Utilisez Java EE JCache avec Open Liberty ou WebSphere Liberty sur un cluster Azure Kubernetes Service (AKS)
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 Azure CLI à l’aide de 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 versionpour rechercher la version et les bibliothèques dépendantes installées. Pour effectuer une mise à niveau vers la dernière version, exécutezaz upgrade.
- Connectez-vous avec Azure CLI à l’aide de la commande
- 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
Ownersoit les rôlesContributoretUser Access Administratorpour 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. Une fois ces étapes effectuées, vous disposez d’un Registre de conteneurs Azure, d’un cluster Azure Kubernetes Service et d’une instance Azure Cache pour Redis pour l’exécution de l’exemple d’application.
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 à 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 devez vous connecter à l’instance ACR avant de pouvoir y envoyer 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 devez voir Login Succeeded à la fin de la sortie de commande si vous vous êtes connecté à l’instance ACR avec succès.
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 d’extraction d’image à partir de l’instance ACR. L’exemple suivant crée un cluster nommé myAKSCluster avec un nœud. 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 localement, utilisez la commande az aks install-cli :
az aks install-cli
Pour configurer kubectl pour vous connecter à votre cluster Kubernetes, utilisez 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 7 de la section Créer un cache Azure pour Redis, sélectionnez Authentification des clés d’accès pour l’option Authentification dans le volet avancé pour ce guide. Pour une sécurité optimale, nous vous recommandons d’utiliser l’ID Microsoft Entra avec des identités managées pour autoriser les demandes sur votre cache, si possible. L’autorisation à l’aide de l’ID Microsoft Entra et des identités managées offre une sécurité et une facilité d’utilisation supérieures par rapport à l’autorisation de clé d’accès partagé. Pour plus d’informations sur l’utilisation d’identités managées avec votre cache, consultez Utiliser l’ID Microsoft Entra pour l’authentification du cache.
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-pluginet 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 vous voyez un message concernant l’état detached HEAD, vous pouvez ignorer ce message en toute sécurité. Cela signifie simplement que vous avez modifié 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 packagepour empaqueter l’application.Exécutez
mvn -Predisson validatepour copier le fichier de configuration Redisson à l’emplacement spécifié. Cette étape insère les valeurs des variables d’environnementREDISCACHEHOSTNAMEetREDISCACHEKEYdans le fichier redisson-config.yaml, qui est référencé par le fichier server.xml.Exécutez
mvn liberty:devpour tester l'application. Si le test réussit, vous devriez voirThe 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:6380Vous 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
artifactIdetversiondé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 targetpour 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.yamlUtilisez 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 20sAttendez de voir
3/3sous la colonneREADYet3sous la colonneAVAILABLE, puis utilisez Ctrl+C pour arrêter le processuskubectlde 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 passe de pending à une adresse IP publique réelle, utilisez Ctrl+C pour arrêter le processus de surveillance kubectl.
Ouvrez un navigateur web sur l’adresse IP externe de votre service (20.84.16.169 pour l’exemple précédent) pour afficher la page d’accueil de 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 pouvez voir les mêmes données affichées dans la section Nouveau café dans la session, mais le nom de pod affiché en haut à gauche de la page est différent.
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 le cluster n’est plus nécessaire, utilisez la commande az group delete pour supprimer le groupe de ressources, le service de 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 :
- Configurer la persistance de session Liberty avec JCache
- Support JCache de Redisson
- Configuration du serveur Open Liberty
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 ?