Condividi tramite

Esercitazione: Installare manualmente JBoss EAP in Azure Macchine virtuali (VM)

  • Articolo

Questa esercitazione illustra i passaggi per installare Red Hat JBoss Enterprise Application Platform (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 EE 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 dalla portale di Azure, vedere Avvio rapido: Distribuire un cluster JBoss EAP in Azure Macchine virtuali (VM).

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

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

  • 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.51.0 o successiva per eseguire i comandi dell'interfaccia della riga di comando di Azure.

  • 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 (in Avvio rapido: Distribuire un cluster JBoss EAP in Azure Macchine virtuali (VM) installare la versione di JBoss EAP testata e certificata di Red Hat.

    Nota

    Se non si dispone del diritto EAP, è possibile iscriversi per ottenere una sottoscrizione per sviluppatori gratuita tramite la Sottoscrizione per sviluppatori di Red Hat per singoli utenti. 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:

      Screenshot della finestra dell'account Red Hat che mostra le opzioni Tipo di account con l'opzione Personale selezionata.

    3. Aprire la sottoscrizione per sviluppatori Red Hat per utenti singoli. Questo collegamento consente di accedere a tutte le sottoscrizioni nell'account per l'SKU appropriato.

    4. Nella riga dei controlli nella tabella Tutte le sottoscrizioni acquistate selezionare Attivo.

    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 Development Kit (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 (Java Database Connectivity) 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.

Accedere ad Azure

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 $RESOURCE_GROUP_NAME nel westus percorso:

export SUBSCRIPTION=$(az account show --query id --output tsv)
export SUFFIX=$(date +%s)
export RESOURCE_GROUP_NAME=rg-$SUFFIX
echo "Resource group name: $RESOURCE_GROUP_NAME"
az group create \
    --name $RESOURCE_GROUP_NAME \
    --location westus

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 $RESOURCE_GROUP_NAME \
    --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 $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 jbossVMGatewaySubnet:

az network vnet subnet create \
    --resource-group $RESOURCE_GROUP_NAME \
    --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 $RESOURCE_GROUP_NAME \
    --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 $RESOURCE_GROUP_NAME \
    --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 $RESOURCE_GROUP_NAME \
    --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 $RESOURCE_GROUP_NAME \
    --vnet-name myVNet \
    --name mySubnet \
    --network-security-group mynsg

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

Creare un computer Red Hat Enterprise Linux per l'amministratore

Generare chiavi SSH

Usare il comando seguente per generare chiavi SSH per adminVM:

ssh-keygen -t rsa -b 4096 -f ~/.ssh/jbosseapvm
ssh-add ~/.ssh/jbosseapvm

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. Si esegue il server di amministrazione in questa macchina virtuale.

L'esempio seguente crea un'identità gestita di Azure e una macchina virtuale Red Hat Enterprise Linux usando l'autenticazione TLS/SSL.

az identity create \
    --name "passwordless-managed-identity" \
    --resource-group $RESOURCE_GROUP_NAME \
    --location westus

az vm create \
    --resource-group $RESOURCE_GROUP_NAME \
    --name adminVM \
    --image RedHat:rhel-raw:86-gen2:latest \
    --assign-identity "/subscriptions/$SUBSCRIPTION/resourceGroups/$RESOURCE_GROUP_NAME/providers/Microsoft.ManagedIdentity/userAssignedIdentities/passwordless-managed-identity" \
    --size Standard_DS1_v2  \
    --admin-username azureuser \
    --ssh-key-values ~/.ssh/jbosseapvm.pub \
    --public-ip-sku Standard \
    --nsg mynsg \
    --vnet-name myVnet \
    --subnet mySubnet

Installare Red Hat JBoss EAP

Per installare, seguire questa procedura:

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

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

  2. Aprire un terminale e SSH con adminVM il comando seguente:

    ssh -i ~/.ssh/jbosseapvm azureuser@$ADMIN_VM_PUBLIC_IP

  3. 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

Nota

I RHSM_USER valori e RHSM_PASSWORD sono necessari per installare Red Hat JBoss EAP. È consigliabile usare un account del servizio con autorizzazioni limitate per accedere a Red Hat Customer Portal.

  1. 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

  2. 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.

  3. Usare i comandi seguenti per installare Red Hat JBoss EAP:

    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!

  1. Usare i comandi seguenti per impostare le autorizzazioni e le configurazioni di rete:

    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

  2. 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

  3. Uscire dalla connessione SSH digitando exit.

Creare computer per server gestiti

È stato installato Red Hat JBoss EAP 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 mspVM1 mspVM2.

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:

  1. Usare il comando seguente per arrestare adminVM:

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

  2. 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 $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}

  3. Usare il comando seguente per avviare adminVM:

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

  4. Usare la procedura seguente per creare mspVM1:

    1. 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 $RESOURCE_GROUP_NAME \
    --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 $RESOURCE_GROUP_NAME \
    --name mspVM1_OsDisk_1 \
    --source ${SNAPSHOT_ID}

    2. 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 $RESOURCE_GROUP_NAME \
    --query '[id]' \
    --output tsv)

#Create VM by attaching existing managed disks as OS
az vm create \
    --resource-group $RESOURCE_GROUP_NAME \
    --name mspVM1 \
    --assign-identity "/subscriptions/$SUBSCRIPTION/resourceGroups/$RESOURCE_GROUP_NAME/providers/Microsoft.ManagedIdentity/userAssignedIdentities/passwordless-managed-identity" \
    --attach-os-disk ${MSPVM1_DISK_ID} \
    --os-type linux \
    --public-ip-sku Standard \
    --nsg mynsg \
    --vnet-name myVnet \
    --subnet mySubnet

    3. È stato creato mspVM1 con Red Hat JBoss EAP 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 $RESOURCE_GROUP_NAME \
    --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
        }
    ]
}

  5. Usare gli stessi comandi per creare mspVM2:

    #Create a new Managed Disks for mspVM2
