Distribuera en containerbaserad Python-app till App Service

I den här delen av självstudieserien får du lära dig hur du distribuerar en containerbaserad Python-webbapp till Azure App Service Web App for Containers. Med den här fullständigt hanterade tjänsten kan du köra containerbaserade appar utan att behöva underhålla din egen containerorkestrerare.

App Service förenklar distributionen via CI/CD-pipelines (kontinuerlig integrering/kontinuerlig distribution) som fungerar med Docker Hub, Azure Container Registry, Azure Key Vault och andra DevOps-verktyg. Den här självstudien är del 4 i en självstudieserie i fem delar.

I slutet av den här artikeln har du en säker, produktionsklar App Service-webbapp som körs från en Docker-containeravbildning. Appen använder en systemtilldelad hanterad identitet för att hämta avbildningen från Azure Container Registry och hämta hemligheter från Azure Key Vault.

Det här tjänstdiagrammet visar de komponenter som beskrivs i den här artikeln.

Azure CLI

Du kan köra Azure CLI kommandon i Azure Cloud Shell eller på en lokal dator med Azure CLI installerat.

Viktig

Använd Azure Cloud Shell för alla CLI-baserade steg i den här självstudien eftersom det:

• Levereras förautentiserad med ditt Azure-konto, så att du inte stöter på autentiseringsproblem
• Innehåller alla nödvändiga Azure CLI tillägg
• Säkerställer konsekvent beteende oavsett ditt lokala operativsystem eller din miljö
• Kräver ingen lokal installation, perfekt för användare utan administratörsbehörighet
• Ger direkt åtkomst till Azure tjänster från portalen – ingen lokal Docker- eller nätverkskonfiguration krävs
• Undviker problem med lokal brandvägg eller nätverkskonfiguration

Skapa Key Vault med RBAC-auktorisering

Azure Key Vault är en säker tjänst för lagring av hemligheter, API-nycklar, anslutningssträngar och certifikat. I det här skriptet lagras MongoDB-anslutningssträngen och webbappens SECRET_KEY.

Konfigurera Key Vault att använda role-baserad åtkomstkontroll (RBAC) för att hantera åtkomst via Azure roller i stället för traditionella åtkomstprinciper. Webbappen använder sin systemtilldelade hanterade identitet för att hämta hemligheter på ett säkert sätt under körning.

Anmärkning

Skapa Key Vault tidigt för att säkerställa att du kan tilldela roller innan du försöker komma åt hemligheter. Den här metoden hjälper också till att undvika spridningsfördröjningar i rolltilldelningar. Eftersom Key Vault inte är beroende av App Service, förbättras tillförlitligheten och ordningsföljden genom att etablera det tidigt.

1. Använd kommandot az keyvault create för att skapa en Azure Key Vault med RBAC aktiverat.

   Bash

   #!/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
   

Skapa apptjänstplanen och webbappen

App Service-planen definierar beräkningsresurser, prisnivå och region för din webbapp. Webbappen kör din containerbaserade applikation och förses med en systemtilldelad hanterad identitet som den använder för att på ett säkert sätt autentisera sig mot Azure Container Registry (ACR) och Azure Key Vault.

I det här steget utför du följande uppgifter:

• Skapa en App Service-plan
• Skapa webbappen med dess hanterade identitet
• Konfigurera webbappen så att den distribueras med hjälp av en specifik containeravbildning
• Förbereda för kontinuerlig distribution via ACR

Anmärkning

Du måste skapa webbappen innan du tilldelar åtkomst till ACR eller Key Vault eftersom den hanterade identiteten endast skapas vid distributionstillfället. Om du tilldelar containeravbildningen när du skapar den kan appen också startas korrekt med den avsedda konfigurationen.

1. Använd kommandot az appservice plan create för att etablera beräkningsmiljön för din app.

   Bash

   #!/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. Använd kommandot az webapp create för att skapa webbappen. Det här kommandot aktiverar även en systemtilldelad hanterad identitet och anger containeravbildningen som appen kör.

   Bash

   #!/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 registry 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" 
   

   Anmärkning

   När du kör det här kommandot kan följande fel visas:

   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.'
   

   Det här felet beror på att webbappen försöker använda administratörsautentiseringsuppgifter för att komma åt ACR, men administratörsautentiseringsuppgifterna är inaktiverade som standard. Du kan ignorera det här meddelandet. Nästa steg konfigurerar webbappen att använda sin hanterade identitet för att autentisera med ACR.

