Schnellstart: Verwenden von Bicep zum Erstellen und Veröffentlichen einer Definition für eine verwaltete Azure-Anwendung

Diese Schnellstartanleitung beschreibt, wie Sie Bicep verwenden, um eine Definition für eine verwaltete Azure-Anwendung in Ihrem Dienstkatalog zu erstellen und zu veröffentlichen. Die Definition in Ihrem Dienstkatalog steht Mitgliedern Ihrer Organisation zur Verfügung.

Um eine Definition für eine verwaltete Anwendung in Ihrem Dienstkatalog zu erstellen und zu veröffentlichen, gehen Sie folgendermaßen vor:

• Verwenden Sie Bicep, um Ihre Vorlage zu entwickeln und in eine Azure Resource Manager(ARM)-Vorlage zu konvertieren. Die Vorlage definiert die von der verwalteten Anwendung bereitgestellten Azure-Ressourcen.
• Konvertieren Sie Bicep in JSON mit dem Bicep-Befehl build. Nachdem die Datei in JSON konvertiert wurde, überprüfen Sie den Code auf Genauigkeit.
• 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. Die .zip-Paketdatei hat einen Grenzwert von 120 MB für die verwaltete Anwendungsdefinition eines Dienstkatalogs.
• Veröffentlichen Sie die Definition der verwalteten Anwendung, damit sie in Ihrem Dienstkatalog verfügbar ist.

Wenn Ihre verwaltete Anwendungsdefinition mehr als 120 MB beträgt oder Sie ihr eigenes Speicherkonto aus Compliance-Gründen Ihrer Organisation verwenden möchten, wechseln Sie zu Schnellstart: Verwenden Ihres eigenen Speichers zum Erstellen und Veröffentlichen einer Azure Managed Application-Definition.

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

Voraussetzungen

Damit Sie die Aufgaben in diesem Artikel ausführen können, benötigen Sie Folgendes:

• Ein Azure-Konto mit einem aktiven Abonnement und Berechtigungen für Microsoft Entra-Ressourcen wie Benutzer*innen, Gruppen oder Dienstprinzipale. Sollten Sie kein Azure-Konto haben, erstellen Sie zunächst ein kostenloses Konto.
• Visual Studio Code mit der neuesten Azure Resource Manager Tools-Erweiterung. Installieren Sie für Bicep-Dateien die Bicep-Erweiterung für Visual Studio Code.
• Installieren Sie die aktuelle Version von Azure PowerShell oder der Azure CLI.

Erstellen einer Bicep-Datei

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. Sie können die Vorlage mithilfe von Bicep entwickeln und dann die Bicep-Datei in JSON konvertieren.

Öffnen Sie Visual Studio Code, erstellen Sie eine Datei unter Beachtung der Groß-/Kleinschreibung mit dem Namen mainTemplate.json, und speichern Sie sie.

Fügen Sie den folgenden Bicep-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.

param location string = resourceGroup().location

@description('App Service plan name.')
@maxLength(40)
param appServicePlanName string

@description('App Service name prefix.')
@maxLength(47)
param appServiceNamePrefix string

var appServicePlanSku = 'B1'
var appServicePlanCapacity = 1
var appServiceName = '${appServiceNamePrefix}${uniqueString(resourceGroup().id)}'
var linuxFxVersion = 'DOTNETCORE|8.0'

resource appServicePlan 'Microsoft.Web/serverfarms@2023-01-01' = {
  name: appServicePlanName
  location: location
  sku: {
    name: appServicePlanSku
    capacity: appServicePlanCapacity
  }
  kind: 'linux'
  properties: {
    zoneRedundant: false
    reserved: true
  }
}

resource appService 'Microsoft.Web/sites@2023-01-01' = {
  name: appServiceName
  location: location
  properties: {
    serverFarmId: appServicePlan.id
    httpsOnly: true
    redundancyMode: 'None'
    siteConfig: {
      linuxFxVersion: linuxFxVersion
      minTlsVersion: '1.2'
      ftpsState: 'Disabled'
    }
  }
}

output appServicePlan string = appServicePlanName
output appServiceApp string = appService.properties.defaultHostName

