Crie e execute um aplicativo Web Python em contêiner localmente

Nesta parte da série de tutoriais, você aprenderá a construir e executar um Django em contêineres ou um aplicativo web Flask Python em seu computador local. Para armazenar dados para este aplicativo, você pode usar uma instância local do MongoDB ou o Azure Cosmos DB para MongoDB. Este artigo é a parte 2 de uma série de tutoriais de 5 partes. Deve completar a parte 1 antes de começar este artigo.

O seguinte diagrama de serviço destaca os componentes locais abordados neste artigo. Neste artigo, também aprende como usar o Azure Cosmos DB para MongoDB com uma imagem local do Docker, em vez de uma instância local do MongoDB.

Clone ou baixe a aplicação Python exemplificativa

Nesta seção, você clona ou baixa o aplicativo Python de exemplo que usa para criar uma imagem do Docker. Você pode escolher entre um aplicativo web Django ou Flask Python. Se você tiver seu próprio aplicativo Web Python, poderá optar por usá-lo. Se você usar seu próprio aplicativo Web Python, certifique-se de que seu aplicativo tenha um Dockerfile na pasta raiz e possa se conectar a um banco de dados MongoDB.

git clone
Baixar

Clone o repositório Django ou Flask em uma pasta local usando um dos seguintes comandos:

Django
Flask

# Django
git clone https://github.com/Azure-Samples/msdocs-python-django-container-web-app.git

# Flask
git clone https://github.com/Azure-Samples/msdocs-python-flask-container-web-app.git

Vai à pasta raiz do teu repositório clonado.

Django
Flask

# Django
cd msdocs-python-django-container-web-app

# Flask
cd msdocs-python-flask-container-web-app

Criar uma imagem do Docker

Nesta seção, você cria uma imagem do Docker para o aplicativo Web Python usando o Visual Studio Code ou a CLI do Azure. A imagem do Docker contém o aplicativo Web Python, suas dependências e o tempo de execução do Python. Constróis a imagem Docker a partir de um Dockerfile que define o conteúdo e o comportamento da imagem. O Dockerfile está na pasta raiz do aplicativo de exemplo que você clonou ou baixou (ou forneceu você mesmo).

Sugestão

Se você é novo na CLI do Azure, consulte Introdução à CLI do Azure para saber como baixar e instalar a CLI do Azure localmente ou como executar comandos da CLI do Azure no Azure Cloud Shell.

CLI do Azure
Código VS

Para construir a imagem do Docker utilizando a CLI do Docker, é necessário Docker. Depois de instalares o Docker, abre uma janela de terminal e vai à pasta de exemplos.

Observação

As etapas nesta seção exigem que o daemon do Docker esteja em execução. Em algumas instalações, como no Windows, é necessário abrir Docker Desktop, que inicia o daemon, antes de poder avançar.

Confirme se o Docker está acessível executando o seguinte comando na pasta raiz do aplicativo de exemplo.
```
docker
```
Se, depois de executar este comando, conseguires ver a ajuda para a CLI do Docker, o Docker estará acessível. Caso contrário, verifique se o Docker está instalado e se seu shell tem acesso à CLI do Docker.
Crie a imagem do Docker para o aplicativo Web Python usando o comando Docker build .

A forma geral do comando é docker build --rm --pull --file "<path-to-project-root>/Dockerfile" --label "com.microsoft.created-by=docker-cli" --tag "<container-name>:latest" "<path-to-project-root>".

Se você estiver na pasta raiz do projeto, use o seguinte comando para criar a imagem do Docker. O ponto (".") no final do comando refere-se ao diretório atual no qual o comando é executado. Para forçar uma reconstrução, adicione --no-cache.

Observação

O repositório de exemplos utiliza Python 3.8. Se estiver a criar o seu próprio Dockerfile, use uma versão Python suportada, como a 3.12 ou 3.13. Consulte suporte de versões do Python para as versões atualmente suportadas.
- Bash
- PowerShell
```
#!/bin/bash
docker build --rm --pull \
  --file "Dockerfile" \
  --label "com.microsoft.created-by=docker-cli" \
  --tag "msdocspythoncontainerwebapp:latest" \
    .
```
```
# PowerShell syntax
docker build --rm --pull `
  --file "Dockerfile" `
  --label "com.microsoft.created-by=docker-cli" `
  --tag "msdocspythoncontainerwebapp:latest" `
    .
```
Confirme se a imagem foi criada com êxito usando o comando Docker images .
```
docker images
```
O comando retorna uma lista de imagens por nome do repositório, TAG e data de criação, entre outras características da imagem.

