Bereitstellen einer Java-Anwendung mit Quarkus in einem Azure Kubernetes Service-Cluster
In diesem Artikel erfahren Sie, wie Sie Red Hat Quarkus mit einer einfachen CRUD-Anwendung schnell in Azure Kubernetes Service (AKS) bereitstellen. Die Anwendung ist eine Aufgabenliste („Todo“) mit einem JavaScript-Front-End und einem REST-Endpunkt. Azure Database for PostgreSQL stellt die Persistenzebene für die App bereit. In diesem Artikel erfahren Sie, wie Sie Ihre App lokal testen und in AKS bereitstellen.
Voraussetzungen
- Sollten Sie über kein Azure-Abonnement verfügen, können Sie zunächst ein kostenloses Azure-Konto erstellen.
- In Azure Cloud Shell sind diese Voraussetzungen bereits vorinstalliert. Weitere Informationen finden Sie unter Schnellstart für Azure Cloud Shell.
- Wenn Sie die in diesem Leitfaden beschriebenen Befehle lokal ausführen (und nicht Azure Cloud Shell verwenden), führen Sie die folgenden Schritte aus:
- 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 (z. B Microsoft-Build von OpenJDK).
- Installieren Sie Maven 3.5.0 oder höher.
- Installieren Sie Docker oder Podman für Ihr Betriebssystem.
- Installieren Sie jq.
- Installieren Sie cURL.
- Installieren Sie die Quarkus-Befehlszeilenschnittstelle (CLI).
- 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.31.0 der Azure CLI erforderlich. Bei Verwendung von Azure Cloud Shell ist die aktuelle Version bereits installiert.
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 2023-07-17
cd aks-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.
Möglicherweise werden Sie gefragt, ob Sie Telemetriedaten von Ihrer Nutzung des Quarkus-Entwicklungsmodus 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-aks 1.0.0-SNAPSHOT on JVM (powered by Quarkus 3.2.0.Final) started in 3.377s. Listening on: http://localhost:8080
INFO [io.quarkus] (Quarkus Main Thread) Profile dev activated. Live Coding activated.
INFO [io.quarkus] (Quarkus Main Thread) Installed features: [agroal, cdi, hibernate-orm, hibernate-orm-panache, hibernate-validator, jdbc-postgresql, narayana-jta, resteasy-reactive, resteasy-reactive-jackson, smallrye-context-propagation, vertx]
--
Tests paused
Press [e] to edit command line args (currently ''), [r] to resume testing, [o] Toggle test output, [:] for the terminal, [h] for more options>
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
- Azure Container Registry (ACR)
- Azure Kubernetes Service (AKS)
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“). Verwenden Sie die folgenden Befehle, um einige Umgebungsvariablen zu definieren, die später verwendet werden:
export UNIQUE_VALUE=<your unique value, such as ejb010717>
export RESOURCE_GROUP_NAME=${UNIQUE_VALUE}rg
export LOCATION=<your desired Azure region for deploying your resources. For example, eastus>
export REGISTRY_NAME=${UNIQUE_VALUE}reg
export DB_SERVER_NAME=${UNIQUE_VALUE}db
export CLUSTER_NAME=${UNIQUE_VALUE}aks
export AKS_NS=${UNIQUE_VALUE}ns
Erstellen einer Azure-Datenbank für PostgreSQL
Azure Database for PostgreSQL ist ein verwalteter Dienst, mit dem Sie hochverfügbare PostgreSQL-Datenbanken in der Azure-Cloud ausführen, verwalten und skalieren können. In diesem Abschnitt werden Sie an einen separaten Schnellstart verwiesen, in dem Sie erfahren, wie Sie einen einzelnen Azure Database for PostgreSQL-Server erstellen und eine Verbindung zu diesem Server herstellen. Allerdings müssen Sie, wenn Sie die Schritte im Schnellstart ausführen, die Einstellungen in der folgenden Tabelle verwenden, um die Datenbankbereitstellung für die Quarkus-Beispiel-App anzupassen. Ersetzen Sie die Umgebungsvariablen durch Ihre tatsächlichen Werte, wenn Sie die Felder im Azure-Portal ausfüllen.
| Einstellung | Wert | BESCHREIBUNG |
|---|---|---|
| Resource group | ${RESOURCE_GROUP_NAME} |
Wählen Sie Neu erstellen. Mit der Bereitstellung wird diese neue Ressourcengruppe erstellt. |
| Servername | ${DB_SERVER_NAME} |
Dieser Wert ist Teil des Hostnamens für den Datenbankserver. |
| Standort | ${LOCATION} |
Wählen Sie in der Dropdownliste einen Standort aus. Beachten Sie den Standort. Sie müssen denselben Standort auch für andere Azure-Ressourcen verwenden, die Sie erstellen. |
| Administratorbenutzername | quarkus | Für den Beispielcode wird dieser Wert vorausgesetzt. |
| Kennwort | Secret123456 | Für den Beispielcode wird dieser Wert vorausgesetzt. |
Führen Sie unter Beachtung der genannten Werte die Schritte im Schnellstart: Erstellen eines Azure Database for PostgreSQL-Servers im Azure-Portal bis zum Abschnitt „Konfigurieren einer Firewallregel“ aus. Im Abschnitt „Konfigurieren einer Firewallregel“ müssen Sie dann für Zugriff auf Azure-Dienste zulassen die Option Ja und dann Speichern auswählen. Wenn Sie dies nicht tun, kann Ihre Quarkus-App nicht auf die Datenbank zugreifen und auch nicht gestartet werden.
Nachdem Sie die Schritte im Schnellstart bis zum Abschnitt „Konfigurieren einer Firewallregel“ (einschließlich des Schritts zum Zulassen des Zugriffs auf Azure-Dienste) abgeschlossen haben, kehren Sie zu diesem Artikel zurück.
Erstellen einer Todo-Datenbank in PostgreSQL
Der von Ihnen zuvor erstellte PostgreSQL-Server ist leer. Es gibt keine Datenbank, die Sie mit der Quarkus-Anwendung verwenden können. Erstellen Sie mit dem folgenden Befehl eine neue Datenbank namens todo:
az postgres db create \
--resource-group ${RESOURCE_GROUP_NAME} \
--name todo \
--server-name ${DB_SERVER_NAME}
Sie müssen todo als Namen der Datenbank verwenden, da der Beispielcode von diesem Datenbanknamen ausgeht.
Wenn der Befehl erfolgreich ist, sieht die Ausgabe in etwa wie im folgenden Beispiel aus:
{
"charset": "UTF8",
"collation": "English_United States.1252",
"id": "/subscriptions/REDACTED/resourceGroups/ejb010718rg/providers/Microsoft.DBforPostgreSQL/servers/ejb010718db/databases/todo",
"name": "todo",
"resourceGroup": "ejb010718rg",
"type": "Microsoft.DBforPostgreSQL/servers/databases"
}
Erstellen einer Microsoft Azure Container Registry-Instanz
Da Quarkus eine cloudnative Technologie ist, bietet es integrierte Unterstützung für das Erstellen von Containern, die in Kubernetes ausgeführt werden. Kubernetes hängt vollständig von einer Containerregistrierung ab, in der nach den auszuführenden Containerimages sucht. In AKS ist Unterstützung für Azure Container Registry (ACR) integriert.
Verwenden Sie den Befehl az acr create zum Erstellen der ACR-Instanz. Im folgenden Beispiel wird eine ACR-Instanz erstellt, die nach 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 ACR-Instanz
Melden Sie sich bei der ACR-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 ACR-Instanz angemeldet haben, sollte am Ende der Befehlsausgabe Login Succeeded angezeigt werden.
Erstellen eines AKS-Clusters
Erstellen Sie mithilfe des Befehls az aks create einen AKS-Cluster. Im folgenden Beispiel wird ein Cluster erstellt, der nach dem Wert Ihrer Umgebungsvariablen ${CLUSTER_NAME} mit einem Knoten benannt ist. Der Cluster ist mit der ACR-Instanz verbunden, die Sie weiter oben erstellt haben. Es dauert mehrere Minuten, bis dieser Befehl abgeschlossen ist.
az aks create \
--resource-group $RESOURCE_GROUP_NAME \
--location ${LOCATION} \
--name $CLUSTER_NAME \
--attach-acr $REGISTRY_NAME \
--node-count 1 \
--generate-ssh-keys \
--enable-managed-identity
Nach wenigen Minuten ist die Ausführung des Befehls abgeschlossen, und es werden Informationen zum Cluster im JSON-Format einschließlich der folgenden Ausgabe zurückgegeben:
"nodeResourceGroup": "MC_<your resource_group_name>_<your cluster name>_<your region>",
"privateFqdn": null,
"provisioningState": "Succeeded",
"resourceGroup": "<your resource group name>",
Herstellen einer Verbindung mit dem AKS-Cluster
Verwenden Sie zum Verwalten eines Kubernetes-Clusters den Kubernetes-Befehlszeilenclient kubectl. Bei Verwendung von Azure Cloud Shell ist kubectl bereits installiert. Verwenden Sie zum lokalen Installieren von kubectl den Befehl az aks install-cli, wie im folgenden Beispiel gezeigt:
az aks install-cli
Weitere Informationen zu kubectl finden Sie unter Befehlszeilentool (kubectl) in der Kubernetes-Dokumentation.
Mit dem Befehl az aks get-credentials können Sie kubectl für die Verbindung mit Ihrem Kubernetes-Cluster konfigurieren, wie aus dem folgenden Beispiel hervorgeht. Mit diesem Befehl werden die Anmeldeinformationen heruntergeladen und die Kubernetes-CLI für ihre Verwendung konfiguriert.
az aks get-credentials \
--resource-group $RESOURCE_GROUP_NAME \
--name $CLUSTER_NAME \
--overwrite-existing \
--admin
Bei erfolgreichem Abschluss enthält die Ausgabe einen Text, der mit dem im folgenden Beispiel vergleichbar ist:
Merged "ejb010718aks-admin" as current context in /Users/edburns/.kube/config
Manchmal kann es praktisch sein, für kubectl den Alias k zu verwenden. Verwenden Sie in diesem Fall den folgenden Befehl:
alias k=kubectl
Überprüfen Sie die Verbindung mit Ihrem Cluster mithilfe des Befehls kubectl get, um eine Liste der Clusterknoten zurückzugeben, wie im folgenden Beispiel gezeigt:
kubectl get nodes
Die folgende Beispielausgabe zeigt den in den vorherigen Schritten erstellten Knoten. Vergewissern Sie sich, dass der Knoten den Status Bereit hat:
NAME STATUS ROLES AGE VERSION
aks-nodepool1-xxxxxxxx-yyyyyyyyyy Ready agent 76s v1.23.8
Erstellen eines neuen Namespace in AKS
Verwenden Sie den folgenden Befehl, um einen neuen Namespace in Kubernetes Service für Ihre Quarkus-App zu erstellen:
kubectl create namespace ${AKS_NS}
Die Ausgabe sollte wie im folgenden Beispiel aussehen:
namespace/<your namespace> created
Anpassen der cloudnativen Konfiguration
Als cloudnative Technologie bietet Quarkus die Möglichkeit, Ressourcen für standardmäßiges Kubernetes, Red Hat OpenShift und Knative automatisch zu konfigurieren. Weitere Informationen finden Sie im Quarkus-Leitfaden für Kubernetes, im Quarkus-Leitfaden für OpenShift und im Quarkus-Leitfaden für Knative. Entwickler können die Anwendung in einem Kubernetes-Zielcluster bereitstellen, indem sie die generierten Manifeste anwenden.
Verwenden Sie den folgenden Befehl, um die entsprechenden Kubernetes-Ressourcen zu generieren und die Erweiterungen quarkus-kubernetes und container-image-jib in Ihrem lokalen Terminal hinzuzufügen:
quarkus ext add kubernetes container-image-jib
Quarkus ändert den POM, um sicherzustellen, dass diese Erweiterungen als <dependencies> aufgeführt werden. Wenn Sie aufgefordert werden, ein Tool namens JBang zu installieren, antworten Sie mit Ja, und erlauben Sie die Installation.
Die Ausgabe sollte wie im folgenden Beispiel aussehen:
[SUCCESS] ✅ Extension io.quarkus:quarkus-kubernetes has been installed
[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 aktivierttest: Wird beim Ausführen von Tests aktiviertprod: 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.
Datenbankkonfiguration
Fügen Sie die folgenden Datenbank-Konfigurationsvariablen hinzu. Ersetzen Sie die Werte von <DB_SERVER_NAME_VALUE> durch die tatsächlichen Werte der Umgebungsvariablen ${DB_SERVER_NAME}.
# Database configurations
%prod.quarkus.datasource.db-kind=postgresql
%prod.quarkus.datasource.jdbc.url=jdbc:postgresql://<DB_SERVER_NAME_VALUE>.postgres.database.azure.com:5432/todo
%prod.quarkus.datasource.jdbc.driver=org.postgresql.Driver
%prod.quarkus.datasource.username=quarkus@<DB_SERVER_NAME_VALUE>
%prod.quarkus.datasource.password=Secret123456
%prod.quarkus.hibernate-orm.database.generation=drop-and-create
Kubernetes-Konfiguration
Fügen Sie die folgenden Kubernetes-Konfigurationsvariablen hinzu. Stellen Sie sicher, dass Sie service-type auf load-balancer festlegen, um extern auf die App zuzugreifen.
# AKS configurations
%prod.quarkus.kubernetes.deployment-target=kubernetes
%prod.quarkus.kubernetes.service-type=load-balancer
Konfiguration von Containerimages
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-aks
%prod.quarkus.container-image.tag=1.0
Erstellen des Containerimages und Pushen an ACR
Führen Sie jetzt den folgenden Befehl aus, um die eigentliche Anwendung zu erstellen. Dieser Befehl verwendet die Kubernetes- und Jib-Erweiterungen, um das Containerimage zu erstellen.
quarkus build --no-tests
Die Ausgabe sollte mit BUILD SUCCESS enden. Die Kubernetes-Manifestdateien werden in target/kubernetes generiert, wie im folgenden Beispiel gezeigt:
tree target/kubernetes
target/kubernetes
├── kubernetes.json
└── kubernetes.yml
0 directories, 2 files
Sie können mithilfe der docker- oder podman-Befehlszeile (CLI) überprüfen, ob auch das Containerimage generiert wird. Die Ausgabe sollte in etwa wie im folgenden Beispiel aussehen:
docker images | grep todo
<LOGIN_SERVER_VALUE>/<USER_NAME_VALUE>/todo-quarkus-aks 1.0 b13c389896b7 18 minutes ago 420MB
Pushen Sie die Containerimages mithilfe des folgenden Befehls an ACR:
export TODO_QUARKUS_TAG=$(docker images | grep todo-quarkus-aks | head -n1 | cut -d " " -f1)
echo ${TODO_QUARKUS_TAG}
docker push ${TODO_QUARKUS_TAG}:1.0
Die Ausgabe sollte in etwa wie im folgenden Beispiel aussehen:
The push refers to repository [<LOGIN_SERVER_VALUE>/<USER_NAME_VALUE>/todo-quarkus-aks]
dfd615499b3a: Pushed
56f5cf1aa271: Pushed
4218d39b228e: Pushed
b0538737ed64: Pushed
d13845d85ee5: Pushed
60609ec85f86: Pushed
1.0: digest: sha256:0ffd70d6d5bb3a4621c030df0d22cf1aa13990ca1880664d08967bd5bab1f2b6 size: 1995
Nachdem Sie die App an ACR gepusht haben, können Sie AKS anweisen, die App auszuführen.
Bereitstellen der Quarkus-App in AKS
Anhand der Schritte in diesem Abschnitt erfahren Sie, wie Sie die Quarkus-Beispiel-App in den erstellten Azure-Ressourcen ausführen.
Bereitstellen der Quarkus-App in AKS mit „kubectl apply“
Stellen Sie die Kubernetes-Ressourcen über die Befehlszeile mit dem Befehl kubectl bereit, wie im folgenden Beispiel gezeigt:
kubectl apply -f target/kubernetes/kubernetes.yml -n ${AKS_NS}
Die Ausgabe sollte wie im folgenden Beispiel aussehen:
deployment.apps/quarkus-todo-demo-app-aks created
Überprüfen Sie mit dem folgenden Befehl, ob die App ausgeführt wird:
kubectl -n $AKS_NS get pods
Wenn der Wert des Felds STATUS etwas anderes als Running enthält, suchen Sie nach dem Fehler, und beheben Sie das Problem, bevor Sie fortfahren. Es kann hilfreich sein, mit dem folgenden Befehl die Podprotokolle zu untersuchen:
kubectl -n $AKS_NS logs $(kubectl -n $AKS_NS get pods | grep quarkus-todo-demo-app-aks | cut -d " " -f1)
Rufen Sie die EXTERNAL-IP ab, um mit dem folgenden Befehl auf die „Todo“-Anwendung zuzugreifen:
kubectl get svc -n ${AKS_NS}
Die Ausgabe sollte wie im folgenden Beispiel aussehen:
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
quarkus-todo-demo-app-aks LoadBalancer 10.0.236.101 20.12.126.200 80:30963/TCP 37s
Sie können den folgenden Befehl verwenden, um den Wert der EXTERNAL-IP in einer Umgebungsvariablen als vollqualifizierte URL zu speichern:
export QUARKUS_URL=http://$(kubectl get svc -n ${AKS_NS} | grep quarkus-todo-demo-app-aks | cut -d " " -f10)
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 AKS hinzu. Markieren Sie außerdem das Element Introduction to Quarkus Todo App als abgeschlossen.
Greifen Sie auf die RESTful-API (/api) zu, um alle Aufgabenelemente abzurufen, die in der Azure PostgreSQL-Datenbank gespeichert sind, wie im folgenden Beispiel gezeigt:
curl --verbose ${QUARKUS_URL}/api | jq .
Die Ausgabe sollte wie im folgenden Beispiel aussehen:
* Connected to 20.237.68.225 (20.237.68.225) port 80 (#0)
> GET /api HTTP/1.1
> Host: 20.237.68.225
> User-Agent: curl/7.88.1
> Accept: */*
>
< HTTP/1.1 200 OK
< content-length: 828
< Content-Type: application/json;charset=UTF-8
<
[
{
"id": 2,
"title": "Quarkus on Azure App Service",
"completed": false,
"order": 1,
"url": "https://learn.microsoft.com/en-us/azure/developer/java/eclipse-microprofile/deploy-microprofile-quarkus-java-app-with-maven-plugin"
},
{
"id": 3,
"title": "Quarkus on Azure Container Apps",
"completed": false,
"order": 2,
"url": "https://learn.microsoft.com/en-us/training/modules/deploy-java-quarkus-azure-container-app-postgres/"
},
{
"id": 4,
"title": "Quarkus on Azure Functions",
"completed": false,
"order": 3,
"url": "https://learn.microsoft.com/en-us/azure/azure-functions/functions-create-first-quarkus"
},
{
"id": 5,
"title": "Deployed the Todo app to AKS",
"completed": false,
"order": 5,
"url": null
},
{
"id": 1,
"title": "Introduction to Quarkus Todo App",
"completed": true,
"order": 0,
"url": null
}
]
Überprüfen der Aktualisierung der Datenbank mit Azure Cloud Shell
Öffnen Sie Azure Cloud Shell im Azure-Portal, indem Sie das Symbol Cloud Shell auswählen, wie im folgenden Screenshot gezeigt:
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=quarkus@${DB_SERVER_NAME} --dbname=todo
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:
Wenn in der Ausgabe MORE angezeigt wird, geben Sie q ein, um den Pager zu beenden.
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}:1.0
docker rmi postgres
az group delete --name $RESOURCE_GROUP_NAME --yes --no-wait
Mit docker rmi können Sie auch die Containerimages postgres und testcontainers löschen, die im Quarkus-Entwicklungsmodus generiert wurden.