Schnellstart: Verwenden Ihres eigenen Speichers zum Erstellen und Veröffentlichen einer Azure Managed Application-Definition

  • Artikel

Dieser Schnellstart enthält eine Einführung in „Bring Your Own Storage (BYOS)“ für eine Azure Managed Application. Sie erstellen und veröffentlichen eine verwaltete Anwendungsdefinition in Ihrem Dienstkatalog für Mitglieder Ihrer Organisation. Wenn Sie Ihr eigenes Speicherkonto verwenden, kann Ihre verwaltete Anwendungsdefinition den Grenzwert von 120 MB des Dienstkatalogs überschreiten.

Um eine verwaltete Anwendungsdefinition in Ihrem Dienstkatalog zu veröffentlichen, gehen Sie folgendermaßen vor:

  • Erstellen Sie eine Azure Resource Manager-Vorlage (ARM-Vorlage), die die Azure-Ressourcen definiert, die mit der verwalteten Anwendung bereitgestellt werden.
  • Definieren Sie die Elemente der Benutzeroberfläche für das Portal, wenn Sie die verwaltete Anwendung bereitstellen.
  • Erstellen Sie ein ZIP-Paket, das die erforderlichen JSON-Dateien enthält.
  • Erstellen Sie ein Speicherkonto, in dem Sie die verwaltete Anwendungsdefinition speichern.
  • Stellen Sie die verwaltete Anwendungsdefinition in Ihrem eigenen Speicherkonto bereit, damit sie in Ihrem Dienstkatalog verfügbar ist.

Wenn Ihre verwaltete Anwendungsdefinition kleiner als 120 MB ist und Sie nicht Ihr eigenes Speicherkonto verwenden wollen, wechseln Sie zu Schnellstart: Erstellen und Veröffentlichen einer verwalteten Azure-Anwendungsdefinition.

Sie können Bicep verwenden, um eine verwaltete Anwendungsdefinition zu entwickeln. Diese muss jedoch in eine JSON-ARM-Vorlage konvertiert werden, bevor Sie die Definition in Azure veröffentlichen können. Weitere Informationen finden Sie unter Schnellstart: Erstellen und Veröffentlichen einer Definition für eine verwaltete Azure-Anwendung mit Bicep.

Sie können Bicep auch verwenden, um eine Definition einer verwalteten Anwendung aus Ihrem Dienstkatalog bereitzustellen. Weitere Informationen finden Sie unter Schnellstart: Verwenden von Bicep zum Bereitstellen einer Definition für eine verwaltete Azure-Anwendung.

Voraussetzungen

Um diesen Schnellstart durchzuführen, benötigen Sie die folgenden Gegenstände:

Erstellen der ARM-Vorlage

Jede Definition einer verwalteten Anwendung enthält eine Datei namens mainTemplate.json. Die Vorlage definiert die zu bereitstellenden Azure-Ressourcen und unterscheidet sich nicht von einer regulären ARM-Vorlage.

Öffnen Sie Visual Studio Code, erstellen Sie eine Datei mit dem Groß-/Kleinschreibungsnamen mainTemplate.json, und speichern Sie sie.

