Java-alkalmazás üzembe helyezése a Quarkus használatával egy Azure Kubernetes Service-fürtön

Ez a cikk bemutatja, hogyan helyezheti üzembe gyorsan a Red Hat Quarkus-t az Azure Kubernetes Service-ben (AKS) egy egyszerű CRUD-alkalmazással. Az alkalmazás egy JavaScript-előtérrel és REST-végponttal rendelkező "teendőlista". A rugalmas Azure Database for PostgreSQL-kiszolgáló biztosítja az alkalmazás adatmegőrzési rétegét. A cikk bemutatja, hogyan tesztelheti az alkalmazást helyileg, és hogyan helyezheti üzembe az AKS-ben.

Előfeltételek

• Ha nem rendelkezik Azure-előfizetéssel, első lépésként hozzon létre egy ingyenes Azure-fiókot.
• Helyi gép előkészítése Unix-szerű operációs rendszerrel – például Ubuntu, macOS vagy Linuxos Windows-alrendszer.
• Telepítse a Java SE 17-es vagy újabb verzióját – például az OpenJDK Microsoft-buildet.
• Telepítse a Maven 3.9.8-es vagy újabb verzióját.
• Telepítse a Dockert az operációs rendszerhez.
• Telepítse a jq-t.
• Telepítse a cURL-t.
• Telepítse a Quarkus CLI 3.12.1-es vagy újabb verzióját.
• Azure CLI Unix-szerű környezetekhez. Ehhez a cikkhez csak az Azure CLI Bash-változata szükséges.
  • • Erősen megüt
    • PowerShell
    • Visual Studio Code

    A fejlesztőknek telepíteniük kell az Azure CLI-t , és interaktív módon kell bejelentkezniük az az bejelentkezési paranccsal, hogy bejelentkezhessenek az Azure-ba, mielőtt a DefaultAzureCredentialt használták volna a kódban.

    az login
    

  • Ez a cikk az Azure CLI legalább 2.61.0-s verzióját igényli.

Az alkalmazásprojekt létrehozása

A cikkhez tartozó Java-mintaprojekt klónozásához használja az alábbi parancsot. A minta a GitHubon található.

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

Ha a leválasztásos HEAD állapotról szóló üzenet jelenik meg, ezt az üzenetet nyugodtan figyelmen kívül hagyhatja. Mivel ez a cikk nem igényel véglegesítést, a leválasztott HEAD-állapot megfelelő.

A Quarkus-alkalmazás helyi tesztelése

Az ebben a szakaszban ismertetett lépések bemutatják, hogyan futtathatja az alkalmazást helyileg.

A Quarkus támogatja a nem konfigurált szolgáltatások automatikus kiépítését fejlesztési és tesztelési módban. A Quarkus erre a képességre dev szolgáltatásként hivatkozik. Tegyük fel, hogy tartalmaz egy Quarkus-funkciót, például egy adatbázis-szolgáltatáshoz való csatlakozást. Tesztelni szeretné az alkalmazást, de még nem konfigurálta teljes mértékben a kapcsolatot egy valódi adatbázissal. A Quarkus automatikusan elindítja az adott szolgáltatás tárolóalapú csonkverzióját, és csatlakoztatja az alkalmazást hozzá. További információ: A Dev Services áttekintése a Quarkus dokumentációjában.

Győződjön meg arról, hogy a tárolókörnyezet fut, és a következő paranccsal lépjen be a Quarkus fejlesztői módba:

quarkus dev

Ahelyett quarkus dev, hogy ugyanezt a dolgot maven használatával mvn quarkus:dev.

Előfordulhat, hogy a rendszer megkérdezi, hogy szeretne-e telemetriát küldeni a Quarkus fejlesztői módjának használatáról. Ha igen, válaszoljon úgy, ahogy szeretné.

A Quarkus fejlesztői mód lehetővé teszi az élő újratöltést háttér-összeállítással. Ha módosítja az alkalmazás forráskódjának bármely aspektusát, és frissíti a böngészőt, láthatja a módosításokat. Ha bármilyen probléma merül fel a fordítással vagy az üzembe helyezéssel kapcsolatban, egy hibaoldal tájékoztatja Önt. A Quarkus fejlesztői mód az 5005-ös porton figyeli a hibakeresőt. Ha a futtatás előtt meg szeretné várni, hogy a hibakereső csatolva legyen, adja át -Dsuspend a parancssort. Ha egyáltalán nem szeretné, hogy a hibakeresőt használja -Ddebug=false.

A kimenetnek a következő példához hasonlóan kell kinéznie:

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

Nyomja le a w billentyűt azon a terminálon, amelyen a Quarkus fejlesztői mód fut. A w billentyű megnyitja az alapértelmezett webböngészőt az Todo alkalmazás megjelenítéséhez. Az alkalmazás grafikus felhasználói felületét http://localhost:8080 közvetlenül is elérheti.

Próbáljon meg kijelölni néhány teendőelemet a teendőlistában. A felhasználói felület áthúzott szövegstílusú kijelölést jelez. Új teendőelemet is hozzáadhat a teendőlistához a Todo-alkalmazások ellenőrzése és az Enter billentyű lenyomásával, ahogyan az alábbi képernyőképen látható:

A RESTful API (/api) elérése a helyi PostgreSQL-adatbázisban tárolt összes teendőelem lekéréséhez:

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

A kimenetnek a következő példához hasonlóan kell kinéznie:

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

Nyomja le a q billentyűt a Quarkus fejlesztői módból való kilépéshez.

Azure-erőforrások létrehozása a Quarkus-alkalmazás futtatásához

Az ebben a szakaszban ismertetett lépések bemutatják, hogyan hozhatja létre a következő Azure-erőforrásokat a Quarkus-mintaalkalmazás futtatásához:

• Rugalmas Azure Database for PostgreSQL-kiszolgáló
• Azure Container Registry
• Azure Kubernetes Service (AKS)

Ezen erőforrások némelyikének egyedi névvel kell rendelkeznie az Azure-előfizetés hatókörén belül. Az egyediség biztosítása érdekében használhatja a monogramot, a sorrendet, a dátumot és az utótagmintát . A minta alkalmazásához nevezze el az erőforrásokat úgy, hogy felsorolja a monogramot, a sorszámot, a mai dátumot és valamilyen erőforrás-specifikus utótagot – például rg az "erőforráscsoportot". A következő környezeti változók ezt a mintát használják. Cserélje le a helyőrző értékeket UNIQUE_VALUE és LOCATION a saját értékeit, majd futtassa a következő parancsokat a terminálban:

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

Rugalmas Azure Database for PostgreSQL-kiszolgáló létrehozása

A rugalmas Azure Database for PostgreSQL-kiszolgáló egy teljes mértékben felügyelt adatbázis-szolgáltatás, amely részletesebb vezérlést és rugalmasságot biztosít az adatbázis-kezelési funkciók és a konfigurációs beállítások felett. Ez a szakasz bemutatja, hogyan hozhat létre rugalmas Azure Database for PostgreSQL-kiszolgálópéldányt az Azure CLI használatával.

Először hozzon létre egy erőforráscsoportot, amely az adatbázis-kiszolgálót és más erőforrásokat tartalmazza az alábbi paranccsal:

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

Ezután hozzon létre egy rugalmas Azure Database for PostgreSQL-kiszolgálópéldányt az alábbi paranccsal:

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

A kiszolgálói, adatbázis-, rendszergazdai és tűzfalszabályok létrehozása néhány percet vesz igénybe. Ha a parancs sikeres, a kimenet az alábbi példához hasonlóan néz ki:

{
  "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"
}

Alkalmazás helyi tesztelése rugalmas Azure Database for PostgreSQL-kiszolgálóval

Az előző szakaszban helyileg tesztelte a Quarkus alkalmazást fejlesztési módban egy Docker-tárolóként kiépített PostgreSQL-adatbázissal. Most tesztelje helyileg a rugalmas Azure Database for PostgreSQL-kiszolgálópéldányhoz való kapcsolatot.

Először adja hozzá az aktuális bejelentkezett felhasználót Microsoft Entra-rendszergazdaként a rugalmas Azure Database for PostgreSQL-kiszolgálópéldányhoz az alábbi parancsokkal:

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)

A sikeres kimenet egy JSON-objektum, beleértve a tulajdonságot "type": "Microsoft.DBforPostgreSQL/flexibleServers/administrators"is.

Ezután adja hozzá a helyi IP-címet a rugalmas Azure Database for PostgreSQL-kiszolgálópéldány tűzfalszabályaihoz az alábbi lépések végrehajtásával:

1. Kérje le a gép helyi IP-címét, ahol a Quarkus alkalmazást helyileg futtatja. Például látogasson el https://whatismyipaddress.com a nyilvános IP-cím 4-ben való lekéréséhez.

2. Definiáljon egy környezeti változót az előző lépésben kapott helyi IP-címmel.

   export AZ_LOCAL_IP_ADDRESS=<your local IP address>
   

3. Futtassa a következő parancsot a helyi IP-cím hozzáadásához a rugalmas Azure Database for PostgreSQL-kiszolgálópéldány tűzfalszabályaihoz:

   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
   

Ezután állítsa be a következő környezeti változókat az előző terminálban. Ezek a környezeti változók a helyileg futó Quarkus alkalmazásból csatlakoznak a rugalmas Azure Database for PostgreSQL-kiszolgálópéldányhoz:

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}

Most futtassa helyileg a Quarkus alkalmazást a rugalmas Azure Database for PostgreSQL-kiszolgálópéldányhoz való kapcsolat teszteléséhez. Az alkalmazás éles módban való elindításához használja a következő parancsot:

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

Nyisson meg egy új webböngészőt http://localhost:8080 a Todo-alkalmazás eléréséhez. A Todo alkalmazásnak hasonlónak kell lennie ahhoz, amit az alkalmazás helyi futtatásakor látott fejlesztési módban.

Azure Container Registry-példány létrehozása

Mivel a Quarkus egy natív felhőalapú technológia, beépített támogatást nyújt a Kubernetesben futó tárolók létrehozásához. A Kubernetes teljes mértékben attól függ, hogy rendelkezik-e tárolóregisztrációs adatbázissal, amelyből megtalálja a futtatandó tárolólemezképeket. Az AKS beépített támogatást nyújt az Azure Container Registryhez.

A tárolóregisztrációs adatbázispéldány létrehozásához használja az az acr create parancsot. Az alábbi példa létrehoz egy tárolóregisztrációs adatbázispéldányt a környezeti változó ${REGISTRY_NAME}értékével:

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

Rövid idő elteltével a következő sorokat tartalmazó JSON-kimenetnek kell megjelennie:

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

A Container Registry-példány bejelentkezési kiszolgálójának lekérése az alábbi paranccsal:

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

A docker csatlakoztatása a tárolóregisztrációs adatbázispéldányhoz

Jelentkezzen be a tárolóregisztrációs adatbázispéldányba. A bejelentkezéssel leküldhet egy képet. A következő paranccsal jelentkezzen be a beállításjegyzékbe:

az acr login --name $REGISTRY_NAME

Ha sikeresen bejelentkezett a tárolóregisztrációs adatbázispéldányba, a parancs kimenetének végén kell megjelennie Login Succeeded .

AKS-fürt létrehozása

Használja az az aks create parancsot egy AKS-fürt létrehozásához. Az alábbi példa egy olyan fürtöt hoz létre, amelynek a környezeti változó ${CLUSTER_NAME} értéke egy csomóponttal van elnevezve. A fürt az előző lépésben létrehozott tárolóregisztrációs adatbázispéldányhoz csatlakozik. A parancs végrehajtása több percet vesz igénybe. A fürt a felügyelt identitás engedélyezésével kezdődik. Ez a lépés a jelszó nélküli adatbázis-kapcsolathoz szükséges.

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

Néhány perc elteltével a parancs befejezi és visszaadja a fürt JSON-formátumú adatait, beleértve a következő kimenetet:

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

Csatlakozás az AKS-fürthöz

Egy Kubernetes-fürt kezeléséhez a Kubernetes parancssori ügyfelet kell használnia kubectl. A helyi telepítéshez kubectl használja az az aks install-cli parancsot az alábbi példában látható módon:

az aks install-cli

További információ: kubectlParancssori eszköz (kubectl) a Kubernetes dokumentációjában.

A Kubernetes-fürthöz való csatlakozás konfigurálásához kubectl használja az az aks get-credentials parancsot az alábbi példában látható módon. Ez a parancs letölti a hitelesítő adatokat, és konfigurálja a Kubernetes parancssori felületét a használatukhoz.

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

A sikeres kimenet a következő példához hasonló szöveget tartalmaz:

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

Hasznos lehet aliasként használni a .. parancsot k kubectl. Ha igen, használja a következő parancsot:

alias k=kubectl

A fürthöz való kapcsolat ellenőrzéséhez használja a parancsot a kubectl get fürtcsomópontok listájának visszaadásához, ahogyan az az alábbi példában látható:

kubectl get nodes

A következő példakimenet az előző lépésekben létrehozott csomópontot mutatja be. Győződjön meg arról, hogy a csomópont állapota készen áll:

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

Új névtér létrehozása az AKS-ben

A következő paranccsal hozzon létre egy új névteret a Kubernetes-szolgáltatásban a Quarkus-alkalmazáshoz:

kubectl create namespace ${AKS_NS}

A kimenetnek a következő példához hasonlóan kell kinéznie:

namespace/<your namespace> created

Szolgáltatáskapcsolat létrehozása az AKS-ben a Service Connector használatával

Ebben a szakaszban szolgáltatáskapcsolatot hoz létre az AKS-fürt és a rugalmas Azure Database for PostgreSQL-kiszolgáló között a Service Connector Microsoft Entra Számítási feladat ID használatával. Ezzel a kapcsolattal az AKS-fürt SQL-hitelesítés nélkül érheti el a rugalmas Azure Database for PostgreSQL-kiszolgálót.

Futtassa az alábbi parancsokat az AKS-fürt és a PostgreSQL-adatbázis közötti kapcsolat létrehozásához a Service Connector Microsoft Entra Számítási feladat ID használatával:

# 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

A következő JSON jelenléte az előző lépések utolsó parancsának kimenetében a szolgáltatás-összekötő sikeres telepítését jelzi:

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

A Service Connector által létrehozott szolgáltatásfiók és titkos kód lekérése

A rugalmas Azure Database for PostgreSQL-kiszolgálón való hitelesítéshez be kell szereznie a Service Connector által létrehozott szolgáltatásfiókot és Kubernetes-titkos kulcsot. Kövesse az oktatóanyag tárolófrissítési szakaszának utasításait: AKS-alkalmazás csatlakoztatása az Azure SQL Database-hez. Használja a közvetlen üzembe helyezés lehetőséget a megadott YAML-mintakódrészlet használatával, és használja a következő lépést:

• A kubernetes-alapú üzembehelyezési YAML-minta kiemelt szakaszaiból másolja ki a következő példában és módon megjelenített és secretRef.namemegjelenített értékeketserviceAccountName:<service-account-name> <secret-name>

  serviceAccountName: <service-account-name>
  containers:
  - name: raw-linux
      envFrom:
         - secretRef:
            name: <secret-name>
  

  Ezeket az értékeket a következő szakaszban a Quarkus-alkalmazás az AKS-fürtön való üzembe helyezéséhez használja.

Natív felhőkonfiguráció testreszabása

Natív felhőtechnológiaként a Quarkus lehetővé teszi az erőforrások automatikus konfigurálását a standard Kuberneteshez, a Red Hat OpenShifthez és a Knativehoz. További információkért lásd a Quarkus Kubernetes útmutatót, a Quarkus OpenShift útmutatót és a Quarkus Knative útmutatót. A fejlesztők a létrehozott jegyzékek alkalmazásával üzembe helyezhetik az alkalmazást egy cél Kubernetes-fürtön.

A megfelelő Kubernetes-erőforrások létrehozásához a következő paranccsal adja hozzá a quarkus-kubernetes bővítményeket a container-image-jib helyi terminálhoz:

quarkus ext add kubernetes container-image-jib

A Quarkus módosítja a POM-t, hogy ezek a bővítmények szerepeljenek a <dependencies>listán. Ha a rendszer egy úgynevezett JBangtelepítésre kéri, válaszoljon igennel, és engedélyezze a telepítést.

A kimenetnek a következő példához hasonlóan kell kinéznie:

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

A bővítmények hozzáadásának ellenőrzéséhez futtathatja git diff és megvizsgálhatja a kimenetet.

Natív felhőtechnológiaként a Quarkus támogatja a konfigurációs profilok fogalmát. A Quarkus három beépített profillal rendelkezik:

• dev - Fejlesztési módban aktiválva
• test - Teszt futtatásakor aktiválva
• prod – Az alapértelmezett profil, ha nem fejlesztési vagy tesztelési módban fut

A Quarkus igény szerint tetszőleges számú elnevezett profilt támogat.

A szakasz további lépései az src/main/resources/application.properties fájl értékeinek testreszabását irányítja.

Az prod. előtag azt jelzi, hogy ezek a tulajdonságok aktívak a prod profilban való futtatáskor. A konfigurációs profilokról további információt a Quarkus dokumentációjában talál.

Adatbázis konfigurálása

Vizsgálja meg a következő adatbáziskonfigurációs változókat. Az adatbázis-kapcsolathoz kapcsolódó tulajdonságok %prod.quarkus.datasource.jdbc.url és %prod.quarkus.datasource.username olvasási értékek a környezeti változókbólAZURE_POSTGRESQL_HOST, AZURE_POSTGRESQL_USERNAMEAZURE_POSTGRESQL_PORTAZURE_POSTGRESQL_DATABASEilletve azok olvasási értékeiből. Ezek a környezeti változók titkos értékekre képeznek le, amelyek az adatbázis kapcsolati adatait tárolják. Biztonsági okokból automatikusan létre lesznek hozva a Service Connector jelszó nélküli bővítményével, ahogyan a cikkben máshol is látható.

# 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-konfiguráció

Vizsgálja meg az alábbi Kubernetes-konfigurációs változókat. service-type az alkalmazás külső elérésére van beállítva load-balancer . Cserélje le az előző szakaszban másolt tényleges értékek értékeit <service-account-name> és <secret-name> értékeit.

# 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

A többi Kubernetes-konfiguráció megadja a titkos értékek leképezését a Quarkus-alkalmazás környezeti változóihoz. A <secret-name> titkos kód tartalmazza az adatbázis kapcsolati adatait. A AZURE_POSTGRESQL_CLIENTID, AZURE_POSTGRESQL_HOST, AZURE_POSTGRESQL_PORT, AZURE_POSTGRESQL_DATABASEés AZURE_POSTGRESQL_USERNAME kulcsok a titkos leképezésben a AZURE_CLIENT_ID, AZURE_POSTGRESQL_HOST, AZURE_POSTGRESQL_PORT, AZURE_POSTGRESQL_DATABASE, és AZURE_POSTGRESQL_USERNAME környezeti változókra.

Ha közvetlenül kubectl használatával szeretné megvizsgálni a titkos kulcsokat, használja az alábbi példához hasonló parancsokat:

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

Tárolórendszerkép konfigurálása

Natív felhőtechnológiaként a Quarkus támogatja a Dockerrel kompatibilis OCI-tárolólemezképek létrehozásának lehetőségét. Cserélje le a környezeti változó értékét <LOGIN_SERVER_VALUE> a ${LOGIN_SERVER} tényleges értékre.

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

Végső ellenőrzésként, amikor elvégzi az application.properties összes szükséges helyettesítését, a karakternek nem lehet előfordulása<. Ha vannak ilyenek, ellenőrizze, hogy elvégezte-e az összes szükséges helyettesítést.

A tárolórendszerkép létrehozása és leküldése a tárolóregisztrációs adatbázisba

Most az alábbi paranccsal hozza létre magát az alkalmazást. Ez a parancs a Kubernetes- és Jib-bővítmények használatával hozza létre a tárolórendszerképet.

quarkus build --no-tests

A kimenetnek a következővel kell végződnie BUILD SUCCESS: . A Kubernetes-jegyzékfájlok a cél/kubernetes fájlban jönnek létre, ahogyan az alábbi példában látható:

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

0 directories, 2 files

Parancssori felülettel docker (CLI) ellenőrizheti, hogy a tároló lemezképe is létrejön-e. A kimenet az alábbi példához hasonlóan néz ki:

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

A tárolórendszerképek leküldése a tárolóregisztrációs adatbázisba az alábbi paranccsal:

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

A kimenetnek a következőképpen kell kinéznie:

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

Most, hogy leküldte az alkalmazást a tárolóregisztrációs adatbázisba, megadhatja az AKS-nek, hogy futtassa az alkalmazást.

A Quarkus-alkalmazás üzembe helyezése az AKS-ben

Az ebben a szakaszban ismertetett lépések bemutatják, hogyan futtathatja a Quarkus mintaalkalmazást a létrehozott Azure-erőforrásokon.

A Kubectl-alkalmazás használata a Quarkus-alkalmazás AKS-ben való üzembe helyezéséhez

Telepítse a Kubernetes-erőforrásokat a parancssor használatával kubectl , ahogyan az a következő példában látható:

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

A kimenetnek a következő példához hasonlóan kell kinéznie:

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

Ellenőrizze, hogy az alkalmazás fut-e az alábbi paranccsal:

kubectl -n $AKS_NS get pods

Ha a STATUS mező értéke nem Runningmást mutat, a folytatás előtt hárítsa el és oldja meg a problémát. Segíthet a podnaplók vizsgálatában az alábbi paranccsal:

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

EXTERNAL-IP Az alábbi paranccsal érheti el a Todo alkalmazást:

kubectl get svc -n ${AKS_NS}

A kimenetnek a következő példához hasonlóan kell kinéznie:

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

A következő paranccsal mentheti a környezeti változó értékét EXTERNAL-IP teljes url-címként:

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

Nyisson meg egy új webböngészőt a következő értékre ${QUARKUS_URL}: . Ezután adjon hozzá egy új teendőelemet a szöveggel Deployed the Todo app to AKS. Jelölje ki az Introduction to Quarkus Todo App elemet befejezettként is.

A RESTful API (/api) elérése az Azure PostgreSQL-adatbázisban tárolt összes teendőelem lekéréséhez, ahogyan az alábbi példában látható:

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

A kimenetnek a következő példához hasonlóan kell kinéznie:

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

Ellenőrizze, hogy az adatbázis frissült-e

Futtassa a következő parancsot annak ellenőrzéséhez, hogy az adatbázis megfelelően lett-e frissítve:

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

Ha a rendszer egy bővítmény telepítésére kéri, válaszoljon az Y válaszra.

A kimenetnek az alábbi példához hasonlóan kell kinéznie, és ugyanazokat az elemeket kell tartalmaznia a Todo alkalmazás grafikus felhasználói felületében és a parancs kimenetében curl korábban:

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

Ha végzett, törölje azt a tűzfalszabályt, amely lehetővé teszi, hogy a helyi IP-cím hozzáférjen a rugalmas Azure Database for PostgreSQL-kiszolgálópéldányhoz az alábbi paranccsal:

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

Az erőforrások eltávolítása

Az Azure-díjak elkerülése érdekében távolítsa el a szükségtelen erőforrásokat. Ha a fürtre már nincs szükség, az az group delete paranccsal távolítsa el az erőforráscsoportot, a tárolószolgáltatást, a tárolóregisztrációs adatbázist és az összes kapcsolódó erőforrást.

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

Érdemes lehet törölni a tárolórendszerképeketpostgres, docker rmi és testcontainers a Quarkus fejlesztői móddal létrehozni.

Következő lépések

• Azure Kubernetes Service
• Kiszolgáló nélküli Java-alkalmazások üzembe helyezése a Quarkus használatával az Azure Functionsben
• Kvarkusz
• Kubernetes-bővítmény
• Jib-beállítások
• Jakarta EE az Azure-ban