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

Artikel
12/18/2024

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 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 verificatie met Azure PowerShell-gebruikers kan de cmdlet Connect-AzAccount worden uitgevoerd. Net als de Azure CLI start Connect-AzAccount standaard de standaardwebbrowser om een gebruikersaccount te verifiëren.
```
Connect-AzAccount
```
  Als u Visual Studio Code gebruikt, kunt u zich ook aanmelden bij Azure met de Azure-accountextensie.
- 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-12-16
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 in een container geplaatste 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 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 .

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

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
Azure Kubernetes Service (AKS)

Notitie

In dit artikel wordt PostgreSQL-verificatie uitgeschakeld om aanbevolen procedures voor beveiliging te illustreren. Microsoft Entra-id wordt gebruikt om de verbinding met de server te verifiëren. Als u PostgreSQL-verificatie wilt inschakelen, raadpleegt u quickstart: Java en JDBC gebruiken met Azure Database for PostgreSQL - Flexible Server en selecteert u het tabblad Wachtwoord .

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_VALUE en LOCATION 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 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.

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 \
    --database-name $DB_NAME \
    --resource-group $RESOURCE_GROUP_NAME \
    --location $LOCATION \
    --public-access 0.0.0.0 \
    --sku-name Standard_B1ms \
    --tier Burstable \
    --active-directory-auth Enabled \
    --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://REDACTED@ejb011212qdb.postgres.database.azure.com/demodb?sslmode=require",
  "databaseName": "demodb",
  "firewallName": "AllowAllAzureServicesAndResourcesWithinAzureIps_2024-12-12_14-30-22",
  "host": "ejb011212qdb.postgres.database.azure.com",
  "id": "/subscriptions/c7844e91-b11d-4a7f-ac6f-996308fbcdb9/resourceGroups/ejb011211sfi/providers/Microsoft.DBforPostgreSQL/flexibleServers/ejb011212qdb",
  "location": "East US 2",
  "password": "REDACTED",
  "resourceGroup": "ejb011211sfi",
  "skuname": "Standard_B1ms",
  "username": "sorrycamel2",
  "version": "16"
}

App lokaal testen met Azure Database for PostgreSQL Flexible Server

In de vorige sectie hebt u de Quarkus-app lokaal getest in de ontwikkelmodus met een PostgreSQL-database die is ingericht als een Docker-container. Test nu de verbinding met het Azure Database for PostgreSQL Flexible Server-exemplaar lokaal.

Voeg eerst de huidige aangemelde gebruiker toe als Microsoft Entra-beheerder aan het azure Database for PostgreSQL Flexible Server-exemplaar met behulp van de volgende opdrachten:

ENTRA_ADMIN_NAME=$(az account show --query user.name --output 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 --output tsv)

Geslaagde uitvoer is een JSON-object met inbegrip van de eigenschap "type": "Microsoft.DBforPostgreSQL/flexibleServers/administrators".

Voeg vervolgens het lokale IP-adres toe aan de firewallregels voor azure Database for PostgreSQL Flexible Server-exemplaren door de volgende stappen uit te voeren:

Haal het lokale IP-adres op van uw computer waarop u de Quarkus-app lokaal uitvoert. Ga bijvoorbeeld naar https://whatismyipaddress.com uw openbare IP v4-adres.
Definieer een omgevingsvariabele met het lokale IP-adres dat u in de vorige stap hebt gekregen.
```
export AZ_LOCAL_IP_ADDRESS=<your local IP address>
```

Voer de volgende opdracht uit om het lokale IP-adres toe te voegen aan de firewallregels voor azure Database for PostgreSQL Flexible Server-exemplaren:

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

Stel vervolgens de volgende omgevingsvariabelen in uw vorige terminal in. Deze omgevingsvariabelen worden gebruikt om verbinding te maken met het Azure Database for PostgreSQL Flexible Server-exemplaar vanuit de Quarkus-app die lokaal wordt uitgevoerd:

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}

