Udostępnij za pośrednictwem

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 chcesz przekazać opinię lub ściśle pracować nad scenariuszami migracji z zespołem inżynierów opracowującym rozwiązanie WebSphere na platformie Azure, wypełnij tę krótką ankietę dotyczącą migracji webSphere i dołącz informacje kontaktowe. Zespół menedżerów programów, architektów i inżynierów natychmiast skontaktuje się z Tobą w celu zainicjowania ścisłej współpracy.

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 jest używana później 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.

Nawiązywanie połączenia z wystąpieniem 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 trwa 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",

Nawiązywanie połączenia z klastrem 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 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 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 .

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

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

Zrzut ekranu przedstawiający pomyślnie wdrożona aplikacja Java liberty w usłudze 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.

Zrzut ekranu przedstawiający przykładową aplikację przedstawiającą nową kawę utworzoną i utrwalone w sesji aplikacji.

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:

Aby zapoznać się z opcjami uruchamiania produktów WebSphere na platformie Azure, zobacz Co to są rozwiązania do uruchamiania rodziny produktów WebSphere na platformie Azure?