Condividi tramite

Distribuire un'applicazione Java con WebLogic Server in un cluster del servizio Azure Kubernetes

  • Articolo

Questo articolo illustra come:

  • Eseguire l'applicazione Java in Oracle WebLogic Server (WLS).
  • Configurare un cluster WebLogic Server nel servizio Azure Kubernetes usando un'offerta di Azure Marketplace.
  • Creare un'immagine Docker dell'applicazione che include modelli WdT (WebLogic Deploy Tooling).
  • Distribuire l'applicazione in contenitori nel cluster WebLogic Server nel servizio Azure Kubernetes con connessione a Microsoft Azure SQL.

Questo articolo usa l'offerta di Azure Marketplace per WebLogic Server per accelerare il percorso verso il servizio Azure Kubernetes. L'offerta effettua automaticamente il provisioning di diverse risorse di Azure, incluse le risorse seguenti:

  • Un'istanza di Registro Azure Container
  • Un cluster del servizio Azure Kubernetes
  • Istanza del controller di ingresso (AGIC) del gateway applicazione di Azure
  • Operatore WebLogic Kubernetes
  • Immagine del contenitore che include il runtime WebLogic
  • Un cluster WebLogic Server senza un'applicazione

L'articolo presenta quindi la creazione di un'immagine per aggiornare il cluster WebLogic Server. L'immagine fornisce l'applicazione e i modelli WDT.

Se si preferisce un approccio meno automatizzato alla distribuzione di WebLogic nel servizio Azure Kubernetes, vedere le istruzioni dettagliate incluse nella documentazione ufficiale del servizio Oracle per Azure Kubernetes.

Se si è interessati a fornire commenti e suggerimenti o lavorare strettamente sugli scenari di migrazione con il team di progettazione che sviluppa WebLogic nelle soluzioni del servizio Azure Kubernetes, compilare questo breve sondaggio sulla migrazione di WebLogic 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

  • Se non si ha una sottoscrizione di Azure, creare un account Azure gratuito prima di iniziare.
  • Verificare che l'identità di Azure usata per accedere e completare questo articolo abbia il ruolo Proprietario nella sottoscrizione corrente o i ruoliCollaboratore e Amministratore accesso utenti nella sottoscrizione corrente. Per una panoramica dei ruoli di Azure, vedere Che cos'è il controllo degli accessi in base al ruolo di Azure? Per informazioni dettagliate sui ruoli specifici richiesti da WLS nel servizio Azure Kubernetes, vedere Ruoli predefiniti di Azure.
  • Avere le credenziali per un account Oracle Single Sign-On (SSO). Per crearne uno, vedere Creare l'account Oracle.
  • Accettare le condizioni di licenza per WebLogic Server.
    • Visitare il Registro Contenitori Oracle ed eseguire l'accesso.
    • Se si dispone di un diritto di supporto, selezionare Middleware, quindi cercare e selezionare weblogic_cpu.
    • Se non si ha un diritto di supporto da Oracle, selezionare Middleware, quindi cercare e selezionare weblogic.
    • Accetta il Contratto di licenza

    Nota

    Ottenere un diritto di supporto da Oracle prima di passare all'ambiente di produzione. In caso contrario, l'esecuzione di immagini non sicure che non vengono applicate patch per errori di sicurezza critici. Per altre informazioni sugli aggiornamenti critici delle patch di Oracle, vedere Aggiornamenti critici delle patch, avvisi di sicurezza e bollettini di Oracle.

  • Preparare un computer locale con sistema operativo simile a Unix installato (ad esempio Ubuntu, Azure Linux, macOS, Sottosistema Windows per Linux).
    • Interfaccia della riga di comando di Azure. Usare az --version per verificare se az funziona. Questo documento è stato testato con la versione 2.55.1.
    • kubectl. Usare kubectl version per verificare se kubectl funziona. Questo documento è stato testato con la versione 1.21.2.
    • Java Development Kit (JDK). L'articolo descrive come installare Microsoft Build di OpenJDK 11. Assicurarsi che la JAVA_HOME variabile di ambiente sia impostata correttamente nelle shell in cui si eseguono i comandi.
    • Maven 3.5.0 o versione successiva.
    • Assicurarsi di avere installato l'utilità zip/unzip. Usare zip/unzip -v per verificare se zip/unzip funziona.

Creare un database SQL di Azure

In questa sezione viene creata una database SQL di Azure usando l'autenticazione di Microsoft Entra, con la connessione identità gestita abilitata.

Creare un gruppo di risorse

Come prima cosa creare un gruppo di risorse con az group create. Poiché i gruppi di risorse devono essere univoci all'interno di una sottoscrizione, selezionare un nome univoco. Un modo semplice per avere nomi univoci consiste nell'usare una combinazione di iniziali, data odierna e identificatore. Ad esempio: abc1228rg. Questo esempio crea un gruppo di risorse denominato abc1228rg nel eastus percorso:

export RESOURCE_GROUP_NAME="abc1228rg"
az group create \
    --name ${RESOURCE_GROUP_NAME} \
    --location eastus

Creare un server di database e un database

Creare un server con il comando az sql server create. In questo esempio viene creato un server denominato myazuresql20130213 con l'utente azureuser amministratore e la password amministratore. Sostituire <your-password> con la password. Per altre informazioni, vedere Avvio rapido: Creare un database singolo - database SQL di Azure.

Nota

Anche se in questo caso si usa un nome utente e una password, queste credenziali non vengono esposte all'esterno del database. La connessione tra il livello applicazione e il database è protetta con identità gestite.

export AZURESQL_SERVER_NAME="myazuresql20130213"
export AZURESQL_ADMIN_USER="azureuser"
export AZURESQL_ADMIN_PASSWORD="<your-password>"
export DATABASE_NAME="mysingledatabase20230213"

az sql server create \
    --resource-group $RESOURCE_GROUP_NAME \
    --name $AZURESQL_SERVER_NAME \
    --location westus \
    --admin-user $AZURESQL_ADMIN_USER \
    --admin-password $AZURESQL_ADMIN_PASSWORD

Creare un database con il comando az sql db create nel livello di elaborazione serverless.

