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

Artikel
12/19/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 Azure CLI mit dem Befehl az login 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 benötigten Bibliotheken zu finden. Führen Sie az upgradeaus, um ein Upgrade auf die neueste 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. Nach Abschluss dieser Schritte verfügen Sie über eine Azure-Container-Registry, einen Azure-Kubernetes-Dienstcluster und eine Azure-Cache-für-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 eine Ressourcengruppe mit der Benennung java-liberty-project mithilfe des Befehls az group create im eastus Speicherort. 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, um die ACR-Instanz zu erstellen. Im folgenden Beispiel wird eine ACR-Instanz namens youruniqueacrnameerstellt. 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 Bild an die Instanz übertragen 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.

Sie sollten Login Succeeded am Ende der Befehlsausgabe sehen, wenn Sie sich erfolgreich bei der ACR-Instanz angemeldet haben.

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 die Berechtigung zum Abruf von Images durch die ACR-Instanz zu erteilen. 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 den Befehl az aks install-cli, um kubectl lokal zu installieren:

az aks install-cli

Verwenden Sie den befehl az aks get-credentials, um kubectl für die Verbindung mit Ihrem Kubernetes-Cluster zu 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. Stellen Sie sicher, dass der Status des Knotens Readyist.

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 in Schritt 7 des Abschnitts Erstellen eines Azure-Caches für Redis Zugriffsschlüssel-Authentifizierung für die Option Authentifizierung im Bereich Erweitert für diesem Leitfaden. Für optimale Sicherheit empfehlen wir, Microsoft Entra ID in Kombination mit verwalteten Identitäten zu verwenden, um Anfragen an Ihren Cache zu autorisieren, falls möglich. Die Autorisierung mithilfe von Microsoft Entra ID und verwalteten Identitäten bietet eine überlegene Sicherheit und Benutzerfreundlichkeit gegenüber der Autorisierung gemeinsam genutzter Zugriffsschlüssel. Weitere Informationen zur Verwendung verwalteter Identitäten mit Ihrem Cache finden Sie unter Microsoft Entra ID zur Cache-Authentifizierung verwenden.
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. In diesen Schritten wird Maven, liberty-maven-plugin and az acr build verwendet. 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 darüber angezeigt wird, dass der Zustand detached HEAD lautet, kann diese Nachricht problemlos ignoriert werden. 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 in der pom.xml Datei definierten Eigenschaften artifactId und version abzurufen.

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.

Um den Fortschritt zu überwachen, verwenden Sie 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

Nachdem sich die EXTERNAL-IP-Adresse von pendingin eine tatsächliche öffentliche IP-Adresse geändert hat, können Sie mit STRG+C den kubectl Überwachungsprozess stoppen.

Öffnen Sie einen Webbrowser mit der externen IP-Adresse Ihres Diensts (20.84.16.169 für das vorherige 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. Oben links auf der Seite sollte der Pod-Name Ihrer Anwendungsreplikate 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, verwenden Sie den Befehl az group delete, um die Ressourcengruppe, den Containerdienst, die Containerregistrierung und alle zugehörigen Ressourcen zu entfernen.

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