Partager via

Déployer une application Java avec Quarkus sur un cluster Azure Kubernetes Service (AKS)

  • Article

Cet article vous montre comment déployer rapidement Red Hat Quarkus sur Azure Kubernetes Service (AKS) avec une application CRUD simple. L’application est une « liste de tâches » avec un front-end JavaScript et un point de terminaison REST. Azure Database pour PostgreSQL – Serveur flexible fournit la couche de persistance pour l’application. L’article vous montre comment tester votre application localement et la déployer sur AKS.

Prérequis

  • Si vous n’avez pas d’abonnement Azure, créez un compte gratuit Azure avant de commencer.
  • Préparez une machine locale avec un système d’exploitation de type UNIX installé (par exemple Ubuntu, macOS ou Sous-système Windows pour Linux).
  • Installez une implémentation de Java SE version 17 ou ultérieure, par exemple la build Microsoft d’OpenJDK.
  • Installez Maven version 3.9.8 ou ultérieure.
  • Installez Docker ou Podman pour votre système d’exploitation.
  • Installez jq.
  • Installez cURL.
  • Installez l’interface CLI de Quarkus version 3.12.1 ou ultérieure.
  • Interface de ligne de commande Azure (Azure CLI) pour les environnements de type Unix. Cet article requiert uniquement la variante Bash d’Azure CLI.
    • Un développeur doit installer Azure CLI et se connecter de manière interactive avec la commande az login pour se connecter à Azure avant d’utiliser DefaultAzureCredential dans le code. 
      az login
    • Cet article nécessite au moins la version 2.61.0 d’Azure CLI.

Création du projet d’application

Utilisez la commande suivante pour cloner l’exemple de projet Java pour cet article. L’exemple se trouve sur GitHub.

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

Si un message vous signale que vous allez passer à l’état detached HEAD, vous pouvez ignorer ce message sans risque. Étant donné que cet article ne nécessite aucune validation, l’état détaché HEAD est approprié.

Tester votre application Quarkus localement

Les étapes de cette section vous montrent comment exécuter l’application localement.

Quarkus prend en charge l’approvisionnement automatique de services non configurés en mode développement et test. Quarkus fait référence à cette fonctionnalité en tant que services de développement. Supposons que vous incluiez une fonctionnalité Quarkus, telle que la connexion à un service de base de données. Vous souhaitez tester l’application, mais vous n’avez pas encore entièrement configuré la connexion à une base de données réelle. Quarkus démarre automatiquement une version stub du service approprié et y connecte votre application. Pour plus d’informations, consultez Vue d’ensemble de Dev Services dans la documentation de Quarkus.

Vérifiez que votre environnement de conteneur, Docker ou Podman, est en cours d’exécution et utilisez la commande suivante pour passer en mode de développement Quarkus :

quarkus dev

Au lieu de quarkus dev, vous pouvez effectuer la même chose avec Maven à l’aide de mvn quarkus:dev.

Vous serez peut-être invité à envoyer des données de télémétrie de votre utilisation du mode de développement Quarkus. Si c’est le cas, répondez comme vous le souhaitez.

Le mode de développement Quarkus permet le rechargement en direct avec la compilation en arrière-plan. Si vous modifiez un aspect du code source de votre application et actualisez votre navigateur, vous pouvez voir les modifications. En cas de problèmes de compilation ou de déploiement, une page d’erreur vous en informera. Le mode de développement Quarkus écoute un débogueur sur le port 5005. Si vous souhaitez attendre que le débogueur s’attache avant de l’exécuter, entrez -Dsuspend dans la ligne de commande. Si vous ne souhaitez pas du tout le débogueur, vous pouvez utiliser -Ddebug=false.

La sortie doit ressembler à cet exemple :

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

Appuyez sur w sur le terminal où le mode de développement Quarkus est en cours d’exécution. La touche w ouvre votre navigateur web par défaut pour afficher l’application Todo. Vous pouvez également accéder directement à l’interface graphique utilisateur de l’application via http://localhost:8080.

