Condividi tramite

Distribuire un'applicazione Java con Quarkus su Azure Container Apps

  • Articolo

Questo articolo illustra come distribuire rapidamente Red Hat Quarkus nelle app contenitore di Microsoft Azure con una semplice applicazione CRUD. L'applicazione è un "elenco attività" con un front-end JavaScript e un endpoint REST. Il server flessibile di Azure Database per PostgreSQL fornisce il livello di persistenza per l'app. L'articolo illustra come testare l'app in locale e distribuirla in App contenitore.

Prerequisiti

Crea il progetto app

Usare i comandi seguenti 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-10-14
cd aca-quarkus

Se viene visualizzato un messaggio relativo allo stato di detached HEAD, questo messaggio è sicuro da ignorare. Poiché questo articolo non richiede commit, è appropriato per lo stato detached HEAD.

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 contenitore sia in esecuzione e usa il comando seguente per entrare in modalità di sviluppo di 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-aca 1.0.0-SNAPSHOT on JVM (powered by Quarkus 3.2.0.Final) started in 14.826s. 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-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 - Server flessibile
  • Registro Azure Container
  • App contenitore di Azure

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 segnaposto in UNIQUE_VALUE e LOCATION con i propri valori ed eseguire i comandi nel terminale.

export UNIQUE_VALUE=<your unique value, such as mjg101424>
export RESOURCE_GROUP_NAME=${UNIQUE_VALUE}rg-passwordless
export LOCATION=<your desired Azure region for deploying your resources - for example, eastus>
export REGISTRY_NAME=${UNIQUE_VALUE}regpasswordless
export DB_SERVER_NAME=${UNIQUE_VALUE}dbpasswordless
export DB_NAME=demodb
export ACA_ENV=${UNIQUE_VALUE}envpasswordless
export ACA_NAME=${UNIQUE_VALUE}acapasswordless

Creare quindi un gruppo di risorse usando il comando seguente:

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

Creare un'istanza del server flessibile di Azure Database 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 flessibilità rispetto alle funzioni di gestione del database e alle impostazioni di configurazione. Questa sezione illustra come creare un'istanza di server flessibile di Azure Database per PostgreSQL utilizzando l'Azure CLI. Per altre informazioni, vedere Avvio rapido: Creare un'istanza di Database di Azure per PostgreSQL - Server flessibile.

Creare un'istanza del server flessibile Database di Azure per PostgreSQL usando il comando seguente:

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

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:REDACTED@<DB_SERVER_NAME>.postgres.database.azure.com/<DB_NAME>?sslmode=require",
  "databaseName": "<DB_NAME>",
  "host": "<DB_SERVER_NAME>.postgres.database.azure.com",
  "id": "/subscriptions/REDACTED/resourceGroups/<RESOURCE_GROUP_NAME>/providers/Microsoft.DBforPostgreSQL/flexibleServers/<DB_SERVER_NAME>",
  "location": "East US",
  "password": "REDACTED",
  "resourceGroup": "<RESOURCE_GROUP_NAME>",
  "skuname": "Standard_B1ms",
  "username": "REDACTED",
  "version": "13"
}

Aggiungere 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 ad signed-in-user show --query userPrincipalName -o 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 -o tsv)

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

Creare un'istanza di Registro Container Microsoft Azure

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

Usare il comando az acr create per creare un'istanza del Registro dei Container. L'esempio seguente crea n'istanza del Registro Container 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>",

Per recuperare il server di accesso dell'istanza del registro contenitori, usa il comando seguente:

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

Connettere Docker all'istanza di Registro Azure Container

Accedere all'istanza del registro dei 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.

Crea un ambiente

Un ambiente di App contenitore di Azure crea un limite sicuro intorno a un gruppo di app contenitore. Le app contenitore nello stesso ambiente vengono distribuite nella stessa rete virtuale e scrivono log nella stessa area di lavoro Log Analytics.

