Compartilhar via

Tutorial: instalar manualmente o JBoss EAP em VMs (Máquinas Virtuais) do Azure

  • Artigo

Este tutorial mostra as etapas para instalar o Red Hat JBoss Enterprise Application Platform (EAP) e configurar um cluster no modo de domínio em VMs (Máquinas Virtuais) do Azure no RHEL (Red Hat Enterprise Linux).

Neste tutorial, você aprenderá a fazer as seguintes tarefas:

  • Crie uma rede virtual personalizada e crie as VMs dentro da rede.
  • Instale o JDK desejado e o Red Hat JBoss EAP nas VMs usando a linha de comando manualmente.
  • Configure um cluster EAP do Red Hat JBoss no modo de domínio usando a interface de linha de comando (CLI).
  • Configure uma conexão de fonte de dados PostgreSQL no cluster.
  • Implemente e execute um aplicativo Java EE de amostra no cluster.
  • Exponha o aplicativo à Internet pública por meio do Gateway de Aplicativo do Azure.
  • Valide a configuração bem-sucedida.

Caso você prefira uma solução totalmente automatizada que execute todas essas etapas em seu nome em VMs do GNU/Linux, diretamente do portal do Azure, consulte Início Rápido: implantar um cluster JBoss EAP em VMs (Máquinas Virtuais) do Azure.

Se você estiver interessado em fornecer comentários ou colaborar de perto em seus cenários de migração com a equipe de engenharia que desenvolve soluções do JBoss EAP no Azure, preencha esta breve pesquisa sobre migração do JBoss EAP e inclua suas informações de contato. A equipe de gerentes de programa, arquitetos e engenheiros entrará em contato prontamente com você para iniciar uma estreita colaboração.

Observação

Este artigo contém referências ao termo servidor subordinado, um termo que a Microsoft não usa mais. Quando o termo for removido do software, também o removeremos deste artigo.

Pré-requisitos

  • Uma assinatura do Azure. Se você não tiver uma assinatura do Azure, crie uma conta gratuita antes de começar.

  • Instale a CLI do Azure versão 2.51.0 ou superior para executar comandos da CLI do Azure.

    • Quando solicitado, instale as extensões da CLI do Azure no primeiro uso. Para obter mais informações sobre extensões, confira Usar extensões com a CLI do Azure.
    • Execute az version para localizar a versão e as bibliotecas dependentes que estão instaladas. Para fazer a atualização para a versão mais recente, execute az upgrade.

  • Certifique-se de que você tenha as licenças Red Hat necessárias. Você precisa ter uma conta do Red Hat com direito do RHSM (Red Hat Subscription Management) para o Red Hat JBoss EAP. Esse direito permite que a solução totalmente automatizada (em Início Rápido: implantar um cluster JBoss EAP em VMs (Máquinas Virtuais) do Azure) instale a versão do JBoss EAP testada e certificada pelo Red Hat.

    Observação

    Se você não tiver um direito de EAP, poderá se inscrever para uma assinatura de desenvolvedor gratuita por meio da Assinatura do Red Hat Developer para pessoas físicas. Salve paralelamente os detalhes da conta, que são usados como nome de usuário do RHSM e senha do RHSM na próxima seção.

  • Se você já estiver registrado ou depois de concluir o registro, poderá localizar as credenciais necessárias (IDs de pool) usando as etapas a seguir. Essas IDs de pool também são usadas como a ID de pool RHSM com direito EAP em etapas subsequentes.

    1. Entre na sua conta do Red Hat.

    2. Na primeira vez que você entrar, será solicitado que você complete seu perfil. Dependendo do seu uso, selecione Pessoal ou Corporativo para Tipo de Conta, conforme mostrado na captura de tela a seguir:

      Captura de tela da janela da conta do Red Hat que mostra as opções de Tipo de Conta com a opção Pessoal selecionada.

    3. Abra a Assinatura do Red Hat Developer para pessoas físicas. Esse link o levará a todas as assinaturas em sua conta para a SKU apropriada.

    4. Na linha de controles na tabela Todas as assinaturas compradas, selecione Ativo.

    5. Selecione o cabeçalho da coluna classificável para Data de término até que o valor mais distante no futuro seja mostrado como a primeira linha.

    6. Selecione a primeira linha. Em seguida, copie e salve o valor após Pools Mestres de IDs de Pool.

  • Um Kit de desenvolvimento JAVA (JDK) versão 11. Neste guia, recomendamos o Build do Red Hat do OpenJDK. Verifique se a variável de ambiente JAVA_HOME está definida corretamente nos shells em que você executa os comandos.

  • Git; use git --version para testar se git funciona. Este tutorial foi testado com a versão 2.25.1.

  • Maven; use mvn -version para testar se mvn funciona. Este tutorial foi testado com a versão 3.6.3.

Preparar o ambiente

Nesta seção, você configura a infraestrutura na qual instala o JDK, o Red Hat JBoss EAP e o driver PostgreSQL Java Database Connectivity (JDBC).

Pressuposições

Este tutorial mostra como configurar um cluster Red Hat JBoss EAP no modo de domínio com um servidor de administração e dois servidores gerenciados em um total de três VMs. Para configurar o cluster, é necessário criar as seguintes três VMs do Azure:

  • Uma VM de administrador (nome da VM adminVM) é executada como o controlador de domínio.
  • Duas VMs gerenciadas (nomes da VM mspVM1 e mspVM2) são executadas como controlador de host.

Entrar no Azure

Se você ainda não o fez, entre na sua assinatura do Azure usando o comando az login e seguindo as instruções na tela.

az login

Observação

Se houver vários locatários do Azure associados às suas credenciais do Azure, você deverá especificar em qual locatário deseja entrar. Isso pode ser feito com a opção --tenant. Por exemplo, az login --tenant contoso.onmicrosoft.com.

Criar um grupo de recursos

Crie um grupo de recursos com az group create. Os nomes de grupo de recursos devem ser exclusivos globalmente em uma assinatura. Por esse motivo, considere adicionar um identificador exclusivo aos nomes que você criar que devem ser exclusivos. Uma técnica útil é usar suas iniciais seguidas da data de hoje no formato mmdd. Este exemplo cria um grupo de recursos chamado $RESOURCE_GROUP_NAME na localização 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

Criar uma rede virtual

Os recursos que compõem o cluster Red Hat JBoss EAP devem se comunicar entre si e com a Internet pública usando uma rede virtual. Para obter um guia completo sobre como planejar sua rede virtual, consulte o guia do Cloud Adoption Framework para Azure Planejar redes virtuais. Para obter mais informações, consulte Perguntas frequentes sobre a Rede Virtual do Azure.

O exemplo nesta seção cria uma rede virtual com espaço de endereço 192.168.0.0/16 e cria uma sub-rede usada para VMs.

Primeiro, crie uma rede virtual usando az network vnet create. O exemplo a seguir cria uma rede chamada myVNet:

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

Crie uma sub-rede para o Red Hat JBoss EAP usando az network vnet subnet create. O seguinte exemplo cria uma sub-rede chamada mySubnet:

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

Crie uma sub-rede para o Gateway de Aplicativo usando o comando az network vnet subnet create. O seguinte exemplo cria uma sub-rede chamada jbossVMGatewaySubnet:

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

Criar um grupo de segurança de rede e atribuir sub-redes a ele

Antes de criar VMs com IPs públicos, crie um NSG (grupo de segurança de rede) para proteger a rede virtual e as sub-redes criadas anteriormente.

Crie um grupo de segurança de rede usando az network nsg create. O seguinte exemplo cria um grupo de segurança de rede chamado mynsg:

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

Crie regras de grupo de segurança de rede usando az network nsg create. O exemplo a seguir cria uma regra de grupo de segurança de rede chamada ALLOW_APPGW e ALLOW_HTTP_ACCESS. Essas regras permitem que o Gateway de Aplicativo aceite o tráfego de entrada nas portas HTTP usadas pelo 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

Associe as sub-redes criadas anteriormente a esse grupo de segurança de rede usando az network vnet subnet update, conforme mostrado no exemplo a seguir:

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

Criar uma máquina Red Hat Enterprise Linux para administrador

Gerar chaves SSH

Use o seguinte comando para gerar chaves SSH para adminVM:

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

Criar a VM do administrador

A imagem do Marketplace que você usa para criar as VMs é RedHat:rhel-raw:86-gen2:latest. Para outras imagens, consulte Imagens do RHEL (Red Hat Enterprise Linux) disponíveis no Azure.

Observação

Você pode consultar todas as imagens disponíveis do Red Hat Enterprise Linux fornecidas pela Red Hat com o comando az vm image list, por exemplo: az vm image list --offer RHEL --publisher RedHat --output table --all. Para obter mais informações, consulte Visão geral das imagens do Red Hat Enterprise Linux.

Se você usar uma imagem diferente, talvez seja necessário instalar bibliotecas extras para habilitar a infraestrutura usada neste guia.

Crie uma VM básica, instale todas as ferramentas necessárias nela, tire um instantâneo dela e crie réplicas com base no instantâneo.

Crie uma VM usando az vm create. Você executa o Servidor de Administração nesta VM.

