Bereitstellen einer containerisierten Python-App in App Service

In diesem Teil der Lernprogrammreihe erfahren Sie, wie Sie eine containerisierte Python-Webanwendung für Azure App Service Web App für Container bereitstellen. Mit diesem vollständig verwalteten Dienst können Sie containerisierte Apps ausführen, ohne ihren eigenen Container-Orchestrator verwalten zu müssen.

Der App-Dienst vereinfacht die Bereitstellung durch kontinuierliche Integration/kontinuierliche Bereitstellungspipelinen (CI/CD), die mit Docker Hub, Azure Container Registry, Azure Key Vault und anderen DevOps-Tools funktionieren. Dieses Lernprogramm ist Teil 4 einer 5-teiligen Lernprogrammreihe.

Am Ende dieses Artikels verfügen Sie über eine sichere, produktionsfähige App Service-Web-App, die über ein Docker-Containerimage ausgeführt wird. Die App verwendet eine vom System zugewiesene verwaltete Identität , um das Image aus der Azure-Containerregistrierung abzurufen und geheime Schlüssel aus Azure Key Vault abzurufen.

Dieses Dienstdiagramm hebt die in diesem Artikel behandelten Komponenten hervor.

Azure-Befehlszeilenschnittstelle

Azure CLI-Befehle können in der Azure Cloud Shell oder auf einem lokalen Computer ausgeführt werden, auf dem die Azure CLI installiert ist.

Wichtig

Wir empfehlen die Verwendung von Azure Cloud Shell für alle CLI-basierten Schritte in diesem Lernprogramm, da sie:

• Kommt vorab authentifiziert mit Ihrem Azure-Konto und vermeidet so Anmeldeprobleme.
• Enthält alle erforderlichen Azure CLI-Erweiterungen sofort einsatzbereit.
• Stellt ein konsistentes Verhalten unabhängig von Ihrem lokalen Betriebssystem oder Ihrer Umgebung sicher
• Erfordert keine lokale Installation, ideal für Benutzer ohne Administratorrechte
• Bietet direkten Zugriff auf Azure-Dienste über das Portal – keine lokale Docker- oder Netzwerkeinrichtung erforderlich
• Vermeidet Firewall- oder Netzwerkkonfigurationsprobleme vor Ort.

Erstellen eines Key Vaults mit RBAC-Autorisierung

Azure Key Vault ist ein sicherer Dienst zum Speichern geheimer Schlüssel, API-Schlüssel, Verbindungszeichenfolgen und Zertifikate. In diesem Skript werden die MongoDB-Verbindungszeichenfolge und die Web-App gespeichert SECRET_KEY.

Der Key Vault ist für die Verwendung der rollenbasierten Zugriffssteuerung (RBAC) für die Verwaltung des Zugriffs über Azure-Rollen anstelle herkömmlicher Zugriffsrichtlinien konfiguriert. Die Web-App verwendet die vom System zugewiesene verwaltete Identität , um geheime Schlüssel zur Laufzeit sicher abzurufen.

Anmerkung

Durch das frühzeitige Erstellen des Key Vault wird sichergestellt, dass Rollen zugewiesen werden können, bevor versucht wird, auf geheime Schlüssel zuzugreifen. Es hilft auch, Verteilungsverzögerungen in Rollenzuweisungen zu vermeiden. Da Key Vault nicht vom App-Dienst abhängt, verbessert die Bereitstellung frühzeitig die Zuverlässigkeit und Sequenzierung.

1. In diesem Schritt verwenden Sie den Befehl "az keyvault create " zum Erstellen eines Azure Key Vault mit aktiviertem RBAC.

   Schlagen

   #!/bin/bash
   RESOURCE_GROUP_NAME="msdocs-web-app-rg"
   LOCATION="westus"
   KEYVAULT_NAME="${RESOURCE_GROUP_NAME}-kv"
   
   az keyvault create \
     --name "$KEYVAULT_NAME" \
     --resource-group "$RESOURCE_GROUP_NAME" \
     --location "$LOCATION" \
     --enable-rbac-authorization true
   

   PowerShell

   # PowerShell syntax
   $RESOURCE_GROUP_NAME="msdocs-web-app-rg"
   $LOCATION="westus"
   $KEYVAULT_NAME="${RESOURCE_GROUP_NAME}-kv"
   
   az keyvault create `
     --name "$KEYVAULT_NAME" `
     --resource-group "$RESOURCE_GROUP_NAME" `
     --location "$LOCATION" `
     --enable-rbac-authorization true
   

Erstellen des App-Serviceplans und der Web-App

Der App-Serviceplan definiert die Berechnungsressourcen, die Preisstufe und die Region für Ihre Web-App. Die Web-App führt Ihre containerisierte Anwendung aus und wird mit einer vom System zugewiesenen verwalteten Identität bereitgestellt, die zur sicheren Authentifizierung bei Azure Container Registry (ACR) und Azure Key Vault verwendet wird.

In diesem Schritt führen Sie die folgenden Aufgaben aus:

• Erstellen eines App Service-Plans
• Erstellen der Web-App mit verwalteter Identität
• Konfigurieren der Web-App für die Bereitstellung mithilfe eines bestimmten Containerimages
• Vorbereitung für die kontinuierliche Bereitstellung über ACR

Anmerkung

Die Web-App muss erstellt werden, bevor Der Zugriff auf ACR oder Key Vault zugewiesen wird, da die verwaltete Identität nur zur Bereitstellungszeit erstellt wird. Außerdem stellt das Zuweisen des Containerimages während der Erstellung sicher, dass die App mit der beabsichtigten Konfiguration ordnungsgemäß gestartet wird.

1. In diesem Schritt verwenden Sie den Befehl "az appservice plan create " zum Bereitstellen der Computeumgebung für Ihre App.

   Schlagen

   #!/bin/bash
   APP_SERVICE_PLAN_NAME="msdocs-web-app-plan"
   
   az appservice plan create \
       --name "$APP_SERVICE_PLAN_NAME" \
       --resource-group "$RESOURCE_GROUP_NAME" \
       --sku B1 \
       --is-linux
   

   PowerShell

   # PowerShell syntax
   $APP_SERVICE_PLAN_NAME="msdocs-web-app-plan"
   
   az appservice plan create `
       --name "$APP_SERVICE_PLAN_NAME" `
       --resource-group "$RESOURCE_GROUP_NAME" `
       --sku B1 `
       --is-linux
   