Fügen Sie den folgenden JSON-Code hinzu, und speichern Sie die Datei. Sie definiert die Ressourcen der verwalteten Anwendung zum Bereitstellen eines App Services, App Service-Plans und eines Speicherkontos.

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "location": {
      "type": "string",
      "defaultValue": "[resourceGroup().location]"
    },
    "appServicePlanName": {
      "type": "string",
      "maxLength": 40,
      "metadata": {
        "description": "App Service plan name."
      }
    },
    "appServiceNamePrefix": {
      "type": "string",
      "maxLength": 47,
      "metadata": {
        "description": "App Service name prefix."
      }
    },
    "storageAccountNamePrefix": {
      "type": "string",
      "maxLength": 11,
      "metadata": {
        "description": "Storage account name prefix."
      }
    },
    "storageAccountType": {
      "type": "string",
      "allowedValues": [
        "Premium_LRS",
        "Standard_LRS",
        "Standard_GRS"
      ],
      "metadata": {
        "description": "Storage account type allowed values"
      }
    }
  },
  "variables": {
    "appServicePlanSku": "F1",
    "appServicePlanCapacity": 1,
    "appServiceName": "[format('{0}{1}', parameters('appServiceNamePrefix'), uniqueString(resourceGroup().id))]",
    "storageAccountName": "[format('{0}{1}', parameters('storageAccountNamePrefix'), uniqueString(resourceGroup().id))]"
  },
  "resources": [
    {
      "type": "Microsoft.Web/serverfarms",
      "apiVersion": "2022-03-01",
      "name": "[parameters('appServicePlanName')]",
      "location": "[parameters('location')]",
      "sku": {
        "name": "[variables('appServicePlanSku')]",
        "capacity": "[variables('appServicePlanCapacity')]"
      }
    },
    {
      "type": "Microsoft.Web/sites",
      "apiVersion": "2022-03-01",
      "name": "[variables('appServiceName')]",
      "location": "[parameters('location')]",
      "properties": {
        "serverFarmId": "[resourceId('Microsoft.Web/serverfarms', parameters('appServicePlanName'))]",
        "httpsOnly": true,
        "siteConfig": {
          "appSettings": [
            {
              "name": "AppServiceStorageConnectionString",
              "value": "[format('DefaultEndpointsProtocol=https;AccountName={0};EndpointSuffix={1};Key={2}', variables('storageAccountName'), environment().suffixes.storage, listKeys(resourceId('Microsoft.Storage/storageAccounts', variables('storageAccountName')), '2022-09-01').keys[0].value)]"
            }
          ]
        }
      },
      "dependsOn": [
        "[resourceId('Microsoft.Web/serverfarms', parameters('appServicePlanName'))]",
        "[resourceId('Microsoft.Storage/storageAccounts', variables('storageAccountName'))]"
      ]
    },
    {
      "type": "Microsoft.Storage/storageAccounts",
      "apiVersion": "2022-09-01",
      "name": "[variables('storageAccountName')]",
      "location": "[parameters('location')]",
      "sku": {
        "name": "[parameters('storageAccountType')]"
      },
      "kind": "StorageV2",
      "properties": {
        "accessTier": "Hot"
      }
    }
  ],
  "outputs": {
    "appServicePlan": {
      "type": "string",
      "value": "[parameters('appServicePlanName')]"
    },
    "appServiceApp": {
      "type": "string",
      "value": "[reference(resourceId('Microsoft.Web/sites', variables('appServiceName')), '2022-03-01').defaultHostName]"
    },
    "storageAccount": {
      "type": "string",
      "value": "[reference(resourceId('Microsoft.Storage/storageAccounts', variables('storageAccountName')), '2022-09-01').primaryEndpoints.blob]"
    }
  }
}

Definieren Sie Ihre Portalbenutzeroberfläche

Als Herausgeber definieren Sie die Portalbenutzeroberfläche zum Erstellen der verwalteten Anwendung. Die createUiDefinition.json-Datei generiert die Portalbenutzeroberfläche. Sie definieren mithilfe von Steuerelementen, z. B. Drop-down-Menüs und Textfeldern, wie Benutzer Werte für die einzelnen Parameter eingeben.

In diesem Beispiel fordert Sie die Benutzeroberfläche auf, das App Service-Namenspräfix, den Namen des App Service-Plans, das Präfix des Speicherkontos und den Speicherkontotyp einzugeben. Während der Bereitstellung verwenden die Variablen in mainTemplate.json die uniqueString-Funktion, um eine 13-stellige Zeichenfolge an die Namenspräfixe anzufügen, sodass die Namen in Azure global eindeutig sind.