Konvertieren von Bicep zu JSON

Verwenden Sie PowerShell oder die Azure CLI, um die Datei mainTemplate.json zu erstellen. Wechseln Sie zu dem Verzeichnis, in dem Sie Ihre Bicep-Datei gespeichert haben, und führen Sie den Befehl build aus.

bicep build mainTemplate.bicep

az bicep build --file mainTemplate.bicep

Weitere Informationen finden Sie unter Bicep-Build.

Nachdem die Bicep-Datei in JSON konvertiert wurde, sollte Ihre Datei mainTemplate.json dem folgenden Beispiel entsprechen. Möglicherweise haben Sie andere Werte in den metadata-Eigenschaften für version und templateHash.

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "metadata": {
    "_generator": {
      "name": "bicep",
      "version": "0.30.3.12046",
      "templateHash": "16466621031230437685"
    }
  },
  "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."
      }
    }
  },
  "variables": {
    "appServicePlanSku": "B1",
    "appServicePlanCapacity": 1,
    "appServiceName": "[format('{0}{1}', parameters('appServiceNamePrefix'), uniqueString(resourceGroup().id))]",
    "linuxFxVersion": "DOTNETCORE|8.0"
  },
  "resources": [
    {
      "type": "Microsoft.Web/serverfarms",
      "apiVersion": "2023-01-01",
      "name": "[parameters('appServicePlanName')]",
      "location": "[parameters('location')]",
      "sku": {
        "name": "[variables('appServicePlanSku')]",
        "capacity": "[variables('appServicePlanCapacity')]"
      },
      "kind": "linux",
      "properties": {
        "zoneRedundant": false,
        "reserved": true
      }
    },
    {
      "type": "Microsoft.Web/sites",
      "apiVersion": "2023-01-01",
      "name": "[variables('appServiceName')]",
      "location": "[parameters('location')]",
      "properties": {
        "serverFarmId": "[resourceId('Microsoft.Web/serverfarms', parameters('appServicePlanName'))]",
        "httpsOnly": true,
        "redundancyMode": "None",
        "siteConfig": {
          "linuxFxVersion": "[variables('linuxFxVersion')]",
          "minTlsVersion": "1.2",
          "ftpsState": "Disabled"
        }
      },
      "dependsOn": [
        "[resourceId('Microsoft.Web/serverfarms', parameters('appServicePlanName'))]"
      ]
    }
  ],
  "outputs": {
    "appServicePlan": {
      "type": "string",
      "value": "[parameters('appServicePlanName')]"
    },
    "appServiceApp": {
      "type": "string",
      "value": "[reference(resourceId('Microsoft.Web/sites', variables('appServiceName')), '2023-01-01').defaultHostName]"
    }
  }
}

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 werden Sie auf der Benutzeroberfläche aufgefordert, das Präfix des App Service-Namens und den Namen des App Service-Plans einzugeben. Während der Bereitstellung von mainTemplate.json verwenden die appServiceName-Variablen die uniqueString-Funktion, um eine 13-stellige Zeichenfolge an das Namenspräfix anzufügen, damit der Name in Azure global eindeutig ist.

Ö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
          }
        ]
      }
    ],
    "outputs": {
      "location": "[location()]",
      "appServicePlanName": "[steps('webAppSettings').appServicePlanName]",
      "appServiceNamePrefix": "[steps('webAppSettings').appServiceName]"
    }
  }
}

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 <pkgstorageaccountname>, einschließlich der spitzen Klammern (<>), durch Ihren eindeutigen Speicherkontonamen.

Connect-AzAccount

New-AzResourceGroup -Name packageStorageGroup -Location westus

$pkgstorageparms = @{
  ResourceGroupName = "packageStorageGroup"
  Name = "<pkgstorageaccountname>"
  Location = "westus"
  SkuName = "Standard_LRS"
  Kind = "StorageV2"
  MinimumTlsVersion = "TLS1_2"
  AllowBlobPublicAccess = $true
  AllowSharedKeyAccess = $false
}

$pkgstorageaccount = New-AzStorageAccount @pkgstorageparms

