Partilhar via

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

Este artigo faz parte de uma série de tutoriais sobre como contentorizar e implementar uma aplicação Web Python para Aplicações de Contentor do Azure. O Container Apps permite que você implante aplicativos em contêineres sem gerenciar uma infraestrutura complexa.

Neste tutorial, você:

  • Containerize um aplicativo Web de exemplo 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 permitam que o aplicativo contêiner se conecte a uma instância do Banco de Dados do Azure para PostgreSQL - Servidor Flexível, onde o aplicativo de exemplo armazena dados.

O diagrama a seguir destaca as tarefas neste tutorial: criar 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 destacadas 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 em do Azure Cloud Shell ou em uma estação de trabalho com o Azure CLI 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. Certifique-se de que está a executar a versão mais recente da CLI do Azure:

    az upgrade

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

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

    Nota

    Para listar as extensões instaladas no seu sistema, pode-se usar o comando az extension list. Por exemplo:

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

Obter a aplicação de exemplo

Faça um fork e clone o código de exemplo para o seu ambiente de desenvolvimento.

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

    Siga as etapas para bifurcar o repositório para sua conta do GitHub. Você também pode descarregar o repositório de código diretamente para a sua máquina local sem criar um fork ou ter uma conta no GitHub. Mas se você usar o método de download, não poderá configurar a integração contínua e a entrega contínua (CI/CD) 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 Git Bash em um computador Windows, digite o seguinte comando antes de continuar:

    #!/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. Inicie sessão no registo utilizando o comando az acr login:

    az acr login --name $REGISTRY_NAME

    O comando adiciona "azurecr.io" ao nome para criar o nome de registro totalmente qualificado. Se o login for bem-sucedido, a mensagem "Login bem-sucedido" será exibida. Se estiver a aceder ao registo a partir de uma subscrição diferente daquela em que criou o registo, utilize o parâmetro --suffix.

    Se o login falhar, certifique-se de que o daemon do Docker está a correr no 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 aplicam-se:

    • O ponto (.) no final do comando indica a localização 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 puxar o 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 -t opção (igual --imagea ), 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 do contêiner foi criada usando o comando az acr repository list:

    az acr repository list --name $REGISTRY_NAME

Nota

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

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

Criar uma instância do PostgreSQL Flexible Server

O aplicativo de exemplo (Django ou Flask) armazena dados de revisã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 terminar.

    #!/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 que você usou para o aplicativo Web. <local> é um dos valores de localização Name do Azure obtidos a partir da saída do comando az account list-locations -o table.

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

    • <admin-password>: A senha do usuário administrador. Ele deve conter de 8 a 128 caracteres de três das seguintes categorias: letras maiúsculas em inglês, letras minúsculas em inglês, números e caracteres não alfanuméricos.

      Importante

      Ao criar nomes de usuário ou senhas, não use o caractere cifrão ($). Mais tarde, quando você cria variáveis de ambiente com esses valores, esse caractere tem um significado especial dentro do contêiner 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 a camada de preço para o servidor. A camada Burstable é uma opção de baixo custo para cargas de trabalho que não precisam da CPU completa continuamente e é adequada para os requisitos deste tutorial.

    • --sku-name: O nome da camada de preços e da configuração de computação; por exemplo, Standard_B1ms. Para obter mais informações, consulte 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 a partir 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: Utilize 7. Ele especifica o número de dias para reter backups para o servidor. O mínimo é de 7 dias.

    • --high-availability: Use Disabled. Desativa 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.

    Nota

    Se planeia trabalhar com o servidor PostgreSQL da sua estação de trabalho local usando ferramentas, necessita de adicionar uma regra de firewall para o endereço IP da estação de trabalho utilizando o comando az postgres flexible-server firewall-rule create.

  2. Use o comando az ad signed-in-user show para obter o ID de objeto da sua conta de utilizador. 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 permita que seu aplicativo Web acesse o servidor flexível do PostgreSQL. No comando a seguir, você configura o firewall do servidor para aceitar conexões da 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"
    ```

Nota

As etapas nesta secção criam um servidor PostgreSQL com um único vCore e memória limitada na camada de preços Burstable. A camada Burstable é uma opção de baixo custo para cargas de trabalho que não precisam da CPU completa continuamente e é adequada para os requisitos deste tutorial. Para cargas de trabalho de produção, pode-se atualizar para a camada de preços de Uso Geral ou Otimizada para Memória. Esses níveis proporcionam maior desempenho, 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 informações sobre preços, consulte Banco de Dados do Azure para preços do PostgreSQL.

Criar um banco de dados no servidor

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

Utilize o comando az postgres flexible-server db create para criar uma base de dados chamada 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 . Quando você está trabalhando com psql, geralmente é mais fácil usar do 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 ofereça suporte ao PostgreSQL, como Azure Data Studio. Para conhecer as etapas que usam o 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 para o aplicativo de contêiner quando ele estiver sendo executado no Azure.

Nota

Para criar uma identidade gerenciada atribuída pelo usuário, sua conta precisa da atribuição de função Colaborador 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, em seguida, conceda-lhe as permissões necessárias para o banco de dados restaurants_reviews. Quer esteja a utilizar a CLI do Azure ou o psql, tem de ligar ao servidor PostgreSQL do Azure com um utilizador configurado como administrador do Microsoft Entra na instância do servidor. Somente as 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. Você usa 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);"

    Nota

    Se estiver a executar o comando az postgres flexible-server execute na estação de trabalho local, certifique-se de que 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 se conecta 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

Aplicações de contentores são implementadas nos Ambientes de Aplicações de Contentores 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.

Estas etapas exigem a extensão Azure Container Apps, 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 $APP_ENV_NAME \
--resource-group $RESOURCE_GROUP_NAME \
--location $LOCATION

  2. Para obter as credenciais de autenticação para a instância do Registo de Contêiner do Azure, utilize 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)

    Você usa o nome de usuário e uma das senhas retornadas da saída do comando quando cria o aplicativo 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 pelo usuário:

    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)

    Você usa o valor da ID do cliente (GUID) e a ID do recurso da saída do comando quando cria o aplicativo contêiner na etapa 5. O ID do recurso tem a seguinte forma: /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.

    Nota

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

  5. Crie uma aplicação de contentor no ambiente usando o 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. Migre e crie um esquema de base de dados apenas para o Django. (No aplicativo de exemplo Flask, isso é feito automaticamente e você pode pular 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, digite python manage.py migrate.

    Não é necessário migrar para revisões do contêiner.

  7. Teste 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. O URL termina em azurecontainerapps.io. Vá para o 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.

Resolver erros de implementação

Esqueceu-se do URL da aplicação para aceder ao website

No portal do Azure:

  • Vá para a página Visão Geral da aplicação de contentor e procure a URL da aplicação .

No Visual Studio Code:

  1. Aceda à visão Azure (Ctrl+Shift+A) e expanda a subscrição em que está a trabalhar.
  2. Expanda o nó Container Apps, expanda o ambiente gerido, clique com o botão direito no python-container-appe selecione Navegar. O VS Code abre o navegador com o 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 Criar Imagem no Azure retorna um erro

Se vir a mensagem "Erro: falha ao transferir contexto. Verifique se o URL está incorreto" na janela VS Code Output, atualize o registro na extensão Docker. Para atualizar, selecione a extensão Docker, vá para a seção Registros , localize o registro e selecione-o.

Se você executar a tarefa Build Image no Azure novamente, verifique se o registro de uma execução anterior existe. Em caso afirmativo, utilize-o.

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

Um erro de acesso que contém "Não é possível acessar o nome do<ACR '>.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 estado de administrador no portal, aceda à sua instância do Registro de Contêiner do Azure, selecione o recurso Chaves de acesso e verifique se o utilizador Admin está habilitado.

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

  • Verifique o resultado do comando da CLI do Azure ou do VS Code e procure por mensagens para confirmar se foi bem-sucedido.
  • Verifique se o nome do Registro foi especificado corretamente em seu comando build com a CLI do Azure ou nos prompts de tarefa do VS Code.
  • Certifique-se de que as suas credenciais não expiraram. 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 website retorna "Pedido Inválido (400)"

Se você receber um erro "Solicitação incorreta (400)", verifique as variáveis de ambiente do 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 URL do Aplicativo na página Visão Geral do para o contêiner. Se o URL do aplicativo contiver a palavra "interno", a entrada não está definida corretamente.
  • Verifique a entrada do contentor. Por exemplo, no portal do Azure, vá para o recurso de Entrada do contêiner. Verifique se de Ingresso HTTP está habilitado e Aceitando tráfego de qualquer lugar está selecionado.

O site não inicia, você recebe "tempo limite de streaming" ou nada é retornado

  • Confira os registros:
    • No portal do Azure, acesse o recurso de gestão de revisões da aplicação de contêineres e verifique o Estado de Provisionamento para o contêiner:
      • Se o estado for Provisionamento, aguarde até que o provisionamento seja concluído.
      • Se o estado for Falha, selecione a revisão e visualize os registos do console. Escolha a ordem das colunas para mostrar Hora gerada, Stream_se Log_s. Classifique os logs pelos mais recentes e procure pelas mensagens Python e na coluna do Stream_s . A saída de Python print é stdout mensagens.
    • Na CLI do Azure, use o comando az containerapp logs show.
  • Se você estiver usando a estrutura 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 migrate.

Próximo passo

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

  • Last updated on