Bereitstellen einer Java-Anwendung mit Quarkus in Azure Container Apps
In diesem Artikel erfahren Sie, wie Sie Red Hat Quarkus in Microsoft Azure Container Apps mit einer einfachen CRUD-Anwendung schnell bereitstellen können. Die Anwendung ist eine Aufgabenliste („Todo“) mit einem JavaScript-Front-End und einem REST-Endpunkt. Azure Database for PostgreSQL – Flexible Server stellt die Persistenzebene für die App bereit. In diesem Artikel erfahren Sie, wie Sie Ihre App lokal testen und in Container Apps bereitstellen.
Voraussetzungen
- Ein Azure-Abonnement. Wenn Sie kein Azure-Abonnement besitzen, erstellen Sie ein kostenloses Konto, bevor Sie beginnen.
- Bereiten Sie einen lokalen Computer mit einem installierten UNIX-ähnlichen Betriebssystem (z. B. Ubuntu, macOS, Windows-Subsystem für Linux) vor.
- Installieren Sie eine Java SE-Implementierung Version 17 oder später (z. B den Microsoft-Build von OpenJDK).
- Installieren Sie Maven, Version 3.9.8 oder höher
- Installieren Sie Docker oder Podman für Ihr Betriebssystem.
- Installieren Sie jq.
- Installieren Sie cURL.
- Installieren Sie Quarkus CLI, Version 3.12.1 oder höher.
- Azure CLI für Unix-ähnliche Umgebungen. In diesem Artikel wird nur die Bash-Variante der Azure CLI benötigt.
- Für diesen Artikel ist mindestens Version 2.61.0 der Azure CLI erforderlich.
Erstellen des App-Projekts
Verwenden Sie den folgenden Befehl, um das Java-Beispielprojekt für diesen Artikel zu klonen. Das Beispiel befindet sich auf GitHub.
git clone https://github.com/Azure-Samples/quarkus-azure
cd quarkus-azure
git checkout 2024-07-08
cd aca-quarkus
Wenn eine Meldung darüber angezeigt wird, dass Sie sich in einem Zustand HEAD getrennt befinden, kann diese Nachricht problemlos ignoriert werden. Da in diesem Artikel keine Commits erforderlich sind, eignet sich der Status „detached HEAD“ (losgelöster Head).
Lokales Testen Ihrer Quarkus-App
Anhand der Schritte in diesem Abschnitt erfahren Sie, wie Sie die App lokal ausführen.
Quarkus unterstützt die automatische Bereitstellung nicht konfigurierter Dienste im Entwicklungs- und Testmodus. Diese Funktion von Quarkus wird als „Dev Services“ bezeichnet. Angenommen, Sie beziehen eine Quarkus-Funktion ein (z. B. das Herstellen einer Verbindung mit einem Datenbankdienst). Sie möchten die App testen, haben aber die Verbindung zu einer echten Datenbank noch nicht vollständig konfiguriert. Quarkus startet automatisch eine Stubversion des relevanten Diensts und verbindet Ihre Anwendung mit diesem. Weitere Informationen finden Sie unter Übersicht über Dev Services in der Quarkus-Dokumentation.
Stellen Sie sicher, dass Ihre Containerumgebung (Docker oder Podman) ausgeführt wird, und verwenden Sie den folgenden Befehl, um in den Quarkus-Entwicklungsmodus zu wechseln:
quarkus dev
Anstelle von quarkus dev können Sie dasselbe Ergebnis mit Maven und der Verwendung von mvn quarkus:dev erzielen.
Sie werden möglicherweise gefragt, ob Sie Telemetriedaten zu Ihrer Nutzung des Quarkus-Entwicklermodus senden möchten. Beantworten Sie diese Frage nach Ihrem Belieben.
Mit dem Quarkus-Entwicklungsmodus wird Live Reload mit Hintergrundkompilierung aktiviert. Wenn Sie einen Aspekt Ihres App-Quellcodes ändern und Ihren Browser aktualisieren, können Sie die Änderungen erkennen. Wenn Probleme bei der Kompilierung oder Bereitstellung auftreten, werden Sie auf einer Fehlerseite darüber informiert. Der Quarkus-Entwicklungsmodus lauscht an Port 5005 auf einen Debugger. Wenn Sie vor dem Ausführen auf das Anfügen des Debuggers warten möchten, übergeben Sie -Dsuspend an der Befehlszeile. Wenn Sie den Debugger gar nicht wollen, können Sie -Ddebug=false verwenden.
Die Ausgabe sollte wie im folgenden Beispiel aussehen:
__ ____ __ _____ ___ __ ____ ______
--/ __ \/ / / / _ | / _ \/ //_/ / / / __/
-/ /_/ / /_/ / __ |/ , _/ ,< / /_/ /\ \
--\___\_\____/_/ |_/_/|_/_/|_|\____/___/
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>
Drücken Sie w auf dem Terminal, auf dem der Quarkus-Entwicklungsmodus ausgeführt wird. Mit der w-Taste wird Ihr Standardwebbrowser geöffnet, um die Anwendung Todo anzuzeigen. Sie können über http://localhost:8080 auch direkt auf die grafische Benutzeroberfläche (GUI) der Anwendung zugreifen.
Versuchen Sie, einige Aufgabenelemente in der Aufgabenliste auszuwählen. Auf der Benutzeroberfläche wird die Auswahl im Textformat „durchgestrichen“ angezeigt. Sie können der Aufgabenliste auch ein neues Aufgabenelement hinzufügen, indem Sie Verify Todo apps (Todo-Apps überprüfen) eingeben und die EINGABETASTE drücken, wie im folgenden Screenshot gezeigt:
Greifen Sie auf die RESTful-API (/api) zu, um alle Aufgabenelemente abzurufen, die in der lokalen PostgreSQL-Datenbank gespeichert sind:
curl --verbose http://localhost:8080/api | jq .
Die Ausgabe sollte wie im folgenden Beispiel aussehen:
* 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
}
]
Drücken Sie q, um den Quarkus-Entwicklungsmodus zu beenden.
Erstellen der Azure-Ressourcen zum Ausführen der Quarkus-App
Anhand der Schritte in diesem Abschnitt erfahren Sie, wie Sie die folgenden Azure-Ressourcen zum Ausführen der Quarkus-Beispiel-App erstellen:
- Azure Database for PostgreSQL – Flexibler Server
- Azure Container Registry
- Azure Container Apps
Einige dieser Ressourcen müssen im Geltungsbereich des Azure-Abonnements eindeutige Namen aufweisen. Um diese Eindeutigkeit sicherzustellen, können Sie das Muster Initialen, Sequenz, Datum, Suffix verwenden. Um dieses Muster anzuwenden, benennen Sie Ihre Ressourcen in folgender Reihenfolge: Ihre Initialen, eine Sequenznummer, heutiges Datum und eine Art ressourcenspezifisches Suffix (z. B. rg für „Ressourcengruppe“). Die folgenden Umgebungsvariablen verwenden dieses Muster. Ersetzen Sie die Platzhalterwerte in UNIQUE_VALUE LOCATION und DB_PASSWORD durch Ihre eigenen Werte, und führen Sie die Befehle in Ihrem Terminal aus.
export UNIQUE_VALUE=<your unique value, such as ejb091223>
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 DB_NAME=demodb
export DB_ADMIN=demouser
export DB_PASSWORD='<your desired password for the database server - for example, Secret123456>'
export ACA_ENV=${UNIQUE_VALUE}env
export ACA_NAME=${UNIQUE_VALUE}aca
Erstellen eines flexiblen Azure Database for PostgreSQL-Servers
Azure Database for PostgreSQL Flexible Server ist ein vollständig verwalteter Datenbankdienst, der eine differenziertere Steuerung und mehr Flexibilität bei den Verwaltungsfunktionen und Konfigurationseinstellungen der Datenbank bietet. In diesem Abschnitt wird das Erstellen einer flexiblen Azure-Datenbank für PostgreSQL-Serverinstanz mithilfe der Azure CLI gezeigt. Weitere Informationen finden Sie unter Schnellstartanleitung: Erstellen einer Azure Database for PostgreSQL – Flexible Server-Instanz mit der Azure CLI.
Erstellen Sie zunächst eine Ressourcengruppe, die den Datenbankserver und andere Ressourcen enthält, indem Sie den folgenden Befehl verwenden:
az group create \
--name $RESOURCE_GROUP_NAME \
--location $LOCATION
Erstellen Sie dann eine flexible Azure Database for PostgreSQL-Serverinstanz anhand des folgenden Befehls:
az postgres flexible-server create \
--name $DB_SERVER_NAME \
--resource-group $RESOURCE_GROUP_NAME \
--admin-user $DB_ADMIN \
--admin-password $DB_PASSWORD \
--database-name $DB_NAME \
--public-access 0.0.0.0 \
--yes
Es dauert ein paar Minuten, den Server, die Datenbank, den Administratorbenutzer und die Firewallregeln zu erstellen. Wenn der Befehl erfolgreich ist, sieht die Ausgabe in etwa wie im folgenden Beispiel aus:
{
"connectionString": "postgresql://<DB_ADMIN>:<DB_PASSWORD>@<DB_SERVER_NAME>.postgres.database.azure.com/<DB_NAME>?sslmode=require",
"databaseName": "<DB_NAME>",
"firewallName": "AllowAllAzureServicesAndResourcesWithinAzureIps_2024-7-5_14-39-45",
"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": "<DB_PASSWORD>",
"resourceGroup": "<RESOURCE_GROUP_NAME>",
"skuname": "Standard_D2s_v3",
"username": "<DB_ADMIN>",
"version": "13"
}
Erstellen einer Microsoft Azure Container Registry-Instanz
Da Quarkus eine Cloud-native Technologie ist, verfügt es über integrierte Unterstützung zum Erstellen von Containern, die in Container Apps ausgeführt werden. Container Apps ist vollständig auf ein Container-Register angewiesen, aus dem die auszuführenden Container-Images gefunden werden. Container Apps verfügt über integrierte Unterstützung für Azure Container Registry.
Erstellen Sie mit dem Befehl az acr create die Container Registry-Instanz. Im folgenden Beispiel wird eine Container Registry-Instanz erstellt, die mit dem Wert Ihrer Umgebungsvariablen ${REGISTRY_NAME} benannt ist:
az acr create \
--resource-group $RESOURCE_GROUP_NAME \
--location ${LOCATION} \
--name $REGISTRY_NAME \
--sku Basic \
--admin-enabled
Nach kurzer Zeit sollte eine JSON-Ausgabe mit folgenden Zeilen angezeigt werden:
"provisioningState": "Succeeded",
"publicNetworkAccess": "Enabled",
"resourceGroup": "<YOUR_RESOURCE_GROUP>",
Verbinden von Docker mit der Container Registry-Instanz
Melden Sie sich bei der Container Registry-Instanz an. Mit der Anmeldung können Sie ein Image per Push übertragen. Führen Sie die folgenden Befehle zum Überprüfen der Verbindung aus:
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
Wenn Sie Podman anstelle von Docker verwenden, ändern Sie den Befehl entsprechend.
Wenn Sie sich erfolgreich bei der Container Registry-Instanz angemeldet haben, sollte Ihnen Login Succeeded am Ende der Befehlsausgabe angezeigt werden.
Erstellen einer Umgebung
Eine Umgebung in Azure Container Apps erstellt eine sichere Grenze für eine Gruppe von Container-Apps. Container-Apps, die in derselben Umgebung bereitgestellt werden, werden im gleichen virtuellen Netzwerk bereitgestellt und schreiben Protokolle in denselben Log Analytics-Arbeitsbereich. Verwenden Sie den Befehl az containerapp env create, um eine Umgebung, wie im folgenden Beispiel dargestellt, zu erstellen:
az containerapp env create \
--resource-group $RESOURCE_GROUP_NAME \
--location $LOCATION \
--name $ACA_ENV
Wenn Sie aufgefordert werden, eine Erweiterung zu installieren, antworten Sie mit Y.
Anpassen der cloudnativen Konfiguration
Als Cloud-native Technologie bietet Quarkus die Möglichkeit, automatisch Container-Images zu generieren. Weitere Informationen finden Sie unter Containerimages. Entwickler können dann das Anwendungsimage auf einer zielcontainerisierten Plattform bereitstellen, z. B. Azure Container Apps.
Verwenden Sie zum Generieren des Containerimages den folgenden Befehl, um die container-image-jib-Erweiterung in Ihrem lokalen Terminal hinzuzufügen:
quarkus ext add container-image-jib
Quarkus ändert den POM, um sicherzustellen, dass die Erweiterung in den <dependencies> einbezogen wird. Wenn Sie aufgefordert werden, etwas namens JBang zu installieren, antworten Sie mit Ja und lassen Sie die Installation zu.
Die Ausgabe sollte wie im folgenden Beispiel aussehen:
[SUCCESS] ✅ Extension io.quarkus:quarkus-container-image-jib has been installed
Um die hinzugefügten Erweiterungen zu überprüfen, können Sie git diff ausführen und die Ausgabe untersuchen.
Als cloudnative Technologie unterstützt Quarkus das Konzept von Konfigurationsprofilen. Quarkus verfügt über die folgenden drei integrierten Profile:
dev– Wird im Entwicklungsmodus aktiviert.test– Wird beim Ausführen von Tests aktiviert.prod– Das Standardprofil (weder im Entwicklungs- noch im Testmodus).
Quarkus unterstützt bei Bedarf eine beliebige Anzahl benannter Profile.
Die letzten Schritte in diesem Abschnitt sind dem Auskommentieren und Anpassen der Werte in der Datei src/main/resources/application.properties gewidmet. Stellen Sie sicher, dass alle Zeilen, die mit # %prod. beginnen, auskommentiert werden, indem Sie das führende # entfernen.
Das Präfix %prod. gibt an, dass diese Eigenschaften aktiv sind, wenn sie im Profil prod ausgeführt werden. Weitere Informationen zu Konfigurationsprofilen finden Sie in der Quarkus-Dokumentation.
Prüfen der Datenbankkonfiguration
Fügen Sie die folgenden Datenbank-Konfigurationsvariablen hinzu. Die Eigenschaften der Datenbankverbindung %prod.quarkus.datasource.jdbc.url, %prod.quarkus.datasource.username und %prod.quarkus.datasource.password werden absichtlich leer gelassen, da sie aus Sicherheitsgründen zur Laufzeit von der Azure Container Apps-Umgebung bereitgestellt werden.
# Database configurations
%prod.quarkus.datasource.db-kind=postgresql
%prod.quarkus.datasource.jdbc.driver=org.postgresql.Driver
%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
Im Allgemeinen erwarten Sie nicht, dass die in der Datenbank gespeicherten Daten gelöscht und mit den Beispieldaten in einer Produktionsumgebung neu aufgefüllt werden. Aus diesem Grund können Sie sehen, dass das Schema für quarkus.hibernate-orm.database.generation als create angegeben ist, sodass die App nur das Schema erstellt, wenn es beim ersten Start nicht vorhanden ist. Außerdem wird die Datenbank nicht vorab mit Beispieldaten aufgefüllt, da hibernate-orm.sql-load-script als no-file angegeben ist. Diese Einstellung unterscheidet sich von der Einstellung, die Sie beim vorherigen lokalen Ausführen der App im Entwicklungsmodus hatten. Die Standardwerte im Entwicklungsmodus für quarkus.hibernate-orm.database.generation und hibernate-orm.sql-load-script sind drop-and-create und import.sql. Dies bedeutet, dass die App das Datenbankschema immer abbricht und die Daten lädt, die in import.sql definiert sind. Die import.sql-Datei ist eine bequeme Einrichtung von Quarkus. Wenn die src/main/resources/import.sql-Datei im Quarkus-JAR-Paket vorhanden ist und der Wert der hibernate-orm.sql-load-script-Eigenschaft import.sql ist, werden die SQL-DML-Anweisungen in dieser Datei zum Startzeitpunkt für die App ausgeführt.
Anpassen der Containerimagekonfiguration
Als cloudnative Technologie unterstützt Quarkus das Generieren von OCI-Containerimages, die mit Docker und Podman kompatibel sind. Fügen Sie die folgenden Containerimagevariablen hinzu. Ersetzen Sie die Werte von <LOGIN_SERVER_VALUE> und <USER_NAME_VALUE> durch die tatsächlichen Werte der Umgebungsvariablen ${LOGIN_SERVER} bzw. ${USER_NAME}.
# 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-aca
%prod.quarkus.container-image.tag=1.0
Erstellen des Containerimages und Pushen an die Container Registry
Führen Sie jetzt den folgenden Befehl aus, um die eigentliche Anwendung zu erstellen. Dieser Befehl verwendet die Jib-Erweiterung, um das Containerimage zu erstellen.
quarkus build --no-tests
Die Ausgabe sollte mit BUILD SUCCESS enden.
Sie können überprüfen, ob das Containerimage ebenfalls generiert wird, indem Sie die docker- oder die podman-Befehlszeile (CLI) verwenden. Die Ausgabe sieht etwa folgendermaßen aus:
docker images | grep todo-quarkus-aca
<LOGIN_SERVER_VALUE>/<USER_NAME_VALUE>/todo-quarkus-aca 1.0 0804dfd834fd 2 minutes ago 407MB
Pushen Sie die Containerimages mit dem folgenden Befehl an Container Registry:
export TODO_QUARKUS_TAG=$(docker images | grep todo-quarkus-aca | head -n1 | cut -d " " -f1):1.0
echo ${TODO_QUARKUS_TAG}
docker push ${TODO_QUARKUS_TAG}
Die Ausgabe sollte in etwa wie im folgenden Beispiel aussehen:
The push refers to repository [<LOGIN_SERVER_VALUE>/<USER_NAME_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
Nachdem Sie das App-Image nun an die Containerregistrierung gepusht haben, verwenden Sie den folgenden Befehl, um eine Container Apps-Instanz zu erstellen und so die App auszuführen, nachdem Sie das Image aus der Container Registry abgerufen haben:
export DATASOURCE_JDBC_URL=jdbc:postgresql://${DB_SERVER_NAME}.postgres.database.azure.com:5432/${DB_NAME}?sslmode=require
az containerapp create \
--resource-group $RESOURCE_GROUP_NAME \
--name $ACA_NAME \
--image $TODO_QUARKUS_TAG \
--environment $ACA_ENV \
--registry-server $LOGIN_SERVER \
--registry-username $USER_NAME \
--registry-password $PASSWORD \
--target-port 8080 \
--secrets \
jdbcurl=${DATASOURCE_JDBC_URL} \
dbusername=${DB_ADMIN} \
dbpassword=${DB_PASSWORD} \
--env-vars \
QUARKUS_DATASOURCE_JDBC_URL=secretref:jdbcurl \
QUARKUS_DATASOURCE_USERNAME=secretref:dbusername \
QUARKUS_DATASOURCE_PASSWORD=secretref:dbpassword \
--ingress 'external'
Die --secrets-Option wird verwendet, um den geheimen Schlüssel zu erstellen, auf den in den Umgebungsvariablen QUARKUS_DATASOURCE_JDBC_URL, QUARKUS_DATASOURCE_USERNAME und QUARKUS_DATASOURCE_PASSWORD verwiesen wird. Die Werte dieser Umgebungsvariablen werden an die Eigenschaften %prod.quarkus.datasource.password, %prod.quarkus.datasource.username und %prod.quarkus.datasource.password übergeben. Quarkus kann Werte aus entsprechenden Umgebungsvariablen nachschlagen, wenn kein Wert in der application.properties-Datei vorhanden ist.
Die erfolgreiche Ausgabe ist ein JSON-Objekt, einschließlich der Eigenschaft "type": "Microsoft.App/containerApps".
Erhalten Sie eine vollständig qualifizierte URL, um auf die Todo-Anwendung anhand des folgenden Befehls zuzugreifen:
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
Öffnen Sie einen neuen Webbrowser mit dem Wert von ${QUARKUS_URL}. Fügen Sie dann ein neues Aufgabenelement mit dem Text Deployed the Todo app to Container Apps hinzu. Wählen Sie dieses Element aus, um es als abgeschlossen zu markieren.
Greifen Sie auf die RESTful-API (/api) zu, um alle ToDo-Elemente abzurufen, die in Azure Database for PostgreSQL gespeichert sind, wie im folgenden Beispiel dargestellt:
curl --verbose -k ${QUARKUS_URL}/api | jq .
Die Ausgabe sollte wie im folgenden Beispiel aussehen:
* 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
}
]
Stellen Sie sicher, dass die Datenbank mithilfe von Azure Cloud Shell aktualisiert wurde.
Öffnen Sie im Azure-Portal die Azure Cloud Shell durch Auswahl des Symbols Cloud Shell (
) neben dem Suchfeld.
Führen Sie den folgenden Befehl lokal aus, und fügen Sie das Ergebnis in Azure Cloud Shell ein:
echo psql --host=${DB_SERVER_NAME}.postgres.database.azure.com --port=5432 --username=${DB_ADMIN} --dbname=${DB_NAME}
Wenn Sie nach dem Kennwort gefragt werden, verwenden Sie den Wert, den Sie beim Erstellen der Datenbank verwendet haben.
Verwenden Sie die folgende Abfrage, um alle Aufgabenelemente abzurufen:
select * from todo;
Die Ausgabe sollte ähnlich wie im folgenden Beispiel aussehen und dieselben Elemente enthalten, die zuvor auf der Oberfläche der App „Todo“ angezeigt wurden:
Geben Sie \q ein, um das Programm psql zu beenden und zur Cloud Shell zurückzukehren.
Bereinigen von Ressourcen
Zum Vermeiden von Azure-Gebühren sollten Sie nicht benötigte Ressourcen bereinigen. Wenn der Cluster nicht mehr benötigt wird, entfernen Sie mit dem Befehl az group delete die Ressourcengruppe, den Containerdienst, die Containerregistrierung und alle zugehörigen Ressourcen.
git reset --hard
docker rmi ${TODO_QUARKUS_TAG}
az group delete --name $RESOURCE_GROUP_NAME --yes --no-wait
Sie können auch docker rmi verwenden, um die vom Quarkus-Entwicklungsmodus generierten Container-Images postgres und testcontainers zu löschen.