2. In diesem Schritt verwenden Sie den Befehl "az webapp create " zum Erstellen der Web-App. Mit diesem Befehl wird auch eine vom System zugewiesene verwaltete Identität aktiviert und das Containerimage festgelegt, das von der App ausgeführt wird.

   Schlagen

   #!/bin/bash
   APP_SERVICE_NAME="msdocs-website-name" #APP_SERVICE_NAME must be globally unique as it becomes the website name in the URL `https://<website-name>.azurewebsites.net`.
   # Use the same registry name as in part 2 of this tutorial series.
   REGISTRY_NAME="msdocscontainerregistryname" #REGISTRY_NAME is the registry name you used in part 2 of this tutorial.
   CONTAINER_NAME="$REGISTRY_NAME.azurecr.io/msdocspythoncontainerwebapp:latest" #CONTAINER_NAME is of the form "yourregistryname.azurecr.io/repo_name:tag".
   
   az webapp create \
     --resource-group "$RESOURCE_GROUP_NAME" \
     --plan "$APP_SERVICE_PLAN_NAME" \
     --name "$APP_SERVICE_NAME" \
     --assign-identity '[system]' \
     --deployment-container-image-name "$CONTAINER_NAME" 
   

   PowerShell

   # Powershell syntax
   $APP_SERVICE_NAME="msdocs-website-name"
   # Use the same rregistry name as in part 2 of this tutorial series.
   $REGISTRY_NAME="msdocscontainerregistryname"
   $CONTAINER_NAME = "$REGISTRY_NAME.azurecr.io/msdocspythoncontainerwebapp:latest"
   
   az webapp create `
     --resource-group "$RESOURCE_GROUP_NAME" `
     --plan "$APP_SERVICE_PLAN_NAME" `
     --name "$APP_SERVICE_NAME" `
     --assign-identity '[system]' `
     --deployment-container-image-name "$CONTAINER_NAME" 
   

   Anmerkung

   Wenn Sie diesen Befehl ausführen, wird möglicherweise der folgende Fehler angezeigt:

   No credential was provided to access Azure Container Registry. Trying to look up...
   Retrieving credentials failed with an exception:'Failed to retrieve container registry credentials. Please either provide the credentials or run 'az acr update -n msdocscontainerregistryname --admin-enabled true' to enable admin first.'
   

   Dieser Fehler tritt auf, da die Web-App versucht, Administratoranmeldeinformationen für den Zugriff auf ACR zu verwenden, welche Anmeldeinformationen standardmäßig deaktiviert sind. Es ist sicher, diese Meldung zu ignorieren: Im nächsten Schritt wird die Web-App so konfiguriert, dass sie ihre verwaltete Identität für die ACR-Authentifizierung verwendet.

Rolle "Secrets Officer" für angemeldete Benutzer erteilen

Um geheime Schlüssel in Azure Key Vault zu speichern, muss der Benutzer, der das Skript ausführt, über die Rolle " Key Vault Secrets Officer " verfügen. Diese Rolle ermöglicht das Erstellen und Verwalten von Geheimnissen im Tresor.

In diesem Schritt weist das Skript diese Rolle dem aktuell angemeldeten Benutzer zu. Dieser Benutzer kann dann Anwendungsgeheimnisse sicher speichern, wie die MongoDB-Verbindungszeichenfolge und die App-SECRET_KEY.

Diese Rollenzuweisung ist die erste von zwei Key Vault-bezogenen Rollenzuweisungen. Später erhält die vom System zugewiesene verwaltete Identität der Web-App Zugriff auf geheime Schlüssel aus dem Tresor.

Die Verwendung von Azure RBAC stellt sicheren, auditierbaren Zugriff basierend auf der Identität sicher, ohne dass hartcodierte Anmeldeinformationen erforderlich sind.

Anmerkung

Dem Benutzer muss die Rolle " Key Vault Secrets Officer " zugewiesen werden, bevor versucht wird, geheime Schlüssel im Schlüsseltresor zu speichern. Diese Zuweisung erfolgt mithilfe des Befehls az role assignment create, der auf den Key Vault abgezielt ist.

1. In diesem Schritt verwenden Sie den Befehl "az role assignment create" , um die Rolle im Key Vault-Bereich zuzuweisen.

   Schlagen

   #!/bin/bash
   CALLER_ID=$(az ad signed-in-user show --query id -o tsv)
   echo $CALLER_ID # Verify this value retrieved successfully. In production, poll to verify this value is retrieved successfully.
   
   az role assignment create \
     --role "Key Vault Secrets Officer" \
     --assignee "$CALLER_ID" \
     --scope "/subscriptions/$(az account show --query id -o tsv)/resourceGroups/$RESOURCE_GROUP_NAME/providers/Microsoft.KeyVault/vaults/$KEYVAULT_NAME"
   
   

   PowerShell

   # PowerShell syntax
   $CALLER_ID=$(az ad signed-in-user show --query id -o tsv)
   echo $CALLER_ID # Verify this value retrieved successfully. In production, poll to verify this value is retrieved successfully.
   
   az role assignment create `
     --role "Key Vault Secrets Officer" `
     --assignee "$CALLER_ID" `
     --scope "/subscriptions/$(az account show --query id -o tsv)/resourceGroups/$RESOURCE_GROUP_NAME/providers/Microsoft.KeyVault/vaults/$KEYVAULT_NAME"
   

Gewähren des Webzugriffs auf ACR mithilfe der verwalteten Identität

Um Bilder sicher aus der Azure Container Registry (ACR) abzurufen, muss die Web-App so konfiguriert werden, dass sie ihre vom System zugewiesene verwaltete Identität verwendet. Die Verwendung verwalteter Identitäten vermeidet die Notwendigkeit von Administratoranmeldeinformationen und unterstützt die sichere Bereitstellung ohne Anmeldeinformationen.

Dieser Prozess umfasst zwei wichtige Aktionen:

• Aktivieren der Web-App für die Verwendung ihrer verwalteten Identität beim Zugriff auf ACR
• Zuweisen der AcrPull-Rolle zu dieser Identität im Ziel-ACR

1. In diesem Schritt rufen Sie die Prinzipal-ID (eindeutige Objekt-ID) der verwalteten Identität der Web-App mithilfe des Befehls az webapp identity show ab. Als Nächstes aktivieren Sie die Verwendung der verwalteten Identität für die ACR-Authentifizierung, indem Sie die acrUseManagedIdentityCreds Eigenschaft mit true unter Verwendung von az webapp config set festlegen. Anschließend weisen Sie die AcrPull-Rolle mithilfe des Befehls "az role assignment create " der verwalteten Identität der Web-App zu. Diese Rolle gewährt der Web-App die Berechtigung, Bilder aus der Registrierung abzurufen.

   Schlagen

   #!/bin/bash
   PRINCIPAL_ID=$(az webapp identity show \
     --name "$APP_SERVICE_NAME" \
     --resource-group "$RESOURCE_GROUP_NAME" \
     --query principalId \
     -o tsv)
   echo $PRINCIPAL_ID # Verify this value retrieved successfully. In production, poll for successful 'AcrPull' role assignment using `az role assignment list`.    
   
   az webapp config set \
     --resource-group "$RESOURCE_GROUP_NAME" \
     --name "$APP_SERVICE_NAME" \
     --generic-configurations '{"acrUseManagedIdentityCreds": true}'
   
   az role assignment create \
   --role "AcrPull" \
   --assignee "$PRINCIPAL_ID" \
   --scope "/subscriptions/$(az account show --query id -o tsv)/resourceGroups/$RESOURCE_GROUP_NAME/providers/Microsoft.ContainerRegistry/registries/$REGISTRY_NAME"
   
   

   PowerShell

   # PowerShell syntax
   $PRINCIPAL_ID=$(az webapp identity show `
     --name "$APP_SERVICE_NAME" `
     --resource-group "$RESOURCE_GROUP_NAME" `
     --query principalId `
     -o tsv)
   echo $PRINCIPAL_ID # Verify this value retrieved successfully. In production, poll for successful AcrPull role assignment using `az role assignment list`.    
   
   az webapp config set `
     --resource-group "$RESOURCE_GROUP_NAME" `
     --name "$APP_SERVICE_NAME" `
     --generic-configurations '{ "acrUseManagedIdentityCreds": true }'
   
   az role assignment create `
     --role "AcrPull" `
     --assignee "$PRINCIPAL_ID" `
     --scope "/subscriptions/$(az account show --query id -o tsv)/resourceGroups/$RESOURCE_GROUP_NAME/providers/Microsoft.ContainerRegistry/registries/$REGISTRY_NAME"
   

Gewähren von Schlüsseltresorzugriff auf die verwaltete Identität der Web-App

Die Web-App benötigt die Berechtigung für den Zugriff auf geheime Schlüssel wie die MongoDB-Verbindungszeichenfolge und die SECRET_KEY. Um diese Berechtigungen zu erteilen, müssen Sie der vom System zugewiesenen verwalteten Identität der Web-App die Rolle "Key Vault Secrets User" zuweisen.

1. In diesem Schritt verwenden Sie die eindeutige ID (Prinzipal-ID) der systemseitig zugewiesenen verwalteten Identität der Web-App, um der Web-App Zugriff auf den Key Vault mit der Rolle "Key Vault Secrets User" zu gewähren, indem Sie den Befehl az role assignment create verwenden.

   Schlagen

   #!/bin/bash
   
   az role assignment create \
   --role "Key Vault Secrets User" \
   --assignee "$PRINCIPAL_ID" \
   --scope "/subscriptions/$(az account show --query id -o tsv)/resourceGroups/$RESOURCE_GROUP_NAME/providers/Microsoft.KeyVault/vaults/$KEYVAULT_NAME"
   

   PowerShell

   # PowerShell syntax
   
     az role assignment create `
     --role "Key Vault Secrets User" `
     --assignee "$PRINCIPAL_ID"`
     --scope "/subscriptions/$(az account show --query id -o tsv)/resourceGroups/$RESOURCE_GROUP_NAME/providers/Microsoft.KeyVault/vaults/$KEYVAULT_NAME"
   
   

Geheime Schlüssel im Schlüsseltresor speichern

Um geheime Schlüssel in Ihrer Anwendung zu vermeiden, speichert dieser Schritt die MongoDB-Verbindungszeichenfolge und den geheimen Schlüssel der Web-App im Azure Key Vault. Diese geheimen Schlüssel können dann von der Web-App zur Laufzeit über die verwaltete Identität sicher aufgerufen werden, ohne dass Anmeldeinformationen im Code oder in der Konfiguration gespeichert werden müssen.

Anmerkung

Während in diesem Lernprogramm nur die Verbindungszeichenfolge und der geheime Schlüssel im Schlüsseltresor gespeichert werden, können Sie optional auch andere Anwendungseinstellungen wie den MongoDB-Datenbanknamen oder den Sammlungsnamen im Key Vault speichern.

1. In diesem Schritt verwenden Sie den Befehl "az cosmosdb keys list" zum Abrufen der MongoDB-Verbindungszeichenfolge. Anschließend verwenden Sie den Befehl "az keyvault secret set ", um sowohl die Verbindungszeichenfolge als auch einen zufällig generierten geheimen Schlüssel im Key Vault zu speichern.

   Schlagen

   #!/bin/bash
   ACCOUNT_NAME="msdocs-cosmos-db-account-name"
   
   MONGO_CONNECTION_STRING=$(az cosmosdb keys list \
     --name "$ACCOUNT_NAME" \
     --resource-group "$RESOURCE_GROUP_NAME" \
     --type connection-strings \
     --query "connectionStrings[?description=='Primary MongoDB Connection String'].connectionString" -o tsv)
   
   SECRET_KEY=$(openssl rand -base64 32 | tr -dc 'a-zA-Z0-9')
   # This key is cryptographically secure, using OpenSSL’s strong random number generator.
   
   az keyvault secret set \
     --vault-name "$KEYVAULT_NAME" \
     --name "MongoConnectionString" \
     --value "$MONGO_CONNECTION_STRING"
   
   az keyvault secret set \
     --vault-name "$KEYVAULT_NAME" \
     --name "MongoSecretKey" \
     --value "$SECRET_KEY"
   

   PowerShell

   # PowerShell syntax
   $ACCOUNT_NAME="msdocs-cosmos-db-account-name"
   
   $MONGO_CONNECTION_STRING = az cosmosdb keys list `
     --name $ACCOUNT_NAME `
     --resource-group $RESOURCE_GROUP_NAME `
     --type connection-strings `
     --query "connectionStrings[?description=='Primary MongoDB Connection String'].connectionString" `
     -o tsv
   
   # Generate a 32-byte cryptographically secure random value
   $bytes = New-Object 'Byte[]' 32
   [System.Security.Cryptography.RandomNumberGenerator]::Create().GetBytes($bytes)
   
   # Convert to base64 and filter to alphanumeric characters only
   $base64 = [Convert]::ToBase64String($bytes)
   $alphanumeric = $base64 -replace '[^a-zA-Z0-9]', ''
   
   # Truncate to 50 characters
   $SECRET_KEY = $alphanumeric.Substring(0, [Math]::Min(50, $alphanumeric.Length))
   
   az keyvault secret set `
     --vault-name "$KEYVAULT_NAME" `
     --name "MongoConnectionString" `
     --value "$MONGO_CONNECTION_STRING"
   
   az keyvault secret set `
     --vault-name "$KEYVAULT_NAME" `
     --name "MongoSecretKey" `
     --value "$SECRET_KEY"
   

Konfigurieren der Webapp zur Verwendung von Kay Vault-Geheimnissen

Um sicher zur Laufzeit auf geheime Schlüssel zuzugreifen, muss die Web-App so konfiguriert werden, dass sie auf die geheimen Schlüssel in Azure Key Vault verweist. Dieser Schritt erfolgt mithilfe von Key Vault-Verweisen, die die geheimen Werte über die vom System zugewiesene verwaltete Identität in die Umgebung der App einfügen.

An diesem Ansatz wird das Hartkodieren von geheimen Informationen vermieden, und die App kann während der Ausführung sicher vertrauliche Werte wie die MongoDB-Verbindungszeichenfolge und den geheimen Schlüssel abrufen.

1. In diesem Schritt verwenden Sie den Befehl "az webapp config appsettings set", um die Anwendungseinstellungen hinzuzufügen, die auf die Key Vault-Geheimnisse verweisen. Dies setzt die MongoConnectionString- und MongoSecretKey-App-Einstellungen so, dass sie auf die entsprechenden in Key Vault gespeicherten Geheimnisse verweisen.

   Schlagen

   #!/bin/bash
   MONGODB_NAME="restaurants_reviews"
   MONGODB_COLLECTION_NAME="restaurants_reviews"
   
   az webapp config appsettings set \
     --resource-group "$RESOURCE_GROUP_NAME" \
     --name "$APP_SERVICE_NAME" \
     --settings \
         CONNECTION_STRING="@Microsoft.KeyVault(SecretUri=https://$KEYVAULT_NAME.vault.azure.net/secrets/MongoConnectionString)" \
         SECRET_KEY="@Microsoft.KeyVault(SecretUri=https://$KEYVAULT_NAME.vault.azure.net/secrets/MongoSecretKey)" \
         DB_NAME="$MONGODB_NAME" \
         COLLECTION_NAME="$MONGODB_COLLECTION_NAME"
   

   PowerShell

   # PowerShell syntax
   $MONGO_DB_NAME="restaurants_reviews"
   $MONGO_COLLECTION_NAME="restaurants_reviews"
   
   az webapp config appsettings set `
     --resource-group $RESOURCE_GROUP_NAME `
     --name $APP_SERVICE_NAME `
     --settings `
       CONNECTION_STRING="@Microsoft.KeyVault(SecretUri=https://$KEYVAULT_NAME.vault.azure.net/secrets/MongoConnectionString)" `
       SECRET_KEY="@Microsoft.KeyVault(SecretUri=https://$KEYVAULT_NAME.vault.azure.net/secrets/MongoSecretKey)" `
       DB_NAME=$MONGODB_NAME `
       COLLECTION_NAME=$MONGODB_COLLECTION_NAME
   

Aktivieren der kontinuierlichen Bereitstellung über ACR

Durch aktivieren der kontinuierlichen Bereitstellung kann die Web-App das neueste Containerimage automatisch abrufen und ausführen, wenn ein Element an die Azure Container Registry (ACR) übertragen wird. Dadurch werden manuelle Bereitstellungsschritte reduziert und sichergestellt, dass Ihre App auf dem neuesten Stand bleibt.

Anmerkung

Im nächsten Schritt registrieren Sie einen Webhook in ACR, um die Web-App zu benachrichtigen, wenn ein neues Bild pusht wird.

1. In diesem Schritt verwenden Sie den Konfigurationsbefehl für die Az webapp-Bereitstellungscontainerkonfiguration , um eine kontinuierliche Bereitstellung von ACR in die Web-App zu ermöglichen.

   Schlagen

   #!/bin/bash
   az webapp deployment container config \
     --name "$APP_SERVICE_NAME" \
     --resource-group "$RESOURCE_GROUP_NAME" \
     --enable-cd true
   

   PowerShell

   # PowerShell syntax
   az webapp deployment container config `
     --name "$APP_SERVICE_NAME" `
     --resource-group "$RESOURCE_GROUP_NAME" `
     --enable-cd true
   

Registrieren Sie einen ACR-Webhook für die kontinuierliche Bereitstellung

Um Bereitstellungen zu automatisieren, registrieren Sie einen Webhook in der Azure Container Registry (ACR), der die Web-App benachrichtigt, wenn ein neues Containerimage übertragen wird. Mit dem Webhook kann die App automatisch die neueste Version abrufen und ausführen.

Der in der Azure Container Registry (ACR) konfigurierte Webhook sendet eine POST-Anforderung an den SCM-Endpunkt (SERVICE_URI) der Web-App, wenn ein neues Image an das Msdocspythoncontainerwebapp-Repository übertragen wird. Diese Aktion löst die Web-App aus, um das aktualisierte Image abzurufen und bereitzustellen, wodurch die fortlaufende Bereitstellungspipeline zwischen ACR und Azure App Service abgeschlossen wird.

Anmerkung

Der Webhook-URI muss diesem Format folgen:
https://<app-name>.scm.azurewebsites.net/api/registry/webhook

Es muss enden mit /api/registry/webhook. Wenn sie einen URI-Fehler erhalten, vergewissern Sie sich, dass der Pfad korrekt ist.

1. Verwenden Sie in diesem Schritt den Befehl "az acr webhook erstellen ", um den Webhook zu registrieren und ihn so zu konfigurieren, dass er für push Ereignisse ausgelöst wird.

   Schlagen

   #!/bin/bash
   CREDENTIAL=$(az webapp deployment list-publishing-credentials \
       --resource-group "$RESOURCE_GROUP_NAME" \
       --name "$APP_SERVICE_NAME" \
       --query publishingPassword --output tsv)
   # Web app publishing credentials may not be available immediately. In production, poll until non-empty.   
   
   SERVICE_URI="https://$APP_SERVICE_NAME:$CREDENTIAL@$APP_SERVICE_NAME.scm.azurewebsites.net/api/registry/webhook"
   
   az acr webhook create \
     --name webhookforwebapp \
     --registry "$REGISTRY_NAME" \
     --scope msdocspythoncontainerwebapp:* \
     --uri "$SERVICE_URI" \
     --actions push
   
   

   PowerShell

   # PowerShell syntax
   $CREDENTIAL=$(az webapp deployment list-publishing-credentials `
     --resource-group "$RESOURCE_GROUP_NAME" `
     --name "$APP_SERVICE_NAME" `
     --query publishingPassword --output tsv)
   
   # Web app publishing credentials may not be available immediately. In production, poll until non-empty.   
   
   $SERVICE_URI = "https://$APP_SERVICE_NAME`:$CREDENTIAL@$APP_SERVICE_NAME.scm.azurewebsites.net/api/registry/webhook"
   
   az acr webhook create `
     --name webhookforwebapp `
     --registry "$REGISTRY_NAME" `
     --scope msdocspythoncontainerwebapp:* `
     --uri "$SERVICE_URI" `
     --actions push
   

Website durchsuchen

Öffnen Sie https://<website-name>.azurewebsites.net und ersetzen Sie <website-name> durch den Namen Ihres App-Diensts, um zu überprüfen, ob die Web-App ausgeführt wird. Du solltest die Beispiel-App für Restaurantbewertungen sehen. Es kann einige Minuten dauern, bis das erste Mal geladen wird.

Sobald die Website angezeigt wird, versuchen Sie, ein Restaurant hinzuzufügen und eine Rezension zu übermitteln, um zu bestätigen, dass die App ordnungsgemäß funktioniert.

Anmerkung

Der Befehl az webapp browse wird in Cloud Shell nicht unterstützt. Wenn Sie Cloud Shell verwenden, öffnen Sie manuell einen Browser, und navigieren Sie zur Website-URL.

Wenn Sie die Azure CLI lokal verwenden, können Sie den Befehl "az webapp browse" verwenden, um die Website in Ihrem Standardbrowser zu öffnen:

az webapp browse --name $APP_SERVICE_NAME --resource-group $RESOURCE_GROUP_NAME

Anmerkung

Der Befehl az webapp browse wird in Cloud Shell nicht unterstützt. Öffnen Sie stattdessen ein Browserfenster, und navigieren Sie stattdessen zur Website-URL.

VS-Code

Sie können die Docker-Erweiterung in Visual Studio Code verwenden, um Ihre containerisierte Webanwendung in Azure App Service zu erstellen und bereitzustellen. Diese Erweiterung optimiert den Prozess des Verpackens Ihrer App und pusht sie in die Cloud. Verwenden Sie nach der Bereitstellung die Azure Tools-Erweiterung, um die Einstellungen der Web-App zu konfigurieren, einschließlich der MongoDB-Verbindungszeichenfolge und eines geheimen Schlüssels für die Anwendung.

Konfigurieren und testen Sie zunächst die App mit hartcodierten Werten, um sicherzustellen, dass sie erfolgreich eine Verbindung mit der MongoDB-Datenbank herstellt. Nachdem Sie überprüft haben, ob die App funktioniert, verwenden Sie die Azure CLI (lokal oder in der Cloud Shell), um einen Azure Key Vault zu erstellen. Gewähren Sie als Nächstes dem Benutzer, der die App in VS Code erstellt, die Berechtigung zum Speichern vertraulicher Informationen. Speichern Sie anschließend die MongoDB-Verbindungszeichenfolge und den geheimen Schlüssel der App als Key Vault-Geheimnisse.

Aktualisieren Sie schließlich in Visual Studio Code die Anwendungseinstellungen der Web-App, um auf die geheimen Schlüssel zu verweisen, die im Key Vault gespeichert sind. Die App kann jetzt sicher auf Konfigurationswerte zugreifen, ohne sie direkt in Code einzubetten.

Erstellen der Web-App

Für diese Schritte ist die Installation der Docker-Erweiterung für VS Code erforderlich.

1. Aktualisieren Sie die Azure Container Registry in der Docker-Erweiterung, um zu bestätigen, dass der von Ihnen erstellte Container im Abschnitt "REGISTRIES " der Docker-Erweiterung angezeigt wird. Wenn dies nicht der Fall ist, klicken Sie mit der rechten Maustaste auf den Namen der Registrierung und wählen Sie Aktualisieren.

   

2. Wählen Sie F1 oder CTRL+SHIFT+P, um die Befehlspalette zu öffnen, geben Sie "Docker Registries" ein und wählen Sie die Docker Registries: Image für Azure App Service bereitstellen... aus.

3. Geben Sie die folgenden Werte ein, wie Sie aufgefordert werden, das Image bereitzustellen:

   • Registrierungsanbieter auswählen: Azure
   • Abonnement: Wählen Sie das Abonnement aus, das die zuvor erstellte Azure-Containerregistrierung enthält.
   • Wählen Sie die Registrierung aus: Geben Sie den Namen der Registrierung ein, die Sie zuvor in diesem Lernprogramm erstellt haben.
   • Repository auswählen: Geben Sie den Repositorynamen "msdocscontainerregistryname" ein. Wenn Sie dieses Repo nicht sehen, aktualisieren Sie den Abschnitt Docker Erweiterung REGISTRIES.
   • Tag auswählen: Neuestes für das Bildtag.
   • Geben Sie einen global eindeutigen Namen für die Web-App ein: Geben Sie einen Namen ein, der global eindeutig für Azure App Service ist. Wenn Sie beispielsweise "msdocs-website-name" verwenden, lautet http://msdocs-website-name.azurewebsites.netdie Web-App-URL .
   • Wählen Sie eine Ressourcengruppe aus: Verwenden Sie die Ressourcengruppe, die die zuvor erstellte Azure-Containerregistrierung enthält.
   • Wählen Sie einen Linux App Service-Plan aus: Verwenden Sie einen vorhandenen oder erstellen Sie einen neuen Plan.

4. Im Fenster OUTPUT sehen Sie die Details der Bereitstellung. Eine der Ausgabezeilen lautet "Granting permission for App Service to pull image from ACR...", was bedeutet, dass der App Service über die verwaltete Identität auf die Registrierung zugreift.

   

   Die endgültige Website https://<app-name>.azurewebsites.net ist noch nicht bereit, da Sie MongoDB-Informationen angeben müssen.

   Anmerkung

   Wenn Sie die Bereitstellung mit Visual Studio Code vornehmen, ist die verwaltete Identität bereits für den App Service festgelegt, um Images aus der Registrierung zu ziehen. Sie können bestätigen, dass die verwaltete Identität aktiviert ist, indem Sie sich die Protokolle im Fenster OUTPUT ansehen und nach der Nachricht "Granting authorization for App Service to pull image from ACR..." suchen.

Konfigurieren der verwalteten Identität und des Webhooks

Während der Bereitstellung mit VS Code wird ein Webhook erstellt, mit dem die Web-App neue Bilder aus der Azure-Containerregistrierung abrufen kann.

1. Überprüfen Sie die Webhooks-Konfiguration im Azure-Portal, um zu bestätigen, dass der Dienst-URI mit "/api/registry/webhook" endet. Um den Dienst-URI zu überprüfen, öffnen Sie die Docker-Erweiterung in VS Code und suchen Sie die Registry, die Sie erstellt haben. Klicken Sie mit der rechten Maustaste auf die Registrierung und wählen Sie Im Portal öffnen. Die Containerregistrierung wird im Azure-Portal geöffnet. Klicken Sie auf "Dienste " und dann auf "Webhooks". Öffnen Sie das Kontextmenü, und klicken Sie auf "Konfigurieren".

   

2. Vergewissern Sie sich, dass der Dienst-URI mit "/api/registry/webhook" endet. Andernfalls fügen Sie sie am Ende der Zeichenfolge hinzu und klicken Sie auf Speichern.

Konfigurieren der Verbindung mit MongoDB mithilfe hartcodierter Werte

In diesem Schritt geben Sie die Umgebungsvariablen an, die für die Webanwendung erforderlich sind, um eine Verbindung mit MongoDB herzustellen.

Anmerkung

Um Umgebungsvariablen für die Web-App aus VS Code zu konfigurieren, müssen Sie das Azure Tools-Erweiterungspaket installiert und über VS Code bei Azure angemeldet sein.

1. In der Azure-Ansicht in VS Code (aus der Azure Tools-Erweiterung):

   1. Erweitern Sie RESOURCES und suchen Sie App Services unter Ihrem Abonnement. (Stellen Sie sicher, dass Sie die Ressourcen nach Gruppe nach Ressourcentyp anzeigen.)

   2. Erweitern Sie App Services , und suchen Sie die von Ihnen erstellte Web-App.

   3. Erweitern Sie Ihre Web-App und klicken Sie mit der rechten Maustaste auf Anwendungseinstellungen.

   4. Wählen Sie Neue Einstellung festlegen....

   

2. Jedes Mal, wenn Sie eine neue Einstellung hinzufügen, wird oben im VS Code-Fenster ein Dialogfeld angezeigt, in dem Sie den Einstellungsnamen gefolgt von seinem Wert hinzufügen können. Fügen Sie die folgenden Einstellungen hinzu:

   • CONNECTION_STRING: die MongoDB-Verbindungszeichenfolge. Später in diesem Lernprogramm legen Sie diesen Wert auf die Verbindungszeichenfolge fest, die Sie in Azure Key Vault speichern.
   • DB_NAME: restaurants_reviews
   • COLLECTION_NAME: restaurants_reviews
   • WEBSITES_PORT: 8000 für Django und 5000 für Flask. Diese Umgebungsvariable gibt den Port an, auf dem der Container lauscht.
   • SECRET_KEY: supersecretkeythatispassedtopythonapp. Dieser geheime Schlüssel ist eine zufällige Zeichenfolge, die von Django und Flask zum Verschlüsseln von Sitzungsdaten verwendet wird. Später in diesem Lernprogramm legen Sie diesen Wert auf die zufällige Zeichenfolge fest, die Sie in Azure Key Vault speichern.

Durchsuchen der Website mithilfe hartcodierter Werte

In der Azure-Ansicht in VS Code (aus der Azure Tools-Erweiterung):

1. Erweitern Sie RESOURCES und suchen Sie App Services unter Ihrem Abonnement. (Stellen Sie sicher, dass Sie die Ressourcen nach Gruppe nach Ressourcentyp anzeigen.)

2. Klicken Sie mit der rechten Maustaste auf Ihre Web-App, und wählen Sie "Website durchsuchen" aus. Wenn ihre Website einen Fehler anzeigt, warten Sie einige Minuten, und versuchen Sie es erneut. Es kann einige Minuten dauern, bis die Web-App gestartet wird. Siehe auch Problembehandlung für App Service.

Erstellen eines Key Vaults mit RBAC-Autorisierung

In diesem Schritt erstellen Sie einen Azure Key Vault zum Speichern der MongoDB-Verbindungszeichenfolge und der Web-App SECRET_KEY. Azure Key Vault ist ein sicherer Dienst zum Speichern geheimer Schlüssel, API-Schlüssel, Verbindungszeichenfolgen und Zertifikate. Der Key Vault ist für die Verwendung der rollenbasierten Zugriffssteuerung (RBAC) für die Verwaltung des Zugriffs über Azure-Rollen anstelle herkömmlicher Zugriffsrichtlinien konfiguriert. Die Web-App verwendet die vom System zugewiesene verwaltete Identität , um geheime Schlüssel zur Laufzeit sicher abzurufen.

Anmerkung

Sie können VS Code für die Verwendung der Azure CLI oder PowerShell konfigurieren. Um die Standardshell in VS Code auszuwählen, wählen Sie F1 oder STRG+UMSCHALT+P aus, um die Befehlspalette zu öffnen. Geben Sie dann Terminal ein: Wählen Sie "Standardprofil" aus. Geben Sie in der Befehlspalette Folgendes ein: Terminal: Wählen Sie "Standardprofil " und dann die gewünschte Standardshell aus.

1. Führen Sie den folgenden Azure CLI-Befehl aus, um einen neuen Key Vault zu erstellen. Dieser Befehl verwendet entweder die Bash- oder PowerShell, um einen Key Vault mit aktivierter RBAC-Autorisierung zu erstellen.

   Schlagen

   #!/bin/bash
   RESOURCE_GROUP_NAME="msdocs-web-app-rg"
   LOCATION="westus"
   KEYVAULT_NAME="${RESOURCE_GROUP_NAME}-kv"
   
   az keyvault create \
     --name "$KEYVAULT_NAME" \
     --resource-group "$RESOURCE_GROUP_NAME" \
     --location "$LOCATION" \
     --enable-rbac-authorization true
   

   PowerShell

   # PowerShell syntax
   $RESOURCE_GROUP_NAME="msdocs-web-app-rg"
   $LOCATION="westus"
   $KEYVAULT_NAME="${RESOURCE_GROUP_NAME}-kv"
   
   az keyvault create `
     --name "$KEYVAULT_NAME" `
     --resource-group "$RESOURCE_GROUP_NAME" `
     --location "$LOCATION" `
     --enable-rbac-authorization true
   

Rolle "Secrets Officer" für angemeldete Benutzer gewähren

Um geheime Schlüssel in Azure Key Vault zu speichern, muss dem Benutzer, der das Skript ausführt, die Rolle " Key Vault Secrets Officer " erteilt werden. Mit dieser Rolle kann der Benutzer Geheimnisse im Tresor erstellen und verwalten.

In diesem Schritt weist das Skript diese Rolle dem aktuell angemeldeten Benutzer zu, sodass sie vertrauliche Anwendungsdaten wie die MongoDB-Verbindungszeichenfolge und die SECRET_KEY der App sicher speichern können.

Durch die Verwendung der Azure Role-Based-Zugriffssteuerung (RBAC) gewährleistet dieser Ansatz einen sicheren und auditierbaren Zugriff auf den Key Vault, der auf der Identität basiert, und vermeidet die Notwendigkeit, Anmeldeinformationen direkt in Code- oder Konfigurationsdateien einzubetten.

Anmerkung

Dem Benutzer muss die Rolle " Key Vault Secrets Officer " zugewiesen werden, bevor versucht wird, geheime Schlüssel im Schlüsseltresor zu speichern. Diese Zuweisung erfolgt mithilfe des Befehls az role assignment create, der auf den Key Vault abgezielt ist.

1. In diesem Schritt verwenden Sie den Befehl "az role assignment create" , um die Rolle im Key Vault-Bereich zuzuweisen.

   Schlagen

   #!/bin/bash
   CALLER_ID=$(az ad signed-in-user show --query id -o tsv)
   echo $CALLER_ID # Verify this value retrieved successfully. In production, poll to verify this value is retrieved successfully.
   
   az role assignment create \
     --role "Key Vault Secrets Officer" \
     --assignee "$CALLER_ID" \
     --scope "/subscriptions/$(az account show --query id -o tsv)/resourceGroups/$RESOURCE_GROUP_NAME/providers/Microsoft.KeyVault/vaults/$KEYVAULT_NAME"
   
   

   PowerShell

   # PowerShell syntax
   $CALLER_ID=$(az ad signed-in-user show --query id -o tsv)
   echo $CALLER_ID # Verify this value retrieved successfully. In production, poll to verify this value is retrieved successfully.
   
   az role assignment create `
     --role "Key Vault Secrets Officer" `
     --assignee "$CALLER_ID" `
     --scope "/subscriptions/$(az account show --query id -o tsv)/resourceGroups/$RESOURCE_GROUP_NAME/providers/Microsoft.KeyVault/vaults/$KEYVAULT_NAME"
   

Geheime Schlüssel im Schlüsseltresor speichern

Um geheime Schlüssel in Ihrer Anwendung zu vermeiden, speichern Sie in diesem Schritt die MongoDB-Verbindungszeichenfolge in der MongoDB-Instanz und den geheimen Schlüssel der Web-App im Azure Key Vault. Diese geheimen Schlüssel können dann von der Web-App zur Laufzeit über die verwaltete Identität sicher aufgerufen werden, ohne dass Anmeldeinformationen im Code oder in der Konfiguration gespeichert werden müssen.

Anmerkung

Während in diesem Lernprogramm nur die Verbindungszeichenfolge und der geheime Schlüssel im Schlüsseltresor gespeichert werden, können Sie optional auch andere Anwendungseinstellungen wie den MongoDB-Datenbanknamen oder den Sammlungsnamen im Key Vault speichern.

1. In diesem Schritt verwenden Sie den Befehl "az cosmosdb keys list" zum Abrufen der MongoDB-Verbindungszeichenfolge. Anschließend verwenden Sie den Befehl "az keyvault secret set ", um sowohl die Verbindungszeichenfolge als auch einen zufällig generierten geheimen Schlüssel im Key Vault zu speichern.

   Schlagen

   #!/bin/bash
   ACCOUNT_NAME="msdocs-cosmos-db-account-name"
   
   MONGO_CONNECTION_STRING=$(az cosmosdb keys list \
     --name "$ACCOUNT_NAME" \
     --resource-group "$RESOURCE_GROUP_NAME" \
     --type connection-strings \
     --query "connectionStrings[?description=='Primary MongoDB Connection String'].connectionString" -o tsv)
   
   SECRET_KEY=$(openssl rand -base64 32 | tr -dc 'a-zA-Z0-9')
   # This key is cryptographically secure, using OpenSSL’s strong random number generator.
   
   az keyvault secret set \
     --vault-name "$KEYVAULT_NAME" \
     --name "MongoConnectionString" \
     --value "$MONGO_CONNECTION_STRING"
   
   az keyvault secret set \
     --vault-name "$KEYVAULT_NAME" \
     --name "MongoSecretKey" \
     --value "$SECRET_KEY"
   

   PowerShell

   # PowerShell syntax
   $ACCOUNT_NAME="msdocs-cosmos-db-account-name"
   
   $MONGO_CONNECTION_STRING = az cosmosdb keys list `
     --name $ACCOUNT_NAME `
     --resource-group $RESOURCE_GROUP_NAME `
     --type connection-strings `
     --query "connectionStrings[?description=='Primary MongoDB Connection String'].connectionString" `
     -o tsv
   
   # Generate a 32-byte cryptographically secure random value
   $bytes = New-Object 'Byte[]' 32
   [System.Security.Cryptography.RandomNumberGenerator]::Create().GetBytes($bytes)
   
   # Convert to base64 and filter to alphanumeric characters only
   $base64 = [Convert]::ToBase64String($bytes)
   $alphanumeric = $base64 -replace '[^a-zA-Z0-9]', ''
   
   # Truncate to 50 characters
   $SECRET_KEY = $alphanumeric.Substring(0, [Math]::Min(50, $alphanumeric.Length))
   
   az keyvault secret set `
     --vault-name "$KEYVAULT_NAME" `
     --name "MongoConnectionString" `
     --value "$MONGO_CONNECTION_STRING"
   
   az keyvault secret set `
     --vault-name "$KEYVAULT_NAME" `
     --name "MongoSecretKey" `
     --value "$SECRET_KEY"
   

Gewähren von Schlüsseltresorzugriff auf die verwaltete Identität der Web-App

Die Web-App benötigt die Erlaubnis, auf die MongoDB-Verbindungszeichenfolge und das im Schlüsseltresor gespeicherte SECRET_KEY zuzugreifen. Um diese Berechtigungen zu erteilen, weisen Sie die Rolle " Key Vault Secrets User" der vom System zugewiesenen verwalteten Identität der Web-App zu.

1. In diesem Schritt verwenden Sie die eindeutige ID (Prinzipal-ID) der systemseitig zugewiesenen verwalteten Identität der Web-App, um der Web-App Zugriff auf den Key Vault mit der Rolle "Key Vault Secrets User" zu gewähren, indem Sie den Befehl az role assignment create verwenden.

   Schlagen

   #!/bin/bash
     APP_SERVICE_NAME="msdocs-website-name"
     PRINCIPAL_ID=$(az webapp identity show \
       --name "$APP_SERVICE_NAME" \
       --resource-group "$RESOURCE_GROUP_NAME" \
       --query principalId \
       -o tsv)
   echo $PRINCIPAL_ID # Verify this value retrieved successfully. In production, poll for successful 'AcrPull' role assignment using `az role assignment list`.    
   
   az role assignment create \
   --role "Key Vault Secrets User" \
   --assignee "$PRINCIPAL_ID" \
   --scope "/subscriptions/$(az account show --query id -o tsv)/resourceGroups/$RESOURCE_GROUP_NAME/providers/Microsoft.KeyVault/vaults/$KEYVAULT_NAME"
   

   PowerShell

   # PowerShell syntax
       $PRINCIPAL_ID=$(az webapp identity show `
     --name "$APP_SERVICE_NAME" `
     --resource-group "$RESOURCE_GROUP_NAME" `
     --query principalId `
     -o tsv)
   echo $PRINCIPAL_ID # Verify this value retrieved successfully. In production, poll for successful AcrPull role assignment using `az role assignment list`.    
   
   
   az role assignment create `
   --role "Key Vault Secrets User" `
   --assignee "$PRINCIPAL_ID"`
   --scope "/subscriptions/$(az account show --query id -o tsv)/resourceGroups/$RESOURCE_GROUP_NAME/providers/Microsoft.KeyVault/vaults/$KEYVAULT_NAME"
       ```
   
   ---
   
   

Konfigurieren der Verbindung mit MongoDB mit Key Vault-Geheimnissen

In diesem Schritt aktualisieren Sie die Umgebungsvariablen, die zum Herstellen einer Verbindung mit MongoDB erforderlich sind, um die im Schlüsseltresor gespeicherten Werte zu verwenden.

1. In der Azure-Ansicht in VS Code (aus der Azure Tools-Erweiterung):

   1. Erweitern Sie RESOURCES und suchen Sie App Services unter Ihrem Abonnement. (Stellen Sie sicher, dass Sie die Ressourcen nach Gruppe nach Ressourcentyp anzeigen.)

   2. Erweitern Sie App Services, erweitern Sie Ihre Web-App, und erweitern Sie dann die Anwendungseinstellungen.

   3. Ändern Sie die folgenden Einstellungen:

   • CONNECTION_STRING: @Microsoft.KeyVault(SecretUri=https://msdocs-web-app-rg-kv.vault.azure.net/secrets/MongoConnectionString)
   • SECRET_KEY: @Microsoft.KeyVault(SecretUri=https://$KEYVAULT_NAME.vault.azure.net/secrets/MongoSecretKey)

   Anmerkung

   Um sicherzustellen, dass die Anwendungseinstellungen richtig festgelegt sind, können Sie den Listenbefehl "az webapp config appsettings" verwenden, um die Anwendungseinstellungen für die Web-App auflisten zu können. Die Form des Befehls lautet: az webapp config appsettings list --/<resource-group msdocs-web-app-rg/> --name /<website-name/>. Dieser Befehl listet alle Anwendungseinstellungen für die Web-App auf, einschließlich der Einstellungen, die Sie gerade festgelegt haben.

Durchsuchen Sie die Website mit Hilfe von Schlüsseltresorgeheimnissen

In der Azure-Ansicht in VS Code (aus der Azure Tools-Erweiterung):

1. Erweitern Sie RESOURCES und suchen Sie App Services unter Ihrem Abonnement. (Stellen Sie sicher, dass Sie die Ressourcen nach Gruppe nach Ressourcentyp anzeigen.)

2. Klicken Sie mit der rechten Maustaste auf Ihre Web-App, und wählen Sie "Website durchsuchen" aus. Wenn ihre Website einen Fehler anzeigt, warten Sie einige Minuten, und versuchen Sie es erneut. Es kann einige Minuten dauern, bis die Web-App gestartet wird. Siehe auch Problembehandlung für App Service.

Problembehandlung bei der Bereitstellung

Wenn die Beispiel-App nicht angezeigt wird, führen Sie die folgenden Schritte aus.

• Überprüfen Sie bei der Bereitstellung von Containern und dem App Service immer die Seite Deployment Center / Logs im Azure-Portal. Bestätigen Sie, dass der Container gezogen wurde und ausgeführt wird. Das erstmalige Abrufen und Ausführen des Containers kann ein paar Augenblicke dauern.
• Versuchen Sie, den App-Dienst neu zu starten, und überprüfen Sie, ob das Problem behoben wird.
• Wenn Programmierfehler auftreten, werden diese Fehler in den Anwendungsprotokollen angezeigt. Wählen Sie auf der Seite des Azure-Portals für den App Service Probleme diagnostizieren und lösen/Anwendungsprotokolle.
• Die Beispiel-App basiert auf einer Verbindung mit Azure Cosmos DB für MongoDB. Vergewissern Sie sich, dass der App-Dienst Über Anwendungseinstellungen mit den richtigen Verbindungsinformationen verfügt.
• Vergewissern Sie sich, dass die verwaltete Identität für den App-Dienst aktiviert ist und im Deployment Center verwendet wird. Gehen Sie auf der Azure-Portalseite für den App Service zur Ressource App Service Deployment Center und bestätigen Sie, dass Authentifizierung auf Verwaltete Identität eingestellt ist.
• Überprüfen Sie, ob der Webhook in der Azure-Containerregistrierung definiert ist. Mit dem Webhook kann der App Service das Image des Containers abrufen. Stellen Sie insbesondere sicher, dass die URI des Dienstes mit "/api/registry/webhook" endet. Bei Bedarf, hinzufügen.
• Verschiedene Azure Container Registry-SKUs haben unterschiedliche Funktionen, darunter die Anzahl von Webhooks. Wenn Sie eine bestehende Registrierung wiederverwenden, könnte die folgende Nachricht angezeigt werden: "Kontingent für Ressourcentyp Webhooks für die Registrierung SKU Basic überschritten. Erfahren Sie mehr über verschiedene SKU-Kontingente und Upgradeprozesse: https://aka.ms/acr/tiers". Wenn Sie diese Nachricht sehen, verwenden Sie eine neue Registrierung oder reduzieren Sie die Anzahl der verwendeten Registrierungs-Webhooks.

Nächster Schritt

Ressourcen bereinigen