Partilhar via

Implantar um aplicativo Java com o Quarkus em um cluster do Serviço Kubernetes do Azure

Este artigo mostra como implantar rapidamente o Red Hat Quarkus no Serviço Kubernetes do Azure (AKS) com um aplicativo CRUD simples. A aplicação é uma "lista de tarefas" com um front-end JavaScript e um endpoint REST. O Banco de Dados do Azure para Servidor Flexível PostgreSQL fornece a camada de persistência para o aplicativo. O artigo mostra como testar seu aplicativo localmente e implantá-lo no AKS.

Pré-requisitos

  • Se não tiver uma conta do Azure, crie uma conta gratuita antes de começar.
  • Prepare uma máquina local com um sistema operativo do tipo Unix instalado - por exemplo, Ubuntu, macOS, ou Windows Subsystem for Linux.
  • Instale uma implementação Java SE versão 17 ou posterior - por exemplo, compilação Microsoft do OpenJDK.
  • Instale o Maven, versão 3.9.8 ou superior.
  • Instale Docker para seu sistema operacional.
  • Instale o jq.
  • Instale cURL
  • Instale a CLI do Quarkus, versão 3.12.1 ou superior.
  • CLI do Azure para ambientes semelhantes ao Unix. Este artigo requer apenas a variante Bash da CLI do Azure.
    • Um desenvolvedor deve instalar a CLI do Azure e entrar interativamente com o comando az login para fazer logon no Azure antes de usar o código DefaultAzureCredential. 
      az login
    • Este artigo requer pelo menos a versão 2.61.0 da CLI do Azure.

Criar o projeto de aplicativo

Use o comando a seguir para clonar o projeto Java de exemplo para este artigo. O exemplo está no GitHub.

git clone https://github.com/Azure-Samples/quarkus-azure
cd quarkus-azure
git checkout 2024-12-16
cd aks-quarkus

Se vires uma mensagem sobre estares no estado HEAD desanexado, podes ignorar essa mensagem. Como este artigo não requer nenhuma confirmação, o estado HEAD destacado é apropriado.

Teste seu aplicativo Quarkus localmente

As etapas nesta seção mostram como executar o aplicativo localmente.

O Quarkus suporta o provisionamento automático de serviços não configurados no modo de desenvolvimento e teste. O Quarkus refere-se a esse recurso como serviços de desenvolvimento. Digamos que você inclua um recurso do Quarkus, como conectar-se a um serviço de banco de dados. Você deseja testar o aplicativo, mas ainda não configurou totalmente a conexão com um banco de dados real. O Quarkus inicia automaticamente uma versão de stub em contêiner do serviço relevante e conecta seu aplicativo a ele. Para obter mais informações, consulte Visão geral dos serviços de desenvolvimento na documentação do Quarkus.

Verifique se o ambiente de contêiner está em execução e use o seguinte comando para entrar no modo de desenvolvimento do Quarkus:

quarkus dev

Em vez de quarkus dev, você pode realizar a mesma coisa com o Maven usando mvn quarkus:dev.

Pode ser que lhe perguntem se deseja enviar telemetria do seu uso do modo de desenvolvimento do Quarkus. Se sim, responda como quiser.

O modo de desenvolvimento do Quarkus permite a recarga ao vivo com compilação em segundo plano. Se você modificar qualquer aspeto do código-fonte do aplicativo e atualizar o navegador, poderá ver as alterações. Se houver algum problema com a compilação ou implantação, uma página de erro informará você. O modo de desenvolvimento do Quarkus escuta um depurador na porta 5005. Se quiser esperar que o depurador seja ligado antes de executar, passe -Dsuspend na linha de comandos. Se não quiser o depurador, pode usar -Ddebug=false.

A saída deve ser semelhante ao exemplo a seguir:

__  ____  __  _____   ___  __ ____  ______
 --/ __ \/ / / / _ | / _ \/ //_/ / / / __/
 -/ /_/ / /_/ / __ |/ , _/ ,< / /_/ /\ \
--\___\_\____/_/ |_/_/|_/_/|_|\____/___/
INFO  [io.quarkus] (Quarkus Main Thread) quarkus-todo-demo-app-aks 1.0.0-SNAPSHOT on JVM (powered by Quarkus 3.2.0.Final) started in 3.377s. Listening on: http://localhost:8080

INFO  [io.quarkus] (Quarkus Main Thread) Profile dev activated. Live Coding activated.
INFO  [io.quarkus] (Quarkus Main Thread) Installed features: [agroal, cdi, hibernate-orm, hibernate-orm-panache, hibernate-validator, jdbc-postgresql, narayana-jta, resteasy-reactive, resteasy-reactive-jackson, smallrye-context-propagation, vertx]

--
Tests paused
Press [e] to edit command line args (currently ''), [r] to resume testing, [o] Toggle test output, [:] for the terminal, [h] for more options>

