Tutorial: Conectar-se ao banco de dados PostgreSQL a partir de um aplicativo de contêiner Java Quarkus sem segredos usando uma identidade gerenciada

Os Aplicativos de Contêiner do Azure fornecem uma identidade gerenciada para seu aplicativo, que é uma solução turn-key para proteger o acesso ao Banco de Dados do Azure para PostgreSQL e outros serviços do Azure. As identidades gerenciadas em Aplicativos de Contêiner tornam seu aplicativo mais seguro, eliminando segredos de seu aplicativo, como credenciais nas variáveis de ambiente.

Este tutorial orienta você pelo processo de criação, configuração, implantação e dimensionamento de aplicativos de contêiner Java no Azure. No final deste tutorial, você terá um aplicativo Quarkus armazenando dados em um banco de dados PostgreSQL com uma identidade gerenciada em execução em Aplicativos de Contêiner.

O que você vai aprender:

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

1. Pré-requisitos

• Azure CLI versão 2.45.0 ou superior.
• Git
• Java JDK
• Maven
• Docker

2. Criar um registro de contêiner

Crie um grupo de recursos com o comando az group create. Um grupo de recursos do Azure é um contentor lógico no qual os recursos do Azure são implementados e geridos.

O exemplo a seguir cria um grupo de recursos nomeado myResourceGroup na região Azure Leste dos EUA.

RESOURCE_GROUP="myResourceGroup"
LOCATION="eastus"

az group create --name $RESOURCE_GROUP --location $LOCATION

Crie uma instância do Registro de contêiner do Azure usando o comando az acr create e recupere seu servidor de logon usando o comando az acr show . O nome do registo tem de ser exclusivo no Azure e conter de 5 a 50 carateres alfanuméricos. Todas as letras devem ser especificadas em minúsculas. No exemplo a seguir, mycontainerregistry007 é usado. Atualize para um valor exclusivo.

REGISTRY_NAME=mycontainerregistry007
az acr create \
    --resource-group $RESOURCE_GROUP \
    --name $REGISTRY_NAME \
    --sku Basic

REGISTRY_SERVER=$(az acr show \
    --name $REGISTRY_NAME \
    --query 'loginServer' \
    --output tsv | tr -d '\r')

3. Clone o aplicativo de exemplo e prepare a imagem do contêiner

Este tutorial usa um aplicativo de lista Fruits de exemplo com uma interface do usuário da Web que chama uma API REST do Quarkus apoiada pelo Banco de Dados do Azure para PostgreSQL. O código do aplicativo está disponível no GitHub. Para saber mais sobre como escrever aplicativos Java usando Quarkus e PostgreSQL, consulte o Quarkus Hibernate ORM with Panache Guide e o Quarkus Datasource Guide.

Execute os seguintes comandos em seu terminal para clonar o repositório de exemplo e configurar o ambiente do aplicativo de exemplo.

git clone https://github.com/quarkusio/quarkus-quickstarts
cd quarkus-quickstarts/hibernate-orm-panache-quickstart

Modificar o seu projeto

1. Adicione as dependências necessárias ao arquivo de lista técnica do seu projeto.

   <dependency>
      <groupId>com.azure</groupId>
      <artifactId>azure-identity-extensions</artifactId>
      <version>1.1.20</version>
   </dependency>
   

