Skapa och distribuera en Django-webbapp till Azure med en användartilldelad hanterad identitet

I den här handledningen kommer du att distribuera en Django-webbapp till Azure App Service. Webbappen använder en användartilldelad hanterad identitet med anslutningar utan lösenord och rollbaserad åtkomstkontroll i Azure för åtkomst till Azure Storage och Azure Database for PostgreSQL - Flexible Server- resurser. Koden använder klassen DefaultAzureCredential i Azure Identity-klientbiblioteket för Python. DefaultAzureCredential klassen upptäcker automatiskt att det finns en hanterad identitet för App Service och använder den för att komma åt andra Azure-resurser.

I den här handledningen skapar du en användartilldelad hanterad identitet och tilldelar den till App Service så att den kan få åtkomst till databas- och lagringskontots resurser. En illustration av användningen av en systemtilldelad hanterad identitet finns i Skapa och distribuera en Flask Python-webbapp till Azure med systemtilldelad hanterad identitet. Användartilldelade hanterade identiteter rekommenderas eftersom de kan användas av flera resurser och deras livscykel frikopplas från de resurslivscykler som de är associerade med. Mer information om metodtips för att använda hanterade identiteter hittar du i Rekommenderade metoder för hanterade identiteter.

Den här handledningen visar hur du distribuerar en webbapp för Python och skapar Azure-resurser med Azure CLI. Kommandona i den här handledningen är skrivna för att köras i ett Bash-skal. Du kan köra handledningskommandona i valfri Bash-miljö med CLI:n installerad, till exempel i din lokala miljö eller Azure Cloud Shell. Med viss ändring – till exempel inställning och användning av miljövariabler – kan du köra dessa kommandon i andra miljöer som Windows-kommandogränssnittet.

Hämta exempelappen

Använd exempelprogrammet Django för att följa med i den här självstudien. Ladda ned eller klona exempelprogrammet till utvecklingsmiljön.

1. Klona exemplet.

   git clone https://github.com/Azure-Samples/msdocs-django-web-app-managed-identity.git
   

2. Gå till programmappen.

   cd msdocs-django-web-app-managed-identity
   

Granska autentiseringskoden

Exempelwebbappen måste autentisera till två olika datalager:

• Azure Blob Storage-server där den lagrar och hämtar foton som skickats av granskare.
• En Azure Database for PostgreSQL – flexibel serverdatabas där den lagrar restauranger och recensioner.

Den använder DefaultAzureCredential för att autentisera mot båda datalager. Med DefaultAzureCredential kan appen konfigureras att köras under identiteten för olika tjänsters huvudsakliga identiteter, beroende på vilken miljö den körs i, utan att ändra koden. I en lokal utvecklingsmiljö kan appen till exempel köras under identiteten för utvecklaren som är inloggad i Azure CLI, medan den i Azure, som i den här självstudien, kan köras under en användartilldelad hanterad identitet.

I båda fallen måste säkerhetsobjektet som appen körs under ha en roll för varje Azure-resurs som appen använder som gör att den kan utföra åtgärderna på den resurs som appen kräver. I den här självstudien använder du Azure CLI-kommandon för att skapa en användartilldelad hanterad identitet och tilldela den till din app i Azure. Sedan tilldelar du identiteten lämpliga roller manuellt på ditt Azure Storage-konto och Azure Database for PostgreSQL-server. Slutligen anger AZURE_CLIENT_ID du miljövariabeln för din app i Azure för att konfigurera DefaultAzureCredential att använda den hanterade identiteten.

När den användartilldelade hanterade identiteten har konfigurerats på din app och dess körningsmiljö, och har tilldelats lämpliga roller på datalagringarna, kan du använda DefaultAzureCredential för att autentisera med de nödvändiga Azure-resurserna.

Följande kod används för att skapa en bloblagringsklient för att ladda upp foton i ./restaurant_review/views.py. ** En instans av DefaultAzureCredential levereras till klienten, som den använder för att hämta åtkomsttoken för att utföra åtgärder på Azure-lagring.

from azure.identity import DefaultAzureCredential
from azure.storage.blob import BlobServiceClient

azure_credential = DefaultAzureCredential()
blob_service_client = BlobServiceClient(
    account_url=account_url,
    credential=azure_credential)

En instans av DefaultAzureCredential används också för att hämta en åtkomsttoken för Azure Database för PostgreSQL i ./azureproject/get_conn.py. I det här fallet hämtas token direkt genom att anropa get_token på autentiseringsinstansen och passera rätt värde. Token används sedan för att ange lösenordet i PostgreSQL-anslutnings-URI:n.

