Esercitazione: Installare manualmente webSphere Application Server Network Deployment (tradizionale) in Azure Macchine virtuali (VM)

Articolo
10/29/2024

Questa esercitazione illustra come installare IBM WebSphere Application Server (WAS) Network Deployment (ND) tradizionale e configurare un cluster WAS in Azure Macchine virtuali (VM) in GNU/Linux.

In questa esercitazione apprenderai a:

Creare una rete virtuale personalizzata e creare le macchine virtuali all'interno della rete.
Installare manualmente WebSphere Application Server Network Deployment tradizionale (V9 o V8.5) nelle macchine virtuali usando l'interfaccia grafica.
Configurare un cluster WAS usando lo strumento di gestione dei profili.
Distribuire ed eseguire un'applicazione Java Platform edizione Enterprise (Java EE) nel cluster.
Esporre l'applicazione a Internet pubblico tramite app Azure lication Gateway.
Convalidare la configurazione corretta.

Se si preferisce una soluzione completamente automatizzata che esegue tutti questi passaggi per conto delle macchine virtuali GNU/Linux, direttamente dalla portale di Azure, vedere Avvio rapido: Distribuire cluster di distribuzione di rete del server applicazioni WebSphere in Azure Macchine virtuali. Un'opzione meno automatizzata, ma ancora accelerata, consiste nell'ignorare i passaggi dell'installazione di Java Development Kit (JDK) e WebSphere nel sistema operativo usando un'immagine di base Di Red Hat Linux preconfigurata. È possibile trovare queste offerte in Azure Marketplace usando una query per l'immagine del server applicazioni WebSphere 9.0.5.x.

Se si è interessati a lavorare a stretto contatto con il team di progettazione che sviluppa soluzioni WebSphere in 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

Una sottoscrizione di Azure. Se non si ha una sottoscrizione di Azure, creare un account gratuito prima di iniziare.
Installare l'interfaccia della riga di comando di Azure versione 2.46.0 o successiva per eseguire i comandi dell'interfaccia della riga di comando di Azure.
- Questo articolo fornisce istruzioni per richiamare i comandi dell'interfaccia della riga di comando di Azure in Windows PowerShell o UNIX Bash. In entrambi i casi, è necessario installare l'interfaccia della riga di comando di Azure.
- Quando richiesto, installare le estensioni dell'interfaccia della riga di comando di Azure al primo utilizzo. Per altre informazioni sulle estensioni, vedere Usare e gestire le estensioni con l'interfaccia della riga di comando di Azure.
- Eseguire az version per trovare la versione e le librerie dipendenti installate. Per eseguire l'aggiornamento alla versione più recente, eseguire az upgrade.
Devi avere un IBMid. Se non è disponibile, creare un account IBM in Accedi a IBM e selezionare Crea un IBMid. Prendere nota della password e dell'indirizzo di posta elettronica IBMid.
- Se si prevede di usare la versione 8.5.5 di IBM WebSphere Application Server Network Deployment, questo IBMid deve avere diritto a usare tale versione del software. Per informazioni sui diritti, chiedere ai contatti primari o secondari per il sito IBM Passport Advantage di concedere l'accesso o seguire la procedura descritta in IBM eCustomer Care.

Preparare l'ambiente

In questa sezione viene configurata l'infrastruttura in cui si installa IBM Installation Manager e WebSphere Application Server Network Deployment tradizionale.

Presupposti

Questa esercitazione configura un cluster WAS con un gestore di distribuzione e due server gestiti in un totale di tre macchine virtuali. Per configurare il cluster, è necessario creare le tre macchine virtuali di Azure seguenti all'interno dello stesso set di disponibilità:

La macchina virtuale di amministrazione (nome adminVMmacchina virtuale ) ha il gestore di distribuzione in esecuzione.
Le macchine virtuali gestite (nomi mspVM1 di vm e mspVM2) hanno due server gestiti in esecuzione.

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

az login

Nota

Se più tenant di Azure sono associati alle credenziali di Azure, è necessario specificare il tenant a cui si vuole accedere. A tale scopo, usare l'opzione --tenant . Ad esempio: az login --tenant contoso.onmicrosoft.com.

Creare un gruppo di risorse

Creare un gruppo di risorse usando az group create. I nomi dei gruppi di risorse devono essere univoci a livello globale all'interno di una sottoscrizione. Per questo motivo, prendere in considerazione la possibilità di anteporre un identificatore univoco a tutti i nomi creati che devono essere univoci. Una tecnica utile consiste nell'usare le iniziali, seguite dalla data odierna in mmdd formato. Questo esempio crea un gruppo di risorse denominato abc1110rg nel eastus percorso:

Bash
PowerShell

export RESOURCE_GROUP_NAME=abc1110rg
az group create --name $RESOURCE_GROUP_NAME --location eastus

$Env:RESOURCE_GROUP_NAME = "abc1110rg"
az group create `
    --name $Env:RESOURCE_GROUP_NAME `
    --location eastus

Creare una rete virtuale

Nota

Per impostazione predefinita, i comandi dell'interfaccia della riga di comando di Azure in questa sezione seguono lo stile Bash, se non diversamente specificato.

Se si eseguono questi comandi in PowerShell, assicurarsi di dichiarare i parametri di ambiente come indicato nei comandi precedenti.