Capture d’écran de l’exemple d’application Todo.

Essayez de sélectionner quelques éléments todo dans la liste des tâches. L’interface utilisateur indique la sélection avec un style de texte barré. Vous pouvez également ajouter un nouvel élément todo à la liste de tâches en tapant Vérifier les applications todo et en appuyant sur Entrée, comme illustré dans la capture d’écran suivante :

Capture d’écran de l’exemple d’application Todo avec de nouveaux objets ajoutés.

Accédez à l’API RESTful (/api) pour obtenir tous les éléments todo qui stockent dans la base de données PostgreSQL locale :

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

La sortie doit ressembler à cet exemple :

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

Appuyez sur q pour quitter le mode dev Quarkus.

Créer les ressources Azure pour exécuter l’application Quarkus

Les étapes de cette section vous montrent comment créer les ressources Azure suivantes pour exécuter l’exemple d’application Quarkus :

  • Azure Database pour PostgreSQL – Serveur flexible
  • Azure Container Registry (ACR)
  • Azure Kubernetes Service (AKS)

Certaines de ces ressources doivent avoir des noms uniques dans l’étendue de l’abonnement Azure. Pour garantir cette unicité, vous pouvez utiliser les modèles initiales, séquence, date et suffixe. Pour appliquer ce modèle, nommez vos ressources en répertoriant vos initiales, un numéro de séquence, la date du jour et un certain type de suffixe spécifique à la ressource, par exemple, rg pour « groupe de ressources ». Les variables d’environnement suivantes utilisent ce modèle. Remplacez les valeurs des espaces réservés UNIQUE_VALUE, LOCATION et DB_PASSWORD par vos propres valeurs, puis exécutez les commandes suivantes dans votre terminal :

export UNIQUE_VALUE=<your unique value, such as ejb010717>
export RESOURCE_GROUP_NAME=${UNIQUE_VALUE}rg
export LOCATION=<your desired Azure region for deploying your resources - for example, northeurope>
export REGISTRY_NAME=${UNIQUE_VALUE}reg
export DB_SERVER_NAME=${UNIQUE_VALUE}db
export DB_NAME=demodb
export DB_ADMIN=demouser
export DB_PASSWORD='<your desired password for the database server - for example, Secret123456>'
export CLUSTER_NAME=${UNIQUE_VALUE}aks
export AKS_NS=${UNIQUE_VALUE}ns

Créer un serveur flexible Azure Database pour PostgreSQL

Un serveur flexible Azure Database pour PostgreSQL est un service de base de données entièrement géré conçu pour offrir un contrôle et une flexibilité plus granulaires des fonctions de gestion de base de données et des paramètres de configuration. Cette section vous montre comment créer une instance Azure Database pour PostgreSQL – Serveur flexible en utilisant Azure CLI. Pour plus d’informations, consultez Démarrage rapide : Créer une instance Azure Database pour PostgreSQL – Serveur flexible en utilisant Azure CLI.

Tout d’abord, créez un groupe de ressources destiné à contenir le serveur de base de données et d’autres ressources en utilisant la commande suivante :

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

Ensuite, créez une instance Azure Database pour PostgreSQL – Serveur flexible en utilisant la commande suivante :

az postgres flexible-server create \
    --name $DB_SERVER_NAME \
    --resource-group $RESOURCE_GROUP_NAME \
    --admin-user $DB_ADMIN \
    --admin-password $DB_PASSWORD \
    --database-name $DB_NAME \
    --public-access 0.0.0.0 \
    --yes

La création du serveur, de la base de données, de l’utilisateur administrateur et des règles de pare-feu prend quelques minutes. Si la commande réussit, la sortie ressemble à l’exemple suivant :

