Verwenden von Java EE JCache mit Open Liberty oder WebSphere Liberty in einem Azure Kubernetes Service-Cluster (AKS)

Artikel
09/09/2024

In diesem Artikel wird beschrieben, wie Sie Java EE JCache in einer containerisierten Anwendung verwenden, die in AKS bereitgestellt wird.

In diesem Leitfaden werden Sie:

Erstellen Sie die Infrastruktur, um Ihre Java-, Java EE-, Jakarta EE- oder MicroProfile-Anwendung in der Open Liberty- oder WebSphere Liberty-Runtime auszuführen.
Verwenden Sie Java EE JCache, der von Azure Cache für Redis als Sitzungscache unterstützt wird.
Erstellen Sie das Docker-Image der Anwendung mithilfe von Open Liberty- oder WebSphere Liberty-Containerimages.
Stellen Sie die containerisierte Anwendung mithilfe des Open Liberty-Operators in einem AKS-Cluster bereit.

Dieser Artikel soll Ihnen helfen, schnell zur Bereitstellung zu gelangen. Bevor Sie in die Produktion gehen, sollten Sie Tuning Liberty erkunden.

Wenn Sie an Feedback oder daran interessiert sind, eng mit dem Entwicklungsteam, das die WebSphere-Lösungen für Azure entwickelt, an Ihren Migrationsszenarien zu arbeiten, füllen Sie diese kurze Umfrage zur WebSphere-Migration aus und geben Sie Ihre Kontaktinformationen an. Das Team aus Programmmanagern, Architekten und Technikern wird sich umgehend mit Ihnen in Verbindung setzen, um eine enge Zusammenarbeit zu initiieren.

Voraussetzungen

Ein Azure-Abonnement. Wenn Sie kein Azure-Abonnement besitzen, erstellen Sie ein kostenloses Konto, bevor Sie beginnen.
Bereiten Sie einen lokalen Computer mit einem installierten UNIX-ähnlichen Betriebssystem (z. B. Ubuntu, macOS, Windows-Subsystem für Linux) vor.
Installieren Sie die Azure CLI, um Azure CLI-Befehle auszuführen.
- Melden Sie sich mit dem Befehl az login bei der Azure CLI an. Führen Sie die in Ihrem Terminal angezeigten Schritte aus, um den Authentifizierungsprozess abzuschließen. Informationen zu anderen Anmeldeoptionen finden Sie unter Anmelden mit der Azure CLI.
- Installieren Sie die Azure CLI-Erweiterung beim ersten Einsatz, wenn Sie dazu aufgefordert werden. Weitere Informationen zu Erweiterungen finden Sie unter Verwenden und Verwalten von Erweiterungen mit der Azure CLI.
- Führen Sie az version aus, um die installierte Version und die abhängigen Bibliotheken zu ermitteln. Führen Sie az upgrade aus, um das Upgrade auf die aktuelle Version durchzuführen.
Installieren Sie eine Java SE-Implementierung Version 17 oder später (z. B den Microsoft-Build von OpenJDK).
Installieren Sie Maven 3.5.0 oder höher.
Installieren Sie Docker für Ihr Betriebssystem.
Sicherstellen, dass Git installiert ist
Stellen Sie sicher, dass Ihnen für das Abonnement entweder die Owner-Rolle oder die Contributor- und User Access Administrator-Rollen zugewiesen wurde. Sie können Ihre Zuweisungen überprüfen, indem Sie die Schritte unter Auflisten von Rollenzuweisungen für einen Benutzer oder eine Gruppe befolgen.

Erstellen der Infrastruktur

Die Schritte in diesem Abschnitt führen Sie zum Erstellen der Anwendungsinfrastruktur in Azure. Nachdem Sie diese Schritte ausgeführt haben, verfügen Sie über eine Azure Container Registry, einen Azure Kubernetes Service-Cluster und eine Azure Cache for Redis-Instanz zum Ausführen der Beispielanwendung.

Erstellen einer Ressourcengruppe

Eine Azure-Ressourcengruppe ist eine logische Gruppe, in der Azure-Ressourcen bereitgestellt und verwaltet werden.

Erstellen Sie am Standort eastus mithilfe des Befehls az group create die Ressourcengruppe java-liberty-project. Diese Ressourcengruppe wird zu einem späteren Zeitpunkt zum Erstellen der Azure Container Registry-Instanz (ACR) und des AKS-Clusters verwendet.

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

Erstellen einer ACR-Instanz

Verwenden Sie den Befehl az acr create zum Erstellen der ACR-Instanz. Im folgenden Beispiel wird die ACR-Instanz youruniqueacrname erstellt. Stellen Sie sicher, dass youruniqueacrname in Azure eindeutig ist.

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

