Share via

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

  • Articolo

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 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.
  • Tutti questi prerequisiti sono preinstallati in Azure Cloud Shell. Per saperne di più, vedi Avvio rapido per Azure Cloud Shell.
  • Se stai eseguendo i comandi in questa guida in locale (anziché usare Azure Cloud Shell), completa i passaggi seguenti:
    • Prepara un computer locale con un sistema operativo simile a Unix installato (ad esempio Ubuntu, Azure Linux, macOS, Sottosistema Windows per Linux).
    • Installa un'implementazione java SE (ad esempio, Microsoft build di OpenJDK).
    • Installa Maven 3.5.0 o versione successiva.
    • Installa Docker o Podman per il tuo sistema operativo.
    • Installa jq.
    • Installa cURL.
    • Installa l'interfaccia della riga di comando di Quarkus.
  • 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.
    • 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.31.0 dell'interfaccia della riga di comando di Azure. Se si usa Azure Cloud Shell, la versione più recente è già installata.

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 2023-07-17
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 del relativo servizio e la connette alla tua applicazione. Per ulteriori informazioni, vedi Panoramica di Dev Services nella documentazione di Quarkus.

Assicurati che l'ambiente del contenitore, Docker o Podman, sia in esecuzione e usa 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.

Ti potrebbe essere chiesto se si vuoi inviare dati di telemetria del tuo 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 si vuole affatto il debugger, è possibile 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.

Screenshot dell'app di esempio Todo.

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

Screenshot dell'app di esempio Todo con i nuovi elementi aggiunti.

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

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
  • 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". Usa i comandi seguenti per definire alcune variabili di ambiente da usare in un secondo momento:

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, eastus>
export REGISTRY_NAME=${UNIQUE_VALUE}reg
export DB_SERVER_NAME=${UNIQUE_VALUE}db
export CLUSTER_NAME=${UNIQUE_VALUE}aks
export AKS_NS=${UNIQUE_VALUE}ns

Creare un database di Azure per PostgreSQL

Il database di Azure per PostgreSQL è un servizio gestito usato per eseguire, gestire e dimensionare database PostgreSQL a disponibilità elevata nel cloud di Azure. Questa sezione ti rimanda a una guida introduttiva separata che spiega come creare un singolo server di Database di Azure per PostgreSQL e come connetterti a esso. Tuttavia, quando segui i passaggi della guida introduttiva, devi usare le impostazioni nella tabella seguente per personalizzare la distribuzione del database per l'app Quarkus di esempio. Sostituisci le variabili di ambiente con i relativi valori reali durante la compilazione dei campi nel portale di Azure.

Impostazione valore Descrizione
Gruppo di risorse ${RESOURCE_GROUP_NAME} Selezionare Crea nuovo. La distribuzione crea questo nuovo gruppo di risorse.
Nome server ${DB_SERVER_NAME} Questo valore fa parte del nome host per il server di database.
Ufficio ${LOCATION} selezionare una località dall'elenco a discesa. Prendi nota della posizione. Devi usare questa stessa posizione per altre risorse di Azure create da te.
Nome utente amministratore quarkus Il codice di esempio presuppone questo valore.
Password Secret123456 Il codice di esempio presuppone questo valore.

Tenendo presente queste sostituzioni di valori, segui la procedura descritta in Avvio rapido: Creare un server di Database di Azure per PostgreSQL usando il portale di Azure fino alla sezione "Configurare una regola del firewall". Quindi, nella sezione "Configurare una regola del firewall", assicurati di selezionare Sì per Consenti l'accesso ai servizi di Azure e quindi seleziona Salva. Se non esegui questa operazione, l'app Quarkus non riesce ad accedere al database e non riesce a avviarsi.

Dopo aver completato i passaggi della guida introduttiva tramite la sezione "Configurare una regola del firewall", incluso il passaggio per consentire l'accesso ai servizi di Azure, torna a questo articolo.

Crea un database To Do in PostgreSQL

Il server PostgreSQL creato in precedenza è vuoto. Non include nessun database che è possibile usare con l'applicazione Quarkus. Creare un nuovo database denominato todo con il comando seguente:

az postgres db create \
    --resource-group ${RESOURCE_GROUP_NAME} \
    --name todo \
    --server-name ${DB_SERVER_NAME}

Devi usare todo come nome del database perché il codice di esempio presuppone quel nome di database.

Se il comando va a buon fine, l'output sarà simile all'esempio seguente:

{
  "charset": "UTF8",
  "collation": "English_United States.1252",
  "id": "/subscriptions/REDACTED/resourceGroups/ejb010718rg/providers/Microsoft.DBforPostgreSQL/servers/ejb010718db/databases/todo",
  "name": "todo",
  "resourceGroup": "ejb010718rg",
  "type": "Microsoft.DBforPostgreSQL/servers/databases"
}

Creare un'istanza di Registro Container Microsoft Azure

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 il Registro Azure Container (ACR).

Usa il comando az acr create per creare l'istanza di Registro Azure Container. L'esempio seguente crea un'istanza di Registro Azure Container denominata con il valore della variabile di ambiente ${REGISTRY_NAME}:

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

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

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

Connettere docker all'istanza di Registro Azure Container

Accedere all'istanza di Registro Azure Container. L'accesso consente di eseguire il push di un'immagine. Usa i comandi seguenti per verificare la connessione:

export LOGIN_SERVER=$(az acr show \
    --name $REGISTRY_NAME \
    --query 'loginServer' \
    --output tsv)
