Distribuire un'applicazione Java con Quarkus in un cluster del servizio Azure Kubernetes

Questo articolo mostra come distribuire rapidamente Red Hat Quarkus nel servizio Azure Kubernetes (AKS) con una semplice applicazione CRUD. L'applicazione è un "elenco attività" con un front-end JavaScript e un endpoint REST. Il server flessibile di Database di Azure per PostgreSQL fornisce il livello di persistenza per l'app. L'articolo ti mostra come testare l a tua app in locale e distribuirla nel servizio Azure Kubernetes.

Prerequisiti

• Se non si ha una sottoscrizione di Azure, creare un account Azure gratuito prima di iniziare.
• Prepara un computer locale con un sistema operativo simile a Unix installato, ad esempio Ubuntu, Azure Linux, macOS, Sottosistema Windows per Linux.
• Installare un'implementazione Java edizione Standard versione 17 o successiva, ad esempio la versione Microsoft di OpenJDK.
• Installare Maven, versione 3.9.8 o successiva.
• Installare Docker per il sistema operativo.
• Installa jq.
• Installa cURL.
• Installare l'interfaccia della riga di comando Quarkusversione 3.12.1 o successiva.
• Interfaccia della riga di comando di Azure per ambienti simili a Unix. Questo articolo richiede solo la variante Bash dell'interfaccia della riga di comando di Azure.
  • • Bash
    • PowerShell
    • Visual Studio Code

    Uno sviluppatore deve installare l'interfaccia della riga di comando di Azure e accedere in modo interattivo con il comando az login per accedere ad Azure prima di usare DefaultAzureCredential nel codice.

    az login
    

  • Questo articolo richiede almeno la versione 2.61.0 dell'interfaccia della riga di comando di Azure.

Crea il progetto app

Usa il comando seguente per clonare il progetto Java di esempio per questo articolo. L'esempio è disponibile in GitHub.

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

Se visualizzi un messaggio relativo allo stato HEAD scollegato, questo messaggio è sicuro da ignorare. Poiché questo articolo non richiede commit, lo stato HEAD scollegato è appropriato.

Testare l'app Quarkus in locale

I passaggi descritti in questa sezione ti mostrano come eseguire l'app in locale.

Quarkus supporta il provisioning automatico di servizi non configurati in modalità di sviluppo e test. Quarkus fa riferimento a questa funzionalità come servizi di sviluppo. Supponiamo di includere una funzionalità Quarkus, ad esempio la connessione a un servizio di database. Vuoi testare l'app, ma non hai ancora configurato completamente la connessione a un database reale. Quarkus avvia automaticamente una versione stub in contenitori del servizio pertinente e la connette all'applicazione. Per ulteriori informazioni, vedi Panoramica di Dev Services nella documentazione di Quarkus.

Assicurarsi che l'ambiente contenitore sia in esecuzione e usare il comando seguente per immettere la modalità di sviluppo Quarkus:

quarkus dev

Invece di quarkus dev, puoi ottenere lo stesso risultato con Maven usando mvn quarkus:dev.

Potrebbe essere richiesto se si vogliono inviare dati di telemetria dell'utilizzo della modalità di sviluppo Quarkus. In tal caso, dai la risposta che ritieni appropriata.

La modalità di sviluppo Quarkus abilita il ricaricamento live con la compilazione in background. Se modifichi qualsiasi aspetto del codice sorgente dell'app e aggiorni il browser, puoi visualizzare le modifiche. In caso di problemi di compilazione o di distribuzione, una pagina di errore te lo segnala. La modalità di sviluppo Quarkus è in ascolto di un debugger sulla porta 5005. Se vuoi attendere il collegamento del debugger prima dell'esecuzione, passa -Dsuspend alla riga di comando. Se non vuoi affatto il debugger, puoi usare -Ddebug=false.

L'output dovrebbe essere simile all'esempio seguente:

__  ____  __  _____   ___  __ ____  ______
 --/ __ \/ / / / _ | / _ \/ //_/ / / / __/
 -/ /_/ / /_/ / __ |/ , _/ ,< / /_/ /\ \
--\___\_\____/_/ |_/_/|_/_/|_|\____/___/
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>

Premi w sul terminale in cui è in esecuzione la modalità di sviluppo Quarkus. Il tasto w apre il Web browser predefinito per visualizzare l'applicazione Todo. Puoi anche accedere direttamente all'interfaccia utente grafica dell'applicazione a http://localhost:8080.