Para construir a imagem Docker localmente usando Visual Studio Code, precisas de Visual Studio Code e da extensão Docker. Instale o Visual Studio Code e a extensão do Docker antes de continuar. Depois de instalares o Visual Studio Code e a extensão Docker, vai à pasta de exemplo que clonaste ou descarregaste e abre o VS Code usando o comando code ..

Observação

As etapas nesta seção exigem que o daemon do Docker esteja em execução. Em algumas instalações, como no Windows, é necessário abrir Docker Desktop para iniciar o daemon antes de prosseguir.

Depois de instalares o Visual Studio Code e a extensão Docker, vai à pasta de exemplo que clonaste ou descarregaste e abre o VS Code usando o comando code ..
No VS Code, abra a extensão Docker e selecione a extensão Docker na barra de atividades.

Se a extensão do Docker relatar um erro "Falha ao conectar", verifique se o Docker está instalado e em execução.
Para criar a imagem do Docker, clique com o botão direito do mouse no Dockerfile e selecione Construir imagem....

Para obter mais informações sobre a sintaxe do Dockerfile, consulte a referência do Dockerfile.
Para confirmar que a imagem foi construída, expanda a seção IMAGENS da extensão Docker e procure a imagem criada recentemente. O nome dessa imagem de contêiner é "msdocspythoncontainerwebapp" (esse valor é definido no arquivo .vscode/tasks.json ).

Neste ponto, você tem uma imagem local do Docker chamada "msdocspythoncontainerwebapp" com a tag "mais recente". As tags ajudam a definir detalhes da versão, uso pretendido, estabilidade e outras informações relevantes. Para obter mais informações, consulte Recomendações para etiquetagem e versionamento de imagens de contêiner.

Observação

Também pode visualizar imagens que constrói a partir do VS Code ou usando diretamente a CLI Docker, usando a aplicação Docker Desktop .

Configurar o MongoDB

A sua aplicação web Python requer uma base de dados MongoDB e uma coleção, ambas chamadas restaurants_reviews, para armazenar dados. Neste tutorial, você usa uma instalação local do MongoDB e uma instância do Azure Cosmos DB para MongoDB para criar e acessar o banco de dados e a coleção.

Importante

Não use um banco de dados MongoDB que você usa na produção. Neste tutorial, armazene a cadeia de ligação do MongoDB de uma destas instâncias do MongoDB numa variável de ambiente. Qualquer pessoa que possa inspecionar o seu recipiente – por exemplo, usando docker inspect – pode ver esta cadeia de ligação.

Base de Dados Mongo Local

Crie uma instância local do MongoDB usando a CLI do Azure.

Instala o MongoDB se ainda não estiver instalado.

Para verificar se o MongoDB está instalado, use o MongoDB Shell (mongosh). Se os comandos seguintes não funcionarem, pode ser necessário instalar explicitamente o Mongosh ou ligar o Mongosh ao seu servidor MongoDB.
- Use o seguinte comando para abrir o shell do MongoDB e obter a versão do shell do MongoDB e do servidor MongoDB:
```
mongosh
```
  Sugestão
  
  Para retornar apenas a versão do servidor MongoDB instalada no seu sistema, feche e reabra o shell do MongoDB e use o seguinte comando: mongosh --quiet --exec 'db.version()'
  
  Em algumas configurações, você também pode invocar diretamente o daemon Mongo em seu shell bash.
```
mongod --version
```
Edite o arquivo mongod.cfg na pasta \MongoDB\Server\8.0\bin e adicione o endereço IP local do seu computador à chave bindIP.

Observação

O caminho do ficheiro de configuração varia consoante o sistema operativo e a versão do MongoDB. No macOS, procure por /usr/local/etc/mongod.conf ou /opt/homebrew/etc/mongod.conf. No sistema Linux, verifique /etc/mongod.conf.

A bindip chave no arquivo de configuração do MongoD define os nomes de host e endereços IP que o MongoDB escuta para conexões de cliente. Adicione o IP atual do seu computador de desenvolvimento local. O aplicativo Web Python de exemplo executado localmente em um contêiner do Docker se comunica com o computador host com esse endereço.