Nach kurzer Zeit sollte eine JSON-Ausgabe mit Folgendem angezeigt werden:

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

Alternativ können Sie eine Azure Container Registry-Instanz erstellen, indem Sie die Schritte unter Schnellstart: Erstellen einer Azure-Containerregistrierung über das Azure-Portal ausführen.

Herstellen einer Verbindung mit der ACR-Instanz

Sie müssen sich bei der ACR-Instanz anmelden, bevor Sie ein Image an diese pushen können. Führen Sie die folgenden Befehle zum Überprüfen der Verbindung aus:

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

Hinweis

Von der Verwendung von Benutzernamen und Passwörtern zur Gewährung des Zugriffs auf eine Containerregistrierung wird abgeraten. Wenn Ihre speziellen Nutzungsanforderungen darauf hindeuten, dass ein auf Anmeldeinformationen basierender Zugang der beste Ansatz ist, können Sie den Benutzernamen und das Passwort mithilfe von az acr credential show abrufen und mit diese Werte mit docker login verwenden.

Wenn Sie sich bei der ACR-Instanz erfolgreich angemeldet haben, sollte am Ende der Befehlsausgabe Login Succeeded angezeigt werden.

Wenn beim Anmelden bei der Azure-Containerregistrierung ein Problem auftritt, lesen Sie die Problembehandlung bei der Registrierungsanmeldung.

Erstellen eines AKS-Clusters

Verwenden Sie den Befehl az aks create, um einen AKS-Cluster zu erstellen und ihm Berechtigungen zum Pullen eines Images aus der ACR-Instanz zu gewähren. Im folgenden Beispiel wird ein Cluster mit dem Namen myAKSCluster mit einem Knoten erstellt. Es dauert mehrere Minuten, bis dieser Befehl abgeschlossen ist.

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

Nach wenigen Minuten ist die Ausführung des Befehls abgeschlossen, und es werden Informationen zum Cluster im JSON-Format zurückgegeben, einschließlich der folgenden Zeilen:

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

Herstellen einer Verbindung mit dem AKS-Cluster

Verwenden Sie zum Verwalten eines Kubernetes-Clusters den Kubernetes-Befehlszeilenclient kubectl. Verwenden Sie für die lokale Installation von kubectl den Befehl az aks install-cli:

az aks install-cli

Mit dem Befehl az aks get-credentials können Sie kubectl für die Verbindungsherstellung mit Ihrem Kubernetes-Cluster konfigurieren. Mit diesem Befehl werden die Anmeldeinformationen heruntergeladen, und die Kubernetes-Befehlszeilenschnittstelle wird für deren Verwendung konfiguriert.

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

Überprüfen Sie die Verbindung mit Ihrem Cluster mithilfe des Befehls kubectl get, um eine Liste der Clusterknoten zurückzugeben.

kubectl get nodes

Die folgende Beispielausgabe zeigt den in den vorherigen Schritten erstellten Knoten. Vergewissern Sie sich, dass der Knoten den Status Bereit hat.

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

Installieren von Open Liberty Operator

Nachdem Sie den Cluster erstellt und eine Verbindung damit hergestellt haben, installieren Sie den Open Liberty Operator durch Ausführung der folgenden Befehle.

# 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

Erstellen einer Azure Cache for Redis-Instanz

Azure Cache for Redis unterstützt die Persistenz von HttpSession für eine Java-Anwendung, die in einem Open Liberty- oder WebSphere Liberty-Server ausgeführt wird. Führen Sie die Schritte in diesem Abschnitt aus, um eine Azure Cache for Redis-Instanz zu erstellen und die Verbindungsinformationen zu notieren. Wir werden diese Informationen später verwenden.

Befolgen Sie die Schritte in Schnellstart: Verwenden von Azure Cache for Redis in Java bis zu, aber nicht einschließlich, Grundlegendes zum Java-Beispiel.

Hinweis

Wählen Sie im Schritt 6 des Abschnitts Erstellen eines Azure Cache für Redis die Option Zugriffsschlüsselauthentifizierung für die Authentifizierung. Diese Option ist für die Beispielanwendung erforderlich, um mithilfe der Redisson-Clientbibliothek eine Verbindung mit dem Azure-Cache für die Redis-Instanz herzustellen. Weitere Informationen finden Sie unter Redisson-Konfiguration.
Kopieren Sie den Hostnamen und den primären Zugriffsschlüssel für Ihre Azure Cache for Redis-Instanz, und führen Sie dann die folgenden Befehle zum Hinzufügen von Umgebungsvariablen aus:
```
export REDISCACHEHOSTNAME=<YOUR_HOST_NAME>
export REDISCACHEKEY=<YOUR_PRIMARY_ACCESS_KEY>
```

Erstellen der Anwendung

