Implantar um aplicativo Web Python FastAPI com PostgreSQL no Azure

• Uma conta do Azure com uma subscrição ativa. Se não tiver uma conta do Azure, pode criar uma gratuitamente.
• Conhecimento em Python para desenvolvimento com FastAPI.

• Uma conta do Azure com uma subscrição ativa. Se não tiver uma conta do Azure, pode criar uma gratuitamente.
• CLI de Desenvolvimento do Azure instalada. Você pode seguir as etapas com o Azure Cloud Shell porque ele já tem a CLI do Desenvolvedor do Azure instalada.
• Conhecimento em Python com desenvolvimento com FastAPI.

1. Criar recursos de App Service e PostgreSQL

Nesta etapa, você cria os recursos do Azure. As etapas usadas neste tutorial criam um conjunto de recursos seguros por padrão que incluem o Serviço de Aplicativo e o Banco de Dados do Azure para PostgreSQL. Para o processo de criação, você especifica:

• O nome da aplicação web. É o nome usado como parte do nome DNS da sua aplicação web.
• A região onde a aplicação corre fisicamente no mundo.
• A pilha de tempo de execução para o aplicativo. É onde você seleciona a versão do Python a ser usada para seu aplicativo.
• O plano de hospedagem para o aplicativo. É a camada de preço que inclui o conjunto de recursos e a capacidade de dimensionamento para seu aplicativo.
• O Grupo de Recursos para o aplicativo. Um grupo de recursos permite agrupar (em um contêiner lógico) todos os recursos do Azure necessários para o aplicativo.

Entre no portal do Azure e siga estas etapas para criar seus recursos do Serviço de Aplicativo do Azure.

2. Verifique as configurações de conexão

O assistente de criação gerou as variáveis de conectividade para você já como configurações do aplicativo. As configurações do aplicativo são uma maneira de manter os segredos de conexão fora do seu repositório de código. Quando estiver pronto para mover os seus segredos para um local mais seguro, consulte Quickstart: Azure Key Vault biblioteca cliente de certificados para Python.

3. Implantar código de exemplo

Nesta etapa, você configura a implantação do GitHub usando as Ações do GitHub. É apenas uma das muitas maneiras de implementar no App Service, sendo também uma ótima forma de ter integração contínua no seu processo de implementação. Por padrão, cada git push no seu repositório do GitHub inicia a ação de compilação e implantação.

Tem problemas? Consulte o Guia de resolução de problemas.

4. Gerar esquema de banco de dados

Numa secção anterior, adicionaste src/entrypoint.sh como comando de arranque para a tua aplicação. entrypoint.sh contém a seguinte linha: python3 src/fastapi_app/seed_data.py. Este comando migra seu banco de dados. No aplicativo de exemplo, ele garante apenas que as tabelas corretas sejam criadas em seu banco de dados. Ele não preenche essas tabelas com nenhum dado.

Nesta secção, executa este comando manualmente para fins de demonstração. Com o banco de dados PostgreSQL protegido pela rede virtual, a maneira mais fácil de executar o comando é em uma sessão SSH com o contêiner do Serviço de Aplicativo.

5. Navegue até o aplicativo

6. Transmitir logs de diagnóstico

O aplicativo de exemplo usa o módulo de log Python Standard Library para ajudá-lo a diagnosticar problemas com seu aplicativo. O aplicativo de exemplo inclui chamadas para o registrador, conforme mostrado no código a seguir.

@app.get("/", response_class=HTMLResponse)
async def index(request: Request, session: Session = Depends(get_db_session)):
    logger.info("root called")
    statement = (
        select(Restaurant, func.avg(Review.rating).label("avg_rating"), func.count(Review.id).label("review_count"))
        .outerjoin(Review, Review.restaurant == Restaurant.id)
        .group_by(Restaurant.id)
    )

Os eventos podem levar vários minutos para aparecer nos logs de diagnóstico. Para saber mais sobre como iniciar sessão em aplicações Python, consulte Configurar Azure Monitor para a sua aplicação Python.

7. Limpar os recursos

Quando terminar, pode eliminar todos os recursos da sua subscrição do Azure eliminando o grupo de recursos.

1. Crie recursos do Azure e implante um aplicativo de exemplo

Nesta etapa, você cria os recursos do Azure e implanta um aplicativo de exemplo no Serviço de Aplicativo no Linux. As etapas usadas neste tutorial criam um conjunto de recursos seguros por padrão que incluem o Serviço de Aplicativo e o Banco de Dados do Azure para PostgreSQL.

1. Se ainda não o fez, clone a ramificação do repositório de starter-no-infra exemplo em um terminal local.

   git clone -b starter-no-infra https://github.com/Azure-Samples/msdocs-fastapi-postgresql-sample-app
   cd msdocs-fastapi-postgresql-sample-app
   

   Este ramo clonado é o seu ponto de partida. Contém uma aplicação FastAPI simples orientada a dados.

2. A partir da raiz do repositório, execute azd init.

   azd init --template msdocs-fastapi-postgresql-sample-app
   

3. Quando solicitado, dê as seguintes respostas:

   Pergunta	Resposta
   O diretório atual não está vazio. Gostaria de inicializar um projeto aqui no '<seu-diretório>'?	Y
   O que você gostaria de fazer com esses arquivos?	Manter os meus ficheiros existentes inalterados
   Insira um novo nome de ambiente	Escreva um nome exclusivo. O modelo azd usa esse nome como parte do nome DNS do seu aplicativo Web no Azure (<app-name>.azurewebsites.net). São permitidos caracteres alfanuméricos e hífenes.

4. Execute o azd up comando para provisionar os recursos necessários do Azure e implantar o código do aplicativo. Se ainda não estiver iniciado sessão no Azure, o navegador abre e pede-lhe para iniciar sessão. O azd up comando também te pede para selecionar a subscrição e o local desejados para implementar.

   azd up
   

   O azd up comando pode levar vários minutos para ser concluído. Ele também compila e implanta o código do aplicativo. Enquanto está em execução, o comando fornece mensagens sobre o processo de provisionamento e implantação, incluindo um link para a implantação no Azure. Quando terminar, o comando também exibirá um link para a aplicação de implementação.

   Este modelo azd contém arquivos (azure.yaml e o diretório infra ) que geram uma arquitetura segura por padrão com os seguintes recursos do Azure:

   • Grupo de recursos → O contêiner para todos os recursos criados.
   • Plano do Serviço de Aplicativo → Define os recursos de computação para o Serviço de Aplicativo. Um plano Linux na camada B1 é especificado.
   • Rede virtual → integrada à aplicação App Service e isola o tráfego da rede back-end.
   • Servidor flexível da Base de Dados do Azure para PostgreSQL → Acessível apenas de dentro da rede virtual. Um banco de dados e um usuário são criados para você no servidor.
   • Zona DNS privada → Permite a resolução DNS do servidor PostgreSQL na rede virtual.
   • Espaço de trabalho do Log Analytics → Atua como o contêiner de destino para seu aplicativo enviar seus logs, onde você também pode consultar os logs.

5. Quando o azd up comando terminar, anote os valores do ID de Subscrição, do Serviço de Aplicação e do Grupo de Recursos na saída. Você os usa nas seções a seguir. A sua saída deve ser semelhante à seguinte saída (parcial):

   Subscription: Your subscription name (1111111-1111-1111-1111-111111111111)
   Location: East US
   
     You can view detailed progress in the Azure Portal:
     https://portal.azure.com/#view/HubsExtension/DeploymentDetailsBlade/~/overview/id/%2Fsubscriptions%2F1111111-1111-1111-1111-111111111111%2Fproviders%2FMicrosoft.Resources%2Fdeployments%2Fyourenv-1721867673
   
     (✓) Done: Resource group: yourenv-rg
     (✓) Done: Virtual Network: yourenv-e2najjk4vewf2-vnet
     (✓) Done: App Service plan: yourenv-e2najjk4vewf2-service-plan
     (✓) Done: Log Analytics workspace: yourenv-e2najjk4vewf2-workspace
     (✓) Done: Application Insights: yourenv-e2najjk4vewf2-appinsights
     (✓) Done: Portal dashboard: yourenv-e2najjk4vewf2-dashboard
     (✓) Done: App Service: yourenv-e2najjk4vewf2-app-service
     (✓) Done: Azure Database for PostgreSQL flexible server: yourenv-e2najjk4vewf2-postgres-server
     (✓) Done: Cache for Redis: yourenv-e2najjk4vewf2-redisCache
     (✓) Done: Private Endpoint: cache-privateEndpoint
   
   SUCCESS: Your application was provisioned in Azure in 32 minutes.
   You can view the resources created under the resource group yourenv-rg in Azure Portal:
   https://portal.azure.com/#@/resource/subscriptions/1111111-1111-1111-1111-111111111111/resourceGroups/yourenv-rg/overview
   
   Deploying services (azd deploy)
   
     (✓) Done: Deploying service web
     - Endpoint: https://yourenv-e2najjk4vewf2-app-service.azurewebsites.net/
   
   

2. Examine a cadeia de conexão do banco de dados

O modelo azd gera as variáveis de conectividade para você como configurações do aplicativo. As configurações do aplicativo são uma maneira de manter os segredos de conexão fora do seu repositório de código.

1. No ficheiro infra/resources.bicep, localize a definição da aplicação e localize a definição para AZURE_POSTGRESQL_CONNECTIONSTRING.

   resource appSettings 'config' = {
     name: 'appsettings'
     properties: {
         SCM_DO_BUILD_DURING_DEPLOYMENT: 'true'
         AZURE_POSTGRESQL_CONNECTIONSTRING: 'dbname=${pythonAppDatabase.name} host=${postgresServer.name}.postgres.database.azure.com port=5432 sslmode=require user=${postgresServer.properties.administratorLogin} password=${databasePassword}'
         SECRET_KEY: secretKey
         AZURE_REDIS_CONNECTIONSTRING: 'rediss://:${redisCache.listKeys().primaryKey}@${redisCache.name}.redis.cache.windows.net:6380/0'
       }
   }
   

2. AZURE_POSTGRESQL_CONNECTIONSTRING contém a cadeia de conexão com o banco de dados Postgres no Azure. Você precisa usá-lo em seu código para se conectar a ele. Você pode encontrar o código que usa essa variável de ambiente em src/fastapi/models.py:

   sql_url = ""
   if os.getenv("WEBSITE_HOSTNAME"):
       logger.info("Connecting to Azure PostgreSQL Flexible server based on AZURE_POSTGRESQL_CONNECTIONSTRING...")
       env_connection_string = os.getenv("AZURE_POSTGRESQL_CONNECTIONSTRING")
       if env_connection_string is None:
           logger.info("Missing environment variable AZURE_POSTGRESQL_CONNECTIONSTRING")
       else:
           # Parse the connection string
           details = dict(item.split('=') for item in env_connection_string.split())
   
           # Properly format the URL for SQLAlchemy
           sql_url = (
               f"postgresql://{quote_plus(details['user'])}:{quote_plus(details['password'])}"
               f"@{details['host']}:{details['port']}/{details['dbname']}?sslmode={details['sslmode']}"
           )
   
   else:
       logger.info("Connecting to local PostgreSQL server based on .env file...")
       load_dotenv()
       POSTGRES_USERNAME = os.environ.get("DBUSER")
       POSTGRES_PASSWORD = os.environ.get("DBPASS")
       POSTGRES_HOST = os.environ.get("DBHOST")
       POSTGRES_DATABASE = os.environ.get("DBNAME")
       POSTGRES_PORT = os.environ.get("DBPORT", 5432)
   
       sql_url = f"postgresql://{POSTGRES_USERNAME}:{POSTGRES_PASSWORD}@{POSTGRES_HOST}:{POSTGRES_PORT}/{POSTGRES_DATABASE}"
   
   engine = create_engine(sql_url)
   

3. Examine o comando de inicialização

O Serviço de Aplicativo do Azure requer um comando de inicialização para executar seu aplicativo FastAPI. O modelo azd define esse comando para você em sua instância do Serviço de Aplicativo.

