Delen via

Een Java-toepassing implementeren met Quarkus in een Azure Kubernetes Service-cluster

  • Artikel

In dit artikel leest u hoe u Red Hat Quarkus snel implementeert in Azure Kubernetes Service (AKS) met een eenvoudige CRUD-toepassing. De toepassing is een takenlijst met een JavaScript-front-end en een REST-eindpunt. Azure Database for PostgreSQL Flexible Server biedt de persistentielaag voor de app. In het artikel wordt beschreven hoe u uw app lokaal test en implementeert in AKS.

Vereisten

  • Als u geen Azure-abonnement hebt, kunt u een gratis Azure-account maken voordat u begint.
  • Bereid een lokale computer voor waarop unix-achtig besturingssysteem is geïnstalleerd, bijvoorbeeld Ubuntu, macOS of Windows-subsysteem voor Linux.
  • Installeer een Java SE-implementatieversie 17 of hoger, bijvoorbeeld Microsoft-build van OpenJDK.
  • Installeer Maven, versie 3.9.8 of hoger.
  • Installeer Docker of Podman voor uw besturingssysteem.
  • Installeer jq.
  • Installeer cURL.
  • Installeer de Quarkus CLI, versie 3.12.1 of hoger.
  • Azure CLI voor Unix-achtige omgevingen. Voor dit artikel is alleen de Bash-variant van Azure CLI vereist.
    • Een ontwikkelaar moet Azure CLI installeren en zich interactief aanmelden met de az login-opdracht om u aan te melden bij Azure voordat de DefaultAzureCredential in code wordt gebruikt. 
      az login
    • Voor dit artikel is ten minste versie 2.61.0 van Azure CLI vereist.

Het app-project maken

Gebruik de volgende opdracht om het Java-voorbeeldproject voor dit artikel te klonen. Het voorbeeld bevindt zich op GitHub.

git clone https://github.com/Azure-Samples/quarkus-azure
cd quarkus-azure
git checkout 2024-07-08
cd aks-quarkus

Als u een bericht ziet over een losgekoppelde HEAD-status , is dit bericht veilig te negeren. Omdat voor dit artikel geen doorvoeringen nodig zijn, is de losgekoppelde HEAD-status geschikt.

Uw Quarkus-app lokaal testen

In de stappen in deze sectie ziet u hoe u de app lokaal uitvoert.

Quarkus ondersteunt het automatisch inrichten van niet-geconfigureerde services in de ontwikkelings- en testmodus. Quarkus verwijst naar deze mogelijkheid als dev-services. Stel dat u een Quarkus-functie opneemt, zoals verbinding maken met een databaseservice. U wilt de app testen, maar u hebt de verbinding met een echte database nog niet volledig geconfigureerd. Quarkus start automatisch een stub-versie van de relevante service en verbindt uw toepassing hiermee. Zie Dev Services Overview in the Quarkus documentation (Overzicht van Dev Services) voor meer informatie.

Zorg ervoor dat uw containeromgeving, Docker of Podman, wordt uitgevoerd en gebruik de volgende opdracht om de dev-modus quarkus in te voeren:

quarkus dev

In plaats van quarkus dev, kunt u hetzelfde doen met Maven met behulp van mvn quarkus:dev.

Mogelijk wordt u gevraagd of u telemetrie wilt verzenden van uw gebruik van quarkus dev-modus. Zo ja, antwoord zoals u wilt.

Quarkus dev-modus maakt live opnieuw laden met achtergrondcompilatie mogelijk. Als u een aspect van de broncode van uw app wijzigt en uw browser vernieuwt, ziet u de wijzigingen. Als er problemen zijn met compilatie of implementatie, laat een foutpagina u weten. Quarkus dev-modus luistert naar een foutopsporingsprogramma op poort 5005. Als u wilt wachten totdat het foutopsporingsprogramma wordt toegevoegd voordat u deze uitvoert, geeft -Dsuspend u de opdrachtregel door. Als u het foutopsporingsprogramma helemaal niet wilt, kunt u gebruiken -Ddebug=false.