Öffnen Sie Visual Studio Code, erstellen Sie eine Datei mit dem Namen createUiDefinition.json, und speichern Sie sie.

Fügen Sie der Datei den folgenden JSON-Code hinzu, und speichern Sie sie.

{
  "$schema": "https://schema.management.azure.com/schemas/0.1.2-preview/CreateUIDefinition.MultiVm.json#",
  "handler": "Microsoft.Azure.CreateUIDef",
  "version": "0.1.2-preview",
  "parameters": {
    "basics": [
      {}
    ],
    "steps": [
      {
        "name": "webAppSettings",
        "label": "Web App settings",
        "subLabel": {
          "preValidation": "Configure the web app settings",
          "postValidation": "Completed"
        },
        "elements": [
          {
            "name": "appServicePlanName",
            "type": "Microsoft.Common.TextBox",
            "label": "App Service plan name",
            "placeholder": "App Service plan name",
            "defaultValue": "",
            "toolTip": "Use alphanumeric characters or hyphens with a maximum of 40 characters.",
            "constraints": {
              "required": true,
              "regex": "^[a-z0-9A-Z-]{1,40}$",
              "validationMessage": "Only alphanumeric characters or hyphens are allowed, with a maximum of 40 characters."
            },
            "visible": true
          },
          {
            "name": "appServiceName",
            "type": "Microsoft.Common.TextBox",
            "label": "App Service name prefix",
            "placeholder": "App Service name prefix",
            "defaultValue": "",
            "toolTip": "Use alphanumeric characters or hyphens with minimum of 2 characters and maximum of 47 characters.",
            "constraints": {
              "required": true,
              "regex": "^[a-z0-9A-Z-]{2,47}$",
              "validationMessage": "Only alphanumeric characters or hyphens are allowed, with a minimum of 2 characters and maximum of 47 characters."
            },
            "visible": true
          }
        ]
      },
      {
        "name": "storageConfig",
        "label": "Storage settings",
        "subLabel": {
          "preValidation": "Configure the storage settings",
          "postValidation": "Completed"
        },
        "elements": [
          {
            "name": "storageAccounts",
            "type": "Microsoft.Storage.MultiStorageAccountCombo",
            "label": {
              "prefix": "Storage account name prefix",
              "type": "Storage account type"
            },
            "toolTip": {
              "prefix": "Enter maximum of 11 lowercase letters or numbers.",
              "type": "Available choices are Standard_LRS, Standard_GRS, and Premium_LRS."
            },
            "defaultValue": {
              "type": "Standard_LRS"
            },
            "constraints": {
              "allowedTypes": [
                "Premium_LRS",
                "Standard_LRS",
                "Standard_GRS"
              ]
            },
            "visible": true
          }
        ]
      }
    ],
    "outputs": {
      "location": "[location()]",
      "appServicePlanName": "[steps('webAppSettings').appServicePlanName]",
      "appServiceNamePrefix": "[steps('webAppSettings').appServiceName]",
      "storageAccountNamePrefix": "[steps('storageConfig').storageAccounts.prefix]",
      "storageAccountType": "[steps('storageConfig').storageAccounts.type]"
    }
  }
}

Weitere Informationen finden Sie unter Erste Schritte mit „CreateUiDefinition“.

Erstellen eines Pakets aus den Dateien

Fügen Sie die beiden Dateien einer Paketdatei mit dem Namen app.zip hinzu. Die zwei Dateien müssen sich auf der Stammebene der ZIP-Datei befinden. Wenn sich die Dateien bei der Erstellung der verwalteten Anwendungsdefinition in einem Ordner befinden, erhalten Sie eine Fehlermeldung, die besagt, dass die erforderlichen Dateien nicht vorhanden sind.