1. No ficheiro infra/resources.bicep, localize a declaração do seu site da Web e, em seguida, encontre a configuração para appCommandLine. Esta é a configuração para o comando de inicialização.

   resource web 'Microsoft.Web/sites@2024-11-01' = {
     name: '${prefix}-app-service'
     location: location
     tags: union(tags, { 'azd-service-name': 'web' })
     kind: 'app,linux'
     properties: {
       serverFarmId: appServicePlan.id
       siteConfig: {
         alwaysOn: true
         linuxFxVersion: 'PYTHON|3.11'
         ftpsState: 'Disabled'
         appCommandLine: 'src/entrypoint.sh'
         minTlsVersion: '1.2'
       }
       httpsOnly: true
     }
     identity: {
       type: 'SystemAssigned'
     }
   

2. O comando de inicialização executa o arquivo src/entrypoint.sh. Examine o código nesse arquivo para entender os comandos que o Serviço de Aplicativo executa para iniciar seu aplicativo:

   #!/bin/bash
   set -e
   python3 -m pip install --upgrade pip
   python3 -m pip install -e src
   python3 src/fastapi_app/seed_data.py
   python3 -m gunicorn fastapi_app:app -c src/gunicorn.conf.py
   

Para saber mais sobre a configuração e inicialização do aplicativo no Serviço de Aplicativo, consulte Configurar um aplicativo Linux Python para o Serviço de Aplicativo do Azure.

4. Gerar esquema de banco de dados

Você deve ter notado na seção anterior que entrypoint.sh contém a seguinte linha: python3 src/fastapi_app/seed_data.py. Este comando migra seu banco de dados. No aplicativo de exemplo, ele garante apenas que as tabelas corretas sejam criadas em seu banco de dados. Ele não preenche essas tabelas com nenhum dado.

Nesta seção, você executará esse comando manualmente para fins de demonstração. Com o banco de dados PostgreSQL protegido pela rede virtual, a maneira mais fácil de executar o comando é em uma sessão SSH com o contêiner do Serviço de Aplicativo.

1. Use o valor do Serviço de Aplicativo que você anotou anteriormente na saída azd para construir a URL para a sessão SSH e navegar até ela no navegador:

2. No terminal SSH, execute python3 src/fastapi_app/seed_data.py. Se for bem-sucedido, o Serviço de Aplicativo está se conectando com êxito ao banco de dados.

   

   Nota

   Somente as alterações nos /home arquivos podem persistir além das reinicializações do aplicativo. As mudanças fora do /home não são persistentes.

5. Navegue até o aplicativo

1. Na saída azd, encontre o URL do seu aplicativo e navegue até ele no navegador. O URL tem esta aparência na saída AZD:

   Deploying services (azd deploy)
   
     (✓) Done: Deploying service web
     - Endpoint: <URL>
   

2. Adicione alguns restaurantes à lista.

   

   Parabéns, você está executando um aplicativo Web no Serviço de Aplicativo do Azure, com conectividade segura ao Banco de Dados do Azure para PostgreSQL.

6. Transmitir logs de diagnóstico

O Serviço de Aplicativo do Azure pode capturar logs para ajudá-lo a diagnosticar problemas com seu aplicativo. Por conveniência, o modelo azd já habilitou o registro no sistema de arquivos local.

O aplicativo de exemplo usa o módulo de log Python Standard Library para gerar logs. A aplicação de exemplo inclui chamadas para o logger.

@app.get("/", response_class=HTMLResponse)
async def index(request: Request, session: Session = Depends(get_db_session)):
    logger.info("root called")
    statement = (
        select(Restaurant, func.avg(Review.rating).label("avg_rating"), func.count(Review.id).label("review_count"))
        .outerjoin(Review, Review.restaurant == Restaurant.id)
        .group_by(Restaurant.id)
    )

Para acessar o fluxo de log, abra seu aplicativo no portal do Azure. Selecione Monitorização>do fluxo de log.

Os eventos podem levar vários minutos para aparecer nos logs de diagnóstico. Saiba mais sobre como iniciar sessão em aplicações Python na série sobre como configurar o Azure Monitor para a sua aplicação Python.

7. Limpar os recursos

Para excluir todos os recursos do Azure no ambiente de implantação atual, execute azd down.

azd down