O exemplo a seguir cria uma Identidade Gerenciada do Azure e uma VM do Red Hat Enterprise Linux usando a autenticação 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

Instalar Red Hat JBoss EAP

Use as etapas a seguir para instalar:

  1. Use o seguinte comando para obter o IP público 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 um terminal e SSH para o adminVM usando o seguinte comando:

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

  3. Configure o firewall para portas usando o seguinte comando:

    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

    Você deve ver a palavra success após os dois primeiros comandos. Você deve ver uma saída semelhante a este exemplo após o 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

Observação

Os RHSM_USER valores e RHSM_PASSWORD são necessários para instalar o Red Hat JBoss EAP. Recomendamos que você use uma conta de serviço com permissões limitadas para acessar o Red Hat Customer Portal.

  1. Use os seguintes comandos para registrar o host admin em sua conta do 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

    Você deverá ver uma saída semelhante ao seguinte exemplo:

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

  2. Use o seguinte comando para anexar o host admin ao pool EAP do Red Hat JBoss:

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

    Observação

    Esse comando será ignorado se você estiver usando o modo Acesso a Conteúdo Simples.

  3. Use os seguintes comandos para instalar o 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

Para o segundo e terceiro comandos, você deve ver muitas linhas de saída, terminando com Complete!

  1. Use os seguintes comandos set permission e configurações de rede:

    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 um dos comandos a seguir para configurar as variáveis de 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. Saia da conexão SSH digitando exit.

Criar máquinas para servidores gerenciados

Você instalou o Red Hat JBoss EAP no adminVM, que é executado como o servidor do controlador de domínio. Você ainda precisa preparar as máquinas para executar os dois servidores do controlador de host. Em seguida, você cria um instantâneo de adminVM e prepara máquinas para dois servidores gerenciados mspVM1 e mspVM2.

Esta seção apresenta uma abordagem para preparar máquinas com o instantâneo do adminVM. Retorne ao terminal em que a CLI do Azure está conectada e use as seguintes etapas:

  1. Use o seguinte comando para interromper adminVM:

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

  2. Use az snapshot create para tirar um instantâneo do disco do sistema operacional adminVM, conforme mostrado no exemplo a seguir:

    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 o seguinte comando para iniciar o adminVM:

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

  4. Use as seguintes etapas para criar mspVM1:

    1. Primeiro, crie um disco gerenciado para mspVM1 com 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. Em seguida, use os seguintes comandos para criar a VM mspVM1, anexando o disco do sistema operacional 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. Você criou o mspVM1 com o Red Hat JBoss EAP instalado. Como a VM foi criada a partir de um instantâneo do disco do sistema operacional adminVM, as duas VMs têm o mesmo nome de host. Use az vm run-command invoke para alterar o nome do host para o valor mspVM1:

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

      Quando o comando for concluído com êxito, você verá uma saída semelhante ao exemplo a seguir:

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

  5. Use os mesmos comandos para criar 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 os seguintes comandos para obter e mostrar os endereços IP privados, que você usa nas seções 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}"

Agora, todas as três máquinas estão prontas. Em seguida, você configura um cluster Red Hat JBoss EAP no modo de domínio gerenciado.

Configurar domínio gerenciado e cluster

Configure o cluster com a replicação de sessão habilitada. Para obter mais informações, consulte Replicação de sessão.

Para habilitar a replicação de sessão, use o Red Hat JBoss EAP High Availability para o cluster. O Microsoft Azure não oferece suporte para protocolos de descoberta de JGroups baseados em multicast. Embora você possa usar outros protocolos de descoberta do JGroups (como uma configuração estática (TCPPING), um banco de dados compartilhado (JDBC_PING), ping baseado em sistema de arquivos compartilhado (FILE_PING) ou TCPGOSSIP), recomendamos que você use o protocolo de descoberta de arquivo compartilhado desenvolvido para o Azure: AZURE_PING. Para obter mais informações, consulte Usar o JBoss EAP High Availability no Microsoft Azure.

Criar uma conta de armazenamento do Azure contêiner de blobs para AZURE_PING

Utilize os seguintes comandos para criar uma conta de armazenamento e um contentor 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

Em seguida, recupere a chave da conta de armazenamento para uso posterior usando o comando a seguir. Se você vir um erro, aguarde alguns minutos e tente novamente. Talvez o comando anterior para criar a conta de armazenamento ainda não tenha sido feito.

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}

Você deve ver o seguinte resultado:

{
  "created": true
}

Configurar o controlador de domínio (nó de administrador)

Este tutorial usa os comandos da CLI de gerenciamento do Red Hat JBoss EAP para configurar o controlador de domínio. Para obter mais informações, consulte Guia da CLI de gerenciamento.

As etapas a seguir definem a configuração do controlador de domínio no adminVM. Use SSH para se conectar ao adminVM como usuário do azureuser . Lembre-se de que o endereço IP público de adminVM foi capturado anteriormente na variável de ambiente ADMIN_VM_PUBLIC_IP.

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

Primeiro, use os seguintes comandos para configurar o perfil HA e JGroups usando o 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

A última Stanza da saída deve ser semelhante ao exemplo a seguir. Se não, solucione o 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

Em seguida, use os seguintes comandos para configurar o servidor JBoss e configurar o serviço EAP:

Observação

Os JBOSS_EAP_USER valores e JBOSS_EAP_PASSWORD são necessários para configurar o usuário de gerenciamento do 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'

O resultado deverá ser semelhante ao seguinte exemplo:

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 fim, use os seguintes comandos para iniciar o serviço 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

O resultado deverá ser semelhante ao seguinte exemplo:

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

Digite q para sair do pager. Saia da conexão SSH digitando exit.

Depois de iniciar o serviço Red Hat JBoss EAP, você pode acessar o console de gerenciamento por meio de http://$ADMIN_VM_PUBLIC_IP:9990 no seu navegador da Web. Entre com o nome de usuário jbossadmin e senha Secret123456 configurados.

Captura de tela do console de gerenciamento do controlador de domínio do Red Hat JBoss Enterprise Application Platform.

Selecione a guia Runtime. No painel de navegação, selecione Topologia. Você pode ver que, por enquanto, seu cluster contém apenas um controlador de domínio:

Configurar controladores de host (nós de trabalho)

Use SSH para se conectar ao mspVM1 como usuário do azureuser. Obtenha o endereço IP público da VM com o seguinte comando:

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

Use os seguintes comandos para configurar o controlador de host em 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 os seguintes comandos para aplicar alterações do controlador de 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})"

A última Stanza da saída deve ser semelhante ao exemplo a seguir. Se não, solucione o 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

Em seguida, use os seguintes comandos para configurar o servidor JBoss e configurar o serviço 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

O resultado deverá ser semelhante ao seguinte exemplo:

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

Digite q para sair do pager. Saia da conexão SSH digitando exit.

Use SSH para se conectar ao mspVM2 como usuário do azureuser. Obtenha o endereço IP público da VM com o seguinte comando:

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

Repita as etapas anteriores em mspVM2 e saia da conexão SSH digitando exit.

Depois que dois controladores de host estiverem conectados ao adminVM, você poderá ver a topologia do cluster, conforme mostrado na captura de tela a seguir:

Expor o cluster EAP do Red Hat JBoss com o Gateway de Aplicativo do Azure

Agora que você criou o cluster em VMs do Azure, esta seção orienta você a expor o JBoss EAP à Internet com o Gateway de Aplicativo do Azure.

Criar o Gateway de Aplicativo do Azure

Para expor o Red Hat JBoss EAP à Internet, é necessário um endereço IP público. Crie o endereço IP público e associe um gateway de aplicativo do Azure a ele. Use az network public-ip create para criá-lo, conforme mostrado no exemplo a seguir:

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

Em seguida, adicione os servidores de back-end ao pool de back-end do Gateway de Aplicativo. Consulte endereços IP de back-end usando os comandos a seguir. Você só tem os controladores de host (nós de trabalho) configurados como servidores de 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)

Em seguida, crie um Gateway de Aplicativo do Azure. O exemplo a seguir cria um gateway de aplicativo com controladores de host no pool de back-end padrão:

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}

Observação

Este exemplo configura o acesso simples aos servidores Red Hat JBoss EAP com HTTP. Se você quiser acesso seguro, configure a terminação TLS/SSL seguindo as instruções em TLS de ponta a ponta com Gateway de Aplicativo.

Este exemplo expõe os controladores de host na porta 8080. Você implanta um aplicativo de exemplo com uma conexão de banco de dados no cluster em etapas posteriores.

Conectar-se ao Servidor Flexível do Banco de Dados do Azure para PostgreSQL

Esta seção mostra como criar uma instância do Servidor Flexível do Banco de Dados do Azure para PostgreSQL e configurar uma conexão com o PostgreSQL no cluster Red Hat JBoss EAP.

Criar uma instância de Servidor Flexível do Banco de Dados do Azure para PostgreSQL

Use as etapas a seguir para criar a instância do banco de dados:

  1. Use az postgres flexible-server create para provisionar uma instância do Servidor Flexível do Banco de Dados do Azure para PostgreSQL, conforme mostrado no exemplo a seguir:

    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 os seguintes comandos para permitir o acesso dos serviços do 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 o comando a seguir para criar o banco de dados:

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

Instalar o driver

Use as etapas a seguir para instalar o driver JDBC com a CLI de gerenciamento do JBoss:

  1. SSH para adminVM usando o comando a seguir. Você pode pular esta etapa se já tiver uma conexão aberta.

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

  2. Use os seguintes comandos para baixar o driver JDBC no 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 os seguintes comandos para copiar o driver JDBC para os controladores de 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"

    O log do servidor está localizado em mspVM1 e mspVM2 em /var/opt/rh/eap7/lib/wildfly/domain/servers/mspvm1-server0/log/server.log. Se a implantação falhar, examine esse arquivo de log e resolva o problema antes de continuar.

  1. Use os seguintes comandos para registrar o 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)"

Configurar a conexão de banco de dados para o cluster Red Hat JBoss EAP

Você iniciou o servidor de banco de dados, obteve o ID de recurso necessário e instalou o driver JDBC. Em seguida, as etapas nesta seção mostram como usar a CLI do JBoss para configurar uma conexão de fonte de dados com a instância do PostgreSQL que você criou anteriormente.

  1. Abra um terminal e SSH para adminVM usando o seguinte comando:

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

  2. Crie a fonte de dados usando os seguintes 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} "

Você configurou com êxito uma fonte de dados chamada java:jboss/datasources/JavaEECafeDB.

Implantar o aplicativo de amostra Java EE Cafe

Use as etapas a seguir para implantar o aplicativo de amostra Java EE Cafe no cluster Red Hat JBoss EAP:

  1. Use as etapas a seguir para criar o Java EE Cafe. Estas etapas pressupõem que você tenha um ambiente local com o Git e o Maven instalados:

    1. Use o seguinte comando para clonar o código-fonte do GitHub:

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

    2. Use o seguinte comando para compilar o código fonte:

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

      Este comando cria o arquivo eap-coffee-app/target/javaee-cafe.war. Você carrega este arquivo na próxima etapa.

  2. Abra um navegador da Web e vá para o console de gerenciamento em http://<adminVM-public-IP>:9990, em seguida, entre com nome de usuário jbossadmin e senha Secret123456.

  3. Use as etapas a seguir para fazer upload do javaee-cafe.war para o Repositório de conteúdo:

    1. Na guia Implantações do console de gerenciamento do Red Hat JBoss EAP, selecione Repositório de Conteúdo no painel de navegação.

    2. Selecione o botão Adicionar e selecione Carregar conteúdo.

      Captura de tela da guia Red Hat JBoss Enterprise Application Platform Deployments com a opção de menu Carregar conteúdo destacada.

    3. Use o seletor de arquivos do navegador para selecionar o arquivo javaee-cafe.war.

    4. Selecione Avançar.

    5. Aceite os padrões na próxima tela e selecione Concluir.

    6. Selecione Exibir conteúdo.

  4. Use as seguintes etapas para implantar um aplicativo no main-server-group:

    1. Em Repositório de Conteúdo, selecione javaee-cafe.war.

    2. No menu suspenso, selecione Implantar.

    3. Selecione main-server-group como o grupo de servidores para implantar javaee-cafe.war.

    4. Selecione Implantar para iniciar a implantação. Você deverá ver uma página semelhante à seguinte captura de tela:

      Captura de tela do aviso de implantação bem-sucedida.

Testar a configuração do cluster do Red Hat JBoss EAP

Você configurou o cluster JBoss EAP e implantou o aplicativo nele. Use as seguintes etapas para acessar o aplicativo para validar todas as configurações:

  1. Use o seguinte comando para obter o endereço IP público do Gateway de Aplicativo do Azure:

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

  2. Abra um navegador da Web.

  3. Navegue até o aplicativo com a URL http://<gateway-public-ip-address>/javaee-cafe/. Não se esqueça da barra final.

  4. Tente adicionar e remover cafés.

Limpar os recursos

Para evitar cobranças do Azure, limpe recursos desnecessários. Quando você não precisar mais do cluster Red Hat JBoss EAP implantado em uma VM do Azure, cancele o registro dos servidores Red Hat JBoss EAP e remova os recursos do Azure.

Use os seguintes comandos para cancelar o registro dos servidores e VMs do Red Hat JBoss EAP do gerenciamento de assinaturas do 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 o seguinte comando para excluir o grupo de recursos $RESOURCE_GROUP_NAME:

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

Próximas etapas

Continue a explorar as opções para executar o JBoss EAP no Azure.

Explorar o JBoss EAP no Azure