Führen Sie die Schritte in diesem Abschnitt aus, um die Beispielanwendung zu erstellen und zu containerisieren. Diese Schritte verwenden Maven liberty-maven-pluginund az acr build. Weitere Informationen zu liberty-maven-plugin finden Sie unter Erstellen einer Webanwendung mit Maven.

Auschecken der Anwendung

Verwenden Sie die folgenden Befehle, um den Beispielcode für diesen Leitfaden zu klonen. Das Beispiel befindet sich im open-liberty-on-aks-Repository in GitHub. Es gibt ein paar Beispiele im Repository. In diesem Artikel wird java-app-jcache verwendet.

git clone https://github.com/Azure-Samples/open-liberty-on-aks.git
cd open-liberty-on-aks
git checkout 20240909
cd java-app-jcache

Wenn eine Meldung angezeigt wird, dass Sie sich im Status „detached HEAD“ befinden, können Sie diese Meldung problemlos ignorieren. Sie bedeutet nur, dass Sie ein Tag ausgecheckt haben.

Die Anwendung hat die folgende Dateistruktur:

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

Die Verzeichnisse java, resources und webapp enthalten den Quellcode der Beispielanwendung.

Im Verzeichnis aks wird die Bereitstellungsdatei openlibertyapplication.yaml verwendet, um das Anwendungsimage bereitzustellen.

Im docker-Verzeichnis platzieren wir zwei Dockerfiles. Dockerfile wird verwendet, um ein Image mit Open Liberty zu erstellen, und Dockerfile-wlp wird genutzt, um ein Image mit WebSphere Liberty zu erstellen.

Im Verzeichnis liberty/config wird die Datei server.xml verwendet, um den Sitzungscache für den Open Liberty- und den WebSphere Liberty-Cluster zu konfigurieren.

Im redisson-Verzeichnis wird die Datei redisson-config.yaml verwendet, um die Verbindung zur Azure Cache for Redis-Instanz zu konfigurieren.

Packen der Anwendung in Container

Um Ihre Liberty-Anwendung im AKS-Cluster bereitzustellen und auszuführen, führen Sie die folgenden Schritte aus, um Ihre Anwendung als Docker-Image zu containerisieren. Sie können die Open Liberty-Containerimages der WebSphere Liberty-Containerimages verwenden.

Stellen Sie sicher, dass das aktuelle Arbeitsverzeichnis in Ihrem lokalen Klon java-app-jcache/target ist.
Führen Sie mvn clean package zum Verpacken der Anwendung aus.
Führen Sie mvn -Predisson validate aus, um die Redisson-Konfigurationsdatei in den angegebenen Speicherort zu kopieren. In diesem Schritt werden die Werte der Umgebungsvariablen REDISCACHEHOSTNAME und REDISCACHEKEY in die redisson-config.yaml-Datei eingefügt, auf die von der server.xml-Datei verwiesen wird.

Führen Sie zum Testen der Anwendung mvn liberty:dev aus. Wenn der Test erfolgreich ist, sollte The defaultServer server is ready to run a smarter planet. in der Befehlsausgabe angezeigt werden. Die Ausgabe sollte ähnlich wie im folgenden Beispiel angezeigt werden, wenn die Redis-Verbindung erfolgreich ist.

[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

Sie können http://localhost:9080/ aufrufen, um zu sehen, dass die Anwendung ausgeführt wird. Aber den Nachweis dafür, dass Redis funktioniert, erhalten Sie in der Ausgabe, die im vorherigen Schritt aufgeführt ist.
Verwenden Sie STRG+C, um die Anwendung zu beenden.

Verwenden Sie die folgenden Befehle, um Werte für die Eigenschaften artifactId und version abzurufen, die in der Datei pom.xml definiert sind.

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)

Führen Sie cd target aus, um das Verzeichnis in den Build des Beispiels zu ändern.
Führen Sie einen der folgenden Befehle aus, um das Anwendungsimage zu erstellen und es an die ACR-Instanz zu pushen.
- Verwenden Sie den folgenden Befehl, um die Erstellung mit einem Open Liberty-Basisimage durchzuführen, wenn Sie die Verwendung von Open Liberty als Lightweight Open Source Java™-Runtime verwenden möchten:
```
# 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 .
```
- Verwenden Sie den folgenden Befehl, um ein WebSphere Liberty-Basisimage zu erstellen, wenn Sie bevorzugt eine kommerzielle Version von Open Liberty verwenden möchten:
```
# 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 .
```

Bereitstellen der Anwendung

Führen Sie die Schritte in diesem Abschnitt aus, um die containerisierte Beispielanwendung im AKS-Cluster bereitzustellen.