{
  "connectionString": "postgresql://<DB_ADMIN>:<DB_PASSWORD>@<DB_SERVER_NAME>.postgres.database.azure.com/<DB_NAME>?sslmode=require",
  "databaseName": "<DB_NAME>",
  "firewallName": "AllowAllAzureServicesAndResourcesWithinAzureIps_2024-7-5_14-39-45",
  "host": "<DB_SERVER_NAME>.postgres.database.azure.com",
  "id": "/subscriptions/REDACTED/resourceGroups/<RESOURCE_GROUP_NAME>/providers/Microsoft.DBforPostgreSQL/flexibleServers/<DB_SERVER_NAME>",
  "location": "North Europe",
  "password": "<DB_PASSWORD>",
  "resourceGroup": "<RESOURCE_GROUP_NAME>",
  "skuname": "Standard_D2s_v3",
  "username": "<DB_ADMIN>",
  "version": "13"
}

Créer une instance Azure Container Registry

Comme Quarkus est une technologie native cloud, elle dispose d’une prise en charge intégrée pour la création de conteneurs qui s’exécutent dans Kubernetes. Kubernetes dépend entièrement de son registre de conteneurs à partir duquel il trouve les images conteneur à exécuter. AKS prend en charge Azure Container Registry (ACR).

Utilisez la commande az acr create pour créer l’instance ACR. L’exemple suivant crée une instance ACR nommée d’après la valeur de votre variable d’environnement ${REGISTRY_NAME} :

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

Après un bref laps de temps, vous devriez voir la sortie JSON qui contient les lignes suivantes :

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

Connectez votre docker à votre instance ACR

Connectez-vous à l’instance ACR. La connexion vous permet d’envoyer (push) une image. Utilisez les commandes suivantes pour vérifier la connexion :

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

Si vous utilisez Podman au lieu de Docker, apportez les modifications nécessaires à la commande.

Si vous êtes bien connecté à l’instance ACR, vous devez voir Login Succeeded à la fin de la sortie de la commande.

Créer un cluster AKS

Utilisez la commande az aks create pour créer un cluster AKS. L’exemple suivant crée une instance ACR nommée avec la valeur de votre variable d’environnement ${CLUSTER_NAME}avec un nœud. Le cluster est connecté à l’instance ACR que vous avez créée lors de l’étape précédente. Cette commande prend plusieurs minutes à s’exécuter.

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

Au bout de quelques minutes, la commande se termine et retourne des informations au format JSON sur le cluster, dont la sortie suivante :

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

Se connecter au cluster AKS

Pour gérer un cluster Kubernetes, vous utilisez kubectl, le client de ligne de commande Kubernetes. Pour installer kubectl localement, utilisez la commande az aks install-cli, comme illustré dans l’exemple suivant :

az aks install-cli

Pour plus d’informations sur kubectl, consultez Outil de ligne de commande (kubectl) dans la documentation Kubernetes.

Pour configurer kubectl afin de vous connecter à votre cluster Kubernetes, exécutez la commande az aks get-credentials comme illustré dans l’exemple suivant. Cette commande télécharge les informations d’identification et configure l’interface CLI Kubernetes pour les utiliser.

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

Une sortie réussie ressemble à ce qui suit :

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

Vous trouverez peut-être utile de créer l’alias k à kubectl. Dans ce cas, utilisez la commande suivante :

alias k=kubectl

Pour vérifier la connexion à votre cluster, utilisez la commande kubectl get pour retourner une liste des nœuds du cluster, comme illustré dans l’exemple suivant :

kubectl get nodes

L’exemple de sortie suivant montre le nœud unique créé au cours des étapes précédentes. Vérifiez que l’état du nœud est Ready :

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

Créer un espace de noms dans AKS

Utilisez la commande suivante pour créer un espace de noms dans votre service Kubernetes pour votre application Quarkus :

kubectl create namespace ${AKS_NS}

La sortie doit ressembler à cet exemple :