azure_credential = DefaultAzureCredential()
token = azure_credential.get_token("https://ossrdbms-aad.database.windows.net")
conf.settings.DATABASES['default']['PASSWORD'] = token.token

För mer information om hur du autentiserar dina appar med Azure-tjänster, se Autentisera Python-appar till Azure-tjänster med hjälp av Azure SDK för Python. För att lära dig mer om DefaultAzureCredential, inklusive hur du anpassar autentiseringskedjan som utvärderas för din miljö, se Översikt över DefaultAzureCredential.

Skapa en flexibel Azure PostgreSQL-server

1. Konfigurera de miljövariabler som behövs för handledningen.

   LOCATION="eastus"
   RAND_ID=$RANDOM
   RESOURCE_GROUP_NAME="msdocs-mi-web-app"
   APP_SERVICE_NAME="msdocs-mi-web-$RAND_ID"
   DB_SERVER_NAME="msdocs-mi-postgres-$RAND_ID"
   ADMIN_USER="demoadmin"
   ADMIN_PW="ChAnG33#ThsPssWD$RAND_ID"
   UA_NAME="UAManagedIdentityPythonTest$RAND_ID"
   

   Viktigt!

   ADMIN_PW måste innehålla mellan 8 och 128 tecken från tre av följande kategorier: engelska versaler, engelska gemener, siffror och icke-alfanumeriska tecken. När du skapar användarnamn eller lösenord, använd inte tecknet $. Du skapar senare miljövariabler med dessa värden där $-tecknet har en speciell betydelse i Linux-containern som används för att köra Pythonprogram.

2. Skapa en resursgrupp med kommandot az group create.

   az group create --location $LOCATION --name $RESOURCE_GROUP_NAME
   

