Distribuire manualmente un'applicazione Java con Open Liberty o WebSphere Liberty in un cluster servizio Azure Kubernetes (AKS)

  • Articolo

Questo articolo fornisce istruzioni dettagliate per l'esecuzione di Open/WebSphere Liberty in Azure.

In particolare, questo articolo illustra come eseguire le attività seguenti:

  • Eseguire l'applicazione Java, Java EE, Jakarta EE o MicroProfile nel runtime Open Liberty o WebSphere Liberty.
  • Compilare l'immagine Docker dell'applicazione con az acr build immagini del contenitore Liberty.
  • Distribuire l'applicazione in contenitori in un cluster del servizio Azure Kubernetes servizio Azure Kubernetes usando l'operatore Liberty.

L'operatore Liberty semplifica la distribuzione e la gestione delle applicazioni in esecuzione nei cluster Kubernetes. Con Open Liberty Operator o WebSphere Liberty Operator, è anche possibile eseguire operazioni più avanzate, ad esempio la raccolta di tracce e dump.

Per una soluzione più automatizzata che accelera il percorso verso il servizio Azure Kubernetes, vedere Distribuire un'applicazione Java con Open Liberty/WebSphere Liberty in un cluster servizio Azure Kubernetes (AKS).

Per altre informazioni su Open Liberty, vedere la pagina del progetto Open Liberty. Per altre informazioni su IBM WebSphere Liberty, vedere la pagina del prodotto WebSphere Liberty.

Questo articolo è progettato per facilitare rapidamente la distribuzione. Prima di passare alla produzione, è consigliabile esplorare Tuning Liberty.

Se si è interessati a fornire commenti e suggerimenti o lavorare sugli scenari di migrazione in stretta collaborazione con il team di progettazione che sviluppa WebSphere nelle soluzioni di Azure, compilare questo breve sondaggio sulla migrazione di WebSphere e includere le informazioni di contatto. Il team di responsabili del programma, architetti e ingegneri si metterà immediatamente in contatto con l'utente per avviare una stretta collaborazione.

Prerequisiti

Accedere ad Azure

Se non è già stato fatto, accedere alla sottoscrizione di Azure usando il comando az login e seguire le istruzioni visualizzate.

az login

Nota

È possibile eseguire la maggior parte dei comandi dell'interfaccia della riga di comando di Azure in PowerShell come in Bash. La differenza esiste solo quando si usano variabili. Nelle sezioni seguenti la differenza viene risolta in schede diverse quando necessario.

Se sono associati più tenant di Azure alle credenziali di Azure, è necessario specificare il tenant a cui si vuole accedere. È possibile eseguire questa operazione con l'opzione --tenant . Ad esempio: az login --tenant contoso.onmicrosoft.com.

Creare un gruppo di risorse

Un gruppo di risorse di Azure è un gruppo logico in cui le risorse di Azure vengono distribuite e gestite.

Creare un gruppo di risorse denominato java-liberty-project usando il comando az group create nel eastus2 percorso. Questo gruppo di risorse viene usato in un secondo momento per creare l'istanza di Registro Azure Container e il cluster del servizio Azure Kubernetes.

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

Creare un'istanza del Registro Container

Usare il comando az acr create per creare l'istanza del Registro Container. Nell'esempio seguente viene creata un'istanza del Registro Container denominata youruniqueacrname. Assicurarsi che youruniqueacrname sia univoco all'interno di Azure.

Nota

Questo articolo usa il meccanismo di autenticazione senza password consigliato per Registro Container. È comunque possibile usare il nome utente e la password con docker login dopo aver usato az acr credential show per ottenere il nome utente e la password. L'uso di nome utente e password è meno sicuro dell'autenticazione senza password.

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

Dopo un breve periodo di tempo, dovrebbe essere visualizzato un output JSON contenente le righe seguenti:

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

Recuperare quindi il server di accesso per l'istanza del Registro Container. Questo valore è necessario quando si distribuisce l'immagine dell'applicazione nel cluster del servizio Azure Kubernetes in un secondo momento.

export LOGIN_SERVER=$(az acr show \
    --name $REGISTRY_NAME \
    --query 'loginServer' \
    --output tsv)

Creare un cluster del servizio Azure Kubernetes

Usare il comando az aks create per creare un cluster del servizio Azure Kubernetes. Nell'esempio seguente viene creato un cluster denominato myAKSCluster con un nodo. Il completamento di questo comando richiede diversi minuti.

export CLUSTER_NAME=myAKSCluster
az aks create \
    --resource-group $RESOURCE_GROUP_NAME \
    --name $CLUSTER_NAME \
    --node-count 1 \
    --generate-ssh-keys \
    --enable-managed-identity

Il comando viene completato dopo pochi minuti e vengono restituite informazioni in formato JSON relative al cluster, he includono il seguente output:

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

Collegare l'istanza del Registro Container al cluster del servizio Azure Kubernetes

Eseguire il comando az aks update per collegare l'istanza del Registro Container al cluster del servizio Azure Kubernetes in modo che il cluster del servizio Azure Kubernetes sia autenticato per eseguire il pull delle immagini dall'istanza del Registro Container, come illustrato nell'esempio seguente:

az aks update \
    --resource-group $RESOURCE_GROUP_NAME \
    --name $CLUSTER_NAME \
    --attach-acr $REGISTRY_NAME

Connettersi al cluster servizio Azure Kubernetes

Per gestire un cluster Kubernetes, usare kubectl, il client della riga di comando Kubernetes. Per eseguire l'installazione kubectl in locale, usa il comando az aks install-cli, come illustrato nell'esempio seguente:

az aks install-cli

Per configurare kubectl per la connessione al cluster Kubernetes, usare il comando az servizio Azure Kubernetes get-credentials. Questo comando scarica le credenziali e configura l'interfaccia della riga di comando di Kubernetes per usarli.

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

Nota

Il comando riportato sopra usa il percorso predefinito del file di configurazione di Kubernetes, ossia ~/.kube/config. È possibile specificare un percorso diverso per il file di configurazione di Kubernetes usando --file.

Per verificare la connessione al cluster, usare il comando kubectl get per restituire un elenco di nodi del cluster.

kubectl get nodes

L'esempio di output seguente mostra il nodo singolo creato nei passaggi precedenti. Assicurarsi che lo stato del nodo sia impostato su Pronto:

NAME                                STATUS   ROLES   AGE     VERSION
aks-nodepool1-xxxxxxxx-yyyyyyyyyy   Ready    <none>  76s     v1.29.9

Creare un database SQL di Azure

In questa sezione viene creato un database singolo database SQL di Azure da usare con l'app.

Impostare prima di tutto le variabili di ambiente correlate al database. Sostituire <your-unique-sql-server-name> con un nome univoco per il server database SQL di Azure.

export SQL_SERVER_NAME=<your-unique-sql-server-name>
export DB_NAME=demodb

Eseguire il comando seguente nel terminale per creare un database singolo in database SQL di Azure e impostare l'utente connesso corrente come amministratore di Microsoft Entra. Per altre informazioni, vedere Avvio rapido: Creare un database singolo - database SQL di Azure.

export ENTRA_ADMIN_NAME=$(az ad signed-in-user show --query userPrincipalName --output tsv)

az sql server create \
    --name $SQL_SERVER_NAME \
    --resource-group $RESOURCE_GROUP_NAME \
    --enable-ad-only-auth \
    --external-admin-principal-type User \
    --external-admin-name $ENTRA_ADMIN_NAME \
    --external-admin-sid $(az ad signed-in-user show --query id --output tsv)
az sql db create \
    --resource-group $RESOURCE_GROUP_NAME \
    --server $SQL_SERVER_NAME \
    --name $DB_NAME \
    --edition GeneralPurpose \
    --compute-model Serverless \
    --family Gen5 \
    --capacity 2

