Implantar um aplicativo Python em contêiner no Serviço de Aplicativo

Nesta parte da série de tutoriais, você aprenderá a implantar um aplicativo Web Python em contêineres no Aplicativo Web do Serviço de Aplicativo do Azure para Contêineres. Esse serviço totalmente gerenciado permite que você execute aplicativos em contêineres sem ter que manter seu próprio orquestrador de contêineres.

O Serviço de Aplicativo simplifica a implantação por meio de pipelines de integração contínua/implantação contínua (CI/CD) que funcionam com o Docker Hub, o Registro de Contêiner do Azure, o Azure Key Vault e outras ferramentas de DevOps. Este tutorial é a parte 4 de uma série de tutoriais de 5 partes.

No final deste artigo, você tem um aplicativo Web do Serviço de Aplicativo seguro e pronto para produção em execução a partir de uma imagem de contêiner do Docker. O aplicativo usa uma identidade gerenciada atribuída pelo sistema para extrair a imagem do Registro de Contêiner do Azure e recuperar segredos do Cofre de Chaves do Azure.

Este diagrama de serviço destaca os componentes abordados neste artigo.

Azure CLI

Os comandos da CLI do Azure podem ser executados no Azure Cloud Shell ou em uma máquina local com a CLI do Azure instalada.

Importante

Recomendamos usar o Azure Cloud Shell para todas as etapas baseadas em CLI neste tutorial porque:

• Vem pré-autenticado com sua conta do Azure, evitando problemas de logon
• Inclui todas as extensões necessárias da CLI do Azure prontas para uso
• Garante um comportamento consistente, independentemente do seu SO ou ambiente local
• Não requer instalação local, ideal para usuários sem direitos de administrador
• Fornece acesso direto aos serviços do Azure a partir do portal, sem necessidade de Docker local ou configuração de rede
• Evita problemas de firewall local ou configuração de rede

Criar cofre de chaves com autorização RBAC

O Azure Key Vault é um serviço seguro para armazenar segredos, chaves de API, cadeias de conexão e certificados. Neste script, ele armazena a cadeia de conexão MongoDB e o elemento SECRET_KEY da aplicação web.

O Cofre da Chave está configurado para usar o RBAC (controle de acesso baseado em função) para gerenciar o acesso por meio de funções do Azure em vez das políticas de acesso tradicionais. O aplicativo Web usa sua identidade gerenciada atribuída ao sistema para recuperar segredos com segurança em tempo de execução.

Observação

Criar o Cofre da Chave com antecedência garante que as funções possam ser atribuídas antes de qualquer tentativa de acessar segredos. Também ajuda a evitar demoras na propagação nas atribuições de funções. Como o Key Vault não depende do Serviço de Aplicativo, provisioná-lo antecipadamente melhora a confiabilidade e o sequenciamento.

1. Nesta etapa, você usa o comando az keyvault create para criar um Cofre de Chaves do Azure com RBAC habilitado.

   Bash

   #!/bin/bash
   RESOURCE_GROUP_NAME="msdocs-web-app-rg"
   LOCATION="westus"
   KEYVAULT_NAME="${RESOURCE_GROUP_NAME}-kv"
   
   az keyvault create \
     --name "$KEYVAULT_NAME" \
     --resource-group "$RESOURCE_GROUP_NAME" \
     --location "$LOCATION" \
     --enable-rbac-authorization true
   

   PowerShell

   # PowerShell syntax
   $RESOURCE_GROUP_NAME="msdocs-web-app-rg"
   $LOCATION="westus"
   $KEYVAULT_NAME="${RESOURCE_GROUP_NAME}-kv"
   
   az keyvault create `
     --name "$KEYVAULT_NAME" `
     --resource-group "$RESOURCE_GROUP_NAME" `
     --location "$LOCATION" `
     --enable-rbac-authorization true
   

Criar o plano de serviço de aplicativo e o aplicativo Web

O Plano do Serviço de Aplicativo define os recursos de computação, a camada de preços e a região do seu aplicativo Web. O aplicativo Web executa seu aplicativo em contêiner e é provisionado com uma identidade gerenciada atribuída pelo sistema que é usada para autenticar com segurança no Registro de Contêiner do Azure (ACR) e no Cofre da Chave do Azure.

Nesta etapa, você executa as seguintes tarefas:

• Criar um Plano do Serviço de Aplicações
• Criar o aplicativo Web com sua identidade gerenciada
• Configurar o aplicativo Web para implantação usando uma imagem de contêiner específica
• Prepare-se para a implantação contínua via ACR

Observação

O aplicativo Web deve ser criado antes de atribuir acesso ao ACR ou ao Cofre da Chave, pois a identidade gerenciada só é criada no momento da implantação. Além disso, atribuir a imagem do contêiner durante a criação garante que o aplicativo seja iniciado corretamente com a configuração pretendida.

1. Nesta etapa, você usa o comando az appservice plan create para provisionar o ambiente de computação para seu aplicativo.

   Bash

   #!/bin/bash
   APP_SERVICE_PLAN_NAME="msdocs-web-app-plan"
   
   az appservice plan create \
       --name "$APP_SERVICE_PLAN_NAME" \
       --resource-group "$RESOURCE_GROUP_NAME" \
       --sku B1 \
       --is-linux
   

   PowerShell

   # PowerShell syntax
   $APP_SERVICE_PLAN_NAME="msdocs-web-app-plan"
   
   az appservice plan create `
       --name "$APP_SERVICE_PLAN_NAME" `
       --resource-group "$RESOURCE_GROUP_NAME" `
       --sku B1 `
       --is-linux
   

2. Nesta etapa, você usa o comando az webapp create para criar o aplicativo Web. Esse comando também habilita uma identidade gerenciada atribuída ao sistema e define a imagem de contêiner que o aplicativo executa.

   Bash

   #!/bin/bash
   APP_SERVICE_NAME="msdocs-website-name" #APP_SERVICE_NAME must be globally unique as it becomes the website name in the URL `https://<website-name>.azurewebsites.net`.
   # Use the same registry name as in part 2 of this tutorial series.
   REGISTRY_NAME="msdocscontainerregistryname" #REGISTRY_NAME is the registry name you used in part 2 of this tutorial.
   CONTAINER_NAME="$REGISTRY_NAME.azurecr.io/msdocspythoncontainerwebapp:latest" #CONTAINER_NAME is of the form "yourregistryname.azurecr.io/repo_name:tag".
   
   az webapp create \
     --resource-group "$RESOURCE_GROUP_NAME" \
     --plan "$APP_SERVICE_PLAN_NAME" \
     --name "$APP_SERVICE_NAME" \
     --assign-identity '[system]' \
     --deployment-container-image-name "$CONTAINER_NAME" 
   

   PowerShell

   # Powershell syntax
   $APP_SERVICE_NAME="msdocs-website-name"
   # Use the same rregistry name as in part 2 of this tutorial series.
   $REGISTRY_NAME="msdocscontainerregistryname"
   $CONTAINER_NAME = "$REGISTRY_NAME.azurecr.io/msdocspythoncontainerwebapp:latest"
   
   az webapp create `
     --resource-group "$RESOURCE_GROUP_NAME" `
     --plan "$APP_SERVICE_PLAN_NAME" `
     --name "$APP_SERVICE_NAME" `
     --assign-identity '[system]' `
     --deployment-container-image-name "$CONTAINER_NAME" 
   

   Observação

   Ao executar este comando, poderá ver o seguinte erro:

   No credential was provided to access Azure Container Registry. Trying to look up...
   Retrieving credentials failed with an exception:'Failed to retrieve container registry credentials. Please either provide the credentials or run 'az acr update -n msdocscontainerregistryname --admin-enabled true' to enable admin first.'
   

   Esse erro ocorre porque o aplicativo Web tenta usar credenciais de administrador para acessar o ACR, cujas credenciais são desabilitadas por padrão. É seguro ignorar esta mensagem: a próxima etapa configura o aplicativo Web para usar sua identidade gerenciada para autenticar com o ACR.

Conceder Função de Oficial de Segredos ao usuário conectado

Para armazenar segredos no Cofre de Chaves do Azure, o usuário que executa o script deve ter a função de Oficial de Segredos do Cofre de Chaves . Essa função permite criar e gerenciar segredos dentro do cofre.

Nesta etapa, o script atribui essa função ao usuário conectado no momento. Esse usuário pode então armazenar com segurança segredos do aplicativo, como a cadeia de conexão MongoDB e o SECRET_KEY.

Esta atribuição de função é a primeira de duas relacionadas com o Key Vault. Mais tarde, à identidade gerida atribuída pelo sistema da aplicação web é concedido acesso para recuperar segredos do repositório.

O uso do RBAC do Azure garante acesso seguro e auditável com base na identidade, eliminando a necessidade de credenciais codificadas.

Observação

O usuário deve receber a função de Oficial de Segredos do Cofre de Chavesantes de tentar armazenar quaisquer segredos no cofre de chaves. Essa atribuição é feita usando o comando az role assignment create no âmbito do Azure Key Vault.

1. Nesta etapa, você usa o comando az role assignment create para atribuir a função no escopo do Cofre de Chaves.

   Bash

   #!/bin/bash
   CALLER_ID=$(az ad signed-in-user show --query id -o tsv)
   echo $CALLER_ID # Verify this value retrieved successfully. In production, poll to verify this value is retrieved successfully.
   
   az role assignment create \
     --role "Key Vault Secrets Officer" \
     --assignee "$CALLER_ID" \
     --scope "/subscriptions/$(az account show --query id -o tsv)/resourceGroups/$RESOURCE_GROUP_NAME/providers/Microsoft.KeyVault/vaults/$KEYVAULT_NAME"
   
   

   PowerShell

   # PowerShell syntax
   $CALLER_ID=$(az ad signed-in-user show --query id -o tsv)
   echo $CALLER_ID # Verify this value retrieved successfully. In production, poll to verify this value is retrieved successfully.
   
   az role assignment create `
     --role "Key Vault Secrets Officer" `
     --assignee "$CALLER_ID" `
     --scope "/subscriptions/$(az account show --query id -o tsv)/resourceGroups/$RESOURCE_GROUP_NAME/providers/Microsoft.KeyVault/vaults/$KEYVAULT_NAME"
   

Conceder acesso à Web ao ACR usando identidade gerenciada

Para extrair imagens do Registro de Contêiner do Azure (ACR) com segurança, o aplicativo Web deve ser configurado para usar sua identidade gerenciada atribuída ao sistema. O uso da identidade gerenciada evita a necessidade de credenciais de administrador e oferece suporte à implantação segura e sem credenciais.

Este processo envolve duas acções-chave:

• Permitindo que o aplicativo Web use sua identidade gerenciada ao acessar o ACR
• Atribuindo a função AcrPull a essa identidade no ACR de destino

1. Nesta etapa, você recupera a ID principal (ID de objeto exclusivo) da identidade gerenciada do aplicativo Web usando o comando az webapp identity show . Em seguida, você habilita o uso da identidade gerenciada para autenticação ACR definindo a acrUseManagedIdentityCreds propriedade como true usando az webapp config set. Em seguida, você atribui a função AcrPull à identidade gerenciada do aplicativo Web usando o comando az role assignment create . Essa função concede ao aplicativo Web permissão para extrair imagens do Registro.

   Bash

   #!/bin/bash
   PRINCIPAL_ID=$(az webapp identity show \
     --name "$APP_SERVICE_NAME" \
     --resource-group "$RESOURCE_GROUP_NAME" \
     --query principalId \
     -o tsv)
   echo $PRINCIPAL_ID # Verify this value retrieved successfully. In production, poll for successful 'AcrPull' role assignment using `az role assignment list`.    
   
   az webapp config set \
     --resource-group "$RESOURCE_GROUP_NAME" \
     --name "$APP_SERVICE_NAME" \
     --generic-configurations '{"acrUseManagedIdentityCreds": true}'
   
   az role assignment create \
   --role "AcrPull" \
   --assignee "$PRINCIPAL_ID" \
   --scope "/subscriptions/$(az account show --query id -o tsv)/resourceGroups/$RESOURCE_GROUP_NAME/providers/Microsoft.ContainerRegistry/registries/$REGISTRY_NAME"
   
   

   PowerShell

   # PowerShell syntax
   $PRINCIPAL_ID=$(az webapp identity show `
     --name "$APP_SERVICE_NAME" `
     --resource-group "$RESOURCE_GROUP_NAME" `
     --query principalId `
     -o tsv)
   echo $PRINCIPAL_ID # Verify this value retrieved successfully. In production, poll for successful AcrPull role assignment using `az role assignment list`.    
   
   az webapp config set `
     --resource-group "$RESOURCE_GROUP_NAME" `
     --name "$APP_SERVICE_NAME" `
     --generic-configurations '{ "acrUseManagedIdentityCreds": true }'
   
   az role assignment create `
     --role "AcrPull" `
     --assignee "$PRINCIPAL_ID" `
     --scope "/subscriptions/$(az account show --query id -o tsv)/resourceGroups/$RESOURCE_GROUP_NAME/providers/Microsoft.ContainerRegistry/registries/$REGISTRY_NAME"
   

Conceder acesso ao cofre de chaves à identidade gerenciada do aplicativo Web

O aplicativo Web precisa de permissão para acessar segredos como a cadeia de conexão MongoDB e o SECRET_KEY. Para conceder essas permissões, você deve atribuir a função Usuário de Segredos do Cofre de Chaves à identidade gerenciada atribuída pelo sistema do aplicativo Web.

1. Nesta etapa, você usa o identificador exclusivo (ID principal) da identidade gerenciada atribuída pelo sistema do aplicativo Web para conceder ao aplicativo Web acesso ao Cofre de Chaves com a função Usuário de Segredos do Cofre de Chaves usando o comando az role assignment create .

   Bash

   #!/bin/bash
   
   az role assignment create \
   --role "Key Vault Secrets User" \
   --assignee "$PRINCIPAL_ID" \
   --scope "/subscriptions/$(az account show --query id -o tsv)/resourceGroups/$RESOURCE_GROUP_NAME/providers/Microsoft.KeyVault/vaults/$KEYVAULT_NAME"
   

   PowerShell

   # PowerShell syntax
   
     az role assignment create `
     --role "Key Vault Secrets User" `
     --assignee "$PRINCIPAL_ID"`
     --scope "/subscriptions/$(az account show --query id -o tsv)/resourceGroups/$RESOURCE_GROUP_NAME/providers/Microsoft.KeyVault/vaults/$KEYVAULT_NAME"
   
   

Armazenar segredos no Cofre da Chave

Para evitar segredos de codificação em seu aplicativo, esta etapa armazena a cadeia de conexão MongoDB e a chave secreta do aplicativo Web no Cofre de Chaves do Azure. Esses segredos podem ser acessados com segurança pelo aplicativo Web em tempo de execução por meio de sua identidade gerenciada, sem a necessidade de armazenar credenciais em código ou configuração.

Observação

Embora este tutorial armazene apenas a cadeia de conexão e a chave secreta no cofre de chaves, você pode, opcionalmente, armazenar outras configurações do aplicativo, como o nome do banco de dados MongoDB ou o nome da coleção no Cofre da Chave.

1. Nesta etapa, você usa o comando az cosmosdb keys list para recuperar a cadeia de conexão MongoDB. Em seguida, use o comando az keyvault secret set para armazenar a cadeia de conexão e uma chave secreta gerada aleatoriamente no Cofre da Chave.

   Bash

   #!/bin/bash
   ACCOUNT_NAME="msdocs-cosmos-db-account-name"
   
   MONGO_CONNECTION_STRING=$(az cosmosdb keys list \
     --name "$ACCOUNT_NAME" \
     --resource-group "$RESOURCE_GROUP_NAME" \
     --type connection-strings \
     --query "connectionStrings[?description=='Primary MongoDB Connection String'].connectionString" -o tsv)
   
   SECRET_KEY=$(openssl rand -base64 32 | tr -dc 'a-zA-Z0-9')
   # This key is cryptographically secure, using OpenSSL’s strong random number generator.
   
   az keyvault secret set \
     --vault-name "$KEYVAULT_NAME" \
     --name "MongoConnectionString" \
     --value "$MONGO_CONNECTION_STRING"
   
   az keyvault secret set \
     --vault-name "$KEYVAULT_NAME" \
     --name "MongoSecretKey" \
     --value "$SECRET_KEY"
   

   PowerShell

   # PowerShell syntax
   $ACCOUNT_NAME="msdocs-cosmos-db-account-name"
   
   $MONGO_CONNECTION_STRING = az cosmosdb keys list `
     --name $ACCOUNT_NAME `
     --resource-group $RESOURCE_GROUP_NAME `
     --type connection-strings `
     --query "connectionStrings[?description=='Primary MongoDB Connection String'].connectionString" `
     -o tsv
   
   # Generate a 32-byte cryptographically secure random value
   $bytes = New-Object 'Byte[]' 32
   [System.Security.Cryptography.RandomNumberGenerator]::Create().GetBytes($bytes)
   
   # Convert to base64 and filter to alphanumeric characters only
   $base64 = [Convert]::ToBase64String($bytes)
   $alphanumeric = $base64 -replace '[^a-zA-Z0-9]', ''
   
   # Truncate to 50 characters
   $SECRET_KEY = $alphanumeric.Substring(0, [Math]::Min(50, $alphanumeric.Length))
   
   az keyvault secret set `
     --vault-name "$KEYVAULT_NAME" `
     --name "MongoConnectionString" `
     --value "$MONGO_CONNECTION_STRING"
   
   az keyvault secret set `
     --vault-name "$KEYVAULT_NAME" `
     --name "MongoSecretKey" `
     --value "$SECRET_KEY"
   

Configurar o aplicativo Web para usar os segredos do Kay Vault

Para acessar segredos com segurança em tempo de execução, o aplicativo Web deve ser configurado para fazer referência aos segredos armazenados no Cofre da Chave do Azure. Esta etapa é feita usando referências do Key Vault, que injetam os valores secretos no ambiente do aplicativo por meio de sua identidade gerenciada atribuída ao sistema.

Essa abordagem evita segredos de codificação e permite que o aplicativo recupere com segurança valores confidenciais, como a cadeia de conexão MongoDB e a chave secreta durante a execução.

1. Nesta etapa, você usa o comando az webapp config appsettings set para adicionar configurações do aplicativo que fazem referência aos segredos do Cofre da Chave. Especificamente, isso define as configurações de MongoConnectionString e MongoSecretKey do aplicativo para fazer referência aos segredos correspondentes armazenados no Key Vault.

   Bash

   #!/bin/bash
   MONGODB_NAME="restaurants_reviews"
   MONGODB_COLLECTION_NAME="restaurants_reviews"
   
   az webapp config appsettings set \
     --resource-group "$RESOURCE_GROUP_NAME" \
     --name "$APP_SERVICE_NAME" \
     --settings \
         CONNECTION_STRING="@Microsoft.KeyVault(SecretUri=https://$KEYVAULT_NAME.vault.azure.net/secrets/MongoConnectionString)" \
         SECRET_KEY="@Microsoft.KeyVault(SecretUri=https://$KEYVAULT_NAME.vault.azure.net/secrets/MongoSecretKey)" \
         DB_NAME="$MONGODB_NAME" \
         COLLECTION_NAME="$MONGODB_COLLECTION_NAME"
   

   PowerShell

   # PowerShell syntax
   $MONGO_DB_NAME="restaurants_reviews"
   $MONGO_COLLECTION_NAME="restaurants_reviews"
   
   az webapp config appsettings set `
     --resource-group $RESOURCE_GROUP_NAME `
     --name $APP_SERVICE_NAME `
     --settings `
       CONNECTION_STRING="@Microsoft.KeyVault(SecretUri=https://$KEYVAULT_NAME.vault.azure.net/secrets/MongoConnectionString)" `
       SECRET_KEY="@Microsoft.KeyVault(SecretUri=https://$KEYVAULT_NAME.vault.azure.net/secrets/MongoSecretKey)" `
       DB_NAME=$MONGODB_NAME `
       COLLECTION_NAME=$MONGODB_COLLECTION_NAME
   

Habilite a implantação contínua a partir do ACR

Habilitar a implantação contínua permite que o aplicativo Web extraia e execute automaticamente a imagem de contêiner mais recente sempre que uma for enviada por push para o Registro de Contêiner do Azure (ACR). Isso reduz as etapas de implantação manual e ajuda a garantir que seu aplicativo permaneça atualizado.

Observação

Na próxima etapa, você registrará um webhook no ACR para notificar o aplicativo Web quando uma nova imagem for enviada.

1. Nesta etapa, você usa o comando az webapp deployment container config para habilitar a implantação contínua do ACR para o aplicativo Web.

   Bash

   #!/bin/bash
   az webapp deployment container config \
     --name "$APP_SERVICE_NAME" \
     --resource-group "$RESOURCE_GROUP_NAME" \
     --enable-cd true
   

   PowerShell

   # PowerShell syntax
   az webapp deployment container config `
     --name "$APP_SERVICE_NAME" `
     --resource-group "$RESOURCE_GROUP_NAME" `
     --enable-cd true
   

Registrar um Webhook ACR para implantação contínua

Para automatizar implantações, registre um webhook no Azure Container Registry (ACR) que notifica o aplicativo Web sempre que uma nova imagem de contêiner é enviada por push. O webhook permite que o aplicativo puxe e execute automaticamente a versão mais recente.

O webhook configurado no Azure Container Registry (ACR) envia uma solicitação POST para o ponto de extremidade SCM (SERVICE_URI) do aplicativo Web sempre que uma nova imagem é enviada por push para o repositório msdocspythoncontainerwebapp. Essa ação aciona o aplicativo Web para extrair e implantar a imagem atualizada, concluindo o pipeline de implantação contínua entre o ACR e o Serviço de Aplicativo do Azure.

Observação

O URI do webhook deve seguir este formato:
https://<app-name>.scm.azurewebsites.net/api/registry/webhook

Deve terminar com /api/registry/webhook. Se você receber um erro de URI, confirme se o caminho está correto.