Por exemplo, parte do arquivo de configuração deve ter esta aparência:
```
net:
  port: 27017
  bindIp: 127.0.0.1,<local-ip-address>
```
Salve suas alterações neste arquivo de configuração.

Importante

Você precisa de privilégios administrativos para salvar as alterações feitas nesse arquivo de configuração.
Reinicie o MongoDB para pegar as alterações no arquivo de configuração.
Abra um shell do MongoDB e execute o seguinte comando para definir o nome do banco de dados como "restaurants_reviews" e o nome da coleção como "restaurants_reviews". Você também pode criar um banco de dados e uma coleção com a extensão VS Code MongoDB ou qualquer outra ferramenta compatível com MongoDB.
```
> help
> use restaurants_reviews
> db.restaurants_reviews.insertOne({})
> show dbs
> exit
```

Depois de concluir a etapa anterior, a cadeia de conexão MongoDB local é "mongodb://127.0.0.1:27017/", o nome do banco de dados é "restaurants_reviews" e o nome da coleção é "restaurants_reviews".

Azure Cosmos DB for MongoDB

Agora, crie uma Azure Cosmos DB para uma instância MongoDB usando a CLI do Azure.

Observação

Na parte 4 desta série de tutoriais, você usa a instância do Azure Cosmos DB para MongoDB para executar o aplicativo Web no Serviço de Aplicativo do Azure.

Antes de executar o script a seguir, substitua o local, o grupo de recursos e o nome da conta do Azure Cosmos DB para MongoDB por valores apropriados (opcional). Usa o mesmo grupo de recursos para todos os recursos do Azure que criares neste tutorial para facilitar a eliminação quando terminares.

O script leva alguns minutos para ser executado.

Bash
PowerShell

#!/bin/bash
# LOCATION: The Azure region. Use the "az account list-locations -o table" command to find a region near you.
LOCATION='westus'
# RESOURCE_GROUP_NAME: The resource group name, which can contain underscores, hyphens, periods, parenthesis, letters, and numbers.
RESOURCE_GROUP_NAME='msdocs-web-app-rg'
# ACCOUNT_NAME: The Azure Cosmos DB for MongDB account name, which can contain lowercase letters, hyphens, and numbers.
ACCOUNT_NAME='msdocs-cosmos-db-account-name'

# Create a resource group
echo "Creating resource group $RESOURCE_GROUP_NAME in $LOCATION..."
az group create --name $RESOURCE_GROUP_NAME --location $LOCATION

# Create a Cosmos account for MongoDB API
echo "Creating $ACCOUNT_NAME. This command may take a while to complete."
az cosmosdb create --name $ACCOUNT_NAME --resource-group $RESOURCE_GROUP_NAME --kind MongoDB

# Create a MongoDB API database
echo "Creating database restaurants_reviews"
az cosmosdb mongodb database create --account-name $ACCOUNT_NAME --resource-group $RESOURCE_GROUP_NAME --name restaurants_reviews

# Create a MongoDB API collection
echo "Creating collection restaurants_reviews"
az cosmosdb mongodb collection create --account-name $ACCOUNT_NAME --resource-group $RESOURCE_GROUP_NAME --database-name restaurants_reviews --name restaurants_reviews

# Get the connection string for the MongoDB database
echo "Get the connection string for the MongoDB account"
az cosmosdb keys list --name $ACCOUNT_NAME --resource-group $RESOURCE_GROUP_NAME --type connection-strings

echo "Copy the Primary MongoDB Connection String from the list above"

# PowerShell syntax
# LOCATION: The Azure region. Use "az account list-locations -o table" to find a region near you.
# RESOURCE_GROUP_NAME: The resource group name, which can contain underscores, hyphens, periods, parenthesis, letters, and numbers.
# ACCOUNT_NAME: The Azure Cosmos DB for MongoDB account name, which can contain lowercase letters, hyphens, and numbers.

$LOCATION = "westus"
$RESOURCE_GROUP_NAME = "msdocs-web-app-rg"
$ACCOUNT_NAME = "msdocs-cosmos-db-account-name"

# Create a resource group
Write-Output "Creating resource group $RESOURCE_GROUP_NAME in $LOCATION..."
az group create --name $RESOURCE_GROUP_NAME --location $LOCATION

# Create a Cosmos account for MongoDB API
Write-Output "Creating $ACCOUNT_NAME. This command may take a while to complete."
az cosmosdb create --name $ACCOUNT_NAME --resource-group $RESOURCE_GROUP_NAME --kind MongoDB