Bevilja Key Vault secrets officer-rollen till autentiserad användare

Om du vill lagra hemligheter i Azure Key Vault måste användaren som kör skriptet ha rollen Key Vault Secrets Officer . Den här rollen ger behörighet att skapa och hantera hemligheter i valvet.

I det här steget tilldelar skriptet rollen till den autentiserade användaren. Den här användaren kan sedan lagra programhemligheter på ett säkert sätt, till exempel MongoDB-anslutningssträngen och appens SECRET_KEY.

Den här rolltilldelningen är den första av två Key Vault-relaterade rolltilldelningar. Senare beviljas webbappens systemtilldelade hanterade identitet åtkomst för att hämta hemligheter från valvet.

Genom att använda Azure RBAC säkerställer du säker, granskningsbar åtkomst baserat på identitet, så att du inte behöver använda hårdkodade autentiseringsuppgifter.

Anmärkning

Tilldela rollen Key Vault Secrets Officer till användaren innan användaren försöker lagra några hemligheter i nyckelvalvet. Använd kommandot az role assignment create med omfång för Key Vault för att skapa den här rolltilldelningen.

1. Använd kommandot az role assignment create för att tilldela rollen i Key Vault omfång.

   Bash

   #!/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"
   

Bevilja webbåtkomst till ACR med hjälp av hanterad identitet

Om du vill hämta avbildningar från Azure Container Registry (ACR) på ett säkert sätt konfigurerar du webbappen så att den använder sin systemtilldelade hanterade identitet. Genom att använda hanterad identitet behöver du inte administratörsautentiseringsuppgifter och kan stödja säker distribution utan autentiseringsuppgifter.

Den här processen omfattar två viktiga åtgärder:

• Göra det möjligt för webbappen att använda sin hanterade identitet vid åtkomst till ACR
• Tilldela AcrPull-rollen till den identiteten på mål-ACR

1. I det här steget hämtar du huvud-ID :t (unikt objekt-ID) för webbappens hanterade identitet med hjälp av kommandot az webapp identity show . Aktivera sedan användningen av den hanterade identiteten för ACR-autentisering genom att ange acrUseManagedIdentityCreds egenskapen till true med hjälp av az webapp config set. Tilldela sedan AcrPull-rollen till webbappens hanterade identitet med hjälp av kommandot az role assignment create . Den här rollen ger webbappen behörighet att hämta avbildningar från registret.

   Bash

   #!/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"
   

Ge nyckelvalvet åtkomst till webbappens hanterade identitet

Webbappen behöver behörighet att komma åt hemligheter som MongoDB-anslutningssträngen SECRET_KEYoch . Om du vill bevilja dessa behörigheter tilldelar du rollen Key Vault Secrets User till webbappens systemtilldelade hanterade identitet.

1. I det här steget använder du den unika identifieraren (huvud-ID) för webbappens systemtilldelade hanterade identitet för att ge webbappen åtkomst till Key Vault med Key Vault Secrets User roll med hjälp av kommandot az role assignment create.

   Bash

   #!/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"
   
   

Lagra hemligheter i Key Vault

Om du vill undvika hårdkodning av hemligheter i ditt program lagrar du MongoDB reťazec pripojenia och webbappens sekretnyckel i Azure Key Vault. Webbappen kan på ett säkert sätt komma åt dessa hemligheter vid körning via dess hanterade identitet, så du behöver inte lagra autentiseringsuppgifter i kod eller konfiguration.

Anmärkning

Även om den här självstudien endast lagrar anslutningssträngen och den hemliga nyckeln i nyckelvalvet kan du även lagra andra programinställningar, till exempel MongoDB-databasnamnet eller samlingsnamnet i Key Vault.

1. Använd kommandot az cosmosdb keys list för att hämta MongoDB-reťazec pripojenia. Använd sedan kommandot az keyvault secret set för att lagra både reťazec pripojenia och en slumpmässigt genererad hemlig nyckel i Key Vault.

   Bash

   #!/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"
   