echo $LOGIN_SERVER
export USER_NAME=$(az acr credential show \
    --name $REGISTRY_NAME \
    --query 'username' \
    --output tsv)
echo $USER_NAME
export PASSWORD=$(az acr credential show \
    --name $REGISTRY_NAME \
    --query 'passwords[0].value' \
    --output tsv)
echo $PASSWORD
docker login $LOGIN_SERVER -u $USER_NAME -p $PASSWORD

Se stai usando Podman invece di Docker, apporta le modifiche necessarie al comando.

Se hai eseguito correttamente l'accesso all'istanza di Registro Azure Container, dovresti visualizzare 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 di Registro Azure Container che hai creato in un passaggio precedente. Il completamento di questo comando richiede diversi minuti.

az aks create \
    --resource-group $RESOURCE_GROUP_NAME \
    --location ${LOCATION} \
    --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. Se si usa Azure Cloud Shell, kubectl è già installato. 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.23.8

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

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 ulteriori informazioni, vedi 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 ti indirizzano a rimuovere il commento e personalizzare i valori nel file src/main/resources/application.properties. Assicurati che tutte le righe che iniziano con # %prod. siano non commentate rimuovendo l'oggetto iniziale #.

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

Aggiungi le seguenti variabili di configurazione del database. Sostituisci i valori di <DB_SERVER_NAME_VALUE> con i valori effettivi della variabile di ambiente ${DB_SERVER_NAME}.

# Database configurations
%prod.quarkus.datasource.db-kind=postgresql
%prod.quarkus.datasource.jdbc.url=jdbc:postgresql://<DB_SERVER_NAME_VALUE>.postgres.database.azure.com:5432/todo
%prod.quarkus.datasource.jdbc.driver=org.postgresql.Driver
%prod.quarkus.datasource.username=quarkus@<DB_SERVER_NAME_VALUE>
%prod.quarkus.datasource.password=Secret123456
%prod.quarkus.hibernate-orm.database.generation=drop-and-create

Configurazione di Kubernetes

Aggiungi le seguenti variabili di configurazione di Kubernetes. Assicurati di impostare service-type su load-balancer per accedere all'app esternamente.

# AKS configurations
%prod.quarkus.kubernetes.deployment-target=kubernetes
%prod.quarkus.kubernetes.service-type=load-balancer

Configurazione dell'immagine del contenitore

In quanto tecnologia nativa del cloud, Quarkus supporta la generazione di immagini contenitore OCI compatibili con Docker e Podman. Aggiungi le seguenti variabili container-image. Sostituisci i valori di <LOGIN_SERVER_VALUE> e <USER_NAME_VALUE> con i valori effettivi delle variabili di ${LOGIN_SERVER} e di ambiente ${USER_NAME} rispettivamente.

# Container Image Build
%prod.quarkus.container-image.build=true
%prod.quarkus.container-image.registry=<LOGIN_SERVER_VALUE>
%prod.quarkus.container-image.group=<USER_NAME_VALUE>
%prod.quarkus.container-image.name=todo-quarkus-aks
%prod.quarkus.container-image.tag=1.0

Compila l'immagine del contenitore ed esegui il push in Registro Azure Container

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

Puoi verificare se l'immagine del contenitore viene generata anche usando la riga di comando (CLI) docker o podman. L'output è simile al seguente esempio:

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

Esegui il push delle immagini del contenitore in Registro Azure Container 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>/<USER_NAME_VALUE>/todo-quarkus-aks]
dfd615499b3a: Pushed
56f5cf1aa271: Pushed
4218d39b228e: Pushed
b0538737ed64: Pushed
d13845d85ee5: Pushed
60609ec85f86: Pushed
1.0: digest: sha256:0ffd70d6d5bb3a4621c030df0d22cf1aa13990ca1880664d08967bd5bab1f2b6 size: 1995

Dopo aver eseguito il push dell'app in Registro Azure Container, puoi indicare al servizio Azure Kubernetes di eseguire l'app.

Distribuire l'app Quarkus nel servizio Azure Kubernetes

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

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:

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.

Screenshot dell'app di esempio Todo in esecuzione nel servizio Azure Kubernetes.

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

Verificare che il database sia stato aggiornato con Azure Cloud Shell

Apri Azure Cloud Shell nel portale di Azure selezionando l'icona Cloud Shell, come illustrato nello screenshot seguente:

Screenshot del portale di Azure con il pulsante Cloud Shell evidenziato.

Esegui il comando seguente in locale e incolla il risultato in Azure Cloud Shell:

echo psql --host=${DB_SERVER_NAME}.postgres.database.azure.com --port=5432 --username=quarkus@${DB_SERVER_NAME} --dbname=todo

Quando viene richiesta la password, usa il valore che hai usato quando hai creato il database.

Usa la query seguente per ottenere tutti gli elementi To Do:

select * from todo;

L'output dovrebbe essere simile all'esempio seguente e dovrebbe includere gli stessi elementi nell'interfaccia utente grafica dell'app To Do mostrata in precedenza:

Screenshot dell'output della query come tabella ASCII.

Se nell'output visualizzi MORE, digita q per uscire dal pager.

Immetti \q per uscire dal programma psql e torna a Cloud Shell.

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 group delete --name $RESOURCE_GROUP_NAME --yes --no-wait

Potresti anche voler usare docker rmi per eliminare le immagini del contenitorepostgres e generate dalla modalità di sviluppo Quarkus testcontainers.

Passaggi successivi