Share via

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

  • Artigo

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:

  • Configure um aplicativo Quarkus para autenticar usando a ID do Microsoft Entra com um Banco de Dados PostgreSQL.
  • Crie um registro de contêiner do Azure e envie por push uma imagem de aplicativo Java para ele.
  • Crie um aplicativo de contêiner no Azure.
  • Crie um banco de dados PostgreSQL no Azure.
  • Conecte-se a um banco de dados PostgreSQL com identidade gerenciada usando o Service Connector.

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

1. Pré-requisitos

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.

az group create --name myResourceGroup --location eastus

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

az acr create \
    --resource-group myResourceGroup \
    --name mycontainerregistry007 \
    --sku Basic

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-providers-jdbc-postgresql</artifactId>
    <version>1.0.0-beta.1</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, as propriedades são usadas no modo Live Coding / Dev do Quarkus, %dev 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.package.type=uber-jar

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=${AZURE_CLIENT_NAME}
%dev.quarkus.datasource.jdbc.url=jdbc:postgresql://${DBHOST}.postgres.database.azure.com:5432/${DBNAME}?\
authenticationPluginClassName=com.azure.identity.providers.postgresql.AzureIdentityPostgresqlAuthenticationPlugin\
&sslmode=require\
&azure.clientId=${AZURE_CLIENT_ID}\
&azure.clientSecret=${AZURE_CLIENT_SECRET}\
&azure.tenantId=${AZURE_TENANT_ID}

%prod.quarkus.datasource.username=${AZURE_MI_NAME}
%prod.quarkus.datasource.jdbc.url=jdbc:postgresql://${DBHOST}.postgres.database.azure.com:5432/${DBNAME}?\
authenticationPluginClassName=com.azure.identity.providers.postgresql.AzureIdentityPostgresqlAuthenticationPlugin\
&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-providers-core::jar,\
com.azure:azure-identity-providers-jdbc-postgresql::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

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. O nome do servidor de login está no formato <registry-name.azurecr.io> (deve ser todo minúsculo), por exemplo, mycontainerregistry007.azurecr.io. Substitua o nome pelo seu próprio nome de registo.

    mvnw quarkus:add-extension -Dextensions="container-image-jib"
mvnw clean package -Pnative -Dquarkus.native.container-build=true -Dquarkus.container-image.build=true -Dquarkus.container-image.registry=mycontainerregistry007 -Dquarkus.container-image.name=quarkus-postgres-passwordless-app -Dquarkus.container-image.tag=v1

  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]. Especifique apenas o nome do recurso do Registro ao entrar com a CLI do Azure. Não use o nome do servidor de login totalmente qualificado.

    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. Substitua mycontainerregistry007 pelo nome do servidor de login da sua instância do Registro. Este exemplo cria o quarkus-postgres-passwordless-app repositório, contendo a quarkus-postgres-passwordless-app:v1 imagem.

    docker push mycontainerregistry007/quarkus-postgres-passwordless-app:v1

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.

    RESOURCE_GROUP="myResourceGroup"
LOCATION="eastus"
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 seu aplicativo executando o seguinte comando. Substitua os marcadores de posição com os seus valores. Para localizar os detalhes da conta de administrador do registro de contêiner, consulte Autenticar com um registro de contêiner do Azure

    CONTAINER_IMAGE_NAME=quarkus-postgres-passwordless-app:v1
REGISTRY_SERVER=mycontainerregistry007
REGISTRY_USERNAME=<REGISTRY_USERNAME>
REGISTRY_PASSWORD=<REGISTRY_PASSWORD>

az containerapp create \
    --resource-group $RESOURCE_GROUP \
    --name my-container-app \
    --image $CONTAINER_IMAGE_NAME \
    --environment $CONTAINERAPPS_ENVIRONMENT \
    --registry-server $REGISTRY_SERVER \
    --registry-username $REGISTRY_USERNAME \
    --registry-password $REGISTRY_PASSWORD

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'
ADMIN_USERNAME='demoadmin'
ADMIN_PASSWORD='<admin-password>'

az postgres flexible-server create \
    --resource-group $RESOURCE_GROUP \
    --name $DB_SERVER_NAME \
    --location $LOCATION \
    --admin-user $DB_USERNAME \
    --admin-password $DB_PASSWORD \
    --sku-name GP_Gen5_2

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.

  • admin-user → Nome de usuário para a conta de administrador. Não pode ser azure_superuser, , , , rootguest, adminadministratorou public. Por exemplo, demoadmin está tudo bem.

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

    Importante

    Ao criar nomes de usuário ou senhas , não use o $ caractere. Mais adiante neste tutorial, você criará variáveis de ambiente com esses valores onde o $ caractere tem um significado especial dentro do contêiner Linux usado para executar aplicativos Java.

  • → 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 GP_Gen5_2. Para obter mais informações, consulte Preços do Banco de Dados do Azure para PostgreSQL.

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

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

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

    az extension add --name serviceconnector-passwordless --upgrade

  3. 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 my-container-app \
    --target-resource-group $RESOURCE_GROUP \
    --server $DB_SERVER_NAME \
    --database fruits \
    --managed-identity

6. Reveja as alterações

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

az containerapp list --resource-group $RESOURCE_GROUP

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.

Azure para Programadores Java