Usare Java edizione Enterprise JCache con Open Liberty o WebSphere Liberty in un cluster servizio Azure Kubernetes (AKS)

  • Articolo

Questo articolo descrive come usare Java edizione Enterprise 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 edizione Enterprise, Jakarta edizione Enterprise o MicroProfile nel runtime Open Liberty o WebSphere Liberty.
  • Usare Java edizione Enterprise JCache supportato da cache di Azure per Redis come cache della 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 non si ha una sottoscrizione di Azure, creare un account gratuito prima di iniziare.

Prerequisiti

  • Questo articolo richiede l'ultima versione dell'interfaccia della riga di comando di Azure. Se si usa Azure Cloud Shell, la versione più recente è già installata.
  • Se si eseguono i comandi in questa guida in locale (anziché Azure Cloud Shell):
    • Preparare un computer locale con sistema operativo simile a Unix installato (ad esempio Ubuntu, macOS sottosistema Windows per Linux).
    • Installare un'implementazione di Java edizione Standard, versione 17 o successiva (ad esempio, Eclipse Open J9).
    • Installare Maven 3.5.0 o versione successiva.
    • Installare Docker per il sistema operativo.
  • Assicurarsi di essere stati assegnati a Owner ruoli o ContributorUser Access Administrator ruoli 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, si avrà un Registro Azure Container, un cluster servizio Azure Kubernetes e un'istanza di cache di Azure per Redis 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 località eastus . Questo gruppo di risorse verrà 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 Registro Azure Container 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 \
    --admin-enabled

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.

Connessione all'istanza di Registro Azure Container

È necessario accedere all'istanza di Registro Azure Container prima di poter eseguire il push di 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)
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

Se è stato eseguito correttamente l'accesso all'istanza di Registro Azure Container, 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 servizio Azure Kubernetes create per creare un cluster del servizio Azure Kubernetes e concedere all'immagine l'autorizzazione pull dall'istanza del Registro Azure Container. L'esempio seguente crea un cluster denominato myAKSCluster con un nodo. Il completamento di questo comando richiederà alcuni 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",

Connessione al cluster del servizio Azure Kubernetes

Per gestire un cluster Kubernetes, usare kubectl, il client della riga di comando Kubernetes. Se si usa Azure Cloud Shell, kubectl è già installato. Per installare kubectl in locale, usare il comando az aks install-cli:

az aks install-cli

Per configurare kubectl per la connessione al cluster Kubernetes, usare il comando az servizio Azure Kubernetes 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 Pronto.

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

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.

  1. Seguire la procedura descritta in Avvio rapido: Usare cache di Azure per Redis in Java fino a, ma non includere Informazioni sull'esempio Java.

  2. 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 20230906

Se viene visualizzato un messaggio relativo allo stato "HEAD scollegato", questo messaggio è sicuro da ignorare. Significa semplicemente che hai estratto 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.

  1. Passare alla directory java-app-jcache del clone locale.

  2. Eseguire mvn clean package per creare un pacchetto dell'applicazione.

  3. Eseguire mvn -Predisson validate per copiare il file di configurazione redisson nel percorso specificato. Questo passaggio inserisce i valori delle variabili REDISCACHEHOSTNAME di ambiente e REDISCACHEKEY nel file redisson-config.yaml a cui fa riferimento il file server.xml .

  4. Eseguire mvn liberty:dev per testare l'applicazione. Se il test ha esito positivo, verrà visualizzato The 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.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:6380

  5. È possibile visitare http://localhost:9080/ per visualizzare l'applicazione in esecuzione, ma la prova di funzionamento di Redis è l'output elencato nel passaggio precedente.

  6. Usare CTRL+C per arrestare l'applicazione.

  7. Usare i comandi seguenti per recuperare i valori per le proprietà artifactId e version definiti 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)

  8. Eseguire cd target per modificare la directory alla compilazione dell'esempio.

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

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

Distribuire l'applicazione

Seguire la procedura descritta in questa sezione per distribuire l'applicazione di esempio in contenitori nel cluster del servizio Azure Kubernetes.

  1. Verificare che la directory di lavoro corrente sia java-app-jcache/target nel clone locale.

  2. 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.yaml

  3. Usare 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           20s

  4. Attendere fino a quando non viene visualizzato 3/3 sotto la READY colonna e 3 sotto la AVAILABLE colonna, quindi usare CTRL+C per arrestare il kubectl processo 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, 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

Quando l'indirizzo EXTERNAL-IP passa da in sospeso a un indirizzo IP pubblico effettivo, usare CTRL+C per arrestare il processo di kubectl controllo.

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. Verrà visualizzato il nome del pod delle repliche dell'applicazione visualizzato in alto a sinistra nella pagina (javaee-cafe-jcache-cluster-77d54bccd4-5xnzx per questo caso).

Screenshot of Java liberty application successfully deployed on 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 of sample application showing new coffee created and persisted in the session of the application.

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 verranno visualizzati gli stessi dati, ma nella parte superiore sinistra della pagina verrà 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.

  1. Trovare l'istanza di cache di Azure per Redis dal portale di Azure.

  2. Selezionare Console per aprire la console Redis.

  3. Eseguire i comandi seguenti per visualizzare i dati della sessione:

    scan 0 count 1000 match '*'

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

  4. 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 di Azure, è consigliabile pulire 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: