Compartir a través de

Tutorial: Instalación manual de JBoss EAP en máquinas virtuales (VM) de Azure

  • Artículo

En este tutorial se describen los pasos para instalar Red Hat JBoss Enterprise Application Platform (EAP) y configurar un clúster en modo de dominio en máquinas virtuales (VM) de Azure en Red Hat Enterprise Linux (RHEL).

En este tutorial, aprenderá las siguientes tareas:

  • Cree una red virtual personalizada y cree las máquinas virtuales dentro de la red.
  • Instale el JDK deseado y Red Hat JBoss EAP en las máquinas virtuales mediante la línea de comandos de forma manual.
  • Configure un clúster de Red Hat JBoss EAP en modo de dominio mediante la interfaz de la línea de comandos (CLI).
  • Configure una conexión de origen de datos de PostgreSQL en el clúster.
  • Implemente y ejecute una aplicación de Java EE de ejemplo en el clúster.
  • Exponga la aplicación en la red pública de Internet a través de Azure Application Gateway.
  • Valide la configuración correcta.

Si prefiere una solución totalmente automatizada que realice todos estos pasos en su nombre en máquinas virtuales de GNU/Linux, directamente en Azure Portal, consulte Inicio rápido: Implementación de un clúster de JBoss EAP en máquinas virtuales (VM) de Azure.

Si está interesado en proporcionar comentarios o trabajar estrechamente en sus escenarios de migración con el equipo de ingeniería que desarrolla JBoss EAP en soluciones de Azure, rellene esta breve Encuesta sobre la migración de JBoss EAP e incluya la información de contacto. El equipo de administradores de programas, arquitectos e ingenieros se pondrá en contacto rápidamente con usted para iniciar una estrecha colaboración.

Nota:

Este artículo contiene referencias al término esclavo, un término que Microsoft ya no usa. Cuando se elimine el término del software, se eliminará también de este artículo.

Requisitos previos

  • Suscripción a Azure. Si no tiene una suscripción a Azure, cree una cuenta gratuita antes de empezar.

  • Instale la versión 2.51.0 o posterior de la CLI de Azure para ejecutar comandos de la CLI de Azure.

    • Cuando se le solicite, instale las extensiones de la CLI de Azure la primera vez que la use. Para más información, consulte Uso de extensiones con la CLI de Azure.
    • Ejecute az version para buscar cuál es la versión y las bibliotecas dependientes que están instaladas. Para realizar la actualización a la versión más reciente, ejecute az upgrade.

  • Asegúrese de que tiene las licencias de Red Hat necesarias. Debe tener una cuenta de Red Hat con derecho de Red Hat Subscription Management (RHSM) para Red Hat JBoss EAP. Este derecho permite que la solución totalmente automatizada (en Inicio rápido: Implementación de un clúster de JBoss EAP en máquinas virtuales de Azure (VM)) instale la versión de JBoss EAP probada y certificada por Red Hat.

    Nota:

    Si no tiene ningún derecho de EAP, puede registrarse para obtener una suscripción gratuita para desarrolladores a través de la Suscripción para desarrolladores de Red Hat para usuarios. Guarde aparte los detalles de la cuenta, que se utilizan como nombre de usuario de RHSM y contraseña de RHSM en la siguiente sección.

  • Si ya está registrado, o después de completar el registro, puede buscar las credenciales necesarias (Identificadores de grupo) siguiendo los pasos siguientes. Estos Identificadores de grupo también sirven como Identificador de grupo de RHSM con derechos de EAP en pasos posteriores.

    1. Inicie sesión en su cuenta de Red Hat.

    2. La primera vez que inicie sesión, se le pedirá que complete el perfil. En función del uso, seleccione Personal o Corporativo en Tipo de cuenta, tal como se ve en la captura de pantalla siguiente:

      Captura de pantalla de la ventana de la cuenta de Red Hat, donde ven las opciones Tipo de cuenta con la opción Personal seleccionada.

    3. Abra Suscripción para desarrolladores de Red Hat para usuarios. Este vínculo le lleva a todas las suscripciones de su cuenta para la SKU adecuada.

    4. En la fila de controles de la tabla Todas las suscripciones compradas, seleccione Activa.

    5. Seleccione el encabezado de la columna ordenable para Fecha de finalización hasta que el valor más lejano en el futuro salga en la primera fila.

    6. Seleccione la primera fila. Luego, copie y guarde el valor que sigue a Grupos principales en Identificadores de grupo.

  • Un Kit de desarrollo de Java (JDK), versión 11. En esta guía, recomendamos Red Hat Build de OpenJDK. Asegúrese de que la variable de entorno JAVA_HOME se ha establecido correctamente en los shells en los que ejecuta los comandos.

  • Git; use git --version para probar si funciona git. Este tutorial se probó con la versión 2.25.1.

  • Maven; use mvn -version para probar si funciona mvn. Este tutorial se probó con la versión 3.6.3.

Preparación del entorno

En esta sección, configurará la infraestructura en la que instalará JDK, Red Hat JBoss EAP y el controlador de Java Database Connectivity de (JDBC) de PostgreSQL.

Supuestos

En este tutorial se configura un clúster de Red Hat JBoss EAP en modo de dominio con un servidor de administración y dos servidores administrados en un total de tres máquinas virtuales. Para configurar el clúster, debe crear las tres máquinas virtuales de Azure siguientes:

  • Una máquina virtual de administración (nombre de máquina virtual adminVM) se ejecuta como controlador de dominio.
  • Dos máquinas virtuales administradas (nombres de máquina virtual mspVM1 y mspVM2) se ejecutan como controlador de host.

Inicio de sesión en Azure

Si no lo ha hecho todavía, inicie sesión en la suscripción de Azure con el comando az login y siga las instrucciones que salen pantalla.

az login

Nota:

Si hay varios inquilinos de Azure asociados a sus credenciales de Azure, debe indicar en qué inquilino desea iniciar sesión. Puede hacerlo con la opción --tenant. Por ejemplo, az login --tenant contoso.onmicrosoft.com.

Crear un grupo de recursos

Cree un grupo de recursos con az group create. Los nombres de los grupos de recursos deben ser únicos globalmente dentro de una suscripción. Por este motivo, plantéese anteponer algún identificador único a los nombres que cree que deban ser únicos. Una técnica útil es usar sus iniciales seguidas de la fecha de hoy en formato mmdd. En este ejemplo se crea un grupo de recursos denominado $RESOURCE_GROUP_NAME en la ubicación westus:

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

Creación de una red virtual

Los recursos que componen el clúster de Red Hat JBoss EAP deben comunicarse entre sí y la red pública de Internet mediante una red virtual. Para tener una guía completa para planificar la red virtual, consulte la guía de Cloud Adoption Framework para Azure Planificación de redes virtuales. Para obtener más información, consulte Preguntas más frecuentes sobre Azure Virtual Network.

En el ejemplo de esta sección se crea una red virtual con el espacio de direcciones 192.168.0.0/16 y se crea una subred que se usa para las máquinas virtuales.

Primero, use az network vnet create para crear una red virtual. En el ejemplo siguiente se crea una red denominada myVNet:

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

Cree una subred para el clúster de Red Hat JBoss EAP mediante az network vnet subnet create. En el ejemplo siguiente se crea una subred denominada mySubnet:

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

Cree una subred para Application Gateway mediante az network vnet subnet create. En el ejemplo siguiente se crea una subred denominada jbossVMGatewaySubnet:

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

Crear un grupo de seguridad de red y asignar subredes

Antes de crear máquinas virtuales con direcciones IP públicas, cree un grupo de seguridad de red (NSG) para proteger la red virtual y las subredes creadas anteriormente.

Utilice az network nsg create para crear un grupo de seguridad de red. En el ejemplo siguiente, se crea un grupo de seguridad de red denominado mynsg:

az network nsg create \
    --resource-group $RESOURCE_GROUP_NAME \
    --name mynsg

Use az network nsg rule create para crear reglas de grupo de seguridad de red. En el ejemplo siguiente, se crean las reglas de un grupo de seguridad de red denominadas ALLOW_APPGW y ALLOW_HTTP_ACCESS. Estas reglas permiten que App Gateway acepte el tráfico entrante en los puertos HTTP que usa 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

Asocie las subredes creadas anteriormente a este grupo de seguridad de red mediante az network vnet subnet update, tal como se muestra en el ejemplo siguiente:

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

Crear una máquina de Red Hat Enterprise Linux para la administración

Generación de claves SSH

Use el comando siguiente para generar claves SSH para adminVM:

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

Crear la máquina virtual de administración

La imagen del marketplace que se usa para crear las máquinas virtuales es RedHat:rhel-raw:86-gen2:latest. Para ver otras imágenes, consulte Imágenes de Red Hat Enterprise Linux (RHEL) disponibles en Azure.

Nota:

Puede consultar todas las imágenes de Red Hat Enterprise Linux disponibles facilitadas por Red Hat con el comando az vm image list; por ejemplo: az vm image list --offer RHEL --publisher RedHat --output table --all. Para obtener más información, consulte Información general sobre las imágenes de Red Hat Enterprise Linux.

Si usa una imagen diferente, es posible que tenga que instalar bibliotecas adicionales para habilitar la infraestructura que se usa en esta guía.

Cree una máquina virtual básica, instale todas las herramientas necesarias en ella, tome una instantánea de ella y después cree réplicas basadas en la instantánea.

Cree una máquina virtual mediante az vm create. Ejecute el servidor de administración en esta máquina virtual.

En el ejemplo siguiente se crea una identidad administrada de Azure y una máquina virtual Red Hat Enterprise Linux mediante la autenticación 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

Instalación de Red Hat JBoss EAP

Consulte el procedimiento siguiente para la instalación:

  1. Use el comando siguiente para obtener la IP pública de adminVM:

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

  2. Abra un terminal y SSH en la adminVM mediante el siguiente comando:

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

  3. Configure el firewall de los puertos mediante el comando siguiente:

    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

    Debería ver la palabra success después de los dos primeros comandos. Debería aparecer un resultado similar al siguiente ejemplo después del tercer 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:

Los RHSM_USER valores y RHSM_PASSWORD son necesarios para instalar Red Hat JBoss EAP. Se recomienda usar una cuenta de servicio con permisos limitados para acceder al Portal de clientes de Red Hat.

  1. Use los siguientes comandos para registrar el host de administración en la cuenta de 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

    Debería ver una salida similar al ejemplo siguiente:

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

  2. Use el siguiente comando para adjuntar el host de administración al grupo de Red Hat JBoss EAP:

    sudo subscription-manager attach --pool=${EAP_POOL}

    Nota:

    Este comando se ignora si usa el modo Acceso simple a contenido.

  3. Use los siguientes comandos para instalar 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

En el segundo y tercer comando, deberían salir muchas líneas como resultado, que terminan con Complete!

  1. Use los siguientes comandos para crear y ajustar los permisos y configuraciones de red:

    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. Use los siguientes comandos para configurar las variables de entorno:

    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. Salga de la conexión con SSH escribiendo exit.

Crear máquinas para servidores administrados

Ha instalado Red Hat JBoss EAP en adminVM, que se ejecuta como servidor de controlador de dominio. Aún le queda por preparar las máquinas para ejecutar los dos servidores de controlador de host. Luego, creará una instantánea de adminVM y preparará las máquinas para dos servidores administrados, mspVM1 y mspVM2.

En esta sección se incluye un método para preparar máquinas con la instantánea de adminVM. Vuelva al terminal que tenga la CLI de Azure iniciada y siga estos pasos:

  1. Utilice el siguiente comando para detener adminVM:

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

  2. Use az snapshot create para tomar una instantánea del disco del sistema operativo adminVM, tal como se muestra en el ejemplo siguiente:

    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. Use el comando siguiente para iniciar adminVM:

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

  4. Siga estos pasos para crear mspVM1:

    1. En primer lugar, cree un disco administrado en 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. Luego, use los siguientes comandos para crear la máquina virtual mspVM1, incluyendo el disco del sistema operativo mspVM1_OsDisk_1:

      #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. Ha creado mspVM1 con Red Hat JBoss EAP instalado. Como la máquina virtual se creó a partir de una instantánea del disco del sistema operativo adminVM, las dos máquinas virtuales tienen el mismo nombre de host. Use az vm run-command invoke para cambiar el nombre de host al valor mspVM1:

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

      Cuando el comando se complete correctamente, verá un resultado similar al que se ve en el siguiente ejemplo:

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

  5. Utilice los mismos comandos para crear 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"

Use los siguientes comandos para obtener y mostrar las direcciones IP privadas que se usan en secciones posteriores:

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

Tras esto, las tres máquinas estarán listas. A continuación, configurará un clúster de Red Hat JBoss EAP en modo de dominio administrado.

Configurar un dominio administrado y un clúster

Configure el clúster con la replicación de sesión habilitada. Para obtener más información, consulte Replicación de sesión.

Para habilitar la replicación de sesión, use la alta disponibilidad de Red Hat JBoss EAP en el clúster. Microsoft Azure no admite protocolos de detección de JGroups basados en multidifusión. Aunque puede usar otros protocolos de detección de JGroups (como una configuración estática (TCPPING), una base de datos compartida (JDBC_PING), un ping basado en el sistema de archivos compartidos (FILE_PING) o TCPGOSSIP, recomendamos usar el protocolo de detección de archivos compartidos desarrollado para Azure: AZURE_PING. Para obtener más información, consulte Uso de la alta disponibilidad de JBoss EAP en Microsoft Azure.

Crear una cuenta de almacenamiento de Azure y un contenedor de blobs para AZURE_PING

Use el siguiente comando para crear una cuenta de almacenamiento y un contenedor de blobs:

# 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

Después, recupere la clave de la cuenta de almacenamiento para usarla más adelante mediante el siguiente comando. Si le sale un error, espere unos minutos e inténtelo de nuevo. Es posible que el comando anterior para crear la cuenta de almacenamiento aún no se haya aplicado.

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}

Debería ver la salida siguiente:

{
  "created": true
}

Configurar el controlador de dominio (nodo de administración)

En este tutorial se usan los comandos de la CLI de administración de Red Hat JBoss EAP para configurar el controlador de dominio. Para obtener más información, consulte Guía sobre la CLI de administración.

En el procedimiento siguiente se crea la configuración del controlador de dominio en adminVM. Use SSH para conectarse a adminVM como usuario azureuser. Recuerde que la dirección IP pública de adminVM se ha capturado anteriormente en la variable de entorno ADMIN_VM_PUBLIC_IP.

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

En primer lugar, use los siguientes comandos para configurar el perfil de alta disponibilidad y JGroups mediante el protocolo AZURE_PING:

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

La última parte del resultado debería verse similar a la del ejemplo siguiente. Si no es así, subsane este problema antes de continuar.

[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

A continuación, use los siguientes comandos para configurar el servidor de JBoss y configurar el servicio de EAP:

Nota:

Los JBOSS_EAP_USER valores y JBOSS_EAP_PASSWORD son necesarios para configurar el usuario de administración de 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'

La salida debería tener un aspecto similar al ejemplo siguiente:

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'

Por último, utilice los siguientes comandos para iniciar el servicio de 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

La salida debería tener un aspecto similar al ejemplo siguiente:

● 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).

Escriba q para salir del paginador. Salga de la conexión con SSH escribiendo exit.

Después de iniciar el servicio de Red Hat JBoss EAP, puede acceder a la consola de administración mediante http://$ADMIN_VM_PUBLIC_IP:9990 en el explorador web. Inicie sesión con el nombre de usuario jbossadmin y la contraseña Secret123456 configurados.

Captura de pantalla de la consola de administración del controlador de dominio de Red Hat JBoss Enterprise Application Platform.

Seleccione la pestaña Runtime. En el panel de navegación, seleccione Topología. Debería ver que por ahora el clúster solo tiene un controlador de dominio:

Configurar controladores de host (nodos de trabajo)

Use SSH para conectarse a mspVM1 como usuario azureuser. Obtenga la dirección IP pública de la máquina virtual con el comando siguiente:

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

Utilice los siguientes comandos para configurar el controlador de host en 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

Use los comandos siguientes para aplicar los cambios del controlador de host en 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})"

La última parte del resultado debería verse similar a la del ejemplo siguiente. Si no es así, subsane este problema antes de continuar.

[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

A continuación, use los siguientes comandos para configurar el servidor de JBoss y el servicio de 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

La salida debería tener un aspecto similar al ejemplo siguiente:

● 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).

Escriba q para salir del paginador. Salga de la conexión con SSH escribiendo exit.

Use SSH para conectarse a mspVM2 como usuario azureuser. Obtenga la dirección IP pública de la máquina virtual con el comando siguiente:

az vm show \
    --resource-group $RESOURCE_GROUP_NAME \
    --name mspVM2 \
    --show-details \
    --query publicIps | tr -d '"'

Repita los pasos anteriores en mspVM2 y luego salga de la conexión con SSH escribiendo exit.

Después de haber conectado dos controladores de host a adminVM, debería poder ver la topología del clúster, tal como se ve en la captura de pantalla siguiente:

Exponer el clúster de Red Hat JBoss EAP con Azure Application Gateway

Ahora que ha creado el clúster en máquinas virtuales de Azure, esta sección le ayudará a exponer JBoss EAP en Internet con Azure Application Gateway.

Crear la instancia de Azure Application Gateway

Para exponer Red Hat JBoss EAP en Internet, se necesita una dirección IP pública. Cree la dirección IP pública y después asocie una puerta de enlace de Azure Application a ella. Use az network public-ip create para crearla, tal como se muestra en el ejemplo siguiente:

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

Seguidamente, agregue los servidores back-end al grupo de back-end de Application Gateway. Consulte las direcciones IP de back-end mediante los siguientes comandos. Solo tiene los controladores de host (nodos de trabajo) configurados como servidores 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)

Después, cree una instancia de Azure Application Gateway. En el ejemplo siguiente se crea una puerta de enlace de aplicaciones con controladores de host en el grupo de back-end predeterminado:

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:

En este ejemplo se configura un acceso sencillo a los servidores de Red Hat JBoss EAP con HTTP. Si quiere tener un acceso seguro, configure la terminación de TLS/SSL siguiendo las instrucciones TLS de un extremo a otro con Application Gateway.

En este ejemplo se exponen los controladores de host en el puerto 8080. Más adelante, implementará una aplicación de ejemplo con una conexión de la base de datos al clúster.

Conexión con servidor flexible de Azure Database for PostrgreSQL

En esta sección se explica cómo crear una instancia de servidor flexible de Azure Database for PostgreSQL y configurar una conexión con PostgreSQL en el clúster de Red Hat JBoss EAP.

Creación de una instancia de servidor flexible de Azure Database for PostgreSQL

Realice los siguientes pasos para crear la instancia de la base de datos:

  1. Use az postgres flexible-server create para aprovisionar una instancia de servidor flexible de Azure Database for PostgreSQL, tal como se ve en el ejemplo siguiente:

    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. Use los siguientes comandos para permitir el acceso a través de los servicios de 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. Use el siguiente comando para crear la base de datos:

    az postgres flexible-server db create \
    --resource-group $RESOURCE_GROUP_NAME \
    --server-name ${DB_SERVER_NAME} \
    --database-name testdb

Instalación del controlador

Siga estos pasos para instalar el controlador JDBC con la CLI de administración de JBoss:

  1. Use SSH en adminVM mediante el comando siguiente. Puede saltarse este paso si ya tiene una conexión abierta.

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

  2. Use los siguientes comandos para descargar el controlador JDBC en 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. Use los siguientes comandos para copiar el controlador JDBC en los controladores 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"

    El registro del servidor se encuentra en mspVM1 y mspVM2 en /var/opt/rh/eap7/lib/wildfly/domain/servers/mspvm1-server0/log/server.log. Si se produce un error en la implementación, examine el archivo de registro y resuelva el problema antes de continuar.

  1. Use los siguientes comandos para registrar el controlador 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)"

Configuración de la conexión de la base de datos en el clúster de Red Hat JBoss EAP

Ha iniciado el servidor de base de datos, ha obtenido el ID de recurso necesario y ha instalado el controlador JDBC. A continuación, en los pasos de esta sección sabrá cómo usar la CLI de JBoss para configurar una conexión de origen de datos con la instancia de PostgreSQL creada anteriormente.

  1. Abra un terminal y SSH en adminVM mediante el siguiente comando:

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

  2. Cree el origen de datos con los siguientes comandos:

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

Tras esto, habrá configurado correctamente un origen de datos denominado java:jboss/datasources/JavaEECafeDB.

Implementación de la aplicación de ejemplo Java EE Cafe

Utilice los siguientes pasos para implementar la aplicación de ejemplo Java EE Cafe en el clúster Red Hat JBoss EAP:

  1. Realice los siguientes pasos para crear Java EE Cafe. En estos pasos se supone que tiene un entorno local con Git y Maven instalados:

    1. Use el siguiente comando para clonar el código fuente de GitHub:

      git clone https://github.com/Azure/rhel-jboss-templates.git --branch 20240904 --single-branch

    2. Use el siguiente comando para compilar el código fuente:

      mvn clean install --file rhel-jboss-templates/eap-coffee-app/pom.xml

      Con este comando se crea el archivo eap-coffee-app/target/javaee-cafe.war. Cargará este archivo en el paso siguiente.

  2. Abra un explorador web y vaya a la consola de administración en http://<adminVM-public-IP>:9990 y luego inicie sesión con el nombre de usuario jbossadmin y la contraseña Secret123456.

  3. Siga estos pasos para cargar javaee-cafe.war en el Repositorio de contenido:

    1. En la pestaña Deployments (Implementaciones) de la consola de administración de Red Hat JBoss EAP, seleccione Content Repository (Repositorio de contenido) en el panel de navegación.

    2. Seleccione el botón Add (Añadir) y luego Upload Content (Cargar contenido).

      Captura de pantalla de la pestaña Deployments (Implementaciones( de la Red Hat JBoss Enterprise Application Platform con la opción de menú Upload Content (Cargar contenido) resaltada.

    3. Use el selector de archivos del explorador para seleccionar el archivo javaee-cafe.war.

    4. Seleccione Siguiente.

    5. Acepte los valores predeterminados en la siguiente pantalla y seleccione Finalizar.

    6. Seleccione Ver contenido.

  4. Siga estos pasos para implementar una aplicación en main-server-group:

    1. En Repositorio de contenido, seleccione javaee-cafe.war.

    2. En el menú desplegable, seleccione Deploy (Implementar).

    3. Seleccione main-server-group como grupo de servidores para implementar javaee-cafe.war.

    4. Seleccione Implementar para iniciar la implementación. Debería ver un aviso similar a la recorte de pantalla siguiente:

      Recorte de pantalla del aviso de implementación correcta.

Probar la configuración del clúster de Red Hat JBoss EAP

Ha configurado el clúster de JBoss EAP e implementado la aplicación en él. Realice los siguientes pasos para acceder a la aplicación para validar todos los ajustes:

  1. Use el comando siguiente para obtener la dirección IP pública de la Azure Application Gateway:

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

  2. Abra un explorador web.

  3. Vaya a la aplicación con la dirección URL http://<gateway-public-ip-address>/javaee-cafe/. No olvide la barra diagonal final.

  4. Intente agregar y quitar cafés.

Limpieza de recursos

Para evitar los cargos de Azure, se recomienda limpiar los recursos que no sean necesarios. Cuando ya no necesite el clúster de Red Hat JBoss EAP implementado en una máquina virtual de Azure, anule el registro de los servidores de Red Hat JBoss EAP y quite los recursos de Azure.

Utilice los siguientes comandos para anular el registro de los servidores y las máquinas virtuales de Red Hat JBoss EAP de la administración de suscripciones de 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"

Use el comando siguiente para eliminar el grupo de recursos $RESOURCE_GROUP_NAME:

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

Pasos siguientes

Siga descubriendo más opciones para ejecutar JBoss EAP en Azure.

Exploración de JBoss EAP en Azure