# Create a MongoDB API database
Write-Output "Creating database restaurants_reviews"
az cosmosdb mongodb database create --account-name $ACCOUNT_NAME --resource-group $RESOURCE_GROUP_NAME --name "restaurants_reviews"

# Create a MongoDB API collection
Write-Output "Creating collection restaurants_reviews"
az cosmosdb mongodb collection create --account-name $ACCOUNT_NAME --resource-group $RESOURCE_GROUP_NAME --database-name "restaurants_reviews" --name "restaurants_reviews"

# Get the connection string for the MongoDB database
Write-Output "Getting the connection string for the MongoDB account..."
az cosmosdb keys list --name $ACCOUNT_NAME --resource-group $RESOURCE_GROUP_NAME --type connection-strings

Write-Output "Copy the Primary MongoDB Connection String from the list above."

Quando o script terminar, copie a String Principal de Ligação MongoDB da saída do último comando para a sua prancheta ou outro local.

{
  "connectionStrings": [
    {
      "connectionString": ""mongodb://msdocs-cosmos-db:pnaMGVtGIRAZHUjsg4GJBCZMBJ0trV4eg2IcZf1TqV...5oONz0WX14Ph0Ha5IeYACDbuVrBPA==@msdocs-cosmos-db.mongo.cosmos.azure.com:10255/?ssl=true&replicaSet=globaldb&retrywrites=false&maxIdleTimeMS=120000&appName=@msdocs-cosmos-db@"",
      "description": "Primary MongoDB Connection String",
      "keyKind": "Primary",
      "type": "MongoDB"
    },

    ...
  ]
}

Depois de concluir a etapa anterior, você terá uma cadeia de conexão do Azure Cosmos DB para MongoDB do formulário mongodb://<server-name>:<password>@<server-name>.mongo.cosmos.azure.com:10255/?ssl=true&<other-parameters>, um banco de dados chamado restaurants_reviewse uma coleção chamada restaurants_reviews.

Para obter mais informações sobre como usar a CLI do Azure para criar uma conta do Cosmos DB para MongoDB e criar bancos de dados e coleções, consulte Criar um banco de dados e uma coleção para o MongoDB para Azure Cosmos DB usando a CLI do Azure. Você também pode usar o PowerShell, a extensão VS Code Azure Databases e o portal do Azure.

Sugestão

Na extensão VS Code Azure Databases, você pode clicar com o botão direito do mouse no servidor MongoDB e obter a cadeia de conexão.

Executar a imagem localmente em um contêiner

Agora está pronto para executar o contentor Docker localmente, usando a sua instância MongoDB local ou a sua instância Cosmos DB para MongoDB. Nesta secção do tutorial, aprendes a usar tanto o VS Code como o CLI do Azure para executar a imagem localmente. A aplicação de exemplo espera que a informação de ligação ao MongoDB seja passada usando variáveis de ambiente. Existem vários métodos para passar variáveis de ambiente para um contentor localmente. Cada método tem vantagens e desvantagens em termos de segurança. Evite fazer check-in ou deixar informações sensíveis no código do contentor.

Observação

Quando implementas a aplicação web no Azure, a aplicação web obtém informações de ligação dos valores do ambiente definidos como definições de configuração do Serviço de Aplicação. Nenhuma das modificações para o cenário do ambiente de desenvolvimento local se aplica.

CLI do Azure
Código VS

MongoDB local

Use os comandos a seguir com sua instância local do MongoDB para executar a imagem do Docker localmente.

Execute a versão mais recente da imagem.

Bash
PowerShell

#!/bin/bash

# Define variables
# Set the port number based on the framework being used:
# 8000 for Django, 5000 for Flask
export PORT=<port-number>  # Replace with actual port (e.g., 8000 or 5000)

# Set your computer''s IP address (replace with actual IP)
export YOUR_IP_ADDRESS=<your-computer-ip-address>  # Replace with actual IP address

# Run the Docker container with the required environment variables
docker run --rm -it \
  --publish "$PORT:$PORT" \
  --add-host "mongoservice:$YOUR_IP_ADDRESS" \
  --env CONNECTION_STRING=mongodb://mongoservice:27017 \
  --env DB_NAME=restaurants_reviews \
  --env COLLECTION_NAME=restaurants_reviews \
  --env SECRET_KEY="supersecretkeythatispassedtopythonapp" \
  msdocspythoncontainerwebapp:latest