Konfigurera webbappen så att den använder Key Vault hemligheter

Om du vill komma åt hemligheter på ett säkert sätt vid körning konfigurerar du webbappen så att den refererar till hemligheterna som lagras i Azure Key Vault. Använd Key Vault referenser för att mata in hemliga värden i appens miljö via dess systemtilldelade hanterade identitet.

Den här metoden undviker hårdkodning av hemligheter och gör att appen på ett säkert sätt kan hämta känsliga värden som MongoDB-anslutningssträngen och den hemliga nyckeln under körningen.

1. Använd kommandot az webapp config appsettings set för att lägga till programinställningar som refererar till Key Vault hemligheter. Mer specifikt anger du appinställningarna MongoConnectionString och MongoSecretKey för att referera till motsvarande hemligheter som lagras i Key Vault.

   Bash

   #!/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
   

Aktivera kontinuerlig distribution från ACR

När du aktiverar kontinuerlig distribution hämtar och kör webbappen automatiskt den senaste containeravbildningen när du push-överför en till Azure Container Registry (ACR). Den här funktionen minskar stegen för manuell distribution och hjälper till att se till att din app håller sig uppdaterad.

Anmärkning

I nästa steg registrerar du en webhook i ACR för att meddela webbappen när en ny avbildning skickas.

1. Använd kommandot az webapp deployment container config för att aktivera kontinuerlig distribution från ACR till webbappen.

   Bash

   #!/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
   

Registrera en ACR-webhook för kontinuerlig distribution

Om du vill automatisera distributioner registrerar du en webhook i Azure Container Registry (ACR) som meddelar webbappen när en ny containeravbildning skickas. Med hjälp av webhooken hämtar och kör appen automatiskt den senaste versionen.

Webhooken som du konfigurerar i Azure Container Registry (ACR) skickar en POST-begäran till webbappens SCM-slutpunkt (SERVICE_URI) när en ny avbildning skickas till lagringsplatsen msdocspythoncontainerwebapp. Den här åtgärden utlöser webbappen för att hämta och distribuera den uppdaterade avbildningen och slutföra pipelinen för kontinuerlig distribution mellan ACR och Azure App Service.

Anmärkning

Webhook-URI:n måste följa det här formatet:
https://<app-name>.scm.azurewebsites.net/api/registry/webhook

Det måste sluta med /api/registry/webhook. Om du får ett URI-fel kontrollerar du att sökvägen är korrekt.

1. Använd kommandot az acr webhook create för att registrera webhooken och konfigurera den för att utlösa push händelser.

   Bash

   #!/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
   

Bläddra på webbplatsen

Kontrollera att webbappen körs genom att öppna https://<website-name>.azurewebsites.netoch ersätta <website-name> med namnet på din App Service. Du bör se exempelappen för restauranggranskning. Det kan ta en stund att läsa in första gången.

När webbplatsen visas kan du prova att lägga till en restaurang och skicka en granskning för att bekräfta att appen fungerar korrekt.

Anmärkning

Kommandot az webapp browse stöds inte i Cloud Shell. Om du använder Cloud Shell öppnar du en webbläsare manuellt och går till webbplatsens URL.

Om du använder Azure CLI lokalt använder du kommandot az webapp browse för att öppna webbplatsen i standardwebbläsaren:

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

Anmärkning

Kommandot az webapp browse stöds inte i Cloud Shell. Öppna ett webbläsarfönster och gå till webbplatsens URL i stället.

VS-kod

Du kan använda Docker-tillägget i Visual Studio Code för att skapa och distribuera ditt containerbaserade webbprogram till Azure App Service. Det här tillägget effektiviserar processen med att paketera din app och skicka den till molnet. När du har distribuerat det använder du Azure Tools-tillägget för att konfigurera webbappens inställningar, inklusive MongoDB-anslutningssträngen och en hemlig nyckel för programmet.

Konfigurera och testa först appen med hjälp av hårdkodade värden för att säkerställa att den startar och ansluter till MongoDB-databasen. När du har verifierat att appen fungerar använder du Azure CLI (antingen lokalt eller i Cloud Shell) för att skapa ett Azure Key Vault. Ge sedan användaren som skapar appen i VS Code behörighet att lagra känslig information och sedan lagra MongoDB-reťazec pripojenia och appens hemliga nyckel som Key Vault hemligheter.

