Używanie usługi Java EE JCache z usługą Open Liberty lub WebSphere Liberty w klastrze usługi Azure Kubernetes Service (AKS)

  • Artykuł

W tym artykule opisano sposób używania usługi Java EE JCache w konteneryzowanej aplikacji wdrożonej w usłudze AKS.

W tym przewodniku wykonasz następujące instrukcje:

  • Utwórz infrastrukturę do uruchamiania aplikacji Java, Java EE, Jakarta EE lub MicroProfile w środowisku uruchomieniowym Open Liberty lub WebSphere Liberty.
  • Użyj usługi Java EE JCache wspieranej przez usługę Azure Cache for Redis jako pamięć podręczną sesji.
  • Skompiluj obraz platformy Docker aplikacji przy użyciu obrazów kontenerów Open Liberty lub WebSphere Liberty.
  • Wdróż konteneryzowaną aplikację w klastrze usługi AKS przy użyciu operatora Open Liberty.

Ten artykuł ma pomóc w szybkim rozpoczęciu wdrażania. Przed przejściem do środowiska produkcyjnego należy zapoznać się z tematem Tuning Liberty.

Jeśli nie masz subskrypcji platformy Azure, przed rozpoczęciem utwórz bezpłatne konto.

Wymagania wstępne

  • Ten artykuł wymaga najnowszej wersji interfejsu wiersza polecenia platformy Azure. Jeśli używasz usługi Azure Cloud Shell, najnowsza wersja jest już zainstalowana.
  • Jeśli uruchamiasz polecenia w tym przewodniku lokalnie (zamiast usługi Azure Cloud Shell):
    • Przygotuj maszynę lokalną z zainstalowanym systemem operacyjnym przypominającym system Unix (na przykład Ubuntu, macOS, Podsystem Windows dla systemu Linux).
    • Zainstaluj implementację środowiska Java SE w wersji 17 lub nowszej (na przykład Eclipse Open J9).
    • Zainstaluj program Maven w wersji 3.5.0 lub nowszej.
    • Zainstaluj platformę Docker dla systemu operacyjnego.
  • Upewnij się, że masz przypisaną Owner rolę lub Contributor role dla User Access Administrator subskrypcji. Możesz zweryfikować przypisania, wykonując kroki opisane w temacie Wyświetlanie listy przypisań ról dla użytkownika lub grupy.

Tworzenie infrastruktury

Kroki opisane w tej sekcji zawierają instrukcje tworzenia infrastruktury aplikacji na platformie Azure. Po wykonaniu tych kroków będziesz mieć usługę Azure Container Registry, klaster usługi Azure Kubernetes Service i wystąpienie usługi Azure Cache for Redis na potrzeby uruchamiania przykładowej aplikacji.

Tworzenie grupy zasobów

Grupa zasobów platformy Azure to logiczna grupa przeznaczona do wdrażania zasobów platformy Azure i zarządzania nimi.

Utwórz grupę zasobów o nazwie java-liberty-project przy użyciu polecenia az group create w lokalizacji eastus . Ta grupa zasobów będzie później używana do tworzenia wystąpienia usługi Azure Container Registry (ACR) i klastra usługi AKS.

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

Tworzenie wystąpienia usługi ACR

Użyj polecenia az acr create, aby utworzyć wystąpienie usługi ACR. Poniższy przykład tworzy wystąpienie usługi ACR o nazwie youruniqueacrname. Upewnij się, że nazwa youruniqueacrname jest unikatowa na platformie Azure.

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

Po krótkim czasie powinny zostać wyświetlone dane wyjściowe JSON zawierające:

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

Alternatywnie możesz utworzyć wystąpienie usługi Azure Container Registry, wykonując kroki opisane w przewodniku Szybki start: tworzenie rejestru kontenerów platformy Azure przy użyciu witryny Azure Portal.

Połączenie do wystąpienia usługi ACR