Pressione w no terminal onde o modo de desenvolvimento do Quarkus está sendo executado. A tecla w abre o navegador da Web padrão para mostrar o Todo aplicativo. Você também pode acessar a interface gráfica do aplicativo diretamente em http://localhost:8080.

Captura de ecrã da aplicação de exemplo Todo.

Tente selecionar alguns itens na lista de tarefas. A interface do usuário indica a seleção com um estilo de texto tachado. Você também pode adicionar um novo item à lista de tarefas digitando Verificar aplicações Todo e pressionando Enter, conforme mostrado na captura de ecrã a seguir.

Captura de ecrã da aplicação de exemplo Todo com novos itens adicionados.

Acesse a API RESTful (/api) para obter todos os itens que são armazenados no banco de dados PostgreSQL local:

curl --verbose http://localhost:8080/api | jq .

A saída deve ser semelhante ao exemplo a seguir:

* Connected to localhost (127.0.0.1) port 8080 (#0)
> GET /api HTTP/1.1
> Host: localhost:8080
> User-Agent: curl/7.88.1
> Accept: */*
>
< HTTP/1.1 200 OK
< content-length: 664
< Content-Type: application/json;charset=UTF-8
<
{ [664 bytes data]
100   664  100   664    0     0  13278      0 --:--:-- --:--:-- --:--:-- 15441
* Connection #0 to host localhost left intact
[
  {
    "id": 1,
    "title": "Introduction to Quarkus Todo App",
    "completed": false,
    "order": 0,
    "url": null
  },
  {
    "id": 2,
    "title": "Quarkus on Azure App Service",
    "completed": false,
    "order": 1,
    "url": "https://learn.microsoft.com/en-us/azure/developer/java/eclipse-microprofile/deploy-microprofile-quarkus-java-app-with-maven-plugin"
  },
  {
    "id": 3,
    "title": "Quarkus on Azure Container Apps",
    "completed": false,
    "order": 2,
    "url": "https://learn.microsoft.com/en-us/training/modules/deploy-java-quarkus-azure-container-app-postgres/"
  },
  {
    "id": 4,
    "title": "Quarkus on Azure Functions",
    "completed": false,
    "order": 3,
    "url": "https://learn.microsoft.com/en-us/azure/azure-functions/functions-create-first-quarkus"
  },
  {
    "id": 5,
    "title": "Verify Todo apps",
    "completed": false,
    "order": 5,
    "url": null
  }
]

Pressione q para sair do modo de desenvolvimento do Quarkus.

Criar os recursos do Azure para executar o aplicativo Quarkus

As etapas nesta seção mostram como criar os seguintes recursos do Azure para executar o aplicativo de exemplo Quarkus:

  • Banco de Dados do Azure para Servidor Flexível PostgreSQL
  • Registo de Contêineres do Azure
  • Serviço Kubernetes do Azure (AKS)

Observação

Este artigo desativa a autenticação do PostgreSQL para ilustrar as práticas recomendadas de segurança. Microsoft Entra ID é usado para autenticar a conexão com o servidor. Se você precisar habilitar a autenticação PostgreSQL, consulte Guia de início rápido: usar Java e JDBC com o Banco de Dados do Azure para PostgreSQL - Servidor flexível e selecione a guia Senha .

Alguns desses recursos devem ter nomes exclusivos dentro do escopo da assinatura do Azure. Para garantir a exclusividade, pode usar o padrão de iniciais, sequência, data, sufixo. Para aplicar esse padrão, nomeie seus recursos listando suas iniciais, algum número de sequência, a data de hoje e algum tipo de sufixo específico de recurso - por exemplo, rg para "grupo de recursos". As variáveis de ambiente a seguir usam esse padrão. Substitua os valores dos espaços reservados UNIQUE_VALUE e LOCATION pelos seus próprios valores e, em seguida, execute no terminal os seguintes comandos:

export UNIQUE_VALUE=<your unique value, such as ejb010717>
export RESOURCE_GROUP_NAME=${UNIQUE_VALUE}rg
export LOCATION=<your desired Azure region for deploying your resources - for example, northeurope>
export REGISTRY_NAME=${UNIQUE_VALUE}reg
export DB_SERVER_NAME=${UNIQUE_VALUE}db
export DB_NAME=demodb
export CLUSTER_NAME=${UNIQUE_VALUE}aks
export AKS_NS=${UNIQUE_VALUE}ns

Criar um Banco de Dados do Azure para o Servidor Flexível PostgreSQL

O Azure Database for PostgreSQL Flexible Server é um serviço de banco de dados totalmente gerenciado projetado para fornecer controle e flexibilidade mais granulares sobre funções de gerenciamento de banco de dados e definições de configuração. Esta seção mostra como criar um Banco de Dados do Azure para a instância do Servidor Flexível PostgreSQL usando a CLI do Azure.

Primeiro, crie um grupo de recursos para conter o servidor de banco de dados e outros recursos usando o seguinte comando:

az group create \
    --name $RESOURCE_GROUP_NAME \
    --location $LOCATION

Em seguida, crie uma instância de servidor flexível do Banco de Dados do Azure para PostgreSQL usando o seguinte comando:

az postgres flexible-server create \
    --name $DB_SERVER_NAME \
    --database-name $DB_NAME \
    --resource-group $RESOURCE_GROUP_NAME \
    --location $LOCATION \
    --public-access 0.0.0.0 \
    --sku-name Standard_B1ms \
    --tier Burstable \
    --active-directory-auth Enabled \
    --yes

Leva alguns minutos para criar o servidor, o banco de dados, o usuário administrador e as regras de firewall. Se o comando for bem-sucedido, a saída será semelhante ao exemplo a seguir:

{
  "connectionString": "postgresql://REDACTED@ejb011212qdb.postgres.database.azure.com/demodb?sslmode=require",
  "databaseName": "demodb",
  "firewallName": "AllowAllAzureServicesAndResourcesWithinAzureIps_2024-12-12_14-30-22",
  "host": "ejb011212qdb.postgres.database.azure.com",
  "id": "/subscriptions/c7844e91-b11d-4a7f-ac6f-996308fbcdb9/resourceGroups/ejb011211sfi/providers/Microsoft.DBforPostgreSQL/flexibleServers/ejb011212qdb",
  "location": "East US 2",
  "password": "REDACTED",
  "resourceGroup": "ejb011211sfi",
  "skuname": "Standard_B1ms",
  "username": "sorrycamel2",
  "version": "16"
}

Testar aplicativo localmente com o Banco de Dados do Azure para Servidor Flexível PostgreSQL

Na seção anterior, você testou o aplicativo Quarkus localmente no modo de desenvolvimento com um banco de dados PostgreSQL provisionado como um contêiner do Docker. Agora, teste a conexão localmente à base de dados do Azure para a instância de Servidor Flexível PostgreSQL.

Primeiro, adicione o usuário conectado atual como Microsoft Entra Admin à instância do Servidor Flexível do Banco de Dados do Azure para PostgreSQL usando os seguintes comandos:

ENTRA_ADMIN_NAME=$(az account show --query user.name --output tsv)
az postgres flexible-server ad-admin create \
    --resource-group $RESOURCE_GROUP_NAME \
    --server-name $DB_SERVER_NAME \
    --display-name $ENTRA_ADMIN_NAME \
    --object-id $(az ad signed-in-user show --query id --output tsv)

A saída bem-sucedida é um objeto JSON que inclui a propriedade "type": "Microsoft.DBforPostgreSQL/flexibleServers/administrators".

Em seguida, adicione o endereço IP local ao Banco de Dados do Azure para regras de firewall de instância do Servidor Flexível PostgreSQL seguindo estas etapas:

  1. Obtenha o endereço IP local da sua máquina onde você executa o aplicativo Quarkus localmente. Por exemplo, visite https://whatismyipaddress.com para obter seu endereço IP público v4.

  2. Defina uma variável de ambiente com o endereço IP local obtido na etapa anterior.

    export AZ_LOCAL_IP_ADDRESS=<your local IP address>

  3. Execute o seguinte comando para adicionar o endereço IP local ao Banco de Dados do Azure para regras de firewall de instância do Servidor Flexível PostgreSQL:

    az postgres flexible-server firewall-rule create \
    --resource-group $RESOURCE_GROUP_NAME \
    --name $DB_SERVER_NAME \
    --rule-name $DB_SERVER_NAME-database-allow-local-ip \
    --start-ip-address $AZ_LOCAL_IP_ADDRESS \
    --end-ip-address $AZ_LOCAL_IP_ADDRESS

Em seguida, defina as seguintes variáveis de ambiente no seu terminal anterior. Essas variáveis de ambiente são usadas para se conectar à instância do Servidor Flexível do Banco de Dados do Azure para PostgreSQL a partir do aplicativo Quarkus em execução localmente:

export AZURE_POSTGRESQL_HOST=${DB_SERVER_NAME}.postgres.database.azure.com
export AZURE_POSTGRESQL_PORT=5432
export AZURE_POSTGRESQL_DATABASE=${DB_NAME}
export AZURE_POSTGRESQL_USERNAME=${ENTRA_ADMIN_NAME}

Observação

Os valores das variáveis de ambiente AZURE_POSTGRESQL_HOST, AZURE_POSTGRESQL_PORT, AZURE_POSTGRESQL_DATABASE e AZURE_POSTGRESQL_USERNAME são lidos pelas propriedades de configuração da base de dados definidas no ficheiro src/main/resources/application.properties introduzido na seção anterior. Esses valores são injetados automaticamente no aplicativo em tempo de execução usando a extensão sem senha do Service Connector quando você implanta o aplicativo Quarkus no cluster AKS mais adiante neste artigo.

Agora, execute o aplicativo Quarkus localmente para testar a conexão com o Banco de Dados do Azure para a instância do Servidor Flexível PostgreSQL. Use o seguinte comando para iniciar o aplicativo no modo de produção:

quarkus build
java -jar target/quarkus-app/quarkus-run.jar

Observação

Se o aplicativo não iniciar com uma mensagem de erro semelhante ao ERROR [org.hib.eng.jdb.spi.SqlExceptionHelper] (JPA Startup Thread) Acquisition timeout while waiting for new connection, é mais provável que seja devido à configuração de rede da sua máquina local. Tente selecionar Adicionar endereço IP do cliente atual no portal do Azure novamente. Para obter mais informações, consulte a seção Criar uma regra de firewall após a criação do servidor em Criar e gerenciar regras de firewall para o Banco de Dados do Azure para PostgreSQL - Servidor flexível usando o portal do Azure. Em seguida, execute o aplicativo novamente.

Abra um novo navegador da Web em http://localhost:8080 para aceder ao aplicativo Todo. Você deve ver o aplicativo Todo, semelhante ao que você viu quando executou o aplicativo localmente no modo de desenvolvimento.

Criar uma instância do Azure Container Registry

Como o Quarkus é uma tecnologia nativa da nuvem, ele tem suporte interno para a criação de contêineres que são executados no Kubernetes. O Kubernetes depende inteiramente de ter um registro de contêiner a partir do qual ele encontra as imagens de contêiner a serem executadas. O AKS tem suporte interno para o Azure Container Registry.

Use o comando az acr create para criar a instância do registro de contêiner. O exemplo a seguir cria uma instância do Registro de contêiner nomeada com o valor da variável ${REGISTRY_NAME}de ambiente :

az acr create \
    --resource-group $RESOURCE_GROUP_NAME \
    --location ${LOCATION} \
    --name $REGISTRY_NAME \
    --sku Basic

Após um curto período de tempo, você verá a saída JSON que contém as seguintes linhas:

  "provisioningState": "Succeeded",
  "publicNetworkAccess": "Enabled",
  "resourceGroup": "<YOUR_RESOURCE_GROUP>",

Obtenha o servidor de logon para a instância do Registro de Contêiner usando o seguinte comando:

export LOGIN_SERVER=$(az acr show \
    --name $REGISTRY_NAME \
    --query 'loginServer' \
    --output tsv)
echo $LOGIN_SERVER

Conecte seu docker à instância do registro do contêiner

Inicie sessão na instância do registo de contentores. Iniciar sessão permite-lhe carregar uma imagem. Use o seguinte comando para entrar no registro:

az acr login --name $REGISTRY_NAME

Se você entrou na instância do Registro de contêiner com êxito, deverá ver Login Succeeded no final da saída do comando.

Criar um cluster do AKS

Utilize o comando az aks create para criar um cluster AKS. O exemplo a seguir cria um cluster cujo nome é o valor da variável de ambiente ${CLUSTER_NAME} com um nó. O cluster está conectado à instância do Registro de contêiner que você criou em uma etapa anterior. Este comando leva vários minutos para ser concluído. O cluster é iniciado com a identidade gerenciada habilitada. Esta etapa é necessária para a conexão de banco de dados sem senha.

az aks create \
    --resource-group $RESOURCE_GROUP_NAME \
    --name $CLUSTER_NAME \
    --attach-acr $REGISTRY_NAME \
    --node-count 1 \
    --generate-ssh-keys \
    --enable-managed-identity

Após alguns minutos, o comando conclui e retorna informações formatadas em JSON sobre o cluster, incluindo a seguinte saída:

  "nodeResourceGroup": "MC_<your resource_group_name>_<your cluster name>_<your region>",
  "privateFqdn": null,
  "provisioningState": "Succeeded",
  "resourceGroup": "<your resource group name>",

Conectar-se ao cluster AKS

Para gerenciar um cluster Kubernetes, use kubectl, o cliente de linha de comando Kubernetes. Para instalar kubectl localmente, use o comando az aks install-cli , conforme mostrado no exemplo a seguir:

az aks install-cli

Para obter mais informações sobre kubectl, consulte Linha de comando (kubectl) na documentação do Kubernetes.

Para configurar kubectl para se conectar ao cluster do Kubernetes, use o comando az aks get-credentials , conforme mostrado no exemplo a seguir. Este comando baixa credenciais e configura a CLI do Kubernetes para usá-las.

az aks get-credentials \
    --resource-group $RESOURCE_GROUP_NAME \
    --name $CLUSTER_NAME \
    --overwrite-existing \
    --admin

A saída bem-sucedida inclui texto semelhante ao exemplo a seguir:

Merged "ejb010718aks-admin" as current context in /Users/edburns/.kube/config

Você pode achar útil o alias k para kubectl. Em caso afirmativo, use o seguinte comando:

alias k=kubectl

Para verificar a conexão com o cluster, use o kubectl get comando para retornar uma lista dos nós do cluster, conforme mostrado no exemplo a seguir:

kubectl get nodes

A saída de exemplo seguinte mostra o nó único criado nas etapas anteriores. Verifique se o status do nó está Pronto:

NAME                                STATUS   ROLES   AGE     VERSION
aks-nodepool1-xxxxxxxx-yyyyyyyyyy   Ready    agent   76s     v1.28.9

Criar um novo namespace no AKS

Use o seguinte comando para criar um novo namespace em seu serviço Kubernetes para seu aplicativo Quarkus:

kubectl create namespace ${AKS_NS}

A saída deve ser semelhante ao exemplo a seguir:

namespace/<your namespace> created

Criar uma conexão de serviço no AKS com o Service Connector

Nesta secção, cria-se uma ligação de serviço entre o cluster AKS e a Base de Dados do Azure para Serviço Flexível PostgreSQL, utilizando o Microsoft Entra Workload ID com o Service Connector. Essa conexão permite que o cluster AKS acesse o Banco de Dados do Azure para o Servidor Flexível PostgreSQL sem usar a autenticação SQL.

Execute os seguintes comandos para criar uma conexão entre o cluster AKS e o banco de dados PostgreSQL usando o ID de carga de trabalho do Microsoft Entra com o Service Connector:

# Register the Service Connector and Kubernetes Configuration resource providers
az provider register --namespace Microsoft.ServiceLinker --wait
az provider register --namespace Microsoft.KubernetesConfiguration --wait

# Install the Service Connector passwordless extension
az extension add --name serviceconnector-passwordless --upgrade --allow-preview true

# Retrieve the AKS cluster and Azure SQL Server resource IDs
export AKS_CLUSTER_RESOURCE_ID=$(az aks show \
    --resource-group $RESOURCE_GROUP_NAME \
    --name $CLUSTER_NAME \
    --query id \
    --output tsv)
export AZURE_POSTGRESQL_RESOURCE_ID=$(az postgres flexible-server show \
    --resource-group $RESOURCE_GROUP_NAME \
    --name $DB_SERVER_NAME \
    --query id \
    --output tsv)

# Create a user-assigned managed identity used for workload identity
export USER_ASSIGNED_IDENTITY_NAME=workload-identity-uami
az identity create \
    --resource-group ${RESOURCE_GROUP_NAME} \
    --name ${USER_ASSIGNED_IDENTITY_NAME}

# Retrieve the user-assigned managed identity resource ID
export UAMI_RESOURCE_ID=$(az identity show \
    --resource-group ${RESOURCE_GROUP_NAME} \
    --name ${USER_ASSIGNED_IDENTITY_NAME} \
    --query id \
    --output tsv)

# Create a service connection between your AKS cluster and your PostgreSQL database using Microsoft Entra Workload ID
az aks connection create postgres-flexible \
    --connection akspostgresconn \
    --kube-namespace $AKS_NS \
    --source-id $AKS_CLUSTER_RESOURCE_ID \
    --target-id $AZURE_POSTGRESQL_RESOURCE_ID/databases/$DB_NAME \
    --workload-identity $UAMI_RESOURCE_ID

A presença do seguinte JSON na saída do comando final nas etapas anteriores indica uma instalação bem-sucedida do conector de serviço:

"name": "akspostgresconn",
"provisioningState": "Succeeded",

Observação

Recomendamos usar a ID de Carga de Trabalho do Microsoft Entra para acesso seguro ao seu Banco de Dados do Azure para Servidor Flexível PostgreSQL sem usar a autenticação de nome de usuário/senha. Se você precisar usar a autenticação de nome de usuário/senha, ignore as etapas anteriores nesta seção e use o nome de usuário e a senha para se conectar ao banco de dados.

Obter conta de serviço e segredo criados pelo Service Connector

Para autenticar no Banco de Dados do Azure para Servidor Flexível PostgreSQL, você precisa obter a conta de serviço e o segredo do Kubernetes criados pelo Service Connector. Siga as instruções na seção Atualize seu contêiner do Tutorial: Conectar um aplicativo AKS ao Banco de Dados SQL do Azure. Pegue a opção Criar diretamente uma implantação usando o trecho de código de exemplo YAML fornecido e use a seguinte etapa:

  • Nas seções destacadas no exemplo de implementação do Kubernetes YAML, copie os valores de serviceAccountName e secretRef.name, representados como <service-account-name> e <secret-name> no exemplo a seguir:

    serviceAccountName: <service-account-name>
containers:
- name: raw-linux
    envFrom:
       - secretRef:
          name: <secret-name>

    Esses valores são usados na próxima seção para implantar o aplicativo Quarkus no cluster AKS.

Personalizar a configuração nativa da nuvem

Como uma tecnologia nativa da nuvem, o Quarkus oferece a capacidade de configurar automaticamente recursos para Kubernetes padrão, Red Hat OpenShift e Knative. Para obter mais informações, consulte o guia do Quarkus Kubernetes, o guia do Quarkus OpenShift e o guia do Quarkus Kunative. Os desenvolvedores podem implantar o aplicativo em um cluster Kubernetes de destino aplicando os manifestos gerados.

Para gerar os recursos Kubernetes apropriados, utilize o seguinte comando para adicionar as extensões quarkus-kubernetes e container-image-jib no seu terminal local.

quarkus ext add kubernetes container-image-jib

O Quarkus modifica o POM para garantir que essas extensões sejam listadas como <dependencies>. Se lhe for pedido para instalar algo chamado JBang, responda sim e permita que seja instalado.

A saída deve ser semelhante ao exemplo a seguir:

[SUCCESS] ✅  Extension io.quarkus:quarkus-kubernetes has been installed
[SUCCESS] ✅  Extension io.quarkus:quarkus-container-image-jib has been installed

Para verificar se as extensões foram adicionadas, você pode executar git diff e examinar a saída.

Como uma tecnologia nativa da nuvem, o Quarkus suporta a noção de perfis de configuração. O Quarkus tem os seguintes três perfis integrados:

  • dev - Ativado quando em modo de desenvolvimento
  • test - Ativado durante a execução de testes
  • prod - O perfil padrão quando não está em execução no modo de desenvolvimento ou teste

O Quarkus suporta qualquer número de perfis nomeados, conforme necessário.

As etapas restantes nesta seção direcionam você para personalizar valores no arquivo src/main/resources/application.properties .

O prod. prefixo indica que estas propriedades estão ativas quando executadas no prod perfil. Para obter mais informações sobre perfis de configuração, consulte a documentação do Quarkus.

Configuração da base de dados

Examine as seguintes variáveis de configuração do banco de dados. As propriedades %prod.quarkus.datasource.jdbc.url e %prod.quarkus.datasource.username relacionadas à conexão do banco de dados leem os valores das variáveis de ambiente AZURE_POSTGRESQL_HOST, AZURE_POSTGRESQL_PORT, AZURE_POSTGRESQL_DATABASE e AZURE_POSTGRESQL_USERNAME, respetivamente. Essas variáveis de ambiente são mapeadas para valores secretos que armazenam as informações de conexão do banco de dados. Por motivos de segurança, eles são gerados automaticamente usando a extensão sem senha do Service Connector, conforme mostrado em outra parte deste artigo.

# Database configurations
%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
%prod.quarkus.datasource.username=${AZURE_POSTGRESQL_USERNAME}
%prod.quarkus.datasource.jdbc.acquisition-timeout=10
%prod.quarkus.hibernate-orm.database.generation=drop-and-create
%prod.quarkus.hibernate-orm.sql-load-script=import.sql

Configuração do Kubernetes

Examine as seguintes variáveis de configuração do Kubernetes. service-type está definido para load-balancer acessar o aplicativo externamente. Substitua os valores de <service-account-name> e <secret-name> pelos valores dos valores reais copiados na seção anterior.

# Kubernetes configurations
%prod.quarkus.kubernetes.deployment-target=kubernetes
%prod.quarkus.kubernetes.service-type=load-balancer
%prod.quarkus.kubernetes.labels."azure.workload.identity/use"=true
%prod.quarkus.kubernetes.service-account=<service-account-name>
%prod.quarkus.kubernetes.env.mapping.AZURE_CLIENT_ID.from-secret=<secret-name>
%prod.quarkus.kubernetes.env.mapping.AZURE_CLIENT_ID.with-key=AZURE_POSTGRESQL_CLIENTID
%prod.quarkus.kubernetes.env.mapping.AZURE_POSTGRESQL_HOST.from-secret=<secret-name>
%prod.quarkus.kubernetes.env.mapping.AZURE_POSTGRESQL_HOST.with-key=AZURE_POSTGRESQL_HOST
%prod.quarkus.kubernetes.env.mapping.AZURE_POSTGRESQL_PORT.from-secret=<secret-name>
%prod.quarkus.kubernetes.env.mapping.AZURE_POSTGRESQL_PORT.with-key=AZURE_POSTGRESQL_PORT
%prod.quarkus.kubernetes.env.mapping.AZURE_POSTGRESQL_DATABASE.from-secret=<secret-name>
%prod.quarkus.kubernetes.env.mapping.AZURE_POSTGRESQL_DATABASE.with-key=AZURE_POSTGRESQL_DATABASE
%prod.quarkus.kubernetes.env.mapping.AZURE_POSTGRESQL_USERNAME.from-secret=<secret-name>
%prod.quarkus.kubernetes.env.mapping.AZURE_POSTGRESQL_USERNAME.with-key=AZURE_POSTGRESQL_USERNAME

As outras configurações do Kubernetes especificam o mapeamento dos valores secretos para as variáveis de ambiente no aplicativo Quarkus. O <secret-name> segredo contém as informações de conexão do banco de dados. As teclas AZURE_POSTGRESQL_CLIENTID, AZURE_POSTGRESQL_HOST, AZURE_POSTGRESQL_PORT, AZURE_POSTGRESQL_DATABASE e AZURE_POSTGRESQL_USERNAME no mapa secreto correspondem, respetivamente, às variáveis de ambiente AZURE_CLIENT_ID, AZURE_POSTGRESQL_HOST, AZURE_POSTGRESQL_PORT, AZURE_POSTGRESQL_DATABASE e AZURE_POSTGRESQL_USERNAME.

Para examinar os segredos diretamente com o kubectl, use comandos semelhantes ao exemplo a seguir:

kubectl -n ${AKS_NS} get secret <secret-name> -o jsonpath="{.data.AZURE_POSTGRESQL_USERNAME}" | base64 --decode

Configuração de imagem de contêiner

Como uma tecnologia nativa da nuvem, o Quarkus suporta a geração de imagens de contêiner OCI compatíveis com o Docker. Substitua o valor de <LOGIN_SERVER_VALUE> pelo valor real da variável de ambiente ${LOGIN_SERVER}.

# Container Image Build
%prod.quarkus.container-image.build=true
%prod.quarkus.container-image.image=<LOGIN_SERVER_VALUE>/todo-quarkus-aks:1.0

Como verificação final, ao completares todas as substituições necessárias em application.properties, não deve haver ocorrências do carácter <. Se houver, verifique se você completou todas as substituições necessárias.

Crie a imagem do contêiner e envie-a para o registro do contêiner

Agora, use o seguinte comando para criar o próprio aplicativo. Este comando usa as extensões Kubernetes e Jib para criar a imagem do contêiner.

quarkus build --no-tests

A saída deve terminar com BUILD SUCCESS. Os arquivos de manifesto do Kubernetes são gerados em target/kubernetes, conforme mostrado no exemplo a seguir:

tree target/kubernetes
target/kubernetes
├── kubernetes.json
└── kubernetes.yml

0 directories, 2 files

Você pode verificar se a imagem do contêiner também é gerada usando docker a linha de comando (CLI). A saída é semelhante ao exemplo a seguir:

docker images | grep todo-quarkus-aks
<LOGIN_SERVER_VALUE>/todo-quarkus-aks   1.0       b13c389896b7   18 minutes ago   422MB

Envie as imagens de contêiner para o registro de contêiner usando o seguinte comando:

export TODO_QUARKUS_TAG=$(docker images | grep todo-quarkus-aks | head -n1 | cut -d " " -f1)
echo ${TODO_QUARKUS_TAG}
docker push ${TODO_QUARKUS_TAG}:1.0

O resultado deverá ter um aspeto semelhante ao seguinte exemplo:

The push refers to repository [<LOGIN_SERVER_VALUE>/todo-quarkus-aks]
dfd615499b3a: Pushed
56f5cf1aa271: Pushed
4218d39b228e: Pushed
b0538737ed64: Pushed
d13845d85ee5: Pushed
60609ec85f86: Pushed
1.0: digest: sha256:0ffd70d6d5bb3a4621c030df0d22cf1aa13990ca1880664d08967bd5bab1f2b6 size: 1995

Agora que tens enviado a aplicação para o registo de contentores, podes dizer ao AKS para executar a aplicação.

Implantar o aplicativo Quarkus no AKS

As etapas nesta seção mostram como executar o aplicativo de exemplo Quarkus nos recursos do Azure que você criou.

Utilize kubectl apply para implantar a aplicação Quarkus no AKS

Implante os recursos do Kubernetes usando kubectl na linha de comando, conforme mostrado no exemplo a seguir:

kubectl apply -f target/kubernetes/kubernetes.yml -n ${AKS_NS}

A saída deve ser semelhante ao exemplo a seguir:

service/quarkus-todo-demo-app-aks created
deployment.apps/quarkus-todo-demo-app-aks created

Verifique se o aplicativo está em execução usando o seguinte comando:

kubectl -n $AKS_NS get pods

Se o valor do STATUS campo mostrar algo diferente de Running, identifique e resolva o problema antes de continuar. Pode ser útil examinar os logs do pod usando o seguinte comando:

kubectl -n $AKS_NS logs $(kubectl -n $AKS_NS get pods | grep quarkus-todo-demo-app-aks | cut -d " " -f1)

Obtenha o EXTERNAL-IP para acessar o aplicativo Todo usando o seguinte comando:

kubectl get svc -n ${AKS_NS}

A saída deve ser semelhante ao exemplo a seguir:

NAME                        TYPE           CLUSTER-IP     EXTERNAL-IP     PORT(S)        AGE
quarkus-todo-demo-app-aks   LoadBalancer   10.0.236.101   20.12.126.200   80:30963/TCP   37s

Você pode usar o seguinte comando para salvar o valor de EXTERNAL-IP numa variável de ambiente como uma URL completa.

export QUARKUS_URL=http://$(kubectl get svc -n ${AKS_NS} | grep quarkus-todo-demo-app-aks | cut -d " " -f10)
echo $QUARKUS_URL

Abra um novo navegador da Web com o valor de ${QUARKUS_URL}. Em seguida, adicione um novo item todo com o texto Deployed the Todo app to AKS. Além disso, selecione como concluído o Introduction to Quarkus Todo App item.

Captura de ecrã da aplicação de exemplo Todo em execução no AKS.

Acesse a API RESTful (/api) para obter todos os itens de todo armazenados no banco de dados PostgreSQL do Azure, conforme mostrado no exemplo a seguir:

curl --verbose ${QUARKUS_URL}/api | jq .

A saída deve ser semelhante ao exemplo a seguir:

* Connected to 20.237.68.225 (20.237.68.225) port 80 (#0)
> GET /api HTTP/1.1
> Host: 20.237.68.225
> User-Agent: curl/7.88.1
> Accept: */*
>
< HTTP/1.1 200 OK
< content-length: 828
< Content-Type: application/json;charset=UTF-8
<
[
  {
    "id": 2,
    "title": "Quarkus on Azure App Service",
    "completed": false,
    "order": 1,
    "url": "https://learn.microsoft.com/en-us/azure/developer/java/eclipse-microprofile/deploy-microprofile-quarkus-java-app-with-maven-plugin"
  },
  {
    "id": 3,
    "title": "Quarkus on Azure Container Apps",
    "completed": false,
    "order": 2,
    "url": "https://learn.microsoft.com/en-us/training/modules/deploy-java-quarkus-azure-container-app-postgres/"
  },
  {
    "id": 4,
    "title": "Quarkus on Azure Functions",
    "completed": false,
    "order": 3,
    "url": "https://learn.microsoft.com/en-us/azure/azure-functions/functions-create-first-quarkus"
  },
  {
    "id": 5,
    "title": "Deployed the Todo app to AKS",
    "completed": false,
    "order": 5,
    "url": null
  },
  {
    "id": 1,
    "title": "Introduction to Quarkus Todo App",
    "completed": true,
    "order": 0,
    "url": null
  }
]

Verifique se o banco de dados está atualizado

Execute o seguinte comando para verificar se o banco de dados agora está atualizado corretamente:

ACCESS_TOKEN=$(az account get-access-token --resource-type oss-rdbms --output tsv --query accessToken)
az postgres flexible-server execute \
    --admin-user $ENTRA_ADMIN_NAME \
    --admin-password $ACCESS_TOKEN \
    --name $DB_SERVER_NAME \
    --database-name $DB_NAME \
    --querytext "select * from todo;"

Se lhe for pedido para instalar uma extensão, responda Y.

A saída deve ser semelhante ao exemplo a seguir e deve incluir os mesmos itens na GUI do aplicativo Todo e na saída do curl comando anteriormente:

Successfully connected to <DB_SERVER_NAME>.
Ran Database Query: 'select * from todo;'
Retrieving first 30 rows of query output, if applicable.
Closed the connection to <DB_SERVER_NAME>
[
  {
    "completed": false,
    "id": 2,
    "ordering": 1,
    "title": "Quarkus on Azure App Service",
    "url": "https://learn.microsoft.com/en-us/azure/developer/java/eclipse-microprofile/deploy-microprofile-quarkus-java-app-with-maven-plugin"
  },
  {
    "completed": false,
    "id": 3,
    "ordering": 2,
    "title": "Quarkus on Azure Container Apps",
    "url": "https://learn.microsoft.com/en-us/training/modules/deploy-java-quarkus-azure-container-app-postgres/"
  },
  {
    "completed": false,
    "id": 4,
    "ordering": 3,
    "title": "Quarkus on Azure Functions",
    "url": "https://learn.microsoft.com/en-us/azure/azure-functions/functions-create-first-quarkus"
  },
  {
    "completed": false,
    "id": 5,
    "ordering": 5,
    "title": "Deployed the Todo app to AKS",
    "url": null
  },
  {
    "completed": true,
    "id": 1,
    "ordering": 0,
    "title": "Introduction to Quarkus Todo App",
    "url": null
  }
]

Quando terminar, exclua a regra de firewall que permite que seu endereço IP local acesse a instância do Servidor Flexível do Banco de Dados do Azure para PostgreSQL usando o seguinte comando:

az postgres flexible-server firewall-rule delete \
    --resource-group $RESOURCE_GROUP_NAME \
    --name $DB_SERVER_NAME \
    --rule-name $DB_SERVER_NAME-database-allow-local-ip \
    --yes

Limpeza de recursos

Para evitar cobranças do Azure, você deve limpar recursos desnecessários. Quando o cluster não for mais necessário, use o comando az group delete para remover o grupo de recursos, o serviço de contêiner, o registro de contêiner e todos os recursos relacionados.

git reset --hard
docker rmi ${TODO_QUARKUS_TAG}:1.0
docker rmi postgres
az identity delete --ids ${UAMI_RESOURCE_ID}
az group delete --name $RESOURCE_GROUP_NAME --yes --no-wait

Você também pode querer usar docker rmi para excluir as imagens geradas postgres e testcontainers de contentores pelo modo de desenvolvimento do Quarkus.

Próximos passos