az sql db create \
    --resource-group $RESOURCE_GROUP_NAME \
    --server $AZURESQL_SERVER_NAME \
    --name $DATABASE_NAME \
    --sample-name AdventureWorksLT \
    --edition GeneralPurpose \
    --compute-model Serverless \
    --family Gen5 \
    --capacity 2

Configurare un amministratore di Microsoft Entra

Per informazioni su come Azure SQL Server interagisce con le identità gestite, vedere Connettersi con l'autenticazione di Microsoft Entra.

Usare la procedura seguente per configurare un account amministratore di Microsoft Entra in Azure SQL Server dal portale di Azure:

  1. Nella portale di Azure aprire l'istanza myazuresql20130213del server SQL di Azure.
  2. Selezionare Impostazioni e quindi Microsoft Entra ID. Nella pagina Microsoft Entra ID selezionare Imposta amministratore.
  3. Nella pagina Aggiungi amministratore cercare un utente, selezionare l'utente o il gruppo come amministratore e quindi selezionare Seleziona.
  4. Nella parte superiore della pagina MICROSOFT Entra ID selezionare Salva. Per gli utenti e i gruppi di Microsoft Entra, l'ID oggetto viene visualizzato accanto al nome dell'amministratore.
  5. Il processo di modifica dell'amministratore può richiedere alcuni minuti. Quindi, il nuovo amministratore viene visualizzato nella casella ID Microsoft Entra.

Creare un'identità gestita assegnata dall'utente

Successivamente, nell'interfaccia della riga di comando di Azure creare un'identità nella sottoscrizione usando il comando az identity create . Usare questa identità gestita per connettersi al database.

az identity create \
    --resource-group ${RESOURCE_GROUP_NAME} \
    --name myManagedIdentity

Creare un utente di database per l'identità gestita

Connettersi ora come utente amministratore di Microsoft Entra al database SQL di Azure dal portale di Azure e creare un utente per l'identità gestita.

Creare prima di tutto una regola del firewall per accedere al server SQL di Azure dal portale, come illustrato nei passaggi seguenti:

  1. Nella portale di Azure aprire l'istanza myazuresql20130213del server SQL di Azure.
  2. Selezionare Sicurezza e quindi Rete.
  3. In Regole del firewall selezionare Aggiungi l'indirizzo IP IPV4 del client.
  4. In Eccezioni selezionare Consenti ai servizi e alle risorse di Azure di accedere a questo server.
  5. Seleziona Salva.

Dopo aver creato la regola del firewall, è possibile accedere al server SQL di Azure dal portale. Usare la procedura seguente per creare un utente del database:

  1. Selezionare Impostazioni e quindi database SQL. Selezionare mysingledatabase20230213.

  2. Selezionare Editor di query. Nella pagina Benvenuto in database SQL Editor di query, in Autenticazione di Active Directory, trovare un messaggio come Logged in as user@contoso.com.

  3. Selezionare Continua come user@contoso.com, dove user è il nome dell'account amministratore di Active Directory.

  4. Dopo l'accesso, nell'editor di Query 1 eseguire i comandi seguenti per creare un utente del database per l'identità myManagedIdentitygestita .

    CREATE USER "myManagedIdentity" FROM EXTERNAL PROVIDER
ALTER ROLE db_datareader ADD MEMBER "myManagedIdentity";
ALTER ROLE db_datawriter ADD MEMBER "myManagedIdentity";
ALTER ROLE db_ddladmin ADD MEMBER "myManagedIdentity";
GO

  5. Nell'editor di Query 1 selezionare Esegui per eseguire i comandi SQL.

  6. Se i comandi sono stati completati correttamente, è possibile trovare un messaggio che indica Query succeeded: Affected rows: 0.

Usare il comando seguente per ottenere il stringa di connessione usato nella sezione successiva:

export CONNECTION_STRING="jdbc:sqlserver://${AZURESQL_SERVER_NAME}.database.windows.net:1433;database=${DATABASE_NAME};encrypt=true;trustServerCertificate=false;hostNameInCertificate=*.database.windows.net;loginTimeout=30;"
echo ${CONNECTION_STRING}

Creare uno schema per l'applicazione di esempio

Selezionare Nuova query e quindi, nell'editor di query, eseguire la query seguente:

CREATE TABLE COFFEE (ID NUMERIC(19) NOT NULL, NAME VARCHAR(255) NULL, PRICE FLOAT(32) NULL, PRIMARY KEY (ID));
CREATE TABLE SEQUENCE (SEQ_NAME VARCHAR(50) NOT NULL, SEQ_COUNT NUMERIC(28) NULL, PRIMARY KEY (SEQ_NAME));
INSERT INTO SEQUENCE VALUES ('SEQ_GEN',0);

Dopo un'esecuzione riuscita, verrà visualizzato il messaggio Query completata: Righe interessate: 1. Se questo messaggio non viene visualizzato, risolvere e risolvere il problema prima di procedere.

È possibile procedere alla distribuzione di WLS nell'offerta del servizio Azure Kubernetes.

Distribuire WebLogic Server nel servizio Azure Kubernetes

Usare la procedura seguente per trovare l'offerta WebLogic Server nel servizio Azure Kubernetes e compilare il riquadro Informazioni di base:

  1. Nella barra di ricerca nella parte superiore del portale di Azure immettere weblogic. Nella sezione Marketplace dei risultati della ricerca suggeriti automaticamente selezionare WebLogic Server nel servizio Azure Kubernetes.

    Screenshot del portale di Azure che mostra WebLogic Server nei risultati della ricerca.

    È anche possibile passare direttamente all'offerta WebLogic Server nel servizio Azure Kubernetes.

  2. Nella pagina dell'offerta selezionare Creare.

  3. Nel riquadro Informazioni di base verificare che il valore visualizzato nel campo Sottoscrizione sia lo stesso a cui è stato eseguito l'accesso in Azure. Assicurarsi di avere i ruoli elencati nella sezione prerequisiti per la sottoscrizione.

    Screenshot del portale di Azure che mostra WebLogic Server nel servizio Azure Kubernetes.

  4. È necessario distribuire l'offerta in un gruppo di risorse vuoto. Nel campo Gruppo di risorse selezionare Crea nuovo e quindi immettere un valore per il gruppo di risorse. Poiché i gruppi di risorse devono essere univoci all'interno di una sottoscrizione, selezionare un nome univoco. Un modo semplice per avere nomi univoci consiste nell'usare una combinazione di iniziali, data odierna e un identificatore, ad esempio ejb0723wls.

  5. In Dettagli istanza selezionare l'area per la distribuzione. Per un elenco delle aree di Azure in cui è disponibile il servizio Azure Kubernetes, vedere Disponibilità dell'area del servizio Azure Kubernetes.

  6. In Credentials for WebLogiclasciare il valore predefinito per Username for Amministratore WebLogic.

  7. RiempirewlsAksCluster2022 per password per amministratore WebLogic. Usare lo stesso valore per i campi di conferma e Password per crittografia del modello WebLogic.

  8. Selezionare Avanti.

Seguire questa procedura per avviare il processo di distribuzione:

  1. Scorrere fino alla sezione etichettata Fornire un account Oracle Single Sign-On (SSO). Compilare le credenziali di Oracle SSO dalle precondizioni.

    Screenshot del portale di Azure che mostra il riquadro dell'accesso Single Sign-On configurato.

  2. Assicurarsi di prendere nota della procedura descritta nella casella delle informazioni a partire da Prima di procedere, è necessario accettare le condizioni e le restrizioni standard Oracle.

  3. A seconda che l'account Oracle SSO disponga o meno di un diritto di supporto Oracle, selezionare l'opzione appropriata per Selezionare il tipo di WebLogic Server Images. Se l'account ha un diritto di supporto, selezionare Immagini di WebLogic Server con patch. In caso contrario, selezionare Immagini generali di WebLogic Server.

  4. Lasciare il valore in Selezionare la combinazione desiderata di WebLogic Server... nel valore predefinito. Sono disponibili un'ampia gamma di opzioni per WebLogic Server, JDK e versione del sistema operativo.

  5. Nella sezione Applicazione, accanto a Distribuire un'applicazione?selezionare No.

I passaggi seguenti consentono quindi di esporre la console di amministrazione di WebLogic Server e l'app di esempio a Internet pubblico con un componente aggiuntivo in ingresso del gateway applicazione predefinito. Per altre informazioni, vedere Cos’è un controller di ingresso del gateway applicazione?

  1. Selezionare Avanti per visualizzare il riquadro TLS/SSL.

  2. Selezionare Avanti per visualizzare il riquadro Bilanciamento del carico.

  3. Accanto a Opzioni di bilanciamento del carico selezionare Controller di ingresso del gateway applicazione.

    Screenshot del portale di Azure che mostra la configurazione più semplice possibile del servizio di bilanciamento del carico nella pagina di creazione di Oracle WebLogic Server nel servizio Azure Kubernetes.

  4. In Controller di ingresso del gateway applicazione verranno visualizzati tutti i campi prepopolati con le impostazioni predefinite perRete virtuale eSubnet. Lasciare invariati i valori predefiniti.

  5. Per Crea ingresso per la console di amministrazione selezionare Sì.

    Screenshot del portale di Azure che mostra la configurazione del controller in ingresso del gateway applicazione nella pagina di creazione di Oracle WebLogic Server nel servizio Azure Kubernetes.

  6. Selezionare Avanti per visualizzare il riquadro DNS.

  7. Selezionare Avanti per visualizzare il riquadro Database.

Usare la procedura seguente per configurare una connessione di database usando un'identità gestita:

  1. Per Connetti al database? selezionare Sì.
  2. In Impostazioni di connessione, per Scegliere il tipo di database, aprire il menu a discesa e quindi selezionare Microsoft SQL Server (con supporto per la connessione senza password).
  3. Per Nome JNDI immettere jdbc/WebLogicCafeDB.
  4. Per Stringa di connessione DataSource immettere il stringa di connessione ottenuto nell'ultima sezione.
  5. Selezionare Usa connessione origine dati senza password.
  6. Per Identità gestita assegnata dall'utente selezionare l'identità gestita creata nel passaggio precedente. In questo esempio il nome è myManagedIdentity.
  7. Selezionare Aggiungi.

La sezione Impostazioni di connessione dovrebbe essere simile alla schermata seguente:

Screenshot della portale di Azure che mostra la scheda Database della pagina Crea Oracle WebLogic Server in servizio Azure Kubernetes.

Per completare la distribuzione, seguire questa procedura:

  1. Selezionare Rivedi e crea. Assicurarsi che la convalida non riesca. In caso di errore, correggere eventuali problemi di convalida e quindi selezionare nuovamente Rivedi e crea.
  2. Seleziona Crea.
  3. Tenere traccia dello stato di avanzamento della distribuzione nella pagina Distribuzione in corso.

A seconda delle condizioni di rete e di altre attività nell'area selezionata, il completamento della distribuzione potrebbe richiedere fino a 50 minuti.

Nota

Se l'organizzazione richiede di distribuire il carico di lavoro all'interno di una rete virtuale aziendale senza indirizzi IP pubblici consentiti, è possibile scegliere il servizio load Balancer interno. Per configurare il servizio load Balancer interno, seguire questa procedura nella scheda Bilanciamento del carico:

  1. Per Opzioni di bilanciamento del carico selezionare Load Balancer Standard Servizio.

  2. Selezionare Usa servizio di bilanciamento del carico interno.

  3. Aggiungi le seguenti righe alla tabella:

    Prefisso del nome del servizio Destinazione Porta
    wls-admin-internal admin-server 7001
    wls-cluster-internal cluster-1 8001

La scheda Bilanciamento del carico dovrebbe essere simile alla schermata seguente:

Screenshot del portale di Azure che mostra la scheda Bilanciamento del carico della pagina Crea Oracle WebLogic Server servizio Azure Kubernetes.

Dopo la distribuzione, è possibile trovare gli URL di accesso del server di amministrazione e del cluster dall'output, etichettati adminConsoleExternalUrl e clusterExternalUrl.

Esaminare l'output della distribuzione

