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

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 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.
  • • Bash
    • PowerShell
    • Visual Studio Code

    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-12-16
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 conteneurisée 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 conteneur est en cours d’exécution, puis 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.

Il est possible qu’on vous demande si vous souhaitez envoyer la télémétrie de votre utilisation du mode développeur de 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.

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, puis en appuyant sur Entrée, comme le montre la capture d’écran suivante :

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
• 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 et LOCATION 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 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.

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

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://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"
}

Tester l’application localement avec Azure Database pour PostgreSQL – Serveur flexible

Dans la section précédente, vous avez testé l’application Quarkus localement en mode de développement avec une base de données PostgreSQL approvisionnée en tant que conteneur Docker. Testez à présent la connexion à l’instance locale d’Azure Database pour PostgreSQL – Serveur flexible.

Tout d’abord, ajoutez l’utilisateur connecté actuel en tant qu’administrateur Microsoft Entra à l’instance d’Azure Database pour PostgreSQL – Serveur flexible à l’aide des commandes suivantes :

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)

Une sortie réussie est un objet JSON incluant la propriété "type": "Microsoft.DBforPostgreSQL/flexibleServers/administrators".

Ajoutez ensuite l’adresse IP locale aux règles de pare-feu de l’instance d’Azure Database pour PostgreSQL – Serveur flexible en suivant ces étapes :

1. Obtenez l’adresse IP locale de la machine où vous exécutez l’application Quarkus localement. Par exemple, consultez https://whatismyipaddress.com pour obtenir votre adresse IPv4 publique.

2. Définissez une variable d’environnement avec l’adresse IP locale que vous avez obtenue à l’étape précédente.

   export AZ_LOCAL_IP_ADDRESS=<your local IP address>
   

3. Exécutez la commande suivante pour ajouter l’adresse IP locale aux règles de pare-feu de l’instance d’Azure Database pour PostgreSQL – Serveur flexible :

   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
   

Définissez ensuite les variables d’environnement suivantes dans votre terminal précédent. Ces variables d’environnement sont utilisées pour se connecter à l’instance d’Azure Database pour PostgreSQL – Serveur flexible à partir de l’application Quarkus s’exécutant localement :

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}

Exécutez à présent l’application Quarkus localement pour tester la connexion à l’instance d’Azure Database pour PostgreSQL – Serveur flexible. Utilisez la commande suivante pour démarrer l’application en mode de production :

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

Ouvrez un nouveau navigateur web sur http://localhost:8080 pour accéder à l’application Todo. Vous devez voir l’application Todo, qui ressemble à ce que vous avez vu quand vous avez exécuté l’application localement en mode de développement.

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 offre une prise en charge intégrée d’Azure Container Registry.

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

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

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

Obtenez le serveur de connexion de l’instance de Container Registry à l’aide de la commande suivante :

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

Connecter votre Docker à l’instance de registre de conteneurs

Connectez-vous à l’instance de registre de conteneurs. La connexion vous permet d’envoyer (push) une image. Utilisez la commande suivante pour vous connecter au registre :

az acr login --name $REGISTRY_NAME

Si vous avez réussi à vous connecter à l’instance de registre de conteneurs, 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 de registre de conteneurs que vous avez créée à une étape précédente. Cette commande prend plusieurs minutes à s’exécuter. Le cluster a démarré avec l’identité managée activée. Cette étape est nécessaire pour la connexion de base de données sans mot de passe.

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

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 une connexion de service dans AKS avec le connecteur de services

Dans cette section, vous créez une connexion de service entre le cluster AKS et Azure Database pour PostgreSQL – Serveur flexible en utilisant la solution ID de charge de travail Microsoft Entra avec le connecteur de services. Cette connexion permet au cluster AKS d’accéder à Azure Database pour PostgreSQL – Serveur flexible sans utiliser l’authentification SQL.

Exécutez les commandes suivantes pour créer une connexion entre le cluster AKS et la base de données PostgreSQL en utilisant la solution ID de charge de travail Microsoft Entra avec le connecteur de services :

# 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

La présence du code JSON suivant dans la sortie de la commande finale au cours des étapes précédentes indique la réussite de l’installation du connecteur de services :

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

Obtenir un compte de service et un secret créés par le connecteur de services

Pour vous authentifier auprès d’Azure Database pour PostgreSQL – Serveur flexible, vous devez obtenir le compte de service et le secret Kubernetes créés par le connecteur de services. Suivez les instructions de la section Mettre à jour votre conteneur du Tutoriel : Connecter une application AKS à Azure SQL Database. Choisissez l’option Créer directement un déploiement en utilisant l’exemple d’extrait de code YAML fourni, puis suivez l’étape indiquée ici :

• Dans les sections mises en évidence de l’exemple de code YAML de déploiement Kubernetes, copiez les valeurs de serviceAccountName et secretRef.name, représentées par <service-account-name> et <secret-name> dans l’exemple suivant :

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

  Ces valeurs sont utilisées dans la section suivante pour déployer l’application Quarkus sur le cluster AKS.

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 autres étapes de cette section vous indiquent comment personnaliser les valeurs du fichier src/main/resources/application.properties.

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

Examinez les variables de configuration de base de données suivantes. Les propriétés de connexion de base de données %prod.quarkus.datasource.jdbc.url et %prod.quarkus.datasource.username lisent les valeurs des variables d’environnement AZURE_POSTGRESQL_HOST, AZURE_POSTGRESQL_PORT, AZURE_POSTGRESQL_DATABASE et AZURE_POSTGRESQL_USERNAME, respectivement. Ces variables d’environnement sont mappées aux valeurs de secrets qui stockent les informations de connexion de base de données. Pour des raisons de sécurité, elles sont générées automatiquement à l’aide de l’extension sans mot de passe Connecteur de services, comme indiqué ailleurs dans cet article.

# 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

Configuration Kubernetes

Examinez les variables de configuration Kubernetes suivantes. service-type a la valeur load-balancer pour accéder à l’application de manière externe. Remplacez les valeurs de <service-account-name> et <secret-name> par les valeurs réelles que vous avez copiées dans la section précédente.

# 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

Les autres configurations Kubernetes spécifient le mappage des valeurs des secrets aux variables d’environnement dans l’application Quarkus. Le secret <secret-name> contient les informations de connexion de base de données. Les clés AZURE_POSTGRESQL_CLIENTID, AZURE_POSTGRESQL_HOST, AZURE_POSTGRESQL_PORT, AZURE_POSTGRESQL_DATABASE et AZURE_POSTGRESQL_USERNAME du secret sont mappées aux variables d’environnement AZURE_CLIENT_ID, AZURE_POSTGRESQL_HOST, AZURE_POSTGRESQL_PORT, AZURE_POSTGRESQL_DATABASE et AZURE_POSTGRESQL_USERNAME, respectivement.

Pour examiner les secrets directement avec kubectl, utilisez des commandes similaires à l’exemple suivant :

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

Configuration de l’image conteneur

En tant que technologie native cloud, Quarkus prend en charge la génération d’images conteneur OCI compatibles avec Docker. Remplacez la valeur de <LOGIN_SERVER_VALUE> par la valeur réelle de la variable d’environnement ${LOGIN_SERVER}.

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

En guise de dernière vérification, une fois que vous avez effectué toutes les substitutions nécessaires dans application.properties, aucune occurrence du caractère < ne doit être présente. Dans le cas contraire, vérifiez une nouvelle fois que vous avez effectué toutes les substitutions nécessaires.

Générer l’image conteneur, et l’envoyer (push) au registre de conteneurs

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. La sortie doit ressembler à celle-ci :

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

Envoyez (push) les images conteneur vers le registre de conteneurs à 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>/todo-quarkus-aks]
dfd615499b3a: Pushed
56f5cf1aa271: Pushed
4218d39b228e: Pushed
b0538737ed64: Pushed
d13845d85ee5: Pushed
60609ec85f86: Pushed
1.0: digest: sha256:0ffd70d6d5bb3a4621c030df0d22cf1aa13990ca1880664d08967bd5bab1f2b6 size: 1995

Une fois que vous avez envoyé (push) l’application vers le registre de conteneurs, 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 :

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

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érifier que la base de données a été mise à jour

Exécutez la commande suivante pour vérifier que la base de données est désormais correctement mise à jour :

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

Si on vous demande d’installer une extension, répondez Y.

La sortie doit ressembler à l’exemple suivant. Elle doit inclure les mêmes éléments dans l’interface graphique utilisateur (GUI) de l’application Todo et la sortie de la commande curl plus tôt :

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

Une fois que vous avez fini, supprimez la règle de pare-feu qui permet à votre adresse IP locale d’accéder à l’instance d’Azure Database pour PostgreSQL – Serveur flexible à l’aide de la commande suivante :

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

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

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

Étapes suivantes

• Azure Kubernetes Service
• Déployer des applications Java serverless avec Quarkus sur Azure Functions
• Quarkus
• Extension Kubernetes
• Options Jib
• Jakarta EE sur Azure