$pkgstoragecontext = New-AzStorageContext -StorageAccountName $pkgstorageaccount.StorageAccountName -UseConnectedAccount

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

$blobparms = @{
  File = "app.zip"
  Container = "appcontainer"
  Blob = "app.zip"
  Context = $pkgstoragecontext
}

Set-AzStorageBlobContent @blobparms

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

az login

az group create --name packageStorageGroup --location westus

az storage account create \
  --name <pkgstorageaccountname> \
  --resource-group packageStorageGroup \
  --location westus \
  --sku Standard_LRS \
  --kind StorageV2 \
  --min-tls-version TLS1_2 \
  --allow-blob-public-access true \
  --allow-shared-key-access false

pkgstgacct=$(az storage account show \
  --resource-group packageStorageGroup \
  --name <pkgstorageaccountname> \
  --query name \
  --output tsv)

az storage container create \
  --account-name $pkgstgacct \
  --name appcontainer \
  --auth-mode login \
  --public-access blob

az storage blob upload \
  --account-name $pkgstgacct \
  --container-name appcontainer \
  --auth-mode login \
  --name "app.zip" \
  --file "app.zip"

packageuri=$(az storage blob url \
  --account-name $pkgstgacct \
  --container-name appcontainer \
  --auth-mode login \
  --name app.zip --output tsv)

Erstellen der Definition für die verwaltete Anwendung

In diesem Abschnitt rufen Sie Identitätsinformationen aus Microsoft Entra ID ab, erstellen eine Ressourcengruppe und stellen die Definition der verwalteten Anwendung bereit.

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

principalid=$(az ad group show --group <managedAppDemo> --query id --output tsv)

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

roleid=$(az role definition list --name Owner --query [].name --output tsv)

Erstellen der Definitionsbereitstellungsvorlage

Verwenden Sie eine Bicep-Datei, um die verwaltete Anwendungsdefinition in Ihrem Dienstkatalog bereitzustellen.

Ö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('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 Bicep managed application'
var definitionDescription = 'Sample Bicep 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
    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.bicepparam, 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.

using './deployDefinition.bicep'

param managedApplicationDefinitionName = 'sampleBicepManagedApplication'
param packageFileUri = '<placeholder for the packageFileUri>'
param principalId = '<placeholder for principalid value>'
param roleId = '<placeholder for roleid value>'

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

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 bicepDefinitionGroup, und stellen Sie eine Definition für eine verwaltete Anwendung bereit.

New-AzResourceGroup -Name bicepDefinitionGroup -Location westus

$deployparms = @{
  ResourceGroupName = "bicepDefinitionGroup"
  TemplateFile = "deployDefinition.bicep"
  TemplateParameterFile = "deployDefinition-parameters.bicepparam"
  Name = "deployDefinition"
}

New-AzResourceGroupDeployment @deployparms

az group create --name bicepDefinitionGroup --location westus

az deployment group create \
  --resource-group bicepDefinitionGroup \
  --template-file deployDefinition.bicep \
  --parameters deployDefinition-parameters.bicepparam \
  --name "deployDefinition"

Überprüfen der Ergebnisse

Führen Sie den folgenden Befehl aus, um zu überprüfen, ob die Definition in Ihrem Dienstkatalog veröffentlicht wird.

Get-AzManagedApplicationDefinition -ResourceGroupName bicepDefinitionGroup

az managedapp definition list --resource-group bicepDefinitionGroup

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 mit Bicep verknüpft ist.

Wenn Sie die Definition für eine verwaltete Anwendung fertiggestellt haben, können Sie die von Ihnen erstellten Ressourcengruppen mit dem Namen packageStorageGroup und bicepDefinitionGroup löschen.

Remove-AzResourceGroup -Name packageStorageGroup

Remove-AzResourceGroup -Name bicepDefinitionGroup

az group delete --resource-group packageStorageGroup --no-wait

az group delete --resource-group bicepDefinitionGroup --no-wait

Nächste Schritte

Sie haben die Definition für die verwaltete Anwendung veröffentlicht. Im nächsten Schritt erfahren Sie, wie Sie eine Instanz dieser Definition bereitstellen.