2. Configure as propriedades do aplicativo Quarkus.

   A configuração do Quarkus está localizada no arquivo src/main/resources/application.properties . Abra este arquivo em seu editor e observe várias propriedades padrão. As propriedades prefixadas com %prod são usadas somente quando o aplicativo é criado e implantado, por exemplo, quando implantado no Serviço de Aplicativo do Azure. Quando o aplicativo é executado localmente, %prod as propriedades são ignoradas. Da mesma forma, %dev as propriedades são usadas no modo Live Coding / Dev do Quarkus, e %test as propriedades são usadas durante testes contínuos.

   Exclua o conteúdo existente em application.properties e substitua pelo seguinte para configurar o banco de dados para os modos de desenvolvimento, teste e produção:

   quarkus.hibernate-orm.database.generation=drop-and-create
   quarkus.datasource.db-kind=postgresql
   quarkus.datasource.jdbc.max-size=8
   quarkus.datasource.jdbc.min-size=2
   quarkus.hibernate-orm.log.sql=true
   quarkus.hibernate-orm.sql-load-script=import.sql
   quarkus.datasource.jdbc.acquisition-timeout = 10
   
   %dev.quarkus.datasource.username=${CURRENT_USERNAME}
   %dev.quarkus.datasource.jdbc.url=jdbc:postgresql://${AZURE_POSTGRESQL_HOST}:${AZURE_POSTGRESQL_PORT}/${AZURE_POSTGRESQL_DATABASE}?\
   authenticationPluginClassName=com.azure.identity.extensions.jdbc.postgresql.AzurePostgresqlAuthenticationPlugin\
   &sslmode=require
   
   %prod.quarkus.datasource.username=${AZURE_POSTGRESQL_USERNAME}
   %prod.quarkus.datasource.jdbc.url=jdbc:postgresql://${AZURE_POSTGRESQL_HOST}:${AZURE_POSTGRESQL_PORT}/${AZURE_POSTGRESQL_DATABASE}?\
   authenticationPluginClassName=com.azure.identity.extensions.jdbc.postgresql.AzurePostgresqlAuthenticationPlugin\
   &sslmode=require
   
   %dev.quarkus.class-loading.parent-first-artifacts=com.azure:azure-core::jar,\
   com.azure:azure-core-http-netty::jar,\
   io.projectreactor.netty:reactor-netty-core::jar,\
   io.projectreactor.netty:reactor-netty-http::jar,\
   io.netty:netty-resolver-dns::jar,\
   io.netty:netty-codec::jar,\
   io.netty:netty-codec-http::jar,\
   io.netty:netty-codec-http2::jar,\
   io.netty:netty-handler::jar,\
   io.netty:netty-resolver::jar,\
   io.netty:netty-common::jar,\
   io.netty:netty-transport::jar,\
   io.netty:netty-buffer::jar,\
   com.azure:azure-identity::jar,\
   com.azure:azure-identity-extensions::jar,\
   com.fasterxml.jackson.core:jackson-core::jar,\
   com.fasterxml.jackson.core:jackson-annotations::jar,\
   com.fasterxml.jackson.core:jackson-databind::jar,\
   com.fasterxml.jackson.dataformat:jackson-dataformat-xml::jar,\
   com.fasterxml.jackson.datatype:jackson-datatype-jsr310::jar,\
   org.reactivestreams:reactive-streams::jar,\
   io.projectreactor:reactor-core::jar,\
   com.microsoft.azure:msal4j::jar,\
   com.microsoft.azure:msal4j-persistence-extension::jar,\
   org.codehaus.woodstox:stax2-api::jar,\
   com.fasterxml.woodstox:woodstox-core::jar,\
   com.nimbusds:oauth2-oidc-sdk::jar,\
   com.nimbusds:content-type::jar,\
   com.nimbusds:nimbus-jose-jwt::jar,\
   net.minidev:json-smart::jar,\
   net.minidev:accessors-smart::jar,\
   io.netty:netty-transport-native-unix-common::jar,\
   net.java.dev.jna:jna::jar
   

Criar e enviar por push uma imagem do Docker para o registro do contêiner

1. Crie a imagem do contêiner.

   Execute o seguinte comando para criar a imagem do aplicativo Quarkus. Você deve marcá-lo com o nome totalmente qualificado do seu servidor de login do registro.

   CONTAINER_IMAGE=${REGISTRY_SERVER}/quarkus-postgres-passwordless-app:v1
   
   mvn quarkus:add-extension -Dextensions="container-image-jib"
   mvn clean package -Dquarkus.container-image.build=true -Dquarkus.container-image.image=${CONTAINER_IMAGE}
   

2. Inicie sessão no registo.

   Antes de enviar imagens de contêiner, você deve fazer login no registro. Para fazer isso, use o comando [az acr login][az-acr-login].

   az acr login --name $REGISTRY_NAME
   

   O comando devolve uma mensagem de Login Succeeded depois de estar concluído.

3. Envie a imagem para o registo.

   Use [docker push][docker-push] para enviar a imagem para a instância do Registro. Este exemplo cria o quarkus-postgres-passwordless-app repositório, contendo a quarkus-postgres-passwordless-app:v1 imagem.

   docker push $CONTAINER_IMAGE
   

4. Criar um aplicativo de contêiner no Azure

1. Crie uma instância de Container Apps executando o seguinte comando. Certifique-se de substituir o valor das variáveis de ambiente pelo nome real e local que você deseja usar.

   CONTAINERAPPS_ENVIRONMENT="my-environment"
   
   az containerapp env create \
       --resource-group $RESOURCE_GROUP \
       --name $CONTAINERAPPS_ENVIRONMENT \
       --location $LOCATION
   

