Nasazení aplikace v Javě s Quarkus v clusteru Azure Kubernetes Service

Článek
12/18/2024

V tomto článku se dozvíte, jak rychle nasadit Red Hat Quarkus ve službě Azure Kubernetes Service (AKS) pomocí jednoduché aplikace CRUD. Aplikace je seznam úkolů s front-endem JavaScriptu a koncovým bodem REST. Flexibilní server Azure Database for PostgreSQL poskytuje vrstvu trvalosti aplikace. V článku se dozvíte, jak aplikaci otestovat místně a nasadit ji do AKS.

Požadavky

Pokud ještě nemáte předplatné Azure, vytvořte si bezplatný účet Azure před tím, než začnete.
Připravte místní počítač s nainstalovaným operačním systémem Unix , například Ubuntu, macOS nebo Subsystém Windows pro Linux.
Nainstalujte implementaci Java SE verze 17 nebo novější – například sestavení OpenJDK od Microsoftu.
Nainstalujte Maven verze 3.9.8 nebo vyšší.
Nainstalujte Docker pro váš operační systém.
Nainstalujte jq.
Nainstalujte cURL.
Nainstalujte rozhraní příkazového řádku Quarkus verze 3.12.1 nebo vyšší.
Azure CLI pro prostředí podobná unixovým systémům. Tento článek vyžaduje pouze variantu Bash Azure CLI.
- Vývojář by měl nainstalovat Azure CLI a přihlásit se interaktivně pomocí příkazu az login pro přihlášení k Azure před použitím defaultAzureCredential v kódu.
```
az login
```
  Pokud se chcete ověřit pomocí azure PowerShellu, můžou spustit rutinu Connect-AzAccount. Ve výchozím nastavení, jako je Azure CLI, Connect-AzAccount spustí výchozí webový prohlížeč pro ověření uživatelského účtu.
```
Connect-AzAccount
```
  Pokud používáte Visual Studio Code, můžete se také přihlásit k Azure pomocí rozšíření účtu Azure.
- Tento článek vyžaduje aspoň verzi 2.61.0 Azure CLI.

Vytvoření projektu aplikace

Pomocí následujícího příkazu naklonujte ukázkový projekt Java pro tento článek. Ukázka je na GitHubu.

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

Pokud se zobrazí zpráva o tom, že je v odpojeném stavu HEAD , je tato zpráva v bezpečí ignorovat. Vzhledem k tomu, že tento článek nevyžaduje potvrzení, je vhodné odpojit stav HEAD.

Místní testování aplikace Quarkus

Kroky v této části ukazují, jak aplikaci spustit místně.

Quarkus podporuje automatické zřizování nekonfigurovaných služeb ve vývojovém a testovacím režimu. Quarkus se na tuto funkci odkazuje jako na vývojové služby. Řekněme, že zahrnete funkci Quarkus, například připojení k databázové službě. Chcete aplikaci otestovat, ale ještě jste nenakonfigurovali připojení k reálné databázi. Quarkus automaticky spustí kontejnerizovanou verzi zástupných procedur příslušné služby a připojí k ní vaši aplikaci. Další informace najdete v tématu Přehled služby Dev Services v dokumentaci k Quarkus.

Ujistěte se, že je vaše prostředí kontejneru spuštěné, a pomocí následujícího příkazu přejděte do vývojového režimu Quarkus:

quarkus dev

quarkus devMísto toho můžete s Mavenem dosáhnout totéž pomocí mvn quarkus:dev.

Může se zobrazit dotaz, jestli chcete odesílat telemetrii využití vývojového režimu Quarkus. Pokud ano, odpovězte tak, jak chcete.

Režim vývoje Quarkus umožňuje živé opětovné načítání s kompilací na pozadí. Pokud upravíte jakýkoli aspekt zdrojového kódu aplikace a aktualizujete prohlížeč, uvidíte změny. Pokud dojde k problémům s kompilací nebo nasazením, zobrazí se chybová stránka s informacemi. Režim vývoje Quarkus naslouchá ladicímu programu na portu 5005. Pokud chcete počkat na připojení ladicího programu před spuštěním, předejte -Dsuspend ho na příkazovém řádku. Pokud ladicí program vůbec nechcete, můžete použít -Ddebug=false.

Výstup by měl vypadat jako v následujícím příkladu:

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

Stiskněte klávesu w na terminálu, kde běží vývojový režim Quarkus. Klávesa w otevře výchozí webový prohlížeč pro zobrazení Todo aplikace. K grafickému uživatelskému rozhraní http://localhost:8080 aplikace můžete přistupovat také přímo.

Zkuste vybrat několik položek úkolů v seznamu úkolů. Uživatelské rozhraní označuje výběr pomocí přeškrtnutého stylu textu. Novou položku seznamu úkolů můžete přidat také zadáním příkazu Ověřit aplikace todo a stisknutím klávesy Enter, jak je znázorněno na následujícím snímku obrazovky:

Přístup k rozhraní RESTful API (/api) a získejte všechny položky úkolů, které se ukládají v místní databázi PostgreSQL:

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

Výstup by měl vypadat jako v následujícím příkladu:

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

Stisknutím klávesy q ukončete vývojový režim Quarkus.

Vytvoření prostředků Azure pro spuštění aplikace Quarkus

Kroky v této části ukazují, jak vytvořit následující prostředky Azure pro spuštění ukázkové aplikace Quarkus:

Flexibilní server Azure Database for PostgreSQL
Azure Container Registry
Azure Kubernetes Service (AKS)

Poznámka:

Tento článek zakáže ověřování PostgreSQL a ilustruje osvědčené postupy zabezpečení. K ověření připojení k serveru se používá ID Microsoft Entra. Pokud potřebujete povolit ověřování PostgreSQL, přečtěte si rychlý start: Použití Javy a JDBC s flexibilním serverem Azure Database for PostgreSQL a výběrem karty Heslo .

Některé z těchto prostředků musí mít jedinečné názvy v rozsahu předplatného Azure. K zajištění této jedinečnosti můžete použít iniciály, posloupnost, datum, vzor přípony . Pokud chcete tento vzor použít, pojmenujte prostředky uvedením iniciály, určitého pořadového čísla, dnešního data a nějaké přípony specifické pro prostředek – například rg "skupina prostředků". Tento vzor používají následující proměnné prostředí. Nahraďte zástupné hodnoty UNIQUE_VALUE a LOCATION vlastními hodnotami a pak v terminálu spusťte následující příkazy:

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

Vytvoření flexibilního serveru Azure Database for PostgreSQL

Flexibilní server Azure Database for PostgreSQL je plně spravovaná databázová služba navržená tak, aby poskytovala podrobnější kontrolu a flexibilitu nad funkcemi správy databází a nastavením konfigurace. V této části se dozvíte, jak vytvořit instanci flexibilního serveru Azure Database for PostgreSQL pomocí Azure CLI.

Nejprve pomocí následujícího příkazu vytvořte skupinu prostředků, která bude obsahovat databázový server a další prostředky:

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

Dále pomocí následujícího příkazu vytvořte instanci flexibilního serveru Azure Database for PostgreSQL:

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

Vytvoření serveru, databáze, uživatele správce a pravidel brány firewall trvá několik minut. Pokud je příkaz úspěšný, výstup vypadá podobně jako v následujícím příkladu:

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

Místní testování aplikace s flexibilním serverem Azure Database for PostgreSQL

V předchozí části jste aplikaci Quarkus otestovali místně ve vývojovém režimu s databází PostgreSQL zřízenou jako kontejner Dockeru. Teď otestujte místní připojení k instanci flexibilního serveru Azure Database for PostgreSQL.

Nejprve pomocí následujících příkazů přidejte aktuální přihlášeného uživatele jako správce Microsoft Entra do instance flexibilního serveru Azure Database for PostgreSQL:

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)

Úspěšný výstup je objekt JSON včetně vlastnosti "type": "Microsoft.DBforPostgreSQL/flexibleServers/administrators".

Dále přidejte místní IP adresu do pravidel brány firewall instance flexibilního serveru Azure Database for PostgreSQL pomocí následujícího postupu:

Získejte místní IP adresu vašeho počítače, na kterém spouštíte aplikaci Quarkus místně. Navštivte například https://whatismyipaddress.com adresu veřejné IP adresy v4.
Definujte proměnnou prostředí s místní IP adresou, kterou jste získali v předchozím kroku.
```
export AZ_LOCAL_IP_ADDRESS=<your local IP address>
```