Zanim będzie można wypchnąć do niego obraz, musisz zalogować się do wystąpienia usługi ACR. Uruchom następujące polecenia, aby zweryfikować połączenie:

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

Po pomyślnym zalogowaniu się do wystąpienia usługi ACR na końcu danych wyjściowych polecenia powinny zostać Login Succeeded wyświetlone dane wyjściowe polecenia.

Jeśli widzisz problem z logowaniem do rejestru kontenerów platformy Azure, zobacz Rozwiązywanie problemów z logowaniem do rejestru.

Tworzenie klastra AKS

Użyj polecenia az aks create, aby utworzyć klaster usługi AKS i przyznać mu uprawnienie do ściągania obrazu z wystąpienia usługi ACR. W poniższym przykładzie pokazano tworzenie klastra o nazwie myAKSCluster z jednym węzłem. Wykonanie tego polecenia potrwa kilka minut.

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

Po kilku minutach polecenie zostanie zakończone i zwróci informacje w formacie JSON dotyczące klastra, w tym następujące wiersze:

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

Połączenie do klastra usługi AKS

Aby zarządzać klastrem Kubernetes, należy użyć klienta wiersza polecenia usługi Kubernetes — narzędzia kubectl. Jeśli korzystasz z usługi Azure Cloud Shell, narzędzie kubectl jest już zainstalowane. Aby zainstalować narzędzie kubectl lokalnie, użyj polecenia az aks install-cli:

az aks install-cli

Aby skonfigurować narzędzie kubectl w celu nawiązania połączenia z klastrem Kubernetes, użyj polecenia az aks get-credentials. To polecenie powoduje pobranie poświadczeń i zastosowanie ich w konfiguracji interfejsu wiersza polecenia Kubernetes.

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

Aby sprawdzić połączenie z klastrem, użyj polecenia kubectl get, aby powrócić do listy węzłów klastra.

kubectl get nodes

Poniższe przykładowe dane wyjściowe zawierają jeden węzeł utworzony w poprzednich krokach. Upewnij się, że stan węzła to Gotowe.

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

Instalowanie operatora Open Liberty

Po utworzeniu i nawiązaniu połączenia z klastrem zainstaluj operator Open Liberty, uruchamiając następujące polecenia.

# 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

Tworzenie wystąpienia pamięci podręcznej Azure Cache for Redis

Usługa Azure Cache for Redis wspiera trwałość HttpSession aplikacji Java uruchomionej na serwerze Open Liberty lub WebSphere Liberty. Wykonaj kroki opisane w tej sekcji, aby utworzyć wystąpienie usługi Azure Cache for Redis i zanotować informacje o połączeniu. Użyjemy tych informacji później.

  1. Postępuj zgodnie z instrukcjami w przewodniku Szybki start: używanie usługi Azure Cache for Redis w języku Java do, ale nie obejmuje to przykładu Języka Java.

  2. Skopiuj nazwę hosta i podstawowy klucz dostępu dla wystąpienia usługi Azure Cache for Redis, a następnie uruchom następujące polecenia, aby dodać zmienne środowiskowe:

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

Kompilowanie aplikacji

Wykonaj kroki opisane w tej sekcji, aby skompilować i konteneryzować przykładową aplikację. W tych krokach są używane narzędzia Maven, liberty-maven-plugini az acr build. Aby dowiedzieć się więcej na temat programu liberty-maven-plugin, zobacz Tworzenie aplikacji internetowej za pomocą narzędzia Maven.

Wyewidencjonowywanie aplikacji

Użyj następujących poleceń, aby sklonować przykładowy kod dla tego przewodnika. Przykład znajduje się w repozytorium open-liberty-on-aks w witrynie GitHub. W repozytorium znajduje się kilka przykładów. W tym artykule jest używana usługa java-app-jcache.

git clone https://github.com/Azure-Samples/open-liberty-on-aks.git
cd open-liberty-on-aks
git checkout 20230906