Se è la prima volta che crei un ambiente Azure Container Apps, è probabile che sia necessario registrare i namespace Microsoft.App e Microsoft.OperationalInsights. Usare i comandi seguenti per registrare i namespace:

az provider register --namespace Microsoft.App --wait
az provider register --namespace Microsoft.OperationalInsights --wait

Usare ora il comando az containerapp env create per creare un ambiente, come illustrato nell'esempio seguente:

az containerapp env create \
    --resource-group $RESOURCE_GROUP_NAME \
    --location $LOCATION \
    --name $ACA_ENV

Se viene chiesto di installare un'estensione, rispondere Y.

Personalizzare la configurazione nativa del cloud

Come tecnologia nativa del cloud, Quarkus offre la possibilità di generare automaticamente immagini del contenitore. Per altre informazioni, vedere Immagini del contenitore. Gli sviluppatori possono quindi distribuire l'immagine dell'applicazione in una piattaforma in contenitori di destinazione, ad esempio App contenitore di Azure.

Per generare l'immagine del contenitore, usare il comando seguente per aggiungere l'estensione container-image-jib nel terminale locale:

quarkus ext add container-image-jib

Quarkus modifica il pom per assicurarsi che l'estensione sia inclusa tra .<dependencies> Se viene chiesto di installare qualcosa denominato JBang, rispondere sì e consentire l'installazione.

L'output dovrebbe essere simile all'esempio seguente:

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

Aprire il file pom.xml e verranno visualizzate le dipendenze seguenti aggiunte dall'estensione container-image-jib :

<dependency>
  <groupId>io.quarkus</groupId>
  <artifactId>quarkus-container-image-jib</artifactId>
</dependency>

Aggiungere quindi le dipendenze seguenti al file pom.xml per supportare l'autenticazione senza password con Database di Azure per PostgreSQL server flessibile:

<dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-identity-extensions</artifactId>
    <version>1.1.20</version>
</dependency>

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

  • dev - Attivato in modalità di sviluppo.
  • test - Attivato durante l'esecuzione dei 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 decommentate rimuovendo il carattere 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.

Esaminare la configurazione del database

Dopo aver rimosso le linee di commento dalle proprietà, la configurazione del database nel file src/main/resources/application.properties dovrebbe apparire come nel seguente esempio:

# Database configurations
%prod.quarkus.datasource.db-kind=postgresql
%prod.quarkus.datasource.jdbc.url=
%prod.quarkus.datasource.username=
%prod.quarkus.datasource.password=
%prod.quarkus.hibernate-orm.database.generation=create
%prod.quarkus.hibernate-orm.sql-load-script=no-file

Rimuovere la proprietà %prod.quarkus.datasource.password perché non è necessaria quando si usa l'autenticazione senza password con il server flessibile di Database di Azure per PostgreSQL. Aggiornare le altre proprietà %prod.quarkus.datasource.jdbc.url correlate alla connessione al database e %prod.quarkus.datasource.username con i valori, come illustrato nell'esempio seguente. La configurazione finale dovrebbe essere simile all'esempio seguente:

# Database configurations
%prod.quarkus.datasource.db-kind=postgresql
%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.hibernate-orm.database.generation=create
%prod.quarkus.hibernate-orm.sql-load-script=no-file

Il valore di ${AZURE_POSTGRESQL_HOST}, ${AZURE_POSTGRESQL_PORT}, ${AZURE_POSTGRESQL_DATABASE}e ${AZURE_POSTGRESQL_USERNAME} viene fornito dall'ambiente app Azure Container in fase di esecuzione usando l'estensione senza password di Service Connector più avanti in questo articolo.