2. Crie um aplicativo de contêiner com a imagem do aplicativo executando o seguinte comando:

   APP_NAME=my-container-app
   az containerapp create \
       --resource-group $RESOURCE_GROUP \
       --name $APP_NAME \
       --image $CONTAINER_IMAGE \
       --environment $CONTAINERAPPS_ENVIRONMENT \
       --registry-server $REGISTRY_SERVER \
       --registry-identity system \
       --ingress 'external' \
       --target-port 8080 \
       --min-replicas 1
   

   Nota

   As opções --registry-username e --registry-password ainda são suportadas, mas não são recomendadas porque usar o sistema de identidade é mais seguro.

5. Crie e conecte um banco de dados PostgreSQL com conectividade de identidade

Em seguida, crie um Banco de Dados PostgreSQL e configure seu aplicativo de contêiner para se conectar a um Banco de Dados PostgreSQL com uma identidade gerenciada atribuída pelo sistema. O aplicativo Quarkus se conectará a esse banco de dados e armazenará seus dados durante a execução, persistindo o estado do aplicativo, não importa onde você execute o aplicativo.

1. Crie o serviço de banco de dados.

   DB_SERVER_NAME='msdocs-quarkus-postgres-webapp-db'
   
   az postgres flexible-server create \
       --resource-group $RESOURCE_GROUP \
       --name $DB_SERVER_NAME \
       --location $LOCATION \
       --public-access None \
       --sku-name Standard_B1ms \
       --tier Burstable \
       --active-directory-auth Enabled
   

   Nota

   As opções --admin-user e --admin-password ainda são suportadas, mas não são recomendadas porque usar o sistema de identidade é mais seguro.

   Os seguintes parâmetros são usados no comando da CLI do Azure acima:

   • → de grupo de recursos Use o mesmo nome de grupo de recursos no qual você criou o aplicativo Web - por exemplo, msdocs-quarkus-postgres-webapp-rg.
   • 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 se torna https://<name>.postgres.database.azure.com). Os caracteres permitidos são A-Z,-09 e .- Um bom padrão é usar uma combinação do nome da sua empresa e do identificador do servidor. (msdocs-quarkus-postgres-webapp-db)
   • local → Use o mesmo local usado para o aplicativo Web. Mude para um local diferente se não funcionar.
   • → None de acesso público que define o servidor no modo de acesso público sem regras de firewall. As regras serão criadas numa fase posterior.
   • 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.
   • camada → A camada de computação do servidor. Para obter mais informações, consulte Preços do Banco de Dados do Azure para PostgreSQL.
   • active-directory-auth → Enabled para habilitar a autenticação do Microsoft Entra.

2. Crie um banco de dados nomeado fruits dentro do serviço PostgreSQL com este comando:

   DB_NAME=fruits
   az postgres flexible-server db create \
       --resource-group $RESOURCE_GROUP \
       --server-name $DB_SERVER_NAME \
       --database-name $DB_NAME
   

3. Instale a extensão sem senha do Service Connector para a CLI do Azure:

   az extension add --name serviceconnector-passwordless --upgrade --allow-preview true
   

4. Conecte o banco de dados ao aplicativo contêiner com uma identidade gerenciada atribuída ao sistema, usando o comando connection.

   az containerapp connection create postgres-flexible \
       --resource-group $RESOURCE_GROUP \
       --name $APP_NAME \
       --target-resource-group $RESOURCE_GROUP \
       --server $DB_SERVER_NAME \
       --database $DB_NAME \
       --system-identity \
       --container $APP_NAME
   

6. Reveja as alterações

Você pode encontrar a URL do aplicativo (FQDN) usando o seguinte comando:

echo https://$(az containerapp show \
    --name $APP_NAME \
    --resource-group $RESOURCE_GROUP \
    --query properties.configuration.ingress.fqdn \
    --output tsv)

Quando a nova página da Web mostra sua lista de frutas, seu aplicativo está se conectando ao banco de dados usando a identidade gerenciada. Agora você deve ser capaz de editar a lista de frutas como antes.

Clean up resources (Limpar recursos)

Nos passos anteriores, criou os recursos do Azure num grupo de recursos. Se achar que não vai precisar destes recursos no futuro, execute o seguinte comando no Cloud Shell para eliminar o grupo de recursos:

az group delete --name myResourceGroup

Este comando pode demorar alguns minutos a ser executado.

Próximos passos

Saiba mais sobre como executar aplicativos Java no Azure no guia do desenvolvedor.