Laden Sie die app.zip-Paketdatei in ein Azure-Speicherkonto hoch, damit Sie sie verwenden können, wenn Sie die verwaltete Anwendungsdefinition bereitstellen. Der Name des Speicherkontos muss global eindeutig sein, und die Länge muss 3-24 Zeichen mit nur Kleinbuchstaben und Zahlen sein. Ersetzen Sie im Befehl den Platzhalter <demostorageaccount>, einschließlich der spitzen Klammern (<>), durch Ihren eindeutigen Speicherkontonamen.

New-AzResourceGroup -Name packageStorageGroup -Location westus3

$storageAccount = New-AzStorageAccount `
  -ResourceGroupName packageStorageGroup `
  -Name "<demostorageaccount>" `
  -Location westus3 `
  -SkuName Standard_LRS `
  -Kind StorageV2

$ctx = $storageAccount.Context

New-AzStorageContainer -Name appcontainer -Context $ctx -Permission blob

Set-AzStorageBlobContent `
  -File "app.zip" `
  -Container appcontainer `
  -Blob "app.zip" `
  -Context $ctx

Verwenden Sie den folgenden Befehl, um den URI der Paketdatei in einer Variablen mit dem Namen packageuri zu speichern. Sie verwenden den Wert der Variable, wenn Sie die verwaltete Anwendungsdefinition bereitstellen.

$packageuri=(Get-AzStorageBlob -Container appcontainer -Blob app.zip -Context $ctx).ICloudBlob.StorageUri.PrimaryUri.AbsoluteUri

Bereitstellen eines eigenen Speichers (Bring Your Own Storage) für die Definition der verwalteten Anwendung

Sie können Ihre verwaltete Anwendungsdefinition in Ihrem eigenen Speicherkonto speichern, damit der Speicherort und Zugriff gemäß den gesetzlichen Anforderungen für Ihre Organisation von Ihnen verwaltet werden. Mithilfe Ihres eigenen Speicherkontos können Sie über eine Anwendung verfügen, die den Grenzwert von 120 MB für eine verwaltete Anwendungsdefinition eines Dienstkatalogs überschreitet.

Hinweis

Die Bereitstellung eines eigenen Speichers wird nur bei Bereitstellungen der Definition der verwalteten Anwendung über ARM-Vorlagen oder REST-APIs unterstützt.

Erstellen des Speicherkontos

Erstellen Sie das Speicherkonto für Ihre verwaltete Anwendungsdefinition. Der Name des Speicherkontos muss global eindeutig sein, und die Länge muss 3-24 Zeichen mit nur Kleinbuchstaben und Zahlen sein.

In diesem Beispiel wird eine neue Ressourcengruppe namens byosDefinitionStorageGroup erstellt. Ersetzen Sie im Befehl den Platzhalter <definitionstorage>, einschließlich der spitzen Klammern (<>), durch Ihren eindeutigen Speicherkontonamen.

New-AzResourceGroup -Name byosDefinitionStorageGroup -Location westus3

New-AzStorageAccount `
  -ResourceGroupName byosDefinitionStorageGroup `
  -Name "<definitionstorage>" `
  -Location westus3 `
  -SkuName Standard_LRS `
  -Kind StorageV2

Verwenden Sie den folgenden Befehl, um die Ressourcen-ID des Speicherkontos in einer Variablen namens storageid zu speichern. Sie verwenden den Wert der Variable, wenn Sie die verwaltete Anwendungsdefinition bereitstellen.

$storageid = (Get-AzStorageAccount -ResourceGroupName byosDefinitionStorageGroup -Name <definitionstorage>).Id

Fehlende Rollenzuweisung für Speicherkonto

Bevor Sie Ihre verwaltete Anwendungsdefinition in Ihrem Speicherkonto bereitstellen, weisen Sie dem Appliance-Ressourcenanbieter-Benutzer die Rolle Mitwirkender im Speicherkontobereich zu. Mit dieser Zuweisung kann die Identität Definitionsdateien in den Container Ihres Speicherkontos schreiben.