Prova a selezionare alcuni elementi To Do nell'elenco To Do. L'interfaccia utente indica la selezione con uno stile di testo barrato. È anche possibile aggiungere un nuovo elemento todo all'elenco todo digitando Verify Todo apps (Verifica app Todo) e premendo INVIO, come illustrato nello screenshot seguente:

Accedi all'API RESTful (/api) per ottenere tutti gli elementi To Do archiviati nel database PostgreSQL locale:

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

L'output dovrebbe essere simile all'esempio seguente:

* 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
  }
]

Premi q per uscire dalla modalità di sviluppo Quarkus.

Creare le risorse di Azure per eseguire l'app Quarkus

I passaggi descritti in questa sezione mostrano come creare le risorse di Azure seguenti per eseguire l'app di esempio Quarkus:

• Database di Azure per PostgreSQL - Server flessibile
• Registro Azure Container
• Servizio Azure Kubernetes (AKS)

Alcune di queste risorse devono avere nomi univoci nell'ambito della sottoscrizione di Azure. Per garantire questa univocità, puoi usare il criterio iniziali, sequenza, data, suffisso. Per applicare questo modello, denomina le tue risorse elencando le tue iniziali, un tipo di numero di sequenza, la data odierna e un tipo di suffisso specifico della risorsa, ad esempio rg per "gruppo di risorse". Le variabili di ambiente seguenti usano questo modello. Sostituire i valori UNIQUE_VALUE segnaposto e LOCATION con i propri valori e quindi eseguire i comandi seguenti nel terminale:

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

Creare un server flessibile di Database di Azure per PostgreSQL

Il server flessibile di Database di Azure per PostgreSQL è un servizio di database completamente gestito progettato per offrire un controllo più granulare e una maggiore flessibilità rispetto alle funzioni di gestione e alle impostazioni di configurazione del database. Questa sezione illustra come creare un server flessibile di Database di Azure per PostgreSQL utilizzando l’interfaccia della riga di comando di Azure.

Per prima cosa, creare un gruppo di risorse per contenere il server di database e altre risorse usando il comando seguente:

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

Quindi, creare un’istanza del server flessibile di Database di Azure per PostgreSQL usando il comando seguente:

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

La creazione del server, del database, dell'utente amministratore e delle regole del firewall richiede alcuni minuti. Se il comando va a buon fine, l'output sarà simile all'esempio seguente:

{
  "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"
}

Testare l'app in locale con Database di Azure per PostgreSQL server flessibile

Nella sezione precedente è stata testata l'app Quarkus in locale in modalità di sviluppo con un database PostgreSQL di cui è stato effettuato il provisioning come contenitore Docker. Testare ora la connessione all'istanza del server flessibile Database di Azure per PostgreSQL localmente.

Aggiungere prima di tutto l'utente connesso corrente come Amministratore di Microsoft Entra all'istanza del server flessibile di Database di Azure per PostgreSQL usando i comandi seguenti:

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)

L'output riuscito è un oggetto JSON che include la proprietà "type": "Microsoft.DBforPostgreSQL/flexibleServers/administrators".

Aggiungere quindi l'indirizzo IP locale alle regole del firewall dell'istanza del server flessibile Database di Azure per PostgreSQL seguendo questa procedura:

1. Ottenere l'indirizzo IP locale del computer in cui si esegue l'app Quarkus in locale. Ad esempio, visitare https://whatismyipaddress.com per ottenere l'indirizzo IP pubblico v4.

2. Definire una variabile di ambiente con l'indirizzo IP locale ottenuto nel passaggio precedente.

   export AZ_LOCAL_IP_ADDRESS=<your local IP address>
   

3. Eseguire il comando seguente per aggiungere l'indirizzo IP locale alle regole del firewall dell'istanza del server flessibile Database di Azure per 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
   

Impostare quindi le variabili di ambiente seguenti nel terminale precedente. Queste variabili di ambiente vengono usate per connettersi all'istanza del server flessibile Database di Azure per PostgreSQL dall'app Quarkus in esecuzione in locale:

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}

Eseguire ora l'app Quarkus in locale per testare la connessione all'istanza del server flessibile Database di Azure per PostgreSQL. Usare il comando seguente per avviare l'app in modalità di produzione:

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