Notitie

De waarden van omgevingsvariabelenAZURE_POSTGRESQL_HOST, AZURE_POSTGRESQL_PORTen AZURE_POSTGRESQL_USERNAME AZURE_POSTGRESQL_DATABASEworden gelezen door databaseconfiguratie-eigenschappen die zijn gedefinieerd in het bestand src/main/resources/application.properties dat in de vorige sectie is geïntroduceerd. Deze waarden worden tijdens runtime automatisch in de app geïnjecteerd met behulp van de extensie zonder wachtwoord voor de Service Connector wanneer u de Quarkus-app implementeert in het AKS-cluster verderop in dit artikel.

Voer nu de Quarkus-app lokaal uit om de verbinding met het Azure Database for PostgreSQL Flexible Server-exemplaar te testen. Gebruik de volgende opdracht om de app te starten in de productiemodus:

quarkus build
java -jar target/quarkus-app/quarkus-run.jar

Notitie

Als de app niet kan worden gestart met een foutbericht dat lijkt op ERROR [org.hib.eng.jdb.spi.SqlExceptionHelper] (JPA Startup Thread) Acquisition timeout while waiting for new connection, is dit waarschijnlijk vanwege de netwerkinstelling van uw lokale computer. Selecteer het IP-adres van de huidige client toevoegen in Azure Portal opnieuw. Zie de sectie Een firewallregel maken nadat de server is gemaakt in Firewallregels maken en beheren voor Azure Database for PostgreSQL - Flexible Server met behulp van Azure Portal voor meer informatie. Voer de vervolgens opnieuw app uit.

Open een nieuwe webbrowser om toegang te http://localhost:8080 krijgen tot de Todo-toepassing. U ziet de taken-app, die lijkt op wat u hebt gezien toen u de app lokaal in de ontwikkelmodus uitvoerde.

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 biedt ingebouwde ondersteuning voor Azure Container Registry.

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

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

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

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

Haal de aanmeldingsserver voor het Container Registry-exemplaar op met behulp van de volgende opdracht:

export LOGIN_SERVER=$(az acr show \
    --name $REGISTRY_NAME \
    --query 'loginServer' \
    --output tsv)
echo $LOGIN_SERVER

Uw Docker verbinden met het containerregisterexemplaren

Meld u aan bij het containerregisterexemplaren. Als u zich aanmeldt, kunt u een afbeelding pushen. Gebruik de volgende opdracht om u aan te melden bij het register:

az acr login --name $REGISTRY_NAME

Als u bent aangemeld bij het containerregisterexemplaren, 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 containerregisterexemplaren dat u in een vorige stap hebt gemaakt. Het voltooien van deze opdracht duurt enkele minuten. Het cluster wordt gestart met beheerde identiteit ingeschakeld. Deze stap is nodig voor de databaseverbinding zonder wachtwoord.

az aks create \
    --resource-group $RESOURCE_GROUP_NAME \
    --name $CLUSTER_NAME \
    --attach-acr $REGISTRY_NAME \
    --node-count 1 \
    --generate-ssh-keys \
    --enable-managed-identity

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 serviceverbinding maken in AKS met serviceconnector

In deze sectie maakt u een serviceverbinding tussen het AKS-cluster en de Flexibele Azure Database for PostgreSQL-server met behulp van Microsoft Entra Workload-ID met serviceconnector. Met deze verbinding heeft het AKS-cluster toegang tot de Azure Database for PostgreSQL Flexible Server zonder SQL-verificatie te gebruiken.

Voer de volgende opdrachten uit om een verbinding te maken tussen het AKS-cluster en de PostgreSQL-database met behulp van Microsoft Entra Workload-ID met Service Connector:

# Register the Service Connector and Kubernetes Configuration resource providers
az provider register --namespace Microsoft.ServiceLinker --wait
az provider register --namespace Microsoft.KubernetesConfiguration --wait

