Esercitazione: Installare manualmente Red Hat JBoss EAP in Azure Macchine virtuali

Articolo
02/05/2024

Questa esercitazione illustra i passaggi per installare Red Hat JBoss EAP e configurare un cluster in modalità di dominio in Azure Macchine virtuali (VM), in Red Hat Enterprise Linux (RHEL).

In questa esercitazione si apprenderà come eseguire le attività seguenti:

Creare una rete virtuale personalizzata e creare le macchine virtuali all'interno della rete.
Installare JDK e Red Hat JBoss EAP desiderati nelle macchine virtuali usando la riga di comando manualmente.
Configurare un cluster Red Hat JBoss EAP in modalità di dominio usando l'interfaccia della riga di comando.
Configurare una connessione all'origine dati PostgreSQL nel cluster.
Distribuire ed eseguire un'applicazione Java edizione Enterprise di esempio 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 dal portale di Azure, vedere Avvio rapido: Distribuire JBoss EAP Server in una macchina virtuale di Azure usando il portale di Azure.

Nota

Questo articolo contiene riferimenti al termine slave, che Microsoft non usa più. Quando il termine verrà rimosso dal software, verrà rimosso anche dall'articolo.

Prerequisiti

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.51.0 o successiva per eseguire i comandi dell'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 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.
Assicurarsi di avere le licenze Red Hat necessarie. È necessario avere un account Red Hat con diritto rhSM (Red Hat Subscription Management) per Red Hat JBoss EAP. Questo diritto consente alla soluzione completamente automatizzata menzionata in precedenza (in Distribuire JBoss EAP Server in una macchina virtuale di Azure usando il portale di Azure) di installare la versione di JBoss EAP testata e certificata di Red Hat.

Nota

Se non si ha un diritto EAP, è possibile iscriversi per ottenere una sottoscrizione per sviluppatori gratuita tramite la sottoscrizione per sviluppatori Red Hat Developer per utenti singoli. Salvare i dettagli dell'account, che vengono usati come nome utente RHSM e password RHSM nella sezione successiva.
Se si è già registrati o dopo aver completato la registrazione, è possibile individuare le credenziali necessarie (ID pool) attenendosi alla procedura seguente. Questi ID pool vengono usati anche come ID pool RHSM con diritto EAP nei passaggi successivi.
1. Accedere all'account Red Hat.
2. La prima volta che si esegue l'accesso, viene richiesto di completare il profilo. A seconda dell'utilizzo, selezionare Personale o Aziendale per Tipo di account, come illustrato nello screenshot seguente:
3. Aprire la sottoscrizione per sviluppatori Red Hat per utenti singoli. Questo collegamento consente di accedere a tutte le sottoscrizioni nell'account per lo SKU appropriato.
4. Nella riga dei controlli nella tabella Tutte le sottoscrizioni acquistate selezionare Attivo. In questo modo vengono visualizzate solo le sottoscrizioni attive.
5. Selezionare l'intestazione di colonna ordinabile per Data fine fino a quando il valore più lontano in futuro viene visualizzato come prima riga.
6. Selezionare la prima riga. Copiare e salvare quindi il valore seguente in Pool master dagli ID pool.
Java JDK, versione 11. In questa guida è consigliabile usare Red Hat Build di OpenJDK. Assicurarsi che la JAVA_HOME variabile di ambiente sia impostata correttamente nelle shell in cui si eseguono i comandi.
Git; usare git --version per verificare se git funziona. Questa esercitazione è stata testata con la versione 2.25.1.
Maven; usare mvn -version per verificare se mvn funziona. Questa esercitazione è stata testata con la versione 3.6.3.

Preparare l'ambiente

In questa sezione viene configurata l'infrastruttura in cui si installa JDK, Red Hat JBoss EAP e il driver JDBC PostgreSQL.

Presupposti

Questa esercitazione configura un cluster Red Hat JBoss EAP in modalità di dominio con un server di amministrazione e due server gestiti in un totale di tre macchine virtuali. Per configurare il cluster, è necessario creare le tre macchine virtuali di Azure seguenti:

Una macchina virtuale amministratore (nome adminVMmacchina virtuale) viene eseguita come controller di dominio.
Due macchine virtuali gestite (nomi mspVM1 di vm e mspVM2) vengono eseguite come controller host.

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

az login

Nota

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

Creare un gruppo di risorse

Come prima cosa creare un gruppo di risorse con 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 pre-attesa di un identificatore univoco per 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:

az group create \
    --name abc1110rg \
    --location eastus

Creare una rete virtuale

Le risorse che comprendono il cluster Red Hat JBoss EAP devono comunicare tra loro e 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.

L'esempio in questa sezione crea una rete virtuale con spazio 192.168.0.0/16 indirizzi e crea una subnet usata per le macchine virtuali.

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

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

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

az network vnet subnet create \
    --resource-group abc1110rg \
    --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 jbossVMGatewaySubnet:

az network vnet subnet create \
    --resource-group abc1110rg \
    --name jbossVMGatewaySubnet \
    --vnet-name myVNet \
    --address-prefixes 192.168.0.128/25

Creare un gruppo di sicurezza di rete e assegnarvi subnet

Prima di creare macchine virtuali con indirizzi IP pubblici, creare un gruppo di sicurezza di rete (NSG) per proteggere la rete virtuale e le subnet create in precedenza.

Creare un gruppo di sicurezza di rete usando az network nsg create. Nell'esempio seguente viene creato un gruppo di sicurezza di rete denominato mynsg:

az network nsg create \
    --resource-group abc1110rg \
    --name mynsg

Creare regole del gruppo di sicurezza di rete usando az network nsg rule create. Nell'esempio seguente vengono create regole del gruppo di sicurezza di rete denominate ALLOW_APPGW e ALLOW_HTTP_ACCESS. Queste regole consentono al gateway app di accettare il traffico in ingresso sulle porte HTTP usate da Red Hat JBoss EAP:

az network nsg rule create \
    --resource-group abc1110rg \
    --nsg-name mynsg \
    --name ALLOW_APPGW \
    --protocol Tcp \
    --destination-port-ranges 65200-65535 \
    --source-address-prefix GatewayManager \
    --destination-address-prefix '*' \
    --access Allow \
    --priority 500 \
    --direction Inbound

az network nsg rule create \
    --resource-group abc1110rg \
    --nsg-name mynsg \
    --name ALLOW_HTTP_ACCESS \
    --protocol Tcp \
    --destination-port-ranges 22 80 443 9990 8080 \
    --source-address-prefix Internet \
    --destination-address-prefix '*' \
    --access Allow \
    --priority 510 \
    --direction Inbound

Associare le subnet create in precedenza a questo gruppo di sicurezza di rete usando az network vnet subnet update, come illustrato nell'esempio seguente:

az network vnet subnet update \
    --resource-group abc1110rg \
    --vnet-name myVNet \
    --name mySubnet \
    --network-security-group mynsg

az network vnet subnet update \
    --resource-group abc1110rg \
    --vnet-name myVNet \
    --name jbossVMGatewaySubnet \
    --network-security-group mynsg

Creare un computer Red Hat Enterprise Linux per l'amministratore

Creare la macchina virtuale di amministrazione

L'immagine del Marketplace usata per creare le macchine virtuali è RedHat:rhel-raw:86-gen2:latest. Per altre immagini, vedere Immagini Red Hat Enterprise Linux (RHEL) disponibili in Azure.

Nota

È possibile eseguire query su tutte le immagini di Red Hat Enterprise Linux disponibili fornite da Red Hat con il comando az vm image list , ad esempio : 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 in questa guida.

Creare una macchina virtuale di base, installare tutti gli strumenti necessari, crearne uno snapshot e quindi creare repliche basate sullo snapshot.

Creare una macchina virtuale usando il comando az vm create. Eseguire il server di Amministrazione istration in questa macchina virtuale.

L'esempio seguente crea una macchina virtuale Red Hat Enterprise Linux usando il nome utente e la coppia di password per l'autenticazione. Se necessario, è invece possibile usare l'autenticazione TLS/SSL.

az vm create \
    --resource-group abc1110rg \
    --name adminVM \
    --image RedHat:rhel-raw:86-gen2:latest \
    --size Standard_DS1_v2  \
    --admin-username azureuser \
    --admin-password Secret123456 \
    --public-ip-sku Standard \
    --nsg mynsg \
    --vnet-name myVnet \
    --subnet mySubnet

Installare OpenJDK 11 e Red Hat JBoss EAP 7.4

Per installare, seguire questa procedura:

Usare il comando seguente per ottenere l'indirizzo IP pubblico di adminVM:

export ADMIN_VM_PUBLIC_IP=$(az vm show \
    --resource-group abc1110rg \
    --name adminVM \
    --show-details \
    --query publicIps | tr -d '"')

Aprire un terminale e SSH con adminVM il comando seguente:
```
ssh azureuser@$ADMIN_VM_PUBLIC_IP
```
Specificare Secret123456 come password.

Configurare il firewall per le porte usando il comando seguente:

sudo firewall-cmd --zone=public --add-port={9999/tcp,8443/tcp,8009/tcp,8080/tcp,9990/tcp,9993/tcp,45700/tcp,7600/tcp} --permanent
sudo firewall-cmd --reload
sudo iptables-save

La parola success dovrebbe essere visualizzata dopo i primi due comandi. L'output dovrebbe essere simile all'esempio seguente dopo il terzo comando:

# Generated by iptables-save v1.8.4 on Wed Mar 29 22:39:23 2023
*filter
:INPUT ACCEPT [20:3546]
:FORWARD ACCEPT [0:0]
:OUTPUT ACCEPT [24:5446]
COMMIT
# Completed on Wed Mar 29 22:39:23 2023
# Generated by iptables-save v1.8.4 on Wed Mar 29 22:39:23 2023
*security
:INPUT ACCEPT [19:3506]
:FORWARD ACCEPT [0:0]
:OUTPUT ACCEPT [5:492]
-A OUTPUT -d 168.63.129.16/32 -p tcp -m tcp --dport 53 -j ACCEPT
-A OUTPUT -d 168.63.129.16/32 -p tcp -m tcp --dport 53 -j ACCEPT
-A OUTPUT -d 168.63.129.16/32 -p tcp -m owner --uid-owner 0 -j ACCEPT
-A OUTPUT -d 168.63.129.16/32 -p tcp -m conntrack --ctstate INVALID,NEW -j DROP
COMMIT
# Completed on Wed Mar 29 22:39:23 2023
# Generated by iptables-save v1.8.4 on Wed Mar 29 22:39:23 2023
*raw
:PREROUTING ACCEPT [20:3546]
:OUTPUT ACCEPT [24:5446]
COMMIT
# Completed on Wed Mar 29 22:39:23 2023
# Generated by iptables-save v1.8.4 on Wed Mar 29 22:39:23 2023
*mangle
:PREROUTING ACCEPT [20:3546]
:INPUT ACCEPT [20:3546]
:FORWARD ACCEPT [0:0]
:OUTPUT ACCEPT [24:5446]
:POSTROUTING ACCEPT [24:5446]
COMMIT
# Completed on Wed Mar 29 22:39:23 2023
# Generated by iptables-save v1.8.4 on Wed Mar 29 22:39:23 2023
*nat
:PREROUTING ACCEPT [1:40]
:INPUT ACCEPT [0:0]
:POSTROUTING ACCEPT [4:240]
:OUTPUT ACCEPT [4:240]
COMMIT
# Completed on Wed Mar 29 22:39:23 2023

Usare i comandi seguenti per registrare l'host amministratore nell'account Red Hat Subscription Management (RHSM):

export RHSM_USER=<your-rhsm-username>
export RHSM_PASSWORD="<your-rhsm-password>"
export EAP_POOL=<your-rhsm-pool-ID>

sudo subscription-manager register --username ${RHSM_USER} --password ${RHSM_PASSWORD} --force

L'output dovrebbe essere simile all'esempio seguente:

Registering to: subscription.rhsm.redhat.com:443/subscription
The system has been registered with ID: redacted
The registered system name is: adminVM

Usare il comando seguente per collegare l'host amministratore al pool EAP di Red Hat JBoss:
```
sudo subscription-manager attach --pool=${EAP_POOL}
```
Nota

Questo comando viene ignorato se si usa la modalità Accesso contenuto semplice.
Usare il comando seguente per installare OpenJDK 11:
```
sudo yum install java-11-openjdk -y
```
Verranno visualizzate molte righe di output, terminando con Complete!

Usare i comandi seguenti per installare Red Hat JBoss EAP 7.4:

sudo subscription-manager repos --enable=jb-eap-7.4-for-rhel-8-x86_64-rpms
sudo yum update -y --disablerepo='*' --enablerepo='*microsoft*'
sudo yum groupinstall -y jboss-eap7

Per i secondi e i terzi comandi, verranno visualizzate molte righe di output, terminando con Complete!

Usare i comandi seguenti: impostare le autorizzazioni e le configurazioni TCP:

sudo sed -i 's/PermitRootLogin yes/PermitRootLogin no/g' /etc/ssh/sshd_config
echo 'AllowTcpForwarding no' | sudo tee -a /etc/ssh/sshd_config
sudo systemctl restart sshd

Usare i comandi seguenti per configurare le variabili di ambiente:

echo 'export EAP_RPM_CONF_DOMAIN="/etc/opt/rh/eap7/wildfly/eap7-domain.conf"' >> ~/.bash_profile
echo 'export EAP_HOME="/opt/rh/eap7/root/usr/share"' >> ~/.bash_profile
source ~/.bash_profile
sudo touch /etc/profile.d/eap_env.sh
echo 'export EAP_HOME="/opt/rh/eap7/root/usr/share"' | sudo tee -a /etc/profile.d/eap_env.sh

Uscire dalla connessione SSH digitando exit.

Creare computer per server gestiti

È stato installato OpenJDK 11 e Red Hat JBoss EAP 7.4 in adminVM, che viene eseguito come server controller di dominio. È comunque necessario preparare i computer per eseguire i due server controller host. Successivamente, si crea uno snapshot di adminVM e si preparano i computer per due server gestiti e mspVM1mspVM2.

Questa sezione presenta un approccio per preparare i computer con lo snapshot di adminVM. Tornare al terminale con l'interfaccia della riga di comando di Azure che ha eseguito l'accesso, quindi seguire questa procedura:

Usare il comando seguente per arrestare adminVM:

az vm stop --resource-group abc1110rg --name adminVM

Usare az snapshot create per creare uno snapshot del disco del adminVM sistema operativo, come illustrato nell'esempio seguente:

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

Usare il comando seguente per avviare adminVM:

az vm start --resource-group abc1110rg --name adminVM

Usare la procedura seguente per creare mspVM1:

Creare prima di tutto un disco gestito per mspVM1 con az disk create:

#Get the snapshot ID
export SNAPSHOT_ID=$(az snapshot show \
    --name myAdminOSDiskSnapshot \
    --resource-group abc1110rg \
    --query '[id]' \
    --output tsv)

#Create a new Managed Disks using the snapshot Id
#Note that managed disk is created in the same location as the snapshot
az disk create \
    --resource-group abc1110rg \
    --name mspVM1_OsDisk_1 \
    --source ${SNAPSHOT_ID}

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

#Get the resource Id of the managed disk
export MSPVM1_DISK_ID=$(az disk show \
    --name mspVM1_OsDisk_1 \
    --resource-group abc1110rg \
    --query '[id]' \
    --output tsv)

#Create VM by attaching existing managed disks as OS
az vm create \
    --resource-group abc1110rg \
    --name mspVM1 \
    --attach-os-disk ${MSPVM1_DISK_ID} \
    --os-type linux \
    --public-ip-sku Standard \
    --nsg mynsg \
    --vnet-name myVnet \
    --subnet mySubnet

È stato creato mspVM1 con OpenJDK 11 e Red Hat JBoss EAP 7.4 installato. Poiché la macchina virtuale è stata creata da uno snapshot del disco del adminVM sistema operativo, le due macchine virtuali hanno lo stesso nome host. Usare az vm run-command invoke per modificare il nome host nel valore mspVM1:

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

Al termine del comando, viene visualizzato 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
        }
    ]
}

Usare gli stessi comandi per creare mspVM2:

#Create a new Managed Disks for mspVM2
az disk create \
    --resource-group abc1110rg \
    --name mspVM2_OsDisk_1 \
    --source ${SNAPSHOT_ID}

#Get the resource Id of the managed disk
export MSPVM2_DISK_ID=$(az disk show \
    --name mspVM2_OsDisk_1 \
    --resource-group abc1110rg \
    --query '[id]' \
    --output tsv)

#Create VM by attaching existing managed disks as OS
az vm create \
    --resource-group abc1110rg \
    --name mspVM2 \
    --attach-os-disk ${MSPVM2_DISK_ID} \
    --os-type linux \
    --public-ip-sku Standard \
    --nsg mynsg \
    --vnet-name myVnet \
    --subnet mySubnet

#Set hostname
az vm run-command invoke \
    --resource-group abc1110rg \
    --name mspVM2 \
    --command-id RunShellScript \
    --scripts "sudo hostnamectl set-hostname mspVM2"

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

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}"

Ora, tutti e tre i computer sono pronti. Configurare quindi un cluster Red Hat JBoss EAP in modalità di dominio gestito.

Configurare un dominio gestito e un cluster

Configurare il cluster con la replica di sessione abilitata. Per altre informazioni, vedere Replica di sessione.

Per abilitare la replica di sessione, usare La disponibilità elevata di Red Hat JBoss EAP per il cluster. Microsoft Azure non supporta i protocolli di individuazione JGroups basati sul multicast UDP. Sebbene sia possibile usare altri protocolli di individuazione JGroups (ad esempio una configurazione statica (TCPPING), un database condiviso (JDBC_PING), un ping basato su file system condiviso (FILE_PING) o TCPGOSSIP), è consigliabile usare il protocollo di individuazione file condiviso sviluppato specificamente per Azure: AZURE_PING. Per altre informazioni, vedere Uso della disponibilità elevata di JBoss EAP in Microsoft Azure.