Aprire un nuovo Web browser per http://localhost:8080 accedere all'applicazione Todo. Verrà visualizzata l'app Todo, simile a quella visualizzata durante l'esecuzione dell'app in locale in modalità di sviluppo.

Creare un'istanza di Registro Azure Container

Poiché Quarkus è una tecnologia nativa del cloud, include il supporto predefinito per la creazione di contenitori eseguiti in Kubernetes. Kubernetes dipende interamente dalla presenza di un registro contenitori dal quale trova le immagini del contenitore da eseguire. Il servizio Azure Kubernetes include il supporto predefinito per Registro Azure Container.

Usare il comando az acr create per creare l'istanza del registro contenitori. L'esempio seguente crea un'istanza del registro contenitori denominata con il valore della variabile ${REGISTRY_NAME}di ambiente :

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

Dopo un breve periodo di tempo, dovresti visualizzare l'output JSON che contiene le righe seguenti:

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

Ottenere il server di accesso per l'istanza del Registro Container usando il comando seguente:

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

Connettere docker all'istanza del registro contenitori

Accedere all'istanza del registro contenitori. L'accesso consente di eseguire il push di un'immagine. Usare il comando seguente per accedere al Registro di sistema:

az acr login --name $REGISTRY_NAME

Se l'accesso all'istanza del registro contenitori è stato eseguito correttamente, verrà visualizzato Login Succeeded alla fine dell'output del comando.

Creare un cluster del servizio Azure Kubernetes

Usare il comando az aks create per creare un cluster del servizio Azure Kubernetes. L'esempio seguente crea un cluster denominato con il valore della tua variabile di ambiente ${CLUSTER_NAME} con un nodo. Il cluster è connesso all'istanza del registro contenitori creata in un passaggio precedente. Il completamento di questo comando richiede diversi minuti. Il cluster viene avviato con l'identità gestita abilitata. Questo passaggio è necessario per la connessione al database senza password.

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

Il comando viene completato dopo pochi minuti e vengono restituite informazioni in formato JSON relative al cluster, he includono il seguente output:

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

Connettersi al cluster servizio Azure Kubernetes

Per gestire un cluster Kubernetes, usa kubectl, il client da riga di comando di Kubernetes. Per eseguire l'installazione kubectl in locale, usa il comando az aks install-cli, come illustrato nell'esempio seguente:

az aks install-cli

Per ulteriori informazioni su kubectl, vedi Strumento da riga di comando (kubectl) nella documentazione di Kubernetes.

Per configurare kubectl per connetterti al cluster Kubernetes, usa il comando az aks get-credentials, come mostrato nell'esempio seguente. Questo comando scarica le credenziali e configura l'interfaccia della riga di comando di Kubernetes per usarli.

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

L'output riuscito include un testo simile all'esempio seguente:

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

Potresti trovare utile eseguire l'alias k per kubectl. In tal caso, usa il comando seguente:

alias k=kubectl

Per verificare la connessione al tuo cluster, usa il comando kubectl get per restituire un elenco dei nodi del cluster, come mostrato nell'esempio seguente:

kubectl get nodes

L'esempio di output seguente mostra il nodo singolo creato nei passaggi precedenti. Assicurarsi che lo stato del nodo sia impostato su Pronto:

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

Creare un nuovo spazio dei nomi nel servizio Azure Kubernetes

Usa il comando seguente per creare un nuovo spazio dei nomi nel servizio Kubernetes per la tua app Quarkus:

kubectl create namespace ${AKS_NS}

L'output dovrebbe essere simile all'esempio seguente:

namespace/<your namespace> created

Creare una connessione al servizio nel servizio Azure Kubernetes con Service Connector

In questa sezione viene creata una connessione al servizio tra il cluster del servizio Azure Kubernetes e il server flessibile Database di Azure per PostgreSQL usando ID dei carichi di lavoro di Microsoft Entra con Service Connector. Questa connessione consente al cluster del servizio Azure Kubernetes di accedere al server flessibile Database di Azure per PostgreSQL senza usare l'autenticazione SQL.

Eseguire i comandi seguenti per creare una connessione tra il cluster del servizio Azure Kubernetes e il database PostgreSQL usando ID dei carichi di lavoro di Microsoft Entra con 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

La presenza del codice JSON seguente nell'output del comando finale nei passaggi precedenti indica un'installazione corretta del connettore di servizio:

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

Ottenere l'account del servizio e il segreto creati da Service Connector

Per eseguire l'autenticazione al server flessibile Database di Azure per PostgreSQL, è necessario ottenere l'account del servizio e il segreto Kubernetes creati da Service Connector. Seguire le istruzioni nella sezione Aggiornare il contenitore di Esercitazione: Connettere un'app del servizio Azure Kubernetes a database SQL di Azure. Usare l'opzione Creare direttamente una distribuzione usando il frammento di codice di esempio YAML fornito e usare il passaggio seguente:

• Dalle sezioni evidenziate nell'esempio di distribuzione YAML di Kubernetes copiare i valori di serviceAccountName e secretRef.name, rappresentati come <service-account-name> e <secret-name> nell'esempio seguente:

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

  Questi valori vengono usati nella sezione successiva per distribuire l'applicazione Quarkus nel cluster del servizio Azure Kubernetes.

Personalizzare la configurazione nativa del cloud

In quanto tecnologia nativa del cloud, Quarkus offre la possibilità di configurare automaticamente le risorse per Kubernetes standard, Red Hat OpenShift e Knative. Per altre informazioni, vedere la guida di Quarkus Kubernetes, la guida di Quarkus OpenShift e la guida di Quarkus Knative. Gli sviluppatori possono distribuire l'applicazione in un cluster Kubernetes di destinazione applicando i manifesti generati.

Per generare le risorse Kubernetes appropriate, usa il comando seguente per aggiungere le estensioni quarkus-kubernetes e container-image-jib nel terminale locale:

quarkus ext add kubernetes container-image-jib

Quarkus modifica il POM per garantire che queste estensioni siano elencate come <dependencies>. Se ti viene chiesto di installare un elemento denominato JBang, rispondi sì e consenti l'installazione.

L'output dovrebbe essere simile all'esempio seguente:

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

Per verificare che le estensioni siano state aggiunte, puoi eseguire git diff ed esaminare l'output.

In quanto tecnologia nativa del cloud, Quarkus supporta la nozione di profili di configurazione. Quarkus dispone dei tre profili predefiniti seguenti:

• dev - Attivato quando in modalità di sviluppo
• test - Attivato durante l'esecuzione di test
• prod - Profilo predefinito quando non è in esecuzione in modalità di sviluppo o test

Quarkus supporta un qualsiasi numero di profili denominati, in base alle esigenze.

I passaggi rimanenti di questa sezione consentono di personalizzare i valori nel file src/main/resources/application.properties .

Il prefisso prod. indica che queste proprietà sono attive durante l'esecuzione nel profilo prod. Per ulteriori informazioni sui profili di configurazione, vedi la documentazione di Quarkus.

Configurazione del database

Esaminare le variabili di configurazione del database seguenti. Le proprietà %prod.quarkus.datasource.jdbc.url correlate alla connessione al database e %prod.quarkus.datasource.username leggono i valori delle variabili AZURE_POSTGRESQL_HOSTdi ambiente , , AZURE_POSTGRESQL_PORTAZURE_POSTGRESQL_DATABASEe AZURE_POSTGRESQL_USERNAME, rispettivamente. Queste variabili di ambiente eseguono il mapping ai valori segreti che archiviano le informazioni di connessione al database. Per motivi di sicurezza, vengono generati automaticamente usando l'estensione senza password di Service Connector, come illustrato altrove in questo articolo.

# 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

Configurazione di Kubernetes

Esaminare le variabili di configurazione di Kubernetes seguenti. service-type è impostato su per load-balancer accedere all'app esternamente. Sostituire i valori di <service-account-name> e <secret-name> con i valori dei valori effettivi copiati nella sezione precedente.

# 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

Le altre configurazioni Kubernetes specificano il mapping dei valori dei segreti alle variabili di ambiente nell'applicazione Quarkus. Il segreto <secret-name> contiene le informazioni di connessione al database. Le AZURE_POSTGRESQL_CLIENTIDchiavi , AZURE_POSTGRESQL_HOST, AZURE_POSTGRESQL_DATABASEAZURE_POSTGRESQL_PORT, e AZURE_POSTGRESQL_USERNAME nel segreto eseguono rispettivamente il AZURE_CLIENT_IDmapping alle variabili di ambiente , , AZURE_POSTGRESQL_DATABASEAZURE_POSTGRESQL_HOSTAZURE_POSTGRESQL_PORT, e .AZURE_POSTGRESQL_USERNAME

Per esaminare i segreti direttamente con kubectl, usare comandi simili all'esempio seguente:

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

Configurazione dell'immagine del contenitore

Come tecnologia nativa del cloud, Quarkus supporta la generazione di immagini contenitore OCI compatibili con Docker. Sostituire il valore di con il valore effettivo della ${LOGIN_SERVER} variabile di <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

Come controllo finale, quando si completano tutte le sostituzioni necessarie in application.properties, non devono essere presenti occorrenze del < carattere. In caso affermativo, verificare di aver completato tutte le sostituzioni necessarie.

Compilare l'immagine del contenitore ed eseguirne il push nel registro contenitori

A questo punto, usa il comando seguente per compilare l'applicazione stessa. Questo comando utilizza le estensioni Kubernetes e Jib per compilare l'immagine del contenitore.

quarkus build --no-tests

L'output deve terminare con BUILD SUCCESS. I file manifesto Kubernetes vengono generati in target/kubernetes, come mostrato nell'esempio seguente:

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

0 directories, 2 files

È possibile verificare se l'immagine del contenitore viene generata anche usando la docker riga di comando. L'output è simile al seguente esempio:

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

Eseguire il push delle immagini del contenitore nel registro contenitori usando il comando seguente:

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

L'output deve essere simile all'esempio seguente:

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

Ora che è stato eseguito il push dell'app nel registro contenitori, è possibile indicare al servizio Azure Kubernetes di eseguire l'app.

Distribuire l'app Quarkus nel servizio Azure Kubernetes

I passaggi descritti in questa sezione illustrano come eseguire l'app di esempio Quarkus nelle risorse di Azure create.

Usa kubectl apply per distribuire l'app Quarkus nel servizio Azure Kubernetes

Distribuisci le risorse Kubernetes usando kubectl nella riga di comando, come mostrato nell'esempio seguente:

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

L'output dovrebbe essere simile all'esempio seguente:

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

Verifica che l'app sia in esecuzione usando il comando seguente:

kubectl -n $AKS_NS get pods

Se il valore del campo STATUS mostra un valore diverso da Running, diagnostica e risolvi il problema prima di continuare. Può essere utile esaminare i log dei pod usando il comando seguente:

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

Ottieni EXTERNAL-IP per accedere all'applicazione To Do usando il comando seguente:

kubectl get svc -n ${AKS_NS}

L'output dovrebbe essere simile all'esempio seguente:

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

Puoi usare il comando seguente per salvare il valore di EXTERNAL-IP in una variabile di ambiente come URL completo:

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

Apri un nuovo Web browser sul valore di ${QUARKUS_URL}. Aggiungi quindi un nuovo elemento To Do con il testo Deployed the Todo app to AKS. Seleziona anche l'elemento Introduction to Quarkus Todo App come completo.

Accedi all'API RESTful (/api) per ottenere tutti gli elementi To Do archiviati nel database PostgreSQL di Azure, come mostrato nell'esempio seguente:

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

L'output dovrebbe essere simile all'esempio seguente:

* 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
  }
]

Verificare che il database sia aggiornato

Eseguire il comando seguente per verificare che il database sia stato aggiornato correttamente:

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 viene chiesto di installare un'estensione, rispondere Y.

L'output dovrebbe essere simile all'esempio seguente e deve includere gli stessi elementi nell'interfaccia utente grafica dell'app Todo e nell'output del curl comando in precedenza:

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
  }
]

Al termine, eliminare la regola del firewall che consente all'indirizzo IP locale di accedere all'istanza del server flessibile Database di Azure per PostgreSQL usando il comando seguente:

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

Pulire le risorse

Per evitare addebiti per Azure, è necessario eliminare le risorse non necessarie. Quando il cluster non è più necessario, usa il comando az group delete per rimuovere il gruppo di risorse, il servizio contenitore e tutte le risorse correlate.

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

È anche possibile usare docker rmi per eliminare le immagini postgres del contenitore e testcontainers generate dalla modalità di sviluppo Quarkus.

Passaggi successivi

• Servizio Azure Kubernetes
• Distribuire app Java serverless con Quarkus in Funzioni di Azure
• Quarkus
• Estensione Kubernetes
• Opzioni jib
• Jakarta EE in Azure