Utiliser Java EE JCache avec Open Liberty ou WebSphere Liberty sur un cluster Azure Kubernetes Service (AKS)
Cet article explique 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 le runtime Open Liberty ou WebSphere Liberty.
- Utilisez Java EE JCache sauvegardé par Azure Cache pour Redis en tant que 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 n’avez pas d’abonnement Azure, créez un compte gratuit avant de commencer.
Prérequis
Utilisez l’environnement Bash dans Azure Cloud Shell. Pour plus d’informations, consultez Démarrage rapide pour Bash dans Azure Cloud Shell.
Si vous préférez exécuter les commandes de référence de l’interface de ligne de commande localement, installez l’interface Azure CLI. Si vous exécutez sur Windows ou macOS, envisagez d’exécuter Azure CLI dans un conteneur Docker. Pour plus d’informations, consultez Guide pratique pour exécuter Azure CLI dans un conteneur Docker.
Si vous utilisez une installation locale, connectez-vous à Azure CLI à l’aide de la commande az login. Pour finir le processus d’authentification, suivez les étapes affichées dans votre terminal. Pour connaître les autres options de connexion, consultez Se connecter avec Azure CLI.
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 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.
- Cet article nécessite la dernière version d’Azure CLI. Si vous utilisez Azure Cloud Shell, sachez que la version la plus récente est déjà installée.
- Si vous exécutez les commandes dans ce guide localement (au lieu d’Azure Cloud Shell) :
- Préparez un ordinateur local avec un système d’exploitation de type UNIX installé (par exemple, Ubuntu, macOS, sous-système Windows pour Linux).
- Installez une implémentation Java SE, version 17 ou ultérieure (par exemple, Eclipse Open J9).
- Installez Maven 3.5.0 ou une version ultérieure.
- Installez Docker pour votre système d’exploitation.
- Assurez-vous que vous avez reçu un
Ownerrôle ouContributorUser Access Administratordes rôles pour l’abonnement. Vous pouvez vérifier vos attributions en suivant les étapes décrites dans Répertorier les attributions 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 d’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 de Azure Cache pour Redis pour exécuter 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 dans l’emplacement eastus. Ce groupe de ressources sera 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 \
--admin-enabled
Après un bref laps de temps, vous devriez voir la sortie JSON suivante :
"provisioningState": "Succeeded",
"publicNetworkAccess": "Enabled",
"resourceGroup": "java-liberty-project",
Vous pouvez également créer une instance de registre de conteneurs Azure en suivant les étapes de démarrage rapide : Créer un registre de conteneurs Azure à l’aide du 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)
export USER_NAME=$(az acr credential show \
--name $REGISTRY_NAME \
--resource-group $RESOURCE_GROUP_NAME \
--query 'username' \
--output tsv)
export PASSWORD=$(az acr credential show \
--name $REGISTRY_NAME \
--resource-group $RESOURCE_GROUP_NAME \
--query 'passwords[0].value' \
--output tsv)
docker login $LOGIN_SERVER -u $USER_NAME -p $PASSWORD
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 de connexion au registre de conteneurs Azure, consultez Résoudre les problèmes de 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 à un nœud nommé myAKSCluster. Cette commande prend plusieurs minutes.
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 retourne 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. Si vous utilisez Azure Cloud Shell, kubectl est déjà installé. 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 Prêt.
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.2.2
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 pour Redis sauvegarde la persistance de l’application HttpSession Java s’exécutant dans un serveur Open Liberty ou WebSphere Liberty. Suivez les étapes de cette section pour créer une instance Azure Cache pour Redis et notez ses informations de connexion. Nous allons utiliser ces informations ultérieurement.
Suivez les étapes de démarrage rapide : Utilisez Azure Cache pour Redis dans Java jusqu’à ce qu’il soit, mais pas compris Comprendre l’exemple Java.
Copiez le nom d’hôte et la clé d’accès primaire pour votre instance de Azure Cache pour 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 générer et conteneuriser l’exemple d’application. 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 l’exemple de code de 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 20230906
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, ressources et webapp contiennent le code source de l’exemple d’application.
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 placez deux fichiers Dockerfiles. Dockerfile est utilisé pour générer une image avec Open Liberty et Dockerfile-wlp est utilisé pour générer une 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 de Azure Cache pour Redis.
Conteneuriser l’application
Pour déployer et exécuter votre application Liberty sur le cluster AKS, procédez comme suit pour conteneuriser votre application en tant qu’image Docker. Vous pouvez utiliser des images conteneur Open Liberty ou des images conteneur WebSphere Liberty.
Remplacez le répertoire par java-app-jcache de 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’environnement etREDISCACHEKEYdans le fichier redisson-config.yaml, qui est référencé par le fichier server.xml.REDISCACHEHOSTNAMEExécutez
mvn liberty:devpour tester l'application. Si le test réussit, vous devez voirThe defaultServer server is ready to run a smarter planet.dans la sortie de la commande. Vous devriez voir une sortie similaire à ce qui suit si la connexion Redis réussit.[INFO] [err] [Default Executor-thread-5] INFO org.redisson.Version - Redisson 3.16.7 [INFO] [err] [redisson-netty-2-2] 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 consulter
http://localhost:9080/l’application en cours d’exécution, mais la preuve de fonctionnement de Redis est la sortie répertorié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 générer avec une image de base Open Liberty si vous préférez utiliser Open Liberty comme runtime Java™ léger code source ouvert :
# Build and tag application image. This will cause 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 générer 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 will cause 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 décrites dans cette section pour déployer l’exemple d’application conteneurisé 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 des informations de configuration Redisson. Avec ce secret, l’application peut se connecter à l’instance de Azure Cache pour 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 s’affiche également 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 que vous voyiez
3/3sous laREADYcolonne et3sous laAVAILABLEcolonne, puis utilisez Ctrl+C pour arrêter lekubectlprocessus de surveillance.
Tester 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 l’attente à une adresse IP publique réelle, utilisez Ctrl+C pour arrêter le kubectl processus 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 n’est pas chargée correctement, c’est parce que l’application démarre. Vous pouvez attendre un certain temps et actualiser la page ultérieurement. Vous devez voir le nom du pod de vos réplicas d’application affichés en haut à gauche de la page (javaee-cafe-jcache-cluster-77d54bccd4-5xnzx pour ce cas).
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, le nombre d’envois s’affiche : 1 affiché en bas à gauche de la page.
Pour démontrer que le cache de session est conservé sur tous les réplicas de l’application, exécutez la commande suivante pour supprimer le réplica actuel avec le nom javaee-cafe-jcache-cluster-<pod id from your running app>du pod :
kubectl delete pod javaee-cafe-jcache-cluster-77d54bccd4-5xnzx
pod "javaee-cafe-jcache-cluster-77d54bccd4-5xnzx" deleted
Actualisez ensuite 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 autre nom de pod s’affiche en haut à gauche de la page.
Enfin, procédez comme suit pour montrer que les données de session sont conservées dans l’instance Azure Cache pour Redis. Vous pouvez émettre des commandes à votre instance de Azure Cache pour Redis à l’aide de la console Redis.
Recherchez votre instance de Azure Cache pour Redis à partir du 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 café.model.entity.Coffee[id=1, name=Coffee 3, price=30.0] à partir de la page web, qui est le café que vous avez créé et conservé dans l’instance de Azure Cache pour 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 pour Redis, recherchez son nom de 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 :
Commentaires
Bientôt disponible : Tout au long de 2024, nous allons supprimer progressivement GitHub Issues comme mécanisme de commentaires pour le contenu et le remplacer par un nouveau système de commentaires. Pour plus d’informations, consultez https://aka.ms/ContentUserFeedback.
Envoyer et afficher des commentaires pour