Jeśli zostanie wyświetlony komunikat o stanie "odłączony HEAD", ten komunikat jest bezpieczny do zignorowania. Oznacza to, że wyewidencjonowaliśmy tag.

Aplikacja ma następującą strukturę plików:

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

Katalogi java, resources i webapp zawierają kod źródłowy przykładowej aplikacji.

W katalogu aks plik wdrożenia openlibertyapplication.yaml służy do wdrażania obrazu aplikacji.

W katalogu docker umieszczamy dwa pliki Dockerfile. Plik Dockerfile służy do kompilowania obrazu za pomocą plików Open Liberty i Dockerfile-wlp do kompilowania obrazu za pomocą platformy WebSphere Liberty.

W katalogu liberty/config plik server.xml służy do konfigurowania pamięci podręcznej sesji dla klastra Open Liberty i WebSphere Liberty.

W katalogu redisson plik redisson-config.yaml służy do konfigurowania połączenia wystąpienia usługi Azure Cache for Redis.

Konteneryzowanie aplikacji

Aby wdrożyć i uruchomić aplikację Liberty w klastrze usługi AKS, wykonaj następujące kroki, aby konteneryzować aplikację jako obraz platformy Docker. Możesz użyć obrazów kontenerów Open Liberty lub obrazów kontenerów WebSphere Liberty.

  1. Zmień katalog na java-app-jcache lokalnego klonu.

  2. Uruchom polecenie mvn clean package , aby spakować aplikację.

  3. Uruchom polecenie mvn -Predisson validate , aby skopiować plik konfiguracji Redisson do określonej lokalizacji. Ten krok wstawia wartości zmiennych REDISCACHEHOSTNAME środowiskowych i REDISCACHEKEY do pliku redisson-config.yaml , do którego odwołuje się plik server.xml .

  4. Uruchom polecenie , mvn liberty:dev aby przetestować aplikację. Jeśli test zakończy się pomyślnie, powinien zostać wyświetlony The defaultServer server is ready to run a smarter planet. w danych wyjściowych polecenia. Jeśli połączenie z usługą Redis zakończy się pomyślnie, powinny zostać wyświetlone dane wyjściowe podobne do poniższych.

    [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. Możesz zobaczyć http://localhost:9080/ uruchomioną aplikację, ale dowód działania usługi Redis to dane wyjściowe wymienione w poprzednim kroku.

  6. Naciśnij klawisze Ctrl+C, aby zatrzymać aplikację.

  7. Użyj następujących poleceń, aby pobrać wartości właściwości artifactId i zdefiniowane w pliku pom.xmlversion.

    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. Uruchom polecenie cd target , aby zmienić katalog na kompilację przykładu.

  9. Uruchom jedno z następujących poleceń, aby skompilować obraz aplikacji i wypchnąć go do wystąpienia usługi ACR.

    • Użyj następującego polecenia, aby skompilować przy użyciu obrazu podstawowego Open Liberty, jeśli wolisz używać biblioteki Open Liberty jako uproszczonego środowiska uruchomieniowego języka Java™ typu open source:

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

    • Użyj następującego polecenia, aby skompilować przy użyciu obrazu podstawowego WebSphere Liberty, jeśli wolisz używać komercyjnej wersji oprogramowania 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 .

Wdrażanie aplikacji

Wykonaj kroki opisane w tej sekcji, aby wdrożyć konteneryzowaną przykładową aplikację w klastrze usługi AKS.

  1. Sprawdź, czy bieżący katalog roboczy to java-app-jcache/target w klonie lokalnym.

  2. Użyj następujących poleceń, aby utworzyć wpis tajny z informacjami o konfiguracji redissona. Za pomocą tego wpisu tajnego aplikacja może nawiązać połączenie z utworzonym wystąpieniem usługi 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

  3. Użyj następujących poleceń, aby wdrożyć aplikację Liberty z trzema replikami w klastrze usługi AKS. Dane wyjściowe polecenia są również wyświetlane w tekście.

    # 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. Poczekaj, aż zobaczysz 3/3 pod kolumną READY i 3 pod kolumną AVAILABLE , a następnie zatrzymaj proces zegarka kubectl za pomocą klawiszy Ctrl+C.

Testowanie aplikacji

Po uruchomieniu aplikacji usługa modułu równoważenia obciążenia Kubernetes uwidacznia fronton aplikacji w Internecie. Ukończenie tego procesu może zająć trochę czasu.

Aby monitorować postęp, użyj polecenia kubectl get-service z argumentem --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

Gdy adres EXTERNAL-IP zmieni się z oczekujące na rzeczywisty publiczny adres IP, użyj klawiszy Ctrl+C, aby zatrzymać kubectl proces oglądania.

Otwórz przeglądarkę internetową na zewnętrzny adres IP usługi (20.84.16.169 w powyższym przykładzie), aby wyświetlić stronę główną aplikacji. Jeśli strona nie jest poprawnie załadowana, oznacza to, że aplikacja jest uruchamiana. Możesz poczekać chwilę i odświeżyć stronę później. Powinna zostać wyświetlona nazwa zasobnika replik aplikacji w lewym górnym rogu strony (javaee-cafe-jcache-cluster-77d54bccd4-5xnzx w tym przypadku).

Screenshot of Java liberty application successfully deployed on A K S.

W formularzu Nowa kawa w sesji ustaw wartości pól Nazwa i Cena, a następnie wybierz pozycję Prześlij. Po kilku sekundach zobaczysz liczbę przesyłania: 1 wyświetlaną w lewym dolnym rogu strony.

Screenshot of sample application showing new coffee created and persisted in the session of the application.

Aby zademonstrować, że pamięć podręczna sesji jest utrwalana we wszystkich replikach aplikacji, uruchom następujące polecenie, aby usunąć bieżącą replikę o nazwie javaee-cafe-jcache-cluster-<pod id from your running app>zasobnika :

kubectl delete pod javaee-cafe-jcache-cluster-77d54bccd4-5xnzx

pod "javaee-cafe-jcache-cluster-77d54bccd4-5xnzx" deleted

Następnie odśwież stronę główną aplikacji. Te same dane zostaną wyświetlone w sekcji Nowa kawa w sesji , ale inna nazwa zasobnika wyświetlana w lewym górnym rogu strony.

Na koniec wykonaj następujące kroki, aby zademonstrować, że dane sesji są utrwalane w wystąpieniu usługi Azure Cache for Redis. Polecenia do wystąpienia usługi Azure Cache for Redis można wydać przy użyciu konsoli usługi Redis.

  1. Znajdź wystąpienie usługi Azure Cache for Redis w witrynie Azure Portal.

  2. Wybierz pozycję Konsola , aby otworzyć konsolę usługi Redis.

  3. Uruchom następujące polecenia, aby wyświetlić dane sesji:

    scan 0 count 1000 match '*'

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

  4. Wyszukaj ciąg café.model.entity.Coffee[id=1, name=Coffee 3, price=30.0] ze strony internetowej, czyli kawy utworzonej i utrwalonej w wystąpieniu usługi Azure Cache for Redis.

Czyszczenie zasobów

Aby uniknąć opłat za platformę Azure, należy wyczyścić niepotrzebne zasoby. Gdy klaster nie jest już potrzebny, użyj polecenia az group delete , aby usunąć grupę zasobów, usługę kontenera, rejestr kontenerów i wszystkie powiązane zasoby.

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

Aby usunąć wystąpienie usługi Azure Cache for Redis, znajdź nazwę grupy zasobów i uruchom następujące polecenie:

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

Następne kroki

Więcej informacji można dowiedzieć się z odwołań używanych w tym przewodniku: