Compartilhar via

Tutorial: Criar e implantar um aplicativo Web Python com Os Aplicativos de Contêiner do Azure e o PostgreSQL

Este artigo faz parte de uma série de tutoriais sobre como containerizar e implantar um aplicativo web Python nos aplicativos de contêiner do Azure. Os Aplicativos de Contêiner do Azure permitem que você implemente aplicativos em contêineres sem gerenciar infraestruturas complexas.

Neste tutorial, você:

  • Conteinerize um aplicativo Web de exemplo do Python (Django ou Flask) criando uma imagem de contêiner na nuvem.
  • Implante a imagem de contêiner nos Aplicativos de Contêiner do Azure.
  • Defina variáveis de ambiente que permitem que o aplicativo de contêiner se conecte a uma instância Banco de Dados do Azure para PostgreSQL – Servidor Flexível, em que o aplicativo de exemplo armazena dados.

O diagrama a seguir realça as tarefas neste tutorial: compilar e implantar uma imagem de contêiner.

Diagrama de serviços envolvidos na implantação de um aplicativo Python em Aplicativos de Contêiner do Azure, com as partes sobre a criação de uma imagem realçadas manualmente.

Pré-requisitos

Se você não tiver uma assinatura do Azure, crie uma conta gratuita antes de começar.

Você pode executar comandos da CLI do Azure no do Azure Cloud Shell ou em uma estação de trabalho com o CLI do Azure instalado.

Se você estiver executando localmente, siga estas etapas para entrar e instalar os módulos necessários para este tutorial:

  1. Entre no Azure e autentique-se, se necessário:

    az login

  2. Verifique se você está executando a versão mais recente da CLI do Azure:

    az upgrade

  3. Instale ou atualize as extensões de containerapp e rdbms-connect da CLI do Azure usando o comando az extension add:

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

    Observação

    Para listar as extensões instaladas em seu sistema, você pode usar o comando az extension list. Por exemplo:

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

Obter o aplicativo de exemplo

Bifurque e clone o código de exemplo em seu ambiente de desenvolvedor:

  1. Vá para o repositório GitHub do aplicativo de exemplo (Django ou Flask) e selecione Bifurcar.

    Siga as etapas para bifurcar o repositório para sua conta do GitHub. Você também pode baixar o repositório de código diretamente para seu computador local sem fazer um fork e sem precisar de uma conta no GitHub. Porém, se você usar o método de download, não poderá configurar a CI/CD (integração contínua e entrega contínua) no próximo tutorial desta série.

  2. No prompt de comando no console, use o comando git clone para clonar o repositório bifurcado na pasta 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. Altere o diretório:

    cd python-container

Criar uma imagem de contêiner a partir do código do aplicativo Web

Depois de seguir estas etapas, você terá uma instância do Registro de Contêiner do Azure que contém uma imagem de contêiner do Docker criada a partir do código de exemplo.

  1. Se você estiver executando comandos em um shell do Git Bash em um computador Windows, insira o seguinte comando antes de prosseguir:

    #!/bin/bash
export MSYS_NO_PATHCONV=1

  2. Crie um grupo de recursos usando o comando az group create:

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

  3. Crie um registro de contêiner usando o 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. Entre no Registro usando o comando az acr login:

    az acr login --name $REGISTRY_NAME

    O comando adiciona "azurecr.io" ao nome para criar o nome do Registro totalmente qualificado. Se a entrada for bem-sucedida, a mensagem "Login Bem-sucedido" aparecerá. Se você estiver acessando o registro de uma assinatura diferente daquela em que criou o registro, use a opção --suffix.

    Se a entrada falhar, verifique se o daemon do Docker está em execução em seu sistema.

  5. Crie a imagem usando o comando az acr build:

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

    Estas considerações se aplicam:

    • O ponto (.) no final do comando indica o local do código-fonte a ser compilado. Se você não estiver executando esse comando no diretório raiz do aplicativo de exemplo, especifique o caminho para o código.

    • Se você estiver executando o comando no Azure Cloud Shell, use git clone para primeiro efetuar pull do repositório para o ambiente do Cloud Shell. Em seguida, altere o diretório para a raiz do projeto para que o ponto (.) seja interpretado corretamente.

    • Se você deixar de fora a opção (igual a -t--image), o comando enfileira uma compilação de contexto local sem enviá-la para o registro. Construir sem empurrar pode ser útil para verificar se a imagem é construída.

  6. Confirme se a imagem de container foi criada usando o comando az acr repository list:

    az acr repository list --name $REGISTRY_NAME

Observação

As etapas nesta seção criam um registro de contêiner na camada de serviço Básica. Essa camada é otimizada em termos de custo, com um conjunto de recursos e uma taxa de transferência orientados para cenários de desenvolvedor, e é adequada para os requisitos deste tutorial. Em cenários de produção, provavelmente você usaria a camada de serviço Standard ou Premium. Essas camadas fornecem níveis aprimorados de armazenamento e taxa de transferência.

Para saber mais, consulte Criar camadas de serviço do Registro de Contêiner do Azure. Para mais informações sobre preços, consulte Preço de Registro de Contêiner do Azure.

Crie uma instância de Servidor Flexível do PostgreSQL

O aplicativo de exemplo (Django ou Flask) armazena dados de avaliação de restaurantes em um banco de dados PostgreSQL. Nestas etapas, você cria o servidor que conterá o banco de dados.

  1. Use o comando az postgres flexible-server create para criar o servidor PostgreSQL no Azure. Não é incomum que esse comando seja executado por alguns minutos antes de ser concluído.

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

    Use estes valores:

    • <postgres-server-name>: o nome do servidor de banco de dados PostgreSQL. Esse nome deve ser exclusivo em todo o Azure. O ponto de extremidade do servidor é https://<postgres-server-name>.postgres.database.azure.com. Os caracteres permitidos são A para Z, 0 para 9e hífen (-).

    • <local>: use o mesmo local usado para o aplicativo Web. <local> é um dos valores Name do local do Azure da saída do comando az account list-locations -o table.

    • <nome de usuário do admin>: o nome de usuário da conta do administrador. Não pode ser azure_superuser, admin, administrator, root, guestou public. Use demoadmin para esse tutorial.

    • <senha do administrador>: a senha do usuário administrador. Ela precisa conter de 8 a 128 caracteres de três das seguintes categorias: Letras maiúsculas, letras minúsculas, números e caracteres não alfanuméricos.

      Importante

      Ao criar nomes de usuário ou senhas, não use o caractere de cifrão ($). Posteriormente, quando você cria variáveis de ambiente com esses valores, esse caractere tem um significado especial dentro do contêiner do Linux que você usa para executar aplicativos Python.

    • --version: use 16. Ele especifica a versão do PostgreSQL a ser usada para o servidor.

    • --tier: use Burstable. Ele especifica o tipo de preço para o servidor. A camada Burstable é uma opção de menor custo para cargas de trabalho que não precisam da CPU completa continuamente e é adequada para os requisitos deste tutorial.

    • --sku-name: o nome do tipo de preço e da configuração de computação; por exemplo, Standard_B1ms. Para obter mais informações, confira Preços do Banco de Dados do Azure para PostgreSQL. Para listar as camadas disponíveis, use az postgres flexible-server list-skus --location <location>.

    • --public-access: use 0.0.0.0. Ele permite o acesso público ao servidor de qualquer serviço do Azure, como Aplicativos de Contêiner.

    • --microsoft-entra-auth: use Enabled. Ele habilita a autenticação do Microsoft Entra no servidor.

    • --storage-size: use 32. Ele especifica o tamanho do armazenamento em gigabytes (GB) para o servidor. O mínimo é de 32 GB.

    • --backup-retention: use 7. Ele especifica o número de dias para reter backups para o servidor. O mínimo é de 7 dias.

    • --high-availability: use Disabled. Ele desabilita a alta disponibilidade para o servidor. A alta disponibilidade não é necessária para este tutorial.

    • --yes: aceita os termos de uso para o servidor PostgreSQL.

    Observação

    Se você planeja trabalhar com o servidor PostgreSQL da estação de trabalho local usando ferramentas, precisará adicionar uma regra de firewall para o endereço IP da estação de trabalho usando o comando az postgres flexible-server firewall-rule create.

  2. Use o comando az ad signed-in-user show para obter a ID do objeto da sua conta de usuário. Use essa ID no próximo comando.

    #!/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. Use o comando az postgres flexible-server ad-admin create para adicionar sua conta de usuário como administrador do Microsoft Entra no servidor 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. Use o comando az postgres flexible-server firewall-rule create para adicionar uma regra que permite que seu aplicativo web acesse o servidor flexível PostgreSQL. No comando a seguir, você configura o firewall do servidor para aceitar conexões de sua estação de trabalho de desenvolvimento usando seu endereço IP público:

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

Observação

As etapas desta seção criam um servidor PostgreSQL com um único vCore e memória limitada na camada de preço com capacidade de intermitência. A camada Burstable é uma opção de menor custo para cargas de trabalho que não precisam da CPU completa continuamente e é adequada para os requisitos deste tutorial. Para workloads de produção, você pode fazer upgrade para o nível de preço Uso geral ou Memória otimizada. Essas camadas fornecem um desempenho mais alto, mas aumentam os custos.

Para saber mais, consulte Opções de computação no Banco de Dados do Azure para PostgreSQL – Servidor Flexível. Para obter mais informações sobre precificação, consulte Preços do Banco de Dados do Azure para PostgreSQL.

Crie um banco de dados no servidor

Neste ponto, você tem um servidor PostgreSQL. Nesta seção, você criará um banco de dados no servidor.

Use o comando az postgres flexible-server db create para criar um banco de dados chamado 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

Você também pode usar o comando az postgres flexible-server connect para se conectar ao banco de dados e, em seguida, trabalhar com comandos psql . Ao trabalhar com psql, geralmente é mais fácil usar o Azure Cloud Shell porque o shell inclui todas as dependências para você.

Você também pode se conectar ao servidor flexível do Banco de Dados do Azure para PostgreSQL e criar um banco de dados usando psql ou um IDE que dê suporte ao PostgreSQL, como do Azure Data Studio. Para as etapas usando psql, consulte Configurar a identidade gerenciada no banco de dados PostgreSQL mais adiante neste artigo.

Criar uma identidade gerenciada atribuída pelo usuário

Crie uma identidade gerenciada atribuída pelo usuário para usar como a identidade do aplicativo de contêiner quando ele estiver em execução no Azure.

Observação

Para criar uma identidade gerenciada atribuída pelo usuário, sua conta precisa da atribuição de função Administrador de identidade gerenciada.

Use o comando az identity create para criar uma identidade gerenciada atribuída pelo usuário:

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

Configurar a identidade gerenciada no banco de dados PostgreSQL

Configure a identidade gerenciada como uma função no servidor PostgreSQL e conceda permissões necessárias para o banco de dados restaurants_reviews. Se você estiver usando a CLI do Azure ou o psql, deverá se conectar ao servidor PostgreSQL do Azure com um usuário que esteja configurado como administrador do Microsoft Entra na instância do servidor. Somente contas do Microsoft Entra configuradas como um administrador do PostgreSQL podem configurar identidades gerenciadas e outras funções de administrador da Microsoft em seu servidor.

  1. Obtenha um token de acesso para sua conta do Azure usando o comando az account get-access-token. Use o token de acesso nas próximas etapas.

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

  2. Adicione a identidade gerenciada atribuída pelo usuário como função de banco de dados em seu servidor PostgreSQL usando o 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);"

    Observação

    Se você estiver executando o comando az postgres flexible-server execute em sua estação de trabalho local, verifique se adicionou uma regra de firewall para o endereço IP da estação de trabalho. Você pode adicionar uma regra usando o comando az postgres flexible-server firewall-rule create. O mesmo requisito também existe para o comando na próxima etapa.

  3. Conceda à identidade gerenciada atribuída pelo usuário as permissões necessárias no banco de dados restaurants_reviews usando o seguinte 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"

    Este comando da CLI do Azure conecta-se ao banco de dados restaurants_reviews no servidor e emite os seguintes comandos SQL:

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

Implantar o aplicativo Web em Aplicativos de Contêiner

Os aplicativos de contêiner são implantados em ambientes de Aplicativos de Contêiner do Azure , que atuam como uma fronteira segura. Nas etapas a seguir, você cria o ambiente e um contêiner dentro do ambiente. Em seguida, configure o contêiner para que o site fique visível externamente.

Essas etapas exigem a extensão Aplicativos de contêiner do Azure containerapp.

  1. Crie um ambiente de aplicativos de contêiner usando o 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 python-container-env \
--resource-group $RESOURCE_GROUP_NAME \
--location $LOCATION

  2. Obtenha as credenciais de autenticação para a instância do Registro de Contêiner do Azure usando o 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)

    Use o nome de usuário e uma das senhas retornadas da saída do comando ao criar o aplicativo de contêiner na etapa 5.

  3. Use o comando az identity show para obter o ID do cliente e o ID do recurso da identidade gerenciada atribuída ao usuário:

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

    Use o valor da ID do cliente (GUID) e a ID do recurso da saída do comando ao criar o aplicativo de contêiner na etapa 5. O ID do recurso tem o seguinte formato: /subscriptions/<subscription-id>/resourcegroups/pythoncontainer-rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/my-ua-managed-id.

  4. Execute o seguinte comando para gerar um valor de chave secreta:

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

    Use o valor da chave secreta para definir uma variável de ambiente ao criar o aplicativo de contêiner na etapa 5.

    Observação

    O comando que esta etapa mostra é para um shell Bash. Dependendo do seu ambiente, talvez seja necessário invocar o Python usando python3. No Windows, você precisa colocar o comando no parâmetro -c entre aspas duplas em vez de aspas simples. Talvez você também precise invocar o Python usando py ou py -3, dependendo do seu ambiente.

  5. Crie um aplicativo contêiner no ambiente usando o comando az containerapp create:

    az containerapp create \
  --name "$CONTAINER_APP_NAME" \
  --resource-group "$RESOURCE_GROUP" \
  --environment "$APP_ENV" \
  --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. Para Django apenas, migre e crie um esquema de banco de dados. (No aplicativo de exemplo Flask, isso é feito automaticamente e você pode ignorar esta etapa.)

    Conecte-se usando o comando az containerapp exec:

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

    Em seguida, no prompt de comando do shell, insira python manage.py migrate.

    Você não precisa migrar para revisões do contêiner.

  7. Testar o site.

    O comando az containerapp create que você inseriu anteriormente gera uma URL de aplicativo que você pode usar para navegar até o aplicativo. A URL termina em azurecontainerapps.io. Abra a URL em um navegador. Como alternativa, você pode usar o comando az containerapp browse .

Aqui está um exemplo do site de exemplo após a adição de um restaurante e duas avaliações.

Captura de tela do site de exemplo criado neste tutorial.

Solucionar problemas de implantação

Você esqueceu a URL do aplicativo para acessar o site

No portal do Azure:

  • Acesse a página Visão Geral do aplicativo contêiner e procure por URL do Aplicativo.

No VS Code:

  1. Acesse a Exibição do Azure (Ctrl+Shift+A) e expanda a assinatura em que está trabalhando.
  2. Expanda o nó Aplicativos de contêiner, e em seguida, expanda o ambiente gerenciado, clique com o botão direito do mouse em python-container-app e então selecione Procurar. O VS Code abre o navegador com a URL do aplicativo.

Na CLI do Azure:

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

No VS Code, a tarefa de criação de imagem na Azure retorna um erro

Se você vir a mensagem "Erro: falha ao baixar o contexto. Verifique se a URL está incorreta." na janela Saída do VS Code e atualize o registro na extensão do Docker. Para atualizar, selecione a extensão do Docker, vá para a seção Registros, localize o registro e selecione-o.

Se você executar a tarefa Criar imagem no Azure novamente, verifique se o registro de uma execução anterior está presente. Em caso afirmativo, use-o.

No portal do Azure, um erro de acesso é exibido durante a criação de um aplicativo de contêiner

Um erro de acesso que contém "Não é possível acessar o ACR '<nome>.azurecr.io'" ocorre quando as credenciais de administrador em uma instância do Registro de Contêiner do Azure são desabilitadas.

Para verificar o status do administrador no portal, acesse a instância do Registro de Contêiner do Azure, selecione o recurso chaves de acesso e verifique se o Usuário Administrador está habilitado.

Sua imagem de contêiner não aparece na instância do Registro de Contêiner do Azure

  • Verifique a saída do comando da CLI do Azure ou a saída do VS Code e procure mensagens que confirmem o êxito.
  • Verifique se o nome do registro foi especificado corretamente no comando de build com a CLI do Azure ou nos prompts de tarefa do VS Code.
  • Certifique-se de que suas credenciais não estejam expiradas. Por exemplo, no VS Code, localize o registro de destino na extensão do Docker e atualize. Na CLI do Azure, execute az login.

O site retorna "Solicitação Incorreta (400)"

Se você receber um erro "Solicitação Incorreta (400)", verifique as variáveis de ambiente postgreSQL passadas para o contêiner. O erro 400 geralmente indica que o código Python não pode se conectar à instância do PostgreSQL.

O código de exemplo usado neste tutorial verifica a existência da variável de ambiente de contêiner RUNNING_IN_PRODUCTION, que pode ser definida como qualquer valor (como 1).

O site retorna "Não Encontrado (404)"

  • Verifique o valor de URL do aplicativo na página Visão geral do contêiner. Se o URL do aplicativo contiver a palavra "internal", o ingresso não está definido corretamente.
  • Verifique a entrada do contêiner. Por exemplo, no portal do Azure, vá para o recurso Ingress do contêiner. Verifique se a Entrada HTTP está habilitada e Aceitar tráfego de qualquer lugar está selecionado.

O site não começa, você obtém "tempo limite do fluxo" ou nada é retornado

  • Verifique os logs:
    • No portal do Azure, acesse o recurso de gerenciamento de revisão do aplicativo contêiner e verifique Status de Provisionamento para o contêiner:
      • Se o status for Provisionando, aguarde até o provisionamento estar completo.
      • Se o status for Falhou, selecione a revisão e exiba os logs do console. Escolha a ordem das colunas para mostrar o Hora da Geração, Stream_s e Log_s. Classifique os logs pelo mais recente e procure mensagens de stderr e stdout do Python na coluna Stream_s. A saída do Python print são mensagens stdout.
    • No Azure CLI, use o comando az containerapp logs show.
  • Se você estiver usando a estrutura do Django, verifique se as tabelas restaurants_reviews existem no banco de dados. Caso contrário, use um console para acessar o contêiner e executar python manage.py migrateo .

Próxima etapa

Configurar a implantação contínua para um aplicativo Web Python nos Aplicativos de Contêiner do Azure