Usare i passaggi descritti in questa sezione per verificare che la distribuzione abbia avuto esito positivo.

Se ci si è allontanati dalla pagina Distribuzione in corso, i passaggi seguenti mostrano come tornare a quella pagina. Se si è ancora nella pagina che mostra il messaggio Distribuzione completata, è possibile passare al passaggio 5 dopo lo screenshot successivo.

  1. Nell’angolo di una pagina qualsiasi del portale di Microsoft Azure, selezionare il menu hamburger e selezionare Gruppi di risorse.

  2. Nella casella con il testo Filtra per qualsiasi campoimmettere i primi caratteri del gruppo di risorse creato in precedenza. Se è stata seguita la convenzione consigliata, immettere le iniziali, quindi selezionare il gruppo di risorse appropriato.

  3. Nella sezione Impostazionidel riquadro di spostamento selezionare Distribuzioni. Viene visualizzato un elenco ordinato delle distribuzioni in questo gruppo di risorse, con quello più recente.

  4. Scorrere fino alla voce meno recente in questo elenco. Questa voce corrisponde alla distribuzione avviata nella sezione precedente. Selezionare la distribuzione meno recente, come illustrato nello screenshot seguente.

    Screenshot del portale di Azure che mostra l'elenco delle distribuzioni dei gruppi di risorse.

  5. Nel riquadro di spostamento selezionare Outout. Questo elenco mostra i valori di output della distribuzione. Informazioni utili sono incluse negli output.

  6. Il valore adminConsoleExternalUrl è il collegamento visibile a Internet pubblico completo per la console di amministrazione di WebLogic Server per questo cluster del servizio Azure Kubernetes. Selezionare l'icona di copia accanto al valore del campo per copiare il collegamento negli Appunti. Salvare questo valore per un secondo momento.

  7. Il valore clusterExternalUrl è il collegamento visibile a Internet pubblico completo per l'app di esempio distribuita in WebLogic Server in questo cluster del servizio Azure Kubernetes. Selezionare l'icona di copia accanto al valore del campo per copiare il collegamento negli Appunti. Salvare questo valore per un secondo momento.

  8. Il valore shellCmdtoOutputWlsImageModelYaml è la stringa base64 del modello WDT usato per compilare l'immagine del contenitore. Salvare questo valore per un secondo momento.

  9. Il valore shellCmdtoOutputWlsImageProperties è la stringa base64 delle proprietà del modello WDT usate per compilare l'immagine del contenitore. Salvare questo valore per un secondo momento.

  10. Il valore shellCmdtoConnectAks è il comando dell'interfaccia della riga di comando di Azure per connettersi a questo cluster del servizio Azure Kubernetes specifico.

Gli altri valori negli output non rientrano nell'ambito di questo articolo, ma sono descritti in dettaglio nella Guida per l'utente di WebLogic nel servizio Azure Kubernetes.

Configurare e distribuire l'applicazione di esempio

L'offerta effettua il provisioning del cluster WebLogic Server tramite modello nell'immagine. Il cluster WebLogic Server non ha attualmente alcuna applicazione distribuita.

Questa sezione aggiorna il cluster WebLogic Server distribuendo un'applicazione di esempio usando un'immagine ausiliaria.

Consultare l'applicazione

In questa sezione si clona il codice di esempio per questa guida. L'esempio si trova in GitHub nel repository weblogic-on-azure nella cartella javaee/weblogic-café/. Ecco la struttura di file dell'applicazione.

weblogic-cafe
├── pom.xml
└── src
    └── main
        ├── java
        │   └── cafe
        │       ├── model
        │       │   ├── CafeRepository.java
        │       │   └── entity
        │       │       └── Coffee.java
        │       └── web
        │           ├── rest
        │           │   └── CafeResource.java
        │           └── view
        │               └── Cafe.java
        ├── resources
        │   ├── META-INF
        │   │   └── persistence.xml
        │   └── cafe
        │       └── web
        │           ├── messages.properties
        │           └── messages_es.properties
        └── webapp
            ├── WEB-INF
            │   ├── beans.xml
            │   ├── faces-config.xml
            │   └── web.xml
            ├── index.xhtml
            └── resources
                └── components
                    └── inputPrice.xhtml

Seguire i comandi seguenti per clonare il repository:

# cd <parent-directory-to-check-out-sample-code>
export BASE_DIR=$PWD

git clone --single-branch https://github.com/microsoft/weblogic-on-azure.git --branch 20240201 $BASE_DIR/weblogic-on-azure

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

Usare il comando seguente per compilare javaee/weblogic-café/:

mvn clean package --file $BASE_DIR/weblogic-on-azure/javaee/weblogic-cafe/pom.xml

Il pacchetto deve essere generato correttamente e situato in $BASE_DIR/weblogic-on-azure/javaee/weblogic-café/target/weblogic-café.war. Se il pacchetto non viene visualizzato, è necessario risolvere il problema prima di continuare.

Usare Registro Azure Container per creare un'immagine ausiliaria

I passaggi di questa sezione illustrano come creare un'immagine ausiliaria. Questa immagine include i componenti seguenti:

  • Il file modello di Modello di immagine
  • Applicazione
  • File di archivio del driver JDBC (Java Database Connectivity)
  • Installazione degli strumenti di distribuzione WebLogic

Un'immagine ausiliaria è un'immagine del contenitore Docker contenente l'app e la configurazione. L'operatore Kubernetes WebLogic combina l'immagine ausiliaria con domain.spec.image nel cluster del servizio Azure Kubernetes che contiene WebLogic Server, JDK e sistema operativo. Per altre informazioni sulle immagini ausiliarie, vedere Immagini ausiliarie nella documentazione di Oracle.

Questa sezione richiede un terminale Linux con l'interfaccia della riga di comando di Azure e kubectl installato.

Per compilare l'immagine, seguire questa procedura:

  1. Usare i comandi seguenti per creare una directory per preparare i modelli e l'applicazione:

    mkdir -p ${BASE_DIR}/mystaging/models
