Compartilhar via

Tutorial: Conectar-se ao Banco de Dados PostgreSQL de um Aplicativo de Contêiner do Java Quarkus sem segredos usando uma identidade gerenciada

  • Artigo

Aplicativos de Contêiner do Azure fornece uma identidade gerenciada para seu aplicativo, que é uma solução perfeita para proteger o acesso a oBanco 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ê no processo de criação, configuração, implantação e colocação em escala 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ê aprenderá:

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

Caso você não tenha uma assinatura 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 contêiner lógico no qual os recursos do Azure são implantados e gerenciados.

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

az group create --name myResourceGroup --location eastus

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

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

3. Clonar o aplicativo de amostra e preparar a imagem de 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 com suporte do Banco de Dados do Azure para PostgreSQL. O código para o aplicativo está disponível no GitHub. Para saber mais sobre como escrever aplicativos Java usando Quarkus e PostgreSQL, consulte o ORM Quarkus Hibernate com o Guia do Panache e o Guia de Fonte de Dados do Quarkus.

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

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

Modifique seu projeto

  1. Adicione as dependências necessárias ao arquivo de marca de ordem de byte 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 esse arquivo em seu editor e observe várias propriedades padrão. As propriedades prefixadas são %prod usadas somente quando o aplicativo é criado e implantado, por exemplo, quando implantado em Serviço de Aplicativo do Azure. Quando o aplicativo é executado localmente, as propriedades %prod são ignoradas. Da mesma forma, as propriedades %dev são usadas no modo Live Coding/Dev do Quarkus e as propriedades %test são usadas durante testes contínuos.

    Exclua o conteúdo existente em application.properties e substitua pelo seguinte para configurar nosso banco de dados para 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

Crie e envie uma imagem do Docker para o registro de contêiner

  1. Compile a imagem de contêiner.

    Execute o comando a seguir para criar a imagem de aplicativo Quarkus. Você deve marcá-lo com o nome totalmente qualificado de seu servidor de login de registro. O nome do servidor de login está no formato <registry-name>.azurecr.io (deve ser tudo minúsculo), por exemplo, myContainerRegistry007.azurecr.io. Substitua o nome pelo seu próprio nome de registro.

    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. Efetue logon no registro.

    Antes de efetuar push de imagens de contêiner, efetue login no registro. Para fazer isso, use o comando [az acr login][az-acr-login]. Especifique apenas o nome do recurso de registro ao entrar com a CLI do Azure. Não use o nome do servidor de logon totalmente qualificado.

    az acr login --name <registry-name>

    O comando retorna uma mensagem Login Succeeded na conclusão.

  3. Efetue push da imagem para o registro.

    Use [docker push][docker-push] para efetuar push da imagem para a instância de registro. Substitua o mycontainerregistry007 pelo nome do servidor de logon de sua instância do registro. Este exemplo cria o repositório quarkus-postgres-passwordless-app, que contém a imagem quarkus-postgres-passwordless-app:v1.

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

4. Criar um aplicativo de contêiner no Azure

  1. Crie uma instância de Aplicativos de Contêiner executando o comando a seguir. Certifique-se de substituir o valor das variáveis de ambiente pelo nome e local reais que 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 aplicativo executando o comando a seguir. Substitua os espaços reservados pelos seus valores. Para encontrar os detalhes da conta de administrador do registro de contêiner, veja 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. Criar e conectar 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, mantendo o estado do aplicativo, não importa onde você o execute.

  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 acima da CLI do Azure:

    • resource-group → use o mesmo nome do grupo de recursos usado ao criar o aplicativo Web, por exemplo msdocs-quarkus-postgres-webapp-rg.

    • nome → 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, 0-9 e -. Um bom padrão é usar uma combinação do nome da empresa e um identificador do servidor. (msdocs-quarkus-postgres-webapp-db)

    • local → usa o mesmo local usado para o aplicativo Web.

    • admin-user → nome de usuário para a conta de administrador. Ele não pode ser azure_superuser, admin, administrator, root, guest ou public. Por exemplo, demoadmin está ok.

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

      Importante

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

    • public-access → None que define o servidor no modo de acesso público sem regras de firewall. As regras serão criadas em uma etapa posterior.

    • sku-name → o nome do tipo de preço e a configuração de computação como, por exemplo GP_Gen5_2. Para obter mais informações, confira Preços do Banco de Dados do Azure para PostgreSQL.

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

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

  3. Instale a extensão sem senha do Conector de Serviço para a CLI do Azure:

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

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

    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. Examinar 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 poder editar a lista de frutas como antes.

Limpar os recursos

Nas etapas anteriores, você criou os recursos do Azure em um grupo de recursos. Se você acha que não precisará desses recursos no futuro, exclua o grupo de recursos executando o seguinte comando no Cloud Shell:

az group delete --name myResourceGroup

Esse comando pode demorar um pouco para ser executado.

Próximas etapas

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

Azure para desenvolvedores Java