az disk create \
    --resource-group $RESOURCE_GROUP_NAME \
    --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 $RESOURCE_GROUP_NAME \
    --query '[id]' \
    --output tsv)

#Create VM by attaching existing managed disks as OS
az vm create \
    --resource-group $RESOURCE_GROUP_NAME \
    --name mspVM2 \
    --assign-identity "/subscriptions/$SUBSCRIPTION/resourceGroups/$RESOURCE_GROUP_NAME/providers/Microsoft.ManagedIdentity/userAssignedIdentities/passwordless-managed-identity" \
    --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 $RESOURCE_GROUP_NAME \
    --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 su multicast. Anche se è possibile usare altri protocolli di individuazione JGroups ( ad esempio una configurazione statica (TCPPING), un database condiviso (JDBC_PING), un ping basato sul file system condiviso (FILE_PING) o TCPGOSSIP), è consigliabile usare il protocollo di individuazione file condiviso sviluppato 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=azurepingstgabc1111rg
# Define your Blob container name
export CONTAINER_NAME=azurepingcontainerabc1111rg

# Create storage account
az storage account create \
    --resource-group $RESOURCE_GROUP_NAME \
    --name ${STORAGE_ACCOUNT_NAME} \
    --location westus \
    --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. Il comando precedente per creare l'account di archiviazione potrebbe non essere ancora stato eseguito.

export STORAGE_ACCESS_KEY=$(az storage account keys list \
    --resource-group $RESOURCE_GROUP_NAME \
    --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 -i ~/.ssh/jbosseapvm 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=azurepingstgabc1111rg
export CONTAINER_NAME=azurepingcontainerabc1111rg
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:

Nota

I JBOSS_EAP_USER valori e JBOSS_EAP_PASSWORD sono necessari per configurare l'utente di gestione di JBoss 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.

Screenshot della console di gestione del controller di dominio Red Hat JBoss Enterprise Application Platform.

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 $RESOURCE_GROUP_NAME \
    --name mspVM1 \
    --show-details \
    --query publicIps | tr -d '"' )

ssh -A -i ~/.ssh/jbosseapvm azureuser@$MSPVM_PUBLIC_IP

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
scp azureuser@${DOMAIN_CONTROLLER_PRIVATE_IP}:/tmp/domain.xml /tmp/domain.xml
sudo mv /tmp/domain.xml $EAP_HOME/wildfly/domain/configuration/domain.xml
sudo chown jboss:jboss $EAP_HOME/wildfly/domain/configuration/domain.xml

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 $RESOURCE_GROUP_NAME \
    --name mspVM2 \
    --show-details \
    --query publicIps | tr -d '"'

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 in macchine virtuali di Azure, questa sezione illustra come esporre 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 $RESOURCE_GROUP_NAME \
    --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 $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)

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 $RESOURCE_GROUP_NAME \
    --name myAppGateway \
    --public-ip-address myAGPublicIPAddress \
    --location westus \
    --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.