Slutligen uppdaterar du webbappens programinställningar i Visual Studio Code för att referera till hemligheterna som lagras i Key Vault. Appen kan nu komma åt konfigurationsvärden på ett säkert sätt utan att bädda in dem direkt i kod.

Skapa webbappen

De här stegen kräver installation av Docker-tillägget för VS Code.

1. Uppdatera Azure Container Registry i Docker-tillägget för att bekräfta att containern du skapade visas under avsnittet Register i Docker-tillägget. Om den inte gör det högerklickar du på registernamnet och väljer Uppdatera.

   

2. Välj F1 eller CTRL+SKIFT+P för att öppna kommandopaletten, skriv "Docker-register" och välj Docker-register: Distribuera avbildning till Azure App Service... uppgift.

3. Ange följande värden enligt anvisningarna för att distribuera bilden.

   • Välj registerprovider: Azure
   • Prenumeration: Välj den prenumeration som innehåller Azure Container Registry som du skapade tidigare.
   • Välj register: Ange namnet på registret som du skapade tidigare i den här självstudien.
   • Välj lagringsplats: Ange lagringsplatsens namn msdocscontainerregistryname. Om du inte ser den här lagringsplatsen, uppdatera avsnittet REGISTRIES i Docker-tillägget.
   • Välj tagg: senaste för avbildningstaggen.
   • Ange ett globalt unikt namn för webbappen: Ange ett namn som är globalt unikt för Azure App Service. Om du till exempel använder msdocs-website-name blir http://msdocs-website-name.azurewebsites.netwebbappens URL .
   • Välj en resursgrupp: Använd resursgruppen som innehåller Azure Container Registry som du skapade tidigare.
   • Välj en Linux App Service-plan: Använd en befintlig eller skapa en ny.

4. Visa fönstret OUTPUT för mer information om distributionen. En av utdataraderna är "Beviljar behörighet åt App Service att hämta avbildning från ACR...", därefter går App Service in i registret med hanterad identitet.

   

   Den sista webbplatsen https://<app-name>.azurewebsites.net är inte klar ännu eftersom du måste ange MongoDB-information.

   Anmärkning

   När du distribuerar med Visual Studio Code är den hanterade identiteten redan konfigurerad för att App Service kan hämta avbildningar från registret. Du kan bekräfta att den hanterade identiteten är aktiverad genom att visa loggar i fönstret OUTPUT och leta efter meddelandet "Bevilja behörighet för App Service att hämta avbildning från ACR...".

Konfigurera hanterad identitet och webhook

Under distributionen med VS Code skapar du en webhook som gör att webbappen kan hämta nya avbildningar från Azure Container Registry.

1. Granska webhooks-konfigurationen i Azure-portalen för att bekräfta att tjänst-URI:n slutar med "/api/registry/webhook". Om du vill granska tjänst-URI:n öppnar du Docker-tillägget i VS Code och letar reda på registret som du skapade. Högerklicka på registret och välj Öppna i portalen. Containerregistret öppnas i Azure-portalen. Klicka på Tjänster och sedan på Webhooks. Öppna snabbmenyn och klicka på Konfigurera.

   

2. Bekräfta att tjänst-URI:n slutar med "/api/registry/webhook". Om den inte gör det lägger du till den i slutet av strängen och klickar på Spara.

Konfigurera anslutning till MongoDB med hjälp av hårdkodade värden

I det här steget anger du de miljövariabler som krävs för att webbprogrammet ska kunna ansluta till MongoDB.

Anmärkning

Om du vill konfigurera miljövariabler för webbappen från VS Code måste du ha Azure Tools-tilläggspaketet installerat och loggas in på Azure från VS Code.

1. I Azure-vyn i VS Code (från Azure Tools-tillägget):

   1. Expandera RESURSER och leta reda på App Services under din prenumeration. (Kontrollera att du visar resurser efter grupp efter resurstyp.)

   2. Expandera App Services och leta reda på webbappen som du skapade.

   3. Expandera webbappen och högerklicka på Programinställningar.

   4. Välj Lägg till ny inställning....

   

