Partilhar via

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

  • 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 nas Máquinas Virtuais (VMs) do Azure, no Red Hat Enterprise Linux (RHEL).

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

  • Crie uma rede virtual personalizada e crie as VMs dentro da rede.
  • Instale o JDK e o Red Hat JBoss EAP desejados nas VMs usando a linha de comando manualmente.
  • Configure um cluster Red Hat JBoss EAP 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 exemplo no cluster.
  • Exponha o aplicativo à Internet pública por meio do Gateway de Aplicativo do Azure.
  • Valide a configuração bem-sucedida.

Se você preferir uma solução totalmente automatizada que execute todas essas etapas em seu nome em VMs GNU/Linux, diretamente do portal do Azure, consulte Guia de início rápido: implantar um cluster EAP JBoss em máquinas virtuais (VMs) do Azure.

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

Nota

Este artigo poderá conter referências ao termo slave (secundário), um termo que a Microsoft já não utiliza. Quando o termo for removido do software, iremos removê-lo deste artigo.

Pré-requisitos

  • Uma subscrição do Azure. Se não tiver uma subscrição 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 lhe for pedido, instale as extensões do CLI do Azure durante a primeira utilização. Para obter mais informações sobre as extensões, veja Utilizar extensões com o CLI do Azure.
    • Execute o comando az version para localizar a versão e as bibliotecas dependentes instaladas. Para atualizar para a versão mais recente, execute o comando az upgrade.

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

    Nota

    Se você não tiver um direito EAP, poderá se inscrever para uma assinatura de desenvolvedor gratuita por meio da Red Hat Developer Subscription for Individuals. Salve de lado os detalhes da conta, que é usado como o nome de usuário RHSM e senha 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. Esses IDs de Pool também são usados como o ID de Pool RHSM com direito EAP nas etapas subsequentes.

    1. Faça login na sua conta Red Hat.

    2. Na primeira vez que iniciar sessão, ser-lhe-á pedido que complete o 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 Red Hat que mostra as opções Tipo de conta com Pessoal selecionado.

    3. Abra a Red Hat Developer Subscription para pessoas físicas. Este link leva você a todas as assinaturas em sua conta para o SKU apropriado.

    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 de lado o valor a seguir aos Pools Mestres das IDs de Pool.

  • Um Java Development Kit (JDK), versão 11. Neste guia, recomendamos o Red Hat Build do OpenJDK. Certifique-se de que sua JAVA_HOME variável de ambiente esteja definida corretamente nos shells nos quais 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 JDBC (PostgreSQL Java Database Connectivity).

Suposições

Este tutorial configura 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, você precisa criar as três VMs do Azure a seguir:

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

Iniciar sessão no Azure

Se ainda não o fez, inicie sessão na sua subscrição do Azure utilizando o comando az login e seguindo as instruções no ecrã.

az login

Nota

Se você tiver vários locatários do Azure associados às suas credenciais do Azure, deverá especificar em qual locatário deseja entrar. Você pode fazer isso com a --tenant opção. 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 grupos de recursos devem ser globalmente exclusivos dentro de uma assinatura. Por esse motivo, considere antecipar algum identificador exclusivo para quaisquer nomes criados que devam ser exclusivos. Uma técnica útil é usar suas iniciais seguidas da data de hoje no mmdd formato. Este exemplo cria um grupo de recursos nomeado $RESOURCE_GROUP_NAME no westus local:

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 para planejar sua rede virtual, consulte o guia do Cloud Adoption Framework for Azure Plan virtual networks. 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 192.168.0.0/16 de endereço 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 cluster Red Hat JBoss EAP usando az network vnet subnet create. O exemplo a seguir 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 Application Gateway usando az network vnet subnet create. O exemplo a seguir 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 exemplo a seguir 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 rule create. O exemplo a seguir cria regras de grupo de segurança de rede denominadas ALLOW_APPGW e ALLOW_HTTP_ACCESS. Essas regras permitem que o App Gateway aceite 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 este 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 admin

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

Nota

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 com az vm create. Executar 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

Instale o Red Hat JBoss EAP

Use as seguintes etapas 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 ao exemplo a seguir após o terceiro 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

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

  1. Use os seguintes comandos para registrar o host administrador 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ê deve ver uma saída semelhante ao exemplo a seguir:

    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}

    Nota

    Este comando será ignorado se estiver a utilizar o modo de Acesso Simples a Conteúdos.

  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 definir permissão 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 os seguintes comandos 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 máquinas para executar os dois servidores de controlador host. Em seguida, você cria um instantâneo e adminVM prepara máquinas para dois servidores mspVM1 gerenciados e mspVM2.

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

  1. Use o seguinte comando para parar adminVM:

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

  2. Use az snapshot create para tirar um instantâneo do adminVM disco do sistema operacional, 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 adminVMo :

    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 VM mspVM1, anexando o disco mspVM1_OsDisk_1do sistema operacional:

      #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 mspVM1 com o Red Hat JBoss EAP instalado. Como a VM foi criada a partir de um instantâneo do adminVM disco do sistema operacional, 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 em 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, as três máquinas estão prontas. Em seguida, configure 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 suporta protocolos de descoberta JGroups baseados em multicast. Embora você possa usar outros protocolos de descoberta 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), é altamente recomendável usar o protocolo de descoberta de arquivos compartilhados desenvolvido para o Azure: AZURE_PING. Para obter mais informações, consulte Usando a alta disponibilidade do JBoss EAP no Microsoft Azure.

Criar conta de armazenamento do Azure e contêiner de Blob para AZURE_PING

Use os seguintes comandos para criar uma conta de armazenamento e um contêiner de 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 vir um erro, aguarde alguns minutos e tente novamente. O comando anterior para criar a conta de armazenamento pode ainda não ter 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}

Deverá ver o seguinte resultado:

{
  "created": true
}

Configurar controlador de domínio (nó admin)

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 configuram a configuração do controlador de domínio no adminVM. Use SSH para se conectar ao adminVM como o azureuser usuário. Lembre-se de que o endereço IP público de foi capturado adminVM anteriormente na ADMIN_VM_PUBLIC_IP variável de ambiente.

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

Primeiro, use os seguintes comandos para configurar o perfil HA e JGroups usando o AZURE_PING protocolo:

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 estrofe de saída deve ser semelhante ao exemplo a seguir. Se isso não acontecer, solucione e resolva 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:

Nota

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á ter um aspeto 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'

Finalmente, 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á ter um aspeto 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 através http://$ADMIN_VM_PUBLIC_IP:9990 do seu navegador da web. Inicie sessão com o nome jbossadmin de utilizador e palavra-passe Secret123456configurados.

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

Selecione a guia Tempo de execução . No painel de navegação, selecione Topologia. Você deve 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 como mspVM1 o azureuser usuário. 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 host no 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 as alterações do controlador 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 estrofe de saída deve ser semelhante ao exemplo a seguir. Se isso não acontecer, solucione e resolva 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á ter um aspeto 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 como mspVM2 o azureuser usuário. 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 e, em mspVM2seguida, 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:

Exponha o cluster Red Hat JBoss EAP com o Azure Application Gateway

Agora que você criou o cluster em VMs do Azure, esta seção o orienta pela exposição do JBoss EAP à Internet com o Azure Application Gateway.

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 back-end ao pool de back-end do Application Gateway. 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}

Nota

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 o Application Gateway.

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

Conectar o Banco de Dados do Azure ao Servidor Flexível PostgreSQL

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

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

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

  1. Use az postgres flexible-server create para provisionar um Banco de Dados do Azure para instância do Servidor Flexível 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 seguinte comando 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 driver

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

  1. SSH para adminVM usando o seguinte comando. Pode ignorar este passo se já tiver uma ligaçã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 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 do 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 criada anteriormente.

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

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

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

Implementar aplicativo de exemplo Java EE Cafe

Use as seguintes etapas para implantar o aplicativo de exemplo Java EE Cafe no cluster Red Hat JBoss EAP:

  1. Use as etapas a seguir para construir 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 criar 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-café.war. Você carrega este arquivo na próxima etapa.

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

  3. Use as seguintes etapas para carregar o javaee-café.war no Repositório de conteúdo:

    1. Na guia Deployments do console de gerenciamento do Red Hat JBoss EAP, selecione Content Repository no painel de navegação.

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

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

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

    4. Selecione Seguinte.

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

    6. Selecione Ver conteúdo.

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

    1. No Repositório de conteúdo, selecione javaee-café.war.

    2. No menu suspenso, selecione Implantar.

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

    4. Selecione Implantar para iniciar a implantação. Você verá um aviso semelhante à seguinte captura de tela:

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

Testar a configuração do cluster 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 browser.

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

  4. Tente adicionar e remover cafés.

Clean up resources (Limpar recursos)

Para evitar cobranças do Azure, você deve limpar recursos desnecessários. Quando 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 Red Hat JBoss EAP do gerenciamento de assinaturas 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 $RESOURCE_GROUP_NAMEde recursos :

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

Próximos passos

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

Explore o JBoss EAP no Azure