Connettere Database di Azure per PostgreSQL server flessibile

Questa sezione illustra come creare un'istanza del server flessibile Database di Azure per PostgreSQL e configurare una connessione a PostgreSQL nel cluster Red Hat JBoss EAP.

Creare un'istanza del server flessibile Database di Azure per PostgreSQL

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

  1. Usare az postgres flexible-server create per effettuare il provisioning di un'istanza del server flessibile Database di Azure per PostgreSQL, come illustrato nell'esempio seguente:

    export DATA_BASE_USER=jboss

DB_SERVER_NAME="jbossdb$(date +%s)"
echo "DB_SERVER_NAME=${DB_SERVER_NAME}"
az postgres flexible-server create \
    --active-directory-auth Enabled \
    --resource-group $RESOURCE_GROUP_NAME \
    --name ${DB_SERVER_NAME}  \
    --location westus \
    --version 16 \
    --public-access 0.0.0.0 \
    --tier Burstable \
    --sku-name Standard_B1ms \
    --yes
objectId=$(az identity show --name passwordless-managed-identity --resource-group $RESOURCE_GROUP_NAME --query principalId -o tsv)
az postgres flexible-server ad-admin create \
  --resource-group $RESOURCE_GROUP_NAME \
  --server-name ${DB_SERVER_NAME}  \
  --display-name "passwordless-managed-identity"  \
  --object-id $objectId \
  --type ServicePrincipal

  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 flexible-server show \
    --resource-group $RESOURCE_GROUP_NAME \
    --name ${DB_SERVER_NAME} \
    --query "fullyQualifiedDomainName" \
    --output tsv)
export name=$(az postgres flexible-server show \
    --resource-group $RESOURCE_GROUP_NAME \
    --name ${DB_SERVER_NAME} \
    --query "name" \
    --output tsv)

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

  3. Usare il comando seguente per creare il database:

    az postgres flexible-server db create \
    --resource-group $RESOURCE_GROUP_NAME \
    --server-name ${DB_SERVER_NAME} \
    --database-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:

  1. Ssh per adminVM usare il comando seguente. È possibile ignorare questo passaggio se è già stata aperta una connessione.

    ssh -A -i ~/.ssh/jbosseapvm azureuser@$ADMIN_VM_PUBLIC_IP

  2. Usare i comandi seguenti per scaricare il driver JDBC in adminVM:

    # Create JDBC driver and module directory
jdbcDriverModuleDirectory="$EAP_HOME"/wildfly/modules/com/postgresql/main

sudo mkdir -p "$jdbcDriverModuleDirectory"

# Download JDBC driver and passwordless extensions

extensionJarName=azure-identity-extensions-1.1.20.jar
extensionPomName=azure-identity-extensions-1.1.20.pom
sudo curl --retry 5 -Lo ${jdbcDriverModuleDirectory}/${extensionJarName} https://repo1.maven.org/maven2/com/azure/azure-identity-extensions/1.1.20/$extensionJarName
sudo curl --retry 5 -Lo ${jdbcDriverModuleDirectory}/${extensionPomName} https://repo1.maven.org/maven2/com/azure/azure-identity-extensions/1.1.20/$extensionPomName

sudo yum install maven -y
sudo mvn dependency:copy-dependencies  -f ${jdbcDriverModuleDirectory}/${extensionPomName} -Ddest=${jdbcDriverModuleDirectory}

# Create module for JDBC driver
jdbcDriverModule=module.xml
sudo cat <<EOF >${jdbcDriverModule}
<?xml version="1.0" ?>
<module xmlns="urn:jboss:module:1.1" name="com.postgresql">
  <resources>
    <resource-root path="${extensionJarName}"/>
EOF