De uitvoer moet eruitzien als in het volgende voorbeeld:

__  ____  __  _____   ___  __ ____  ______
 --/ __ \/ / / / _ | / _ \/ //_/ / / / __/
 -/ /_/ / /_/ / __ |/ , _/ ,< / /_/ /\ \
--\___\_\____/_/ |_/_/|_/_/|_|\____/___/
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>

Druk op w op de terminal waar de Quarkus-ontwikkelmodus wordt uitgevoerd. Met de w-toets wordt uw standaardwebbrowser geopend om de Todo toepassing weer te geven. U kunt ook rechtstreeks toegang krijgen tot de toepassings-GUI http://localhost:8080 .

Schermopname van de todo-voorbeeld-app.

Selecteer een paar taken in de takenlijst. De gebruikersinterface geeft de selectie aan met een doorhalende tekststijl. U kunt ook een nieuw taakitem toevoegen aan de takenlijst door Todo-apps verifiëren te typen en op Enter te drukken, zoals wordt weergegeven in de volgende schermafbeelding:

Schermopname van de todo-voorbeeld-app met nieuwe items toegevoegd.

Open de RESTful-API (/api) om alle taken op te halen die zijn opgeslagen in de lokale PostgreSQL-database:

curl --verbose http://localhost:8080/api | jq .

De uitvoer moet eruitzien als in het volgende voorbeeld:

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

Druk op q om quarkus-ontwikkelaarsmodus af te sluiten.

De Azure-resources maken om de Quarkus-app uit te voeren

In de stappen in deze sectie ziet u hoe u de volgende Azure-resources maakt om de Quarkus-voorbeeld-app uit te voeren:

  • Flexibele azure Database for PostgreSQL-server
  • Azure Container Registry (ACR)
  • Azure Kubernetes Service (AKS)

Sommige van deze resources moeten unieke namen hebben binnen het bereik van het Azure-abonnement. Om deze uniekheid te garanderen, kunt u het initialen-, reeks-, datum-, achtervoegselpatroon gebruiken. Als u dit patroon wilt toepassen, noemt u uw resources door uw initialen, een reeksnummer, de datum van vandaag en een bepaald type resourcespecifiek achtervoegsel weer te geven, rg bijvoorbeeld voor 'resourcegroep'. In de volgende omgevingsvariabelen wordt dit patroon gebruikt. Vervang de tijdelijke aanduidingen UNIQUE_VALUELOCATIONDB_PASSWORD en door uw eigen waarden en voer vervolgens de volgende opdrachten uit in uw terminal:

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, northeurope>
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 CLUSTER_NAME=${UNIQUE_VALUE}aks
export AKS_NS=${UNIQUE_VALUE}ns

Een Flexibele Azure Database for PostgreSQL-server maken

Azure Database for PostgreSQL Flexible Server is een volledig beheerde databaseservice die is ontworpen om nauwkeurige controle en flexibiliteit te bieden als het gaat om databasebeheerfuncties en configuratie-instellingen. In deze sectie wordt beschreven hoe u een Exemplaar van Azure Database for PostgreSQL Flexible Server maakt met behulp van de Azure CLI. Zie quickstart: Een Exemplaar van Azure Database for PostgreSQL - Flexible Server maken met behulp van Azure CLI voor meer informatie.

Maak eerst een resourcegroep die de databaseserver en andere resources bevat met behulp van de volgende opdracht:

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

Maak vervolgens een exemplaar van een flexibele Azure Database for PostgreSQL-server met behulp van de volgende opdracht:

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

Het duurt enkele minuten om de server, database, beheerder en firewallregels te maken. Als de opdracht is geslaagd, ziet de uitvoer er ongeveer als volgt uit:

{
  "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": "North Europe",
  "password": "<DB_PASSWORD>",
  "resourceGroup": "<RESOURCE_GROUP_NAME>",
  "skuname": "Standard_D2s_v3",
  "username": "<DB_ADMIN>",
  "version": "13"
}

Een Azure Container Registry-exemplaar maken

Omdat Quarkus een systeemeigen cloudtechnologie is, biedt het ingebouwde ondersteuning voor het maken van containers die worden uitgevoerd in Kubernetes. Kubernetes is volledig afhankelijk van het hebben van een containerregister waaruit de containerinstallatiekopieën worden gevonden die moeten worden uitgevoerd. AKS heeft ingebouwde ondersteuning voor Azure Container Registry (ACR).

Gebruik de opdracht az acr create om het ACR-exemplaar te maken. In het volgende voorbeeld wordt een ACR-exemplaar gemaakt met de waarde van uw omgevingsvariabele ${REGISTRY_NAME}:

az acr create \
    --resource-group $RESOURCE_GROUP_NAME \
    --location ${LOCATION} \
    --name $REGISTRY_NAME \
    --sku Basic \
    --admin-enabled

Na korte tijd ziet u JSON-uitvoer die de volgende regels bevat:

  "provisioningState": "Succeeded",
  "publicNetworkAccess": "Enabled",
  "resourceGroup": "<YOUR_RESOURCE_GROUP>",

Uw Docker verbinden met het ACR-exemplaar

Meld u aan bij het ACR-exemplaar. Als u zich aanmeldt, kunt u een afbeelding pushen. Gebruik de volgende opdrachten om de verbinding te controleren:

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

Als u Podman gebruikt in plaats van Docker, moet u de benodigde wijzigingen aanbrengen in de opdracht.

Als u zich hebt aangemeld bij het ACR-exemplaar, ziet Login Succeeded u aan het einde van de opdrachtuitvoer.

Een AKS-cluster maken

Gebruik de opdracht az aks create om een AKS-cluster te maken. In het volgende voorbeeld wordt een cluster met de naam gemaakt met de waarde van uw omgevingsvariabele ${CLUSTER_NAME} met één knooppunt. Het cluster is verbonden met het ACR-exemplaar dat u in een vorige stap hebt gemaakt. Het voltooien van deze opdracht duurt enkele minuten.

az aks create \
    --resource-group $RESOURCE_GROUP_NAME \
    --location ${LOCATION} \
    --name $CLUSTER_NAME \
    --attach-acr $REGISTRY_NAME \
    --node-count 1 \
    --generate-ssh-keys

Na een paar minuten wordt de opdracht voltooid en retourneert JSON-geformatteerde informatie over het cluster, inclusief de volgende uitvoer:

  "nodeResourceGroup": "MC_<your resource_group_name>_<your cluster name>_<your region>",
  "privateFqdn": null,
  "provisioningState": "Succeeded",
  "resourceGroup": "<your resource group name>",

Verbinding maken met het AKS-cluster

Als u een Kubernetes-cluster wilt beheren, gebruikt kubectlu de Kubernetes-opdrachtregelclient. Als u lokaal wilt installeren kubectl , gebruikt u de opdracht az aks install-cli , zoals wordt weergegeven in het volgende voorbeeld:

az aks install-cli

Zie het opdrachtregelprogramma (kubectl) in de Kubernetes-documentatie voor meer informatiekubectl.

Gebruik de opdracht az aks get-credentials om verbinding te maken kubectl met uw Kubernetes-cluster, zoals wordt weergegeven in het volgende voorbeeld. Bij deze opdracht worden referenties gedownload en wordt Kubernetes CLI geconfigureerd voor het gebruik van deze referenties.

az aks get-credentials \
    --resource-group $RESOURCE_GROUP_NAME \
    --name $CLUSTER_NAME \
    --overwrite-existing \
    --admin

Geslaagde uitvoer bevat tekst die vergelijkbaar is met het volgende voorbeeld:

Merged "ejb010718aks-admin" as current context in /Users/edburns/.kube/config

Het is misschien handig om een alias k te gebruiken voor kubectl. Gebruik in dat voorbeeld de volgende opdracht:

alias k=kubectl

Als u de verbinding met uw cluster wilt controleren, gebruikt u de kubectl get opdracht om een lijst met de clusterknooppunten te retourneren, zoals wordt weergegeven in het volgende voorbeeld:

kubectl get nodes

In de volgende voorbeelduitvoer ziet u het enkele knooppunt dat is gemaakt in de vorige stappen. Zorg ervoor dat de status van het knooppunt Ready is:

NAME                                STATUS   ROLES   AGE     VERSION
aks-nodepool1-xxxxxxxx-yyyyyyyyyy   Ready    agent   76s     v1.28.9

Een nieuwe naamruimte maken in AKS

Gebruik de volgende opdracht om een nieuwe naamruimte te maken in uw Kubernetes-service voor uw Quarkus-app:

kubectl create namespace ${AKS_NS}

De uitvoer moet eruitzien als in het volgende voorbeeld:

namespace/<your namespace> created

Een geheim maken voor databaseverbinding in AKS

Maak een geheim db-secret in de AKS-naamruimte om de verbindingsgegevens van de database op te slaan. Gebruik de volgende opdracht om het geheim te maken:

kubectl create secret generic db-secret \
    -n ${AKS_NS} \
    --from-literal=jdbcurl=jdbc:postgresql://${DB_SERVER_NAME}.postgres.database.azure.com:5432/${DB_NAME}?sslmode=require \
    --from-literal=dbusername=${DB_ADMIN} \
    --from-literal=dbpassword=${DB_PASSWORD}

De uitvoer moet eruitzien als in het volgende voorbeeld:

secret/db-secret created

De cloudeigen configuratie aanpassen

Quarkus biedt als cloudeigen technologie de mogelijkheid om automatisch resources te configureren voor standaard Kubernetes, Red Hat OpenShift en Knative. Zie de Quarkus Kubernetes-handleiding, Quarkus OpenShift-handleiding en Quarkus Knative Guide voor meer informatie. Ontwikkelaars kunnen de toepassing implementeren in een Kubernetes-doelcluster door de gegenereerde manifesten toe te passen.

Als u de juiste Kubernetes-resources wilt genereren, gebruikt u de volgende opdracht om de quarkus-kubernetes en container-image-jib extensies toe te voegen in uw lokale terminal:

quarkus ext add kubernetes container-image-jib

Quarkus wijzigt de POM om ervoor te zorgen dat deze extensies worden vermeld als <dependencies>. Als u wordt gevraagd iets met de naam JBangte installeren, antwoordt u ja en staat u toe dat het moet worden geïnstalleerd.

De uitvoer moet eruitzien als in het volgende voorbeeld:

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

Als u wilt controleren of de extensies zijn toegevoegd, kunt u de uitvoer uitvoeren git diff en onderzoeken.

Quarkus ondersteunt als cloudeigen technologie het begrip configuratieprofielen. Quarkus heeft de volgende drie ingebouwde profielen:

  • dev - Geactiveerd in de ontwikkelmodus
  • test - Geactiveerd bij het uitvoeren van tests
  • prod - Het standaardprofiel wanneer het niet wordt uitgevoerd in de ontwikkelings- of testmodus

Quarkus ondersteunt een willekeurig aantal benoemde profielen, indien nodig.

De resterende stappen in deze sectie leiden u naar het verwijderen van opmerkingen en het aanpassen van waarden in het bestand src/main/resources/application.properties . Zorg ervoor dat alle lijnen die beginnen, # %prod. ongecommenteerd zijn door de voorloop te #verwijderen.

Het prod. voorvoegsel geeft aan dat deze eigenschappen actief zijn wanneer ze in het prod profiel worden uitgevoerd. Zie de Quarkus-documentatie voor meer informatie over configuratieprofielen.

Databaseconfiguratie

Voeg de volgende databaseconfiguratievariabelen toe. De eigenschappen %prod.quarkus.datasource.jdbc.urlvan de databaseverbinding, %prod.quarkus.datasource.usernameen %prod.quarkus.datasource.password waarden lezen uit de omgevingsvariabelenDB_JDBC_URLDB_USERNAME, respectievelijkDB_PASSWORD. Deze omgevingsvariabelen worden om veiligheidsredenen toegewezen aan geheime waarden waarin de gegevens van de databaseverbinding worden opgeslagen. Deze worden beschreven in de volgende sectie.

# Database configurations
%prod.quarkus.datasource.db-kind=postgresql
%prod.quarkus.datasource.jdbc.driver=org.postgresql.Driver
%prod.quarkus.datasource.jdbc.url=${DB_JDBC_URL}
%prod.quarkus.datasource.username=${DB_USERNAME}
%prod.quarkus.datasource.password=${DB_PASSWORD}
%prod.quarkus.hibernate-orm.database.generation=drop-and-create
%prod.quarkus.hibernate-orm.sql-load-script=import.sql

Kubernetes-configuratie

Voeg de volgende Kubernetes-configuratievariabelen toe. Zorg ervoor dat deze is ingesteld service-type op load-balancer toegang tot de app extern.

# Kubernetes configurations
%prod.quarkus.kubernetes.deployment-target=kubernetes
%prod.quarkus.kubernetes.service-type=load-balancer
%prod.quarkus.kubernetes.env.secrets=db-secret
%prod.quarkus.kubernetes.env.mapping.DB_JDBC_URL.from-secret=db-secret
%prod.quarkus.kubernetes.env.mapping.DB_JDBC_URL.with-key=jdbcurl
%prod.quarkus.kubernetes.env.mapping.DB_USERNAME.from-secret=db-secret
%prod.quarkus.kubernetes.env.mapping.DB_USERNAME.with-key=dbusername
%prod.quarkus.kubernetes.env.mapping.DB_PASSWORD.from-secret=db-secret
%prod.quarkus.kubernetes.env.mapping.DB_PASSWORD.with-key=dbpassword

De andere Kubernetes-configuraties geven de toewijzing van de geheime waarden aan de omgevingsvariabelen in de Quarkus-toepassing op. Het db-secret geheim bevat de verbindingsgegevens van de database. De jdbcurl, dbusernameen dbpassword sleutels in de geheime toewijzing aan respectievelijk de DB_JDBC_URL, DB_USERNAMEen DB_PASSWORD omgevingsvariabelen.

Configuratie van containerinstallatiekopieën

Als systeemeigen cloudtechnologie biedt Quarkus ondersteuning voor het genereren van OCI-containerinstallatiekopieën die compatibel zijn met Docker en Podman. Voeg de volgende variabelen voor containerinstallatiekopieën toe. Vervang respectievelijk de waarden van <LOGIN_SERVER_VALUE> en <USER_NAME_VALUE> door de waarden van de werkelijke waarden van de ${LOGIN_SERVER} en ${USER_NAME} omgevingsvariabelen.

# 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

Bouw de containerinstallatiekopieën en push deze naar ACR

Gebruik nu de volgende opdracht om de toepassing zelf te bouwen. Met deze opdracht worden de Kubernetes- en Jib-extensies gebruikt om de containerinstallatiekopieën te bouwen.

quarkus build --no-tests

De uitvoer moet eindigen op BUILD SUCCESS. De Kubernetes-manifestbestanden worden gegenereerd in target/kubernetes, zoals wordt weergegeven in het volgende voorbeeld:

tree target/kubernetes
target/kubernetes
├── kubernetes.json
└── kubernetes.yml

0 directories, 2 files

U kunt controleren of de containerinstallatiekopie ook wordt gegenereerd met behulp van docker of podman opdrachtregel (CLI). Uitvoer ziet er ongeveer uit als in het volgende voorbeeld:

docker images | grep todo
<LOGIN_SERVER_VALUE>/<USER_NAME_VALUE>/todo-quarkus-aks   1.0       b13c389896b7   18 minutes ago   424MB

Push de containerinstallatiekopieën naar ACR met behulp van de volgende opdracht:

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

De uitvoer moet er als in het volgende voorbeeld uitzien:

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

Nu u de app naar ACR hebt gepusht, kunt u AKS vertellen de app uit te voeren.

De Quarkus-app implementeren in AKS

In de stappen in deze sectie ziet u hoe u de Quarkus-voorbeeld-app uitvoert op de Azure-resources die u hebt gemaakt.

Kubectl gebruiken om de Quarkus-app te implementeren in AKS

Implementeer de Kubernetes-resources met behulp van kubectl de opdrachtregel, zoals wordt weergegeven in het volgende voorbeeld:

kubectl apply -f target/kubernetes/kubernetes.yml -n ${AKS_NS}

De uitvoer moet eruitzien als in het volgende voorbeeld:

deployment.apps/quarkus-todo-demo-app-aks created

Controleer of de app wordt uitgevoerd met behulp van de volgende opdracht:

kubectl -n $AKS_NS get pods

Als de waarde van het STATUS veld iets anders weergeeft dan Running, lost u het probleem op en lost u het probleem op voordat u doorgaat. Het kan helpen om de podlogboeken te onderzoeken met behulp van de volgende opdracht:

kubectl -n $AKS_NS logs $(kubectl -n $AKS_NS get pods | grep quarkus-todo-demo-app-aks | cut -d " " -f1)

Haal de EXTERNAL-IP toegang tot de Todo-toepassing op met behulp van de volgende opdracht:

kubectl get svc -n ${AKS_NS}

De uitvoer moet eruitzien als in het volgende voorbeeld:

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

U kunt de volgende opdracht gebruiken om de waarde van EXTERNAL-IP een omgevingsvariabele op te slaan als een volledig gekwalificeerde URL:

export QUARKUS_URL=http://$(kubectl get svc -n ${AKS_NS} | grep quarkus-todo-demo-app-aks | cut -d " " -f10)
echo $QUARKUS_URL

Open een nieuwe webbrowser met de waarde van ${QUARKUS_URL}. Voeg vervolgens een nieuw taakitem toe met de tekst Deployed the Todo app to AKS. Selecteer ook het Introduction to Quarkus Todo App item als voltooid.

Schermopname van de todo-voorbeeld-app die wordt uitgevoerd in AKS.

Open de RESTful-API (/api) om alle taken op te halen die zijn opgeslagen in de Azure PostgreSQL-database, zoals wordt weergegeven in het volgende voorbeeld:

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

De uitvoer moet eruitzien als in het volgende voorbeeld:

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

Controleer of de database is bijgewerkt met behulp van Azure Cloud Shell

Open Azure Cloud Shell in Azure Portal door het Cloud Shell-pictogram te selecteren, zoals wordt weergegeven in de volgende schermopname:

Schermopname van Azure Portal met de knop Cloud Shell gemarkeerd.

Voer de volgende opdracht lokaal uit en plak het resultaat in Azure Cloud Shell:

echo psql --host=${DB_SERVER_NAME}.postgres.database.azure.com --port=5432 --username=${DB_ADMIN} --dbname=${DB_NAME}

Wanneer u om het wachtwoord wordt gevraagd, gebruikt u de waarde die u hebt gebruikt bij het maken van de database.

Gebruik de volgende query om alle taken op te halen:

select * from todo;

De uitvoer moet er ongeveer uitzien als in het volgende voorbeeld en moet dezelfde items bevatten in de todo-app-GUI die eerder is weergegeven:

Schermopname van de queryuitvoer als een ASCII-tabel.

Als u in de uitvoer ziet MORE , typt u q om de pager af te sluiten.

Voer \q in om het psql programma af te sluiten en terug te keren naar de Cloud Shell.

Resources opschonen

Om Azure-kosten te vermijden, moet u overbodige resources opschonen. Wanneer het cluster niet meer nodig is, gebruikt u de opdracht az group delete om de resourcegroep, de containerservice, het containerregister en alle gerelateerde resources te verwijderen.

git reset --hard
docker rmi ${TODO_QUARKUS_TAG}:1.0
docker rmi postgres
az group delete --name $RESOURCE_GROUP_NAME --yes --no-wait

U kunt ook de docker rmi containerinstallatiekopieën postgres verwijderen en testcontainers gegenereerd door quarkus dev-modus.

Volgende stappen