Usar o Java EE JCache com o Open Liberty ou WebSphere Liberty em um cluster do AKS (Serviço de Kubernetes do Azure)

Artigo
01/10/2025

Este artigo descreve como usar o Java EE JCache em um aplicativo conteinerizado implantado no AKS.

Neste guia, você vai:

Crie a infraestrutura para executar seu aplicativo Java, Java EE, Jakarta EE ou MicroProfile no runtime do Open Liberty ou do WebSphere Liberty.
Use o Java EE JCache com suporte do Azure Cache for Redis como cache de sessão.
Crie a imagem do Docker do aplicativo usando as imagens de contêiner do Open Liberty ou do WebSphere Liberty.
Implantar o aplicativo em contêineres em um cluster AKS usando o Open Liberty Operator.

Este artigo tem o objetivo de ajudá-lo a iniciar rapidamente a implementação. Antes de acessar a produção, você deve explorar o Ajuste do Liberty.

Se você tiver interesse em fornecer feedback ou trabalhar em seus cenários de migração em estreita colaboração com a equipe de engenharia que desenvolve o WebSphere para as soluções do Azure, responda a essa breve pesquisa sobre migração para o WebSphere e inclua seus dados de contato. A equipe de gerentes de programas, arquitetos e engenheiros entrará em contato prontamente com você para dar início a uma estreita colaboração.

Pré-requisitos

Uma assinatura do Azure. Se você não tiver uma assinatura do Azure, crie uma conta gratuita antes de começar.
Prepare um computador local com sistema operacional semelhante ao Unix instalado - por exemplo, Ubuntu, macOS ou o Subsistema do Windows para Linux.
Instale a CLI do Azure para executar comandos da CLI do Azure.
- Entre com a CLI do Azure usando o comando az login. Para concluir o processo de autenticação, siga as etapas exibidas no terminal. Para ver outras opções de entrada, consulte Conectar-se ao Azure com a CLI do Azure.
- Quando solicitado, instale a extensão da CLI do Azure no primeiro uso. Para obter mais informações sobre extensões, confira Usar e gerenciar extensões com a CLI do Azure.
- Execute az version para localizar a versão e as bibliotecas dependentes instaladas. Para atualizar para a versão mais recente, execute az upgrade.
Instale uma implementação Java SE versão 17 ou posterior – por exemplo, o build da Microsoft do OpenJDK.
Instale o Maven 3.5.0 ou posterior.
Instalar o Docker para o seu sistema operacional.
Verifique se o Git está instalado.
Verifique se foi atribuída a você a função Owner ou as funções Contributor e User Access Administrator para a assinatura. Você pode verificar as atribuições seguindo as etapas em Listar atribuições de função para um usuário ou grupo.

Criar a infraestrutura

As etapas nesta seção orientam você a criar a infraestrutura de aplicativo no Azure. Depois de concluir essas etapas, você tem um Registro de Contêiner do Azure, um cluster do Serviço de Kubernetes do Azure e uma instância do Cache do Azure para Redis para executar o aplicativo de exemplo.

Criar um grupo de recursos

Um grupo de recursos do Azure é um grupo lógico no qual os recursos do Azure são implantados e gerenciados.

Crie um grupo de recursos chamado java-liberty-project usando o comando az group create no local eastus. Esse grupo de recursos é usado posteriormente para criar a instância de ACR (Registro de Contêiner do Azure) e o cluster do AKS.

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

Criar uma instância de ACR

Use o comando az acr create para criar a instância do ACR. O exemplo a seguir cria uma instância do ACR chamada youruniqueacrname. Verifique se youruniqueacrname é exclusivo no Azure.

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

Após um curto período, você deverá ver uma saída JSON que contém:

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

Como alternativa, você pode criar uma instância do registro de contêiner do Azure de acordo com as etapas em Início Rápido: Criar um registro de contêiner do Azure usando o portal do Azure.

Conecte-se à instância de ACR

Você precisa entrar na instância do ACR antes de poder fazer push de uma imagem para ela. Execute os seguintes comandos para verificar a conexão:

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

Observação

O uso de credenciais de nome de usuário e senha para conceder acesso a um registro de contêiner não é incentivado. Se os seus requisitos de uso específicos sugerirem que o acesso baseado em credenciais seja a melhor abordagem, você poderá obter o nome de usuário e a senha usando az acr credential show e usar esses valores com docker login.

Você deverá ver Login Succeeded no final da saída do comando se tiver entrado na instância do ACR com êxito.

Se você encontrar um problema ao entrar no registro de contêiner do Azure, consulte Solucionar problemas de logon do registro.

Criar um cluster AKS

Use o comando az aks create para criar um cluster do AKS e conceder a ele permissão de pull de imagem da instância do ACR. O exemplo a seguir cria um cluster chamado myAKSCluster com um nó. Esse comando leva vários minutos para ser concluído.

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