Creare un account di archiviazione di Azure e un contenitore BLOB per AZURE_PING

Usare i comandi seguenti per creare un account di archiviazione e un contenitore BLOB:

# Define your storage account name
export STORAGE_ACCOUNT_NAME=azurepingstgabc1110rg
# Define your Blob container name
export CONTAINER_NAME=azurepingcontainerabc1110rg

# Create storage account
az storage account create \
    --resource-group abc1110rg \
    --name ${STORAGE_ACCOUNT_NAME} \
    --location eastus \
    --sku Standard_LRS \
    --kind StorageV2 \
    --access-tier Hot

Recuperare quindi la chiave dell'account di archiviazione per usarla in un secondo momento usando il comando seguente. Se viene visualizzato un errore, attendere alcuni minuti e riprovare. L'errore potrebbe essere causato dal comando precedente per creare l'account di archiviazione non completamente completato.

export STORAGE_ACCESS_KEY=$(az storage account keys list \
    --resource-group abc1110rg \
    --account-name ${STORAGE_ACCOUNT_NAME} \
    --query "[0].value" \
    --output tsv)

# Create blob container
az storage container create \
    --name ${CONTAINER_NAME} \
    --account-name ${STORAGE_ACCOUNT_NAME} \
    --account-key ${STORAGE_ACCESS_KEY}

Verrà visualizzato l'output seguente:

{
  "created": true
}

Configurare il controller di dominio (nodo amministratore)

Questa esercitazione usa i comandi dell'interfaccia della riga di comando di gestione di Red Hat JBoss EAP per configurare il controller di dominio. Per altre informazioni, vedere Guida all'interfaccia della riga di comando di gestione.

La procedura seguente consente di configurare la configurazione del controller di dominio in adminVM. Usare SSH per connettersi all'oggetto adminVM come azureuser utente. Tenere presente che l'indirizzo IP pubblico di è stato acquisito in precedenza nella ADMIN_VM_PUBLIC_IP variabile di adminVM ambiente.

ssh azureuser@$ADMIN_VM_PUBLIC_IP

Usare prima di tutto i comandi seguenti per configurare il profilo a disponibilità elevata e I JGroup usando il AZURE_PING protocollo :

export HOST_VM_IP=$(hostname -I)
export STORAGE_ACCOUNT_NAME=azurepingstgabc1110rg
export CONTAINER_NAME=azurepingcontainerabc1110rg
export STORAGE_ACCESS_KEY=<the-value-from-before-you-connected-with-SSH>


#-Configure the HA profile and JGroups using AZURE_PING protocol
sudo -u jboss $EAP_HOME/wildfly/bin/jboss-cli.sh --echo-command \
'embed-host-controller --std-out=echo --domain-config=domain.xml --host-config=host-master.xml',\
':write-attribute(name=name,value=domain1)',\
'/profile=ha/subsystem=jgroups/stack=tcp:remove',\
'/profile=ha/subsystem=jgroups/stack=tcp:add()',\
'/profile=ha/subsystem=jgroups/stack=tcp/transport=TCP:add(socket-binding=jgroups-tcp,properties={ip_mcast=false})',\
"/profile=ha/subsystem=jgroups/stack=tcp/protocol=azure.AZURE_PING:add(properties={storage_account_name=\"${STORAGE_ACCOUNT_NAME}\", storage_access_key=\"${STORAGE_ACCESS_KEY}\", container=\"${CONTAINER_NAME}\"})",\
'/profile=ha/subsystem=jgroups/stack=tcp/protocol=MERGE3:add',\
'/profile=ha/subsystem=jgroups/stack=tcp/protocol=FD_SOCK:add(socket-binding=jgroups-tcp-fd)',\
'/profile=ha/subsystem=jgroups/stack=tcp/protocol=FD_ALL:add',\
'/profile=ha/subsystem=jgroups/stack=tcp/protocol=VERIFY_SUSPECT:add',\
'/profile=ha/subsystem=jgroups/stack=tcp/protocol=pbcast.NAKACK2:add(properties={use_mcast_xmit=false,use_mcast_xmit_req=false})',\
'/profile=ha/subsystem=jgroups/stack=tcp/protocol=UNICAST3:add',\
'/profile=ha/subsystem=jgroups/stack=tcp/protocol=pbcast.STABLE:add',\
'/profile=ha/subsystem=jgroups/stack=tcp/protocol=pbcast.GMS:add',\
'/profile=ha/subsystem=jgroups/stack=tcp/protocol=MFC:add',\
'/profile=ha/subsystem=jgroups/stack=tcp/protocol=FRAG3:add',\
'/profile=ha/subsystem=jgroups/channel=ee:write-attribute(name="stack", value="tcp")',\
'/server-group=main-server-group:write-attribute(name="profile", value="ha")',\
'/server-group=main-server-group:write-attribute(name="socket-binding-group", value="ha-sockets")',\
"/host=master/subsystem=elytron/http-authentication-factory=management-http-authentication:write-attribute(name=mechanism-configurations,value=[{mechanism-name=DIGEST,mechanism-realm-configurations=[{realm-name=ManagementRealm}]}])",\
"/host=master/interface=unsecure:add(inet-address=${HOST_VM_IP})",\
"/host=master/interface=management:write-attribute(name=inet-address, value=${HOST_VM_IP})",\
"/host=master/interface=public:add(inet-address=${HOST_VM_IP})"

# Save a copy of the domain.xml, later you need to share it with all host controllers
cp $EAP_HOME/wildfly/domain/configuration/domain.xml /tmp/domain.xml

L'ultima stanza di output dovrebbe essere simile all'esempio seguente. In caso contrario, risolvere e risolvere il problema prima di continuare.

[domain@embedded /] /host=master/interface=public:add(inet-address=192.168.0.4 )
{
    "outcome" => "success",
    "result" => undefined,
    "server-groups" => undefined,
    "response-headers" => {"process-state" => "reload-required"}
}
02:05:55,019 INFO  [org.jboss.as] (MSC service thread 1-1) WFLYSRV0050: JBoss EAP 7.4.10.GA (WildFly Core 15.0.25.Final-redhat-00001) stopped in 28ms

Usare quindi i comandi seguenti per configurare il server JBoss e configurare il servizio EAP:

# Configure the JBoss server and setup EAP service
echo 'WILDFLY_HOST_CONFIG=host-master.xml' | sudo tee -a $EAP_RPM_CONF_DOMAIN

# Configure JBoss EAP management user
export JBOSS_EAP_USER=jbossadmin
export JBOSS_EAP_PASSWORD=Secret123456
sudo $EAP_HOME/wildfly/bin/add-user.sh  -u $JBOSS_EAP_USER -p $JBOSS_EAP_PASSWORD -g 'guest,mgmtgroup'

L'output deve essere simile all'esempio seguente:

Added user 'jbossadmin' to file '/etc/opt/rh/eap7/wildfly/standalone/mgmt-users.properties'
Added user 'jbossadmin' to file '/etc/opt/rh/eap7/wildfly/domain/mgmt-users.properties'
Added user 'jbossadmin' with groups guest,mgmtgroup to file '/etc/opt/rh/eap7/wildfly/standalone/mgmt-groups.properties'
Added user 'jbossadmin' with groups guest,mgmtgroup to file '/etc/opt/rh/eap7/wildfly/domain/mgmt-groups.properties'

Usare infine i comandi seguenti per avviare il servizio EAP:

# Start the JBoss server and setup EAP service
sudo systemctl enable eap7-domain.service

# Edit eap7-domain.services
sudo sed -i 's/After=syslog.target network.target/After=syslog.target network.target NetworkManager-wait-online.service/' /usr/lib/systemd/system/eap7-domain.service
sudo sed -i 's/Before=httpd.service/Wants=NetworkManager-wait-online.service \nBefore=httpd.service/' /usr/lib/systemd/system/eap7-domain.service

# Reload and restart EAP service
sudo systemctl daemon-reload
sudo systemctl restart eap7-domain.service

# Check the status of EAP service
systemctl status eap7-domain.service

L'output deve essere simile all'esempio seguente:

● eap7-domain.service - JBoss EAP (domain mode)
   Loaded: loaded (/usr/lib/systemd/system/eap7-domain.service; enabled; vendor>
   Active: active (running) since Thu 2023-03-30 02:11:44 UTC; 5s ago
 Main PID: 3855 (scl)
    Tasks: 82 (limit: 20612)
   Memory: 232.4M
   CGroup: /system.slice/eap7-domain.service
           ├─3855 /usr/bin/scl enable eap7 -- /opt/rh/eap7/root/usr/share/wildf>
           ├─3856 /bin/bash /var/tmp/sclfYu7yW
           ├─3858 /bin/sh /opt/rh/eap7/root/usr/share/wildfly/bin/launch.sh /us>
           ├─3862 /bin/sh /opt/rh/eap7/root/usr/share/wildfly/bin/domain.sh --h>
           ├─3955 /usr/lib/jvm/jre/bin/java -D[Process Controller] -server -Xms>
           └─3967 /usr/lib/jvm/jre/bin/java -D[Host Controller] -Dorg.jboss.boo>

Mar 30 02:11:44 adminVM systemd[1]: Started JBoss EAP (domain mode).

Digitare q per uscire dal cercapersone. Uscire dalla connessione SSH digitando exit.

Dopo aver avviato il servizio Red Hat JBoss EAP, è possibile accedere alla console di gestione tramite http://$ADMIN_VM_PUBLIC_IP:9990 il Web browser. Accedere con il nome utente jbossadmin e la password Secret123456configurati.

Selezionare la scheda Runtime . Nel riquadro di spostamento selezionare Topologia. Si noterà che per il momento il cluster contiene solo un controller di dominio:

Configurare i controller host (nodi di lavoro)

Usare SSH per connettersi a mspVM1 come azureuser utente. Ottenere l'indirizzo IP pubblico della macchina virtuale con il comando seguente:

MSPVM_PUBLIC_IP=$(az vm show \
    --resource-group abc1110rg \
    --name mspVM1 \
    --show-details \
    --query publicIps)

ssh azureuser@$MSPVM_PUBLIC_IP

Tenere presente che la password è la stessa di prima, poiché mspVM1 è semplicemente un clone di adminVM.

Usare i comandi seguenti per configurare il controller host in mspVM1:

# environment variables
export DOMAIN_CONTROLLER_PRIVATE_IP=<adminVM-private-IP>
export HOST_VM_NAME=$(hostname)
export HOST_VM_NAME_LOWERCASE=$(echo "${HOST_VM_NAME,,}")
export HOST_VM_IP=$(hostname -I)

export JBOSS_EAP_USER=jbossadmin
export JBOSS_EAP_PASSWORD=Secret123456

# Save default domain configuration as backup
sudo -u jboss mv $EAP_HOME/wildfly/domain/configuration/domain.xml $EAP_HOME/wildfly/domain/configuration/domain.xml.backup

# Fetch domain.xml from domain controller
sudo -u jboss scp azureuser@${DOMAIN_CONTROLLER_PRIVATE_IP}:/tmp/domain.xml $EAP_HOME/wildfly/domain/configuration/domain.xml

Viene richiesta la password per la connessione. Per questo esempio, la password è Secret123456.

Usare i comandi seguenti per applicare le modifiche del controller host a mspVM1:

# Setup host controller
sudo -u jboss $EAP_HOME/wildfly/bin/jboss-cli.sh --echo-command \
"embed-host-controller --std-out=echo --domain-config=domain.xml --host-config=host-slave.xml",\
"/host=${HOST_VM_NAME_LOWERCASE}/server-config=server-one:remove",\
"/host=${HOST_VM_NAME_LOWERCASE}/server-config=server-two:remove",\
"/host=${HOST_VM_NAME_LOWERCASE}/server-config=${HOST_VM_NAME_LOWERCASE}-server0:add(group=main-server-group)",\
"/host=${HOST_VM_NAME_LOWERCASE}/subsystem=elytron/authentication-configuration=slave:add(authentication-name=${JBOSS_EAP_USER}, credential-reference={clear-text=${JBOSS_EAP_PASSWORD}})",\
"/host=${HOST_VM_NAME_LOWERCASE}/subsystem=elytron/authentication-context=slave-context:add(match-rules=[{authentication-configuration=slave}])",\
"/host=${HOST_VM_NAME_LOWERCASE}:write-attribute(name=domain-controller.remote.username, value=${JBOSS_EAP_USER})",\
"/host=${HOST_VM_NAME_LOWERCASE}:write-attribute(name=domain-controller.remote, value={host=${DOMAIN_CONTROLLER_PRIVATE_IP}, port=9990, protocol=remote+http, authentication-context=slave-context})",\
"/host=${HOST_VM_NAME_LOWERCASE}/core-service=discovery-options/static-discovery=primary:write-attribute(name=host, value=${DOMAIN_CONTROLLER_PRIVATE_IP})",\
"/host=${HOST_VM_NAME_LOWERCASE}/interface=unsecured:add(inet-address=${HOST_VM_IP})",\
"/host=${HOST_VM_NAME_LOWERCASE}/interface=management:write-attribute(name=inet-address, value=${HOST_VM_IP})",\
"/host=${HOST_VM_NAME_LOWERCASE}/interface=public:write-attribute(name=inet-address, value=${HOST_VM_IP})"

L'ultima stanza di output dovrebbe essere simile all'esempio seguente. In caso contrario, risolvere e risolvere il problema prima di continuare.

[domain@embedded /] /host=mspvm1/interface=public:write-attribute(name=inet-address, value=192.168.0.5 )
{
    "outcome" => "success",
    "result" => undefined,
    "server-groups" => undefined,
    "response-headers" => {"process-state" => "reload-required"}
}
02:58:59,388 INFO  [org.jboss.as] (MSC service thread 1-2) WFLYSRV0050: JBoss EAP 7.4.10.GA (WildFly Core 15.0.25.Final-redhat-00001) stopped in 58ms

Usare quindi i comandi seguenti per configurare il server JBoss e configurare il servizio EAP:

echo 'WILDFLY_HOST_CONFIG=host-slave.xml' | sudo tee -a $EAP_RPM_CONF_DOMAIN

# Enable the JBoss server and setup EAP service
sudo systemctl enable eap7-domain.service

# Edit eap7-domain.services
sudo sed -i 's/After=syslog.target network.target/After=syslog.target network.target NetworkManager-wait-online.service/' /usr/lib/systemd/system/eap7-domain.service
sudo sed -i 's/Before=httpd.service/Wants=NetworkManager-wait-online.service \nBefore=httpd.service/' /usr/lib/systemd/system/eap7-domain.service

# Reload and restart EAP service
sudo systemctl daemon-reload
sudo systemctl restart eap7-domain.service

# Check the status of EAP service
systemctl status eap7-domain.service

L'output deve essere simile all'esempio seguente:

● eap7-domain.service - JBoss EAP (domain mode)
   Loaded: loaded (/usr/lib/systemd/system/eap7-domain.service; enabled; vendor>
   Active: active (running) since Thu 2023-03-30 03:02:15 UTC; 7s ago
 Main PID: 9699 (scl)
    Tasks: 51 (limit: 20612)
   Memory: 267.6M
   CGroup: /system.slice/eap7-domain.service
           ├─9699 /usr/bin/scl enable eap7 -- /opt/rh/eap7/root/usr/share/wildf>
           ├─9700 /bin/bash /var/tmp/sclgJ1hRD
           ├─9702 /bin/sh /opt/rh/eap7/root/usr/share/wildfly/bin/launch.sh /us>
           ├─9706 /bin/sh /opt/rh/eap7/root/usr/share/wildfly/bin/domain.sh --h>
           ├─9799 /usr/lib/jvm/jre/bin/java -D[Process Controller] -server -Xms>
           └─9811 /usr/lib/jvm/jre/bin/java -D[Host Controller] -Dorg.jboss.boo>

Mar 30 03:02:15 mspVM1 systemd[1]: Started JBoss EAP (domain mode).

Digitare q per uscire dal cercapersone. Uscire dalla connessione SSH digitando exit.

Usare SSH per connettersi a mspVM2 come azureuser utente. Ottenere l'indirizzo IP pubblico della macchina virtuale con il comando seguente:

az vm show \
    --resource-group abc1110rg \
    --name mspVM2 \
    --show-details \
    --query publicIps

Ripetere i passaggi precedenti in mspVM2e quindi uscire dalla connessione SSH digitando exit.

Dopo che due controller host sono connessi a adminVM, dovrebbe essere possibile visualizzare la topologia del cluster, come illustrato nello screenshot seguente:

Esporre un cluster Red Hat JBoss EAP con app Azure lication Gateway

Dopo aver creato il cluster Red Hat JBoss EAP in macchine virtuali di Azure, questa sezione illustra il processo di esposizione di Red Hat JBoss EAP a Internet con app Azure lication Gateway.

Creare il gateway di app Azure lication

Per esporre Red Hat JBoss EAP a Internet, è necessario un indirizzo IP pubblico. Creare l'indirizzo IP pubblico e quindi associarlo a un gateway di app Azure lication. Usare az network public-ip create per crearlo, come illustrato nell'esempio seguente:

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

Aggiungere quindi i server back-end al pool back-end gateway applicazione. Eseguire una query per gli indirizzi IP back-end usando i comandi seguenti. Sono configurati solo i controller host (nodi di lavoro) come server back-end.

export MSPVM1_NIC_ID=$(az vm show \
    --resource-group abc1110rg \
    --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 abc1110rg \
    --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)

Creare quindi un gateway di app Azure lication. L'esempio seguente crea un gateway applicazione con controller host nel pool back-end predefinito:

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

Nota

Questo esempio configura l'accesso semplice ai server Red Hat JBoss EAP 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.

In questo esempio vengono esposti i controller host sulla porta 8080. Si distribuisce un'applicazione di esempio con una connessione di database al cluster nei passaggi successivi.

Connessione Database di Azure per PostgreSQL

Questa sezione illustra come creare un'istanza di PostgreSQL in Azure e configurare una connessione a PostgreSQL nel cluster Red Hat JBoss EAP.

Creare un'istanza di Database di Azure per PostgreSQL

Per creare l'istanza del database, seguire questa procedura:

Usare az postgres server create per effettuare il provisioning di un'istanza di PostgreSQL in Azure, come illustrato nell'esempio seguente:

export DATA_BASE_USER=jboss
export DATA_BASE_PASSWORD=Secret123456

DB_SERVER_NAME="jbossdb$(date +%s)"
echo "DB_SERVER_NAME=${DB_SERVER_NAME}"
az postgres server create \
    --resource-group abc1110rg \
    --name ${DB_SERVER_NAME}  \
    --location eastus \
    --admin-user ${DATA_BASE_USER} \
    --ssl-enforcement Enabled \
    --admin-password ${DATA_BASE_PASSWORD} \
    --sku-name GP_Gen5_2

Usare i comandi seguenti per consentire l'accesso dai servizi di Azure:

# Save aside the following names for later use
export fullyQualifiedDomainName=$(az postgres server show \
    --resource-group abc1110rg \
    --name ${DB_SERVER_NAME} \
    --query "fullyQualifiedDomainName" \
    --output tsv)
export name=$(az postgres server show \
    --resource-group abc1110rg \
    --name ${DB_SERVER_NAME} \
    --query "name" \
    --output tsv)

az postgres server firewall-rule create \
    --resource-group abc1110rg \
    --server ${DB_SERVER_NAME} \
    --name "AllowAllAzureIps" \
    --start-ip-address 0.0.0.0 \
    --end-ip-address 0.0.0.0

Usare il comando seguente per creare il database:

az postgres db create \
    --resource-group abc1110rg \
    --server ${DB_SERVER_NAME} \
    --name testdb

Installare il driver

Usare la procedura seguente per installare il driver JDBC con l'interfaccia della riga di comando di gestione di JBoss. Per altre informazioni sui driver JDBC in Red Hat JBoss EAP, vedere Installazione di un driver JDBC come distribuzione JAR.

Ssh per adminVM usare il comando seguente. È possibile ignorare questo passaggio se è già stata aperta una connessione.
```
ssh azureuser@$ADMIN_VM_PUBLIC_IP
```
Usare i comandi seguenti per scaricare il driver JDBC. In questo caso si usano postgresql-42.5.2.jar. Per altre informazioni sui percorsi di download dei driver JDBC, vedere Percorsi di download dei driver JDBC forniti da Red Hat.
```
jdbcDriverName=postgresql-42.5.2.jar
sudo curl --retry 5 -Lo /tmp/${jdbcDriverName} https://jdbc.postgresql.org/download/${jdbcDriverName}
```
Distribuire il driver JDBC usando il comando seguente dell'interfaccia della riga di comando di JBoss:
```
sudo -u jboss $EAP_HOME/wildfly/bin/jboss-cli.sh --connect --controller=$(hostname -I) --echo-command \
"deploy /tmp/${jdbcDriverName} --server-groups=main-server-group"
```
Il log del server si trova in mspVM1 e mspVM2 in /var/opt/rh/eap7/lib/wildfly/domain/servers/mspvm1-server0/log/server.log. Se la distribuzione non riesce, esaminare questo file di log e risolvere il problema prima di continuare.

Configurare la connessione di database per il cluster Red Hat JBoss EAP

Il server di database è stato avviato, ottenuto l'ID risorsa necessario e installato il driver JDBC. I passaggi descritti in questa sezione illustrano quindi come usare l'interfaccia della riga di comando di JBoss per configurare una connessione origine dati con l'istanza di PostgreSQL creata in precedenza.

Aprire un terminale e SSH con adminVM il comando seguente:
```
ssh azureuser@$ADMIN_VM_PUBLIC_IP
```

Creare un'origine dati usando i comandi seguenti:

# Replace the following values with your own
export DATA_SOURCE_CONNECTION_STRING=jdbc:postgresql://<database-fully-qualified-domain-name>:5432/testdb
export DATA_BASE_USER=jboss@<database-server-name>
export JDBC_DATA_SOURCE_NAME=dataSource-postgresql
export JDBC_JNDI_NAME=java:jboss/datasources/JavaEECafeDB
export DATA_BASE_PASSWORD=Secret123456
export JDBC_DRIVER_NAME=postgresql-42.5.2.jar

sudo -u jboss $EAP_HOME/wildfly/bin/jboss-cli.sh --connect --controller=$(hostname -I) --echo-command \
"data-source add --driver-name=${JDBC_DRIVER_NAME} --profile=ha --name=${JDBC_DATA_SOURCE_NAME} --jndi-name=${JDBC_JNDI_NAME} --connection-url=${DATA_SOURCE_CONNECTION_STRING} --user-name=${DATA_BASE_USER} --password=${DATA_BASE_PASSWORD}"

Dopo questi passaggi, è stata configurata correttamente un'origine dati denominata java:jboss/datasources/JavaEECafeDB.

Distribuire l'applicazione di esempio Java edizione Enterprise Cafe

Usare la procedura seguente per distribuire l'applicazione di esempio Java edizione Enterprise Cafe nel cluster Red Hat JBoss EAP:

Usare la procedura seguente per compilare Java edizione Enterprise Cafe. Questi passaggi presuppongono che sia installato un ambiente locale con Git e Maven:
1. Usare il comando seguente per clonare il codice sorgente da GitHub:
```
git clone https://github.com/Azure/rhel-jboss-templates.git
```
2. Usare il comando seguente per compilare il codice sorgente:
```
mvn clean install --file rhel-jboss-templates/eap-coffee-app/pom.xml
```
  Questo comando crea il file eap-coffee-app/target/javaee-café.war. Caricare questo file nel passaggio successivo.
Aprire un Web browser e passare alla console di gestione all'indirizzo http://<adminVM-public-IP>:9990, quindi accedere con nome utente jbossadmin e password Secret123456.
Usare la procedura seguente per caricare javaee-café.war nel repository di contenuti:
1. Nella scheda Distribuzioni della console di gestione di Red Hat JBoss EAP selezionare Repository contenuto nel riquadro di spostamento.
2. Selezionare il pulsante Aggiungi e quindi carica contenuto.
3. Usare il selettore di file del browser per selezionare il file javaee-café.war .
4. Selezionare Avanti.
5. Accettare le impostazioni predefinite nella schermata successiva e quindi selezionare Fine.
6. Selezionare Visualizza contenuto.
Usare la procedura seguente per distribuire un'applicazione in main-server-group:
1. In Repository di contenuti selezionare javaee-café.war.
2. Nel menu a discesa selezionare Distribuisci.
3. Selezionare main-server-group come gruppo di server per la distribuzione di javaee-café.war.
4. Selezionare Distribuisci per avviare la distribuzione. Verrà visualizzato un avviso simile allo screenshot seguente:

Testare la configurazione del cluster Red Hat JBoss EAP

A questo punto è stata completata la configurazione del cluster Red Hat JBoss EAP e la distribuzione dell'applicazione Java edizione Enterprise. Usare la procedura seguente per accedere all'applicazione per convalidare tutte le impostazioni:

Usare il comando seguente per ottenere l'indirizzo IP pubblico del gateway di app Azure lication:

az network public-ip show \
    --resource-group abc1110rg \
    --name myAGPublicIPAddress \
    --query '[ipAddress]' \
    --output tsv

Aprire un Web browser.
Passare all'applicazione con l'URL http://<gateway-public-ip-address>/javaee-cafe/. Non dimenticare la barra finale.
Provare ad aggiungere e rimuovere caffè.

Pulire le risorse

Per evitare addebiti per Azure, è necessario eliminare le risorse non necessarie. Quando non è più necessario il cluster Red Hat JBoss EAP distribuito in una macchina virtuale di Azure, annullare la registrazione dei server Red Hat JBoss EAP e rimuovere le risorse di Azure.

Usare i comandi seguenti per annullare la registrazione dei server EAP EAP di Red Hat JBoss dalla gestione delle sottoscrizioni di Red Hat:

# Unregister domain controller
az vm run-command invoke \
    --resource-group abc1110rg \
    --name adminVM \
    --command-id RunShellScript \
    --scripts "sudo subscription-manager unregister"

# Unregister host controllers
az vm run-command invoke \
    --resource-group abc1110rg \
    --name mspVM1 \
    --command-id RunShellScript \
    --scripts "sudo subscription-manager unregister"
az vm run-command invoke \
    --resource-group abc1110rg \
    --name mspVM2 \
    --command-id RunShellScript \
    --scripts "sudo subscription-manager unregister"

Usare il comando seguente per eliminare il gruppo abc1110rgdi risorse :

az group delete --name abc1110rg --yes --no-wait

Passaggi successivi

Continuare a esplorare le opzioni per eseguire Red Hat JBoss EAP in Azure.

Altre informazioni su JBoss EAP in Azure

Share via

Esercitazione: Installare manualmente Red Hat JBoss EAP in Azure Macchine virtuali

Prerequisiti

Preparare l'ambiente

Presupposti

Creare un gruppo di risorse

Creare una rete virtuale

Creare un gruppo di sicurezza di rete e assegnarvi subnet

Creare un computer Red Hat Enterprise Linux per l'amministratore

Creare la macchina virtuale di amministrazione

Installare OpenJDK 11 e Red Hat JBoss EAP 7.4

Creare computer per server gestiti

Configurare un dominio gestito e un cluster

Creare un account di archiviazione di Azure e un contenitore BLOB per AZURE_PING

Configurare il controller di dominio (nodo amministratore)

Configurare i controller host (nodi di lavoro)

Esporre un cluster Red Hat JBoss EAP con app Azure lication Gateway

Creare il gateway di app Azure lication

Connessione Database di Azure per PostgreSQL

Creare un'istanza di Database di Azure per PostgreSQL

Installare il driver

Configurare la connessione di database per il cluster Red Hat JBoss EAP

Distribuire l'applicazione di esempio Java edizione Enterprise Cafe

Testare la configurazione del cluster Red Hat JBoss EAP

Pulire le risorse

Passaggi successivi

Commenti e suggerimenti

Commenti e suggerimenti

Risorse aggiuntive

Share via

Esercitazione: Installare manualmente Red Hat JBoss EAP in Azure Macchine virtuali

Prerequisiti

Preparare l'ambiente

Presupposti

Accedere ad Azure

Creare un gruppo di risorse

Creare una rete virtuale

Creare un gruppo di sicurezza di rete e assegnarvi subnet

Creare un computer Red Hat Enterprise Linux per l'amministratore

Creare la macchina virtuale di amministrazione

Installare OpenJDK 11 e Red Hat JBoss EAP 7.4

Creare computer per server gestiti

Configurare un dominio gestito e un cluster

Creare un account di archiviazione di Azure e un contenitore BLOB per AZURE_PING

Configurare il controller di dominio (nodo amministratore)

Configurare i controller host (nodi di lavoro)

Esporre un cluster Red Hat JBoss EAP con app Azure lication Gateway

Creare il gateway di app Azure lication

Connessione Database di Azure per PostgreSQL

Creare un'istanza di Database di Azure per PostgreSQL

Installare il driver

Configurare la connessione di database per il cluster Red Hat JBoss EAP

Distribuire l'applicazione di esempio Java edizione Enterprise Cafe

Testare la configurazione del cluster Red Hat JBoss EAP

Pulire le risorse

Passaggi successivi

Commenti e suggerimenti

Commenti e suggerimenti

Risorse aggiuntive