Dela via

Självstudie: Skapa och distribuera en Python-webbapp med Azure Container Apps och PostgreSQL

Den här artikeln är del av en självstudieserie om hur du containeriserar och distribuerar en Python webbapp till Azure Container Apps. Med Container Apps kan du distribuera containerbaserade appar utan att hantera komplex infrastruktur.

I den här handledningen:

  • Containerisera en Python-exempelwebbapp (Django eller Flask) genom att skapa en containeravbildning i molnet.
  • Distribuera containeravbildningen till Azure Container Apps.
  • Definiera miljövariabler som gör att containerappen kan ansluta till en Azure Database for PostgreSQL – flexibel server instans där exempelappen lagrar data.

Följande diagram visar uppgifterna i den här handledningen: bygga och distribuera en containeravbildning.

Diagram över tjänster som ingår i distributionen av en Python-app i Azure Container Apps, där delarna om att skapa en avbildning är markerade manuellt.

Förutsättningar

Om du inte har en Azure-prenumeration skapar du ett kostnadsfritt konto innan du börjar.

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

Om du kör lokalt följer du de här stegen för att logga in och installera de moduler som krävs för den här självstudien:

  1. Logga in på Azure och autentisera om det behövs:

    az login

  2. Kontrollera att du kör den senaste versionen av Azure CLI:

    az upgrade

  3. Installera eller uppgradera containerappen och rdbms-connect Azure CLI-tillägg med hjälp av kommandot az extension add:

    az extension add --name containerapp --upgrade
az extension add --name rdbms-connect --upgrade

    Kommentar

    Om du vill visa en lista över de tillägg som är installerade i systemet kan du använda kommandot az extension list. Till exempel:

    az extension list --query [].name --output tsv

Hämta exempelappen

Förgrena och klona exempelkoden till utvecklarmiljön:

  1. Gå till GitHub-lagringsplatsen för exempelappen (Django eller Flask) och välj Förgrening.

    Följ stegen för att förgrena lagringsplatsen till ditt GitHub-konto. Du kan också ladda ned kodlagringsplatsen direkt till din lokala dator utan förgrening eller ett GitHub-konto. Men om du använder nedladdningsmetoden kan du inte konfigurera kontinuerlig integrering och kontinuerlig leverans (CI/CD) i nästa självstudie i den här serien.

  2. I kommandotolken i konsolen använder du git clone-kommandot för att klona den förgrenade lagringsplatsen till mappen python-container :

    # Django
git clone https://github.com/<github-username>/msdocs-python-django-azure-container-apps.git python-container

# Flask
# git clone https://github.com/<github-username>/msdocs-python-flask-azure-container-apps.git python-container

  3. Ändra katalogen:

    cd python-container

Skapa en containeravbildning från webbappskod

När du har följt de här stegen har du en Azure Container Registry-instans som innehåller en Docker-containeravbildning som skapats från exempelkoden.

  1. Om du kör kommandon i ett Git Bash-gränssnitt på en Windows-dator anger du följande kommando innan du fortsätter:

    #!/bin/bash
export MSYS_NO_PATHCONV=1

  2. Skapa en resursgrupp genom att använda kommandot az group create:

    #!/bin/bash
RESOURCE_GROUP_NAME=<resource-group-name>
LOCATION=<location>
az group create \
    --name $RESOURCE_GROUP_NAME \
    --location $LOCATION

  3. Skapa ett containerregister med hjälp av kommandot az acr create:

    #!/bin/bash
REGISTRY_NAME=<registry-name> #The name that you use for *\<registry-name>* must be unique within Azure, and it must contain 5 to 50 alphanumeric characters.
az acr create \
    --resource-group $RESOURCE_GROUP_NAME \
    --name $REGISTRY_NAME \
    --sku Basic \
    --admin-enabled true

  4. Logga in på registret med kommandot az acr login:

    az acr login --name $REGISTRY_NAME

    Kommandot lägger till "azurecr.io" i namnet för att skapa det fullständigt kvalificerade registernamnet. Om inloggningen lyckas visas meddelandet "Inloggningen lyckades". Om du kommer åt registret från en prenumeration som skiljer sig från den som du skapade registret i använder du växeln --suffix.

    Om inloggningen misslyckas kontrollerar du att Docker-daemonen körs i systemet.

  5. Skapa avbildningen med hjälp av kommandot az acr build:

    #!/bin/bash
az acr build \
    --registry $REGISTRY_NAME \
    --resource-group $RESOURCE_GROUP_NAME \
    --image pythoncontainer:latest .

    Dessa överväganden gäller:

    • Punkten (.) i slutet av kommandot anger platsen för källkoden som ska skapas. Om du inte kör det här kommandot i exempelappens rotkatalog anger du sökvägen till koden.

    • Om du kör kommandot i Azure Cloud Shell använder du git clone för att först hämta lagringsplatsen till Cloud Shell-miljön. Ändra sedan katalogen till projektets rot så att punkten (.) tolkas korrekt.

    • Om du utelämnar -t alternativet (samma som --image) köar kommandot en lokal kontextversion utan att push-överföra den till registret. Att skapa utan push-överföring kan vara användbart för att kontrollera att avbildningen skapas.

  6. Bekräfta att containeravbildningen skapades med hjälp av kommandot az acr repository list.

    az acr repository list --name $REGISTRY_NAME

Kommentar

Stegen i det här avsnittet skapar ett containerregister på basic-tjänstnivån. Den här nivån är kostnadsoptimerad med en funktionsuppsättning och ett dataflöde som är avsett för utvecklarscenarier och är lämplig för kraven i den här självstudien. I produktionsscenarier använder du förmodligen antingen standard- eller Premium-tjänstnivån. Dessa nivåer ger förbättrade nivåer av lagring och dataflöde.

Mer information finns i Azure Container Registry-tjänstnivåer. För mer information om priser, se Azure Container Registry-priser.

Skapa en PostgreSQL– flexibel serverinstans

Exempelappen (Django eller Flask) lagrar granskningsdata för restaurangen i en PostgreSQL-databas. I de här stegen skapar du den server som ska innehålla databasen.

  1. Använd kommandot az postgres flexible-server create för att skapa PostgreSQL-servern i Azure. Det är inte ovanligt att det här kommandot körs i några minuter innan det är klart.

    #!/bin/bash
ADMIN_USERNAME=demoadmin
ADMIN_PASSWORD=<admin-password> # Use a strong password that meets the requirements for PostgreSQL.
POSTGRES_SERVER_NAME=<postgres-server-name> 
az postgres flexible-server create \
  --resource-group $RESOURCE_GROUP_NAME \
  --name $POSTGRES_SERVER_NAME \
  --location $LOCATION \
  --admin-user $ADMIN_USERNAME \
  --admin-password $ADMIN_PASSWORD \
  --version 16 \
  --tier Burstable \
  --sku-name Standard_B1ms \
  --public-access 0.0.0.0 \
  --microsoft-entra-auth Enabled \
  --storage-size 32 \
  --backup-retention 7 \
  --high-availability Disabled \
  --yes

    Använd följande värden:

    • <postgres-server-name>: PostgreSQL-databasservernamnet. Det här namnet måste vara unikt i hela Azure. Serverslutpunkten är https://<postgres-server-name>.postgres.database.azure.com. Tillåtna tecken AZ, 0 till 9och bindestreck (-).

    • <plats>: Använd samma plats som du använde för webbappen. <plats> är ett av Azure-platsens Name värden från resultatet av kommandot az account list-locations -o table.

    • <admin-username>: Användarnamnet för administratörskontot. Det kan inte vara azure_superuser, admin, administrator, root, guesteller public. Använd demoadmin för den här handledningen.

    • <administratörslösenord>: Administratörsanvändarens lösenord. Den 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.

      Viktigt!

      När du skapar användarnamn eller lösenord, använd inte dollartecknet ($). När du senare skapar miljövariabler med dessa värden har det tecknet en särskild betydelse i Den Linux-container som du använder för att köra Python-appar.

    • --version: Använd 16. Den anger vilken PostgreSQL-version som ska användas för servern.

    • --tier: Använd Burstable. Den anger prisnivån för servern. Nivån Burstable är ett billigare alternativ för arbetsbelastningar som inte behöver hela processorn kontinuerligt och som är lämplig för kraven i den här självstudien.

    • --sku-name: Namnet på prisnivån och beräkningskonfigurationen. till exempel Standard_B1ms. Mer information finns i Priser för Azure Database for PostgreSQL. Om du vill visa tillgängliga nivåer använder du az postgres flexible-server list-skus --location <location>.

    • --public-access: Använd 0.0.0.0. Det ger offentlig åtkomst till servern från valfri Azure-tjänst, till exempel Container Apps.

    • --microsoft-entra-auth: Använd Enabled. Det möjliggör Microsoft Entra-autentisering på servern.

    • --storage-size: Använd 32. Den anger lagringsstorleken i gigabyte (GB) för servern. Minst 32 GB.

    • --backup-retention: Använd 7. Den anger antalet dagar för att behålla säkerhetskopior för servern. Minst 7 dagar.

    • --high-availability: Använd Disabled. Den inaktiverar hög tillgänglighet för servern. Hög tillgänglighet krävs inte för den här handledningen.

    • --yes: Den accepterar användningsvillkoren för PostgreSQL-servern.

    Kommentar

    Om du planerar att arbeta med PostgreSQL-servern från din lokala arbetsstation med hjälp av verktyg måste du lägga till en brandväggsregel för arbetsstationens IP-adress med hjälp av kommandot az postgres flexible-server firewall-rule create.

  2. Använd kommandot az ad signed-in-user show för att hämta objekt-ID:t för ditt användarkonto. Du använder det här ID:t i nästa kommando.

    #!/bin/bash
CALLER_OBJECT_ID=$(az ad signed-in-user show --query id -o tsv)
CALLER_DISPLAY_NAME=$(az ad signed-in-user show --query userPrincipalName -o tsv)

  3. Använd kommandot az postgres flexible-server ad-admin create för att lägga till ditt användarkonto som Microsoft Entra-administratör på PostgreSQL-servern:

    #!/bin/bash
az postgres flexible-server microsoft-entra-admin create \
  --server-name "$POSTGRES_SERVER_NAME" \
  --resource-group "$RESOURCE_GROUP_NAME" \
  --display-name "$CALLER_DISPLAY_NAME" \
  --object-id "$CALLER_OBJECT_ID" \
  --type User

  4. Använd kommandot az postgres flexible-server firewall-rule create för att lägga till en regel som tillåter din webbapp att komma åt PostgreSQL-flexibla server. I följande kommando konfigurerar du serverns brandvägg så att den accepterar anslutningar från din utvecklingsarbetsstation med hjälp av din offentliga IP-adress:

    MY_IP=$(curl -s ifconfig.me)
az postgres flexible-server firewall-rule create \
  --name "$POSTGRES_SERVER_NAME" \
  --resource-group "$RESOURCE_GROUP_NAME" \
  --rule-name allow-my-ip \
  --start-ip-address "$MY_IP" \
  --end-ip-address "$MY_IP"
    ```

Kommentar

Stegen i det här avsnittet skapar en PostgreSQL-server med en enda virtuell kärna och begränsat minne på prisnivån Burstable. Nivån Burstable är ett billigare alternativ för arbetsbelastningar som inte behöver hela processorn kontinuerligt och som är lämplig för kraven i den här självstudien. För produktionsbelastningar kan du uppgradera till antingen prisnivån Allmänt bruk eller Minnesoptimerad. Dessa nivåer ger högre prestanda men ökar kostnaderna.

Mer information finns i Beräkningsalternativ i Azure Database for PostgreSQL – flexibel server. Information om priser finns i Prissättning för Azure Database for PostgreSQL.

Skapa en databas på servern

Nu har du en PostgreSQL-server. I det här avsnittet skapar du en databas på servern.

Använd kommandot az postgres flexible-server db create för att skapa en databas med namnet restaurants_reviews:

#!/bin/bash
DATABASE_NAME=restaurants_reviews
az postgres flexible-server db create \
    --resource-group $RESOURCE_GROUP_NAME \
    --server-name $POSTGRES_SERVER_NAME \
    --database-name $DATABASE_NAME

Du kan också använda kommandot az postgres flexible-server connect för att ansluta till databasen och sedan arbeta med psql-kommandon . När du arbetar med psql är det ofta enklare att använda Azure Cloud Shell- eftersom gränssnittet innehåller alla beroenden åt dig.

Du kan också ansluta till den flexibla Servern Azure Database for PostgreSQL och skapa en databas med hjälp av psql eller en IDE som stöder PostgreSQL, till exempel Azure Data Studio. Anvisningar om hur du använder psql finns i Konfigurera den hanterade identiteten på PostgreSQL-databasen senare i den här artikeln.

Skapa en användartilldelad hanterad identitet

Skapa en användartilldelad hanterad identitet som ska användas som identitet för containerappen när den körs i Azure.

Kommentar

För att skapa en användartilldelad hanterad identitet behöver ditt konto hanterad identitetsdeltagare rolltilldelning.

Använd kommandot az identity create för att skapa en användartilldelad hanterad identitet:

UA_MANAGED_IDENTITY_NAME=<managed-identity-name> # Use a unique name for the managed identity, such as-"my-ua-managed-id".
az identity create \
    --name $UA_MANAGED_IDENTITY_NAME 
    --resource-group $RESOURCE_GROUP_NAME

Konfigurera den hanterade identiteten i PostgreSQL-databasen

Konfigurera den hanterade identiteten som en roll på PostgreSQL-servern och ge den sedan nödvändiga behörigheter för restaurants_reviews-databasen. Oavsett om du använder Azure CLI eller psql måste du ansluta till Azure PostgreSQL-servern med en användare som har konfigurerats som Microsoft Entra-administratör på din serverinstans. Endast Microsoft Entra-konton som konfigurerats som PostgreSQL-administratör kan konfigurera hanterade identiteter och andra Microsoft-administratörsroller på servern.

  1. Hämta en åtkomsttoken för ditt Azure-konto med hjälp av kommandot az account get-access-token. Du använder åtkomsttoken i nästa steg.

    #!/bin/bash
MY_ACCESS_TOKEN=$(az account get-access-token --resource-type oss-rdbms --output tsv --query accessToken)
echo $MY_ACCESS_TOKEN

  2. Lägg till den hanterade identiteten tilldelad av användaren som en databasroll på din PostgreSQL-server genom att använda kommandot az postgres flexible-server execute.

    #!/bin/bash
az postgres flexible-server execute \
  --name "$POSTGRES_SERVER_NAME" \
  --admin-user "$CALLER_DISPLAY_NAME" \
  --admin-password "$ACCESS_TOKEN" \
  --database-name postgres \
  --querytext "SELECT * FROM pgaadauth_create_principal('$UA_MANAGED_IDENTITY_NAME', false, false);"

    Kommentar

    Om du kör kommandot az postgres flexible-server execute på den lokala arbetsstationen kontrollerar du att du har lagt till en brandväggsregel för arbetsstationens IP-adress. Du kan lägga till en regel med hjälp av kommandot az postgres flexible-server firewall-rule create. Samma krav finns också för kommandot i nästa steg.

  3. Ge den användartilldelade hanterade identiteten nödvändiga behörigheter för restaurants_reviews-databasen med hjälp av följande kommandot az postgres flexible-server execute:

    #!/bin/bash
SQL_GRANTS=$(cat <<EOF
GRANT CONNECT ON DATABASE $DATABASE_NAME TO "$UA_MANAGED_IDENTITY_NAME";
GRANT USAGE, CREATE ON SCHEMA public TO "$UA_MANAGED_IDENTITY_NAME";
GRANT ALL PRIVILEGES ON ALL TABLES IN SCHEMA public TO "$UA_MANAGED_IDENTITY_NAME";
ALTER DEFAULT PRIVILEGES IN SCHEMA public GRANT SELECT, INSERT, UPDATE, DELETE ON TABLES TO "$UA_MANAGED_IDENTITY_NAME";
EOF
)

az postgres flexible-server execute \
  --name "$POSTGRES_SERVER_NAME" \
  --admin-user "$CALLER_DISPLAY_NAME" \
  --admin-password "$MY_ACCESS_TOKEN" \
  --database-name "$DATABASE_NAME" \
  --querytext "$SQL_GRANTS"

    Det här Azure CLI-kommandot ansluter till restaurants_reviews-databasen på servern och utfärdar följande SQL-kommandon:

    GRANT CONNECT ON DATABASE restaurants_reviews TO "my-ua-managed-id";
GRANT USAGE ON SCHEMA public TO "my-ua-managed-id";
GRANT CREATE ON SCHEMA public TO "my-ua-managed-id";
GRANT ALL PRIVILEGES ON ALL TABLES IN SCHEMA public TO "my-ua-managed-id";
ALTER DEFAULT PRIVILEGES IN SCHEMA public
GRANT SELECT, INSERT, UPDATE, DELETE ON TABLES TO "my-ua-managed-id";

Distribuera webbappen till Container Apps

Container-appar distribueras på Azure Container Apps-miljöer , som utgör en säker gräns. I följande steg skapar du miljön och en container i miljön. Sedan konfigurerar du containern så att webbplatsen visas externt.

De här stegen kräver Azure Container Apps-tillägget containerapp.

  1. Skapa en Container Apps-miljö med hjälp av kommandot az containerapp env create:

    #!/bin/bash
APP_ENV_NAME=<app-env-name> # Use a unique name for the environment, such as "python-container-env".
az containerapp env create \
--name $APP_ENV_NAME \
--resource-group $RESOURCE_GROUP_NAME \
--location $LOCATION

  2. Hämta inloggningsuppgifterna för Azure Container Registry-instansen med hjälp av kommandot az acr credential show:

    #!/bin/bash
REGISTRY_CREDS=$(az acr credential show -n "$REGISTRY_NAME" --query "[username,passwords[0].value]" -o tsv)
REGISTRY_USERNAME=$(echo "$REGISTRY_CREDS" | head -n1)
REGISTRY_PASSWORD=$(echo "$REGISTRY_CREDS" | tail -n1)

    Du använder användarnamnet och ett av de lösenord som returneras från kommandots utdata när du skapar containerappen i steg 5.

  3. Använd kommandot az identity show för att hämta klient-ID och resurs-ID för den användartilldelade hanterade identiteten:

    UA_CLIENT_ID=$(az identity show \
    --name "$UA_MANAGED_IDENTITY_NAME" \
    --resource-group "$RESOURCE_GROUP_NAME" \
    --query clientId -o tsv)
UA_RESOURCE_ID=$(az identity show \
    --name "$UA_MANAGED_IDENTITY_NAME" \
    --resource-group "$RESOURCE_GROUP_NAME" \
    --query id -o tsv)

    Du använder värdet för klient-ID (GUID) och resurs-ID från kommandots utdata när du skapar containerappen i steg 5. Resurs-ID:t har följande formulär: /subscriptions/<subscription-id>/resourcegroups/pythoncontainer-rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/my-ua-managed-id.

  4. Kör följande kommando för att generera ett hemligt nyckelvärde:

    AZURE_SECRET_KEY=$(python -c 'import secrets; print(secrets.token_hex())')

    Du använder värdet för hemlig nyckel för att ange en miljövariabel när du skapar containerappen i steg 5.

    Kommentar

    Kommandot som det här steget visar är för ett Bash-gränssnitt. Beroende på din miljö kan du behöva anropa Python med hjälp av python3. I Windows måste du omsluta kommandot i parametern -c med dubbla citattecken i stället för enkla citattecken. Du kan också behöva anropa Python med hjälp av py eller py -3, beroende på din miljö.

  5. Skapa en containerapp i miljön med hjälp av kommandot az containerapp create:

    az containerapp create \
  --name "$CONTAINER_APP_NAME" \
  --resource-group "$RESOURCE_GROUP_NAME" \
  --environment "$APP_ENV_NAME" \
  --image "$REGISTRY_NAME.azurecr.io/$IMAGE_NAME" \
  --target-port "$TARGET_PORT" \
  --ingress external \
  --registry-server "$REGISTRY_NAME.azurecr.io" \
  --registry-username "$REGISTRY_USERNAME" \
  --registry-password "$REGISTRY_PASSWORD" \
  --user-assigned "$UA_RESOURCE_ID" \
  --env-vars \
      DBHOST="$POSTGRES_SERVER_NAME" \
      DBNAME="$DATABASE_NAME" \
      DBUSER="$UA_MANAGED_IDENTITY_NAME" \
      RUNNING_IN_PRODUCTION=1 \
      AZURE_CLIENT_ID="$UA_CLIENT_ID" \
      AZURE_SECRET_KEY="$AZURE_SECRET_KEY"

  6. För endast Django, migrera och skapa ett databasschema. (I Flask-exempelappen görs den automatiskt och du kan hoppa över det här steget.)

    För att ansluta, använd kommandot az containerapp exec:

        az containerapp exec \
        --name $CONTAINER_APP_NAME \
        --resource-group $RESOURCE_GROUP_NAME

    I kommandotolken för gränssnittet anger du sedan python manage.py migrate.

    Du behöver inte migrera för revisioner av containern.

  7. Testa webbplatsen.

    Det az containerapp create kommando som du angav tidigare matar ut en program-URL som du kan använda för att bläddra till appen. URL:en slutar i azurecontainerapps.io. Gå till URL:en i en webbläsare. Du kan också använda kommandot az containerapp browse .

Här är ett exempel på exempelwebbplatsen efter att en restaurang har lagts till och två recensioner har lagts till.

Skärmbild av exempelwebbplatsen som skapats i den här självstudien.

Felsöka distribution

Du har glömt program-URL:en för att komma åt webbplatsen

I Azure-portalen:

  • Gå till sidan Översikt i containerappen och leta efter applikations-URL.

I VS Code:

  1. Gå till Azure-vyn (Ctrl+Skift+A) och expandera prenumerationen som du arbetar i.
  2. Expandera noden Container Apps, expandera den hanterade miljön, högerklicka python-container-appoch välj sedan Bläddra. VS Code öppnar webbläsaren med programmets URL.

I Azure CLI:n:

  • Använd kommandot az containerapp show -g pythoncontainer-rg -n python-container-app --query properties.configuration.ingress.fqdn.

I VS Code returnerar uppgiften Skapa avbildning i Azure ett fel

Om du ser meddelandet "Fel: det gick inte att ladda ned kontexten. Kontrollera om URL:en är felaktig i fönstret VS Code Output och uppdatera registret i Docker-tillägget. Om du vill uppdatera väljer du Docker-tillägget, går till avsnittet Registries, letar upp registret och väljer det.

Om du kör Build Image i Azure uppgift igen kontrollerar du om registret från en tidigare körning finns. I så fall använder du den.

I Azure-portalen visas ett åtkomstfel när en containerapp skapas

Ett åtkomstfel som innehåller "Det går inte att komma åt ACR "<namn>.azurecr.io" inträffar när administratörsautentiseringsuppgifter för en Azure Container Registry-instans inaktiveras.

Om du vill kontrollera administratörsstatusen i portalen går du till din Azure Container Registry-instans, väljer åtkomstnycklar resurs och kontrollerar att administratörsanvändare är aktiverad.

Containeravbildningen visas inte i Azure Container Registry-instansen

  • Kontrollera utdata från Azure CLI-kommandot eller VS Code-utdata och leta efter meddelanden för att bekräfta att det har lyckats.
  • Kontrollera att namnet på registret har angetts korrekt i byggkommandot med Azure CLI eller i uppgiftsprompterna för VS Code.
  • Kontrollera att dina autentiseringsuppgifter inte har upphört att gälla. I VS Code hittar du till exempel målregistret i Docker-tillägget och uppdaterar. Kör az logini Azure CLI.

Webbplatsen returnerar "Felaktig begäran (400)"

Om du får felet "Felaktig begäran (400)" kontrollerar du de PostgreSQL-miljövariabler som skickas till containern. 400-felet anger ofta att Python-koden inte kan ansluta till PostgreSQL-instansen.

Exempelkoden som används i den här självstudien söker efter förekomsten av containermiljövariabeln RUNNING_IN_PRODUCTION, som kan anges till valfritt värde (till exempel 1).

Webbplatsen returnerar "Hittades inte (404)"

  • Kontrollera värdet för applikations-URL på sidan Översikt för containern. Om program-URL:en innehåller ordet "intern" är ingressen inte korrekt inställd.
  • Kontrollera containerns ingress. I Azure-portalen går du till exempel till ingress- resursen för containern. Kontrollera att HTTP-ingress är aktiverad och att alternativet acceptera trafik från alla håll har valts.

Webbplatsen startar inte, du får "stream timeout" eller så returneras ingenting

  • Kontrollera loggarna:
    • I Azure-portalen går du till containerappens revisionshanteringsresurs och kontrollerar Etableringsstatus för containern:
      • Om statusen är Etablering, vänta tills etableringen har slutförts.
      • Om statusen är Misslyckadesväljer du revisionen och visar konsolloggarna. Välj ordningen på kolumnerna för att visa Tid genererad, Stream_soch Log_s. Sortera loggarna efter de senaste och leta efter Python-stderr och stdout meddelanden i kolumnen Stream_s. Python-print genererar stdout meddelanden.
    • I Azure CLI använder du kommandot az containerapp logs show.
  • Om du använder Django-ramverket kontrollerar du om det finns restaurants_reviews tabeller i databasen. Om inte använder du en konsol för att komma åt containern och köra python manage.py migrate.

Gå vidare

Konfigurera kontinuerlig distribution för en Python-webbapp i Azure Container Apps