Utilisez Java EE JCache avec Open Liberty ou WebSphere Liberty sur un cluster Azure Kubernetes Service (AKS)

Article
09/11/2024

Cet article décrit comment utiliser Java EE JCache dans une application conteneurisée déployée sur AKS.

Dans ce guide, vous allez :

Créez l’infrastructure pour exécuter votre application Java, Java EE, Jakarta EE ou MicroProfile sur l’environnement d’exécution Open Liberty ou WebSphere Liberty.
Utilisez Java EE JCache pris en charge par Azure Cache for Redis comme cache de session.
Générer l’image Docker de l’application à l’aide d’images conteneur Open Liberty ou WebSphere Liberty.
Déployez l’application en conteneur sur un cluster AKS à l’aide de l’opérateur Open Liberty.

Cet article vous aide à accéder rapidement au déploiement. Avant de passer en production, vous devez explorer Tuning Liberty.

Si vous souhaitez fournir des commentaires ou travailler étroitement sur vos scénarios de migration avec l’équipe d’ingénierie qui développe WebSphere sur des solutions Azure, répondez à cette courte enquête sur la migration WebSphere et incluez vos coordonnées. L’équipe de gestionnaires de programmes, d’architectes et d’ingénieurs vous contactera rapidement pour établir une collaboration.

Prérequis

Un abonnement Azure. Si vous n’avez pas d’abonnement Azure, créez un compte gratuit 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 l’interface de ligne de commande Azure (CLI Azure) pour exécuter des commandes CLI Azure.
- Connectez-vous avec l’interface de ligne de commande Azure en utilisant la commande az login. Pour finir le processus d’authentification, suivez les étapes affichées dans votre terminal. Veuillez consulter la section Connexion à Azure avec l’interface de ligne de commande Azure pour d’autres options de connexion.
- Lorsque vous y êtes invité, installez l’extension Azure CLI lors de la première utilisation. Pour plus d’informations sur les extensions, consultez Utiliser et gérer des extensions avec Azure CLI.
- Exécutez az version pour rechercher la version et les bibliothèques dépendantes installées. Pour effectuer une mise à niveau vers la dernière version, exécutez az upgrade.
Installez une implémentation de Java SE version 17 ou ultérieure, par exemple la build Microsoft d’OpenJDK.
Installez Maven 3.5.0 ou une version ultérieure.
Installez Docker pour votre système d’exploitation.
Vérifiez que Git est installé.
Assurez-vous que vous avez reçu soit le rôle Owner soit les rôles Contributor et User Access Administrator pour l’abonnement. Vous pouvez vérifier vos affectations en suivant les étapes de Lister les affectations de rôles pour un utilisateur ou un groupe.

Créer l’infrastructure

Les étapes de cette section vous guident pour créer l’infrastructure de l’application sur Azure. Après avoir terminé ces étapes, vous disposerez d’un Azure Container Registry, d’un cluster Azure Kubernetes Service et d’une instance Azure Cache for Redis pour exécuter l’application d’exemple.

Créer un groupe de ressources

Un groupe de ressources Azure est un groupe logique dans lequel des ressources Azure sont déployées et gérées.

Créez un groupe de ressources appelé java-liberty-project à l’aide de la commande az group create dans l’emplacement eastus. Ce groupe de ressources est utilisé plus tard pour créer l’instance Azure Container Registry (ACR) et le cluster AKS.

export RESOURCE_GROUP_NAME=java-liberty-project
az group create --name $RESOURCE_GROUP_NAME --location eastus

Créer une instance ACR

Utilisez la commande az acr create pour créer l’instance ACR. L’exemple suivant crée une instance ACR nommée youruniqueacrname. Assurez-vous que youruniqueacrname est unique dans Azure.

export REGISTRY_NAME=youruniqueacrname
az acr create \
    --resource-group $RESOURCE_GROUP_NAME \
    --name $REGISTRY_NAME \
    --sku Basic

Après un bref laps de temps, vous devriez voir la sortie JSON suivante :

  "provisioningState": "Succeeded",
  "publicNetworkAccess": "Enabled",
  "resourceGroup": "java-liberty-project",

Alternativement, vous pouvez créer une instance Azure Container Registry en suivant les étapes de Prise en main rapide : Créer un Azure Container Registry en utilisant le portail Azure.

Se connecter à l’instance ACR

Vous devrez vous connecter à l’instance ACR avant de pouvoir y pousser une image. Exécutez les commandes suivantes pour vérifier la connexion :

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

az acr login \
    --name $REGISTRY_NAME \
    --resource-group $RESOURCE_GROUP_NAME

Remarque

L’utilisation des identifiants nom d’utilisateur et mot de passe pour accorder l’accès à un registre de conteneurs est déconseillée. Si vos exigences particulières suggèrent que l’accès basé sur des identifiants est la meilleure approche, vous pouvez obtenir le nom d’utilisateur et le mot de passe en utilisant az acr credential show et utiliser ces valeurs avec docker login.

Vous devriez voir Login Succeeded à la fin de la sortie de commande si vous vous êtes connecté avec succès à l’instance ACR.

Si vous rencontrez un problème lors de la connexion au registre de conteneurs Azure, consultez Dépanner la connexion au registre.

Créer un cluster AKS

Utilisez la commande az aks create pour créer un cluster AKS et lui accorder l’autorisation de récupérer les images à partir de l’instance ACR. L’exemple suivant crée un cluster à un nœud nommé myAKSCluster. Cette commande prend plusieurs minutes à s’exécuter.

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

Après quelques minutes, la commande se termine et renvoie des informations au format JSON sur le cluster, y compris les lignes suivantes :

  "nodeResourceGroup": "MC_java-liberty-project_myAKSCluster_eastus",
  "privateFqdn": null,
  "provisioningState": "Succeeded",
  "resourceGroup": "java-liberty-project",

Se connecter au cluster AKS

Pour gérer un cluster Kubernetes, vous utilisez kubectl, le client de ligne de commande Kubernetes. Pour installer kubectl en local, utilisez la commande az aks install-cli :

az aks install-cli

Pour configurer kubectl afin de vous connecter à votre cluster Kubernetes, exécutez la commande az aks get-credentials. 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

Pour vérifier la connexion à votre cluster, utilisez la commande kubectl get pour retourner une liste des nœuds du cluster.

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

Installer l’Opérateur Open Liberty

Une fois que vous avez créé le cluster et que vous y êtes connecté, installez l’Opérateur Open Liberty en exécutant les commandes suivantes.

# Install cert-manager Operator
CERT_MANAGER_VERSION=v1.11.2
kubectl apply -f https://github.com/jetstack/cert-manager/releases/download/${CERT_MANAGER_VERSION}/cert-manager.yaml

# Install Open Liberty Operator
export OPERATOR_VERSION=1.3.3
mkdir -p overlays/watch-all-namespaces
wget https://raw.githubusercontent.com/OpenLiberty/open-liberty-operator/main/deploy/releases/${OPERATOR_VERSION}/kustomize/overlays/watch-all-namespaces/olo-all-namespaces.yaml -q -P ./overlays/watch-all-namespaces
wget https://raw.githubusercontent.com/OpenLiberty/open-liberty-operator/main/deploy/releases/${OPERATOR_VERSION}/kustomize/overlays/watch-all-namespaces/cluster-roles.yaml -q -P ./overlays/watch-all-namespaces
wget https://raw.githubusercontent.com/OpenLiberty/open-liberty-operator/main/deploy/releases/${OPERATOR_VERSION}/kustomize/overlays/watch-all-namespaces/kustomization.yaml -q -P ./overlays/watch-all-namespaces
mkdir base
wget https://raw.githubusercontent.com/OpenLiberty/open-liberty-operator/main/deploy/releases/${OPERATOR_VERSION}/kustomize/base/kustomization.yaml -q -P ./base
wget https://raw.githubusercontent.com/OpenLiberty/open-liberty-operator/main/deploy/releases/${OPERATOR_VERSION}/kustomize/base/open-liberty-crd.yaml -q -P ./base
wget https://raw.githubusercontent.com/OpenLiberty/open-liberty-operator/main/deploy/releases/${OPERATOR_VERSION}/kustomize/base/open-liberty-operator.yaml -q -P ./base
wget https://raw.githubusercontent.com/OpenLiberty/open-liberty-operator/main/deploy/releases/${OPERATOR_VERSION}/kustomize/base/open-liberty-roles.yaml -q -P ./base
kubectl create namespace open-liberty
kubectl apply --server-side -k overlays/watch-all-namespaces

Créer une instance Cache Redis Azure

Azure Cache for Redis prend en charge la persistance du HttpSession pour une application Java fonctionnant sur un serveur Open Liberty ou WebSphere Liberty. Suivez les étapes de cette section pour créer une instance Azure Cache for Redis et notez ses informations de connexion. Nous utiliserons ces informations plus tard.

Suivez les étapes de Prise en main rapide : Utiliser Azure Cache for Redis dans Java jusqu’à, mais sans inclure, Comprendre l’exemple Java.

Remarque

À l’étape 6 de la section Créer un cache Azure pour Redis, sélectionnez Authentification par clés d’accès pour l’option Authentification. Cette option est requise pour que l’application exemple puisse se connecter à l’instance Azure Cache pour Redis en utilisant la bibliothèque cliente Redisson. Pour plus d’informations, consultez Configuration de Redisson.
Copiez le Nom d’hôte et la Clé d’accès principale de votre instance Azure Cache for Redis, puis exécutez les commandes suivantes pour ajouter des variables d’environnement :
```
export REDISCACHEHOSTNAME=<YOUR_HOST_NAME>
export REDISCACHEKEY=<YOUR_PRIMARY_ACCESS_KEY>
```

Créer l’application

Suivez les étapes de cette section pour construire et conteneuriser l’application d’exemple. Ces étapes utilisent Maven, liberty-maven-plugin, et az acr build. Pour en savoir plus sur le liberty-maven-plugin, consultez Building a web application with Maven.

Extraire l’application

Utilisez les commandes suivantes pour cloner le code exemple pour ce guide. L’exemple se trouve dans le référentiel open-liberty-on-aks sur GitHub. Il existe quelques exemples dans le référentiel. Cet article utilise java-app-jcache.

git clone https://github.com/Azure-Samples/open-liberty-on-aks.git
cd open-liberty-on-aks
git checkout 20240909
cd java-app-jcache

Si un message vous signale que vous allez passer à l’état « detached HEAD », vous pouvez ignorer ce message sans risque. Il signifie simplement que vous avez extrait une étiquette.

L’application a la structure de fichiers suivante :

java-app-jcache/
├── pom.xml
└── src
    └── main
        ├── aks
        │   └── openlibertyapplication.yaml
        ├── docker
        │   ├── Dockerfile
        │   └── Dockerfile-wlp
        ├── java
        ├── liberty
        │   └── config
        │       └── server.xml
        ├── redisson
        │   └── redisson-config.yaml
        ├── resources
        └── webapp

Les répertoires java, resources, et webapp contiennent le code source de l’application d’exemple.

Dans le répertoire aks, le fichier de déploiement openlibertyapplication.yaml est utilisé pour déployer l’image de l’application.

Dans le répertoire docker, nous plaçons deux Dockerfiles. Dockerfile est utilisé pour construire l’image avec Open Liberty et Dockerfile-wlp est utilisé pour construire l’image avec WebSphere Liberty.

Dans le répertoire liberty/config, le fichier server.xml est utilisé pour configurer le cache de session pour le cluster Open Liberty et WebSphere Liberty.

Dans le répertoire redisson, le fichier redisson-config.yaml est utilisé pour configurer la connexion de l’instance Azure Cache for Redis.

Conteneuriser l’application

Pour déployer et exécuter votre application Liberty sur le cluster AKS, suivez les étapes suivantes pour conteneuriser votre application sous forme d’image Docker. Vous pouvez utiliser les images de conteneur Open Liberty ou les images de conteneur WebSphere Liberty.

Vérifiez que le répertoire de travail actuel est java-app-jcache dans votre clone local.
Exécutez mvn clean package pour empaqueter l’application.
Exécutez mvn -Predisson validate pour copier le fichier de configuration Redisson à l’emplacement spécifié. Cette étape insère les valeurs des variables d’environnement REDISCACHEHOSTNAME et REDISCACHEKEY dans le fichier redisson-config.yaml, qui est référencé par le fichier server.xml.

Exécutez mvn liberty:dev pour tester l'application. Si le test réussit, vous devriez voir The defaultServer server is ready to run a smarter planet. dans la sortie de la commande. Vous devriez voir une sortie similaire à la suivante si la connexion Redis est réussie.

[INFO] [err] [Default Executor-thread-5] INFO org.redisson.Version - Redisson 3.23.4
[INFO] [err] [redisson-netty-2-7] INFO org.redisson.connection.pool.MasterPubSubConnectionPool - 1 connections initialized for redacted.redis.cache.windows.net/20.25.90.239:6380
[INFO] [err] [redisson-netty-2-20] INFO org.redisson.connection.pool.MasterConnectionPool - 24 connections initialized for redacted.redis.cache.windows.net/20.25.90.239:6380

Vous pouvez visiter http://localhost:9080/ pour voir l’application en cours d’exécution, mais la preuve du bon fonctionnement de Redis se trouve dans la sortie listée à l’étape précédente.
Utilisez Ctrl+C pour arrêter l’application.

Utilisez les commandes suivantes pour récupérer les valeurs des propriétés artifactId et version définies dans le fichier pom.xml.

export artifactId=$(mvn -q -Dexec.executable=echo -Dexec.args='${project.artifactId}' --non-recursive exec:exec)
export version=$(mvn -q -Dexec.executable=echo -Dexec.args='${project.version}' --non-recursive exec:exec)

Exécutez cd target pour basculer le répertoire vers le build de l’exemple.
Exécutez l’une des commandes suivantes pour générer l’image de l’application et l’envoyer à l’instance ACR.
- Utilisez la commande suivante pour construire avec une image de base Open Liberty si vous préférez utiliser Open Liberty comme environnement d’exécution Java™ open source léger :
```
# Build and tag application image. This causes the ACR instance to pull the necessary Open Liberty base images.
az acr build -t ${artifactId}:${version} -r $REGISTRY_NAME --resource-group $RESOURCE_GROUP_NAME .
```
- Utilisez la commande suivante pour construire avec une image de base WebSphere Liberty si vous préférez utiliser une version commerciale d’Open Liberty :
```
# Build and tag application image. This causes the ACR instance to pull the necessary WebSphere Liberty base images.
az acr build -t ${artifactId}:${version} -r $REGISTRY_NAME --resource-group $RESOURCE_GROUP_NAME --file=Dockerfile-wlp .
```

Déployer l’application

Suivez les étapes de cette section pour déployer l’application conteneurisée sur le cluster AKS.

Vérifiez que le répertoire de travail actuel est java-app-jcache/target dans votre clone local.
Utilisez les commandes suivantes pour créer un secret avec les informations de configuration Redisson. Avec ce secret, l’application peut se connecter à l’instance Azure Cache for Redis créée.
```
export REDISSON_CONFIG_SECRET_NAME=redisson-config-secret
kubectl create secret generic ${REDISSON_CONFIG_SECRET_NAME} --from-file=$(pwd)/liberty/wlp/usr/servers/defaultServer/redisson-config.yaml
```

Utilisez les commandes suivantes pour déployer votre application Liberty avec trois réplicas sur le cluster AKS. La sortie de commande est également montrée en ligne.

# Set number of application replicas
export REPLICAS=3

# Create OpenLibertyApplication "javaee-cafe-jcache-cluster"
envsubst < openlibertyapplication.yaml | kubectl create -f -

openlibertyapplication.openliberty.io/javaee-cafe-jcache-cluster created

# Check if OpenLibertyApplication instance is created
kubectl get openlibertyapplication ${artifactId}-cluster

NAME                               IMAGE                                                         EXPOSED      RECONCILED   AGE
javaee-cafe-jcache-cluster         youruniqueacrname.azurecr.io/javaee-cafe-jcache:1.0.0                      True         59s

# Check if deployment created by Operator is ready
kubectl get deployment ${artifactId}-cluster --watch

NAME                               READY   UP-TO-DATE   AVAILABLE   AGE
javaee-cafe-jcache-cluster         0/3     3            0           20s

Attendez de voir 3/3 sous la colonne READY et 3 sous la colonne AVAILABLE, puis utilisez Ctrl+C pour arrêter le processus kubectl de surveillance.

Test de l’application

Quand l’application s’exécute, un service Kubernetes d’équilibrage de charge expose le front-end de l’application sur Internet. Ce processus peut prendre un certain temps.

Pour surveiller la progression, utilisez la commande kubectl get service avec l’argument --watch.

kubectl get service ${artifactId}-cluster --watch

NAME                               TYPE           CLUSTER-IP     EXTERNAL-IP     PORT(S)          AGE
javaee-cafe-jcache-cluster         LoadBalancer   10.0.50.29     20.84.16.169    80:31732/TCP     68s

Une fois que l’adresse EXTERNAL-IP change de en attente à une véritable adresse IP publique, utilisez Ctrl+C pour arrêter le processus kubectl de surveillance.

Ouvrez un navigateur web sur l’adresse IP externe de votre service (20.84.16.169 pour l’exemple ci-dessus) afin d’afficher la page d’accueil à l’application. Si la page ne se charge pas correctement, c’est parce que l’application est en cours de démarrage. Vous pouvez attendre un moment et actualiser la page plus tard. Vous devriez voir le nom du pod de vos réplicas d’application affiché en haut à gauche de la page (javaee-cafe-jcache-cluster-77d54bccd4-5xnzx dans ce cas).

Capture d’écran de l’application Java Liberty déployée avec succès sur A K S.

Sous la forme Nouveau café dans la session, définissez les valeurs des champs Nom et Prix, puis sélectionnez Envoyer. Après quelques secondes, vous verrez Nombre de soumissions : 1 affiché en bas à gauche de la page.

Capture d’écran de l’application d’exemple montrant le nouveau café créé et persistant dans la session de l’application.

Pour démontrer que le cache de session est persistant sur tous les réplicas de l’application, exécutez la commande suivante pour supprimer le réplicat actuel avec le nom du pod javaee-cafe-jcache-cluster-<pod id from your running app> :

kubectl delete pod javaee-cafe-jcache-cluster-77d54bccd4-5xnzx

pod "javaee-cafe-jcache-cluster-77d54bccd4-5xnzx" deleted

Ensuite, actualisez la page d’accueil de l’application. Vous verrez les mêmes données affichées dans la section Nouveau café dans la session, mais un nom de pod différent affiché en haut à gauche de la page.

Enfin, suivez les étapes suivantes pour démontrer que les données de session sont persistantes dans l’instance Azure Cache for Redis. Vous pouvez émettre des commandes à votre instance Azure Cache for Redis en utilisant la Console Redis.

Trouvez votre instance Azure Cache for Redis dans le portail Azure.
Sélectionnez Console pour ouvrir la console Redis.

Exécutez les commandes suivantes pour afficher les données de session :

scan 0 count 1000 match '*'

hgetall "com.ibm.ws.session.attr.default_host%2F"

Recherchez cafe.model.entity.Coffee[id=1, name=Coffee 3, price=30.0] sur la page Web, qui est le café que vous avez créé et persisté dans l’instance Azure Cache for Redis.

Nettoyer les ressources

Pour éviter des frais Azure, vous devez nettoyer les ressources non nécessaires. 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.

az group delete --name $RESOURCE_GROUP_NAME --yes --no-wait

Pour supprimer l’instance Azure Cache for Redis, trouvez le nom de son groupe de ressources et exécutez la commande suivante :

az group delete --name <AZURE_CACHE_FOR_REDIS_RESOURCE_GROUP_NAME> --yes --no-wait

Étapes suivantes

Vous pouvez en savoir plus sur les références utilisées dans ce guide :

Pour explorer les options d’exécution des produits WebSphere sur Azure, veuillez consulter la section Quelles sont les solutions pour exécuter la famille de produits WebSphere sur Azure ?

Partager via