2. Varje gång du lägger till en ny inställning visas en dialogruta överst i VS Code-fönstret där du kan lägga till inställningsnamnet följt av dess värde. Lägg till följande inställningar:

   • CONNECTION_STRING: MongoDB-anslutningssträngen. Senare i den här självstudien anger du det här värdet som den anslutningssträng som du lagrar i Azure Key Vault.
   • DB_NAME: restaurants_reviews
   • COLLECTION_NAME: restaurants_reviews
   • WEBSITES_PORT: 8000 för Django och 5000 för Flask. Den här miljövariabeln anger den port som containern lyssnar på.
   • SECRET_KEY: supersecretkeythatispassedtopythonapp. Den här hemliga nyckeln är en slumpmässig sträng som används av Django och Flask för att kryptera sessionsdata. Senare i den här självstudien anger du det här värdet till den slumpmässiga sträng som du lagrar i Azure Key Vault.

Bläddra på webbplatsen med hjälp av hårdkodade värden

I Azure-vyn i VS Code (från Azure Tools-tillägget):

1. Expandera RESURSER och leta reda på App Services under din prenumeration. (Kontrollera att du visar resurser efter grupp efter resurstyp.)

2. Högerklicka på webbappen och välj Bläddra på webbplatsen. Om ett fel visas på webbplatsen väntar du några minuter och försöker igen. Det kan ta några minuter innan webbappen startas. Se även Felsökning av App Service.

Skapa Key Vault med RBAC-auktorisering

I det här steget skapar du ett Azure Key Vault för att lagra MongoDB-anslutningssträngen och webbappens SECRET_KEY. Azure Key Vault är en säker tjänst för lagring av hemligheter, API-nycklar, anslutningssträngar och certifikat. Du konfigurerar Key Vault att använda role-baserad åtkomstkontroll (RBAC) för att hantera åtkomst via Azure roller i stället för traditionella åtkomstprinciper. Webbappen använder sin systemtilldelade hanterade identitet för att hämta hemligheter på ett säkert sätt under körning.

Anmärkning

Du kan konfigurera VS Code för att använda Azure CLI eller PowerShell. Om du vill välja standardgränssnittet i VS Code väljer du F1 eller CTRL+SKIFT+P för att öppna kommandopaletten. Skriv sedan Terminal: Välj Standardprofil. I kommandopaletten skriver du och väljer Terminal: Välj Standardprofil och välj sedan önskat standardgränssnitt.

1. Kör följande Azure CLI-kommando för att skapa ett nytt Key Vault. Det här kommandot använder antingen bash eller PowerShell för att skapa en Key Vault med RBAC-auktorisering aktiverat.

   Bash

   #!/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
   

Bevilja Key Vault secrets officer-rollen till autentiserad användare

Om du vill lagra hemligheter i Azure Key Vault beviljar du rollen Key Vault Secrets Officer till den användare som kör skriptet. Den här rollen ger möjlighet att skapa och hantera hemligheter i valvet.

I det här steget tilldelar skriptet den här rollen till den för närvarande autentiserade användaren, vilket gör det möjligt för dem att lagra känsliga programdata på ett säkert sätt, till exempel MongoDB-reťazec pripojenia och appens SECRET_KEY.

Genom att använda Azure Role-Based Access Control (RBAC) garanterar den här metoden säker, granskningsbar åtkomst till Key Vault baserat på identitet, så du behöver inte bädda in autentiseringsuppgifter direkt i kod- eller konfigurationsfiler.

Anmärkning

Tilldela rollen Key Vault Secrets Officer till användaren innan de försöker lagra hemligheter i nyckelvalvet. Använd kommandot az role assignment create med omfång för Key Vault för att skapa den här rolltilldelningen.

1. Använd kommandot az role assignment create för att tilldela rollen i Key Vault omfång.

   Bash

   #!/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"
   

Lagra hemligheter i Key Vault

Om du vill undvika hårdkodning av hemligheter i programmet lagrar du MongoDB reťazec pripojenia till MongoDB-instansen och webbappens sekretnyckel i Azure Key Vault. Webbappen kan på ett säkert sätt komma åt dessa hemligheter vid körning via sin hanterade identitet, utan att behöva lagra autentiseringsuppgifter i kod eller konfiguration.

Anmärkning

