Condividi tramite

Esercitazione: Compilare e distribuire un'app Web Python con App Azure Container e PostgreSQL

Questo articolo fa parte di una serie di esercitazioni su come inserire e distribuire un'app Web Python in App Azure Container. App contenitore consente di distribuire app in contenitori senza gestire un'infrastruttura complessa.

In questa esercitazione:

  • Containerizzare un'app Web di esempio Python (Django o Flask) costruendo un'immagine container nel cloud.
  • Distribuire l'immagine del contenitore su Azure Container Apps.
  • Definire le variabili di ambiente che consentono all'app contenitore di connettersi a un 'istanza di Database di Azure per PostgreSQL - Server flessibile, in cui l'app di esempio archivia i dati.

Il diagramma seguente illustra le attività di questa esercitazione: creazione e distribuzione di un'immagine del container.

Diagramma dei servizi coinvolti nella distribuzione di un'app Python nelle app Azure Container, con le parti relative alla creazione di un'immagine evidenziata manualmente.

Prerequisiti

Se non hai una sottoscrizione di Azure, crea un account gratuito prima di iniziare.

È possibile eseguire i comandi di Azure CLI in Azure Cloud Shell o su una workstation con Azure CLI installata.

Se si esegue localmente, seguire questa procedura per accedere e installare i moduli necessari per questa esercitazione:

  1. Accedere ad Azure ed eseguire l'autenticazione, se necessario:

    az login

  2. Assicurarsi di eseguire la versione più recente dell'interfaccia della riga di comando di Azure:

    az upgrade

  3. Installare o aggiornare le estensioni containerapp e rdbms-connect dell'interfaccia della riga di comando di Azure usando il comando az extension add:

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

    Nota

    Per elencare le estensioni installate nel sistema, è possibile usare il comando az extension list. Per esempio:

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

Ottenere l'app di esempio

Forka e clona il codice di esempio nel tuo ambiente di sviluppo.

  1. Passare al repository GitHub dell'app di esempio (Django o Flask) e selezionare Fork.

    Seguire i passaggi per fare il fork del repository nel tuo account GitHub. È anche possibile scaricare il repository del codice direttamente nel computer locale senza creare fork o un account GitHub. Tuttavia, se si usa il metodo del download, non sarà possibile configurare l'integrazione continua e la consegna continua (CI/CD) nel tutorial successivo di questa serie.

  2. Nel prompt dei comandi della console, usa il comando git clone per clonare il repository forkato nella cartella 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. Cambia la directory:

    cd python-container

Creare un'immagine del contenitore dal codice dell'app Web

Dopo aver seguito questa procedura, si avrà un'istanza di Registro Azure Container che contiene un'immagine del contenitore Docker compilata dal codice di esempio.

  1. Se si eseguono comandi in una shell Git Bash in un computer Windows, immettere il comando seguente prima di procedere:

    #!/bin/bash
export MSYS_NO_PATHCONV=1

  2. Creare un gruppo di risorse usando il comando az group create :

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

  3. Creare un registro di container utilizzando il comando 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. Accedere al registro utilizzando il comando az acr login:

    az acr login --name $REGISTRY_NAME

    Il comando aggiunge "azurecr.io" al nome per creare il nome completo del Registro di sistema. Se l'accesso ha esito positivo, viene visualizzato il messaggio "Login Succeeded". Se si accede al Registro di sistema da una sottoscrizione diversa da quella in cui è stato creato il Registro di sistema, usare l'opzione --suffix.

    Se l'accesso non riesce, verificare che il daemon Docker sia in esecuzione nel sistema.

  5. Creare l'immagine usando il comando az acr build:

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

    Queste considerazioni si applicano:

    • Il punto (.) alla fine del comando indica il percorso del codice sorgente da compilare. Se non esegui questo comando nella directory radice dell'app di esempio, specifica il percorso del codice.

    • Se si esegue il comando in Azure Cloud Shell, usare git clone per eseguire prima il pull del repository nell'ambiente Cloud Shell. Quindi, cambia la directory alla radice del progetto così che il punto (.) venga interpretato correttamente.

    • Se si esce dall'opzione -t (uguale --imagea ), il comando accoda una compilazione di contesto locale senza eseguirne il push nel Registro di sistema. La compilazione senza push può essere utile per verificare che l'immagine venga compilata.

  6. Verificare che l'immagine del container sia stata creata utilizzando il comando az acr repository list:

    az acr repository list --name $REGISTRY_NAME

Nota

I passaggi descritti in questa sezione creano un registro contenitori nel livello di servizio Basic. Questo livello è ottimizzato per i costi, con un set di funzionalità e prestazioni destinati agli scenari di sviluppo ed è adatto ai requisiti di questo tutorial. Negli scenari di produzione è probabile che si usi il livello di servizio Standard o Premium. Questi livelli offrono livelli migliorati di archiviazione e velocità effettiva.

Per altre informazioni, vedere livelli di servizio di Registro Azure Container. Per informazioni sui prezzi, vedere prezzi di Azure Container Registry.

Creare un'istanza del server flessibile PostgreSQL

L'app di esempio (Django o Flask) archivia i dati delle revisioni dei ristoranti in un database PostgreSQL. In questi passaggi viene creato il server che conterrà il database.

  1. Usare il comando az postgres flexible-server create per creare il server PostgreSQL in Azure. Non è insolito che questo comando venga eseguito per alcuni minuti prima che venga completato.

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

    Usare questi valori:

    • <postgres-server-name>: nome del server di database PostgreSQL. Questo nome deve essere univoco in tutto Azure. L'endpoint server è https://<postgres-server-name>.postgres.database.azure.com. I caratteri consentiti sono A a Z, 0 a 9e trattino (-).

    • <posizione>: Usare la stessa posizione dell'app Web. <posizione> è uno dei valori Name della posizione di Azure dall'output del comando az account list-locations -o table.

    • < > nome utente amministratore: nome utente per l'account amministratore. Non può essere azure_superuser, admin, administrator, root, guesto public. Usare demoadmin per questa esercitazione.

    • < > : la password dell'utente amministratore. Deve contenere da 8 a 128 caratteri di tre delle categorie seguenti: lettere maiuscole, lettere minuscole, numeri e caratteri non alfanumerici.

      Importante

      Quando si creano nomi utente o password, non usare il simbolo di dollaro ($). Successivamente, quando si creano variabili di ambiente con questi valori, tale carattere ha un significato speciale all'interno del contenitore Linux usato per eseguire app Python.

    • --version: Usare 16. Specifica la versione di PostgreSQL da usare per il server.

    • --tier: Usare Burstable. Specifica il piano tariffario per il server. Il livello Burstable è un'opzione a basso costo per i carichi di lavoro che non richiedono continuamente l'intera CPU ed è adatto ai requisiti di questo tutorial.

    • --sku-name: nome del piano tariffario e della configurazione di calcolo; ad esempio, Standard_B1ms. Per altre informazioni, vedere Piano tariffario di Database di Azure per PostgreSQL. Per elencare i livelli disponibili, usare az postgres flexible-server list-skus --location <location>.

    • --public-access: Usare 0.0.0.0. Consente l'accesso pubblico al server da qualsiasi servizio di Azure, ad esempio App contenitore.

    • --microsoft-entra-auth: Usare Enabled. Abilita l'autenticazione di Microsoft Entra nel server.

    • --storage-size: Usare 32. Specifica le dimensioni di archiviazione in gigabyte (GB) per il server. Il valore minimo è 32 GB.

    • --backup-retention: Usare 7. Specifica il numero di giorni per conservare i backup per il server. Il valore minimo è 7 giorni.

    • --high-availability: Usare Disabled. Disabilita la disponibilità elevata per il server. La disponibilità elevata non è necessaria per questa esercitazione.

    • --yes: accetta le condizioni per l'utilizzo per il server PostgreSQL.

    Nota

    Se si prevede di utilizzare il server PostgreSQL dalla workstation locale usando degli strumenti, è necessario aggiungere una regola del firewall per l'indirizzo IP della workstation utilizzando il comando az postgres flexible-server firewall-rule create.

  2. Utilizzare il comando az ad signed-in-user show per ottenere l'ID oggetto del tuo account utente. Questo ID viene usato nel comando successivo.

    #!/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. Usare il comando az postgres flexible-server ad-admin create per aggiungere il tuo account utente come amministratore di Microsoft Entra sul server PostgreSQL.

    #!/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. Usare il comando az postgres flexible-server firewall-rule create per aggiungere una regola che consenta all'app Web di accedere al server flessibile PostgreSQL. Nel comando seguente si configura il firewall del server per accettare le connessioni dalla workstation di sviluppo usando l'indirizzo IP pubblico:

    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"
    ```

Nota

I passaggi descritti in questa sezione creano un server PostgreSQL con un singolo vCore e una memoria limitata nel piano tariffario Burstable. Il livello Burstable è un'opzione a basso costo per i carichi di lavoro che non richiedono continuamente l'intera CPU ed è adatto ai requisiti di questo tutorial. Per i carichi di lavoro di produzione, è possibile eseguire l'aggiornamento al piano tariffario Utilizzo generico o Ottimizzato per la memoria. Questi livelli offrono prestazioni più elevate, ma aumentano i costi.

Per ulteriori informazioni, vedere Opzioni di calcolo in Azure Database per PostgreSQL - Server Flessibile. Per informazioni sui prezzi, vedere prezzi di Azure Database per PostgreSQL.

Creare un database nel server

A questo punto, si dispone di un server PostgreSQL. In questa sezione viene creato un database nel server.

Usare il comando az postgres flexible-server db create per creare un database denominato 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

È anche possibile usare il comando az postgres flexible-server connect per connettersi al database e quindi usare i comandi psql . Quando si usa psql, è spesso più facile usare Azure Cloud Shell perché la shell include tutte le dipendenze necessarie.

È anche possibile connettersi al server flessibile di Database di Azure per PostgreSQL e creare un database usando psql o un IDE che supporta PostgreSQL, ad esempio Azure Data Studio. Per la procedura con psql, vedere Configurare l'identità gestita nel database PostgreSQL più avanti in questo articolo.

Creare un'identità gestita assegnata dall'utente

Creare un'identità gestita assegnata dall'utente da usare come identità per l'app contenitore quando è in esecuzione in Azure.

Nota

Per creare un'identità gestita assegnata dall'utente, l'account necessita dell'assegnazione di ruolo Contributore di identità gestita.

Usare il comando az identity create per creare un'identità gestita assegnata all'utente.

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

Configurare l'identità gestita nel database PostgreSQL

Configurare l'identità gestita come ruolo nel server PostgreSQL e quindi concedere le autorizzazioni necessarie per il database restaurants_reviews. Che si usi Azure CLI o psql, è necessario connettersi al server PostgreSQL di Azure con un utente configurato come amministratore di Microsoft Entra nell'istanza del server. Solo gli account Microsoft Entra configurati come amministratore postgreSQL possono configurare identità gestite e altri ruoli di amministratore Microsoft nel server.

  1. Ottenere un token di accesso per l'account Azure usando il comando az account get-access-token. Il token di accesso viene usato nei passaggi successivi.

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

  2. Aggiungere l'identità gestita assegnata dall'utente come ruolo di database sul server PostgreSQL usando il comando 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);"

    Nota

    Assicurati di eseguire il comando az postgres flexible-server execute sulla tua workstation locale e verifica di aver aggiunto una regola del firewall per l'indirizzo IP della tua workstation. È possibile aggiungere una regola utilizzando il comando az postgres flexible-server firewall-rule create. Lo stesso requisito esiste anche per il comando nel passaggio successivo.

  3. Concedere le autorizzazioni necessarie all'identità gestita assegnata dall'utente per il database restaurants_reviews usando il seguente comando 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"

    Questo comando dell'interfaccia della riga di comando di Azure si connette al database restaurants_reviews nel server ed esegue i comandi SQL seguenti:

    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";

Distribuire l'app Web in App contenitore

Le app contenitore vengono distribuite negli ambienti di *Azure Container Apps* , che rappresentano un confine sicuro. Nei passaggi seguenti si creano l'ambiente e un contenitore all'interno dell'ambiente. Si configura quindi il contenitore in modo che il sito Web sia visibile esternamente.

Questi passaggi richiedono l'estensione Azure Container Apps, containerapp.

  1. Creare un ambiente per Container Apps usando il comando 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. Ottenere le credenziali di accesso per l'istanza di Azure Container Registry usando il comando 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)

    Si usa il nome utente e una delle password restituite dall'output del comando quando si crea l'applicazione container nel passaggio 5.

  3. Usare il comando az identity show per ottenere l'ID client e l'ID risorsa dell'identità gestita assegnata dall'utente.

    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)

    Si utilizza il valore dell'ID client (GUID) e l'ID risorsa dell'output del comando, quando si crea l'applicazione contenitore nel passaggio 5. L'ID risorsa ha il formato seguente: /subscriptions/<subscription-id>/resourcegroups/pythoncontainer-rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/my-ua-managed-id.

  4. Eseguire il comando seguente per generare un valore di chiave privata:

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

    Si usa il valore della chiave segreta per impostare una variabile di ambiente quando si crea l'app contenitore nel passaggio 5.

    Nota

    Il comando illustrato in questo passaggio è relativo a una shell Bash. A seconda dell'ambiente, potrebbe essere necessario richiamare Python usando python3. In Windows è necessario racchiudere il comando nel parametro -c tra virgolette doppie anziché virgolette singole. Potrebbe anche essere necessario richiamare Python usando py o py -3, a seconda dell'ambiente.

  5. Creare un'applicazione contenitore nell'ambiente utilizzando il comando 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. Solo per Django, eseguire la migrazione e creare uno schema di database. Nell'app di esempio Flask viene eseguita automaticamente ed è possibile ignorare questo passaggio.

    Connettersi utilizzando il comando az containerapp exec:

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

    Al prompt dei comandi della shell immettere quindi python manage.py migrate.

    Non è necessario eseguire la migrazione per le revisioni del contenitore.

  7. Testare il sito Web.

    Il comando az containerapp create immesso in precedenza restituisce un URL dell'applicazione che è possibile usare per passare all'app. L'URL termina in azurecontainerapps.io. Vai all'URL nel browser. In alternativa, è possibile usare il comando az containerapp browse .

Ecco un esempio del sito web di esempio dopo l'aggiunta di un ristorante e due recensioni.

Screenshot del sito Web di esempio costruito in questo tutorial.

Risolvere i problemi di distribuzione

L'URL dell'applicazione è stata dimenticata per l'accesso al sito Web

Nel portale di Azure:

  • Passare alla pagina Panoramica dell'app contenitore e cercare URL dell'applicazione.

In VS Code:

  1. Passare alla visualizzazione di Azure (Ctrl+Shift+A) ed espandere la sottoscrizione su cui stai lavorando.
  2. Espandere il nodo Container Apps, espandere l'ambiente gestito, fare clic con il pulsante destro del mouse sul nodo python-container-appe quindi selezionare Sfoglia. VS Code apre il browser con l'URL dell'applicazione.

Nell'interfaccia della riga di comando di Azure:

  • Usare il comando az containerapp show -g pythoncontainer-rg -n python-container-app --query properties.configuration.ingress.fqdn.

In VS Code l'attività Compila immagine in Azure restituisce un errore

Se viene visualizzato il messaggio "Errore: impossibile scaricare il contesto. "Controllare se l'URL è errato nella finestra di output di VS Code , quindi aggiornare il registro nell'estensione Docker." Per aggiornare, selezionare l'estensione Docker, passare alla sezione registri, individuare il registro e selezionarlo.

Se esegui di nuovo l'attività Build Image in Azure, verifica se il registro di una precedente esecuzione esiste. In tal caso, usalo.

Nel portale di Azure viene visualizzato un errore di accesso durante la creazione di un'app contenitore

Un errore di accesso che contiene "Impossibile accedere al nome<del Registro Azure Container>.azurecr.io" si verifica quando le credenziali di amministratore in un'istanza di Registro Azure Container sono disabilitate.

Per controllare lo stato di amministratore nel portale, vai all'istanza di Azure Container Registry, seleziona la risorsa chiavi di accesso e assicurati che l'utente amministratore Admin sia abilitato.

L'immagine del contenitore non viene visualizzata nell'istanza di Registro Azure Container

  • Controllare l'output di Azure CLI o di Visual Studio Code e cercare messaggi per confermare il successo.
  • Verificare che il nome del Registro di sistema sia stato specificato correttamente nel comando di compilazione con l'interfaccia della riga di comando di Azure o nei prompt delle attività di VS Code.
  • Assicurarsi che le credenziali non siano scadute. Ad esempio, in VS Code trovare il Registro di sistema di destinazione nell'estensione Docker e aggiornare. Nell'interfaccia della riga di comando di Azure, eseguire az login.

Il sito Web restituisce "Richiesta non valida (400)"

Se viene visualizzato un errore "Richiesta non valida (400)", controllare le variabili di ambiente PostgreSQL passate al contenitore. L'errore 400 indica spesso che il codice Python non è in grado di connettersi all'istanza di PostgreSQL.

Il codice di esempio usato in questa esercitazione verifica l'esistenza della variabile di ambiente del contenitore RUNNING_IN_PRODUCTION, che può essere impostata su qualsiasi valore ( ad esempio 1).

Il sito Web restituisce "Non trovato (404)"

  • Controllare il valore url applicazione nella pagina Panoramica del contenitore. Se l'URL dell'applicazione contiene la parola "internal", l'ingresso non è impostato correttamente.
  • Controllare l'ingresso del contenitore. Ad esempio, nel portale di Azure, vai alla risorsa Ingress del contenitore. Assicurarsi che Ingresso HTTP sia abilitato e che l'opzione Accetta traffico da qualsiasi origine sia selezionata.

Il sito web non si avvia, viene visualizzato un "timeout del flusso" o non viene restituito nulla.

  • Controllare i registri:
    • Nel portale di Azure passare alla risorsa di gestione delle revisioni dell'app contenitore e controllare Stato del provisioning per il contenitore:
      • Se lo stato è provisioning, attendere il completamento del provisioning.
      • Se lo stato è Non riuscito, selezionare la revisione e visualizzare i log della console. Scegli l'ordine delle colonne da visualizzare: Time Generated, Stream_se Log_s. Ordinare i log in base ai più recenti e cercare i messaggi di Python e nella colonna Stream_s del flusso . L'output di Python print è di stdout messaggi.
    • Nell'interfaccia CLI di Azure, utilizzare il comando az containerapp logs show.
  • Se si usa il framework Django, verificare se le tabelle restaurants_reviews esistono nel database. In caso contrario, usare una console per accedere al contenitore ed eseguire python manage.py migrate.

Passaggio successivo

Configurare la distribuzione continua per un'app Web Python in Azure Container Apps

  • Last updated on