Stellen Sie sicher, dass das aktuelle Arbeitsverzeichnis in Ihrem lokalen Klon java-app-jcache/target ist.
Verwenden Sie die folgenden Befehle, um einen geheimen Schlüssel mit Redisson-Konfigurationsinformationen zu erstellen. Mit diesem geheimen Schlüssel kann die Anwendung eine Verbindung mit der erstellten Azure Cache for Redis-Instanz herstellen.
```
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
```

Verwenden Sie die folgenden Befehle, um Ihre Liberty-Anwendung mit drei Replikaten im AKS-Cluster bereitzustellen. Die Befehlsausgabe wird auch inline angezeigt.

# 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

Warten Sie, bis Ihnen 3/3 unter der Spalte READY und 3 unter der Spalte AVAILABLE angezeigt wird. Verwenden Sie dann Strg+C, um den kubectl-Überwachungsprozess zu beenden.

Testen der Anwendung

Wenn die Anwendung ausgeführt wird, macht ein Kubernetes-Lastenausgleichsdienst das Anwendungs-Front-End im Internet verfügbar. Es kann eine Weile dauern, bis dieser Vorgang abgeschlossen ist.

Verwenden Sie zum Überwachen des Fortschritts den Befehl kubectl get service mit dem Argument --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

Sobald die EXTERNAL-IP-Adresse von ausstehend in eine tatsächliche öffentliche IP-Adresse geändert wird, verwenden Sie Strg+C, um den kubectl-Überwachungsprozess zu beenden.

Öffnen Sie einen Webbrowser für die externe IP-Adresse Ihres Diensts (20.84.16.169 für das vorstehende Beispiel), um die Startseite der Anwendung anzuzeigen. Wenn die Seite nicht ordnungsgemäß geladen wird, liegt dies daran, dass die App gestartet wird. Sie können einen Moment warten und die Seite später aktualisieren. Der Podname Ihrer Anwendungsreplikate sollte oben links auf der Seite angezeigt werden (javaee-cafe-jcache-cluster-77d54bccd4-5xnzx für diesen Fall).

Screenshot der Java Liberty-Anwendung, die erfolgreich auf A K S bereitgestellt wurde.

Legen Sie im Formular Neuer Kaffee in Sitzung die Werte für die Felder Name und Preis fest, und wählen Sie dann Übermitteln aus. Nach einigen Sekunden wird Anzahl der Übermittlungen: 1 unten auf der Seite angezeigt.

Screenshot der Beispielanwendung, der neuen Kaffee zeigt, der erstellt und in der Sitzung der Anwendung gespeichert wird.

Um zu veranschaulichen, dass der Sitzungscache in allen Replikaten der Anwendung beibehalten wird, führen Sie den folgenden Befehl aus, um das aktuelle Replikat mit dem Podnamen javaee-cafe-jcache-cluster-<pod id from your running app>zu löschen:

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

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

Aktualisieren Sie dann die Startseite der Anwendung. Die gleichen Daten werden im Abschnitt Neuer Kaffee in Sitzung angezeigt, aber ein anderer Podname wird oben links auf der Seite aufgeführt.

Führen Sie schließlich die folgenden Schritte aus, um zu veranschaulichen, dass die Sitzungsdaten in der Azure Cache for Redis-Instanz beibehalten werden. Sie können Befehle an Ihre Azure Cache for Redis-Instanz senden, indem Sie Redis Console verwenden.

Finden Sie Ihre Azure Cache for Redis-Instanz aus dem Azure-Portal.
Wählen Sie Konsole aus, um die Redis-Konsole zu öffnen.

Führen Sie die folgenden Befehle aus, um die Sitzungsdaten anzuzeigen:

scan 0 count 1000 match '*'

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

Suchen Sie auf der Webseite nach cafe.model.entity.Coffee[id=1, name=Coffee 3, price=30.0]. Dies ist der Kaffee, den Sie in der Azure Cache for Redis-Instanz erstellt und beibehalten haben.

Bereinigen von Ressourcen

Zum Vermeiden von Azure-Gebühren sollten Sie nicht benötigte Ressourcen bereinigen. Wenn der Cluster nicht mehr benötigt wird, entfernen Sie mit dem Befehl az group delete die Ressourcengruppe, den Containerdienst, die Containerregistrierung und alle zugehörigen Ressourcen.

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

Um die Azure Cache for Redis-Instanz zu löschen, suchen Sie den Namen der Ressourcengruppe, und führen Sie den folgenden Befehl aus:

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

Nächste Schritte

Weitere Informationen finden Sie über die in diesem Handbuch verwendeten Verweise:

Informationen zu Optionen zum Ausführen von WebSphere-Produkten auf Azure finden Sie unter Welche Lösungen gibt es zum Ausführen der WebSphere-Produktfamilie auf Azure?

Freigeben über