3. Skapa en flexibel PostgreSQL-server med kommandot az postgres flexible-server create. (Detta och efterföljande kommandon använder radfortsättningstecknet för Bash Shell ('\'). Ändra radbrytningstecknet för andra skal.

   az postgres flexible-server create \
     --resource-group $RESOURCE_GROUP_NAME \
     --name $DB_SERVER_NAME \
     --location $LOCATION \
     --admin-user $ADMIN_USER \
     --admin-password $ADMIN_PW \
     --sku-name Standard_D2ds_v4 \
     --active-directory-auth Enabled \
     --public-access 0.0.0.0
   

   sku-name är namnet på prisnivån och datorkonfigurationen. För mer information, se Prissättning för Azure Database for PostgreSQL. För att lista tillgängliga SKU:er, använd az postgres flexible-server list-skus --location $LOCATION.

4. Lägg till ditt Azure-konto som Microsoft Entra-administratör för servern med kommandot az postgres flexible-server ad-admin create.

   ACCOUNT_EMAIL=$(az ad signed-in-user show --query userPrincipalName --output tsv)
   ACCOUNT_ID=$(az ad signed-in-user show --query id --output tsv)
   echo $ACCOUNT_EMAIL, $ACCOUNT_ID
   az postgres flexible-server ad-admin create \
     --resource-group $RESOURCE_GROUP_NAME \
     --server-name $DB_SERVER_NAME \
     --display-name $ACCOUNT_EMAIL \
     --object-id $ACCOUNT_ID \
     --type User
   

5. Konfigurera en brandväggsregel på din server med kommandot az postgres flexible-server firewall-rule create. Den här regeln tillåter din lokala miljö att ansluta till servern. (Om du använder Azure Cloud Shell kan du hoppa över det här steget.)

   IP_ADDRESS=<your IP>
   az postgres flexible-server firewall-rule create \
      --resource-group $RESOURCE_GROUP_NAME \
      --name $DB_SERVER_NAME \
      --rule-name AllowMyIP \
      --start-ip-address $IP_ADDRESS \
      --end-ip-address $IP_ADDRESS
   

   Använd valfritt verktyg eller webbplats som visar din IP-adress för att ersätta <your IP> i kommandot. Till exempel kan du använda webbplatsen "What's My IP Address?".

6. Skapa en databas med namnet restaurant med kommandot az postgres flexible-server execute.

   az postgres flexible-server execute \
     --name $DB_SERVER_NAME \
     --admin-user $ADMIN_USER \
     --admin-password $ADMIN_PW \
     --database-name postgres \
     --querytext 'create database restaurant;'
   

Skapa en Azure App Service och distribuera koden

Kör dessa kommandon i rotmappen i exempelappen för att skapa en App Service och distribuera koden till den.

1. Skapa en apptjänst med kommandot az webapp up.

   az webapp up \
     --resource-group $RESOURCE_GROUP_NAME \
     --location $LOCATION \
     --name $APP_SERVICE_NAME \
     --runtime PYTHON:3.9 \
     --sku B1
   

   sku definierar storleken (CPU, minne) och kostnaden för appservice-planen. B1-tjänstplanen (Basic) medför en liten kostnad i din Azure-prenumeration. För en fullständig lista över App Service-planer, visa prissättningssidan för App Service.

2. Konfigurera App Service för att använda start.sh i exempelrepo med kommandot az webapp config set.

   az webapp config set \
     --resource-group $RESOURCE_GROUP_NAME \
     --name $APP_SERVICE_NAME \
     --startup-file "start.sh"
   

Skapa ett lagringskonto och en container

Exempelappen lagrar foton som skickas av granskare som blobar i Azure Storage.

• När en användare skickar ett foto med sin recension skriver appen bilden i containern med hjälp av hanterad identitet och DefaultAzureCredential för att få åtkomst till lagringskontot.

• När en användare visar recensionerna för en restaurang returnerar appen en länk till fotot i Blob Storage för varje granskning som har en associerad med den. För att webbläsaren ska kunna visa fotot måste det kunna komma åt det i ditt lagringskonto. Blobdata måste vara tillgängliga för att kunna läsas offentligt via anonym (oautentiserad) åtkomst.

I det här avsnittet skapar du ett lagringskonto och en container som tillåter offentlig läsåtkomst till blobar i containern. I senare avsnitt skapar du en användartilldelad hanterad identitet och konfigurerar den för att skriva blobar till lagringskontot.

1. Använd kommandot az storage create för att skapa ett lagringskonto.

   STORAGE_ACCOUNT_NAME="msdocsstorage$RAND_ID"
   az storage account create \
     --name $STORAGE_ACCOUNT_NAME \
     --resource-group $RESOURCE_GROUP_NAME \
     --location $LOCATION \
     --sku Standard_LRS \
     --allow-blob-public-access true
   

2. Skapa en container kallad photos i lagringskontot med kommandot az storage container create.

   az storage container create \
     --account-name $STORAGE_ACCOUNT_NAME \
     --name photos \
     --public-access blob \
     --auth-mode login
   

   Kommentar

   Om kommandot misslyckas, till exempel om du får ett fel som anger att begäran kan blockeras av nätverksregler för lagringskontot, anger du följande kommando för att se till att ditt Azure-användarkonto har tilldelats en Azure-roll med behörighet att skapa en container.

   az role assignment create --role "Storage Blob Data Contributor" --assignee $ACCOUNT_EMAIL --scope "/subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCE_GROUP_NAME/providers/Microsoft.Storage/storageAccounts/$STORAGE_ACCOUNT_NAME"
   

   För mer information, se Snabbstart: Skapa, ladda ner och lista blobar med Azure CLI. Observera att flera Azure-roller gör att du kan skapa containrar i ett lagringskonto, inklusive "Ägare", "Deltagare", "Storage Blob Data Owner" och "Storage Blob Data Contributor".

Skapa en användartilldelad hanterad identitet

Skapa en användartilldelad hanterad identitet och tilldela den till App Service. Den hanterade identiteten används för att komma åt databasen och lagringskontot.

1. Använd kommandot az identity create för att skapa en användartilldelad hanterad identitet och mata ut klient-ID till en variabel för senare användning.

   UA_CLIENT_ID=$(az identity create --name $UA_NAME --resource-group $RESOURCE_GROUP_NAME --query clientId --output tsv)
   echo $UA_CLIENT_ID
   

2. Använd kommandot az account show för att få ditt prenumerations-ID och mata ut det till en variabel som kan användas för att skapa resurs-ID för den hanterade identiteten.

   SUBSCRIPTION_ID=$(az account show --query id --output tsv)
   RESOURCE_ID="/subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCE_GROUP_NAME/providers/Microsoft.ManagedIdentity/userAssignedIdentities/$UA_NAME"
   echo $RESOURCE_ID
   

3. Tilldela den hanterade identiteten till App Service med kommandot az webapp identity assign.

   export MSYS_NO_PATHCONV=1
   az webapp identity assign \
       --resource-group $RESOURCE_GROUP_NAME \
       --name $APP_SERVICE_NAME \
       --identities $RESOURCE_ID
   

4. Skapa App Service-appinställningar som innehåller klient-ID för den hanterade identiteten och annan konfigurationsinformation med kommandot az webapp config appsettings set.

   az webapp config appsettings set \
     --resource-group $RESOURCE_GROUP_NAME \
     --name $APP_SERVICE_NAME \
     --settings AZURE_CLIENT_ID=$UA_CLIENT_ID \
       STORAGE_ACCOUNT_NAME=$STORAGE_ACCOUNT_NAME \
       STORAGE_CONTAINER_NAME=photos \
       DBHOST=$DB_SERVER_NAME \
       DBNAME=restaurant \
       DBUSER=$UA_NAME
   

Exempelappen använder miljövariabler (appinställningar) för att definiera anslutningsinformation för databasen och lagringskontot, men dessa variabler innehåller inte lösenord. I stället görs autentiseringen utan lösenord med DefaultAzureCredential.

Exempelappkoden använder DefaultAzureCredential-konstruktorn utan att skicka det användartilldelade klient-ID:t för hanterad identitet till konstruktorn. I det här scenariot är fallback-lösningen att söka efter AZURE_CLIENT_ID-miljövariabeln, som du anger som en appinställning.

AZURE_CLIENT_ID Om miljövariabeln inte finns används den systemtilldelade hanterade identiteten om den är konfigurerad. För mer information, se Introducing DefaultAzureCredential.

Skapa roller för den hanterade identiteten

I det här avsnittet skapar du rolltilldelningar för den hanterade identiteten för att ge åtkomst till lagringskontot och databasen.

1. Skapa en rolltilldelning för den hanterade identiteten för att aktivera åtkomst till lagringskontot med kommandot az role assignment create.

   export MSYS_NO_PATHCONV=1
   az role assignment create \
   --assignee $UA_CLIENT_ID \
   --role "Storage Blob Data Contributor" \
   --scope "/subscriptions/$SUBSCRIPTION_ID/resourcegroups/$RESOURCE_GROUP_NAME"
   

   Kommandot anger omfånget för rolltilldelningen till resursgruppen. För mer information, se Förstå rolltilldelningar.

2. Använd kommandot az postgres flexible-server execute för att ansluta till Postgres-databasen och köra samma kommandon för att tilldela roller till den hanterade identiteten.

   ACCOUNT_EMAIL_TOKEN=$(az account get-access-token --resource-type oss-rdbms --output tsv --query accessToken)
   az postgres flexible-server execute \
     --name $DB_SERVER_NAME \
     --admin-user $ACCOUNT_EMAIL \
     --admin-password $ACCOUNT_EMAIL_TOKEN \
     --database-name postgres \
     --querytext "select * from pgaadauth_create_principal('"$UA_NAME"', false, false);select * from pgaadauth_list_principals(false);"
   

   Om du har problem med att köra kommandot kontrollerar du att du har lagt till ditt användarkonto som Microsoft Entra-administratör för PosgreSQL-servern och att du har tillåtit åtkomst till din IP-adress i brandväggsreglerna. Mer information finns i avsnittet Skapa en flexibel Azure PostgreSQL-server.

Testa Python-webbappen i Azure

Python-exempelappen använder azure.identity paketet och dess DefaultAzureCredential klass. När appen körs i Azure, identifierar DefaultAzureCredential automatiskt om det finns en hanterad identitet för App Service, och i så fall använder den identiteten för att komma åt andra Azure-resurser (lagring och PostgreSQL i det här fallet). Du behöver inte ange lagringsnycklar, certifikat eller autentiseringsuppgifter till App Service för att få åtkomst till dessa resurser.

1. Bläddra till det distribuerade programmet på webbadressen http://$APP_SERVICE_NAME.azurewebsites.net.

   Det kan ta en minut eller två innan appen startas. Om du ser en standardappsida som inte är standardexempelappsidan väntar du en minut och uppdaterar webbläsaren.

2. Testa funktionerna i exempelappen genom att lägga till en restaurang och några recensioner med foton för restaurangen.

   Restaurangen och granskningsinformationen lagras i Azure Database for PostgreSQL och fotona lagras i Azure Storage. Här är ett exempel på skärmbild:

   Skärmbild av exempelappen som visar restaurangrecension med hjälp av Azure App Service, Azure PostgreSQL Database och Azure Storage.

Rensa

I den här självstudien skapades alla Azure-resurser i samma resursgrupp. Om du tar bort resursgruppen med kommandot az group delete, tas alla resurser i resursgruppen bort. Detta är det snabbaste sättet att ta bort alla Azure-resurser som används för din app.

az group delete  --name $RESOURCE_GROUP_NAME 

Du kan även lägga till --no-wait argumentet så att kommandot kan returneras innan åtgärden har slutförts.

Nästa steg

• Skapa och distribuera en Flask-webbapp till Azure med en systemtilldelad hanterad identitet.

• Distribuera en Python-webbapp (Django eller Flask) med PostgreSQL i Azure App Service