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

Artikel
09/24/2024

I den här självstudien distribuerar du en Django-webbapp till Azure App Service. Webbappen använder en användartilldelad hanterad identitet (lösenordslösa anslutningar) med rollbaserad åtkomstkontroll i Azure för åtkomst till Azure Storage och Azure Database for PostgreSQL – flexibla serverresurser . Koden använder klassen DefaultAzureCredential i Azure Identity-klientbiblioteket för Python. Klassen DefaultAzureCredential identifierar 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 självstudien skapar du en användartilldelad hanterad identitet och tilldelar den till App Service så att den kan komma åt databas- och lagringskontoresurserna. Ett exempel på hur du använder 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 metodtipsjför att använda hanterade identiteter finns i Rekommenderade metoder för hanterad identitet.

Den här självstudien visar hur du distribuerar Python-webbappen och skapar Azure-resurser med hjälp av Azure CLI. Kommandona i den här självstudien skrivs för att köras i ett Bash-gränssnitt. Du kan köra självstudiekommandona i valfri Bash-miljö med CLI installerat, till exempel 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.

Klona exemplet.

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

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 till båda datalager. Med DefaultAzureCredentialkan appen konfigureras att köras under identiteten för olika tjänsthuvudnamn, beroende på vilken miljö den körs i, utan att göra ändringar i 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 i din app och dess körningsmiljö och tilldelats lämpliga roller i datalager kan du använda DefaultAzureCredential för att autentisera med nödvändiga Azure-resurser.

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 mot Azure Storage.

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 for PostgreSQL i ./azureproject/get_conn.py. I det här fallet hämtas token direkt genom att anropa get_token på autentiseringsuppgiftsinstansen och skicka rätt värde till den scope . 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

Mer information om hur du autentiserar dina appar med Azure-tjänster finns i Autentisera Python-appar till Azure-tjänster med hjälp av Azure SDK för Python. Mer information om DefaultAzureCredential, inklusive hur du anpassar autentiseringskedjan som utvärderas för din miljö, finns i Översikt över DefaultAzureCredential.

Skapa en flexibel Azure PostgreSQL-server

Konfigurera de miljövariabler som behövs för självstudien.
```
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-numeriska tecken. När du skapar användarnamn eller lösenord använder $ du inte tecknet. Senare skapar du miljövariabler med dessa värden där $ tecknet har särskild betydelse i Linux-containern som används för att köra Python-appar.

Skapa en resursgrupp med kommandot az group create.

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

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 radfortsättningstecknet för andra gränssnitt.)
```
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-namnet är namnet på prisnivån och beräkningskonfigurationen. Mer information finns i Priser för Azure Database for PostgreSQL. Om du vill visa en lista över tillgängliga SKU:er använder du az postgres flexible-server list-skus --location $LOCATION.

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

Konfigurera en brandväggsregel på servern med kommandot az postgres flexible-server firewall-rule create . Med den här regeln kan din lokala miljöåtkomst 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 alla verktyg eller webbplatser som visar din IP-adress som ersättning <your IP> i kommandot. Du kan till exempel använda webbplatsen Vad är min IP-adress?

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.

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:n definierar storleken (CPU, minne) och kostnaden för App Service-planen. B1-tjänstplanen (Basic) medför en liten kostnad i din Azure-prenumeration. En fullständig lista över App Service-planer finns på sidan med priser för App Service.

Konfigurera App Service för att använda start.sh i exempeldatabasen 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 granskning skriver exempelappen avbildningen till 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.

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

Skapa en container med namnet foton 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"
```
Mer information finns i Snabbstart: Skapa, ladda ned 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.

Använd kommandot az identity create för att skapa en användartilldelad hanterad identitet och mata ut klient-ID:t 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
```

Använd kommandot az account show för att hämta ditt prenumerations-ID och mata ut det till en variabel som kan användas för att konstruera 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

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

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 lösenordslös med DefaultAzureCredential.

Exempelappkoden använder DefaultAzureCredential klasskonstruktorn utan att skicka det användartilldelade klient-ID:t för hanterad identitet till konstruktorn. I det här scenariot är återställningen 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. Mer information finns i Introduktion till StandardAzureCredential.

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.

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. Mer information finns i Förstå rolltilldelningar.
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 DefaultAzureCredential identifierar automatiskt om det finns en hanterad identitet för App Service och i så fall använder den den 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.

Bläddra till det distribuerade programmet på URL:en 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.
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:

Rensa

I den här självstudien skapades alla Azure-resurser i samma resursgrupp. Om du tar bort resursgruppen tas alla resurser i resursgruppen bort med kommandot az group delete och 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 också lägga till --no-wait argumentet så att kommandot kan returneras innan åtgärden har slutförts.

Dela via