In genere, non ci si aspetta che i dati salvati in modo permanente nel database vengano eliminati e ripopolati con i dati di esempio in un ambiente di produzione. Ecco perché è possibile notare che lo schema per quarkus.hibernate-orm.database.generation viene specificato in create modo che l'app crei solo lo schema quando non esiste all'avvio iniziale. Inoltre, il database non viene popolato in anticipo con dati di esempio perché hibernate-orm.sql-load-script viene specificato come no-file. Questa impostazione è diversa da quando l'app è stata eseguita in locale in modalità di sviluppo in precedenza. I valori predefiniti in modalità di sviluppo per e sono e, rispettivamente, il che significa che l'app elimina e ricrea sempre lo schema del database e carica i dati definiti in quarkus.hibernate-orm.database.generation.hibernate-orm.sql-load-scriptdrop-and-createimport.sql Il file import.sql è una funzionalità utile di Quarkus. Se il file src/main/resources/import.sql esiste nel file JAR Quarkus e il valore della hibernate-orm.sql-load-script proprietà è import.sql, le istruzioni DML SQL in questo file vengono eseguite in fase di avvio per l'app.

Testare localmente l'app Quarkus con il server flessibile di Azure Database per PostgreSQL

Prima di distribuire l'app Quarkus su Azure Container Apps, testare localmente la connessione all'istanza del server flessibile del database di Azure per PostgreSQL.

Prima di tutto, aggiungi l'indirizzo IP locale alle regole del firewall dell'istanza del server flessibile del Database di Azure per PostgreSQL utilizzando il comando seguente:

export AZ_LOCAL_IP_ADDRESS=$(curl -s https://whatismyip.akamai.com)

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 di server flessibile di Microsoft Azure Database per PostgreSQL dall'app Quarkus eseguita 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}

Esegui l'app Quarkus in locale per testare la connessione al server flessibile di Database di Azure per l'istanza di PostgreSQL. Usare i comandi seguenti per avviare l'app in modalità di produzione:

mvn clean package -DskipTests
java -jar target/quarkus-app/quarkus-run.jar

Per accedere all'applicazione Todo, aprire un nuovo browser web su http://localhost:8080. Dovrebbe essere visualizzata la stessa app Todo visualizzata quando è stata eseguita l'app in locale in modalità di sviluppo, senza elementi Todo.

Per arrestare l'app, premere Control+C.

Creare l'immagine del contenitore e caricarla nel registro contenitori

A questo punto, usa il comando seguente per compilare l'applicazione stessa. Questo comando usa l'estensione Jib per compilare l'immagine del contenitore.

export TODO_QUARKUS_IMAGE_NAME=todo-quarkus-aca
export TODO_QUARKUS_IMAGE_TAG=${LOGIN_SERVER}/${TODO_QUARKUS_IMAGE_NAME}:1.0
quarkus build -Dquarkus.container-image.build=true -Dquarkus.container-image.image=${TODO_QUARKUS_IMAGE_TAG} --no-tests

L'output deve terminare con BUILD SUCCESS.

È possibile verificare se l'immagine del contenitore viene generata anche usando la riga di comando docker, come illustrato nell'esempio seguente:

docker images | grep ${TODO_QUARKUS_IMAGE_NAME}

L'output è simile al seguente esempio:

<LOGIN_SERVER_VALUE>/todo-quarkus-aca   1.0       0804dfd834fd   2 minutes ago   407MB

Caricare le immagini del container nel registro dei container usando il comando seguente:

docker push ${TODO_QUARKUS_IMAGE_TAG}

L'output deve essere simile all'esempio seguente:

The push refers to repository [<LOGIN_SERVER_VALUE>/todo-quarkus-aca]
188a550fce3d: Pushed
4e3afea591e2: Pushed
1db0eba807a6: Pushed
c72d9ccda0b2: Pushed
d7819b8a2d18: Pushed
d0e5cba6b262: Pushed
e0bac91f0f10: Pushed
1.0: digest: sha256:f9ccb476e2388efa0dfdf817625a94f2247674148a69b7e4846793e63c8be994 size: 1789

Distribuire l'app Quarkus in App Azure Container

Dopo aver caricato l'immagine dell'app nel registro dei contenitori, utilizzare il comando seguente per creare un'istanza di App Container di Azure per eseguire l'app dopo aver scaricato l'immagine dal registro dei contenitori:

az containerapp create \
    --resource-group $RESOURCE_GROUP_NAME \
    --name $ACA_NAME \
    --image $TODO_QUARKUS_IMAGE_TAG \
    --environment $ACA_ENV \
    --registry-server $LOGIN_SERVER \
    --registry-identity system \
    --target-port 8080 \
    --ingress 'external' \
    --min-replicas 1

L'output riuscito è un oggetto JSON che include la proprietà "type": "Microsoft.App/containerApps".

Connettere quindi l'istanza del server flessibile Database di Azure per PostgreSQL all'app contenitore usando Service Connector attenendosi alla procedura seguente:

  1. Installare l'estensione senza password di Service Connector per l'interfaccia della riga di comando di Azure usando il comando seguente:

    az extension add --name serviceconnector-passwordless --upgrade --allow-preview true

  2. Connettere il database all'app contenitore con un'identità gestita assegnata dal sistema usando il comando seguente:

    az containerapp connection create postgres-flexible \
    --resource-group $RESOURCE_GROUP_NAME \
    --name $ACA_NAME \
    --target-resource-group $RESOURCE_GROUP_NAME \
    --server $DB_SERVER_NAME \
    --database $DB_NAME \
    --system-identity \
    --container $ACA_NAME

    L'output riuscito è un oggetto JSON che include la proprietà "type": "microsoft.servicelinker/linkers".

Ottenere un URL completo per accedere all'applicazione Todo usando il comando seguente:

export QUARKUS_URL=https://$(az containerapp show \
    --resource-group $RESOURCE_GROUP_NAME \
    --name $ACA_NAME \
    --query properties.configuration.ingress.fqdn -o tsv)
