Tutorial: Instalar o Red Hat JBoss EAP em Máquinas Virtuais do Azure manualmente

Artigo
02/05/2024

Este tutorial mostra as etapas para instalar o Red Hat JBoss 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 o JBoss EAP Server em uma máquina virtual do Azure usando o portal do Azure.

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

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 mencionada anteriormente (em Implantar o JBoss EAP Server em uma máquina virtual do Azure usando o portal 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:
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. Isso garante que apenas assinaturas ativas sejam mostradas.
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 JDK Java, 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.

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.

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 abc1110rg no eastus local:

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

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 abc1110rg \
    --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 abc1110rg \
    --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 abc1110rg \
    --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 abc1110rg \
    --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 abc1110rg \
    --nsg-name mynsg \
    --name ALLOW_APPGW \
    --protocol Tcp \
    --destination-port-ranges 65200-65535 \
    --source-address-prefix GatewayManager \
    --destination-address-prefix '*' \
    --access Allow \
    --priority 500 \
    --direction Inbound

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

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 abc1110rg \
    --vnet-name myVNet \
    --name mySubnet \
    --network-security-group mynsg

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

Criar uma máquina Red Hat Enterprise Linux para administrador

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 VM Red Hat Enterprise Linux usando o par de nome de usuário e senha para a autenticação. Se desejar, você pode usar a autenticação TLS/SSL.

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

Instale o OpenJDK 11 e o Red Hat JBoss EAP 7.4

Use as seguintes etapas para instalar:

Use o seguinte comando para obter o IP público de adminVM:

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

Abra um terminal e SSH para o adminVM usando o seguinte comando:
```
ssh azureuser@$ADMIN_VM_PUBLIC_IP
```
Forneça Secret123456 como senha.

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

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

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.
Use o seguinte comando para instalar o OpenJDK 11:
```
sudo yum install java-11-openjdk -y
```
Você deve ver muitas linhas de saída, terminando com Complete!

Use os seguintes comandos para instalar o Red Hat JBoss EAP 7.4:

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

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

Use os seguintes comandos definir permissão e configurações TCP:

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

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

Saia da conexão SSH digitando exit.

Criar máquinas para servidores gerenciados

Você instalou o OpenJDK 11 e o Red Hat JBoss EAP 7.4 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:

Use o seguinte comando para parar adminVM:

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

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 abc1110rg \
    --name adminVM \
    --query storageProfile.osDisk.managedDisk.id \
    --output tsv)
az snapshot create \
    --resource-group abc1110rg \
    --name myAdminOSDiskSnapshot \
    --source ${ADMIN_OS_DISK_ID}

Use o seguinte comando para iniciar adminVMo :

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

Use as seguintes etapas para criar mspVM1:

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 abc1110rg \
    --query '[id]' \
    --output tsv)

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

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 abc1110rg \
    --query '[id]' \
    --output tsv)

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

Você criou mspVM1 com o OpenJDK 11 e o Red Hat JBoss EAP 7.4 instalados. 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 abc1110rg \
    --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
        }
    ]
}

Use os mesmos comandos para criar mspVM2:

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

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

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

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

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 UDP. 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 especificamente 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=azurepingstgabc1110rg
# Define your Blob container name
export CONTAINER_NAME=azurepingcontainerabc1110rg

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

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 erro pode ser causado pelo comando anterior para criar a conta de armazenamento não totalmente concluída.

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

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

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 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=azurepingstgabc1110rg
export CONTAINER_NAME=azurepingcontainerabc1110rg
export STORAGE_ACCESS_KEY=<the-value-from-before-you-connected-with-SSH>


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

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

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:

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

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 abc1110rg \
    --name mspVM1 \
    --show-details \
    --query publicIps)

ssh azureuser@$MSPVM_PUBLIC_IP

Lembre-se que a senha é a mesma de antes, já que mspVM1 é simplesmente um clone de adminVM.

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

É-lhe pedida a palavra-passe para a ligação. Neste exemplo, a senha é Secret123456.

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 abc1110rg \
    --name mspVM2 \
    --show-details \
    --query publicIps

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 Red Hat JBoss EAP em máquinas virtuais do Azure, esta seção o orienta pelo processo de exposição do Red Hat 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 abc1110rg \
    --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 abc1110rg \
    --name mspVM1 \
    --query networkProfile.networkInterfaces'[0]'.id \
    --output tsv)
export MSPVM1_IP=$(az network nic show \
    --ids ${MSPVM1_NIC_ID} \
    --query ipConfigurations'[0]'.privateIPAddress \
    --output tsv)
export MSPVM2_NIC_ID=$(az vm show \
    --resource-group abc1110rg \
    --name mspVM2 \
    --query networkProfile.networkInterfaces'[0]'.id \
    --output tsv)
export MSPVM2_IP=$(az network nic show \
    --ids ${MSPVM2_NIC_ID} \
    --query ipConfigurations'[0]'.privateIPAddress \
    --output tsv)

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 abc1110rg \
    --name myAppGateway \
    --public-ip-address myAGPublicIPAddress \
    --location eastus \
    --capacity 2 \
    --http-settings-port 8080 \
    --http-settings-protocol Http \
    --frontend-port 80 \
    --sku Standard_V2 \
    --subnet jbossVMGatewaySubnet \
    --vnet-name myVNet \
    --priority 1001 \
    --servers ${MSPVM1_IP} ${MSPVM2_IP}

Nota

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 para PostgreSQL

Esta seção mostra como criar uma instância do PostgreSQL no Azure e configurar uma conexão com o PostgreSQL em seu cluster Red Hat JBoss EAP.

Criar um Banco de Dados do Azure para instância do PostgreSQL

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

Use az postgres server create para provisionar uma instância do PostgreSQL no Azure, conforme mostrado no exemplo a seguir:

export DATA_BASE_USER=jboss
export DATA_BASE_PASSWORD=Secret123456

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

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

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

Use o seguinte comando para criar o banco de dados:

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

Instalar driver

Use as etapas a seguir para instalar o driver JDBC com a CLI de gerenciamento do JBoss. Para obter mais informações sobre drivers JDBC no Red Hat JBoss EAP, consulte Instalando um driver JDBC como uma implantação JAR.

SSH para adminVM usando o seguinte comando. Pode ignorar este passo se já tiver uma ligação aberta.
```
ssh azureuser@$ADMIN_VM_PUBLIC_IP
```
Use os comandos a seguir para baixar o driver JDBC. Aqui, você usa postgresql-42.5.2.jar. Para obter mais informações sobre os locais de download do driver JDBC, consulte Locais de download do driver JDBC fornecidos pela Red Hat.
```
jdbcDriverName=postgresql-42.5.2.jar
sudo curl --retry 5 -Lo /tmp/${jdbcDriverName} https://jdbc.postgresql.org/download/${jdbcDriverName}
```
Implante o driver JDBC usando o seguinte comando JBoss CLI:
```
sudo -u jboss $EAP_HOME/wildfly/bin/jboss-cli.sh --connect --controller=$(hostname -I) --echo-command \
"deploy /tmp/${jdbcDriverName} --server-groups=main-server-group"
```
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.

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.

Abra um terminal e SSH para adminVM usando o seguinte comando:
```
ssh azureuser@$ADMIN_VM_PUBLIC_IP
```

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
export DATA_BASE_USER=jboss@<database-server-name>
export JDBC_DATA_SOURCE_NAME=dataSource-postgresql
export JDBC_JNDI_NAME=java:jboss/datasources/JavaEECafeDB
export DATA_BASE_PASSWORD=Secret123456
export JDBC_DRIVER_NAME=postgresql-42.5.2.jar

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

Após essas etapas, 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:

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
```
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.
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.
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.
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.
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:

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

Agora você concluiu de configurar o cluster Red Hat JBoss EAP e implementar o aplicativo Java EE nele. Use as seguintes etapas para acessar o aplicativo para validar todas as configurações:

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 abc1110rg \
    --name myAGPublicIPAddress \
    --query '[ipAddress]' \
    --output tsv

Abra um browser.
Navegue até o aplicativo com a URL http://<gateway-public-ip-address>/javaee-cafe/. Não se esqueça da barra rasteira.
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 abc1110rg \
    --name adminVM \
    --command-id RunShellScript \
    --scripts "sudo subscription-manager unregister"

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

Use o seguinte comando para excluir o grupo abc1110rgde recursos :

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

Próximos passos

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

Saiba mais sobre o JBoss EAP no Azure

Share via

Tutorial: Instalar o Red Hat JBoss EAP em Máquinas Virtuais do Azure manualmente

Pré-requisitos

Preparar o ambiente

Suposições

Criar um grupo de recursos

Criar uma rede virtual

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

Criar uma máquina Red Hat Enterprise Linux para administrador

Criar a VM admin

Instale o OpenJDK 11 e o Red Hat JBoss EAP 7.4

Criar máquinas para servidores gerenciados

Configurar domínio gerenciado e cluster

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

Configurar controlador de domínio (nó admin)

Configurar controladores de host (nós de trabalho)

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

Criar o Gateway de Aplicativo do Azure

Conectar o Banco de Dados do Azure para PostgreSQL

Criar um Banco de Dados do Azure para instância do PostgreSQL

Instalar driver

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

Implementar aplicativo de exemplo Java EE Cafe

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

Clean up resources (Limpar recursos)

Próximos passos

Comentários

Comentários

Recursos adicionais

Share via

Tutorial: Instalar o Red Hat JBoss EAP em Máquinas Virtuais do Azure manualmente

Pré-requisitos

Preparar o ambiente

Suposições

Iniciar sessão no Azure

Criar um grupo de recursos

Criar uma rede virtual

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

Criar uma máquina Red Hat Enterprise Linux para administrador

Criar a VM admin

Instale o OpenJDK 11 e o Red Hat JBoss EAP 7.4

Criar máquinas para servidores gerenciados

Configurar domínio gerenciado e cluster

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

Configurar controlador de domínio (nó admin)

Configurar controladores de host (nós de trabalho)

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

Criar o Gateway de Aplicativo do Azure

Conectar o Banco de Dados do Azure para PostgreSQL

Criar um Banco de Dados do Azure para instância do PostgreSQL

Instalar driver

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

Implementar aplicativo de exemplo Java EE Cafe

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

Clean up resources (Limpar recursos)

Próximos passos

Comentários

Comentários

Recursos adicionais