namespace/<your namespace> created

Créer un secret pour la connexion de base de données dans AKS

Créez un secret db-secret dans l’espace de noms AKS pour stocker les informations de connexion de base de données. Utilisez la commande suivante pour créer le secret :

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

La sortie doit ressembler à cet exemple :

secret/db-secret created

Personnaliser la configuration native cloud

En tant que technologie native cloud, Quarkus offre la possibilité de configurer automatiquement des ressources pour Kubernetes standard, Red Hat OpenShift et Knative. Pour plus d’informations, consultez le guide Kubernetes de Quarkus, le guide OpenShift de Quarkus et le guide Knative de Quarkus. Les développeurs peuvent déployer l’application sur un cluster Kubernetes cible en appliquant les manifestes générés.

Pour générer les ressources Kubernetes appropriées, utilisez la commande suivante pour ajouter les extensions quarkus-kubernetes et container-image-jib dans votre terminal local :

quarkus ext add kubernetes container-image-jib

Quarkus modifie le POM pour s’assurer que ces extensions sont répertoriées en tant que <dependencies>. Si vous êtes invité à installer un élément appelé JBang, répondez oui et autorisez-le à être installé.

La sortie doit ressembler à cet exemple :

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

Pour vérifier que les extensions sont ajoutées, vous pouvez exécuter git diff et examiner la sortie.

En tant que technologie native cloud, Quarkus prend en charge la notion de profils de configuration. Quarkus dispose des trois profils intégrés suivants :

  • dev – Activé en mode développement
  • test – Activé lors de l’exécution de tests
  • prod – Profil par défaut en cas de non-exécution en mode développement ou test

Quarkus prend en charge n’importe quel nombre de profils nommés, selon les besoins.

Les étapes restantes de cette section vous dirigent vers la suppression des marques de commentaire et la personnalisation des valeurs dans le fichier src/main/resources/application.properties. Assurez-vous que toutes les lignes commençant par # %prod. ne sont pas commentées en supprimant le premier #.

Le préfixe prod. indique que ces propriétés sont actives lors de l’exécution dans le profil prod. Pour plus d’informations sur les profils de configuration, consultez la documentation de Quarkus.

Configuration de la base de données

Ajoutez les variables de configuration de base de données suivantes. Les propriétés associées à la connexion de base de données %prod.quarkus.datasource.jdbc.url, %prod.quarkus.datasource.username et %prod.quarkus.datasource.password lisent les valeurs des variables d’environnement DB_JDBC_URL, DB_USERNAME et DB_PASSWORD, respectivement. Ces variables d’environnement correspondent aux valeurs des secrets qui stockent les informations de connexion de base de données pour des raisons de sécurité, qui sont décrites dans la section suivante.

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

Configuration Kubernetes

Ajoutez les variables de configuration Kubernetes suivantes. Veillez à définir service-type sur load-balancer pour accéder à l’application en externe.

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

Les autres configurations Kubernetes spécifient le mappage des valeurs des secrets aux variables d’environnement dans l’application Quarkus. Le secret db-secret contient les informations de connexion de base de données. Les clés jdbcurl, dbusernameet dbpassword du secret sont mappées aux variables d’environnement DB_JDBC_URL, DB_USERNAME et DB_PASSWORD, respectivement.

Configuration de l’image conteneur

En tant que technologie cloud native, Quarkus prend en charge la génération d’images conteneur OCI compatibles avec Docker et Podman. Ajoutez les variables d’image conteneur suivantes. Remplacez les valeurs de <LOGIN_SERVER_VALUE> et <USER_NAME_VALUE> par les valeurs des valeurs réelles des variables d’environnement ${LOGIN_SERVER} et ${USER_NAME}, respectivement.

# 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

Générer l’image conteneur, puis l’envoyer (push) à ACR

Maintenant, exécutez la commande suivante pour générer l’application elle-même. Cette commande utilise les extensions Kubernetes et Jib pour générer l’image conteneur.