Após alguns minutos, o comando será concluído e retornará informações no formato JSON sobre o cluster, incluindo as seguintes linhas:

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

Conecte-se ao cluster do AKS

Para gerenciar um cluster do Kubernetes, use kubectl, o cliente de linha de comando do Kubernetes. Para instalar kubectl localmente, use o comando az aks install-cli:

az aks install-cli

Para configurar kubectl para se conectar ao cluster do Kubernetes, use o comando az aks get-credentials. Este comando baixa as credenciais e configura a CLI do Kubernetes para usá-las.

az aks get-credentials \
    --resource-group $RESOURCE_GROUP_NAME \
    --name $CLUSTER_NAME \
    --overwrite-existing

Para verificar a conexão com o cluster, use o comando kubectl get para retornar uma lista dos nós de cluster.

kubectl get nodes

A saída de exemplo a seguir mostra o único nó criado nas etapas anteriores. Certifique-se de que o status do nó esteja Ready.

NAME                                STATUS   ROLES   AGE     VERSION
aks-nodepool1-xxxxxxxx-yyyyyyyyyy   Ready    agent   76s     v1.18.10

Instalar o Open Liberty Operator

Depois de criar e conectar-se ao cluster, instale o Open Liberty Operator executando os comandos a seguir.

# 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

Criar uma instância de Cache do Azure para Redis

O Azure Cache for Redis dá suporte à persistência do HttpSession para um aplicativo Java em execução em um servidor Open Liberty ou WebSphere Liberty. Siga as etapas nesta seção para criar uma instância do Azure Cache for Redis e anote suas informações de conexão. Vamos usar essas informações mais tarde.

Siga as etapas em Início Rápido: Usar o Azure Cache for Redis no Java até, mas não incluindo, Noções básicas sobre o exemplo de Java.

Observação

Na etapa 7 da seção Criar um Cache do Azure para Redis, selecione Autenticação de Chaves de Acesso para a opção Autenticação no painel Avançado deste guia. Para garantir a segurança ideal, recomendamos que você use o Microsoft Entra ID com identidades gerenciadas para autorizar solicitações ao seu cache, se possível. A autorização usando a ID do Microsoft Entra e identidades gerenciadas fornece segurança superior e facilidade de uso sobre a autorização de chave de acesso compartilhado. Para obter mais informações sobre como usar identidades gerenciadas com seu cache, consulte Usar a ID do Microsoft Entra para autenticação de cache.
Copie o Nome do host e a Chave de acesso primária para sua instância do Azure Cache for Redis e execute os seguintes comandos para adicionar variáveis de ambiente:
```
export REDISCACHEHOSTNAME=<YOUR_HOST_NAME>
export REDISCACHEKEY=<YOUR_PRIMARY_ACCESS_KEY>
```

Compilar o aplicativo

Siga as etapas nesta seção para criar e conteinerizar o aplicativo de exemplo. Essas etapas usam o Maven, liberty-maven-plugin e az acr build. Para saber mais sobre o liberty-maven-plugin, confira Como compilar um aplicativo Web com o Maven.

Fazer check-out do aplicativo

Use os comandos a seguir para clonar o código de exemplo para este guia. O exemplo está no repositório open-liberty-on-aks no GitHub. Há alguns exemplos no repositório. Este artigo 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 você vir uma mensagem sobre estar no estado detached HEAD, essa mensagem pode ser ignorada. Isso só quer dizer que você verificou uma etiqueta.

O aplicativo tem a seguinte estrutura de arquivos:

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

Os diretórios java, resources e webapp contêm o código-fonte do aplicativo de exemplo.

No diretório aks, o arquivo de implantação openlibertyapplication.yaml é usado para implantar a imagem do aplicativo.

No diretório docker, colocamos dois Dockerfiles. O Dockerfile é usado para construir a imagem com o Open Liberty e o Dockerfile-wlp é usado para construir a imagem com o WebSphere Liberty.

No diretório liberty/config, o arquivo server.xml é usado para configurar o cache de sessão para o cluster do Open Liberty e do WebSphere Liberty.

No diretório redisson, o arquivo redisson-config.yaml é usado para configurar a conexão da instância do Azure Cache for Redis.

Colocar o aplicativo em um contêiner

Para implantar e executar seu aplicativo Liberty no cluster do AKS, siga estas etapas para conteinerizar seu aplicativo como uma imagem Docker. É possível usar imagens de contêiner do Open Liberty ou imagens de contêiner do WebSphere Liberty.

Verifique se o diretório de trabalho atual é java-app-jcache em seu clone local.
Execute mvn clean package para empacotar o aplicativo.
Execute mvn -Predisson validate para copiar o arquivo de configuração Redisson para o local especificado. Esta etapa insere os valores das variáveis de ambiente REDISCACHEHOSTNAME e REDISCACHEKEY no arquivo redisson-config.yaml, que é referenciado pelo arquivo server.xml.