Sie können Variablen verwenden, um die Rollenzuweisung einzurichten. In diesem Beispiel wird die in einem vorherigen Schritt erstellte $storageid-Variable verwendet und die $arpid-Variable erstellt.

$arpid = (Get-AzADServicePrincipal -SearchString "Appliance Resource Provider").Id

New-AzRoleAssignment -ObjectId $arpid `
-RoleDefinitionName Contributor `
-Scope $storageid

Der Applianceressourcenanbieter ist ein Dienstprinzipal im Mandanten Ihrem Microsoft Entra-Mandanten. Im Azure-Portal können Sie verifizieren, ob sie registriert ist, indem Sie zu Microsoft Entra ID>Unternehmensanwendungen wechseln und den Suchfilter zu Microsoft-Anwendungen ändern. Suchen Sie nach Appliance-Ressourcenanbieter. Wenn sie nicht gefunden wird, registrieren Sie den Microsoft.Solutions Ressourcenanbieter.

Abrufen der Gruppen-ID und Rollendefinitions-ID

Der nächste Schritt besteht darin, einen Benutzer, eine Sicherheitsgruppe oder eine Anwendung für das Verwalten der Ressourcen für den Kunden auszuwählen. Diese Identität verfügt in der verwalteten Ressourcengruppe über Berechtigungen entsprechend der zugewiesenen Rolle. Die Rolle kann eine beliebige integrierte Azure-Rolle wie „Besitzer“ oder „Mitwirkender“ sein.

In diesem Beispiel wird eine Sicherheitsgruppe verwendet, und Ihr Microsoft Entra-Konto sollte Mitglied der Gruppe sein. Um die Objekt-ID der Gruppe abzurufen, ersetzen Sie den Platzhalter <managedAppDemo>, einschließlich der spitzen Klammern (<>), durch den Namen Ihrer Gruppe. Sie verwenden den Wert der Variable, wenn Sie die verwaltete Anwendungsdefinition bereitstellen.

Um eine neue Microsoft Entra-Gruppe zu erstellen, wechseln Sie zu Verwalten von Microsoft Entra-Gruppen und -Gruppenmitgliedschaft.

$principalid=(Get-AzADGroup -DisplayName <managedAppDemo>).Id

Als Nächstes benötigen Sie die Rollendefinitions-ID der integrierten Azure-Rolle, der Sie Zugriff auf den Benutzer, die Gruppe oder Anwendung gewähren möchten. Sie verwenden den Wert der Variable, wenn Sie die verwaltete Anwendungsdefinition bereitstellen.

$roleid=(Get-AzRoleDefinition -Name Owner).Id

Erstellen der Definitionsbereitstellungsvorlage

Verwenden Sie eine Bicep-Datei, um die verwaltete Anwendungsdefinition in Ihrem Dienstkatalog bereitzustellen. Nach der Bereitstellung werden die Definitionsdateien in Ihrem eigenen Speicherkonto gespeichert.

Öffnen Sie Visual Studio Code, erstellen Sie eine Datei mit dem Namen azuredeploy.json, und speichern Sie sie.

Fügen Sie den folgenden Bicep-Code hinzu, und speichern Sie die Datei.

param location string = resourceGroup().location

@description('Name of the managed application definition.')
param managedApplicationDefinitionName string

@description('Resource ID for the bring your own storage account where the definition is stored.')
param definitionStorageResourceID string

@description('The URI of the .zip package file.')
param packageFileUri string

@description('Publishers Principal ID that needs permissions to manage resources in the managed resource group.')
param principalId string

@description('Role ID for permissions to the managed resource group.')
param roleId string

var definitionLockLevel = 'ReadOnly'
var definitionDisplayName = 'Sample BYOS managed application'
var definitionDescription = 'Sample BYOS managed application that deploys web resources'

resource managedApplicationDefinition 'Microsoft.Solutions/applicationDefinitions@2021-07-01' = {
  name: managedApplicationDefinitionName
  location: location
  properties: {
    lockLevel: definitionLockLevel
    description: definitionDescription
    displayName: definitionDisplayName
    packageFileUri: packageFileUri
    storageAccountId: definitionStorageResourceID
    authorizations: [
      {
        principalId: principalId
        roleDefinitionId: roleId
      }
    ]
  }
}

Weitere Informationen zu den Eigenschaften der Vorlage finden Sie unter Microsoft.Solutions/applicationDefinitions.

Die lockLevel in der verwalteten Ressourcengruppe verhindert, dass der Kunde unerwünschte Vorgänge für diese Ressourcengruppe ausführt. Derzeit ist ReadOnly die einzige unterstützte Sperrebene. ReadOnly gibt an, dass die in der verwalteten Ressourcengruppe vorhandenen Ressourcen für den Kunden schreibgeschützt sind. Die Herausgeberidentitäten, denen Zugriff auf die verwaltete Ressourcengruppe gewährt wird, sind von dieser Sperrebene ausgeschlossen.

Erstellen der Parameterdatei

Die Bereitstellungsvorlage der verwalteten Anwendungsdefinition erfordert Eingaben für mehrere Parameter. Der Bereitstellungsbefehl fordert Sie zur Eingabe der Werte auf, oder Sie können eine Parameterdatei für die Werte erstellen. In diesem Beispiel verwenden wir eine Parameterdatei, um die Parameterwerte an den Bereitstellungsbefehl zu übergeben.

Erstellen Sie in Visual Studio Code eine neue Datei mit dem Namen deployDefinition.parameters.json, und speichern Sie sie.

Fügen Sie der Parameterdatei Folgendes hinzu, und speichern Sie sie. Ersetzen Sie dann die <placeholder values>, einschließlich der spitzen Klammern (<>), durch Ihre Werte.

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentParameters.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "managedApplicationDefinitionName": {
      "value": "<placeholder for managed application name>"
    },
    "definitionStorageResourceID": {
      "value": "<placeholder for you storage account ID>"
    },
    "packageFileUri": {
      "value": "<placeholder for the packageFileUri>"
    },
    "principalId": {
      "value": "<placeholder for principalid value>"
    },
    "roleId": {
      "value": "<placeholder for roleid value>"
    }
  }
}

In der folgenden Tabelle werden die Parameterwerte für die verwaltete Anwendungsdefinition beschrieben.

Parameter Wert
managedApplicationDefinitionName Name der verwalteten Anwendungsdefinition. Verwenden Sie in diesem Beispiel sampleByosManagedApplication.
definitionStorageResourceID Ressourcen-ID für das Speicherkonto, in dem die Definition gespeichert ist. Verwenden Sie den Wert Ihrer storageid-Variable.
packageFileUri Geben Sie den URI für Ihre ZIP-Paketdatei ein. Verwenden Sie den Wert Ihrer packageuri-Variable. Das Format ist https://yourStorageAccountName.blob.core.windows.net/appcontainer/app.zip.
principalId Die Prinzipal-ID des Herausgebers, die Berechtigungen zum Verwalten von Ressourcen in der verwalteten Ressourcengruppe benötigt. Verwenden Sie den Wert Ihrer principalid-Variable.
roleId Rollen-ID für Berechtigungen für die verwaltete Ressourcengruppe. Beispiel: Besitzer, Mitwirkender, Leser. Verwenden Sie den Wert Ihrer roleid-Variable.

So rufen Sie Ihre Variablenwerte ab:

  • Azure PowerShell: Geben Sie in PowerShell $variableName ein, um den Wert einer Variable anzuzeigen.
  • Azure CLI: Geben Sie in Bash echo $variableName ein, um den Wert einer Variable anzuzeigen.

Bereitstellen der Definition