# Install the Service Connector passwordless extension
az extension add --name serviceconnector-passwordless --upgrade --allow-preview true

# Retrieve the AKS cluster and Azure SQL Server resource IDs
export AKS_CLUSTER_RESOURCE_ID=$(az aks show \
    --resource-group $RESOURCE_GROUP_NAME \
    --name $CLUSTER_NAME \
    --query id \
    --output tsv)
export AZURE_POSTGRESQL_RESOURCE_ID=$(az postgres flexible-server show \
    --resource-group $RESOURCE_GROUP_NAME \
    --name $DB_SERVER_NAME \
    --query id \
    --output tsv)

# Create a user-assigned managed identity used for workload identity
export USER_ASSIGNED_IDENTITY_NAME=workload-identity-uami
az identity create \
    --resource-group ${RESOURCE_GROUP_NAME} \
    --name ${USER_ASSIGNED_IDENTITY_NAME}

# Retrieve the user-assigned managed identity resource ID
export UAMI_RESOURCE_ID=$(az identity show \
    --resource-group ${RESOURCE_GROUP_NAME} \
    --name ${USER_ASSIGNED_IDENTITY_NAME} \
    --query id \
    --output tsv)

# Create a service connection between your AKS cluster and your PostgreSQL database using Microsoft Entra Workload ID
az aks connection create postgres-flexible \
    --connection akspostgresconn \
    --kube-namespace $AKS_NS \
    --source-id $AKS_CLUSTER_RESOURCE_ID \
    --target-id $AZURE_POSTGRESQL_RESOURCE_ID/databases/$DB_NAME \
    --workload-identity $UAMI_RESOURCE_ID

De aanwezigheid van de volgende JSON in de uitvoer van de laatste opdracht in de voorgaande stappen geeft een geslaagde installatie van de serviceconnector aan:

"name": "akspostgresconn",
"provisioningState": "Succeeded",

Notitie

U wordt aangeraden Microsoft Entra Workload-ID te gebruiken voor beveiligde toegang tot uw Azure Database for PostgreSQL Flexible Server zonder verificatie met gebruikersnaam en wachtwoord. Als u verificatie van gebruikersnaam/wachtwoord wilt gebruiken, negeert u de vorige stappen in deze sectie en gebruikt u de gebruikersnaam en het wachtwoord om verbinding te maken met de database.

Serviceaccount en geheim ophalen dat is gemaakt door Service Connector

Als u zich wilt verifiëren bij azure Database for PostgreSQL Flexible Server, moet u het serviceaccount en het Kubernetes-geheim ophalen dat is gemaakt door Service Connector. Volg de instructies in de sectie Uw container bijwerken van de zelfstudie: Een AKS-app verbinden met Azure SQL Database. Gebruik de optie Rechtstreeks een implementatie met behulp van het opgegeven YAML-voorbeeldcodefragment en gebruik de volgende stap:

Kopieer in de gemarkeerde secties in de YAML van de kubernetes-voorbeeldimplementatie de waarden van serviceAccountName en secretRef.name, weergegeven als <service-account-name> en <secret-name> in het volgende voorbeeld:
```
serviceAccountName: <service-account-name>
containers:
- name: raw-linux
    envFrom:
       - secretRef:
          name: <secret-name>
```
Deze waarden worden gebruikt in de volgende sectie om de Quarkus-toepassing te implementeren in het AKS-cluster.

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.

Met de resterende stappen in deze sectie kunt u waarden aanpassen in het bestand src/main/resources/application.properties .

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

Bekijk de volgende databaseconfiguratievariabelen. De eigenschappen %prod.quarkus.datasource.jdbc.url van de databaseverbinding en %prod.quarkus.datasource.username het lezen van waarden uit de omgevingsvariabelen AZURE_POSTGRESQL_HOST, AZURE_POSTGRESQL_PORTrespectievelijk , AZURE_POSTGRESQL_DATABASEen AZURE_POSTGRESQL_USERNAME. Deze omgevingsvariabelen worden toegewezen aan geheime waarden waarmee de databaseverbindingsgegevens worden opgeslagen. Om veiligheidsredenen worden ze automatisch gegenereerd met behulp van de extensie zonder wachtwoord voor serviceconnector, zoals elders in dit artikel wordt weergegeven.