Execute mvn liberty:dev para testar o aplicativo. Você deverá ver The defaultServer server is ready to run a smarter planet. na saída do comando se o teste for bem-sucedido. Você deverá ver uma saída semelhante ao exemplo a seguir, se a conexão Redis for bem-sucedida.

[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

Você pode acessar http://localhost:9080/ para ver o aplicativo em execução, mas a prova de que o Redis está funcionando é a saída listada na etapa anterior.
Use Ctrl+C para interromper o aplicativo.

Use os seguintes comandos para recuperar valores para propriedades artifactId e version definidos no arquivo 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)

Execute cd target para alterar o diretório para o build da amostra.

Execute um dos comandos a seguir para criar a imagem do aplicativo e enviá-la por push para a instância de ACR.

Use o comando a seguir para criar com a imagem base do Open Liberty se preferir usar o Open Liberty como um runtime Java™ de software livre leve:

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

Use o comando a seguir para criar com a imagem base do WebSphere Liberty se preferir usar uma versão comercial do 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 .

Implantar o aplicativo

Siga as etapas nesta seção para implantar o aplicativo conteinerizado de exemplo no cluster do AKS.

Verifique se o diretório de trabalho atual é java-app-jcache/target em seu clone local.

Use os comandos a seguir para criar um segredo com informações de configuração do Redisson. Com esse segredo, o aplicativo pode se conectar à instância criada do Azure Cache for Redis.

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

Execute os comandos a seguir para implantar seu aplicativo Liberty com três réplicas no cluster do AKS. A saída do comando também é mostrada embutida.

# 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

Aguarde até que você veja 3/3 na coluna READY e 3 na coluna AVAILABLE e, em seguida, use Ctrl + C para interromper o processo de inspeção kubectl.

Testar o aplicativo

Quando o aplicativo for executado, o serviço de balanceamento de carga do Kubernetes expõe o aplicativo front-end à internet. Esse processo pode levar algum tempo para ser concluído.

Para monitorar o progresso, use o comando kubectl get service com o argumento --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

Depois que o endereço EXTERNAL-IP for alterado de pending para um endereço IP público real, use Ctrl+C para interromper o processo de inspeção do kubectl.

Abra um navegador da Web para o endereço IP externo do seu serviço (20.84.16.169 para o exemplo anterior) para ver a home page do aplicativo. Se a página não for carregada corretamente, é porque o aplicativo está sendo iniciado. Aguarde e atualize a página mais tarde. Você deverá ver o nome do pod das réplicas do seu aplicativo exibido no canto superior esquerdo da página (javaee-cafe-jcache-cluster-77d54bccd4-5xnzx para esse caso).

Captura de tela do aplicativo Java Liberty implantado com sucesso no AKS.

No formulário Novo café na sessão, defina valores para os campos Nome e Preço e, em seguida, selecione Enviar. Após alguns segundos, você verá Contagem de envios: 1, que aparece na parte inferior esquerda da página.

Captura de tela do aplicativo de exemplo mostrando o novo café criado e persistido na sessão do aplicativo.

Para demonstrar que o cache de sessão é persistente em todas as réplicas do aplicativo, execute o seguinte comando para excluir a réplica atual com o nome de 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

Em seguida, atualize a página inicial do aplicativo. Você verá os mesmos dados exibidos na seção Novo café na sessão, mas um nome de pod diferente exibido no canto superior esquerdo da página.

Por fim, siga estas etapas para demonstrar que os dados da sessão são mantidos na instância do Azure Cache for Redis. Você pode emitir comandos para sua instância do Azure Cache for Redis usando o Console do Redis.

No portal do Azure, localize seu Azure Cache for Redis.
Selecione Console para abrir o console do Redis.

Execute os seguintes comandos para ver os dados da sessão:

scan 0 count 1000 match '*'

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

Procure cafe.model.entity.Coffee[id=1, name=Coffee 3, price=30.0] na página da Web, que é o café que você criou e persistiu na instância do Azure Cache for Redis.

Limpar os recursos

Para evitar cobranças do Azure, limpe recursos desnecessários. Quando o cluster não for mais necessário, use o comando az group delete para remover o grupo de recursos, o serviço de contêiner, o registro de contêiner e todos os recursos relacionados.

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

Para excluir a instância do Azure Cache for Redis, localize o nome do grupo de recursos e execute o seguinte comando:

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

Próximas etapas

Você pode saber mais sobre as referências usadas neste guia:

Para explorar as opções para executar produtos WebSphere no Azure, consulte Quais são as soluções para executar a família de produtos WebSphere no Azure?

Compartilhar via