Wenn Sie die verwaltete Anwendungsdefinition bereitstellen, wird sie in Ihrem Dienstkatalog verfügbar. Bei diesem Prozess werden die Ressourcen der verwalteten Anwendung nicht bereitgestellt.

Erstellen Sie eine Ressourcengruppe mit dem Namen byosDefinitionRG, und stellen Sie die verwaltete Anwendungsdefinition für Ihr Speicherkonto bereit.

New-AzResourceGroup -Name byosAppDefinitionGroup -Location westus3

New-AzResourceGroupDeployment `
  -ResourceGroupName byosAppDefinitionGroup `
  -TemplateFile deployDefinition.bicep `
  -TemplateParameterFile deployDefinition.parameters.json

Überprüfen des Speichers von Definitionsdateien

Während der Bereitstellung verwendet die Eigenschaft der Vorlage storageAccountId die Ressourcen-ID Ihres Speicherkontos und erstellt einen neuen Container mit dem Namen applicationdefinitionsGroß-/Kleinschreibung. Die Dateien aus dem .zip Paket, das Sie während der Bereitstellung angegeben haben, werden im neuen Container gespeichert.

Sie können die folgenden Befehle verwenden, um zu überprüfen, ob die Dateien der verwalteten Anwendungsdefinition im Container Ihres Speicherkontos gespeichert werden. Ersetzen Sie im Befehl den Platzhalter <definitionstorage>, einschließlich der spitzen Klammern (<>), durch Ihren eindeutigen Speicherkontonamen.

Get-AzStorageAccount -ResourceGroupName byosDefinitionStorageGroup -Name <definitionstorage> |
Get-AzStorageContainer -Name applicationdefinitions |
Get-AzStorageBlob | Select-Object -Property Name | Format-List

Hinweis

Um für mehr Sicherheit zu sorgen, können Sie eine Definition für verwaltete Anwendungen erstellen und in einem Azure-Speicherkontoblob mit aktivierter Verschlüsselung speichern. Der Definitionsinhalt wird mithilfe der Verschlüsselungsoptionen des Speicherkontos verschlüsselt. Nur Benutzer mit Berechtigungen für die Datei können auf die Definition in Ihrem Dienstkatalog zugreifen.

Sicherstellen, dass Benutzer auf Ihre Definition zugreifen können

Sie haben zwar Zugriff auf die Definition der verwalteten Anwendung, möchten aber sicherstellen, dass andere Benutzer in Ihrer Organisation darauf zugreifen können. Erteilen Sie ihnen mindestens die Leserrolle für die Definition. Diese Zugriffsebene haben sie möglicherweise vom Abonnement oder von der Ressourcengruppe geerbt. Informationen zum Überprüfen, wer Zugriff auf die Definition hat, sowie zum Hinzufügen von Benutzern oder Gruppen finden Sie unter Zuweisen von Azure-Rollen über das Azure-Portal.

Bereinigen von Ressourcen

Wenn Sie die Definition bereitstellen möchten, fahren Sie mit dem Abschnitt Nächste Schritte fort, der mit dem Artikel zum Bereitstellen der Definition verknüpft ist.

Wenn Sie mit der Definition für eine verwaltete Anwendung fertig sind, können Sie die von Ihnen erstellten Ressourcengruppen mit dem Namen packageStorageGroup, byosDefinitionStorageGroup und byosAppDefinitionGroup löschen.

Der Befehl fordert Sie auf, zu bestätigen, dass Sie die Ressourcengruppe entfernen wollen.

Remove-AzResourceGroup -Name packageStorageGroup

Remove-AzResourceGroup -Name byosAppDefinitionGroup

Remove-AzResourceGroup -Name byosDefinitionStorageGroup

Nächste Schritte

Sie haben die Definition für die verwaltete Anwendung veröffentlicht. Als Nächstes erfahren Sie, wie Sie eine Instanz dieser Definition bereitstellen.

Schnellstart: Bereitstellen von verwalteter Dienstkataloganwendung