Spuštěním následujícího příkazu přidejte místní IP adresu do pravidel brány firewall instance flexibilního serveru Azure Database for PostgreSQL:

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

Potom nastavte následující proměnné prostředí v předchozím terminálu. Tyto proměnné prostředí slouží k připojení k instanci flexibilního serveru Azure Database for PostgreSQL z aplikace Quarkus spuštěné místně:

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}

Poznámka:

Hodnoty proměnných AZURE_POSTGRESQL_HOSTprostředí , AZURE_POSTGRESQL_PORT, AZURE_POSTGRESQL_DATABASEa AZURE_POSTGRESQL_USERNAME jsou přečteny vlastnosti konfigurace databáze definované v souboru src/main/resources/application.properties představené v předchozí části. Tyto hodnoty se automaticky vloží do aplikace za běhu pomocí rozšíření bez hesla konektoru služby, když nasadíte aplikaci Quarkus do clusteru AKS dále v tomto článku.

Teď spusťte aplikaci Quarkus místně a otestujte připojení k instanci flexibilního serveru Azure Database for PostgreSQL. Pomocí následujícího příkazu spusťte aplikaci v produkčním režimu:

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

Poznámka:

Pokud se aplikaci nepodaří spustit s chybovou zprávou podobnou ERROR [org.hib.eng.jdb.spi.SqlExceptionHelper] (JPA Startup Thread) Acquisition timeout while waiting for new connectiontéto, je pravděpodobně kvůli nastavení sítě místního počítače. Zkuste znovu vybrat možnost Přidat aktuální IP adresu klienta z webu Azure Portal. Další informace najdete v části Vytvoření pravidla brány firewall po vytvoření serveru v části Vytvoření a správa pravidel brány firewall pro flexibilní server Azure Database for PostgreSQL pomocí webu Azure Portal. Pak aplikaci spusťte znovu.

Otevřete nový webový prohlížeč pro přístup k http://localhost:8080 aplikaci Todo. Měla by se zobrazit aplikace Todo, která vypadá podobně, jako když jste aplikaci spustili místně v režimu vývoje.

Vytvořit instanci služby Azure Container Registry

Vzhledem k tomu, že Quarkus je nativní cloudová technologie, má integrovanou podporu pro vytváření kontejnerů, které běží v Kubernetes. Kubernetes je zcela závislý na tom, že má registr kontejneru, ze kterého najde image kontejneru ke spuštění. AKS má integrovanou podporu služby Azure Container Registry.

Pomocí příkazu az acr create vytvořte instanci registru kontejneru. Následující příklad vytvoří instanci registru kontejneru s názvem s hodnotou proměnné prostředí ${REGISTRY_NAME}:

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

Po krátké době byste měli vidět výstup JSON, který obsahuje následující řádky:

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

Pomocí následujícího příkazu získejte přihlašovací server pro instanci služby Container Registry:

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

Připojení dockeru k instanci registru kontejneru

Přihlaste se k instanci registru kontejneru. Přihlášení umožňuje nasdílení image. Pomocí následujícího příkazu se přihlaste k registru:

az acr login --name $REGISTRY_NAME

Pokud jste se úspěšně přihlásili k instanci registru kontejneru, měli byste vidět Login Succeeded na konci výstupu příkazu.

Vytvoření clusteru AKS

Pomocí příkazu az aks create vytvořte cluster AKS. Následující příklad vytvoří cluster s názvem s hodnotou proměnné ${CLUSTER_NAME} prostředí s jedním uzlem. Cluster je připojený k instanci registru kontejneru, kterou jste vytvořili v předchozím kroku. Dokončení tohoto příkazu trvá několik minut. Cluster se spustí s povolenou spravovanou identitou. Tento krok je nezbytný pro připojení k databázi bez hesla.

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

Po několika minutách se příkaz dokončí a vrátí informace o clusteru ve formátu JSON, včetně následujícího výstupu:

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

Připojení ke clusteru AKS

Ke správě clusteru Kubernetes použijete kubectlklienta příkazového řádku Kubernetes. Pokud chcete nainstalovat kubectl místně, použijte příkaz az aks install-cli , jak je znázorněno v následujícím příkladu:

az aks install-cli

Další informace o kubectlnástroji příkazového řádku (kubectl) najdete v dokumentaci Kubernetes.

Pokud chcete nakonfigurovat kubectl připojení ke clusteru Kubernetes, použijte příkaz az aks get-credentials , jak je znázorněno v následujícím příkladu. Tento příkaz stáhne přihlašovací údaje a nakonfiguruje rozhraní příkazového řádku Kubernetes tak, aby je používalo.

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

Úspěšný výstup obsahuje text podobný následujícímu příkladu:

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

Možná je užitečné aliasovat k kubectl. Pokud ano, použijte následující příkaz:

alias k=kubectl

Pokud chcete ověřit připojení ke clusteru, použijte kubectl get příkaz k vrácení seznamu uzlů clusteru, jak je znázorněno v následujícím příkladu:

kubectl get nodes

Následující příklad výstupu ukazuje jeden uzel vytvořený v předchozích krocích. Ujistěte se, že je stav uzlu připravený:

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

Vytvoření nového oboru názvů v AKS

Pomocí následujícího příkazu vytvořte ve službě Kubernetes nový obor názvů pro vaši aplikaci Quarkus:

kubectl create namespace ${AKS_NS}

Výstup by měl vypadat jako v následujícím příkladu:

namespace/<your namespace> created

Vytvoření připojení služby v AKS pomocí konektoru Service Connector

V této části vytvoříte připojení služby mezi clusterem AKS a flexibilním serverem Azure Database for PostgreSQL pomocí ID úloh Microsoft Entra s konektorem služby. Toto připojení umožňuje clusteru AKS přistupovat k flexibilnímu serveru Azure Database for PostgreSQL bez použití ověřování SQL.

Spuštěním následujících příkazů vytvořte připojení mezi clusterem AKS a databází PostgreSQL pomocí ID úloh Microsoft Entra s konektorem služby:

# 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

Přítomnost následujícího kódu JSON ve výstupu z posledního příkazu v předchozích krocích značí úspěšnou instalaci konektoru služby:

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

Poznámka:

Doporučujeme použít ID úloh Microsoft Entra pro zabezpečený přístup k flexibilnímu serveru Azure Database for PostgreSQL bez použití ověřování pomocí uživatelského jména a hesla. Pokud potřebujete použít ověřování pomocí uživatelského jména nebo hesla, ignorujte předchozí kroky v této části a pro připojení k databázi použijte uživatelské jméno a heslo.

Získání účtu služby a tajného kódu vytvořeného konektorem služby

Pokud se chcete ověřit na flexibilním serveru Azure Database for PostgreSQL, musíte získat účet služby a tajný kód Kubernetes vytvořený konektorem služby. Postupujte podle pokynů v části Kurz aktualizace kontejneru: Připojení aplikace AKS ke službě Azure SQL Database. Použijte možnost Přímé vytvoření nasazení pomocí poskytnutého fragmentu ukázkového kódu YAML a použijte následující krok:

Ze zvýrazněných částí v ukázkovém yaml nasazení Kubernetes zkopírujte hodnoty serviceAccountName secretRef.namea , reprezentované jako <service-account-name> a <secret-name> v následujícím příkladu:
```
serviceAccountName: <service-account-name>
containers:
- name: raw-linux
    envFrom:
       - secretRef:
          name: <secret-name>
```
Tyto hodnoty se používají v další části k nasazení aplikace Quarkus do clusteru AKS.

Přizpůsobení nativní konfigurace cloudu

Jako nativní cloudová technologie nabízí Quarkus možnost automaticky konfigurovat prostředky pro standardní Kubernetes, Red Hat OpenShift a Knative. Další informace najdete v průvodci Quarkus Kubernetes, příručkou Quarkus OpenShift a příručkou Quarkus Knative. Vývojáři mohou aplikaci nasadit do cílového clusteru Kubernetes použitím vygenerovaných manifestů.

Pokud chcete vygenerovat příslušné prostředky Kubernetes, přidejte do quarkus-kubernetes místního terminálu následující příkaz:container-image-jib

quarkus ext add kubernetes container-image-jib

Quarkus upraví POM, aby se zajistilo, že jsou tato rozšíření uvedena jako <dependencies>. Pokud se zobrazí výzva k instalaci s názvem JBang, odpovězte ano a povolte instalaci.

Výstup by měl vypadat jako v následujícím příkladu:

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

Pokud chcete ověřit přidání rozšíření, můžete spustit git diff a prozkoumat výstup.

Jako nativní technologie cloudu podporuje Quarkus pojem konfiguračních profilů. Quarkus má následující tři předdefinované profily:

dev - Aktivováno v režimu vývoje
test - Aktivováno při spouštění testů
prod – Výchozí profil, pokud není spuštěný ve vývojovém nebo testovacím režimu

Quarkus podle potřeby podporuje libovolný počet pojmenovaných profilů.

Zbývající kroky v této části vás nasměruje na přizpůsobení hodnot v souboru src/main/resources/application.properties .

Předpona prod. označuje, že tyto vlastnosti jsou aktivní při spuštění v prod profilu. Další informace o konfiguračních profilech najdete v dokumentaci k Quarkus.

Konfigurace databáze

Prozkoumejte následující proměnné konfigurace databáze. Vlastnosti %prod.quarkus.datasource.jdbc.url související s připojením k databázi a %prod.quarkus.datasource.username čtení hodnot z proměnných AZURE_POSTGRESQL_HOSTprostředí , AZURE_POSTGRESQL_PORT, AZURE_POSTGRESQL_DATABASEa AZURE_POSTGRESQL_USERNAME, v uvedeném pořadí. Tyto proměnné prostředí se mapují na tajné hodnoty, které ukládají informace o připojení k databázi. Z bezpečnostních důvodů se automaticky vygenerují pomocí rozšíření bez hesla konektoru služby, jak je znázorněno jinde v tomto článku.

# 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

Konfigurace Kubernetes

Prozkoumejte následující proměnné konfigurace Kubernetes. service-type je nastavená na load-balancer externí přístup k aplikaci. Nahraďte hodnoty <service-account-name> a <secret-name> hodnotami skutečných hodnot, které jste zkopírovali v předchozí části.

# 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

Ostatní konfigurace Kubernetes určují mapování tajných hodnot na proměnné prostředí v aplikaci Quarkus. Tajný <secret-name> klíč obsahuje informace o připojení k databázi. Proměnné AZURE_POSTGRESQL_CLIENTID, , AZURE_POSTGRESQL_PORTAZURE_POSTGRESQL_HOST, AZURE_POSTGRESQL_DATABASEa AZURE_POSTGRESQL_USERNAME klíče v tajné mapě na AZURE_CLIENT_ID, AZURE_POSTGRESQL_HOST, AZURE_POSTGRESQL_PORTAZURE_POSTGRESQL_DATABASE, a AZURE_POSTGRESQL_USERNAME proměnné prostředí, v uvedeném pořadí.

Pokud chcete prozkoumat tajné kódy přímo pomocí kubectl, použijte příkazy podobné následujícímu příkladu:

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

Konfigurace image kontejneru

Jako nativní technologie cloudu podporuje Quarkus generování imagí kontejnerů OCI kompatibilních s Dockerem. Nahraďte hodnotu <LOGIN_SERVER_VALUE> skutečnou hodnotou ${LOGIN_SERVER} proměnné prostředí.

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

Při závěrečné kontrole platí, že po dokončení všech nezbytných nahrazení v souboru application.properties nesmí existovat žádné výskyty znaku < . Pokud ano, pečlivě zkontrolujte, že jste dokončili všechny nezbytné náhrady.

Sestavení image kontejneru a jeho nasdílení do registru kontejneru

Teď pomocí následujícího příkazu sestavte samotnou aplikaci. Tento příkaz používá rozšíření Kubernetes a Jib k sestavení image kontejneru.

quarkus build --no-tests

Výstup by měl končit .BUILD SUCCESS Soubory manifestu Kubernetes se generují v cíli nebo kubernetes, jak je znázorněno v následujícím příkladu:

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

0 directories, 2 files

Pomocí příkazového řádku (CLI) můžete ověřit, jestli se image kontejneru vygeneruje docker . Výstup vypadá podobně jako v následujícím příkladu:

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

Nasdílení imagí kontejneru do registru kontejneru pomocí následujícího příkazu:

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

Výstup by měl vypadat zhruba jako v tomto příkladu:

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

Teď, když jste aplikaci odeslali do registru kontejneru, můžete AKS říct, aby aplikaci spustila.

Nasazení aplikace Quarkus do AKS

Kroky v této části ukazují, jak spustit ukázkovou aplikaci Quarkus na vytvořených prostředcích Azure.

Použití kubectl k nasazení aplikace Quarkus do AKS

Nasaďte prostředky Kubernetes pomocí kubectl příkazového řádku, jak je znázorněno v následujícím příkladu:

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

Výstup by měl vypadat jako v následujícím příkladu:

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

Pomocí následujícího příkazu ověřte, že je aplikace spuštěná:

kubectl -n $AKS_NS get pods

Pokud hodnota pole zobrazuje něco jiného STATUS než Running, před pokračováním problém vyřešte a vyřešte problém. Může vám pomoct prozkoumat protokoly podů pomocí následujícího příkazu:

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

EXTERNAL-IP Pomocí následujícího příkazu získejte přístup k aplikaci Todo:

kubectl get svc -n ${AKS_NS}

Výstup by měl vypadat jako v následujícím příkladu:

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

Pomocí následujícího příkazu můžete uložit hodnotu EXTERNAL-IP proměnné prostředí jako plně kvalifikovanou adresu URL:

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

Otevřete nový webový prohlížeč s hodnotou ${QUARKUS_URL}. Potom přidejte novou položku úkolu s textem Deployed the Todo app to AKS. Introduction to Quarkus Todo App Vyberte také položku jako dokončenou.

Přístup k rozhraní RESTful API (/api) a získejte všechny položky úkolů uložené v databázi Azure PostgreSQL, jak je znázorněno v následujícím příkladu:

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

Výstup by měl vypadat jako v následujícím příkladu:

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

Ověřte, že je databáze aktualizovaná.

Spuštěním následujícího příkazu ověřte, že je databáze aktualizována správně:

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

Pokud se zobrazí výzva k instalaci rozšíření, odpovězte na Y.

Výstup by měl vypadat podobně jako v následujícím příkladu a měl by obsahovat stejné položky v grafickém curl uživatelském rozhraní aplikace Todo a výstup příkazu dříve:

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

Po dokončení odstraňte pravidlo brány firewall, které umožňuje místní IP adrese přistupovat k instanci flexibilního serveru Azure Database for PostgreSQL pomocí následujícího příkazu:

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

Vyčištění prostředků

Abyste se vyhnuli poplatkům za Azure, měli byste vyčistit nepotřebné prostředky. Pokud už cluster nepotřebujete, pomocí příkazu az group delete odeberte skupinu prostředků, službu kontejneru, registr kontejneru a všechny související prostředky.

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

Můžete také použít docker rmi k odstranění imagí postgres kontejneru a testcontainers vygenerovaných vývojovými režimy Quarkus.

Sdílet prostřednictvím

Nasazení aplikace v Javě s Quarkus v clusteru Azure Kubernetes Service

Požadavky

Vytvoření projektu aplikace

Místní testování aplikace Quarkus

Vytvoření prostředků Azure pro spuštění aplikace Quarkus

Vytvoření flexibilního serveru Azure Database for PostgreSQL

Místní testování aplikace s flexibilním serverem Azure Database for PostgreSQL

Vytvořit instanci služby Azure Container Registry

Připojení dockeru k instanci registru kontejneru

Vytvoření clusteru AKS

Připojení ke clusteru AKS

Vytvoření nového oboru názvů v AKS

Vytvoření připojení služby v AKS pomocí konektoru Service Connector

Získání účtu služby a tajného kódu vytvořeného konektorem služby

Přizpůsobení nativní konfigurace cloudu

Konfigurace databáze

Konfigurace Kubernetes

Konfigurace image kontejneru

Sestavení image kontejneru a jeho nasdílení do registru kontejneru

Nasazení aplikace Quarkus do AKS

Použití kubectl k nasazení aplikace Quarkus do AKS

Ověřte, že je databáze aktualizovaná.

Vyčištění prostředků

Další kroky

Další materiály