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.
- Installieren Sie die Azure-Befehlszeilenschnittstelle zum Ausführen von Azure CLI-Befehlen.
- Melden Sie sich mit dem Befehl az login bei der Azure CLI an. Führen Sie die in Ihrem Terminal angezeigten Schritte aus, um den Authentifizierungsprozess abzuschließen. Weitere Anmeldemöglichkeiten finden Sie unter Anmeldung bei Azure mit Azure CLI.
- Installieren Sie die Azure CLI-Erweiterung beim ersten Einsatz, wenn Sie dazu aufgefordert werden. Weitere Informationen zu Erweiterungen finden Sie unter Verwenden und Verwalten von Erweiterungen mit der Azure CLI.
- Führen Sie az version aus, um die installierte Version und die abhängigen Bibliotheken zu ermitteln. Führen Sie az upgrade aus, um das Upgrade auf die aktuelle Version durchzuführen. 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-10-14
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 ihren eigenen Werten, LOCATION und führen Sie die Befehle in Ihrem Terminal aus.
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
Erstellen Sie nun mithilfe des folgenden Befehls eine Ressourcengruppe:
az group create \
--name $RESOURCE_GROUP_NAME \
--location $LOCATION
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 mithilfe des folgenden Befehls eine Azure-Datenbank für flexible Serverinstanzen für PostgreSQL:
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
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://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"
}
Fügen Sie den aktuellen angemeldeten Benutzer als Microsoft Entra-Administrator zur Azure-Datenbank für PostgreSQL Flexible Server-Instanz hinzu, indem Sie die folgenden Befehle verwenden:
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)
Die erfolgreiche Ausgabe ist ein JSON-Objekt, einschließlich der Eigenschaft "type": "Microsoft.DBforPostgreSQL/flexibleServers/administrators".
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
Nach kurzer Zeit sollte eine JSON-Ausgabe mit folgenden Zeilen angezeigt werden:
"provisioningState": "Succeeded",
"publicNetworkAccess": "Enabled",
"resourceGroup": "<YOUR_RESOURCE_GROUP>",
Rufen Sie den Anmeldeserver für die Containerregistrierungsinstanz mithilfe des folgenden Befehls ab:
export LOGIN_SERVER=$(az acr show \
--name $REGISTRY_NAME \
--query 'loginServer' \
--output tsv)
echo $LOGIN_SERVER
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. Verwenden Sie den folgenden Befehl, um sich bei der Registrierung anzumelden:
az acr login --name $REGISTRY_NAME
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
Öffnen Sie die datei pom.xml , und sie sollten die folgenden Abhängigkeiten sehen, die von der container-image-jib Erweiterung hinzugefügt wurden:
<dependency>
<groupId>io.quarkus</groupId>
<artifactId>quarkus-container-image-jib</artifactId>
</dependency>
Fügen Sie dann die folgenden Abhängigkeiten zur pom.xml Datei hinzu, um die kennwortlose Authentifizierung mit Azure Database für PostgreSQL Flexible Server zu unterstützen:
<dependency>
<groupId>com.azure</groupId>
<artifactId>azure-identity-extensions</artifactId>
<version>1.1.20</version>
</dependency>
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
Nach dem Aufheben der Auskommentierung der Eigenschaften sollte die Datenbankkonfiguration in der Datei "src/main/resources/application.properties " wie im folgenden Beispiel aussehen:
# 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
%prod.quarkus.datasource.password Eigenschaft entfernen, da sie bei Verwendung der kennwortlosen Authentifizierung mit Azure Database für PostgreSQL Flexible Server nicht erforderlich ist. Aktualisieren Sie die anderen Eigenschaften der Datenbankverbindung %prod.quarkus.datasource.jdbc.url und %prod.quarkus.datasource.username mit den Werten, wie im folgenden Beispiel gezeigt. Die endgültige Konfiguration sollte wie im folgenden Beispiel aussehen:
# 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
Der Wert von ${AZURE_POSTGRESQL_HOST}, ${AZURE_POSTGRESQL_PORT}, ${AZURE_POSTGRESQL_DATABASE}und ${AZURE_POSTGRESQL_USERNAME} werden von der Azure-Container-Apps-Umgebung zur Laufzeit mithilfe der Kennwortlosen Erweiterung Service Connector weiter unten in diesem Artikel bereitgestellt.
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.
Testen Sie IhreRelationus-App lokal mit Azure Database für PostgreSQL Flexible Server
Testen Sie vor der Bereitstellung der Blobus-App in Azure Container-Apps die Verbindung mit der Azure-Datenbank für Die Flexible Server-Instanz von PostgreSQL lokal.
Fügen Sie zunächst die lokale IP-Adresse zu den Firewallregeln der Azure-Datenbank für flexible Serverinstanzen mit den folgenden Befehlen hinzu:
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
Legen Sie als Nächstes die folgenden Umgebungsvariablen im vorherigen Terminal fest. Diese Umgebungsvariablen werden verwendet, um eine Verbindung mit der Azure-Datenbank für PostgreSQL Flexible Server-Instanz aus der Lokal ausgeführten Quarkus-App herzustellen:
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}
Führen Sie die Aspxus-App lokal aus, um die Verbindung mit der Azure-Datenbank für Flexible Server-Instanz von PostgreSQL zu testen. Verwenden Sie den folgenden Befehl, um die App im Produktionsmodus zu starten:
mvn clean package -DskipTests
java -jar target/quarkus-app/quarkus-run.jar
Öffnen Sie einen neuen Webbrowser, um http://localhost:8080 auf die Todo-Anwendung zuzugreifen. Sie sollten dieselbe Todo-App sehen, wie Sie gesehen haben, wenn Sie die App lokal im Entwicklungsmodus ausgeführt haben, ohne dass Todo-Elemente vorhanden sind.
Drücken Sie CTRL+C, um die App zu beenden.
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.
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
Die Ausgabe sollte mit BUILD SUCCESS enden.
Sie können überprüfen, ob das Containerimage auch mithilfe der docker Befehlszeile ( podman CLI) generiert wird, wie im folgenden Beispiel gezeigt:
docker images | grep ${TODO_QUARKUS_IMAGE_NAME}
Die Ausgabe sieht etwa folgendermaßen aus:
<LOGIN_SERVER_VALUE>/todo-quarkus-aca 1.0 0804dfd834fd 2 minutes ago 407MB
Pushen Sie die Containerimages mit dem folgenden Befehl an Container Registry:
docker push ${TODO_QUARKUS_IMAGE_TAG}
Die Ausgabe sollte in etwa wie im folgenden Beispiel aussehen:
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
Bereitstellen der Quarkus-App in Azure-Container-Apps
Nachdem Sie das App-Image nun an die Containerregistrierung übertragen haben, verwenden Sie den folgenden Befehl, um eine Container-Apps-Instanz zu erstellen, um die App auszuführen, nachdem Sie das Image aus der Containerregistrierung abgerufen haben:
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
Die erfolgreiche Ausgabe ist ein JSON-Objekt, einschließlich der Eigenschaft "type": "Microsoft.App/containerApps".
Verbinden Sie dann die Azure-Datenbank für PostgreSQL Flexible Server-Instanz mithilfe von Service Connector mit der Container-App, indem Sie die folgenden Schritte ausführen:
Installieren Sie die kennwortlose Service Connector-Erweiterung für die Azure CLI mithilfe des folgenden Befehls:
az extension add --name serviceconnector-passwordless --upgrade --allow-preview trueVerbinden Sie die Datenbank mit der Container-App mit einer vom System zugewiesenen verwalteten Identität mithilfe des folgenden Befehls:
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_NAMEDie erfolgreiche Ausgabe ist ein JSON-Objekt, einschließlich der Eigenschaft
"type": "microsoft.servicelinker/linkers".
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}. Wenn die Webseite nicht ordnungsgemäß gerendert wird, warten Sie eine Weile, und aktualisieren Sie die Seite.
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
}
]
Überprüfen, ob die Datenbank aktualisiert wurde
Führen Sie den folgenden Befehl aus, um zu überprüfen, ob die Datenbank mit dem neuen Todo-Element aktualisiert wurde:
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;"
Wenn Sie aufgefordert werden, eine Erweiterung zu installieren, antworten Sie mit Y.
Die Ausgabe sollte dem folgenden Beispiel ähneln und dasselbe Element in der zuvor gezeigten Todo-App-GUI enthalten:
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
}
]
Wenn Sie fertig sind, löschen Sie die Firewallregel, mit der Ihre lokale IP-Adresse auf die Azure-Datenbank für PostgreSQL Flexible Server-Instanz zugreifen kann, indem Sie den folgenden Befehl verwenden:
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
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_IMAGE_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.