Usar Java EE JCache com Open Liberty ou WebSphere Liberty em um cluster do Azure Kubernetes Service (AKS)

  • Artigo

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

Neste guia, você:

  • Crie a infraestrutura para executar seu aplicativo Java, Java EE, Jakarta EE ou MicroProfile no tempo de execução do Open Liberty ou WebSphere Liberty.
  • Use Java EE JCache apoiado pelo Cache Redis do Azure como cache de sessão.
  • Crie a imagem do Docker do aplicativo usando imagens de contêiner Open Liberty ou WebSphere Liberty.
  • Implante o aplicativo conteinerizado em um cluster AKS usando o Open Liberty Operator.

Este artigo destina-se a ajudá-lo a chegar rapidamente à implantação. Antes de ir para a produção, você deve explorar Tuning Liberty.

Se você estiver interessado em fornecer comentários ou trabalhar em estreita colaboração em seus cenários de migração com a equipe de engenharia que desenvolve soluções WebSphere on Azure, preencha esta breve pesquisa sobre migração do WebSphere e inclua suas informações de contato. A equipe de gerentes de programa, arquitetos e engenheiros entrará prontamente em contato com você para iniciar uma estreita colaboração.

Pré-requisitos

  • Uma subscrição do Azure. Se não tiver uma subscrição do Azure, crie uma conta gratuita antes de começar.
  • Prepare uma máquina local com o sistema operacional Unix-like instalado - por exemplo, Ubuntu, macOS ou Windows Subsystem 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 os passos apresentados no seu terminal. Consulte Entrar no Azure com a CLI do Azure para obter outras opções de entrada.
    • Quando solicitado, instale a extensão da CLI do Azure na primeira utilização. Para obter mais informações sobre extensões, consulte Usar e gerenciar extensões com a CLI do Azure.
    • Execute o comando az version para localizar a versão e as bibliotecas dependentes instaladas. Para atualizar para a versão mais recente, execute o comando az upgrade.
  • Instale uma implementação Java SE versão 17 ou posterior - por exemplo, compilação Microsoft do OpenJDK.
  • Instale o Maven 3.5.0 ou superior.
  • Instale o Docker para seu sistema operacional.
  • Verifique se o Git está instalado.
  • Certifique-se de que lhe foi atribuída uma Owner função ou Contributor funções User Access Administrator para a subscrição. Você pode verificar suas 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ê terá um Registro de Contêiner do Azure, um cluster do Serviço 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 implementados e geridos.

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 do Registro de Contêiner do Azure (ACR) e o cluster AKS.

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

Criar uma instância ACR

Use o comando az acr create para criar a instância do ACR. O exemplo a seguir cria uma instância ACR chamada youruniqueacrname. Certifique-se de que 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 de tempo, você 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 seguindo as etapas em Guia de início rápido : Criar um registro de contêiner do Azure usando o portal do Azure.

Conectar-se à instância ACR

Você precisará entrar na instância do ACR antes de enviar uma imagem por push 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

Nota

O uso de credenciais de nome de usuário e senha para conceder acesso a um registro de contêiner é desencorajado. Se seus requisitos específicos de uso sugerirem que o acesso baseado em credenciais é 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ê deve ver Login Succeeded no final da saída do comando se você entrou na instância ACR com êxito.

Se vir um problema ao iniciar sessão no registo de contentor do Azure, consulte Resolução de problemas de início de sessão do registo.

Criar um cluster do AKS

Use o comando az aks create para criar um cluster AKS e conceda-lhe permissão de pull de imagem da instância ACR. O exemplo seguinte cria um cluster com o nome myAKSCluster com um nó. Este 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 conclui e retorna informações formatadas em JSON sobre o cluster, incluindo as seguintes linhas:

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

Conectar-se ao cluster AKS

Para gerenciar um cluster 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 ligar ao cluster do Kubernetes, utilize o comando az aks get-credentials. Este comando baixa 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 ligação ao cluster, utilize o comando kubectl get para devolver uma lista de nós do cluster.

kubectl get nodes

A saída de exemplo seguinte mostra o nó único criado nos passos anteriores. Verifique se o status do nó é Pronto.

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

# 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 do Cache do Azure para Redis

O Cache do Azure para Redis apoia a HttpSession persistência do 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 Cache Redis do Azure e anote suas informações de conexão. Usaremos essas informações mais tarde.

  1. Siga as etapas em Guia de início rápido: use o Cache do Azure para Redis em Java até, mas não incluindo Noções básicas sobre o exemplo Java.

    Nota

    Na etapa 6 da seção Criar um Cache do Azure para Redis, selecione Autenticação de Chaves de Acesso para a opção Autenticação . Essa opção é necessária para que o aplicativo de exemplo se conecte à instância do Cache Redis do Azure usando a biblioteca de cliente Redisson . Consulte Configuração do Redisson para obter mais informações.

  2. Copie o nome do host e a chave de acesso primária para sua instância do Cache Redis do Azure e execute os seguintes comandos para adicionar variáveis de ambiente:

    export REDISCACHEHOSTNAME=<YOUR_HOST_NAME>
export REDISCACHEKEY=<YOUR_PRIMARY_ACCESS_KEY>

Criar a aplicação

Siga as etapas nesta seção para criar e colocar em contêineres o aplicativo de exemplo. Essas etapas usam Maven, liberty-maven-plugin, e az acr build. Para saber mais sobre o , consulte Criando um aplicativo Web com o liberty-maven-pluginMaven.

Confira o aplicativo

Use os comandos a seguir para clonar o código de exemplo deste guia. A amostra está no repositório open-liberty-on-aks no GitHub. Existem algumas amostras 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 vir uma mensagem sobre estar no estado "HEAD desanexado", é seguro ignorá-la. Isso significa apenas que você fez check-out de uma tag.

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. Dockerfile é usado para construir imagem com Open Liberty e Dockerfile-wlp é usado para construir imagem com WebSphere Liberty.

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

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

Colocar a aplicação num contentor

Para implantar e executar seu aplicativo Liberty no cluster AKS, use as etapas a seguir para colocar seu aplicativo em contêineres como uma imagem do Docker. É possível usar imagens de contêiner do Open Liberty ou imagens de contêiner do WebSphere Liberty.

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

  2. Execute mvn clean package para empacotar o aplicativo.

  3. Execute mvn -Predisson validate para copiar o arquivo de configuração Redisson para o local especificado. Esta etapa insere os valores das variáveis REDISCACHEHOSTNAME de ambiente e REDISCACHEKEY no arquivo redisson-config.yaml , que é referenciado pelo arquivo server.xml .

  4. Execute mvn liberty:dev para testar o aplicativo. Se o teste for bem-sucedido, você verá The defaultServer server is ready to run a smarter planet. na saída do comando. Você verá uma saída semelhante à seguinte 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

  5. Você pode visitar 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.

  6. Use Ctrl+C para parar o aplicativo.

  7. Use os comandos a seguir 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)

  8. Execute cd target para alterar o diretório para a compilação do exemplo.

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

    • Use o seguinte comando para construir com uma imagem base do Open Liberty se preferir usar o Open Liberty como um tempo de execução Java™ de código aberto 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 seguinte comando para construir com uma 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 .

Implementar a aplicação

Siga as etapas nesta seção para implantar o aplicativo de amostra em contêiner no cluster AKS.

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

  2. Use os comandos a seguir para criar um segredo com as informações de configuração do Redisson. Com esse segredo, o aplicativo pode se conectar à instância criada do Cache do Azure para 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

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

    # 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. Aguarde até ver 3/3 sob a READY coluna e 3 sob a AVAILABLE coluna e, em seguida, use Ctrl+C para interromper o processo de kubectl observação.

Testar a aplicação

Quando o aplicativo é executado, um serviço de balanceador de carga do Kubernetes expõe o front-end do aplicativo à Internet. Este processo pode demorar algum tempo a concluir.

Para monitorizar o progresso, utilize 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

Quando o endereço EXTERNAL-IP mudar de pendente para um endereço IP público real, use Ctrl+C para interromper o kubectl processo de monitoramento.

Abra um navegador da Web para o endereço IP externo do seu serviço (20.84.16.169 para o exemplo acima) para ver a página inicial do aplicativo. Se a página não estiver carregada corretamente, é porque o aplicativo está iniciando. Você pode esperar um pouco e atualizar a página mais tarde. Você deve 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 este caso).

Screenshot da aplicação Java liberty implementada com sucesso em A K S.

No formulário Novo café na sessão, defina valores para os campos Nome e Preço e selecione Enviar. Após alguns segundos, você verá Enviar contagem: 1 exibido 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 javaee-cafe-jcache-cluster-<pod id from your running app>do pod :

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, use as etapas a seguir para demonstrar que os dados da sessão são persistentes na instância do Cache do Azure para Redis. Você pode emitir comandos para sua instância do Cache do Azure para Redis usando o Console Redis.

  1. Encontre sua instância do Cache do Azure para Redis no portal do Azure.

  2. Selecione Console para abrir o console Redis.

  3. Execute os seguintes comandos para exibir os dados da sessão:

    scan 0 count 1000 match '*'

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

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

Clean up resources (Limpar recursos)

Para evitar cobranças do Azure, você deve limpar 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 Cache do Azure para 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óximos passos

Você pode aprender mais com as referências usadas neste guia:

Para explorar 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?