Usare Java EE JCache con Open Liberty o WebSphere Liberty in un cluster servizio Azure Kubernetes (AKS)
Questo articolo descrive come usare Java EE JCache in un'applicazione in contenitori distribuita nel servizio Azure Kubernetes.
In questa guida si apprenderà quanto segue:
- Creare l'infrastruttura per eseguire l'applicazione Java, Java EE, Jakarta EE o MicroProfile nel runtime Open Liberty o WebSphere Liberty.
- Usare Java EE JCache supportato da cache di Azure per Redis come cache di sessione.
- Compilare l'immagine Docker dell'applicazione usando immagini del contenitore Open Liberty o WebSphere Liberty.
- Distribuire l'applicazione in contenitori in un cluster del servizio Azure Kubernetes usando Open Liberty Operator.
Questo articolo è progettato per facilitare rapidamente la distribuzione. Prima di passare alla produzione, è consigliabile esplorare Tuning Liberty.
Se si è interessati a fornire commenti e suggerimenti o lavorare sugli scenari di migrazione in stretta collaborazione con il team di progettazione che sviluppa WebSphere nelle soluzioni di Azure, compilare questo breve sondaggio sulla migrazione di WebSphere e includere le informazioni di contatto. Il team di responsabili del programma, architetti e ingegneri si metterà immediatamente in contatto con l'utente per avviare una stretta collaborazione.
Prerequisiti
- Una sottoscrizione di Azure. Se non si ha una sottoscrizione di Azure, creare un account gratuito prima di iniziare.
- Prepara un computer locale con un sistema operativo simile a Unix installato, ad esempio Ubuntu, Azure Linux, macOS, Sottosistema Windows per Linux.
- Installare l'interfaccia della riga di comando di Azure per eseguire i comandi dell'interfaccia della riga di comando di Azure.
- Accedi con Azure CLI usando il comando
az login. Per completare il processo di autenticazione, seguire la procedura visualizzata nel terminale. Per altre opzioni di accesso, vedere Accedere ad Azure con l'interfaccia della riga di comando di Azure . - Quando richiesto, al primo utilizzo installare l'estensione dell'interfaccia della riga di comando di Azure. Per altre informazioni sulle estensioni, vedere Usare e gestire le estensioni con l'interfaccia della riga di comando di Azure.
- Eseguire
az versionper trovare la versione e le librerie dipendenti installate. Per eseguire l'aggiornamento alla versione più recente, eseguireaz upgrade.
- Accedi con Azure CLI usando il comando
- Installare un'implementazione Java edizione Standard versione 17 o successiva, ad esempio la versione Microsoft di OpenJDK.
- Installare Maven 3.5.0 o versione successiva.
- Installare Docker per il sistema operativo.
- Assicurarsi che Git sia installato.
- Assicurarsi di essere stati assegnati a
Ownerruoli oContributorUser Access Administratorruoli per la sottoscrizione. È possibile verificare le assegnazioni seguendo la procedura descritta in Elencare le assegnazioni di ruolo per un utente o un gruppo.
Creare l'infrastruttura
I passaggi descritti in questa sezione illustrano come creare l'infrastruttura dell'applicazione in Azure. Dopo aver completato questi passaggi, è disponibile un registro Azure Container, un cluster del servizio Azure Kubernetes e un'istanza di Cache Redis di Azure per l'esecuzione dell'applicazione di esempio.
Creare un gruppo di risorse
Un gruppo di risorse di Azure è un gruppo logico in cui le risorse di Azure vengono distribuite e gestite.
Creare un gruppo di risorse denominato java-liberty-project usando il comando az group create nella posizione eastus. Questo gruppo di risorse viene usato in un secondo momento per creare l'istanza di Registro Azure Container (ACR) e il cluster del servizio Azure Kubernetes.
export RESOURCE_GROUP_NAME=java-liberty-project
az group create --name $RESOURCE_GROUP_NAME --location eastus
Creare un'istanza di Registro Azure Container
Usare il comando az acr create per creare l'istanza di Registro Azure Container. Nell'esempio seguente viene creata un'istanza di ACR denominata youruniqueacrname. Assicurarsi che youruniqueacrname sia univoco all'interno di Azure.
export REGISTRY_NAME=youruniqueacrname
az acr create \
--resource-group $RESOURCE_GROUP_NAME \
--name $REGISTRY_NAME \
--sku Basic
Dopo un breve periodo di tempo, dovrebbe essere visualizzato un output JSON che contiene:
"provisioningState": "Succeeded",
"publicNetworkAccess": "Enabled",
"resourceGroup": "java-liberty-project",
In alternativa, è possibile creare un'istanza del Registro Azure Container seguendo la procedura descritta in Avvio rapido: Creare un registro contenitori di Azure usando il portale di Azure.
Connettersi all'istanza di Registro Azure Container
È necessario accedere all'istanza di Azure Container Registry prima di poter pushare un'immagine. Eseguire i comandi seguenti per verificare la connessione:
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
Nota
L'uso di credenziali di nome utente e password per concedere l'accesso a un registro contenitori è sconsigliato. Se i requisiti di utilizzo specifici suggeriscono l'accesso basato sulle credenziali è l'approccio migliore, è possibile ottenere il nome utente e la password usando az acr credential show e usare questi valori con docker login.
Se è stato eseguito correttamente l'accesso all'istanza di ACR, verrà visualizzato Login Succeeded alla fine dell'output del comando.
Se viene visualizzato un problema durante l'accesso al Registro Azure Container, vedere Risolvere i problemi di accesso al Registro di sistema.
Creare un cluster del servizio Azure Kubernetes
Usare il comando az aks create per creare un cluster AKS e concedergli l'autorizzazione per il pull delle immagini dall'istanza ACR. Nell'esempio seguente viene creato un cluster denominato myAKSCluster con un nodo. Il completamento di questo comando richiede diversi minuti.
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
Dopo alcuni minuti, il comando completa e restituisce informazioni in formato JSON sul cluster, incluse le righe seguenti:
"nodeResourceGroup": "MC_java-liberty-project_myAKSCluster_eastus",
"privateFqdn": null,
"provisioningState": "Succeeded",
"resourceGroup": "java-liberty-project",
Connettersi al cluster servizio Azure Kubernetes
Per gestire un cluster Kubernetes, usare kubectl, il client della riga di comando Kubernetes. Per installare kubectl in locale, usare il comando az aks install-cli:
az aks install-cli
Per configurare kubectl per connettersi al cluster Kubernetes, usare il comando az aks get-credentials. Questo comando scarica le credenziali e configura l'interfaccia della riga di comando di Kubernetes per usarli.
az aks get-credentials \
--resource-group $RESOURCE_GROUP_NAME \
--name $CLUSTER_NAME \
--overwrite-existing
Per verificare la connessione al cluster, usare il comando kubectl get per restituire un elenco di nodi del cluster.
kubectl get nodes
L'esempio di output seguente mostra il nodo singolo creato nei passaggi precedenti. Assicurarsi che lo stato del nodo sia Ready.
NAME STATUS ROLES AGE VERSION
aks-nodepool1-xxxxxxxx-yyyyyyyyyy Ready agent 76s v1.18.10
Installare Open Liberty Operator
Dopo aver creato e connesso il cluster, installare Open Liberty Operator eseguendo i comandi seguenti.
# 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
Creare un'istanza di Azure Cache per Redis
cache di Azure per Redis la persistenza di per un'applicazione Java in esecuzione all'interno di HttpSession un server Open Liberty o WebSphere Liberty. Seguire i passaggi descritti in questa sezione per creare un'istanza di cache di Azure per Redis e annotare le informazioni di connessione. Queste informazioni verranno usate in un secondo momento.
Seguire la procedura descritta in Avvio rapido: Usare cache di Azure per Redis in Java fino a, ma non includere Informazioni sull'esempio Java.
Nota
Nel passaggio 7 della sezione Creare una cache di Azure per Redis, selezionare Autenticazione delle chiavi di accesso per l'opzione Autenticazione nel riquadro Avanzato per questa guida. Per una sicurezza ottimale, è consigliabile usare Microsoft Entra ID con identità gestite per autorizzare le richieste nella cache, se possibile. L'autorizzazione tramite l'ID e le identità gestite di Microsoft Entra offre sicurezza e facilità d'uso superiori rispetto all'autorizzazione della chiave di accesso condiviso. Per altre informazioni sull'uso di identità gestite con la cache, vedere Usare l'ID Microsoft Entra per l'autenticazione della cache.
Copiare il nome host e la chiave di accesso primaria per l'istanza di cache di Azure per Redis e quindi eseguire i comandi seguenti per aggiungere variabili di ambiente:
export REDISCACHEHOSTNAME=<YOUR_HOST_NAME> export REDISCACHEKEY=<YOUR_PRIMARY_ACCESS_KEY>
Compilare l'applicazione
Seguire i passaggi descritti in questa sezione per compilare e inserire in contenitori l'applicazione di esempio. Questi passaggi usano Maven, liberty-maven-plugine az acr build. Per altre informazioni su liberty-maven-plugin, vedere Compilazione di un'applicazione Web con Maven.
Consultare l'applicazione
Usare i comandi seguenti per clonare il codice di esempio per questa guida. L'esempio si trova nel repository open-liberty-on-aks in GitHub. Nel repository sono disponibili alcuni esempi. Questo articolo usa 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
Se viene visualizzato un messaggio relativo allo stato di detached HEAD, questo messaggio è sicuro da ignorare. Significa semplicemente che hai controllato un tag.
L'applicazione ha la struttura di file seguente:
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
Le directory java, resources e webapp contengono il codice sorgente dell'applicazione di esempio.
Nella directory del servizio Azure Kubernetes il file di distribuzione openlibertyapplication.yaml viene usato per distribuire l'immagine dell'applicazione.
Nella directory docker vengono inseriti due Dockerfile. Dockerfile viene usato per creare un'immagine con Open Liberty e Dockerfile-wlp per creare un'immagine con WebSphere Liberty.
Nella directory liberty/config il file server.xml viene usato per configurare la cache delle sessioni per il cluster Open Liberty e WebSphere Liberty.
Nella directory redisson il file redisson-config.yaml viene usato per configurare la connessione dell'istanza di cache di Azure per Redis.
Distribuire l'applicazione in un contenitore
Per distribuire ed eseguire l'applicazione Liberty nel cluster del servizio Azure Kubernetes, seguire questa procedura per inserire in contenitori l'applicazione come immagine Docker. È possibile usare immagini del contenitore Open Liberty o immagini del contenitore WebSphere Liberty.
Verificare che la directory di lavoro corrente sia java-app-jcache nel clone locale.
Eseguire
mvn clean packageper creare un pacchetto dell'applicazione.Eseguire
mvn -Predisson validateper copiare il file di configurazione redisson nel percorso specificato. Questo passaggio inserisce i valori delle variabiliREDISCACHEHOSTNAMEdi ambiente eREDISCACHEKEYnel file redisson-config.yaml a cui fa riferimento il file server.xml .Eseguire
mvn liberty:devper testare l'applicazione. Se il test ha esito positivo, verrà visualizzatoThe defaultServer server is ready to run a smarter planet.nell'output del comando. Se la connessione Redis ha esito positivo, verrà visualizzato un output simile al seguente.[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È possibile visitare
http://localhost:9080/per visualizzare l'applicazione in esecuzione, ma la prova di funzionamento di Redis è l'output elencato nel passaggio precedente.Usare CTRL+C per arrestare l'applicazione.
Usare i comandi seguenti per recuperare i valori per le proprietà
artifactIdeversiondefiniti nel file 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)Eseguire
cd targetper modificare la directory alla compilazione dell'esempio.Eseguire uno dei comandi seguenti per compilare l'immagine dell'applicazione ed eseguirne il push nell'istanza di Registro Azure Container.
Usare il comando seguente per compilare con un'immagine di base Open Liberty se si preferisce usare Open Liberty come runtime Java™ open source leggero:
# 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 .Usare il comando seguente per compilare con un'immagine di base WebSphere Liberty se si preferisce usare una versione commerciale di 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 .
Distribuire l'applicazione
Seguire la procedura descritta in questa sezione per distribuire l'applicazione di esempio in contenitori nel cluster del servizio Azure Kubernetes.
Verificare che la directory di lavoro corrente sia java-app-jcache/target nel clone locale.
Usare i comandi seguenti per creare un segreto con le informazioni di configurazione di Redisson. Con questo segreto, l'applicazione può connettersi all'istanza di cache di Azure per Redis creata.
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.yamlUsare i comandi seguenti per distribuire l'applicazione Liberty con tre repliche nel cluster del servizio Azure Kubernetes. L'output del comando viene visualizzato anche inline.
# 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 20sAttendere fino a quando non viene visualizzato
3/3sotto laREADYcolonna e3sotto laAVAILABLEcolonna, quindi usare CTRL+C per arrestare ilkubectlprocesso di controllo.
Testare l'applicazione
Quando l'applicazione viene eseguita, un servizio di bilanciamento del carico Kubernetes espone il front-end dell'applicazione a Internet. Il completamento di questo processo può richiedere alcuni minuti.
Per monitorare lo stato di avanzamento, usare il comando kubectl get service con l'argomento --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
Dopo che l'indirizzo EXTERNAL-IP passa da pending a un indirizzo IP pubblico reale, usare CTRL+C per interrompere il processo di controllo kubectl.
Aprire un Web browser all'indirizzo IP esterno del servizio (20.84.16.169 per l'esempio precedente) per visualizzare la home page dell'applicazione. Se la pagina non viene caricata correttamente, è perché l'app viene avviata. È possibile attendere un po' di tempo e aggiornare la pagina in un secondo momento. Dovreste vedere il nome del pod delle repliche della vostra applicazione nell'angolo in alto a sinistra della pagina (javaee-cafe-jcache-cluster-77d54bccd4-5xnzx in questo caso).
Screenshot dell'applicazione Java liberty distribuita correttamente in A K S.
Nel modulo Nuovo caffè nella sessione impostare i valori per i campi Nome e Prezzo e quindi selezionare Invia. Dopo alcuni secondi, vedrai Conteggio invii: 1 visualizzato nella parte inferiore sinistra della pagina.
Screenshot dell'applicazione di esempio che mostra il nuovo caffè creato e salvato in modo permanente nella sessione dell'applicazione.
Per dimostrare che la cache della sessione è persistente in tutte le repliche dell'applicazione, eseguire il comando seguente per eliminare la replica corrente con il nome javaee-cafe-jcache-cluster-<pod id from your running app>del pod :
kubectl delete pod javaee-cafe-jcache-cluster-77d54bccd4-5xnzx
pod "javaee-cafe-jcache-cluster-77d54bccd4-5xnzx" deleted
Aggiornare quindi la home page dell'applicazione. Nella sezione Nuovo caffè nella sessione vengono visualizzati gli stessi dati, ma nell'angolo in alto a sinistra della pagina viene visualizzato un nome di pod diverso.
Usare infine i passaggi seguenti per dimostrare che i dati della sessione sono persistenti nell'istanza di cache di Azure per Redis. È possibile eseguire comandi all'istanza di cache di Azure per Redis usando la console Redis.
Trovare l'istanza di cache di Azure per Redis dal portale di Azure.
Selezionare Console per aprire la console Redis.
Eseguire i comandi seguenti per visualizzare i dati della sessione:
scan 0 count 1000 match '*' hgetall "com.ibm.ws.session.attr.default_host%2F"Cercare café.model.entity.Coffee[id=1, name=Coffee 3, price=30.0] dalla pagina Web, ovvero il caffè creato e salvato in modo permanente nell'istanza di cache di Azure per Redis.
Pulire le risorse
Per evitare addebiti per Azure, è necessario eliminare le risorse non necessarie. Quando il cluster non è più necessario, usare il comando az group delete per rimuovere il gruppo di risorse, il servizio contenitore, il registro contenitori e tutte le risorse correlate.
az group delete --name $RESOURCE_GROUP_NAME --yes --no-wait
Per eliminare l'istanza di cache di Azure per Redis, trovare il nome del gruppo di risorse ed eseguire il comando seguente:
az group delete --name <AZURE_CACHE_FOR_REDIS_RESOURCE_GROUP_NAME> --yes --no-wait
Passaggi successivi
Per altre informazioni, vedere i riferimenti usati in questa guida:
- Configurazione della persistenza della sessione Liberty con JCache
- Supporto di JCache di Redisson
- Aprire Configurazione di Liberty Server
Per esplorare le opzioni per eseguire prodotti WebSphere in Azure, vedere Quali sono le soluzioni per eseguire la famiglia di prodotti WebSphere in Azure?