cd ${BASE_DIR}/mystaging/models

  2. Copiare il valore shellCmdtoOutputWlsImageModelYaml salvato dagli output della distribuzione, incollarlo nella finestra Bash ed eseguire il comando. Il comando dovrebbe essere simile all'esempio seguente:

    echo -e IyBDb3B5cmlna...Cgo= | base64 -d > model.yaml

    Questo comando genera un file ${BASE_DIR}/mystaging/models/model.yaml con contenuto simile all'esempio seguente:

    # Copyright (c) 2020, 2021, Oracle and/or its affiliates.
# Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl.

# Based on ./kubernetes/samples/scripts/create-weblogic-domain/model-in-image/model-images/model-in-image__WLS-v1/model.10.yaml
# in https://github.com/oracle/weblogic-kubernetes-operator.

domainInfo:
  AdminUserName: "@@SECRET:__weblogic-credentials__:username@@"
  AdminPassword: "@@SECRET:__weblogic-credentials__:password@@"
  ServerStartMode: "prod"

topology:
  Name: "@@ENV:CUSTOM_DOMAIN_NAME@@"
  ProductionModeEnabled: true
  AdminServerName: "admin-server"
  Cluster:
    "cluster-1":
      DynamicServers:
        ServerTemplate: "cluster-1-template"
        ServerNamePrefix: "@@ENV:MANAGED_SERVER_PREFIX@@"
        DynamicClusterSize: "@@PROP:CLUSTER_SIZE@@"
        MaxDynamicClusterSize: "@@PROP:CLUSTER_SIZE@@"
        MinDynamicClusterSize: "0"
        CalculatedListenPorts: false
  Server:
    "admin-server":
      ListenPort: 7001
  ServerTemplate:
    "cluster-1-template":
      Cluster: "cluster-1"
      ListenPort: 8001
  SecurityConfiguration:
    NodeManagerUsername: "@@SECRET:__weblogic-credentials__:username@@"
    NodeManagerPasswordEncrypted: "@@SECRET:__weblogic-credentials__:password@@"

resources:
  SelfTuning:
    MinThreadsConstraint:
      SampleMinThreads:
        Target: "cluster-1"
        Count: 1
    MaxThreadsConstraint:
      SampleMaxThreads:
        Target: "cluster-1"
        Count: 10
    WorkManager:
      SampleWM:
        Target: "cluster-1"
        MinThreadsConstraint: "SampleMinThreads"
        MaxThreadsConstraint: "SampleMaxThreads"

  3. In modo analogo, copiare il valore shellCmdtoOutputWlsImageProperties, incollarlo nella finestra Bash ed eseguire il comando. Il comando dovrebbe essere simile all'esempio seguente:

    echo -e IyBDb3B5cml...pFPTUK | base64 -d > model.properties

    Questo comando genera un file ${BASE_DIR}/mystaging/models/model.properties con contenuto simile all'esempio seguente:

    # Copyright (c) 2021, Oracle Corporation and/or its affiliates.
# Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl.

# Based on ./kubernetes/samples/scripts/create-weblogic-domain/model-in-image/model-images/model-in-image__WLS-v1/model.10.properties
# in https://github.com/oracle/weblogic-kubernetes-operator.

CLUSTER_SIZE=5

  4. Usare la procedura seguente per creare il file del modello di applicazione.

    1. Usare i comandi seguenti per copiare weblogic-café.war e salvarlo in wlsdeploy/applications:

      mkdir -p ${BASE_DIR}/mystaging/models/wlsdeploy/applications
cp $BASE_DIR/weblogic-on-azure/javaee/weblogic-cafe/target/weblogic-cafe.war ${BASE_DIR}/mystaging/models/wlsdeploy/applications/weblogic-cafe.war

    2. Usare i comandi seguenti per creare il file del modello di applicazione con il contenuto illustrato. Salvare il file del modello in ${BASE_DIR}/mystaging/models/appmodel.yaml.

      cat <<EOF >appmodel.yaml
appDeployments:
  Application:
    weblogic-cafe:
      SourcePath: 'wlsdeploy/applications/weblogic-cafe.war'
      ModuleType: ear
      Target: 'cluster-1'
EOF

  5. Per configurare la connessione all'origine dati, seguire questa procedura.

    1. Usare la procedura seguente per scaricare e installare il driver JDBC di Microsoft SQL Server e l'estensione Azure Identity che abilita le connessioni di database usando l'identità gestita di Azure.

      1. Usare i comandi seguenti per scaricare e installare il driver JDBC di Microsoft SQL Server in wlsdeploy/externalJDBCLibraries:

        export DRIVER_VERSION="10.2.1.jre8"
export MSSQL_DRIVER_URL="https://repo.maven.apache.org/maven2/com/microsoft/sqlserver/mssql-jdbc/${DRIVER_VERSION}/mssql-jdbc-${DRIVER_VERSION}.jar"

mkdir ${BASE_DIR}/mystaging/models/wlsdeploy/externalJDBCLibraries
curl -m 120 -fL ${MSSQL_DRIVER_URL} -o ${BASE_DIR}/mystaging/models/wlsdeploy/externalJDBCLibraries/mssql-jdbc-${DRIVER_VERSION}.jar

      2. Usare i comandi seguenti per installare l'estensione Azure Identity in wlsdeploy/classpathLibraries:

        curl -LO https://github.com/oracle/weblogic-azure/raw/refs/heads/main/weblogic-azure-aks/src/main/resources/azure-identity-extensions.xml

mvn dependency:copy-dependencies -f azure-identity-extensions.xml