# Database configurations
%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.datasource.jdbc.acquisition-timeout=10
%prod.quarkus.hibernate-orm.database.generation=drop-and-create
%prod.quarkus.hibernate-orm.sql-load-script=import.sql

Kubernetes-configuratie

Bekijk de volgende Kubernetes-configuratievariabelen. service-type is ingesteld op load-balancer toegang tot de app extern. Vervang de waarden van <service-account-name> en <secret-name> door de waarden van de werkelijke waarden die u in de vorige sectie hebt gekopieerd.

# Kubernetes configurations
%prod.quarkus.kubernetes.deployment-target=kubernetes
%prod.quarkus.kubernetes.service-type=load-balancer
%prod.quarkus.kubernetes.labels."azure.workload.identity/use"=true
%prod.quarkus.kubernetes.service-account=<service-account-name>
%prod.quarkus.kubernetes.env.mapping.AZURE_CLIENT_ID.from-secret=<secret-name>
%prod.quarkus.kubernetes.env.mapping.AZURE_CLIENT_ID.with-key=AZURE_POSTGRESQL_CLIENTID
%prod.quarkus.kubernetes.env.mapping.AZURE_POSTGRESQL_HOST.from-secret=<secret-name>
%prod.quarkus.kubernetes.env.mapping.AZURE_POSTGRESQL_HOST.with-key=AZURE_POSTGRESQL_HOST
%prod.quarkus.kubernetes.env.mapping.AZURE_POSTGRESQL_PORT.from-secret=<secret-name>
%prod.quarkus.kubernetes.env.mapping.AZURE_POSTGRESQL_PORT.with-key=AZURE_POSTGRESQL_PORT
%prod.quarkus.kubernetes.env.mapping.AZURE_POSTGRESQL_DATABASE.from-secret=<secret-name>
%prod.quarkus.kubernetes.env.mapping.AZURE_POSTGRESQL_DATABASE.with-key=AZURE_POSTGRESQL_DATABASE
%prod.quarkus.kubernetes.env.mapping.AZURE_POSTGRESQL_USERNAME.from-secret=<secret-name>
%prod.quarkus.kubernetes.env.mapping.AZURE_POSTGRESQL_USERNAME.with-key=AZURE_POSTGRESQL_USERNAME

De andere Kubernetes-configuraties geven de toewijzing van de geheime waarden aan de omgevingsvariabelen in de Quarkus-toepassing op. Het <secret-name> geheim bevat de verbindingsgegevens van de database. De AZURE_POSTGRESQL_CLIENTID, AZURE_POSTGRESQL_HOST, AZURE_POSTGRESQL_PORT, , en AZURE_POSTGRESQL_USERNAME AZURE_POSTGRESQL_DATABASEsleutels in de geheime toewijzing aan respectievelijk de AZURE_CLIENT_ID, AZURE_POSTGRESQL_HOST, AZURE_POSTGRESQL_PORT, en AZURE_POSTGRESQL_USERNAME AZURE_POSTGRESQL_DATABASEomgevingsvariabelen.

Als u de geheimen rechtstreeks met kubectl wilt onderzoeken, gebruikt u opdrachten die vergelijkbaar zijn met het volgende voorbeeld:

kubectl -n ${AKS_NS} get secret <secret-name> -o jsonpath="{.data.AZURE_POSTGRESQL_USERNAME}" | base64 --decode

Configuratie van containerinstallatiekopieën