# PowerShell syntax
# Define variables
# Set the port number based on the framework being used:
# 8000 for Django, 5000 for Flask
$PORT = "your_port_number"  # Replace with your actual port number
$YOUR_IP_ADDRESS = "your_ip_address"  # Replace with your actual IP address

# Run the Docker container with the required environment variables
docker run --rm -it `
    --publish "${PORT}:${PORT}" `
    --add-host "mongoservice:$YOUR_IP_ADDRESS" `
    --env CONNECTION_STRING="mongodb://mongoservice:27017" `
    --env DB_NAME="restaurants_reviews" `
    --env COLLECTION_NAME="restaurants_reviews" `
    --env SECRET_KEY="supersecretkeythatispassedtopythonapp" `
    msdocspythoncontainerwebapp:latest

Confirme se o contêiner está em execução. Em outra janela do console, execute o comando docker container ls .
```
docker container ls
```
Vê o seu recipiente msdocspythoncontainerwebapp:latest na lista. Observe a NAMES coluna da saída e a PORTS coluna. Use o nome do contêiner para parar o contêiner.
Teste o aplicativo Web.

Aceda a http://127.0.0.1:8000 para o Django e http://127.0.0.1:5000/ para o Flask.
Desligue o contentor.
```
docker container stop <container-name>
```

Azure Cosmos DB for MongoDB

Use os comandos a seguir com sua instância do Azure Cosmos DB para MongoDB para executar a imagem do Docker no Azure.

Execute a versão mais recente da imagem.

Bash
PowerShell

#!/bin/bash
# PORT=8000 for Django and 5000 for Flask
export PORT=<port-number>
export CONNECTION_STRING="<connection-string>"

docker run --rm -it \
  --publish $PORT:$PORT/tcp \
  --env CONNECTION_STRING=$CONNECTION_STRING \
  --env DB_NAME=restaurants_reviews \
  --env COLLECTION_NAME=restaurants_reviews \
  --env SECRET_KEY=supersecretkeythatyougenerate \
  msdocspythoncontainerwebapp:latest

# PowerShell syntax
# PORT=8000 for Django and 5000 for Flask
$PORT=<port-number>
$CONNECTION_STRING="<connection-string>"

docker run --rm -it `
  --publish ${PORT}:${PORT}/tcp `
  --env CONNECTION_STRING=$CONNECTION_STRING `
  --env DB_NAME=restaurants_reviews `
  --env COLLECTION_NAME=restaurants_reviews `
  --env SECRET_KEY=supersecretkeythatyougenerate `
  msdocspythoncontainerwebapp:latest

Para fins de demonstração, este exemplo mostra a passagem de informação sensível. Pode visualizar a informação da cadeia de ligação inspecionando o contentor usando o comando docker container inspect. Outra maneira de lidar com segredos é usar a funcionalidade BuildKit do Docker.

Abra uma nova janela de consola e execute o seguinte comando docker container ls para confirmar que o container está a correr.
```
docker container ls
```
Vê o seu recipiente msdocspythoncontainerwebapp:latest na lista. Observe a NAMES coluna da saída e a PORTS coluna. Use o nome do contêiner para parar o contêiner.
Teste o aplicativo Web.

Aceda a http://127.0.0.1:8000 para Django e a http://127.0.0.1:5000/ para Flask.
Desligue o contentor.
```
docker container stop <container-name>
```

Nesta secção do tutorial, use a extensão Docker no Visual Studio Code para executar o contentor. Você pode usar a cadeia de conexão para sua instância local do MongoDB ou sua instância do Cosmos DB para MongoDB dentro do VS Code.

Na pasta .vscode da aplicação de exemplo, o ficheirosettings.json define o que acontece quando usas a extensão Docker e selecionas Executar ou Executar Interativo no menu contextual de uma etiqueta. O arquivo settings.json contém dois modelos cada para os (MongoDB local) cenários e (MongoDB Azure) .

Se você estiver usando um banco de dados MongoDB local:
- Substitua ambas as instâncias de <YOUR_IP_ADDRESS> pelo seu endereço IP.
- Substitua ambas as instâncias de <CONNECTION_STRING> pela string de conexão do seu banco de dados MongoDB.
- Adicione a seguinte variável de ambiente à cadeia de variáveis passada para o comando Docker run para os modelos locais do MongoDB para os blocos de código "docker.commands.run" e "docker.commands.runInteractive":
```
-e 'SECRET_KEY=supersecretkeythatispassedtopythonapp'
```
Se você estiver usando um banco de dados do Azure Cosmos DB para MongoDB:
- Substitua ambas as instâncias de <CONNECTION_STRING> pela cadeia de conexão do Azure Cosmos DB para MongoDB.
- Adicione a seguinte variável de ambiente à lista de variáveis passadas para o comando Docker run nos templates do Azure Cosmos DB para MongoDB para os blocos de código "docker.commands.run" e "docker.commands.runInteractive":
```
-e 'SECRET_KEY=supersecretkeythatispassedtopythonapp'
```
Defina a docker.dockerPath definição de configuração usada pelos modelos. Para definir docker.dockerPath, abra a Paleta de Comandos VS Code (Ctrl+Shift+P), introduza "Preferências: Abrir Definições do Espaço de Trabalho" e depois introduza "docker.dockerPath" na caixa de Pesquisa. Digite "docker" (sem as aspas) para o valor da configuração.

Observação

Presume-se que o nome do banco de dados e o nome da coleção sejam restaurants_reviews.
Execute a imagem.
1. Na seção IMAGENS da extensão Docker, localize a imagem construída.
2. Expanda a imagem para encontrar a tag mais recente , clique com o botão direito do mouse e selecione Executar interativo.
3. Você será solicitado a selecionar a tarefa apropriada para seu cenário, "Configuração de execução interativa (MongoDB local)" ou "Configuração de execução interativa (MongoDB Azure)".
Com uma execução interativa, podes ver todas as declarações de impressão no código, o que pode ser útil para a detecção de erros. Você também pode selecionar Executar, que não é interativo e não mantém a entrada padrão aberta.

Importante

Esta etapa falhará se o perfil de terminal padrão estiver definido como Prompt de Comando (Windows). Para alterar o perfil padrão, abra a paleta de comandos VS Code (Ctrl+Shift+P), digite "Terminal: Select Default Profile" e selecione um perfil diferente no menu suspenso - como Git Bash ou PowerShell.
Confirme se o contêiner do Docker está em execução.
1. Na seção CONTAINERS da extensão do Docker, localize o contêiner.
2. Expanda o nó Contêineres Individuais e confirme se o contêiner "msdocspythoncontainerwebapp" está em execução. Procure um símbolo de triângulo verde ao lado do nome do contêiner.
Teste o aplicativo Web clicando com o botão direito do mouse no nome do contêiner e selecionando Abrir no navegador.

O navegador abre no seu navegador padrão como "http://127.0.0.1:8000" para Django ou "http://127.0.0.1:5000/" para Flask.

Observação

Se você receber um erro de tempo limite, verifique se o serviço MongoDB está em execução. Caso contrário, pare o contêiner do Docker no VS Code e reinicie o serviço MongoDB. Em seguida, inicie o contêiner do Docker novamente e tente acessar o aplicativo Web em seu navegador.
Pare o contentor.
1. Na seção CONTAINERS da extensão do Docker, localize o contêiner em execução.
2. Clique com o botão direito do mouse no contêiner e selecione Parar.

Sugestão

Também pode executar o contentor ao selecionar uma configuração de execução ou depuração. Quando executas ou depuras, as tarefas de extensão Docker em tasks.json são chamadas. A tarefa que é chamada depende da configuração de lançamento que selecionar. Para a tarefa "Docker: Python (MongoDB local)", especifique <YOUR-IP-ADDRESS>. Para a tarefa "Docker: Python (MongoDB Azure)", especifique <CONNECTION-STRING.>

Também podes iniciar um contentor a partir de uma imagem e pará-lo usando a aplicação Docker Desktop .

Próximo passo

Criar uma imagem de contêiner no Azure

Comentários

Esta página foi útil?

Last updated on 2026-05-26

Crie e execute um aplicativo Web Python em contêiner localmente

Clone ou baixe a aplicação Python exemplificativa

Criar uma imagem do Docker

Configurar o MongoDB

Base de Dados Mongo Local

Azure Cosmos DB for MongoDB

Executar a imagem localmente em um contêiner

MongoDB local

Azure Cosmos DB for MongoDB

Próximo passo

Comentários

Recursos adicionais