echo $QUARKUS_URL

Apri un nuovo Web browser sul valore di ${QUARKUS_URL}. Se il rendering della pagina Web non viene eseguito correttamente, attendere un po' di tempo e aggiornare la pagina.

Aggiungi quindi un nuovo elemento To Do con il testo Deployed the Todo app to Container Apps. Selezionare questo elemento per contrassegnarlo come completato.

Screenshot dell'app di esempio Todo in esecuzione in App contenitore.

Accedere all'API RESTful (/api) per ottenere tutti gli elementi todo archiviati nella Database di Azure per PostgreSQL, come illustrato nell'esempio seguente:

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

L'output dovrebbe essere simile all'esempio seguente:

* Connected to <aca-name>.<random-id>.eastus.azurecontainerapps.io (20.231.235.79) port 443 (#0)
> GET /api HTTP/2
> Host: <aca-name>.<random-id>.eastus.azurecontainerapps.io
> user-agent: curl/7.88.1
> accept: */*
>
< HTTP/2 200
< content-length: 88
< content-type: application/json;charset=UTF-8
<
[
  {
    "id": 1,
    "title": "Deployed the Todo app to Container Apps",
    "completed": true,
    "order": 1,
    "url": null
  }
]

Verificare che il database sia aggiornato

Usare il comando seguente per verificare che il database sia stato aggiornato con il nuovo elemento todo:

export 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 lo stesso elemento nell'interfaccia utente grafica dell'app Todo illustrata 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": true,
    "id": 1,
    "ordering": 1,
    "title": "Deployed the Todo app to Container Apps",
    "url": null
  }
]

Quando hai finito, elimina la regola del firewall che consente all'indirizzo IP locale di accedere all'istanza del server flessibile di Database di Azure per PostgreSQL utilizzando il seguente 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

Pulire le risorse

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

git reset --hard
docker rmi ${TODO_QUARKUS_IMAGE_TAG}
az group delete --name $RESOURCE_GROUP_NAME --yes --no-wait

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

Passaggi successivi