mkdir -p ${BASE_DIR}/mystaging/models/wlsdeploy/classpathLibraries/azureLibraries
mkdir ${BASE_DIR}/mystaging/models/wlsdeploy/classpathLibraries/jackson
# fix JARs conflict issue in GA images, put jackson libraries to PRE_CLASSPATH to upgrade the existing libs.
mv target/dependency/jackson-annotations-*.jar ${BASE_DIR}/mystaging/models/wlsdeploy/classpathLibraries/jackson/
mv target/dependency/jackson-core-*.jar ${BASE_DIR}/mystaging/models/wlsdeploy/classpathLibraries/jackson/
mv target/dependency/jackson-databind-*.jar ${BASE_DIR}/mystaging/models/wlsdeploy/classpathLibraries/jackson/
mv target/dependency/jackson-dataformat-xml-*.jar ${BASE_DIR}/mystaging/models/wlsdeploy/classpathLibraries/jackson/
# Thoes jars will be appended to CLASSPATH
mv target/dependency/*.jar ${BASE_DIR}/mystaging/models/wlsdeploy/classpathLibraries/azureLibraries/

      3. Usare i comandi seguenti per pulire le risorse:

        rm target -f -r
rm azure-identity-extensions.xml

    2. Connettersi al cluster del servizio Azure Kubernetes copiando il valore shellCmdtoConnectAks salvato in precedenza, incollandolo nella finestra Bash, quindi eseguendo il comando. Il comando dovrebbe essere simile all'esempio seguente:

      az account set --subscription <subscription>;
az aks get-credentials \
    --resource-group <resource-group> \
    --name <name>

      L'output dovrebbe essere simile all'esempio seguente. Se questo output non viene visualizzato, risolvere e risolvere il problema prima di continuare.

      Merged "<name>" as current context in /Users/<username>/.kube/config

    3. Esportare il modello di connessione del database e salvarlo in ${BASE_DIR}/mystaging/models/dbmodel.yaml. I passaggi seguenti estraggono il modello di configurazione del database da ConfigMap sample-domain1-wdt-config-map. Il nome segue il formato <domain-uid>-wdt-config-map, dove <domain-uid> viene impostato durante la distribuzione dell'offerta. Se è stato modificato il valore predefinito, sostituirlo con il proprio UID di dominio.

      1. La chiave dati è <db-secret-name.yaml>. Usare il comando seguente per recuperare il nome del segreto del database:

        export WLS_DOMAIN_UID=sample-domain1
export WLS_DOMAIN_NS=${WLS_DOMAIN_UID}-ns
export DB_K8S_SECRET_NAME=$(kubectl get secret -n ${WLS_DOMAIN_NS} | grep "ds-secret" | awk '{print $1}')

      2. Estrarre quindi il modello di database con questo comando:

        kubectl get configmap sample-domain1-wdt-config-map -n ${WLS_DOMAIN_NS} -o=jsonpath="{['data']['${DB_K8S_SECRET_NAME}\.yaml']}" >${BASE_DIR}/mystaging/models/dbmodel.yaml

      3. Usare infine il comando seguente per verificare il contenuto di dbmodel.yaml.

        cat ${BASE_DIR}/mystaging/models/dbmodel.yaml

        L'output di questo comando dovrebbe essere simile alla struttura seguente:

        # Copyright (c) 2020, 2021, Oracle and/or its affiliates.
# Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl.

resources:
  JDBCSystemResource:
    jdbc/WebLogicCafeDB:
      Target: 'cluster-1'
      JdbcResource:
      JDBCDataSourceParams:
         JNDIName: [
            jdbc/WebLogicCafeDB
         ]
         GlobalTransactionsProtocol: OnePhaseCommit
      JDBCDriverParams:
         DriverName: com.microsoft.sqlserver.jdbc.SQLServerDriver
         URL: '@@SECRET:ds-secret-sqlserver-1727147748:url@@'
         PasswordEncrypted: '@@SECRET:ds-secret-sqlserver-1727147748:password@@'
         Properties:
            user:
            Value: '@@SECRET:ds-secret-sqlserver-1727147748:user@@'
      JDBCConnectionPoolParams:
            TestTableName: SQL SELECT 1
            TestConnectionsOnReserve: true

  6. Usare i comandi seguenti per creare un file di archivio e quindi rimuovere la cartella wlsdeploy , che non è più necessaria:

    cd ${BASE_DIR}/mystaging/models
zip -r archive.zip wlsdeploy

rm -f -r wlsdeploy

  7. Usare i comandi seguenti per scaricare e installare WebLogic Deploy Tooling (WDT) nella directory di staging e rimuovere i file weblogic-deploy/bin/*.cmd, che non vengono usati negli ambienti UNIX:

    cd ${BASE_DIR}/mystaging
curl -m 120 -fL https://github.com/oracle/weblogic-deploy-tooling/releases/latest/download/weblogic-deploy.zip -o weblogic-deploy.zip

unzip weblogic-deploy.zip -d .
rm ./weblogic-deploy/bin/*.cmd

  8. Usare il comando seguente per pulire il programma di installazione di WDT:

    rm weblogic-deploy.zip

  9. Usare i comandi seguenti per creare un file Docker:

    cd ${BASE_DIR}/mystaging
cat <<EOF >Dockerfile
FROM busybox
ARG AUXILIARY_IMAGE_PATH=/auxiliary
ARG USER=oracle
ARG USERID=1000
ARG GROUP=root
ENV AUXILIARY_IMAGE_PATH=\${AUXILIARY_IMAGE_PATH}
RUN adduser -D -u \${USERID} -G \$GROUP \$USER
COPY --chown=\$USER:\$GROUP ./ \${AUXILIARY_IMAGE_PATH}/
USER \$USER
EOF

  10. Eseguire il az acr build comando usando ${BASE_DIR}/mystaging/Dockerfile, come illustrato nell'esempio seguente:

    export ACR_NAME=<value-from-clipboard>
export IMAGE="wlsaks-auxiliary-image:1.0"

  11. Usare i comandi seguenti per controllare i file di staging:

    cd ${BASE_DIR}/mystaging
find -maxdepth 2 -type f -print

    Questi comandi producono output simile all'esempio seguente:

    ./models/model.properties
./models/model.yaml
./models/appmodel.yaml
./models/dbmodel.yaml
./models/archive.zip
./Dockerfile
./weblogic-deploy/VERSION.txt
./weblogic-deploy/LICENSE.txt

  12. Compilare l'immagine con az acr build, come illustrato nell'esempio seguente:

    az acr build -t ${IMAGE} --build-arg AUXILIARY_IMAGE_PATH=/auxiliary -r ${ACR_NAME} --platform linux/amd64 .

    Quando si compila correttamente l'immagine, l'output è simile all'esempio seguente:

    ...
Step 1/9 : FROM busybox
latest: Pulling from library/busybox
Digest: sha256:9ae97d36d26566ff84e8893c64a6dc4fe8ca6d1144bf5b87b2b85a32def253c7
Status: Image is up to date for busybox:latest
---> 65ad0d468eb1
Step 2/9 : ARG AUXILIARY_IMAGE_PATH=/auxiliary
---> Running in 1f8f4e82ccb6
Removing intermediate container 1f8f4e82ccb6
---> 947fde618be9
Step 3/9 : ARG USER=oracle
---> Running in dda021591e41
Removing intermediate container dda021591e41
---> f43d84be4517
Step 4/9 : ARG USERID=1000
---> Running in cac4df6dfd13
Removing intermediate container cac4df6dfd13
---> e5513f426c74
Step 5/9 : ARG GROUP=root
---> Running in 8fec1763270c
Removing intermediate container 8fec1763270c
---> 9ef233dbe279
Step 6/9 : ENV AUXILIARY_IMAGE_PATH=${AUXILIARY_IMAGE_PATH}
---> Running in b7754f58157a
Removing intermediate container b7754f58157a
---> 4a26a97eb572
Step 7/9 : RUN adduser -D -u ${USERID} -G $GROUP $USER
---> Running in b6c1f1a81af1
Removing intermediate container b6c1f1a81af1
---> 97d3e5ad7540
Step 8/9 : COPY --chown=$USER:$GROUP ./ ${AUXILIARY_IMAGE_PATH}/
---> 21088171876f
Step 9/9 : USER $USER
---> Running in 825e0abc9f6a
Removing intermediate container 825e0abc9f6a
---> b81d6430fcda
Successfully built b81d6430fcda
Successfully tagged wlsaksacru6jyly7kztoqu.azurecr.io/wlsaks-auxiliary-image:1.0
2024/08/28 03:06:19 Successfully executed container: build
2024/08/28 03:06:19 Executing step ID: push. Timeout(sec): 3600, Working directory: '', Network: ''
2024/08/28 03:06:19 Pushing image: wlsaksacru6jyly7kztoqu.azurecr.io/wlsaks-auxiliary-image:1.0, attempt 1
The push refers to repository [wlsaksacru6jyly7kztoqu.azurecr.io/wlsaks-auxiliary-image]
ee589b3cda86: Preparing
c1fd1adab3b9: Preparing
d51af96cf93e: Preparing
c1fd1adab3b9: Pushed
d51af96cf93e: Pushed
ee589b3cda86: Pushed
1.0: digest: sha256:c813eb75576eb07a179c3cb4e70106ca7dd280f933ab33a2f6858de673b12eac size: 946
2024/08/28 03:06:21 Successfully pushed image: wlsaksacru6jyly7kztoqu.azurecr.io/wlsaks-auxiliary-image:1.0
2024/08/28 03:06:21 Step ID: build marked as successful (elapsed time in seconds: 8.780235)
2024/08/28 03:06:21 Populating digests for step ID: build...
2024/08/28 03:06:22 Successfully populated digests for step ID: build
2024/08/28 03:06:22 Step ID: push marked as successful (elapsed time in seconds: 1.980158)
2024/08/28 03:06:22 The following dependencies were found:
2024/08/28 03:06:22
- image:
   registry: wlsaksacru6jyly7kztoqu.azurecr.io
   repository: wlsaks-auxiliary-image
   tag: "1.0"
   digest: sha256:c813eb75576eb07a179c3cb4e70106ca7dd280f933ab33a2f6858de673b12eac
runtime-dependency:
   registry: registry.hub.docker.com
   repository: library/busybox
   tag: latest
   digest: sha256:9ae97d36d26566ff84e8893c64a6dc4fe8ca6d1144bf5b87b2b85a32def253c7
git: {}

Run ID: ca1 was successful after 14s

    L'immagine viene inserita in Registro Azure Container dopo una compilazione riuscita.

  13. È possibile eseguire az acr repository show per verificare se l'immagine viene inserita correttamente nel repository remoto, come illustrato nell'esempio seguente:

    az acr repository show --name ${ACR_NAME} --image ${IMAGE}

    Questo comando dovrebbe produrre un output simile all'esempio seguente:

    {
   "changeableAttributes": {
      "deleteEnabled": true,
      "listEnabled": true,
      "readEnabled": true,
      "writeEnabled": true
   },
   "createdTime": "2024-01-24T06:14:19.4546321Z",
   "digest": "sha256:a1befbefd0181a06c6fe00848e76f1743c1fecba2b42a975e9504ba2aaae51ea",
   "lastUpdateTime": "2024-01-24T06:14:19.4546321Z",
   "name": "1.0",
   "quarantineState": "Passed",
   "signed": false
}

Applicare l'immagine ausiliaria

Nei passaggi precedenti è stata creata l'immagine ausiliaria, inclusi i modelli e WDT. Applicare l'immagine ausiliaria al cluster WebLogic Server seguendo questa procedura.

  1. Applicare l'immagine ausiliaria applicando patch alla definizione della risorsa personalizzata del dominio usando il comando kubectl patch.

    L'immagine ausiliaria è definita in spec.configuration.model.auxiliaryImages, come illustrato nell'esempio seguente:

    spec:
  clusters:
  - name: sample-domain1-cluster-1
  configuration:
    model:
      auxiliaryImages:
      - image: wlsaksacrafvzeyyswhxek.azurecr.io/wlsaks-auxiliary-image:1.0
        imagePullPolicy: IfNotPresent
        sourceModelHome: /auxiliary/models
        sourceWDTInstallHome: /auxiliary/weblogic-deploy

    Usare i comandi seguenti per aumentare il valore restartVersion e usare kubectl patch per applicare l'immagine ausiliaria al dominio CRD usando la definizione illustrata:

    export VERSION=$(kubectl -n ${WLS_DOMAIN_NS} get domain ${WLS_DOMAIN_UID} -o=jsonpath='{.spec.restartVersion}' | tr -d "\"")
export VERSION=$((VERSION+1))

export ACR_LOGIN_SERVER=$(az acr show --name ${ACR_NAME} --query "loginServer" --output tsv)

cat <<EOF >patch-file.json
[
  {
    "op": "replace",
    "path": "/spec/restartVersion",
    "value": "${VERSION}"
  },
  {
    "op": "add",
    "path": "/spec/configuration/model/auxiliaryImages",
    "value": [{"image": "$ACR_LOGIN_SERVER/$IMAGE", "imagePullPolicy": "IfNotPresent", "sourceModelHome": "/auxiliary/models", "sourceWDTInstallHome": "/auxiliary/weblogic-deploy"}]
  },
  {
   "op": "remove",
   "path": "/spec/configuration/model/configMap"
  }
]
EOF

kubectl -n ${WLS_DOMAIN_NS} patch domain ${WLS_DOMAIN_UID} \
    --type=json \
    --patch-file patch-file.json

  2. Poiché la connessione al database è configurata nell'immagine ausiliaria, eseguire il comando seguente per rimuovere ConfigMap:

    kubectl delete configmap sample-domain1-wdt-config-map -n ${WLS_DOMAIN_NS}

Prima di procedere, attendere che il comando seguente produa l'output seguente per il server di amministrazione e i server gestiti:

kubectl get pod -n ${WLS_DOMAIN_NS} -w

NAME                             READY   STATUS    RESTARTS   AGE
sample-domain1-admin-server      1/1     Running   0          20m
sample-domain1-managed-server1   1/1     Running   0          19m
sample-domain1-managed-server2   1/1     Running   0          18m

Potrebbero essere necessari 5-10 minuti prima che il sistema raggiunga questo stato. L'elenco seguente offre una panoramica delle operazioni che si verificano durante l'attesa:

  • Dovrebbe essere visualizzata l’esecuzione di sample-domain1-introspector innanzitutto. Questo software cerca le modifiche apportate alla risorsa personalizzata del dominio in modo che possa eseguire le azioni necessarie nel cluster Kubernetes.
  • Quando vengono rilevate modifiche, l'introspezione del dominio termina e avvia nuovi pod per implementare le modifiche.
  • Verrà quindi visualizzato il termine e il riavvio del pod sample-domain1-admin-server.
  • Verranno quindi visualizzati i due server gestiti terminano e si riavviano.
  • Solo quando tutti e tre i pod mostrano lo stato 1/1 Running è possibile procedere.

Verificare la funzionalità della distribuzione

Seguire questa procedura per verificare la funzionalità della distribuzione visualizzando la console di amministrazione di WebLogic Server e l'app di esempio:

  1. Incollare il valore adminConsoleExternalUrl nella barra degli indirizzi di un Web browser connesso a Internet. Verrà visualizzata la schermata di accesso familiare della console di amministrazione di WebLogic Server.

  2. Accedere con il nome utente weblogic e la password immessi durante la distribuzione di WebLogic Server dal portale di Azure. Tenere presente che questo valore è wlsAksCluster2022.

  3. Nella casella Struttura dominio selezionare Servizi.

  4. In Serviziselezionare Origini dati.

  5. Nel pannelloRiepilogo delle origini dati JDBC selezionare Monitoraggio. La schermata dovrebbe essere simile all’esempio seguente. Lo stato dell'origine dati è in esecuzione nei server gestiti.

    Screenshot dello stato dell'origine dati.

  6. Nella casella Struttura dominio selezionare Distribuzioni.

  7. Nella tabella Distribuzioni deve essere presente una riga. Il nome deve essere lo stesso valore del valore Application nel file appmodel.yaml. Selezionare il nome.

  8. Selezionare la scheda Test.

  9. Selezionare weblogic-café.

  10. Nel panello Impostazioni per weblogic-café selezionare la scheda Test.

  11. Espandere l'icona + accanto a weblogic-café. La schermata dovrebbe essere simile all’esempio seguente. In particolare, verranno visualizzati valori simili a http://sample-domain1-managed-server1:8001/weblogic-cafe/index.xhtml nella colonna Punto di test.

    Screenshot dei punti di test di weblogic-café.

    Nota

    I collegamenti ipertestuali nella colonna Punto di test non sono selezionabili perché la console di amministrazione non è stata configurata con l'URL esterno in cui è in esecuzione. Questo articolo illustra semplicemente la console di amministrazione di WebLogic Server a scopo dimostrativo. Non usare la console di amministrazione di WebLogic Server per modifiche di configurazione durevoli durante l'esecuzione di WebLogic Server nel servizio Azure Kubernetes. La progettazione nativa del cloud di WebLogic Server nel servizio Azure Kubernetes richiede che qualsiasi configurazione durevole debba essere rappresentata nelle immagini Docker iniziali o applicata al cluster del servizio Azure Kubernetes in esecuzione usando tecniche CI/CD come l'aggiornamento del modello, come descritto nella documentazione di Oracle.

  12. Comprendere il valore context-path dell'app di esempio distribuita. Se è stata distribuita l'app di esempio consigliata, context-path è weblogic-cafe.

  13. Costruire un URL completo per l'app di esempio aggiungendo l'oggetto context-path al valore clusterExternalUrl. Se è stata distribuita l'app di esempio consigliata, l'URL completo deve essere simile a http://wlsgw202401-wls-aks-domain1.eastus.cloudapp.azure.com/weblogic-cafe/.

  14. Incollare l'URL completo in un Web browser connesso a Internet. Se è stata distribuita l'app di esempio consigliata, verranno visualizzati risultati simili allo screenshot seguente:

    Screenshot dell'app Web di test.

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. Il comando seguente rimuove il gruppo di risorse, il servizio contenitore, il registro contenitori, database e tutte le risorse correlate:

az group delete --name <resource-group-name> --yes --no-wait
az group delete --name <db-resource-group-name> --yes --no-wait

Passaggi successivi

Per altre informazioni sull'esecuzione di WebLogic Server nel servizio Azure Kubernetes o nelle macchine virtuali, vedere i collegamenti seguenti:

Per altre informazioni sulle offerte Oracle WebLogic in Azure Marketplace, vedere Oracle WebLogic Server in Azure. Queste offerte sono tutte di tipo Bring Your Own License. Presuppongono che si abbiano già le licenze appropriate con Oracle e che si abbia una licenza appropriata per l'esecuzione delle offerte in Azure.