Share via

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

  • Článek

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. 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.
  • Služba Azure Cloud Shell má všechny tyto předpoklady předinstalované. Další informace najdete v rychlém startu pro Azure Cloud Shell.
  • Pokud příkazy v této příručce spouštíte místně (místo použití Azure Cloud Shellu), proveďte následující kroky:
    • 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 (například sestavení OpenJDK od Microsoftu).
    • Nainstalujte Maven 3.5.0 nebo novější.
    • Nainstalujte Docker nebo Podman pro váš operační systém.
    • Nainstalujte jq.
    • Nainstalujte cURL.
    • Nainstalujte rozhraní příkazového řádku Quarkus.
  • 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
    • Tento článek vyžaduje aspoň verzi 2.31.0 Azure CLI. Pokud používáte Azure Cloud Shell, je už nainstalovaná nejnovější verze.

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 2023-07-17
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í 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, Docker nebo Podman 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 telemetrická data o 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.

Snímek obrazovky ukázkové aplikace Todo

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:

Snímek obrazovky ukázkové aplikace Todo s přidanými novými položkami

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:

  • Azure Database for PostgreSQL
  • Azure Container Registry (ACR)
  • Azure Kubernetes Service (AKS)

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ů". Pomocí následujících příkazů definujte některé proměnné prostředí, které se mají použít později:

export UNIQUE_VALUE=<your unique value, such as ejb010717>
export RESOURCE_GROUP_NAME=${UNIQUE_VALUE}rg
export LOCATION=<your desired Azure region for deploying your resources. For example, eastus>
export REGISTRY_NAME=${UNIQUE_VALUE}reg
export DB_SERVER_NAME=${UNIQUE_VALUE}db
export CLUSTER_NAME=${UNIQUE_VALUE}aks
export AKS_NS=${UNIQUE_VALUE}ns

Vytvoření Azure Database for PostgreSQL

Azure Database for PostgreSQL je spravovaná služba pro spouštění, správu a škálování vysoce dostupných databází PostgreSQL v cloudu Azure. Tato část vás nasměruje na samostatný rychlý start, který ukazuje, jak vytvořit jeden server Azure Database for PostgreSQL a jak se k němu připojit. Pokud ale budete postupovat podle kroků v rychlém startu, musíte použít nastavení v následující tabulce k přizpůsobení nasazení databáze pro ukázkovou aplikaci Quarkus. Proměnné prostředí nahraďte jejich skutečnými hodnotami při vyplňování polí na webu Azure Portal.

Nastavení Hodnota Popis
Skupina prostředků ${RESOURCE_GROUP_NAME} Vyberte, že chcete vytvořit novou IP adresu. Nasazení vytvoří tuto novou skupinu prostředků.
Název serveru ${DB_SERVER_NAME} Tato hodnota je součástí názvu hostitele databázového serveru.
Umístění ${LOCATION} V rozevíracím seznamu vyberte umístění. Poznamenejte si umístění. Musíte použít stejné umístění pro další prostředky Azure, které vytvoříte.
Uživatelské jméno správce quarkus Vzorový kód předpokládá tuto hodnotu.
Heslo Tajný kód123456 Vzorový kód předpokládá tuto hodnotu.

S ohledem na tyto náhrady hodnot postupujte podle kroků v rychlém startu: Vytvoření serveru Azure Database for PostgreSQL pomocí webu Azure Portal až do části Konfigurace pravidla brány firewall. Potom v části Konfigurace pravidla brány firewall nezapomeňte vybrat Ano pro povolení přístupu ke službám Azure a pak vyberte Uložit. Pokud to neuděláte, vaše aplikace Quarkus nemůže získat přístup k databázi a jednoduše se nikdy nespustí.

Po dokončení kroků v rychlém startu v části Konfigurace pravidla brány firewall, včetně kroku povolení přístupu ke službám Azure, se vraťte do tohoto článku.

Vytvoření databáze todo v PostgreSQL

Server PostgreSQL, který jste vytvořili dříve, je prázdný. Nemá žádnou databázi, kterou můžete použít s aplikací Quarkus. Vytvořte novou databázi volanou todo pomocí následujícího příkazu:

az postgres db create \
    --resource-group ${RESOURCE_GROUP_NAME} \
    --name todo \
    --server-name ${DB_SERVER_NAME}

Musíte použít todo jako název databáze, protože vzorový kód předpokládá, že název databáze.

Pokud je příkaz úspěšný, výstup vypadá podobně jako v následujícím příkladu:

{
  "charset": "UTF8",
  "collation": "English_United States.1252",
  "id": "/subscriptions/REDACTED/resourceGroups/ejb010718rg/providers/Microsoft.DBforPostgreSQL/servers/ejb010718db/databases/todo",
  "name": "todo",
  "resourceGroup": "ejb010718rg",
  "type": "Microsoft.DBforPostgreSQL/servers/databases"
}

Vytvoření instance služby Microsoft 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 (ACR).

K vytvoření instance ACR použijte příkaz az acr create. Následující příklad vytvoří instanci ACR s hodnotou proměnné prostředí ${REGISTRY_NAME}:

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

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

Připojení do instance ACR do dockeru

Přihlaste se k instanci ACR. Přihlášení umožňuje nasdílení image. Pomocí následujících příkazů ověřte připojení:

export LOGIN_SERVER=$(az acr show \
    --name $REGISTRY_NAME \
    --query 'loginServer' \
    --output tsv)
echo $LOGIN_SERVER
export USER_NAME=$(az acr credential show \
    --name $REGISTRY_NAME \
    --query 'username' \
    --output tsv)
echo $USER_NAME
export PASSWORD=$(az acr credential show \
    --name $REGISTRY_NAME \
    --query 'passwords[0].value' \
    --output tsv)
echo $PASSWORD
docker login $LOGIN_SERVER -u $USER_NAME -p $PASSWORD

Pokud místo Dockeru používáte Podman, proveďte potřebné změny příkazu.

Pokud jste se úspěšně přihlásili k instanci ACR, 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 služby ACR, kterou jste vytvořili v předchozím kroku. Dokončení tohoto příkazu trvá několik minut.

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

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í do clusteru AKS

Ke správě clusteru Kubernetes použijete kubectlklienta příkazového řádku Kubernetes. Pokud používáte Azure Cloud Shell, kubectl je už nainstalovaný. 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 kkubectl. 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.23.8

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

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 zrušení komentáře a přizpůsobení hodnot v souboru src/main/resources/application.properties . Ujistěte se, že všechny řádky začínající # %prod. na začátku jsou nekommentovány odebráním úvodních #řádků .

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

Přidejte následující konfigurační proměnné databáze. Nahraďte hodnoty <DB_SERVER_NAME_VALUE> skutečnými hodnotami ${DB_SERVER_NAME} proměnné prostředí.

# Database configurations
%prod.quarkus.datasource.db-kind=postgresql
%prod.quarkus.datasource.jdbc.url=jdbc:postgresql://<DB_SERVER_NAME_VALUE>.postgres.database.azure.com:5432/todo
%prod.quarkus.datasource.jdbc.driver=org.postgresql.Driver
%prod.quarkus.datasource.username=quarkus@<DB_SERVER_NAME_VALUE>
%prod.quarkus.datasource.password=Secret123456
%prod.quarkus.hibernate-orm.database.generation=drop-and-create

Konfigurace Kubernetes

Přidejte následující proměnné konfigurace Kubernetes. Nezapomeňte nastavit service-type přístup k load-balancer aplikaci externě.

# AKS configurations
%prod.quarkus.kubernetes.deployment-target=kubernetes
%prod.quarkus.kubernetes.service-type=load-balancer

Konfigurace image kontejneru

Jako nativní technologie cloudu podporuje Quarkus generování imagí kontejnerů OCI kompatibilních s Dockerem a Podmanem. Přidejte následující proměnné image kontejneru. Nahraďte hodnoty <LOGIN_SERVER_VALUE> a <USER_NAME_VALUE> hodnotami skutečných hodnot ${LOGIN_SERVER} proměnných prostředí a ${USER_NAME} proměnných prostředí.

# Container Image Build
%prod.quarkus.container-image.build=true
%prod.quarkus.container-image.registry=<LOGIN_SERVER_VALUE>
%prod.quarkus.container-image.group=<USER_NAME_VALUE>
%prod.quarkus.container-image.name=todo-quarkus-aks
%prod.quarkus.container-image.tag=1.0

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

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 podman řádku nebo příkazového řádku můžete ověřit, jestli se image kontejneru vygenerujedocker. Výstup vypadá podobně jako v následujícím příkladu:

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

Nasdílení imagí kontejneru do služby ACR 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>/<USER_NAME_VALUE>/todo-quarkus-aks]
dfd615499b3a: Pushed
56f5cf1aa271: Pushed
4218d39b228e: Pushed
b0538737ed64: Pushed
d13845d85ee5: Pushed
60609ec85f86: Pushed
1.0: digest: sha256:0ffd70d6d5bb3a4621c030df0d22cf1aa13990ca1880664d08967bd5bab1f2b6 size: 1995

Teď, když jste aplikaci nasdíleli do ACR, 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 prostředcích Azure, které jste vytvořili.

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:

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. S prozkoumáním protokolů podů vám může pomoct následující příkaz:

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.

Snímek obrazovky ukázkové aplikace Todo spuštěné v AKS

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ěření aktualizace databáze pomocí Azure Cloud Shellu

Otevřete Azure Cloud Shell na webu Azure Portal výběrem ikony Cloud Shellu , jak je znázorněno na následujícím snímku obrazovky:

Snímek obrazovky webu Azure Portal se zvýrazněným tlačítkem Cloud Shell

Spusťte místně následující příkaz a vložte výsledek do Azure Cloud Shellu:

echo psql --host=${DB_SERVER_NAME}.postgres.database.azure.com --port=5432 --username=quarkus@${DB_SERVER_NAME} --dbname=todo

Po zobrazení výzvy k zadání hesla použijte hodnotu, kterou jste použili při vytváření databáze.

Pomocí následujícího dotazu získejte všechny položky úkolů:

select * from todo;

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 uživatelském rozhraní aplikace Todo zobrazeném dříve:

Snímek obrazovky s výstupem dotazu jako tabulkou ASCII

Pokud se zobrazí MORE ve výstupu, zadáním q ukončete pager.

Zadáním \q ukončete psql program a vraťte se do Cloud Shellu.

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 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.

Další kroky