Als systeemeigen cloudtechnologie biedt Quarkus ondersteuning voor het genereren van OCI-containerinstallatiekopieën die compatibel zijn met Docker. Vervang de waarde door <LOGIN_SERVER_VALUE> de werkelijke waarde van de ${LOGIN_SERVER} omgevingsvariabele.

# Container Image Build
%prod.quarkus.container-image.build=true
%prod.quarkus.container-image.image=<LOGIN_SERVER_VALUE>/todo-quarkus-aks:1.0

Als laatste controle moet u, wanneer u alle benodigde vervangingen in application.properties voltooit, geen exemplaren van het < teken voorkomen. Als dat zo is, controleert u of u alle benodigde vervangingen hebt voltooid.

Bouw de containerinstallatiekopieën en push deze naar het containerregister

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 de opdrachtregel (CLI). De uitvoer ziet er ongeveer als volgt uit:

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

Push de containerinstallatiekopieën naar het containerregister 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>/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 het containerregister 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:

service/quarkus-todo-demo-app-aks created
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.

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

Voer de volgende opdracht uit om te controleren of de database nu correct is bijgewerkt:

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;"

Als u wordt gevraagd om een extensie te installeren, beantwoordt u Y.

De uitvoer moet er ongeveer uitzien als in het volgende voorbeeld en moet dezelfde items bevatten in de gui van de Taken-app en de uitvoer van curl de opdracht eerder:

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": false,
    "id": 2,
    "ordering": 1,
    "title": "Quarkus on Azure App Service",
    "url": "https://learn.microsoft.com/en-us/azure/developer/java/eclipse-microprofile/deploy-microprofile-quarkus-java-app-with-maven-plugin"
  },
  {
    "completed": false,
    "id": 3,
    "ordering": 2,
    "title": "Quarkus on Azure Container Apps",
    "url": "https://learn.microsoft.com/en-us/training/modules/deploy-java-quarkus-azure-container-app-postgres/"
  },
  {
    "completed": false,
    "id": 4,
    "ordering": 3,
    "title": "Quarkus on Azure Functions",
    "url": "https://learn.microsoft.com/en-us/azure/azure-functions/functions-create-first-quarkus"
  },
  {
    "completed": false,
    "id": 5,
    "ordering": 5,
    "title": "Deployed the Todo app to AKS",
    "url": null
  },
  {
    "completed": true,
    "id": 1,
    "ordering": 0,
    "title": "Introduction to Quarkus Todo App",
    "url": null
  }
]

Wanneer u klaar bent, verwijdert u de firewallregel waarmee uw lokale IP-adres toegang heeft tot het exemplaar van Azure Database for PostgreSQL Flexible Server met behulp van de volgende opdracht:

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

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 identity delete --ids ${UAMI_RESOURCE_ID}
az group delete --name $RESOURCE_GROUP_NAME --yes --no-wait

Mogelijk wilt docker rmi u ook de containerinstallatiekopieën postgres verwijderen en testcontainers gegenereerd door de dev-modus Quarkus.

Delen via

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

Vereisten

Het app-project maken

Uw Quarkus-app lokaal testen

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

Een Flexibele Azure Database for PostgreSQL-server maken

App lokaal testen met Azure Database for PostgreSQL Flexible Server

Een Azure Container Registry-exemplaar maken

Uw Docker verbinden met het containerregisterexemplaren

Een AKS-cluster maken

Verbinding maken met het AKS-cluster

Een nieuwe naamruimte maken in AKS

Een serviceverbinding maken in AKS met serviceconnector

Serviceaccount en geheim ophalen dat is gemaakt door Service Connector

De cloudeigen configuratie aanpassen

Databaseconfiguratie

Kubernetes-configuratie

Configuratie van containerinstallatiekopieën

Bouw de containerinstallatiekopieën en push deze naar het containerregister

De Quarkus-app implementeren in AKS

Kubectl gebruiken om de Quarkus-app te implementeren in AKS

Controleer of de database is bijgewerkt

Resources opschonen

Volgende stappen

Aanvullende resources