Condividi tramite

Distribuire un'applicazione Java con Quarkus in un'app contenitore di Azure

  • 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 Database di Azure 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

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-10-14
cd aca-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.

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 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 altre informazioni, vedere la Guida introduttiva: Creare un'istanza del server flessibile di Database di Azure per PostgreSQL usando l'interfaccia della riga di comando di Azure.

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 l'istanza del Registro 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>",

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 Container

Accedere all'istanza del Registro Container. 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 stai usando Podman invece di Docker, apporta le modifiche necessarie al comando.

Se l'accesso all'istanza del Registro Container è 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. Usare 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 un elemento 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 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.

Esaminare la configurazione del database

Dopo aver rimosso il commento delle proprietà, la configurazione del database nel file src/main/resources/application.properties dovrebbe essere simile all'esempio seguente:

# 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 Database di Azure per PostgreSQL server flessibile. 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 prepopolato 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 import.sql.import.sql drop-and-create hibernate-orm.sql-load-script quarkus.hibernate-orm.database.generation 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 l'app Quarkus in locale con Database di Azure per PostgreSQL server flessibile

Prima di distribuire l'app Quarkus in App Contenitore di Azure, testare la connessione all'istanza del server flessibile Database di Azure per PostgreSQL localmente.

Aggiungere prima di tutto l'indirizzo IP locale alle regole del firewall dell'istanza del server flessibile Database di Azure per PostgreSQL usando i comandi seguenti:

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 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 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:

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

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

Premere CTRL+C per arrestare l'app.

Compilare l'immagine del contenitore ed eseguirne il push nel Registro Container

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 docker riga di comando o , podman 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

Eseguire il push delle immagini del contenitore in Registro Contenitori 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 eseguito il push dell'immagine dell'app nel Registro Container, usare il comando seguente per creare un'istanza di App contenitore per eseguire l'app dopo aver eseguito il pull dell'immagine dal Registro Container:

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 stato aggiornato

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

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_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