Per suddividere una riga di comando in più righe in PowerShell, è possibile usare il carattere backtick (') alla fine di ogni riga.

Le risorse che compongono il cluster server applicazioni WebSphere devono comunicare tra loro e con la rete Internet pubblica usando una rete virtuale. Per una guida completa alla pianificazione della rete virtuale, vedere la guida di Cloud Adoption Framework per Azure Pianificare le reti virtuali. Per altre informazioni, vedere Azure Rete virtuale domande frequenti.

Usare la procedura seguente per creare la rete virtuale. L'esempio in questa sezione crea una rete virtuale con spazio 192.168.0.0/16 indirizzi e crea una subnet per le macchine virtuali.

Creare una rete virtuale usando az network vnet create. L'esempio seguente crea una rete denominata myVNet:

Bash
PowerShell

az network vnet create \
    --resource-group $RESOURCE_GROUP_NAME \
    --name myVNet \
    --address-prefixes 192.168.0.0/24

az network vnet create `
    --resource-group $Env:RESOURCE_GROUP_NAME `
    --name myVNet `
    --address-prefixes 192.168.0.0/24

Creare una subnet per il cluster WAS usando az network vnet subnet create. Nell'esempio seguente viene creata una subnet denominata mySubnet:

Bash
PowerShell

az network vnet subnet create \
    --resource-group $RESOURCE_GROUP_NAME \
    --name mySubnet \
    --vnet-name myVNet \
    --address-prefixes 192.168.0.0/25

az network vnet subnet create `
    --resource-group $Env:RESOURCE_GROUP_NAME `
    --name mySubnet `
    --vnet-name myVNet `
    --address-prefixes 192.168.0.0/25

Creare una subnet per gateway applicazione usando az network vnet subnet create. Nell'esempio seguente viene creata una subnet denominata wasGateway:

Bash
PowerShell

az network vnet subnet create \
    --resource-group $RESOURCE_GROUP_NAME \
    --name wasGateway \
    --vnet-name myVNet \
    --address-prefixes 192.168.0.128/25

az network vnet subnet create `
    --resource-group $Env:RESOURCE_GROUP_NAME `
    --name wasGateway `
    --vnet-name myVNet `
    --address-prefixes 192.168.0.128/25

Creare un set di disponibilità

Creare un set di disponibilità usando az vm availability-set create, come illustrato nell'esempio seguente. Creare un set di disponibilità è un'operazione facoltativa, ma consigliata. Per altre informazioni, vedere Procedura dettagliata dell'infrastruttura di Azure di esempio per le macchine virtuali Windows.

Bash
PowerShell

az vm availability-set create \
    --resource-group $RESOURCE_GROUP_NAME \
    --name myAvailabilitySet \
    --platform-fault-domain-count 2 \
    --platform-update-domain-count 2

az vm availability-set create `
    --resource-group $Env:RESOURCE_GROUP_NAME `
    --name myAvailabilitySet `
    --platform-fault-domain-count 2 `
    --platform-update-domain-count 2

Ottenere o installare WAS in GNU/Linux

Le sezioni seguenti descrivono i passaggi per ottenere o installare WAS in GNU/Linux. È possibile scegliere il sistema operativo e la versione WAS in base ai requisiti, ma è necessario verificare che siano disponibili nella documentazione ibm WebSphere Application Server Network Deployment.

WAS ND V9
WAS ND V85

Se si vuole usare WAS V9, le istruzioni usano un'immagine di macchina virtuale di Azure che contiene la versione supportata più recente del software. IBM e Microsoft mantengono l'immagine. Per l'elenco completo delle immagini di base WAS gestite da IBM e Microsoft, vedere Azure Marketplace.

IBM e Microsoft mantengono un'immagine di base della macchina virtuale con WAS V9 preinstallata nella versione consigliata di Red Hat Enterprise Linux. Per altre informazioni su questa immagine, vedere il portale di Azure. Se si usa questo approccio, l'immagine di Azure Marketplace usata per creare le macchine virtuali è ibm-usa-ny-armonk-hq-6275750-ibmcloud-aiops:2021-04-27-twas-cluster-base-image:2021-04-27-twas-cluster-base-image:latest. Usare il comando seguente per salvare il nome dell'immagine in una variabile di ambiente:

export VM_URN="ibm-usa-ny-armonk-hq-6275750-ibmcloud-aiops:2023-03-27-twas-cluster-base-image:2023-03-27-twas-cluster-base-image:latest"

$Env:VM_URN="ibm-usa-ny-armonk-hq-6275750-ibmcloud-aiops:2023-03-27-twas-cluster-base-image:2023-03-27-twas-cluster-base-image:latest"

Se si vuole usare WAS V8.5, le istruzioni iniziano con una macchina virtuale Red Hat Enterprise Linux di base e illustrano i passaggi per installare tutte le dipendenze necessarie.

L'immagine di Azure Marketplace usata per creare le macchine virtuali è RedHat:rhel-raw:86-gen2:latest. Usare il comando seguente per salvare il nome dell'immagine in una variabile di ambiente.

Nota

È possibile eseguire query su tutte le immagini Red Hat Enterprise Linux disponibili fornite da Red Hat usando az vm image list, come illustrato nell'esempio seguente:

az vm image list \
    --offer RHEL \
    --publisher RedHat \
    --output table \
    --all

Per altre informazioni, vedere Panoramica delle immagini Red Hat Enterprise Linux.

Se si usa un'immagine diversa, potrebbe essere necessario installare librerie aggiuntive per abilitare l'infrastruttura usata da questa guida.

export VM_URN="RedHat:rhel-raw:86-gen2:latest"

$Env:VM_URN="RedHat:rhel-raw:86-gen2:latest"

Creare un computer Red Hat Enterprise Linux

Usare la procedura seguente per creare una macchina virtuale di base, verificare l'installazione degli strumenti necessari, creare uno snapshot del disco e creare repliche basate su tale snapshot:

Creare una macchina virtuale usando il comando az vm create. Eseguire il gestore di distribuzione in questa macchina virtuale.

L'esempio seguente crea un computer Red Hat Enterprise Linux usando una coppia nome utente/password per l'autenticazione. È invece possibile scegliere di usare l'autenticazione TLS/SSL, che è più sicura.

Bash
PowerShell

az vm create \
    --resource-group $RESOURCE_GROUP_NAME \
    --name adminVM \
    --availability-set myAvailabilitySet \
    --image $VM_URN \
    --size Standard_DS1_v2  \
    --admin-username azureuser \
    --admin-password Secret123456 \
    --public-ip-address "" \
    --nsg ""

# For `public-ip-address` and `nsg`, be sure to wrap the value "" in '' in PowerShell.
az vm create `
    --resource-group $Env:RESOURCE_GROUP_NAME `
    --name adminVM `
    --availability-set myAvailabilitySet `
    --image $Env:VM_URN `
    --size Standard_DS1_v2 `
    --admin-username azureuser `
    --admin-password Secret123456 `
    --public-ip-address '""' `
    --nsg '""'

Creare e collegare un nuovo disco per i file WAS usando il comando seguente:

WAS ND V9
WAS ND V85

Questo passaggio viene già eseguito quando si usa l'immagine di base della macchina virtuale.

az vm disk attach \
    --resource-group $RESOURCE_GROUP_NAME \
    --vm-name adminVM \
    --name adminVM_Data_Disk_1 \
    --new \
    --size-gb 100 \
    --sku StandardSSD_LRS

az vm disk attach `
    --resource-group $Env:RESOURCE_GROUP_NAME `
    --vm-name adminVM `
    --name adminVM_Data_Disk_1 `
    --new `
    --size-gb 100 `
    --sku StandardSSD_LRS

Creare una macchina virtuale Windows e configurare un server X

Questa esercitazione usa l'interfaccia grafica di WAS per completare l'installazione e la configurazione. Si usa una macchina virtuale Windows come jump box ed è possibile eseguire un server X Window System per visualizzare i programmi di installazione grafici nelle tre macchine virtuali del cluster WAS.

Usare la procedura seguente per effettuare il provisioning di un computer Windows 10 e installare un server X. Se si ha già un computer Windows nella stessa rete del computer Red Hat Enterprise Linux, non è necessario effettuarne il provisioning da Azure. È possibile passare direttamente alla sezione che installa il server X.

Usare la procedura seguente per creare una macchina virtuale Windows 10 dalla portale di Azure:
1. Aprire il gruppo di risorse creato prima nella portale di Azure.
2. Selezionare Crea per creare la risorsa.
3. Selezionare Calcolo, cercare Windows 10 e quindi selezionare Microsoft Windows 10.
4. Selezionare il piano desiderato e quindi selezionare Crea.
5. Usare i valori seguenti per configurare la macchina virtuale:
  - Nome macchina virtuale: myWindowsVM
  - Immagine: Windows 10 Pro
  - Nome utente: azureuser
  - Password: Secret123456
6. Selezionare la casella di controllo in Licenze.
7. Seleziona Rivedi e crea e quindi seleziona Crea.
La creazione della macchina virtuale e delle risorse di supporto richiede alcuni minuti.

Al termine della distribuzione, installare il server X e usarlo per configurare il server applicazioni nei computer Linux usando un'interfaccia grafica.
Per installare e avviare il server X, seguire questa procedura:
1. Usare Desktop remoto per connettersi a myWindowsVM. Per una guida dettagliata, vedere Come connettersi con Desktop remoto e accedere a una macchina virtuale di Azure che esegue Windows. È necessario eseguire i passaggi rimanenti in questa sezione in myWindowsVM.
2. Scaricare e installare VcXsrv Windows X Server.
3. Disabilitare il firewall. Per consentire la comunicazione dalle macchine virtuali Linux, seguire questa procedura per disattivare Windows Defender Firewall:
  1. Cercare e aprire Windows Defender Firewall.
  2. Trova Attiva o disattiva Windows Defender Firewall e quindi seleziona Disattiva nelle impostazioni di rete privata. È possibile lasciare invariate le impostazioni di rete pubblica.
  3. Seleziona OK.
  4. Chiudere il pannello delle impostazioni di Windows Defender Firewall .
4. Selezionare X-launch dal desktop.
5. Per le impostazioni di visualizzazione, impostare il numero di visualizzazione su -1 per usare più finestre e quindi selezionare Avanti.
6. Per Selezionare come avviare i client, selezionare Avvia nessun client e quindi selezionare Avanti.
7. Per impostazioni aggiuntive, selezionare Appunti e Selezione primaria, Opengl nativo e Disabilita controllo di accesso.
8. Seleziona Avanti per terminare.
È possibile che venga visualizzata una finestra di dialogo di avviso Sicurezza di Windows con questo messaggio: "Consenti a VcXsrv windows X-server di comunicare su queste reti". Selezionare Consenti l'accesso.

A questo punto è possibile connettersi al computer Red Hat Enterprise Linux e installare gli strumenti necessari usando l'interfaccia grafica. Le sezioni seguenti illustrano come installare IBM Installation Manager e WebSphere Application Server Network Deployment tradizionale. Si usa myWindowsVM per l'installazione e la configurazione.

Installare le dipendenze

Usare la procedura seguente per installare le dipendenze necessarie per consentire la connessione dal server X e abilitare l'installazione grafica:

Usare la procedura seguente per ottenere l'indirizzo IP privato di adminVM:
1. Nella portale di Azure selezionare il gruppo di risorse creato in precedenza.
2. Nell'elenco delle risorse selezionare adminVM.
3. Nel riquadro panoramica selezionare Proprietà.
4. Nella sezione Rete copiare il valore di Indirizzo IP privato. In questo esempio il valore è 192.168.0.4.
Aprire un prompt dei comandi da myWindowsVMe quindi connettersi a adminVM usando ssh, come illustrato nell'esempio seguente:
```
set ADMINVM_IP="192.168.0.4"
ssh azureuser@%ADMINVM_IP%
```
Immettere la password Secret123456.
Usare il comando seguente per passare all'utente root . Questa esercitazione installa tutti gli strumenti con l'utente root .
```
sudo su -
```

Usare i comandi seguenti per installare le dipendenze:

# dependencies for X server access
yum install -y libXtst libSM libXrender

# dependencies for GUI installation
yum install -y gtk2 libXtst xorg-x11-fonts-Type1 mesa-libGL

Successivamente, si continua a montare il disco dati in adminVM, quindi mantenere aperto questo terminale.

Questo passaggio viene già eseguito quando si usa l'immagine di base della macchina virtuale.

Tutti i file di installazione e le configurazioni vengono archiviati nel disco dati. Per montare il disco, seguire questa procedura. Eseguire i comandi come root utente. Se non si lavora con root, eseguire sudo su - per cambiare utente.

Usare il comando seguente per verificare la presenza dell'ultimo dispositivo disco creato formattato per contenere i file WAS:
```
ls -alt /dev/sd*|head -1
```
L'output è simile all'esempio seguente:
```
brw-rw----. 1 root disk 8, 32 Jan 28 09:04 /dev/sdc
```
Usare la procedura seguente per formattare il dispositivo. root Come utente, eseguire parted nel dispositivo.
1. Usare il comando seguente per creare una partizione primaria che si estende sull'intero disco:
```
parted /dev/sdc --script mklabel gpt mkpart xfspart xfs 0% 100%
```
2. Usare il comando seguente per controllare i dettagli del dispositivo stampandone i metadati:
```
parted /dev/sdc print
```
  L'output deve essere simile all'esempio seguente:
```
Model: Msft Virtual Disk (scsi)
Disk /dev/sdc: 107GB
Sector size (logical/physical): 512B/4096B
Partition Table: gpt
Disk Flags:

Number  Start   End    Size   File system  Name     Flags
1      1049kB  107GB  107GB               xfspart
```
Usare i comandi seguenti per creare un file system nella partizione del dispositivo:
```
mkfs.xfs /dev/sdc1
partprobe /dev/sdc1
```
Usare il comando seguente per creare un punto di montaggio:
```
mkdir /datadrive
```
Usare il comando seguente per montare il disco:
```
mount /dev/sdc1 /datadrive
```

Usare il comando seguente per aggiungere il montaggio al file /etc/fstab :

echo "UUID=$(blkid | grep -Po "(?<=\/dev\/sdc1\: UUID=\")[^\"]*(?=\".*)")   /datadrive   xfs   defaults,nofail   1   2" >> /etc/fstab

Usare i comandi seguenti per creare directory per i file di installazione e i file di configurazione:

export IM_INSTALL_DIRECTORY=/datadrive/IBM/InstallationManager/V1.9
export WAS_ND_INSTALL_DIRECTORY=/datadrive/IBM/WebSphere/ND/V85
export IM_SHARED_DIRECTORY=/datadrive/IBM/IMShared
mkdir -p ${IM_INSTALL_DIRECTORY}
mkdir -p ${WAS_ND_INSTALL_DIRECTORY}
mkdir -p ${IM_SHARED_DIRECTORY}

Successivamente, si continua a installare IBM Installation Manager in adminVM, quindi mantenere aperto questo terminale.

Scaricare e installare IBM Installation Manager

Usare la procedura seguente per scaricare e installare IBM Installation Manager usando il server X in myWindowsVM:

Scaricare IBM Installation Manager usando il curl comando , come illustrato nell'esempio seguente. Salvare il file del programma di installazione in /datadrive/tmp e quindi decomprimere il file in /datadrive/installer.

yum install -y unzip
mkdir /datadrive/tmp
cd /datadrive/tmp
curl -LO https://public.dhe.ibm.com/ibmdl/export/pub/software/im/zips/agent.installer.linux.gtk.x86_64.zip
unzip -o agent.installer.linux.gtk.x86_64.zip -d /datadrive/installer

Prima di aprire il programma di installazione, impostare la DISPLAY variabile , come illustrato nell'esempio seguente. Questa variabile consente l'esecuzione del programma di installazione grafico nella macchina virtuale Red Hat Linux, ma viene visualizzata in myWindowsVM. Il valore della DISPLAY variabile include l'indirizzo IP privato di myWindowsVM.

In questo esempio l'indirizzo IP è 192.168.0.5. Il numero di visualizzazione segue l'indirizzo IP di myWindowsVM. In X Window System il numero di visualizzazione più comune è :0.0.
```
export DISPLAY=<my-windows-VM-private-IP>:0.0
# export DISPLAY=192.168.0.5:0.0
```
Per trovare l'indirizzo IP, seguire questa procedura:
1. Nella portale di Azure selezionare myWindowsVM.
2. Nel riquadro di panoramica, in Proprietà, nella sezione Rete trovare Indirizzo IP privato.
Usare i comandi seguenti per avviare il processo di installazione di IBM Installation Manager:
```
cd /datadrive/installer
./install
```
Dopo un po', viene visualizzato il programma di installazione. Se l'interfaccia utente non viene visualizzata, risolvere il problema prima di procedere. Mantenere le impostazioni predefinite e selezionare Avanti.
Accettare il contratto di licenza selezionando Accetto le condizioni nel contratto di licenza e quindi selezionare Avanti.
Impostare la directory di Installation Manager su /datadrive/IBM/InstallationManager/V1.9 e quindi selezionare Avanti.

Nota

Molti dei passaggi descritti in questa guida richiedono di copiare i valori da questo testo e incollarli direttamente nell'interfaccia utente del programma di installazione. Un errore di digitazione in uno di questi valori può causare un errore completo del processo. È consigliabile aprire un'istanza del Blocco note all'interno della macchina virtuale jump box di Windows e usarla come posizione intermedia per incollare i valori di questa guida. Quindi, all'interno della macchina virtuale, eseguire un'operazione di copia/incolla separata dal Blocco note all'interfaccia utente del programma di installazione. Questa azione riduce al minimo le probabilità che un semplice errore di digitamento causi un errore di guida.
Esaminare le informazioni di riepilogo e quindi selezionare Installa.
Attendere la verifica del completamento dell'installazione senza errori.
Chiudere il programma di installazione. IBM Installation Manager è ora installato nella directory /datadrive/IBM/InstallationManager/V1.9.

Continuare quindi a installare WebSphere Application Server in adminVM, quindi mantenere aperto questo terminale.

Installare la distribuzione di rete del server applicazioni WebSphere tradizionale

WAS ND V9
WAS ND V85

Quando si usa l'immagine di base, WebSphere Application Server Network Deployment è già installato nella directory /datadrive/IBM/WebSphere/ND/V9.

In questa sezione si usa il server X in myWindowsVM per visualizzare il programma di installazione grafico per la distribuzione di rete del server applicazioni WebSphere tradizionale V8.5 in esecuzione in adminVM. Usare la procedura seguente per visualizzare il programma di installazione e installare il server:

Se non si usa il terminale precedente, impostare la DISPLAY variabile eseguendo export DISPLAY=<my-windows-vm-private-ip>:0.0.
Usare i comandi seguenti per avviare il processo per installare WAS:
```
cd /datadrive/IBM/InstallationManager/V1.9/eclipse/
./IBMIM
```
Dopo un po', viene visualizzato il programma di installazione. Se l'interfaccia utente non viene visualizzata, risolvere il problema prima di procedere.
Selezionare Preferenze file>per iniziare a configurare una connessione al repository.
Nel riquadro Repository selezionare Aggiungi repository. Trovare l'URL del repository dal repository di prodotti online delle offerte IBM WebSphere Application Server. Per WebSphere Application Server Network Deployment V8.5, l'URL deve essere https://www.ibm.com/software/repositorymanager/com.ibm.websphere.ND.v85. Compilare l'URL nella casella Repository e quindi selezionare OK.
Dopo un po' di tempo, il riquadro Password obbligatorio chiede di immettere il tuo IBMid. Immettere il nome utente e la password, selezionare Salva password e quindi fare clic su OK.

Nota

L'IBMid deve avere diritto all'esecuzione di WebSphere 8.5.5. Per ottenere questo diritto, contattare IBM eCustomer Care.
La connessione al repository richiede tempo. Se viene visualizzato un errore, assicurarsi che IBMid e la password siano corretti. Assicurarsi anche che l'IBMid abbia diritto ad accedere al repository di prodotti per IBM WebSphere Application Server Network Deployment V8.5.
Al termine della connessione, l'URL del repository del prodotto si trova nell'elenco Repository . Selezionare OK per chiudere il riquadro Preferenze .
Nella pagina di destinazione di IBM Installation Manager selezionare Installa. La preparazione del programma di installazione richiede tempo. Potrebbe essere visualizzato un messaggio simile a Waiting for www-147.ibm.com.
Dopo aver stabilito la connessione, viene visualizzato il riquadro Installa pacchetti . Selezionare la distribuzione di rete IBM WebSphere Application Server di primo livello 8.5.5.x. Il numero di versione esatto può essere diverso, ma deve essere la versione 8.5.5 più recente visualizzata. Assicurarsi di selezionare le caselle di controllo annidate. Quindi seleziona Avanti.
La preparazione del programma di installazione richiede tempo. Potrebbe essere visualizzato un messaggio simile a Waiting for www-147.ibm.com. Se viene richiesto di installare le correzioni, accettare l'installazione delle correzioni consigliate e procedere.
Accettare il contratto di licenza selezionando Accetto le condizioni nel contratto di licenza e quindi selezionare Avanti.
Impostare Directory risorse condivise su /datadrive/IBM/IMShared e quindi selezionare Avanti.
Impostare Directory di installazione su /datadrive/IBM/WebSphere/ND/V85 e quindi selezionare Avanti.
Mantenere Traduzioni con il valore predefinito e selezionare Avanti.
Mantenere il valore predefinito di IBM JDK e selezionare Avanti.
Nella scheda Riepilogo selezionare Installa.
Il processo di installazione dovrebbe terminare senza errori. Per Quale programma si vuole avviare?, selezionare Nessuno. Quindi selezionare Fine.
Se viene visualizzata la casella degli strumenti di personalizzazione di WebSphere, chiuderla. Chiudere IBM Installation Manager.
Tornare alla shell da cui è stato avviato IBM Installation Manager. Verificare il percorso di installazione corretto usando il comando seguente per verificare l'esistenza dello strumento di gestione dei profili:
```
ls -la /datadrive/IBM/WebSphere/ND/V85/bin/ProfileManagement/pmt.sh
```
Se il file non esiste, correggere il problema prima di procedere.

È stata completata l'installazione della distribuzione di rete del server applicazioni WebSphere nella directory /datadrive/IBM/WebSphere/ND/V85.

Creare computer per server gestiti

È stata installata la distribuzione di rete del server applicazioni WebSphere in adminVM, che esegue lo strumento di gestione distribuzione. È comunque necessario preparare i computer per eseguire i due server gestiti. Successivamente, si crea uno snapshot da dischi di adminVM e si preparano i computer per i mspVM1 server gestiti e mspVM2.

Questa sezione presenta un approccio per preparare i computer con lo snapshot di adminVM. Tornare al terminale in cui si è connessi all'interfaccia della riga di comando di Azure e quindi seguire questa procedura. Questo terminale non è il jump box di Windows.

Usare il comando seguente per arrestare adminVM:

Bash
PowerShell

# export RESOURCE_GROUP_NAME=abc1110rg
az vm stop --resource-group $RESOURCE_GROUP_NAME --name adminVM

# $Env:RESOURCE_GROUP_NAME = "abc1110rg"
az vm stop --resource-group $Env:RESOURCE_GROUP_NAME --name adminVM

Usare az snapshot create per creare uno snapshot del disco del adminVM sistema operativo:

Bash
PowerShell

export ADMIN_OS_DISK_ID=$(az vm show \
    --resource-group $RESOURCE_GROUP_NAME \
    --name adminVM \
    --query storageProfile.osDisk.managedDisk.id \
    --output tsv)
az snapshot create \
    --resource-group $RESOURCE_GROUP_NAME \
    --name myAdminOSDiskSnapshot \
    --source $ADMIN_OS_DISK_ID

$Env:ADMIN_OS_DISK_ID=$(az vm show `
    --resource-group $Env:RESOURCE_GROUP_NAME  `
    --name adminVM `
    --query storageProfile.osDisk.managedDisk.id `
    --output tsv)
az snapshot create  `
    --resource-group $Env:RESOURCE_GROUP_NAME  `
    --name myAdminOSDiskSnapshot  `
    --source $Env:ADMIN_OS_DISK_ID

Usare az snapshot create per creare uno snapshot del adminVM disco dati:

Bash
PowerShell

export ADMIN_DATA_DISK_ID=$(az vm show \
    --resource-group $RESOURCE_GROUP_NAME \
    --name adminVM \
    --query 'storageProfile.dataDisks[0].managedDisk.id' \
    --output tsv)
az snapshot create \
    --resource-group $RESOURCE_GROUP_NAME \
    --name myAdminDataDiskSnapshot \
    --source $ADMIN_DATA_DISK_ID

$Env:ADMIN_DATA_DISK_ID=$(az vm show `
    --resource-group $Env:RESOURCE_GROUP_NAME  `
    --name adminVM  `
    --query 'storageProfile.dataDisks[0].managedDisk.id' `
    --output tsv)
az snapshot create  `
    --resource-group $Env:RESOURCE_GROUP_NAME  `
    --name myAdminDataDiskSnapshot `
    --source $Env:ADMIN_DATA_DISK_ID

Usare i comandi seguenti per eseguire query sugli ID snapshot usati in un secondo momento:

Bash
PowerShell

# Get the snapshot ID.
export OS_SNAPSHOT_ID=$(az snapshot show \
    --resource-group $RESOURCE_GROUP_NAME \
    --name myAdminOSDiskSnapshot \
    --query '[id]' \
    --output tsv)
export DATA_SNAPSHOT_ID=$(az snapshot show \
    --resource-group $RESOURCE_GROUP_NAME \
    --name myAdminDataDiskSnapshot \
    --query '[id]' \
    --output tsv)

# Get the snapshot ID.
$Env:OS_SNAPSHOT_ID=$(az snapshot show `
    --resource-group $Env:RESOURCE_GROUP_NAME  `
    --name myAdminOSDiskSnapshot `
    --query '[id]' `
    --output tsv)
$Env:DATA_SNAPSHOT_ID=$(az snapshot show  `
    --resource-group $Env:RESOURCE_GROUP_NAME  `
    --name myAdminDataDiskSnapshot `
    --query '[id]' `
    --output tsv)

mspVM1 Creare quindi e mspVM2.

Creare mspVM1

Usare la procedura seguente per creare mspVM1:

Creare un disco del sistema operativo per mspVM1 usando az disk create:

Bash
PowerShell

# Create a new managed disk by using the OS snapshot ID.
# Note that the managed disk is created in the same location as the snapshot.
az disk create \
    --resource-group $RESOURCE_GROUP_NAME \
    --name mspVM1_OsDisk_1 \
    --source $OS_SNAPSHOT_ID

# Create a new managed disk by using the OS snapshot ID.
# Note that the managed disk is created in the same location as the snapshot.
az disk create `
    --resource-group $Env:RESOURCE_GROUP_NAME  `
    --name mspVM1_OsDisk_1 `
    --source $Env:OS_SNAPSHOT_ID

Usare i comandi seguenti per creare la macchina virtuale collegando il disco mspVM1_OsDisk_1del mspVM1 sistema operativo :

Bash
PowerShell

# Get the resource ID of the managed disk.
export MSPVM1_OS_DISK_ID=$(az disk show \
    --resource-group $RESOURCE_GROUP_NAME \
    --name mspVM1_OsDisk_1 \
    --query '[id]' \
    --output tsv)

# Get the resource ID of the managed disk.
$Env:MSPVM1_OS_DISK_ID=$(az disk show `
    --resource-group $Env:RESOURCE_GROUP_NAME `
    --name mspVM1_OsDisk_1 `
    --query '[id]' `
    --output tsv)

WAS ND V9
WAS ND V85

# Create the VM by attaching the existing managed disk as an OS.
az vm create \
    --resource-group $RESOURCE_GROUP_NAME \
    --name mspVM1 \
    --attach-os-disk $MSPVM1_OS_DISK_ID \
    --plan-publisher ibm-usa-ny-armonk-hq-6275750-ibmcloud-aiops \
    --plan-product 2023-03-27-twas-cluster-base-image \
    --plan-name 2023-03-27-twas-cluster-base-image \
    --os-type linux \
    --availability-set myAvailabilitySet \
    --public-ip-address "" \
    --nsg ""

# Create the VM by attaching the existing managed disk as an OS.
# For `public-ip-address` and `nsg`, be sure to wrap the value "" in '' in PowerShell.
az vm create `
    --resource-group $Env:RESOURCE_GROUP_NAME `
    --name mspVM1 `
    --attach-os-disk $Env:MSPVM1_OS_DISK_ID `
    --plan-publisher ibm-usa-ny-armonk-hq-6275750-ibmcloud-aiops `
    --plan-product 2023-03-27-twas-cluster-base-image `
    --plan-name 2023-03-27-twas-cluster-base-image `
    --os-type linux `
    --availability-set myAvailabilitySet `
    --public-ip-address '""' `
    --nsg '""'

# Create the VM by attaching the existing managed disk as an OS.
az vm create \
    --resource-group $RESOURCE_GROUP_NAME \
    --name mspVM1 \
    --attach-os-disk $MSPVM1_OS_DISK_ID \
    --os-type linux \
    --availability-set myAvailabilitySet \
    --public-ip-address "" \
    --nsg ""

# Create the VM by attaching the existing managed disk as an OS.
# For `public-ip-address` and `nsg`, be sure to wrap the value "" in '' in PowerShell.
az vm create `
    --resource-group $Env:RESOURCE_GROUP_NAME `
    --name mspVM1 `
    --attach-os-disk $Env:MSPVM1_OS_DISK_ID `
    --os-type linux `
    --availability-set myAvailabilitySet `
    --public-ip-address '""' `
    --nsg '""'

Creare un disco gestito dallo snapshot del disco dati e collegarlo a mspVM1:

Bash
PowerShell

az disk create \
    --resource-group $RESOURCE_GROUP_NAME \
    --name mspVM1_Data_Disk_1 \
    --source $DATA_SNAPSHOT_ID

export MSPVM1_DATA_DISK_ID=$(az disk show \
    --resource-group $RESOURCE_GROUP_NAME \
    --name mspVM1_Data_Disk_1 \
    --query '[id]' \
    --output tsv)

az vm disk attach \
    --resource-group $RESOURCE_GROUP_NAME \
    --vm-name mspVM1 \
    --name $MSPVM1_DATA_DISK_ID

az disk create `
    --resource-group $Env:RESOURCE_GROUP_NAME `
    --name mspVM1_Data_Disk_1 `
    --source $Env:DATA_SNAPSHOT_ID

$Env:MSPVM1_DATA_DISK_ID=$(az disk show `
    --resource-group $Env:RESOURCE_GROUP_NAME `
    --name mspVM1_Data_Disk_1 `
    --query '[id]' `
    --output tsv)

az vm disk attach `
    --resource-group $Env:RESOURCE_GROUP_NAME `
    --vm-name mspVM1 `
    --name $Env:MSPVM1_DATA_DISK_ID

mspVM1 Creato con WAS installato. Poiché la macchina virtuale è stata creata da uno snapshot dei adminVM dischi, le due macchine virtuali hanno lo stesso nome host. Usare az vm run-command invoke per modificare il nome host nel valore mspVM1:

Bash
PowerShell

az vm run-command invoke \
    --resource-group $RESOURCE_GROUP_NAME \
    --name mspVM1 \
    --command-id RunShellScript \
    --scripts "sudo hostnamectl set-hostname mspVM1"

az vm run-command invoke `
    --resource-group $Env:RESOURCE_GROUP_NAME `
    --name mspVM1 `
    --command-id RunShellScript `
    --scripts "sudo hostnamectl set-hostname mspVM1"

Al termine del comando, si ottiene un output simile all'esempio seguente:

{
    "value": [
        {
        "code": "ProvisioningState/succeeded",
        "displayStatus": "Provisioning succeeded",
        "level": "Info",
        "message": "Enable succeeded: \n[stdout]\n\n[stderr]\n",
        "time": null
        }
    ]
}

Creare mspVM2

Usare la procedura seguente per creare mspVM2:

Creare un disco del sistema operativo per mspVM2 usando az disk create:

Bash
PowerShell

# Create a new managed disk by using the OS snapshot ID.
# Note that the managed disk is created in the same location as the snapshot.
az disk create \
    --resource-group $RESOURCE_GROUP_NAME \
    --name mspVM2_OsDisk_1 \
    --source $OS_SNAPSHOT_ID

# Create a new managed disk by using the OS snapshot ID.
# Note that the managed disk is created in the same location as the snapshot.
az disk create `
    --resource-group $Env:RESOURCE_GROUP_NAME  `
    --name mspVM2_OsDisk_1 `
    --source $Env:OS_SNAPSHOT_ID

Usare i comandi seguenti per creare la macchina virtuale collegando il disco mspVM2_OsDisk_1del mspVM2 sistema operativo :

Bash
PowerShell

# Get the resource ID of the managed disk.
export MSPVM2_OS_DISK_ID=$(az disk show \
    --resource-group $RESOURCE_GROUP_NAME \
    --name mspVM2_OsDisk_1 \
    --query '[id]' \
    --output tsv)

# Get the resource ID of the managed disk.
$Env:MSPVM2_OS_DISK_ID=$(az disk show `
    --resource-group $Env:RESOURCE_GROUP_NAME `
    --name mspVM2_OsDisk_1 `
    --query '[id]' `
    --output tsv)

WAS ND V9
WAS ND V85

# Create the VM by attaching the existing managed disk as an OS.
az vm create \
    --resource-group $RESOURCE_GROUP_NAME \
    --name mspVM2 \
    --attach-os-disk $MSPVM2_OS_DISK_ID \
    --plan-publisher ibm-usa-ny-armonk-hq-6275750-ibmcloud-aiops \
    --plan-product 2023-03-27-twas-cluster-base-image \
    --plan-name 2023-03-27-twas-cluster-base-image \
    --os-type linux \
    --availability-set myAvailabilitySet \
    --public-ip-address "" \
    --nsg ""

# Create the VM by attaching the existing managed disk as an OS.
# For `public-ip-address` and `nsg`, be sure to wrap the value "" in '' in PowerShell.
az vm create `
    --resource-group $Env:RESOURCE_GROUP_NAME `
    --name mspVM2 `
    --attach-os-disk $Env:MSPVM2_OS_DISK_ID `
    --plan-publisher ibm-usa-ny-armonk-hq-6275750-ibmcloud-aiops `
    --plan-product 2023-03-27-twas-cluster-base-image `
    --plan-name 2023-03-27-twas-cluster-base-image `
    --os-type linux `
    --availability-set myAvailabilitySet `
    --public-ip-address '""' `
    --nsg '""'

# Create the VM by attaching the existing managed disk as an OS.
az vm create \
    --resource-group $RESOURCE_GROUP_NAME \
    --name mspVM2 \
    --attach-os-disk $MSPVM2_OS_DISK_ID \
    --os-type linux \
    --availability-set myAvailabilitySet \
    --public-ip-address "" \
    --nsg ""

# Create the VM by attaching the existing managed disk as an OS.
# For `public-ip-address` and `nsg`, be sure to wrap the value "" in '' in PowerShell.
az vm create `
    --resource-group $Env:RESOURCE_GROUP_NAME `
    --name mspVM2 `
    --attach-os-disk $Env:MSPVM2_OS_DISK_ID `
    --os-type linux `
    --availability-set myAvailabilitySet `
    --public-ip-address '""' `
    --nsg '""'

Creare un disco gestito dallo snapshot dei dati e collegarlo a mspVM2:

Bash
PowerShell

az disk create \
    --resource-group $RESOURCE_GROUP_NAME \
    --name mspVM2_Data_Disk_1 \
    --source $DATA_SNAPSHOT_ID

export MSPVM2_DATA_DISK_ID=$(az disk show \
    --resource-group $RESOURCE_GROUP_NAME \
    --name mspVM2_Data_Disk_1 \
    --query '[id]' \
    --output tsv)

az vm disk attach \
    --resource-group $RESOURCE_GROUP_NAME \
    --vm-name mspVM2 \
    --name $MSPVM2_DATA_DISK_ID

az disk create `
    --resource-group $Env:RESOURCE_GROUP_NAME `
    --name mspVM2_Data_Disk_1 `
    --source $Env:DATA_SNAPSHOT_ID

$Env:MSPVM2_DATA_DISK_ID=$(az disk show `
    --resource-group $Env:RESOURCE_GROUP_NAME `
    --name mspVM2_Data_Disk_1 `
    --query '[id]' `
    --output tsv)

az vm disk attach `
    --resource-group $Env:RESOURCE_GROUP_NAME `
    --vm-name mspVM2 `
    --name $Env:MSPVM2_DATA_DISK_ID

mspVM2 Creato con WAS installato. Poiché la macchina virtuale è stata creata da uno snapshot dei adminVM dischi, le due macchine virtuali hanno lo stesso nome host. Usare az vm run-command invoke per modificare il nome host nel valore mspVM2:

Bash
PowerShell

az vm run-command invoke \
    --resource-group $RESOURCE_GROUP_NAME \
    --name mspVM2 \
    --command-id RunShellScript \
    --scripts "sudo hostnamectl set-hostname mspVM2"

az vm run-command invoke `
    --resource-group $Env:RESOURCE_GROUP_NAME `
    --name mspVM2 `
    --command-id RunShellScript `
    --scripts "sudo hostnamectl set-hostname mspVM2"

Al termine del comando, si ottiene un output simile all'esempio seguente:

{
    "value": [
        {
        "code": "ProvisioningState/succeeded",
        "displayStatus": "Provisioning succeeded",
        "level": "Info",
        "message": "Enable succeeded: \n[stdout]\n\n[stderr]\n",
        "time": null
        }
    ]
}

Assicurarsi di aver completato i passaggi precedenti sia per che mspVM2per mspVM1 . Usare quindi i passaggi seguenti per completare la preparazione dei computer:

Usare il comando az vm start per avviare adminVM, come illustrato nell'esempio seguente:

Bash
PowerShell

az vm start --resource-group $RESOURCE_GROUP_NAME --name adminVM

az vm start --resource-group $Env:RESOURCE_GROUP_NAME --name adminVM

Usare i comandi seguenti per ottenere e visualizzare gli indirizzi IP privati, usati nelle sezioni successive:

Bash
PowerShell

export ADMINVM_NIC_ID=$(az vm show \
    --resource-group $RESOURCE_GROUP_NAME \
    --name adminVM \
    --query networkProfile.networkInterfaces'[0]'.id \
    --output tsv)
export ADMINVM_IP=$(az network nic show \
    --ids $ADMINVM_NIC_ID \
    --query ipConfigurations'[0]'.privateIPAddress \
    --output tsv)
export MSPVM1_NIC_ID=$(az vm show \
    --resource-group $RESOURCE_GROUP_NAME \
    --name mspVM1 \
    --query networkProfile.networkInterfaces'[0]'.id \
    --output tsv)
export MSPVM1_IP=$(az network nic show \
    --ids $MSPVM1_NIC_ID \
    --query ipConfigurations'[0]'.privateIPAddress \
    --output tsv)
export MSPVM2_NIC_ID=$(az vm show \
    --resource-group $RESOURCE_GROUP_NAME \
    --name mspVM2 \
    --query networkProfile.networkInterfaces'[0]'.id \
    --output tsv)
export MSPVM2_IP=$(az network nic show \
    --ids $MSPVM2_NIC_ID \
    --query ipConfigurations'[0]'.privateIPAddress \
    --output tsv)
echo "Private IP of adminVM: $ADMINVM_IP"
echo "Private IP of mspVM1: $MSPVM1_IP"
echo "Private IP of mspVM2: $MSPVM2_IP"

$Env:ADMINVM_NIC_ID=$(az vm show `
    --resource-group $Env:RESOURCE_GROUP_NAME `
    --name adminVM `
    --query networkProfile.networkInterfaces'[0]'.id `
    --output tsv)
$Env:ADMINVM_IP=$(az network nic show `
    --ids $Env:ADMINVM_NIC_ID `
    --query ipConfigurations'[0]'.privateIPAddress `
    --output tsv)
$Env:MSPVM1_NIC_ID=$(az vm show `
    --resource-group $Env:RESOURCE_GROUP_NAME `
    --name mspVM1 `
    --query networkProfile.networkInterfaces'[0]'.id `
    --output tsv)
$Env:MSPVM1_IP=$(az network nic show `
    --ids $Env:MSPVM1_NIC_ID `
    --query ipConfigurations'[0]'.privateIPAddress `
    --output tsv)
$Env:MSPVM2_NIC_ID=$(az vm show `
    --resource-group $Env:RESOURCE_GROUP_NAME `
    --name mspVM2 \
    --query networkProfile.networkInterfaces'[0]'.id `
    --output tsv)
$Env:MSPVM2_IP=$(az network nic show `
    --ids $Env:MSPVM2_NIC_ID `
    --query ipConfigurations'[0]'.privateIPAddress `
    --output tsv)
echo "Private IP of adminVM: $Env:ADMINVM_IP"
echo "Private IP of mspVM1: $Env:MSPVM1_IP"
echo "Private IP of mspVM2: $Env:MSPVM2_IP"

Ora, tutti e tre i computer sono pronti. Successivamente, si configura un cluster WAS.

Creare profili WAS e un cluster

Questa sezione illustra come creare e configurare un cluster WAS. In termini di creazione di profili WAS e cluster, non esiste alcuna differenza significativa tra la serie 9.x e la serie 8.5.x. Tutti gli screenshot di questa sezione mostrano V9 come base.

Configurare un profilo di Deployment Manager

In questa sezione si usa il server X in myWindowsVM per creare un profilo di gestione per lo strumento di gestione della distribuzione per amministrare i server all'interno della cella di Deployment Manager usando lo Strumento di gestione profili. Per altre informazioni sui profili, vedere Concetti relativi ai profili. Per altre informazioni sulla creazione del profilo di Deployment Manager, vedere Creazione di profili di gestione con i responsabili della distribuzione.

Usare la procedura seguente per creare e configurare il profilo di gestione:

Assicurarsi di essere ancora nel computer Windows. In caso contrario, usare i comandi seguenti per connettersi in remoto a myWindowsVMe quindi connettersi a adminVM da un prompt dei comandi:
```
set ADMINVM_IP="192.168.0.4"
ssh azureuser@%ADMINVM_IP%
```

Usare i comandi seguenti per diventare l'utente root e impostare la DISPLAY variabile:

sudo su -

export DISPLAY=<my-windows-vm-private-ip>:0.0
# export DISPLAY=192.168.0.5:0.0

Usare i comandi seguenti per avviare lo strumento di gestione dei profili:

WAS ND V9
WAS ND V85

cd /datadrive/IBM/WebSphere/ND/V9/bin/ProfileManagement
./pmt.sh

cd /datadrive/IBM/WebSphere/ND/V85/bin/ProfileManagement
./pmt.sh

Dopo un po', viene visualizzato lo strumento di gestione dei profili. Se l'interfaccia utente non viene visualizzata, controllare dietro il prompt dei comandi. Seleziona Crea.
Nel riquadro Selezione ambiente selezionare Gestione e quindi avanti.
Nel riquadro Selezione tipo di server selezionare Gestione distribuzione e quindi selezionare Avanti.
Nel riquadro Opzioni di creazione profilo selezionare Creazione avanzata profilo e quindi selezionare Avanti.
Nel riquadro Distribuzione applicazione facoltativa verificare che l'opzione Distribuisci la console di amministrazione (scelta consigliata) sia selezionata e quindi selezionare Avanti.
Nel riquadro Nome profilo e Posizione immettere il nome e la posizione del profilo. In questo esempio il nome del profilo è Dmgr01. La posizione dipende dalla versione WAS:
- In WAS V9, il percorso è /datadrive/IBM/WebSphere/ND/V9/profiles/Dmgr01.
- In WAS V8.5, il percorso è /datadrive/IBM/WebSphere/ND/V85/profiles/Dmgr01.
Al termine selezionare Avanti.
Nel riquadro Node, Host e Cell Names (Nomi nodo), Host (Host) e Cell Names (Nomi cella) immettere il nome del nodo, il nome host e il nome della cella. L'host è l'indirizzo IP privato di adminVM. In questo esempio il nome del nodo è adminvmCellManager01, il valore host è 192.168.0.4e il nome della cella è adminvmCell01. Al termine selezionare Avanti.
Nel riquadro Sicurezza amministrativa immettere il nome utente e la password dell'amministratore. In questo esempio il nome utente è webspheree la password è Secret123456. Prendere nota del nome utente e della password in modo da poterli usare per accedere alla console IBM. Al termine selezionare Avanti.
Per il certificato di sicurezza (parte 1), immettere il certificato, se disponibile. In questo esempio viene usato il certificato autofirmato predefinito. Quindi seleziona Avanti.
Per il certificato di sicurezza (parte 2), immettere il certificato, se disponibile. In questo esempio viene usato il certificato autofirmato predefinito. Quindi seleziona Avanti.
Nel riquadro Assegnazione valori porta mantenere le porte predefinite e selezionare Avanti.
Nel riquadro Definizione servizio Linux non selezionare Esegui il processo di gestione distribuzione come servizio Linux. Successivamente, si crea il servizio Linux. Selezionare Avanti.
Nel riquadro Riepilogo creazione profilo verificare che le informazioni siano corrette e quindi selezionare Crea.
Per completare la creazione del profilo sono necessari alcuni minuti. Quando viene visualizzato il riquadro Completamento creazione profilo, selezionare Avvia la console Primi passaggi. Quindi selezionare Fine.
Viene visualizzata la console Primi passaggi . Selezionare Verifica installazione.
Viene avviato il processo di verifica e viene visualizzato un output simile all'esempio seguente. In caso di errori, è necessario risolverli prima di procedere.
Viene avviato il processo di gestione della distribuzione. È possibile chiudere la console Primi passaggi chiudendo il riquadro di output e selezionando Esci dalla console.

La creazione del profilo è stata completata. È possibile chiudere la casella degli strumenti di personalizzazione di WebSphere.

Per accedere alla console IBM, aprire le porte del firewall usando i comandi seguenti:

firewall-cmd --zone=public --add-port=9060/tcp --permanent
firewall-cmd --zone=public --add-port=9043/tcp --permanent
firewall-cmd --zone=public --add-port=9809/tcp --permanent
firewall-cmd --zone=public --add-port=7277/tcp --permanent
firewall-cmd --zone=public --add-port=9402/tcp --permanent
firewall-cmd --zone=public --add-port=9403/tcp --permanent
firewall-cmd --zone=public --add-port=9352/tcp --permanent
firewall-cmd --zone=public --add-port=9632/tcp --permanent
firewall-cmd --zone=public --add-port=9100/tcp --permanent
firewall-cmd --zone=public --add-port=9401/tcp --permanent
firewall-cmd --zone=public --add-port=8879/tcp --permanent
firewall-cmd --zone=public --add-port=5555/tcp --permanent
firewall-cmd --zone=public --add-port=7060/tcp --permanent
firewall-cmd --zone=public --add-port=11005/udp --permanent
firewall-cmd --zone=public --add-port=11006/tcp --permanent
firewall-cmd --zone=public --add-port=9420/tcp --permanent

firewall-cmd --reload

Per avviare automaticamente deployment manager all'avvio, creare un servizio Linux per il processo. Eseguire i comandi seguenti per creare un servizio Linux:

WAS ND V9
WAS ND V85

export PROFILE_PATH=/datadrive/IBM/WebSphere/ND/V9/profiles/Dmgr01

# Configure SELinux so systemctl has access on server start/stop script files.
semanage fcontext -a -t bin_t "${PROFILE_PATH}/bin(/.*)?"
restorecon -r -v ${PROFILE_PATH}/bin

# Add service.
${PROFILE_PATH}/bin/wasservice.sh -add adminvmCellManager01 -servername dmgr -profilePath ${PROFILE_PATH}

export PROFILE_PATH=/datadrive/IBM/WebSphere/ND/V85/profiles/Dmgr01

# Configure SELinux so systemctl has access on server start/stop script files.
semanage fcontext -a -t bin_t "${PROFILE_PATH}/bin(/.*)?"
restorecon -r -v ${PROFILE_PATH}/bin

# Add service.
${PROFILE_PATH}/bin/wasservice.sh -add adminvmCellManager01 -servername dmgr -profilePath ${PROFILE_PATH}

Verificare che venga visualizzato l'output seguente:
```
CWSFU0013I: Service [adminvmCellManager01] added successfully.
```
Se l'output non viene visualizzato, risolvere e risolvere il problema prima di continuare.

Il gestore di distribuzione è in esecuzione in adminVM. Dalla macchina virtuale Windows jump box è possibile accedere alla console IBM all'URL http://<admin-vm-private-ip>:9060/ibm/console/.

Configurare profili personalizzati

In questa sezione si usa il server X in myWindowsVM per creare profili personalizzati per i server mspVM1 gestiti e mspVM2.

Assicurarsi di essere ancora nel computer Windows. In caso contrario, connettersi in remoto a myWindowsVM.

Configurare il profilo personalizzato per mspVM1

Usare la procedura seguente per configurare un profilo personalizzato per mspVM1:

Usare i comandi seguenti per connettersi a mspVM1 da un prompt dei comandi:
```
set MSPVM1VM_IP="192.168.0.6"
ssh azureuser@%MSPVM1VM_IP%
```

Usare i comandi seguenti per diventare l'utente root e impostare la DISPLAY variabile:

sudo su -

export DISPLAY=<my-windows-vm-private-ip>:0.0
# export DISPLAY=192.168.0.5:0.0

Per accedere a Deployment Manager in adminVM, aprire le porte del firewall usando i comandi seguenti:

firewall-cmd --zone=public --add-port=9080/tcp --permanent
firewall-cmd --zone=public --add-port=9443/tcp --permanent
firewall-cmd --zone=public --add-port=2809/tcp --permanent
firewall-cmd --zone=public --add-port=9405/tcp --permanent
firewall-cmd --zone=public --add-port=9406/tcp --permanent
firewall-cmd --zone=public --add-port=9353/tcp --permanent
firewall-cmd --zone=public --add-port=9633/tcp --permanent
firewall-cmd --zone=public --add-port=5558/tcp --permanent
firewall-cmd --zone=public --add-port=5578/tcp --permanent
firewall-cmd --zone=public --add-port=9100/tcp --permanent
firewall-cmd --zone=public --add-port=9404/tcp --permanent
firewall-cmd --zone=public --add-port=7276/tcp --permanent
firewall-cmd --zone=public --add-port=7286/tcp --permanent
firewall-cmd --zone=public --add-port=5060/tcp --permanent
firewall-cmd --zone=public --add-port=5061/tcp --permanent
firewall-cmd --zone=public --add-port=8880/tcp --permanent
firewall-cmd --zone=public --add-port=11003/udp --permanent
firewall-cmd --zone=public --add-port=11004/tcp --permanent
firewall-cmd --zone=public --add-port=2810/tcp --permanent
firewall-cmd --zone=public --add-port=9201/tcp --permanent
firewall-cmd --zone=public --add-port=9202/tcp --permanent
firewall-cmd --zone=public --add-port=9354/tcp --permanent
firewall-cmd --zone=public --add-port=9626/tcp --permanent
firewall-cmd --zone=public --add-port=9629/tcp --permanent
firewall-cmd --zone=public --add-port=7272/tcp --permanent
firewall-cmd --zone=public --add-port=5001/tcp --permanent
firewall-cmd --zone=public --add-port=5000/tcp --permanent
firewall-cmd --zone=public --add-port=9900/tcp --permanent
firewall-cmd --zone=public --add-port=9901/tcp --permanent
firewall-cmd --zone=public --add-port=8878/tcp --permanent
firewall-cmd --zone=public --add-port=7061/tcp --permanent
firewall-cmd --zone=public --add-port=7062/tcp --permanent
firewall-cmd --zone=public --add-port=11001/udp --permanent
firewall-cmd --zone=public --add-port=11002/tcp --permanent
firewall-cmd --zone=public --add-port=9809/tcp --permanent
firewall-cmd --zone=public --add-port=9402/tcp --permanent
firewall-cmd --zone=public --add-port=9403/tcp --permanent
firewall-cmd --zone=public --add-port=9352/tcp --permanent
firewall-cmd --zone=public --add-port=9632/tcp --permanent
firewall-cmd --zone=public --add-port=9401/tcp --permanent
firewall-cmd --zone=public --add-port=11005/udp --permanent
firewall-cmd --zone=public --add-port=11006/tcp --permanent
firewall-cmd --zone=public --add-port=8879/tcp --permanent
firewall-cmd --zone=public --add-port=9060/tcp --permanent
firewall-cmd --zone=public --add-port=9043/tcp --permanent

firewall-cmd --reload

Usare i comandi seguenti per avviare lo strumento di gestione dei profili:

WAS ND V9
WAS ND V85

cd /datadrive/IBM/WebSphere/ND/V9/bin/ProfileManagement
./pmt.sh

cd /datadrive/IBM/WebSphere/ND/V85/bin/ProfileManagement
./pmt.sh

Dopo un po', viene visualizzato lo strumento di gestione dei profili. Se l'interfaccia utente non viene visualizzata, risolvere e risolvere il problema prima di continuare. Seleziona Crea.
Nel riquadro Selezione ambiente selezionare Profilo personalizzato e quindi avanti.
Nel riquadro Opzioni di creazione profilo selezionare Creazione avanzata profilo e quindi selezionare Avanti.
Nel riquadro Nome profilo e Posizione immettere il nome e la posizione del profilo. In questo esempio il nome del profilo è Custom01. La posizione dipende dalla versione WAS:
- In WAS V9 il percorso è /datadrive/IBM/WebSphere/ND/V9/profiles/Custom01.
- In WAS V8.5, il percorso è /datadrive/IBM/WebSphere/ND/V85/profiles/Custom01.
Al termine selezionare Avanti.
Nel riquadro Nodi e nomi host immettere il nome e l'host del nodo. Il valore dell'host è l'indirizzo IP privato di mspVM1. In questo esempio l'host è 192.168.0.6 e il nome del nodo è mspvm1Node01. Al termine selezionare Avanti.
Nel riquadro Federazione immettere il nome host e l'autenticazione del gestore di distribuzione. Per Nome host o indirizzo IP di Deployment Manager, il valore è l'indirizzo IP privato di adminVM, che è 192.168.0.4 qui. Per l'autenticazione di Deployment Manager, in questo esempio il nome utente è websphere e la password è Secret123456. Al termine selezionare Avanti.
Per il certificato di sicurezza (parte 1), immettere il certificato, se disponibile. In questo esempio viene usato il certificato autofirmato predefinito. Quindi seleziona Avanti.
Per il certificato di sicurezza (parte 2), immettere il certificato, se disponibile. In questo esempio viene usato il certificato autofirmato predefinito. Quindi seleziona Avanti.
Nel riquadro Assegnazione valori porta mantenere le porte predefinite e selezionare Avanti.
Nel riquadro Riepilogo creazione profilo verificare che le informazioni siano corrette e quindi selezionare Crea.
La creazione del profilo personalizzato richiede tempo. Nel riquadro Creazione profilo completata deselezionare la casella di controllo Avvia la console Dei primi passaggi. Selezionare quindi Fine per completare la creazione del profilo e chiudere lo strumento di gestione dei profili.

Per avviare automaticamente il server all'avvio, creare un servizio Linux per il processo. I comandi seguenti creano un servizio Linux per avviare nodeagent:

WAS ND V9
WAS ND V85

export PROFILE_PATH=/datadrive/IBM/WebSphere/ND/V9/profiles/Custom01

# Configure SELinux so systemctl has access on server start/stop script files.
semanage fcontext -a -t bin_t "${PROFILE_PATH}/bin(/.*)?"
restorecon -r -v ${PROFILE_PATH}/bin

# Add service to start nodeagent.
${PROFILE_PATH}/bin/wasservice.sh -add mspvm1Node01 -servername nodeagent -profilePath ${PROFILE_PATH}

export PROFILE_PATH=/datadrive/IBM/WebSphere/ND/V85/profiles/Custom01

# Configure SELinux so systemctl has access on server start/stop script files.
semanage fcontext -a -t bin_t "${PROFILE_PATH}/bin(/.*)?"
restorecon -r -v ${PROFILE_PATH}/bin

# Add service to start nodeagent.
${PROFILE_PATH}/bin/wasservice.sh -add mspvm1Node01 -servername nodeagent -profilePath ${PROFILE_PATH}

Verificare che venga visualizzato l'output seguente:
```
CWSFU0013I: Service [mspvm1Node01] added successfully.
```
Se l'output non viene visualizzato, risolvere e risolvere il problema prima di continuare.

È stato creato un profilo personalizzato ed nodeagent è in esecuzione in mspVM1. Interrompere l'uso dell'utente root e chiudere la connessione SSH a mspVM1.

Configurare il profilo personalizzato per mspVM2

Tornare all'inizio della sezione Configurare il profilo personalizzato per mspVM1 ed eseguire gli stessi passaggi per mspVM2. Ovvero, ovunque sia stato usato mspVM1 o simile, eseguire la stessa operazione per mspVM2.

Nel riquadro Node and Host Names (Nomi nodo e host) immettere mspvm2Node01 per Node name (Nome nodo) e 192.168.0.7 per Host name (Nome host).

È stato preparato il profilo personalizzato per due server gestiti: mspVM1 e mspVM2. Continuare con la creazione di un cluster WAS.

Creare un cluster e avviare server

In questa sezione si usa la console IBM per creare un cluster WAS e avviare i server gestiti usando il browser in myWindowsVM. Assicurarsi di essere ancora nel computer Windows. In caso contrario, connettersi in remoto a myWindowsVM. Seguire quindi questa procedura:

Aprire il browser Microsoft Edge e passare a http://<adminvm-private-ip>:9060/ibm/console/. In questo esempio l'URL della console IBM è http://192.168.0.4:9060/ibm/console/. Trovare il riquadro di accesso. Accedere alla console IBM usando il nome utente e la password amministrativi (websphere/Secret123456). È ora possibile amministrare cluster e server.
Nel riquadro di spostamento selezionare Server Clusters WebSphere application server clusters> (Cluster>server applicazioni WebSphere). Selezionare quindi Nuovo per creare un nuovo cluster.
Nella finestra di dialogo Crea un nuovo cluster immettere il nome del cluster nel passaggio 1: Immettere le informazioni di base sul cluster. In questo esempio il nome del cluster è cluster1. Al termine selezionare Avanti.
Per Passaggio 2: Creare il primo membro del cluster, immettere il nome del membro e selezionare il nodo mspvm1Node01. In questo esempio il nome del membro è msp1. Il nodo dipende dalla versione WAS:
- In WAS V9 il nodo è mspvm1Node01 (ND 9.0.5.12).
- In WAS V8.5 il nodo è mspvm1Node01 (ND 8.5.5.24).
Al termine selezionare Avanti.
Per Passaggio 3: Creare membri del cluster aggiuntivi, immettere il secondo nome del membro e selezionare node mspvm2Node01. In questo esempio il nome del membro è msp2. Il nodo dipende dalla versione WAS:
- In WAS V9 il nodo è mspvm2Node01 (ND 9.0.5.12).
- In WAS V8.5 il nodo è mspvm2Node01 (ND 8.5.5.24).
Selezionare Aggiungi membro per aggiungere il secondo nodo. La tabella elenca due membri. Al termine selezionare Avanti.
Per Passaggio 4: Riepilogo, selezionare Fine.

La creazione del cluster richiede tempo. Dopo aver creato il cluster, cluster1 viene visualizzato nella tabella .
Selezionare cluster1 e quindi selezionare Rivedi per esaminare le informazioni.
Selezionare Synchronize changes with Nodes (Sincronizza modifiche con nodi) e quindi selezionare Save ( Salva).
La creazione dovrebbe terminare senza errori. Seleziona OK per continuare.
Selezionare cluster1 nella tabella e quindi selezionare il pulsante Start per avviare il cluster.
L'avvio dei due server gestiti richiede tempo. Nella colonna Stato selezionare l'icona di aggiornamento (due frecce che puntano l'una all'altra) per aggiornare lo stato.

Passare il puntatore del mouse sull'icona di aggiornamento. Quando la descrizione comando mostra Avviato, è possibile considerare attendibile il formato del cluster. Continuare ad aggiornare periodicamente e controllare fino a quando non viene visualizzata la descrizione comando Avviata.
Seguire questa procedura per configurare le impostazioni dei criteri di monitoraggio del server applicazioni per avviare automaticamente il server gestito dopo l'avvio dell'agente node.

Usare la procedura seguente per configurare msp1:
1. Nel riquadro di spostamento selezionare Server, tipi di server e quindi server applicazioni WebSphere.
2. Selezionare il collegamento ipertestuale per il server msp1applicazioni .
3. Nella sezione Infrastruttura server selezionare Java e gestione dei processi.
4. Selezionare Criteri di monitoraggio.
5. Assicurarsi che l'opzione Riavvio automatico sia selezionata e quindi selezionare RUNNING come stato di riavvio del nodo. Seleziona OK.
6. Tornare al riquadro Servizi middleware. Nel pannello Messaggi selezionare il collegamento Rivedi e quindi selezionare Sincronizza modifiche con nodi. Selezionare Salva per salvare e sincronizzare le modifiche.
7. Viene visualizzato il messaggio seguente: The configuration synchronization complete for cell. selezionare OK per uscire dalla configurazione.
Usare la procedura seguente per configurare msp2:
1. Nel riquadro di spostamento selezionare Server, tipi di server e quindi server applicazioni WebSphere.
2. Selezionare il collegamento ipertestuale per il server msp2applicazioni .
3. Nella sezione Infrastruttura server selezionare Java e gestione dei processi.
4. Selezionare Criteri di monitoraggio.
5. Assicurarsi che l'opzione Riavvio automatico sia selezionata e quindi selezionare RUNNING come stato di riavvio del nodo. Seleziona OK.
6. Tornare al riquadro Servizi middleware. Nel pannello Messaggi selezionare il collegamento Rivedi e quindi selezionare Sincronizza modifiche con nodi. Selezionare Salva per salvare e sincronizzare le modifiche.
7. Viene visualizzato il messaggio seguente: The configuration synchronization complete for cell. selezionare OK per uscire dalla configurazione.

È stato configurato cluster1 con due server gestiti e msp2msp1 . Il cluster è operativo.

Distribuire un'applicazione

Usare la procedura seguente per distribuire l'applicazione:

Nella console di amministrazione in cui è stato eseguito l'accesso in precedenza selezionare Applicazioni>nuova applicazione e quindi nuova applicazione aziendale.
Nel pannello successivo selezionare File system remoto e quindi selezionare Sfoglia per esplorare i file system dei server installati.
Selezionare il sistema che inizia con adminvm. Viene visualizzato il file system della macchina virtuale. Da qui selezionare V9 (o V85) e quindi installableApps.
Nell'elenco delle applicazioni disponibili per l'installazione selezionare DefaultApplication.ear. Quindi, selezionare OK.
Si torna al pannello per selezionare l'applicazione. Selezionare Avanti.
Selezionare Avanti per tutti i passaggi rimanenti nel flusso di lavoro Installa nuova applicazione . Quindi selezionare Fine.
Verrà visualizzato il messaggio seguente: Application DefaultApplication.ear installed successfully. se questo messaggio non viene visualizzato, risolvere e risolvere il problema prima di continuare.
Selezionare il collegamento Salva direttamente nel collegamento di configurazione master.
È necessario avviare l'applicazione. Passare ad Applicazioni>tutte le applicazioni. Selezionare la casella di controllo DefaultApplication.ear, assicurarsi che Action (Azione) sia impostata su Start e quindi selezionare Submit Action (Invia azione).
Nella colonna Stato della tabella Tutte le applicazioni selezionare l'icona di aggiornamento. Dopo alcune volte l'aggiornamento della tabella in questo modo, viene visualizzata una freccia verde nella colonna Stato per DefaultApplication.ear.

L'applicazione è ora installata nel cluster WAS.

Esporre WAS usando app Azure lication Gateway

Dopo aver creato il cluster WAS in macchine virtuali GNU/Linux, questa sezione illustra il processo di esposizione di WAS a Internet usando app Azure lication Gateway.

Creare il gateway applicazione

Usare la procedura seguente per creare il gateway applicazione:

Per esporre WAS a Internet, è necessario un indirizzo IP pubblico. Nella shell con l'interfaccia della riga di comando di Azure installata creare l'indirizzo IP usando az network public-ip create, come illustrato nell'esempio seguente:

Bash
PowerShell

az network public-ip create \
    --resource-group $RESOURCE_GROUP_NAME \
    --name myAGPublicIPAddress \
    --allocation-method Static \
    --sku Standard

export APPGATEWAY_IP=$(az network public-ip show \
    --resource-group $RESOURCE_GROUP_NAME \
    --name myAGPublicIPAddress \
    --query '[ipAddress]' \
    --output tsv)

az network public-ip create `
    --resource-group $Env:RESOURCE_GROUP_NAME `
    --name myAGPublicIPAddress `
    --allocation-method Static  `
    --sku Standard

$Env:APPGATEWAY_IP=$(az network public-ip show  `
    --resource-group $Env:RESOURCE_GROUP_NAME  `
    --name myAGPublicIPAddress `
    --query '[ipAddress]' `
    --output tsv)

Creare il gateway applicazione da associare all'indirizzo IP. L'esempio seguente crea un gateway applicazione con i server gestiti WebSphere nel pool back-end predefinito:

Bash
PowerShell

az network application-gateway create \
    --resource-group $RESOURCE_GROUP_NAME \
    --name myAppGateway \
    --public-ip-address myAGPublicIPAddress \
    --location eastus \
    --capacity 2 \
    --http-settings-port 80 \
    --http-settings-protocol Http \
    --frontend-port 80 \
    --sku Standard_V2 \
    --subnet wasGateway \
    --vnet-name myVNet \
    --priority 1001 \
    --servers ${MSPVM1_IP} ${MSPVM2_IP}

az network application-gateway create  `
    --resource-group $Env:RESOURCE_GROUP_NAME  `
    --name myAppGateway `
    --public-ip-address myAGPublicIPAddress `
    --location eastus `
    --capacity 2 `
    --http-settings-port 80 `
    --http-settings-protocol Http `
    --frontend-port 80 `
    --sku Standard_V2 `
    --subnet wasGateway `
    --vnet-name myVNet `
    --priority 1001 `
    --servers $Env:MSPVM1_IP $Env:MSPVM2_IP

I server gestiti espongono i carichi di lavoro con la porta 9080. Usare i comandi seguenti per aggiornare appGatewayBackendHttpSettings specificando la porta back-end e creando un probe per tale porta 9080 :

Bash
PowerShell

az network application-gateway probe create \
    --resource-group $RESOURCE_GROUP_NAME \
    --gateway-name myAppGateway \
    --name clusterProbe \
    --protocol http \
    --host-name-from-http-settings true \
    --match-status-codes 404 \
    --path "/"

az network application-gateway http-settings update \
    --resource-group $RESOURCE_GROUP_NAME \
    --gateway-name myAppGateway \
    --name appGatewayBackendHttpSettings \
    --host-name-from-backend-pool true \
    --port 9080 \
    --probe clusterProbe

az network application-gateway probe create  `
    --resource-group $Env:RESOURCE_GROUP_NAME  `
    --gateway-name myAppGateway  `
    --name clusterProbe `
    --protocol http `
    --host-name-from-http-settings true `
    --match-status-codes 404 `
    --path "/"

az network application-gateway http-settings update `
    --resource-group $Env:RESOURCE_GROUP_NAME  `
    --gateway-name myAppGateway `
    --name appGatewayBackendHttpSettings `
    --host-name-from-backend-pool true `
    --port 9080 `
    --probe clusterProbe

Usare i comandi seguenti per effettuare il provisioning di una regola di riscrittura per i reindirizzamenti:

Bash
PowerShell

# Create a rewrite rule set.
az network application-gateway rewrite-rule set create \
    --resource-group $RESOURCE_GROUP_NAME \
    --gateway-name myAppGateway \
    --name myRewriteRuleSet

# Associated routing rules.
az network application-gateway rule update \
    --resource-group $RESOURCE_GROUP_NAME \
    --gateway-name myAppGateway \
    --name rule1 \
    --rewrite-rule-set myRewriteRuleSet

# Create a rewrite rule 1.
az network application-gateway rewrite-rule create \
    --resource-group $RESOURCE_GROUP_NAME \
    --gateway-name myAppGateway \
    --rule-set-name myRewriteRuleSet \
    --name myRewriteRule01 \
    --sequence 100 \
    --response-headers Location=http://${APPGATEWAY_IP}{http_resp_Location_2}

# Create a rewrite rule condition.
az network application-gateway rewrite-rule condition create \
    --resource-group $RESOURCE_GROUP_NAME \
    --gateway-name myAppGateway \
    --rule-name myRewriteRule01 \
    --rule-set-name myRewriteRuleSet \
    --variable "http_resp_Location" \
    --ignore-case true \
    --negate false \
    --pattern "(https?):\/\/192.168.0.6:9080(.*)$"

# Create a rewrite rule 2.
az network application-gateway rewrite-rule create \
    --resource-group $RESOURCE_GROUP_NAME \
    --gateway-name myAppGateway \
    --rule-set-name myRewriteRuleSet \
    --name myRewriteRule02 \
    --sequence 100 \
    --response-headers Location=http://${APPGATEWAY_IP}{http_resp_Location_2}

# Create a rewrite rule condition.
az network application-gateway rewrite-rule condition create \
    --resource-group $RESOURCE_GROUP_NAME \
    --gateway-name myAppGateway \
    --rule-name myRewriteRule02 \
    --rule-set-name myRewriteRuleSet \
    --variable "http_resp_Location" \
    --ignore-case true \
    --negate false \
    --pattern "(https?):\/\/192.168.0.7:9080(.*)$"

# Create a rewrite rule set.
az network application-gateway rewrite-rule set create `
    --resource-group $Env:RESOURCE_GROUP_NAME  `
    --gateway-name myAppGateway `
    --name myRewriteRuleSet

# Associated routing rules.
az network application-gateway rule update `
    --resource-group $Env:RESOURCE_GROUP_NAME  `
    --gateway-name myAppGateway `
    --name rule1 `
    --rewrite-rule-set myRewriteRuleSet

# Create a rewrite rule 1.
az network application-gateway rewrite-rule create `
    --resource-group $Env:RESOURCE_GROUP_NAME  `
    --gateway-name myAppGateway `
    --rule-set-name myRewriteRuleSet `
    --name myRewriteRule01 `
    --sequence 100 `
    --response-headers Location="http://${Env:APPGATEWAY_IP}{http_resp_Location_2}"

# Create a rewrite rule condition.
az network application-gateway rewrite-rule condition create `
    --resource-group $Env:RESOURCE_GROUP_NAME  `
    --gateway-name myAppGateway `
    --rule-name myRewriteRule01 `
    --rule-set-name myRewriteRuleSet `
    --variable "http_resp_Location" `
    --ignore-case true `
    --negate false `
    --pattern '"(https?):\/\/192.168.0.6:9080(.*)$"'
    # Be sure to wrap the "" in ''

# Create a rewrite rule 2.
az network application-gateway rewrite-rule create `
    --resource-group $Env:RESOURCE_GROUP_NAME  `
    --gateway-name myAppGateway `
    --rule-set-name myRewriteRuleSet `
    --name myRewriteRule02 `
    --sequence 100 `
    --response-headers Location="http://${Env:APPGATEWAY_IP}{http_resp_Location_2}"

# Create a rewrite rule condition.
az network application-gateway rewrite-rule condition create `
    --resource-group $Env:RESOURCE_GROUP_NAME  `
    --gateway-name myAppGateway `
    --rule-name myRewriteRule02 `
    --rule-set-name myRewriteRuleSet `
    --variable "http_resp_Location" `
    --ignore-case true `
    --negate false `
    --pattern '"(https?):\/\/192.168.0.7:9080(.*)$"'
    # Be sure to wrap the "" in ''

È ora possibile accedere all'applicazione usando l'URL prodotto dal comando seguente:

Bash
PowerShell

echo "http://${APPGATEWAY_IP}/snoop/"

echo "http://${Env:APPGATEWAY_IP}/snoop/"

Nota

In questo esempio viene configurato l'accesso semplice ai server WAS con HTTP. Se si vuole un accesso sicuro, configurare la terminazione TLS/SSL seguendo le istruzioni riportate in TLS end-to-end con gateway applicazione.

Questo esempio non espone la console IBM tramite gateway applicazione. Per accedere alla console IBM, è possibile usare il computer myWindowsVM Windows o assegnare un indirizzo IP pubblico a adminVM.

Se non si vuole usare la jump box myWindowsVM per accedere alla console IBM, ma si vuole esporla a una rete pubblica, usare i comandi seguenti per assegnare un indirizzo IP pubblico a adminVM:

Bash
PowerShell

# Create a public IP address.
az network public-ip create \
    --resource-group $RESOURCE_GROUP_NAME \
    --name myAdminVMPublicIPAddress \
    --allocation-method Static \
    --sku Standard

# Create a network security group.
az network nsg create \
    --resource-group $RESOURCE_GROUP_NAME \
    --name adminnsg

# Create an inbound rule for the network security group.
az network nsg rule create \
    --resource-group $RESOURCE_GROUP_NAME \
    --nsg-name adminnsg \
    --name ALLOW_IBM_CONSOLE \
    --access Allow \
    --direction Inbound \
    --source-address-prefixes '["*"]' \
    --destination-port-ranges 9043 \
    --protocol Tcp \
    --priority 500

# Update the network adapter with the network security group.
az network nic update \
    --resource-group $RESOURCE_GROUP_NAME \
    --name adminVMVMNic \
    --network-security-group adminnsg

# Update the network adapter with the public IP address.
az network nic ip-config update \
    --resource-group $RESOURCE_GROUP_NAME \
    --name ipconfigadminVM \
    --nic-name adminVMVMNic \
    --public-ip-address myAdminVMPublicIPAddress

export ADMIN_PUBLIC_IP=$(az network public-ip show \
    --resource-group $RESOURCE_GROUP_NAME \
    --name myAdminVMPublicIPAddress \
    --query '[ipAddress]' \
    --output tsv)

echo "IBM Console public URL: https://${ADMIN_PUBLIC_IP}:9043/ibm/console/"

# Create a public IP address.
az network public-ip create `
    --resource-group $Env:RESOURCE_GROUP_NAME `
    --name myAdminVMPublicIPAddress `
    --allocation-method Static `
    --sku Standard

# Create a network security group.
az network nsg create `
    --resource-group $Env:RESOURCE_GROUP_NAME  `
    --name adminnsg

# Create an inbound rule for the network security group.
az network nsg rule create `
    --resource-group $Env:RESOURCE_GROUP_NAME  `
    --nsg-name adminnsg `
    --name ALLOW_IBM_CONSOLE `
    --access Allow `
    --direction Inbound `
    --source-address-prefixes '["*"]' `
    --destination-port-ranges 9043 `
    --protocol Tcp `
    --priority 500

# Update the network adapter with the network security group.
az network nic update `
    --resource-group $Env:RESOURCE_GROUP_NAME  `
    --name adminVMVMNic `
    --network-security-group adminnsg

# Update the network adapter with the public IP address.
az network nic ip-config update `
    --resource-group $Env:RESOURCE_GROUP_NAME `
    --name ipconfigadminVM `
    --nic-name adminVMVMNic `
    --public-ip-address myAdminVMPublicIPAddress

$Env:ADMIN_PUBLIC_IP=$(az network public-ip show `
    --resource-group $Env:RESOURCE_GROUP_NAME  `
    --name myAdminVMPublicIPAddress `
    --query '[ipAddress]' `
    --output tsv)

echo "IBM Console public URL: https://${Env:ADMIN_PUBLIC_IP}:9043/ibm/console/"

Testare la configurazione del cluster WAS

È stata completata la configurazione del cluster WAS e la distribuzione dell'applicazione Java EE. Usare la procedura seguente per accedere all'applicazione per convalidare tutte le impostazioni:

Aprire un Web browser.
Passare all'applicazione usando l'URL http://<gateway-public-ip-address>/snoop/.
Quando si aggiorna continuamente il browser, l'app scorre le istanze del server. Esaminare il valore dell'intestazione della richiesta host e notare che cambia dopo il ricaricamento più volte.

Pulire le risorse

La configurazione del cluster WAS è stata completata. Le sezioni seguenti descrivono come rimuovere le risorse create.

Pulire il computer Windows

È possibile rimuovere il computer myWindowsVM Windows usando i comandi seguenti. In alternativa, è possibile arrestare il computer Windows e continuare a usarlo come jump box per le attività di manutenzione del cluster in corso.

export WINDOWSVM_NIC_ID=$(az vm show \
    --resource-group ${RESOURCE_GROUP_NAME} \
    --name myWindowsVM \
    --query networkProfile.networkInterfaces[0].id \
    --output tsv)
export WINDOWSVM_NSG_ID=$(az network nic show \
    --ids ${WINDOWSVM_NIC_ID} \
    --query networkSecurityGroup.id \
    --output tsv)
export WINDOWSVM_DISK_ID=$(az vm show \
    --resource-group ${RESOURCE_GROUP_NAME} \
    --name myWindowsVM \
    --query storageProfile.osDisk.managedDisk.id \
    --output tsv)
export WINDOWSVM_PUBLIC_IP=$(az network public-ip list \
    -g ${RESOURCE_GROUP_NAME} --query [0].id \
    --output tsv)

echo "deleting myWindowsVM"
az vm delete --resource-group ${RESOURCE_GROUP_NAME} --name myWindowsVM --yes
echo "deleting nic ${WINDOWSVM_NIC_ID}"
az network nic delete --ids ${WINDOWSVM_NIC_ID}
echo "deleting public-ip ${WINDOWSVM_PUBLIC_IP}"
az network public-ip delete --ids ${WINDOWSVM_PUBLIC_IP}
echo "deleting disk ${WINDOWSVM_DISK_ID}"
az disk delete --yes --ids ${WINDOWSVM_DISK_ID}
echo "deleting nsg ${WINDOWSVM_NSG_ID}"
az network nsg delete --ids ${WINDOWSVM_NSG_ID}

Pulire tutte le risorse

Eliminare abc1110rg usando il comando seguente:

Bash
PowerShell

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

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

Passaggi successivi

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

Condividi tramite

Esercitazione: Installare manualmente webSphere Application Server Network Deployment (tradizionale) in Azure Macchine virtuali (VM)

Prerequisiti

Preparare l'ambiente

Presupposti

Creare un gruppo di risorse

Creare una rete virtuale

Creare un set di disponibilità

Ottenere o installare WAS in GNU/Linux

Creare un computer Red Hat Enterprise Linux

Creare una macchina virtuale Windows e configurare un server X

Installare le dipendenze

Montare il disco dati

Scaricare e installare IBM Installation Manager

Installare la distribuzione di rete del server applicazioni WebSphere tradizionale

Creare computer per server gestiti

Creare mspVM1

Creare mspVM2

Creare profili WAS e un cluster

Configurare un profilo di Deployment Manager

Configurare profili personalizzati

Configurare il profilo personalizzato per mspVM1

Configurare il profilo personalizzato per mspVM2

Creare un cluster e avviare server

Distribuire un'applicazione

Esporre WAS usando app Azure lication Gateway

Creare il gateway applicazione

Testare la configurazione del cluster WAS

Pulire le risorse

Pulire il computer Windows

Pulire tutte le risorse

Passaggi successivi

Commenti e suggerimenti

Risorse aggiuntive

Condividi tramite

Esercitazione: Installare manualmente webSphere Application Server Network Deployment (tradizionale) in Azure Macchine virtuali (VM)

Prerequisiti

Preparare l'ambiente

Presupposti

Accedere ad Azure

Creare un gruppo di risorse

Creare una rete virtuale

Creare un set di disponibilità

Ottenere o installare WAS in GNU/Linux

Creare un computer Red Hat Enterprise Linux

Creare una macchina virtuale Windows e configurare un server X

Installare le dipendenze

Montare il disco dati

Installare la distribuzione di rete del server applicazioni WebSphere tradizionale

Creare computer per server gestiti

Creare mspVM1

Creare mspVM2

Creare profili WAS e un cluster

Configurare un profilo di Deployment Manager

Configurare profili personalizzati

Configurare il profilo personalizzato per mspVM1

Configurare il profilo personalizzato per mspVM2

Creare un cluster e avviare server

Distribuire un'applicazione

Esporre WAS usando app Azure lication Gateway

Creare il gateway applicazione

Testare la configurazione del cluster WAS

Pulire le risorse

Pulire il computer Windows

Pulire tutte le risorse

Passaggi successivi

Commenti e suggerimenti

Risorse aggiuntive