Aggiungere quindi l'indirizzo IP locale alle regole del firewall del server database SQL di Azure per consentire al computer locale di connettersi al database per i test locali in un secondo momento.

export AZ_LOCAL_IP_ADDRESS=$(curl -s https://whatismyip.akamai.com)
az sql server firewall-rule create \
    --resource-group $RESOURCE_GROUP_NAME \
    --server $SQL_SERVER_NAME \
    --name AllowLocalIP \
    --start-ip-address $AZ_LOCAL_IP_ADDRESS \
    --end-ip-address $AZ_LOCAL_IP_ADDRESS

Nota

Si crea un server SQL di Azure con autenticazione SQL disabilitata per considerazioni sulla sicurezza. Solo l'ID Microsoft Entra viene usato per eseguire l'autenticazione al server. Se è necessario abilitare l'autenticazione SQL, vedere az sql server create per altre informazioni.

Creare una connessione al servizio nel servizio Azure Kubernetes con Service Connector

Eseguire i comandi seguenti per creare una connessione tra il cluster del servizio Azure Kubernetes e il database SQL usando ID dei carichi di lavoro di Microsoft Entra con Service Connector. Per altre informazioni, vedere Creare una connessione al servizio nel servizio Azure Kubernetes con Service Connector (anteprima).

# Register the Service Connector and Kubernetes Configuration resource providers
az provider register --namespace Microsoft.ServiceLinker --wait
az provider register --namespace Microsoft.KubernetesConfiguration --wait

# Install the Service Connector passwordless extension
az extension add --name serviceconnector-passwordless --upgrade --allow-preview true

# Retrieve the AKS cluster and Azure SQL Server resource IDs
export AKS_CLUSTER_RESOURCE_ID=$(az aks show \
    --resource-group $RESOURCE_GROUP_NAME \
    --name $CLUSTER_NAME \
    --query id \
    --output tsv)
export AZURE_SQL_SERVER_RESOURCE_ID=$(az sql server show \
    --resource-group $RESOURCE_GROUP_NAME \
    --name $SQL_SERVER_NAME \
    --query id \
    --output tsv)

# Create a user-assigned managed identity used for workload identity
export USER_ASSIGNED_IDENTITY_NAME=workload-identity-uami
az identity create \
    --resource-group ${RESOURCE_GROUP_NAME} \
    --name ${USER_ASSIGNED_IDENTITY_NAME}

# Retrieve the user-assigned managed identity resource ID
export UAMI_RESOURCE_ID=$(az identity show \
    --resource-group ${RESOURCE_GROUP_NAME} \
    --name ${USER_ASSIGNED_IDENTITY_NAME} \
    --query id \
    --output tsv)

# Create a service connection between your AKS cluster and your SQL database using Microsoft Entra Workload ID
az aks connection create sql \
    --connection akssqlconn \
    --client-type java \
    --source-id $AKS_CLUSTER_RESOURCE_ID \
    --target-id $AZURE_SQL_SERVER_RESOURCE_ID/databases/$DB_NAME \
    --workload-identity $UAMI_RESOURCE_ID

Nota

È consigliabile usare ID dei carichi di lavoro di Microsoft Entra per proteggere l'accesso alle database SQL di Azure senza usare l'autenticazione SQL. Se è necessario usare l'autenticazione SQL, ignorare i passaggi precedenti in questa sezione e usare il nome utente e la password per connettersi al database SQL di Azure.

Ottenere l'account servcie e il segreto creati da Service Connector

Per eseguire l'autenticazione al database SQL di Azure, è necessario ottenere l'account del servizio e il segreto creati da Service Connector. Seguire la sezione Aggiornare il contenitore. Usare l'opzione Creare direttamente una distribuzione usando il frammento di codice di esempio YAML fornito ed eseguire la procedura seguente:

  1. Dalle sezioni evidenziate nell'esempio di distribuzione YAML di Kubernetes copiare i serviceAccountName valori e secretRef.name , come illustrato nell'esempio seguente:

    serviceAccountName: <service-account-name>
containers:
- name: raw-linux
   envFrom:
      - secretRef:
         name: <secret-name>

  2. Sostituire <service-account-name> e <secret-name> con i valori copiati nel passaggio precedente per definire le variabili di ambiente seguenti:

    export SERVICE_ACCOUNT_NAME=<service-account-name>
export SECRET_NAME=<secret-name>

    Questi valori vengono usati nella sezione successiva per distribuire l'applicazione Liberty nel cluster del servizio Azure Kubernetes.

Nota

Il segreto creato da Service Connector contiene , AZURE_SQL_CONNECTIONSTRINGche è una password gratuita stringa di connessione al database SQL di Azure. Per altre informazioni, vedere Il valore di esempio dell'autenticazione dell'identità gestita assegnata dall'utente .

Installare Open Liberty Operator

In questa sezione si installa Open Liberty Operator nel cluster del servizio Azure Kubernetes per ospitare l'applicazione Liberty.

Installare Open Liberty Operator eseguendo i comandi seguenti:

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

Configurare e compilare l'immagine dell'applicazione

Per distribuire ed eseguire l'applicazione Liberty nel cluster del servizio Azure Kubernetes, inserire in un contenitore l'applicazione come immagine Docker usando immagini del contenitore Open Liberty o immagini del contenitore WebSphere Liberty.

Seguire i passaggi descritti in questa sezione per distribuire l'applicazione di esempio nel runtime Liberty. Questi passaggi usano Maven.

Consultare l'applicazione

Clonare il codice di esempio per questa guida. L'esempio è disponibile in GitHub. Nel repository sono disponibili alcuni esempi. Questo articolo usa l'esempio java-app . I file importanti vengono visualizzati di seguito.

git clone https://github.com/Azure-Samples/open-liberty-on-aks.git
cd open-liberty-on-aks
export BASE_DIR=$PWD
git checkout 20241029

Se viene visualizzato un messaggio relativo allo stato "HEAD scollegato", questo messaggio può essere tranquillamente ignorato. Significa semplicemente che è stato estratto un tag.

java-app
├─ src/main/
│  ├─ aks/
│  │  ├─ openlibertyapplication-passwordless-db.yaml
│  ├─ docker/
│  │  ├─ Dockerfile
│  │  ├─ Dockerfile-wlp
│  ├─ liberty/config/
│  │  ├─ server.xml
│  ├─ java/
│  ├─ resources/
│  ├─ webapp/
├─ pom.xml
├─ pom-azure-identity.xml

Le directory java, resources e webapp contengono il codice sorgente dell'applicazione di esempio. Il codice dichiara e usa un'origine dati denominata jdbc/JavaEECafeDB.

Nella directory del servizio Azure Kubernetes il file openlibertyapplication-passwordless-db.yaml viene usato per distribuire l'immagine dell'applicazione. Nella directory docker sono disponibili due file per creare l'immagine dell'applicazione con Open Liberty o WebSphere Liberty.

Nella directory liberty/config, il server.xml viene usato per configurare la connessione di database per il cluster Open Liberty e WebSphere Liberty. Definisce una variabile azure.sql.connectionstring usata per connettersi al database SQL di Azure.

Il file pom.xml è il file POM (Project Object Model) di Maven che contiene le informazioni di configurazione per il progetto. Il file pom-azure-identity.xml dichiara azure-identity la dipendenza, che viene usata per eseguire l'autenticazione ai servizi di Azure usando Microsoft Entra ID.

Nota

Questo esempio usa la azure-identity libreria per eseguire l'autenticazione per database SQL di Azure usando l'autenticazione di Microsoft Entra, consigliata per considerazioni sulla sicurezza. Se è necessario usare l'autenticazione SQL nell'applicazione Liberty, vedere Connessioni di database relazionali con JDBC per altre informazioni.

Compilare il progetto

Dopo aver raccolto le proprietà necessarie, è possibile compilare l'applicazione. Il file POM per il progetto legge molte variabili dall'ambiente. Come parte della compilazione Maven, queste variabili vengono usate per popolare i valori nei file YAML che si trovano in src/main/aks. Se si preferisce, è possibile eseguire operazioni simili per l'applicazione all'esterno di Maven.

cd $BASE_DIR/java-app

# The following variables are used for deployment file generation into target/
export LOGIN_SERVER=${LOGIN_SERVER}
export SC_SERVICE_ACCOUNT_NAME=${SERVICE_ACCOUNT_NAME}
export SC_SECRET_NAME=${SECRET_NAME}

mvn clean install
mvn dependency:copy-dependencies -f pom-azure-identity.xml -DoutputDirectory=target/liberty/wlp/usr/shared/resources

Testare il progetto in locale

È ora possibile eseguire e testare il progetto in locale prima di eseguire la distribuzione in Azure. Per praticità, usare .liberty-maven-plugin Per altre informazioni su liberty-maven-plugin, vedere Compilazione di un'applicazione Web con Maven. Per l'applicazione, è possibile eseguire operazioni simili usando qualsiasi altro meccanismo, ad esempio l'IDE locale. È anche possibile prendere in considerazione l'uso dell'opzione liberty:devc destinata allo sviluppo con i contenitori. Per altre informazioni su liberty:devc, vedere la documentazione di Liberty.

Nota

Se è stata selezionata una distribuzione di database "serverless", verificare che il database SQL non sia stato attivato in modalità di sospensione. Un modo per eseguire questa operazione consiste nell'accedere all'editor di query del database come descritto in Avvio rapido: Usare l'editor di query portale di Azure (anteprima) per eseguire query database SQL di Azure.

  1. Avviare l'applicazione usando liberty:run.

    cd $BASE_DIR/java-app

# The value of environment variable AZURE_SQL_CONNECTIONSTRING is read by configuration variable `azure.sql.connectionstring` in server.xml
export AZURE_SQL_CONNECTIONSTRING="jdbc:sqlserver://$SQL_SERVER_NAME.database.windows.net:1433;databaseName=$DB_NAME;authentication=ActiveDirectoryDefault"
mvn liberty:run

  2. Verificare che l'applicazione funzioni come previsto. Se ha esito positivo, verrà visualizzato un messaggio simile a [INFO] [AUDIT] CWWKZ0003I: The application javaee-cafe updated in 1.930 seconds. nell'output del comando. Passare a http://localhost:9080/ nel browser per verificare che l'applicazione sia accessibile e che tutte le funzioni funzionino.

  3. Premere CTRL+C per arrestarsi. Selezionare se si esegue il servizio Azure Kubernetes Y per terminare il processo batch.

Al termine, eliminare la regola del firewall che consente all'indirizzo IP locale di accedere al database SQL di Azure usando il comando seguente:

az sql server firewall-rule delete \
    --resource-group $RESOURCE_GROUP_NAME \
    --server $SQL_SERVER_NAME \
    --name AllowLocalIP

Compilare l'immagine per la distribuzione del servizio Azure Kubernetes

È ora possibile eseguire il comando az acr build per compilare l'immagine, come illustrato nell'esempio seguente:

cd $BASE_DIR/java-app/target

az acr build \
    --registry ${REGISTRY_NAME} \
    --image javaee-cafe:v1 \
    .

Il az acr build comando carica gli artefatti specificati nel Dockerfile nell'istanza del Registro Container, compila l'immagine e la archivia nell'istanza del Registro Container.

Distribuire l'applicazione nel cluster del servizio Azure Kubernetes

Usare la procedura seguente per distribuire l'applicazione Liberty nel cluster del servizio Azure Kubernetes:

  1. Applicare il file di distribuzione eseguendo i comandi seguenti:

    cd $BASE_DIR/java-app/target

# Apply deployment file
kubectl apply -f openlibertyapplication-passwordless-db.yaml

  2. Determinare se l'istanza OpenLibertyApplication viene creata eseguendo il comando seguente:

    kubectl get openlibertyapplication javaee-cafe-cluster

    L'output dovrebbe essere simile all'esempio seguente:

    NAME                  IMAGE                                        EXPOSED   RECONCILED   RESOURCESREADY   READY   WARNING   AGE
javaee-cafe-cluster   jiangma102924acr.azurecr.io/javaee-cafe:v1             True         True             True              57s

  3. Determinare se la distribuzione creata dall'operatore è pronta eseguendo il comando seguente:

    kubectl get deployment javaee-cafe-cluster --watch

    L'output dovrebbe essere simile all'esempio seguente:

    NAME                        READY   UP-TO-DATE   AVAILABLE   AGE
javaee-cafe-cluster         0/3     3            0           20s

  4. Attendere fino a quando non viene visualizzato 3/3 sotto la READY colonna e 3 sotto la AVAILABLE colonna, quindi usare CTRL+C per arrestare il kubectl processo di controllo.

Testare l'applicazione

Quando l'applicazione viene eseguita, un servizio di bilanciamento del carico Kubernetes espone il front-end dell'applicazione a Internet. Il completamento di questo processo può richiedere alcuni minuti.

Per monitorare lo stato di avanzamento, usare il comando kubectl get service con l'argomento --watch , come illustrato nell'esempio seguente:

kubectl get service javaee-cafe-cluster --watch

L'output dovrebbe essere simile all'esempio seguente:

NAME                        TYPE           CLUSTER-IP     EXTERNAL-IP     PORT(S)          AGE
javaee-cafe-cluster         LoadBalancer   10.0.251.169   52.152.189.57   80:31732/TCP     68s

Dopo che l'indirizzo EXTERNAL-IP passa da in sospeso a un indirizzo IP pubblico effettivo, usare CTRL+C per arrestare il processo di kubectl controllo.

Se è trascorso del tempo tra l'esecuzione dei passaggi in questa sezione e quella precedente, verificare che il database sia attivo, se necessario. Vedere la nota precedente relativa alla sospensione del database.

Aprire un Web browser all'indirizzo IP esterno del servizio (52.152.189.57 per l'esempio precedente) per visualizzare la home page dell'applicazione. Se la pagina non viene caricata correttamente, è perché l'app viene avviata. È possibile attendere un po' di tempo e aggiornare la pagina in un secondo momento. Verrà visualizzato il nome del pod delle repliche dell'applicazione visualizzato in alto a sinistra nella pagina. Attendere alcuni minuti e aggiornare la pagina per visualizzare un nome di pod diverso a causa del bilanciamento del carico fornito dal cluster del servizio Azure Kubernetes.

Applicazione Java liberty distribuita correttamente nel servizio Azure Kubernetes.

Nota

Attualmente, l'applicazione non usa HTTPS. È consigliabile abilitare TLS con i propri certificati. Per altre informazioni, vedere Usare TLS con un controller di ingresso in servizio Azure Kubernetes (servizio Azure Kubernetes).

Pulire le risorse

Per evitare addebiti per Azure, è necessario eliminare le risorse non necessarie. Quando il cluster non è più necessario, usare il comando az group delete per rimuovere il gruppo di risorse, il servizio contenitore, il registro contenitori, il database e tutte le risorse correlate.

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

Passaggi successivi

Per altre informazioni, vedere i riferimenti usati in questa guida:

Per incorporare cache di Azure per Redis in un'app Java, vedere Usare cache di Azure per Redis in Java con il client Redisson Redis.

Per esplorare le opzioni per eseguire prodotti WebSphere in Azure, vedere Quali sono le soluzioni per eseguire la famiglia di prodotti WebSphere in Azure?