Även om den här självstudien endast lagrar anslutningssträngen och den hemliga nyckeln i nyckelvalvet kan du även lagra andra programinställningar, till exempel MongoDB-databasnamnet eller samlingsnamnet i Key Vault.

1. Använd kommandot az cosmosdb keys list för att hämta MongoDB-reťazec pripojenia. Använd sedan kommandot az keyvault secret set för att lagra både reťazec pripojenia och en slumpmässigt genererad hemlig nyckel i Key Vault.

   Bash

   #!/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"
   

Ge nyckelvalvet åtkomst till webbappens hanterade identitet

Webbappen behöver behörighet att komma åt MongoDB-anslutningssträngen SECRET_KEY och den som du lagrade i nyckelvalvet. Om du vill bevilja dessa behörigheter tilldelar du rollen Key Vault Secrets User till webbappens systemtilldelade hanterade identitet.

1. I det här steget använder du den unika identifieraren (huvud-ID) för webbappens systemtilldelade hanterade identitet för att ge webbappen åtkomst till Key Vault med Key Vault Secrets User roll med hjälp av kommandot az role assignment create.

   Bash

   #!/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"
       ```
   
   ---
   
   

Konfigurera anslutning till MongoDB med hjälp av Key Vault hemligheter

I det här steget uppdaterar du de miljövariabler som behövs för att ansluta till MongoDB för att använda de värden som lagras i nyckelvalvet.

1. I Azure-vyn i VS Code (från Azure Tools-tillägget):

   1. Expandera RESURSER och leta reda på App Services under din prenumeration. (Kontrollera att du visar resurser efter grupp efter resurstyp.)

   2. Expandera App Services, expandera webbappen och expandera sedan Programinställningar.

   3. Ändra följande inställningar:

   • 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)

   Anmärkning

   Kontrollera att programinställningarna har angetts korrekt genom att använda kommandot az webapp config appsettings list för att visa en lista över programinställningarna för webbappen. Kommandots form är: az webapp config appsettings list --/<resource-group msdocs-web-app-rg/> --name /<website-name/>. Det här kommandot visar alla programinställningar för webbappen, inklusive de som du precis har angett.

Bläddra på webbplatsen genom att använda Key Vault-hemligheter

I Azure-vyn i VS Code (från Azure Tools-tillägget):

1. Expandera RESURSER och leta reda på App Services under din prenumeration. (Kontrollera att du visar resurser efter grupp efter resurstyp.)

2. Högerklicka på webbappen och välj Bläddra på webbplatsen. Om ett fel visas på webbplatsen väntar du några minuter och försöker igen. Det kan ta några minuter innan webbappen startas. Se även Felsökning av App Service.

Felsök driftsättning

Om du inte ser exempelappen kan du prova följande steg.

• För containerdistribution och App Service kontrollerar du alltid sidan Deployment Center / Logs i Azure portalen. Kontrollera att containern har hämtats och är igång. Den första hämtningen och körningen av containern kan ta en stund.
• Försök att starta om App Service och se om det löser problemet.
• Om det finns programmeringsfel visas dessa fel i programloggarna. På sidan Azure-portalen för App Service väljer du Diagnostisera och lösa problem/programloggar.
• Exempelappen förlitar sig på en anslutning till Azure Cosmos DB för MongoDB. Bekräfta att App Service har programinställningar med rätt anslutningsinformation.
• Bekräfta att den hanterade identiteten är aktiverad för appservicen och används i distributionscentret. På Azure-portalen går du till App Service-resursen Deployment Center och bekräftar att Autentisering är inställt på Hanterad identitet.
• Kontrollera att webhooken har definierats i Azure Container Registry. Med webhooken kan App Service hämta containeravbildningen. Kontrollera särskilt att tjänst-URI slutar med "/api/registry/webhook". Om inte, lägg till den.
• Olika Azure Container Registry-sku:er har olika funktioner, inklusive antalet webhooks. Om du återanvänder ett befintligt register kan du se meddelandet: "Kvoten har överskridits för resurstypen webhooks för registret med SKU Basic." Läs mer om olika SKU-kvoter och uppgraderingsprocess: https://aka.ms/acr/tiers". Om du ser det här meddelandet, använd ett nytt register eller minska antalet register-webhooks som används.

Nästa steg

Rensa resurser