1. Nesta etapa, use o comando az acr webhook create para registrar o webhook e configurá-lo para disparar em push eventos.

   Bash

   #!/bin/bash
   CREDENTIAL=$(az webapp deployment list-publishing-credentials \
       --resource-group "$RESOURCE_GROUP_NAME" \
       --name "$APP_SERVICE_NAME" \
       --query publishingPassword --output tsv)
   # Web app publishing credentials may not be available immediately. In production, poll until non-empty.   
   
   SERVICE_URI="https://$APP_SERVICE_NAME:$CREDENTIAL@$APP_SERVICE_NAME.scm.azurewebsites.net/api/registry/webhook"
   
   az acr webhook create \
     --name webhookforwebapp \
     --registry "$REGISTRY_NAME" \
     --scope msdocspythoncontainerwebapp:* \
     --uri "$SERVICE_URI" \
     --actions push
   
   

   PowerShell

   # PowerShell syntax
   $CREDENTIAL=$(az webapp deployment list-publishing-credentials `
     --resource-group "$RESOURCE_GROUP_NAME" `
     --name "$APP_SERVICE_NAME" `
     --query publishingPassword --output tsv)
   
   # Web app publishing credentials may not be available immediately. In production, poll until non-empty.   
   
   $SERVICE_URI = "https://$APP_SERVICE_NAME`:$CREDENTIAL@$APP_SERVICE_NAME.scm.azurewebsites.net/api/registry/webhook"
   
   az acr webhook create `
     --name webhookforwebapp `
     --registry "$REGISTRY_NAME" `
     --scope msdocspythoncontainerwebapp:* `
     --uri "$SERVICE_URI" `
     --actions push
   

Navegar no site

Para verificar se o aplicativo Web está em execução, abra https://<website-name>.azurewebsites.net, substituindo <website-name> pelo nome do seu Serviço de Aplicativo. Você deve ver o aplicativo de exemplo de avaliação de restaurante. Pode levar alguns momentos para carregar a primeira vez.

Quando o site aparecer, tente adicionar um restaurante e enviar uma avaliação para confirmar se o aplicativo está funcionando corretamente.

Observação

O comando az webapp browse não é suportado no Cloud Shell. Se você estiver usando o Cloud Shell, abra manualmente um navegador e navegue até o URL do site.

Se você estiver usando a CLI do Azure localmente, poderá usar o comando az webapp browse para abrir o site em seu navegador padrão:

az webapp browse --name $APP_SERVICE_NAME --resource-group $RESOURCE_GROUP_NAME

Observação

O comando az webapp browse não é suportado no Cloud Shell. Abra uma janela do navegador e navegue até o URL do site.

Código VS

Você pode usar a extensão Docker no Visual Studio Code para criar e implantar seu aplicativo Web em contêiner no Serviço de Aplicativo do Azure. Essa extensão simplifica o processo de empacotar seu aplicativo e enviá-lo para a nuvem. Depois de implantado, use a extensão Ferramentas do Azure para definir as configurações do aplicativo Web, incluindo a cadeia de conexão MongoDB e uma chave secreta para o aplicativo.

Inicialmente, configure e teste o aplicativo usando valores codificados para garantir que ele seja iniciado com êxito e se conecte ao banco de dados do MongoDB. Depois de verificar se o aplicativo funciona, use a CLI do Azure (localmente ou no Cloud Shell) para criar um Cofre da Chave do Azure. Em seguida, conceda ao usuário que está criando o aplicativo no VS Code permissão para armazenar informações confidenciais e, em seguida, armazenar a cadeia de conexão MongoDB e a chave secreta do aplicativo como segredos do Cofre da Chave.

Finalmente, no Visual Studio Code, atualize as configurações do aplicativo Web para fazer referência aos segredos armazenados no Cofre da Chave. O aplicativo agora pode acessar valores de configuração com segurança sem incorporá-los diretamente no código.

Criar o aplicativo Web

Essas etapas exigem a instalação da extensão Docker para VS Code.

1. Atualize o Registro de Contêiner do Azure na extensão do Docker para confirmar se o contêiner criado aparece na seção REGISTROS da extensão do Docker. Caso contrário, clique com o botão direito do rato no nome do registo e selecione Atualizar.

   

2. Selecione F1 ou CTRL+SHIFT+P para abrir a paleta de comandos, digite "Registros do Docker" e selecione o Registros do Docker: Implantar imagem no Serviço de Aplicativo do Azure... tarefa.

3. Insira os seguintes valores conforme solicitado para implantar a imagem:

   • Selecione o provedor do Registro: Azure
   • Assinatura: selecione a assinatura que contém o Registro de Contêiner do Azure que você criou anteriormente.
   • Selecionar registro: digite o nome do registro que você criou anteriormente neste tutorial.
   • Selecionar repositório: insira o nome do repositório msdocscontainerregistryname. Se não vires este repositório, atualiza a extensão do Docker na seção REGISTOS.
   • Selecione a tag: mais recente para a tag da imagem.
   • Insira um nome globalmente exclusivo para o aplicativo Web: insira um nome que seja globalmente exclusivo para o Serviço de Aplicativo do Azure. Por exemplo, se você usar msdocs-website-name, a URL do aplicativo Web será http://msdocs-website-name.azurewebsites.net.
   • Selecione um grupo de recursos: use o grupo de recursos que contém o Registro de Contêiner do Azure criado anteriormente.
   • Selecione um plano do Linux App Service: use um existente ou crie um novo.

4. Veja a janela OUTPUT para obter detalhes da implantação. Uma das linhas de saída é "Concedendo permissão para que o Serviço de Aplicações extraia a imagem do ACR...", em que o Serviço de Aplicações acede ao registo utilizando uma identidade gerida.

   

   O site final https://<app-name>.azurewebsites.net ainda não está pronto porque precisa especificar informações do MongoDB.

   Observação

   Quando se implementa com o Visual Studio Code, a identidade gerida já está configurada para o App Service extrair imagens do registo. Você pode confirmar que a identidade gerenciada está habilitada exibindo os logs na janela OUTPUT e procurando a mensagem "Concedendo permissão para o Serviço de Aplicativo extrair imagem do ACR...".

Configurar identidade gerenciada e webhook

Durante a implantação com o VS Code, é criado um webhook que permite que o aplicativo Web extraia novas imagens do Registro de Contêiner do Azure.

1. Examine a configuração de webhooks no portal do Azure para confirmar que o URI de serviço termina com "/api/registry/webhook". Para revisar o URI do serviço, abra a extensão Docker no VS Code e localize o registro que você criou. Clique com o botão direito do rato no registo e selecione Abrir no Portal. O registro de contêiner é aberto no portal do Azure. Clique em Serviços e, em seguida, clique em Webhooks. Abra o menu de contexto e clique em Configurar.

   

2. Confirme se o URI do serviço termina com "/api/registry/webhook". Caso contrário, adicione-o ao final da cadeia de caracteres e clique em Salvar

Configurar a conexão com o MongoDB usando valores codificados

Nesta etapa, você especifica as variáveis de ambiente necessárias para que o aplicativo Web se conecte ao MongoDB.

Observação

Para configurar variáveis de ambiente para o aplicativo Web a partir do VS Code, você deve ter o pacote de extensão Ferramentas do Azure instalado e estar conectado ao Azure a partir do VS Code.

1. No modo de exibição do Azure no VS Code (da extensão Ferramentas do Azure):

   1. Expanda RECURSOS e encontre Serviços de Aplicações na sua subscrição. (Certifique-se de agrupar os recursos por Tipo de Recurso .)

   2. Expanda Serviços de Aplicativos e localize o aplicativo Web que você criou.

   3. Expanda seu aplicativo Web e clique com o botão direito do mouse em Configurações do aplicativo.

   4. Selecione Adicionar nova configuração....

   

2. Cada vez que você adiciona uma nova configuração, uma caixa de diálogo aparece na parte superior da janela VS Code, onde você pode adicionar o nome da configuração seguido de seu valor. Adicione as seguintes configurações:

   • CONNECTION_STRING: a cadeia de conexão MongoDB. Mais adiante neste tutorial, você define esse valor para a cadeia de conexão que armazena no Cofre da Chave do Azure.
   • DB_NAME: restaurants_reviews
   • COLLECTION_NAME: restaurants_reviews
   • WEBSITES_PORT: 8000 para Django e 5000 para Flask. Essa variável de ambiente especifica a porta na qual o contêiner está escutando.
   • SECRET_KEY: SupersecretKeyThatisPassedToPythonApp. Esta chave secreta é uma string aleatória usada por Django e Flask para criptografar dados da sessão. Mais adiante neste tutorial, você define esse valor como a cadeia de caracteres aleatória que você armazena no Cofre da Chave do Azure.

Navegar no site usando valores codificados

No modo de exibição do Azure no VS Code (da extensão Ferramentas do Azure):

1. Expanda RECURSOS e encontre Serviços de Aplicações na sua subscrição. (Certifique-se de agrupar os recursos por Tipo de Recurso .)

2. Clique com o botão direito do rato na sua aplicação Web e selecione Procurar Website. Se o seu site mostrar um erro, aguarde alguns minutos e tente novamente. Pode levar alguns minutos para que o aplicativo Web seja iniciado. Consulte também Solução de problemas do Serviço de Aplicativo.

Criar cofre de chaves com autorização RBAC

Nesta etapa, cria-se um Cofre de Chaves do Azure para armazenar a cadeia de conexão MongoDB e o SECRET_KEY específico da aplicação web. O Azure Key Vault é um serviço seguro para armazenar segredos, chaves de API, cadeias de conexão e certificados. O Cofre da Chave está configurado para usar o RBAC (controle de acesso baseado em função) para gerenciar o acesso por meio de funções do Azure em vez das políticas de acesso tradicionais. O aplicativo Web usa sua identidade gerenciada atribuída ao sistema para recuperar segredos com segurança em tempo de execução.

Observação

Você pode configurar o VS Code para usar a CLI do Azure ou o PowerShell. Para selecionar seu shell padrão no VS Code, selecione F1 ou CTRL+SHIFT+P para abrir a paleta de comandos. Em seguida, digite Terminal: Selecione Perfil padrão. Na paleta de comandos, digite e selecione: Terminal: Selecione Perfil padrão e, em seguida, selecione o shell padrão desejado.

1. Execute o seguinte comando da CLI do Azure para criar um novo Cofre de Chaves. Este comando usa o bash ou o PowerShell para criar um Cofre de Chaves com autorização RBAC habilitada.

   Bash

   #!/bin/bash
   RESOURCE_GROUP_NAME="msdocs-web-app-rg"
   LOCATION="westus"
   KEYVAULT_NAME="${RESOURCE_GROUP_NAME}-kv"
   
   az keyvault create \
     --name "$KEYVAULT_NAME" \
     --resource-group "$RESOURCE_GROUP_NAME" \
     --location "$LOCATION" \
     --enable-rbac-authorization true
   

   PowerShell

   # PowerShell syntax
   $RESOURCE_GROUP_NAME="msdocs-web-app-rg"
   $LOCATION="westus"
   $KEYVAULT_NAME="${RESOURCE_GROUP_NAME}-kv"
   
   az keyvault create `
     --name "$KEYVAULT_NAME" `
     --resource-group "$RESOURCE_GROUP_NAME" `
     --location "$LOCATION" `
     --enable-rbac-authorization true
   

Conceder a função de Oficial de Segredos ao usuário conectado

Para armazenar segredos no Cofre de Chaves do Azure, o usuário que executa o script deve receber a função de Oficial de Segredos do Cofre de Chaves . Esta função permite que o utilizador crie e gerencie segredos dentro do depósito.

Nesta etapa, o script atribui essa função ao usuário conectado no momento, permitindo que ele armazene com segurança dados confidenciais do aplicativo, como a cadeia de conexão MongoDB e a SECRET_KEY do aplicativo.

Ao usar o RBAC (Controle de Acesso Role-Based do Azure), essa abordagem garante acesso seguro e auditável ao Cofre da Chave com base na identidade, evitando a necessidade de incorporar credenciais diretamente em arquivos de código ou configuração.

Observação

O usuário deve receber a função de Oficial de Segredos do Cofre de Chavesantes de tentar armazenar quaisquer segredos no cofre de chaves. Essa atribuição é feita usando o comando az role assignment create no âmbito do Azure Key Vault.

1. Nesta etapa, você usa o comando az role assignment create para atribuir a função no escopo do Cofre de Chaves.

   Bash

   #!/bin/bash
   CALLER_ID=$(az ad signed-in-user show --query id -o tsv)
   echo $CALLER_ID # Verify this value retrieved successfully. In production, poll to verify this value is retrieved successfully.
   
   az role assignment create \
     --role "Key Vault Secrets Officer" \
     --assignee "$CALLER_ID" \
     --scope "/subscriptions/$(az account show --query id -o tsv)/resourceGroups/$RESOURCE_GROUP_NAME/providers/Microsoft.KeyVault/vaults/$KEYVAULT_NAME"
   
   

   PowerShell

   # PowerShell syntax
   $CALLER_ID=$(az ad signed-in-user show --query id -o tsv)
   echo $CALLER_ID # Verify this value retrieved successfully. In production, poll to verify this value is retrieved successfully.
   
   az role assignment create `
     --role "Key Vault Secrets Officer" `
     --assignee "$CALLER_ID" `
     --scope "/subscriptions/$(az account show --query id -o tsv)/resourceGroups/$RESOURCE_GROUP_NAME/providers/Microsoft.KeyVault/vaults/$KEYVAULT_NAME"
   

Armazenar segredos no Cofre da Chave

Para evitar segredos de codificação em seu aplicativo, nesta etapa você armazena a cadeia de conexão MongoDB para a instância do MongoDB e a chave secreta do aplicativo Web no Cofre de Chaves do Azure. Esses segredos podem ser acessados com segurança pelo aplicativo Web em tempo de execução por meio de sua identidade gerenciada, sem a necessidade de armazenar credenciais em código ou configuração.

Observação

Embora este tutorial armazene apenas a cadeia de conexão e a chave secreta no cofre de chaves, você pode, opcionalmente, armazenar outras configurações do aplicativo, como o nome do banco de dados MongoDB ou o nome da coleção no Cofre da Chave.

1. Nesta etapa, você usa o comando az cosmosdb keys list para recuperar a cadeia de conexão MongoDB. Em seguida, use o comando az keyvault secret set para armazenar a cadeia de conexão e uma chave secreta gerada aleatoriamente no Cofre da Chave.

   Bash

   #!/bin/bash
   ACCOUNT_NAME="msdocs-cosmos-db-account-name"
   
   MONGO_CONNECTION_STRING=$(az cosmosdb keys list \
     --name "$ACCOUNT_NAME" \
     --resource-group "$RESOURCE_GROUP_NAME" \
     --type connection-strings \
     --query "connectionStrings[?description=='Primary MongoDB Connection String'].connectionString" -o tsv)
   
   SECRET_KEY=$(openssl rand -base64 32 | tr -dc 'a-zA-Z0-9')
   # This key is cryptographically secure, using OpenSSL’s strong random number generator.
   
   az keyvault secret set \
     --vault-name "$KEYVAULT_NAME" \
     --name "MongoConnectionString" \
     --value "$MONGO_CONNECTION_STRING"
   
   az keyvault secret set \
     --vault-name "$KEYVAULT_NAME" \
     --name "MongoSecretKey" \
     --value "$SECRET_KEY"
   

   PowerShell

   # PowerShell syntax
   $ACCOUNT_NAME="msdocs-cosmos-db-account-name"
   
   $MONGO_CONNECTION_STRING = az cosmosdb keys list `
     --name $ACCOUNT_NAME `
     --resource-group $RESOURCE_GROUP_NAME `
     --type connection-strings `
     --query "connectionStrings[?description=='Primary MongoDB Connection String'].connectionString" `
     -o tsv
   
   # Generate a 32-byte cryptographically secure random value
   $bytes = New-Object 'Byte[]' 32
   [System.Security.Cryptography.RandomNumberGenerator]::Create().GetBytes($bytes)
   
   # Convert to base64 and filter to alphanumeric characters only
   $base64 = [Convert]::ToBase64String($bytes)
   $alphanumeric = $base64 -replace '[^a-zA-Z0-9]', ''
   
   # Truncate to 50 characters
   $SECRET_KEY = $alphanumeric.Substring(0, [Math]::Min(50, $alphanumeric.Length))
   
   az keyvault secret set `
     --vault-name "$KEYVAULT_NAME" `
     --name "MongoConnectionString" `
     --value "$MONGO_CONNECTION_STRING"
   
   az keyvault secret set `
     --vault-name "$KEYVAULT_NAME" `
     --name "MongoSecretKey" `
     --value "$SECRET_KEY"
   

Conceder acesso ao cofre de chaves à identidade gerenciada do aplicativo Web

A aplicação Web precisa de permissão para aceder à string de conexão do MongoDB e ao SECRET_KEY que você armazenou no cofre de chaves. Para conceder essas permissões, atribua a função Usuário de Segredos do Cofre de Chaves à identidade gerenciada atribuída pelo sistema do aplicativo Web.

1. Nesta etapa, você usa o identificador exclusivo (ID principal) da identidade gerenciada atribuída pelo sistema do aplicativo Web para conceder ao aplicativo Web acesso ao Cofre de Chaves com a função Usuário de Segredos do Cofre de Chaves usando o comando az role assignment create .

   Bash

   #!/bin/bash
     APP_SERVICE_NAME="msdocs-website-name"
     PRINCIPAL_ID=$(az webapp identity show \
       --name "$APP_SERVICE_NAME" \
       --resource-group "$RESOURCE_GROUP_NAME" \
       --query principalId \
       -o tsv)
   echo $PRINCIPAL_ID # Verify this value retrieved successfully. In production, poll for successful 'AcrPull' role assignment using `az role assignment list`.    
   
   az role assignment create \
   --role "Key Vault Secrets User" \
   --assignee "$PRINCIPAL_ID" \
   --scope "/subscriptions/$(az account show --query id -o tsv)/resourceGroups/$RESOURCE_GROUP_NAME/providers/Microsoft.KeyVault/vaults/$KEYVAULT_NAME"
   

   PowerShell

   # PowerShell syntax
       $PRINCIPAL_ID=$(az webapp identity show `
     --name "$APP_SERVICE_NAME" `
     --resource-group "$RESOURCE_GROUP_NAME" `
     --query principalId `
     -o tsv)
   echo $PRINCIPAL_ID # Verify this value retrieved successfully. In production, poll for successful AcrPull role assignment using `az role assignment list`.    
   
   
   az role assignment create `
   --role "Key Vault Secrets User" `
   --assignee "$PRINCIPAL_ID"`
   --scope "/subscriptions/$(az account show --query id -o tsv)/resourceGroups/$RESOURCE_GROUP_NAME/providers/Microsoft.KeyVault/vaults/$KEYVAULT_NAME"
       ```
   
   ---
   
   

Configurar a conexão com o MongoDB usando segredos do Key Vault

Nesta etapa, você atualiza as variáveis de ambiente necessárias para se conectar ao MongoDB para usar os valores armazenados no cofre de chaves.

1. No modo de exibição do Azure no VS Code (da extensão Ferramentas do Azure):

   1. Expanda RECURSOS e encontre Serviços de Aplicações na sua subscrição. (Certifique-se de agrupar os recursos por Tipo de Recurso .)

   2. Expanda Serviços de Aplicativo, expanda seu aplicativo Web e expanda Configurações do Aplicativo.

   3. Modifique as seguintes definições:

   • CADEIA_DE_CONEXÃO: @Microsoft.KeyVault(SecretUri=https://msdocs-web-app-rg-kv.vault.azure.net/secrets/MongoConnectionString)
   • SECRET_KEY: @Microsoft.KeyVault(SecretUri=https://$KEYVAULT_NAME.vault.azure.net/secrets/MongoSecretKey)

   Observação

   Para verificar se as configurações do aplicativo estão definidas corretamente, você pode usar o comando az webapp config appsettings list para listar as configurações do aplicativo Web. A forma do comando é: az webapp config appsettings list --/<resource-group msdocs-web-app-rg/> --name /<website-name/>. Este comando lista todas as configurações do aplicativo Web, incluindo as que você acabou de definir.

Navegue no site usando os segredos do Key Vault

No modo de exibição do Azure no VS Code (da extensão Ferramentas do Azure):

1. Expanda RECURSOS e encontre Serviços de Aplicações na sua subscrição. (Certifique-se de agrupar os recursos por Tipo de Recurso .)

2. Clique com o botão direito do rato na sua aplicação Web e selecione Procurar Website. Se o seu site mostrar um erro, aguarde alguns minutos e tente novamente. Pode levar alguns minutos para que o aplicativo Web seja iniciado. Consulte também Solução de problemas do Serviço de Aplicativo.

Solucionar problemas de implantação

Se não conseguir ver a aplicação de exemplo, tente os passos seguintes.

• Com a implantação de contentores e o Serviço de Aplicações, verifique sempre a página de Registos do Centro de Implantação no portal do Azure. Confirme se o contêiner foi extraído e está em execução. A tração inicial do recipiente pode demorar alguns momentos.
• Tente reiniciar o Serviço de Aplicativo e veja se isso resolve o problema.
• Se houver erros de programação, esses erros aparecerão nos logs do aplicativo. Na página do portal do Azure para o Serviço de Aplicativo, selecione Diagnosticar e resolver problemas/registos da Aplicação.
• O aplicativo de exemplo depende de uma conexão com o Azure Cosmos DB para MongoDB. Confirme se o Serviço de Aplicativo tem configurações de aplicativo com as informações de conexão corretas.
• Confirme se a identidade gerenciada está habilitada para o Serviço de Aplicativo e é usada no Centro de Implantação. Na página do portal do Azure para o Serviço de Aplicativo, vá para o recurso Centro de Implantação do Serviço de Aplicativo e confirme que a Autenticação está definida como Identidade Gerenciada.
• Verifique se o webhook está definido no Registro de Contêiner do Azure. O webhook permite que o Serviço de Aplicações obtenha a imagem do contentor. Em particular, verifique se o URI do serviço termina com "/api/registry/webhook". Se não, adicione-o.
• Diferentes SKUs do Registro de Contêiner do Azure têm recursos diferentes, incluindo o número de webhooks. Se estiver a reutilizar um registo existente, poderá ver a mensagem: "Cota excedida para webhooks do tipo de recurso no registo SKU Basic. Saiba mais sobre diferentes cotas de SKU e processo de atualização: https://aka.ms/acr/tiers". Se vir esta mensagem, utilize um novo registo ou reduza o número de webhooks de registo em utilização.

Próximo passo

Limpar recursos