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. O aplicativo é uma "lista de tarefas" com um front-end JavaScript e um ponto de extremidade 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 subscrição do Azure, crie uma conta gratuita do Azure antes de começar.
• Prepare uma máquina local com o sistema operacional Unix-like instalado - por exemplo, Ubuntu, macOS ou Windows Subsystem para 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 o Docker para seu sistema operacional.
• Instale o jq.
• Instale o cURL.
• Instale a CLI do Quarkus, versão 3.12.1 ou superior.
• CLI do Azure para ambientes Unix-like. Este artigo requer apenas a variante Bash da CLI do Azure.
  • • Bash
    • PowerShell
    • Visual Studio Code

    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 você vir uma mensagem sobre estar no estado HEAD desanexado, essa mensagem é segura para ignorar. 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.

Você pode ser perguntado 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 você quiser esperar que o depurador anexe antes de executar, passe -Dsuspend a linha de comando. Se você não quiser o depurador, você pode usar -Ddebug=falseo .

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 GUI do aplicativo diretamente http://localhost:8080 .

Tente selecionar alguns itens de todo 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 todo à lista todo digitando Verify Todo apps e pressionando Enter, conforme mostrado na captura de tela a seguir:

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://zcusa.951200.xyz/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://zcusa.951200.xyz/en-us/training/modules/deploy-java-quarkus-azure-container-app-postgres/"
  },
  {
    "id": 4,
    "title": "Quarkus on Azure Functions",
    "completed": false,
    "order": 3,
    "url": "https://zcusa.951200.xyz/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 Contentores do Azure
• Azure Kubernetes Service (AKS)

Alguns desses recursos devem ter nomes exclusivos dentro do escopo da assinatura do Azure. Para garantir essa exclusividade, você pode usar as iniciais, sequência, data, padrão de 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 UNIQUE_VALUE de espaço reservado por LOCATION seus próprios valores e, em seguida, execute os seguintes comandos no terminal:

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 com o Banco de Dados do Azure para instância do Servidor Flexível PostgreSQL localmente.

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}

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

Abra um novo navegador da Web para http://localhost:8080 acessar o 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

Entre na instância do registro de contêiner. Iniciar sessão permite-lhe enviar uma imagem por push. 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 nomeado com o valor da variável ${CLUSTER_NAME} de ambiente 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 kubectlo , consulte Ferramenta de 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 nos passos 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 seção, você cria uma conexão de serviço entre o cluster AKS e o Banco de Dados do Azure para Servidor Flexível PostgreSQL usando a ID de Carga de Trabalho do Microsoft Entra 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",

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, use o seguinte comando para adicionar as quarkus-kubernetes extensões e container-image-jib em 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 essas propriedades estão ativas quando executadas prod no 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 relacionadas à conexão do banco de dados e %prod.quarkus.datasource.username os valores de leitura das variáveis AZURE_POSTGRESQL_HOSTde ambiente , , AZURE_POSTGRESQL_PORTAZURE_POSTGRESQL_DATABASE, e AZURE_POSTGRESQL_USERNAME, respectivamente. 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 AZURE_POSTGRESQL_CLIENTIDchaves , , AZURE_POSTGRESQL_PORTAZURE_POSTGRESQL_HOST, AZURE_POSTGRESQL_DATABASE, e AZURE_POSTGRESQL_USERNAME no mapa secreto para as AZURE_CLIENT_IDvariáveis , AZURE_POSTGRESQL_HOST, AZURE_POSTGRESQL_PORT, AZURE_POSTGRESQL_DATABASE, e AZURE_POSTGRESQL_USERNAME ambiente, respectivamente.

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 pelo valor real da ${LOGIN_SERVER} variável de <LOGIN_SERVER_VALUE> ambiente.

# 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, quando você concluir todas as substituições necessárias em application.properties, não deve haver ocorrências do < personagem. 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 você enviou o aplicativo para o registro de contêiner, você pode dizer ao AKS para executar o aplicativo.

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.

Use kubectl apply para implantar o aplicativo 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 campo mostrar algo diferente de Running, solucione e resolva o problema antes de STATUS 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 em uma variável de EXTERNAL-IP ambiente como uma URL totalmente qualificada:

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 o Introduction to Quarkus Todo App item como concluído.

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://zcusa.951200.xyz/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://zcusa.951200.xyz/en-us/training/modules/deploy-java-quarkus-azure-container-app-postgres/"
  },
  {
    "id": 4,
    "title": "Quarkus on Azure Functions",
    "completed": false,
    "order": 3,
    "url": "https://zcusa.951200.xyz/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://zcusa.951200.xyz/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://zcusa.951200.xyz/en-us/training/modules/deploy-java-quarkus-azure-container-app-postgres/"
  },
  {
    "completed": false,
    "id": 4,
    "ordering": 3,
    "title": "Quarkus on Azure Functions",
    "url": "https://zcusa.951200.xyz/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

Clean up resources (Limpar 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 postgres de contêiner geradas testcontainers pelo modo de desenvolvimento do Quarkus.

Próximos passos

• Azure Kubernetes Service
• Implantar aplicativos Java sem servidor com o Quarkus no Azure Functions
• Quarkus
• Extensão Kubernetes
• Opções de Jib
• Jacarta EE no Azure