quarkus build --no-tests

La sortie doit se terminer par BUILD SUCCESS. Les fichiers manifeste Kubernetes sont générés dans target/kubernetes, comme illustré dans l’exemple suivant :

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

0 directories, 2 files

Vous pouvez vérifier si l’image conteneur est également générée à l’aide de la ligne de commande (CLI) docker ou podman. La sortie ressemble à l’exemple suivant :

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

Envoyez les images conteneur à ACR à l’aide de la commande suivante :

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

La sortie doit être semblable à l’exemple suivant :

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

Maintenant que vous avez envoyé l’application à ACR, vous pouvez indiquer à AKS d’exécuter l’application.

Déployer l’application Quarkus sur AKS

Les étapes de cette section vous montrent comment exécuter l’exemple d’application Quarkus sur les ressources Azure que vous avez créées.

Utiliser « kubectl apply » pour déployer l’application Quarkus sur AKS

Déployez les ressources Kubernetes à l’aide kubectl de la ligne de commande, comme illustré dans l’exemple suivant :

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

La sortie doit ressembler à cet exemple :

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

Vérifiez que l’application est en cours d’exécution à l’aide de la commande suivante :

kubectl -n $AKS_NS get pods

Si la valeur du champ STATUS indique autre chose que Running, résolvez le problème avant de continuer. Il peut être utile d’examiner les journaux de pod à l’aide de la commande suivante :

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

Obtenez EXTERNAL-IP pour accéder à l’application Todo à l’aide de la commande suivante :

kubectl get svc -n ${AKS_NS}

La sortie doit ressembler à cet exemple :

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

Vous pouvez utiliser la commande suivante pour enregistrer la valeur de EXTERNAL-IP dans une variable d’environnement en tant qu’URL complète :

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

Ouvrez un nouveau navigateur web à la valeur de ${QUARKUS_URL}. Ensuite, ajoutez un nouvel élément todo avec le texte Deployed the Todo app to AKS. Sélectionnez également l’élément Introduction to Quarkus Todo App comme terminé.

Capture d’écran de l’exemple d’application Todo en cours d’exécution dans AKS.

Accédez à l’API RESTful (/api) pour obtenir tous les éléments todo stockés dans la base de données Azure PostgreSQL, comme illustré dans l’exemple suivant :

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

La sortie doit ressembler à cet exemple :

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

Vérifiez que la base de données a été mise à jour à l’aide d’Azure Cloud Shell

Ouvrez Azure Cloud Shell dans le portail Azure en sélectionnant l’icône Cloud Shell, comme illustré dans la capture d’écran suivante :

Capture d’écran du portail Azure avec le bouton Cloud Shell mis en évidence.

Exécutez la commande suivante localement et collez le résultat dans Azure Cloud Shell :

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

Lorsque vous êtes invité à entrer le mot de passe, utilisez la même valeur que lors de la création de la base de données.

Utilisez la requête suivante pour obtenir tous les éléments todo :

select * from todo;

La sortie doit ressembler à l’exemple suivant et doit inclure les mêmes éléments dans l’interface graphique utilisateur de l’application Todo présentée précédemment :

Capture d’écran de la sortie de requête comme table ASCII.

Si vous voyez MORE dans la sortie, tapez q pour quitter le récepteur de radiomessagerie.

Entrez \q pour quitter le programme psql et revenir au Cloud Shell.

Nettoyer les ressources

Pour éviter des frais Azure, vous devez nettoyer les ressources inutiles. Lorsque vous n’avez plus besoin du cluster, utilisez la commande az group delete pour supprimer le groupe de ressources, le service conteneur, le registre de conteneurs et toutes les ressources associées.

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

Vous pouvez également utiliser docker rmi pour supprimer les images conteneur postgres et testcontainers générées par le mode de développement Quarkus.

Étapes suivantes