# Add all jars from target/dependency
for jar in ${jdbcDriverModuleDirectory}/target/dependency/*.jar; do
if [ -f "$jar" ]; then
# Extract just the filename from the path
jarname=$(basename "$jar")
echo "    <resource-root path=\"target/dependency/${jarname}\"/>" >> ${jdbcDriverModule}
fi
done

# Add the closing tags
cat <<EOF >> ${jdbcDriverModule}
</resources>
<dependencies>
<module name="javaee.api"/>
<module name="sun.jdk"/>
<module name="ibm.jdk"/>
<module name="javax.api"/>
<module name="javax.transaction.api"/>
</dependencies>
</module>
EOF

chmod 644 $jdbcDriverModule
sudo mv $jdbcDriverModule $jdbcDriverModuleDirectory/$jdbcDriverModule

  3. Usare i comandi seguenti per copiare il driver JDBC nei controller host:

    scp -rp $EAP_HOME/wildfly/modules/com/postgresql azureuser@mspvm1:/tmp/
ssh azureuser@mspvm1 "sudo mkdir -p $EAP_HOME/wildfly/modules/com/postgresql && sudo cp -rp /tmp/postgresql/* $EAP_HOME/wildfly/modules/com/postgresql && sudo rm -rf /tmp/postgresql"

scp -rp $EAP_HOME/wildfly/modules/com/postgresql azureuser@mspvm2:/tmp/
ssh azureuser@mspvm2 "sudo mkdir -p $EAP_HOME/wildfly/modules/com/postgresql && sudo cp -rp /tmp/postgresql/* $EAP_HOME/wildfly/modules/com/postgresql && sudo rm -rf /tmp/postgresql"

    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.

  1. Usare i comandi seguenti per registrare il driver JDBC:

    # Register JDBC driver
sudo -u jboss $EAP_HOME/wildfly/bin/jboss-cli.sh --connect --controller=$(hostname -I) --echo-command \
"/profile=ha/subsystem=datasources/jdbc-driver=postgresql:add(driver-name=postgresql,driver-module-name=com.postgresql,driver-xa-datasource-class-name=org.postgresql.xa.PGXADataSource)"

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.

  1. Aprire un terminale e SSH con adminVM il comando seguente:

    ssh -i ~/.ssh/jbosseapvm azureuser@$ADMIN_VM_PUBLIC_IP

  2. 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?sslmode=require&user=passwordless-managed-identity&authenticationPluginClassName=com.azure.identity.extensions.jdbc.postgresql.AzurePostgresqlAuthenticationPlugin"
export JDBC_DATA_SOURCE_NAME=dataSource-postgresql
export JDBC_JNDI_NAME=java:jboss/datasources/JavaEECafeDB

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

È stata configurata correttamente un'origine dati denominata java:jboss/datasources/JavaEECafeDB.

Distribuire l'applicazione di esempio Java EE Cafe

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

  1. Usare la procedura seguente per compilare Java EE 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 --branch 20240904 --single-branch

    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.

  2. 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.

  3. 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.

      Screenshot della scheda Red Hat JBoss Enterprise Application Platform Deployments con l'opzione di menu Carica contenuto evidenziata.

    3. Usare il selettore di file del browser per selezionare il file javaee-cafe.war.

    4. Selezionare Avanti.

    5. Accettare le impostazioni predefinite nella schermata successiva e quindi selezionare Fine.

    6. Selezionare Visualizza contenuti.

  4. Usare la procedura seguente per distribuire un'applicazione in main-server-group:

    1. In Repository di contenuti selezionare javaee-cafe.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 a quello raffigurato nello screenshot seguente:

      Screenshot dell'avviso relativo alla corretta distribuzione.

Testare la configurazione del cluster Red Hat JBoss EAP

È stato configurato il cluster JBoss EAP e l'applicazione è stata distribuita. Usare la procedura seguente per accedere all'applicazione per convalidare tutte le impostazioni:

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

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

  2. Aprire un Web browser.

  3. Passare all'applicazione con l'URL http://<gateway-public-ip-address>/javaee-cafe/. Non dimenticare la barra finale.

  4. 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 $RESOURCE_GROUP_NAME \
    --name adminVM \
    --command-id RunShellScript \
    --scripts "sudo subscription-manager unregister"

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

Usare il comando seguente per eliminare il gruppo $RESOURCE_GROUP_NAMEdi risorse :

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

Passaggi successivi

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

Esplorare JBoss EAP in Azure