Freigeben über

Tutorial: JBoss EAP auf Azure Virtual Machines (VMs) manuell installieren

  • Artikel

Dieses Tutorial zeigt Ihnen die Schritte zur Installation von Red Hat JBoss Enterprise Application Platform (EAP) und zur Konfiguration eines Clusters im Domänenmodus auf Azure Virtual Machines (VMs), auf Red Hat Enterprise Linux (RHEL).

In diesem Tutorial lernen Sie Folgendes:

  • Erstellen Sie ein angepasstes virtuelles Netzwerk und erstellen Sie die VMs innerhalb des Netzwerks.
  • Installieren Sie das gewünschte JDK und Red Hat JBoss EAP auf den VMs manuell über die Kommandozeile.
  • Konfigurieren Sie einen Red Hat JBoss EAP Cluster im Domänen-Modus über die Befehlszeilenschnittstelle (CLI).
  • Konfigurieren Sie eine PostgreSQL-Datenquellenverbindung im Cluster.
  • Stellen Sie eine Java EE-Beispielanwendung bereit und führen Sie sie in dem Cluster aus.
  • Stellen Sie die Anwendung über Azure Application Gateway dem öffentlichen Internet zur Verfügung.
  • Validieren Sie die erfolgreiche Konfiguration.

Wenn Sie eine vollautomatische Lösung bevorzugen, die alle diese Schritte in Ihrem Namen auf GNU/Linux VMs direkt vom Azure-Portal aus durchführt, lesen Sie Schnellstart: Bereitstellen eines JBoss EAP-Clusters auf Azure Virtual Machines (VMs).

Wenn Sie an Feedback oder daran interessiert sind, eng mit dem Entwicklungsteam, das die JBoss EAP-Lösungen für Azure entwickelt, an Ihren Migrationsszenarien zu arbeiten, füllen Sie diese kurze Umfrage zur JBoss EAP-Migration aus und geben Sie Ihre Kontaktinformationen an. Das Team aus Programmmanagern, Architekten und Ingenieuren wird sich umgehend mit Ihnen in Verbindung setzen, um eine enge Zusammenarbeit zu initiieren.

Hinweis

Dieser Artikel enthält Verweise auf den Begriff Slave, einen Begriff, den Microsoft nicht mehr verwendet. Sobald der Begriff aus der Software entfernt wurde, wird er auch aus diesem Artikel entfernt.

Voraussetzungen

  • Ein Azure-Abonnement. Wenn Sie kein Azure-Abonnement besitzen, erstellen Sie ein kostenloses Konto, bevor Sie beginnen.

  • Installieren Sie Azure CLI Version 2.51.0 oder höher, um Azure CLI-Befehle auszuführen.

    • Installieren Sie die Azure CLI-Erweiterungen bei der ersten Verwendung, wenn Sie dazu aufgefordert werden. Weitere Informationen zu Erweiterungen finden Sie unter Verwenden von Erweiterungen mit der Azure CLI.
    • Führen Sie az version aus, um die installierte Version und die abhängigen Bibliotheken zu ermitteln. Führen Sie az upgrade aus, um das Upgrade auf die aktuelle Version durchzuführen.

  • Stellen Sie sicher, dass Sie über die erforderlichen Red Hat-Lizenzen verfügen. Sie benötigen ein Red Hat-Konto mit Red Hat Subscription Management (RHSM)-Berechtigung für Red Hat JBoss EAP. Mit dieser Berechtigung kann die vollautomatische Lösung (in Schnellstart: Bereitstellen eines JBoss EAP Clusters auf Azure Virtual Machines (VMs)) die von Red Hat getestete und zertifizierte JBoss EAP-Version bereitstellen.

    Hinweis

    Wenn Sie keine EAP-Berechtigung haben, können Sie sich über Red Hat Entwicklerabonnements für Einzelpersonen für ein kostenloses Entwicklerabonnement registrieren. Speichern Sie die Kontodaten, die im nächsten Abschnitt als RHSM-Benutzername und RHSM-Kennwort verwendet werden.

  • Wenn Sie bereits registriert sind oder nachdem Sie die Registrierung abgeschlossen haben, können Sie die erforderlichen Anmeldeinformationen (Pool-IDs) mit Hilfe der folgenden Schritte ausfindig machen. Diese Pool-IDs werden auch als RHSM-Pool-ID mit EAP-Berechtigung in den nachfolgenden Schritten verwendet.

    1. Melden Sie sich bei Ihrem Red Hat-Konto an.

    2. Wenn Sie sich zum ersten Mal anmelden, werden Sie aufgefordert, Ihr Profil zu vervollständigen. Abhängig von Ihrer Verwendung wählen Sie entweder Personal oder Corporate für Kontotyp, wie im folgenden Screenshot gezeigt:

      Screenshot des Red Hat-Konto-Fensters, das die Optionen für den Kontotyp mit der Auswahl Personal anzeigt.

    3. Öffnen Sie Red Hat Developer Subscription for Individuals. Über diesen Link gelangen Sie zu allen Abonnements in Ihrem Konto für die entsprechende SKU.

    4. In der Zeile der Steuerelemente unter der Tabelle All purchased Subscription wählen Sie Active.

    5. Wählen Sie die sortierbare Spaltenüberschrift für End Date, bis der am weitesten in der Zukunft liegende Wert als erste Zeile angezeigt wird.

    6. Wählen Sie die erste Zeile aus. Kopieren Sie dann den Wert nach Master Pools aus Pool IDs und speichern Sie ihn ab.

  • Java Development Kit (JDK), Version 11. In dieser Anleitung empfehlen wir Red Hat Build von OpenJDK. Stellen Sie sicher, dass die Umgebungsvariable JAVA_HOME in den Shells korrekt festgelegt ist, in denen Sie die Befehle ausführen.

  • Git; verwenden Sie git --version, um zu testen, ob git funktioniert. Dieses Tutorial wurde mit der Version 2.25.1 getestet.

  • Maven; verwenden Sie mvn -version, um zu testen, ob mvn funktioniert. Dieses Tutorial wurde mit der Version 3.6.3 getestet.

Vorbereiten der Umgebung

In diesem Abschnitt richten Sie die Infrastruktur ein, in der Sie das JDK, Red Hat JBoss EAP und den PostgreSQL Java Database Connectivity (JDBC)-Treiber installieren.

Annahmen

In diesem Tutorial wird ein Red Hat JBoss EAP-Cluster im Domänenmodus mit einem Administrationsserver und zwei verwalteten Servern auf insgesamt drei VMs konfiguriert. Um den Cluster zu konfigurieren, müssen Sie die folgenden drei Azure-VMs erstellen:

  • Eine Admin-VM (VM-Name adminVM) wird als Domänencontroller ausgeführt.
  • Zwei verwaltete VMs (VM-Namen mspVM1 und mspVM2) werden als Host-Controller ausgeführt.

Anmelden bei Azure

Falls Sie dies noch nicht getan haben, melden Sie sich mit dem Befehl az login bei Ihrem Azure-Abonnement an, und folgen Sie den Anweisungen auf dem Bildschirm.

az login

Hinweis

Wenn Sie mehrere Azure-Mandanten mit Ihren Anmeldeinformationen verknüpft haben, müssen Sie angeben, bei welchem Mandanten Sie sich anmelden möchten. Sie können dies mit der Option --tenant tun. Beispiel: az login --tenant contoso.onmicrosoft.com.

Erstellen einer Ressourcengruppe

Erstellen Sie mit az group create eine Ressourcengruppe. Ressourcengruppennamen müssen innerhalb eines Abonnements global eindeutig sein. Aus diesem Grund sollten Sie jedem Namen, den Sie erstellen und der eindeutig sein muss, einen eindeutigen Bezeichner voranstellen. Es hat sich bewährt, Ihre Initialen gefolgt vom heutigen Datum im Format mmdd zu verwenden. In diesem Beispiel wird eine Ressourcengruppe mit dem Namen $RESOURCE_GROUP_NAME am Standort westus erstellt:

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

Erstellen eines virtuellen Netzwerks

Die Ressourcen, aus denen Ihr Red Hat JBoss EAP-Cluster besteht, müssen über ein virtuelles Netzwerk miteinander und mit dem öffentlichen Internet kommunizieren. Eine vollständige Anleitung zur Planung Ihres virtuellen Netzwerks finden Sie in der Anleitung zum Cloud Adoption Framework für Azure Planen virtueller Netzwerke. Weitere Informationen finden Sie unter Azure Virtual Network: häufig gestellte Fragen.

Das Beispiel in diesem Abschnitt erstellt ein virtuelles Netzwerk mit dem Adressraum 192.168.0.0/16 und erstellt ein Subnetz, das für VMs verwendet wird.

Erstellen Sie zunächst ein virtuelles Netzwerk, indem Sie az network vnet create verwenden. Das folgende Beispiel erstellt ein Netzwerk mit dem Namen myVNet:

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

Erstellen Sie ein Subnetz für den Red Hat JBoss EAP-Cluster, indem Sie az network vnet subnet create verwenden. Im folgenden Beispiel wird ein Subnetz namens mySubnet erstellt:

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

Erstellen Sie ein Subnetz für Application Gateway mit az network vnet subnet create. Im folgenden Beispiel wird ein Subnetz namens jbossVMGatewaySubnet erstellt:

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

Erstellen Sie eine Netzwerksicherheitsgruppe und weisen Sie ihr Subnetze zu

Bevor Sie VMs mit öffentlichen IPs erstellen, erstellen Sie eine Netzwerksicherheitsgruppe (NSG), um das virtuelle Netzwerk und die zuvor erstellten Subnetze zu sichern.

Erstellen Sie mit az network nsg create eine Netzwerksicherheitsgruppe. Im folgenden Beispiel wird eine Netzwerksicherheitsgruppe namens mynsg erstellt:

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

Erstellen Sie die Regeln für die Netzwerksicherheitsgruppe mit az network nsg rule create. Das folgende Beispiel erstellt Regeln für die Netzwerksicherheitsgruppe mit den Namen ALLOW_APPGW und ALLOW_HTTP_ACCESS. Diese Regeln lassen die Möglichkeit zu, dass App Gateway eingehenden Datenverkehr über die von Red Hat JBoss EAP verwendeten HTTP-Ports akzeptiert:

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

Verknüpfen Sie die zuvor erstellten Subnetze mit dieser Netzwerksicherheitsgruppe, indem Sie az network vnet subnet update verwenden, wie im folgenden Beispiel gezeigt:

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

Erstellen Sie eine Red Hat Enterprise Linux Maschine für Admin

Generieren von SSH-Schlüsseln

Verwenden Sie den folgenden Befehl, um SSH-Schlüssel für adminVM:

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

Erstellen der Admin-VM

Das Marketplace-Image, das Sie zum Erstellen der VMs verwenden, ist RedHat:rhel-raw:86-gen2:latest. Weitere Images finden Sie unter Red Hat Enterprise Linux (RHEL)-Images in Azure verfügbar.

Hinweis

Sie können alle verfügbaren Red Hat Enterprise Linux-Images, die von Red Hat bereitgestellt werden, mit dem Befehl az vm image list abfragen - zum Beispiel: az vm image list --offer RHEL --publisher RedHat --output table --all. Weitere Informationen finden Sie unter Übersicht über Red Hat Enterprise Linux-Images.

Wenn Sie ein anderes Image verwenden, müssen Sie möglicherweise zusätzliche Bibliotheken installieren, um die in dieser Anleitung verwendete Infrastruktur zu aktivieren.

Erstellen Sie eine Basis-VM, installieren Sie alle erforderlichen Tools darauf, erstellen Sie einen Snapshot davon und erstellen Sie dann Repliken auf der Grundlage des Snapshots.

Erstellen Sie einen virtuellen Computer mit az vm create. Sie führen den Administrationsserver auf dieser VM aus.

Im folgenden Beispiel wird eine azure Managed Identity und eine Red Hat Enterprise Linux-VM mit TLS/SSL-Authentifizierung erstellt.

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

Installieren von Red Hat JBoss EAP

Führen Sie die folgenden Schritte zur Installation aus:

  1. Verwenden Sie den folgenden Befehl, um die öffentliche IP von adminVM abzurufen:

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

  2. Öffnen Sie ein Terminal ,und verbinden Sie sich per SSH mit dem adminVM mit folgendem Befehl:

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

  3. Konfigurieren Sie die Firewall für die Ports mit dem folgenden Befehl:

    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

    Nach den ersten beiden Befehlen sollten Sie das Wort success sehen. Nach dem dritten Befehl sollten Sie eine Ausgabe ähnlich dem folgenden Beispiel erhalten:

    # 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

Hinweis

Die RHSM_USER Werte sind RHSM_PASSWORD erforderlich, um Red Hat JBoss EAP zu installieren. Es wird empfohlen, ein Dienstkonto mit eingeschränkten Berechtigungen für den Zugriff auf das Red Hat-Kundenportal zu verwenden.

  1. Verwenden Sie die folgenden Befehle, um den Admin-Host in Ihrem Red Hat Subscription Management (RHSM)-Konto zu registrieren:

    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

    Die Ausgabe sollte etwa folgendem Beispiel entsprechen:

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

  2. Verwenden Sie den folgenden Befehl, um den Admin Host mit dem Red Hat JBoss EAP-Pool zu verbinden:

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

    Hinweis

    Dieser Befehl wird ignoriert, wenn Sie den Modus Simple Content Access verwenden.

  3. Verwenden Sie die folgenden Befehle, um Red Hat JBoss EAP zu installieren:

    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

Für den zweiten und dritten Befehl sollten Sie viele Zeilen der Ausgabe sehen, die mit Complete! enden

  1. Verwenden Sie die folgenden Befehle, um Berechtigungen und Netzwerkkonfigurationen festzulegen:

    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. Verwenden Sie die folgenden Befehle, um die Umgebungsvariablen zu konfigurieren:

    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. Beenden Sie die SSH-Verbindung durch Eingabe von exit.

Erstellen von Maschinen für verwaltete Server

Sie haben Red Hat JBoss EAP auf adminVM installiert, der als Domänencontroller-Server ausgeführt wird. Sie müssen noch Maschinen vorbereiten, auf denen die beiden Host-Controller-Server ausgeführt werden. Als nächstes erstellen Sie einen Snapshot von adminVM und bereiten Maschinen für zwei verwaltete Server, mspVM1 und mspVM2, vor.

In diesem Abschnitt wird ein Ansatz zur Vorbereitung von Maschinen mit dem Snapshot von adminVM vorgestellt. Kehren Sie zu Ihrem Terminal zurück, in dem Azure CLI angemeldet ist, und führen Sie dann die folgenden Schritte aus:

  1. Verwenden Sie den folgenden Befehl, um adminVM anzuhalten:

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

  2. Verwenden Sie az snapshot create, um einen Snapshot des Datenträgers adminVM zu erstellen, wie im folgenden Beispiel gezeigt:

    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. Verwenden Sie den folgenden Befehl, um adminVM zu starten:

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

  4. Verwenden Sie die folgenden Schritte, um mspVM1 zu erstellen:

    1. Erstellen Sie zunächst einen verwalteten Datenträger für mspVM1 mit 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. Als nächstes erstellen Sie mit den folgenden Befehlen VM mspVM1, wobei Sie den Datenträger für das Betriebssystem mspVM1_OsDisk_1 anhängen:

      #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. Sie haben Red Hat JBoss EAP installiert und mspVM1 erstellt. Da die VM aus einem Snapshot des Datenträgers adminVM erstellt wurde, haben die beiden VMs denselben Hostnamen. Verwenden Sie az vm run-command invoke, um den Hostnamen auf den Wert mspVM1 zu ändern:

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

      Wenn der Befehl erfolgreich abgeschlossen wurde, sehen Sie eine Ausgabe ähnlich dem folgenden Beispiel:

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

  5. Verwenden Sie die gleichen Befehle, um mspVM2 zu erstellen:

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

Verwenden Sie die folgenden Befehle, um die privaten IP-Adressen abzurufen und anzuzeigen, die Sie in späteren Abschnitten verwenden:

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

Jetzt sind alle drei Maschinen bereit. Als nächstes konfigurieren Sie einen Red Hat JBoss EAP-Cluster im verwalteten Domänen-Modus.

Konfigurieren der verwalteten Domäne und des Clusters

Konfigurieren Sie den Cluster mit aktivierter Sitzungsreplikation. Weitere Informationen finden Sie unter Sitzungsreplikation.

Um die Sitzungsreplikation zu aktivieren, verwenden Sie Red Hat JBoss EAP High Availability für den Cluster. Microsoft Azure unterstützt keine JGroups-Erkennungsprotokolle, die auf Multicast beruhen. Sie können zwar auch andere JGroups-Erkennungsprotokolle verwenden (z. B. eine statische Konfiguration (TCPPING), eine gemeinsam genutzte Datenbank (JDBC_PING), ein auf einem gemeinsam genutzten Dateisystem basierendes Ping (FILE_PING) oder TCPGOSSIP), wir empfehlen jedoch dringend, das für Azure entwickelte Protokoll zur gemeinsamen Dateierkennung zu verwenden: AZURE_PING. Weitere Informationen finden Sie unter Verwendung von JBoss EAP High Availability in Microsoft Azure.

Erstellen eines Azure Storage-Kontos und eines Blob-Containers für AZURE_PING

Verwenden Sie die folgenden Befehle, um ein Speicherkonto und einen Blob-Container zu erstellen:

# 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

Rufen Sie dann den Schlüssel des Speicherkontos zur späteren Verwendung mit dem folgenden Befehl ab. Wenn Sie eine Fehlermeldung erhalten, warten Sie ein paar Minuten und versuchen Sie es erneut. Der vorherige Befehl zum Erstellen des Speicherkontos ist möglicherweise noch nicht ausgeführt worden.

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}

Die folgende Ausgabe wird angezeigt.

{
  "created": true
}

Domänencontroller (Admin-Knoten) konfigurieren

In diesem Tutorial werden die Red Hat JBoss EAP Management CLI-Befehle verwendet, um den Domänencontroller zu konfigurieren. Weitere Informationen finden Sie in der Management CLI Anleitung.

Mit den folgenden Schritten richten Sie die Konfiguration des Domänencontrollers auf adminVM ein. Verwenden Sie SSH, um sich als Benutzer*innen adminVM mit azureuser zu verbinden. Erinnern Sie sich, dass die öffentliche IP-Adresse von adminVM zuvor in der Umgebungsvariablen ADMIN_VM_PUBLIC_IP erfasst wurde.

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

Verwenden Sie zunächst die folgenden Befehle, um das HA-Profil und die JGroups unter Verwendung des AZURE_PING-Protokolls zu konfigurieren:

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

Die letzte Zeile der Ausgabe sollte ähnlich wie im folgenden Beispiel aussehen. Ist dies nicht der Fall, beheben Sie das Problem, bevor Sie fortfahren.

[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

Verwenden Sie dann die folgenden Befehle, um den JBoss-Server zu konfigurieren und den EAP-Dienst einzurichten:

Hinweis

Die JBOSS_EAP_USER Werte JBOSS_EAP_PASSWORD sind erforderlich, um den JBoss-EAP-Verwaltungsbenutzer zu konfigurieren.

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

Die Ausgabe sollte in etwa wie im folgenden Beispiel aussehen:

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'

Verwenden Sie schließlich die folgenden Befehle, um den EAP-Dienst zu starten:

# 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

Die Ausgabe sollte in etwa wie im folgenden Beispiel aussehen:

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

Geben Sie q ein, um den Pager zu beenden. Beenden Sie die SSH-Verbindung durch Eingabe von exit.

Nachdem Sie den Red Hat JBoss EAP-Dienst gestartet haben, können Sie über http://$ADMIN_VM_PUBLIC_IP:9990 in Ihrem Webbrowser auf die Verwaltungskonsole zugreifen. Melden Sie sich mit dem konfigurierten Benutzernamen jbossadmin und Kennwort Secret123456 an.

Screenshot der Verwaltungskonsole des Red Hat JBoss Enterprise Application Platform-Domänencontrollers.

Wählen Sie die Registerkarte Runtime aus. Wählen Sie im Navigationsbereich die Option Topology aus. Sie sollten sehen, dass Ihr Cluster im Moment nur einen Domänencontroller enthält:

Konfigurieren des Host-Controllers (Arbeitsknoten)

Verwenden Sie SSH, um sich mit mspVM1 als Benutzer*in von azureuser zu verbinden. Ermitteln Sie die öffentliche IP-Adresse der VM mit dem folgenden Befehl:

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

Verwenden Sie die folgenden Befehle, um den Host-Controller auf mspVM1 einzurichten:

# 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

Verwenden Sie die folgenden Befehle, um die Änderungen am Host-Controller auf mspVM1 anzuwenden:

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

Die letzte Zeile der Ausgabe sollte ähnlich wie im folgenden Beispiel aussehen. Ist dies nicht der Fall, beheben Sie das Problem, bevor Sie fortfahren.

[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

Verwenden Sie dann die folgenden Befehle, um den JBoss-Server zu konfigurieren und den EAP-Dienst einzurichten:

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

Die Ausgabe sollte in etwa wie im folgenden Beispiel aussehen:

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

Geben Sie q ein, um den Pager zu beenden. Beenden Sie die SSH-Verbindung durch Eingabe von exit.

Verwenden Sie SSH, um sich mit mspVM2 als Benutzer*in von azureuser zu verbinden. Ermitteln Sie die öffentliche IP-Adresse der VM mit dem folgenden Befehl:

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

Wiederholen Sie die vorherigen Schritte auf mspVM2 und beenden Sie die SSH-Verbindung durch Eingabe von exit.

Nachdem zwei Host-Controller mit adminVM verbunden sind, sollten Sie die Topologie des Clusters sehen können, wie im folgenden Screenshot dargestellt:

Red Hat JBoss EAP Cluster mit Azure Application Gateway bereitstellen

Nachdem Sie den Cluster auf Azure-VMs erstellt haben, erfahren Sie in diesem Abschnitt, wie Sie JBoss EAP mit Azure Application Gateway ins Internet bringen.

Erstellen Sie die Azure Application Gateway-Instanz.

Um Red Hat JBoss EAP für das Internet zugänglich zu machen, benötigen Sie eine öffentliche IP-Adresse. Erstellen Sie die öffentliche IP-Adresse und verknüpfen Sie dann ein Azure Application Gateway damit. Verwenden Sie az network public-ip create, um sie zu erstellen, wie im folgenden Beispiel gezeigt:

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

Als nächstes fügen Sie die Backend-Server zum Application Gateway Backend-Pool hinzu. Verwenden Sie für die Abfrage der IP-Adressen der Backends die folgenden Befehle. Sie haben nur die Host-Controller (Arbeitsknoten) als Backend-Server konfiguriert.

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)

Als nächstes erstellen Sie ein Azure Application Gateway. Das folgende Beispiel erstellt ein Application Gateway mit Host-Controllern im Standard Backend-Pool:

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}

Hinweis

In diesem Beispiel wird ein einfacher Zugriff auf die Red Hat JBoss EAP-Server über HTTP eingerichtet. Wenn Sie einen sicheren Zugriff wünschen, konfigurieren Sie die TLS/SSL-Terminierung, indem Sie die Anweisungen in Ende-zu-Ende TLS mit Application Gateway befolgen.

In diesem Beispiel werden die Host-Controller über Port 8080 angesprochen. Sie stellen in späteren Schritten eine Beispielanwendung mit einer Datenbankverbindung zum Cluster bereit.

Azure Database für PostgreSQL Flexible-Server verbinden

Dieser Abschnitt zeigt Ihnen, wie Sie eine Azure Database for PostgreSQL Flexible-Server-Instanz erstellen und eine Verbindung zu PostgreSQL auf Ihrem Red Hat JBoss EAP-Cluster konfigurieren.

Erstellen einer Azure Datenbank for PostgreSQL Flexible-Server-Instanz

Verwenden Sie die folgenden Schritte, um die Datenbankinstanz zu erstellen:

  1. Verwenden Sie az postgres flexible-server create , um eine Azure Datenbank for PostgreSQL Flexible-Server -nstanz zu erstellen, wie im folgenden Beispiel gezeigt:

    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. Verwenden Sie die folgenden Befehle, um den Zugriff von Azure Services aus zuzulassen:

    # 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. Verwenden Sie den folgenden Befehl, um die Datenbank zu erstellen:

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

Treiber installieren

Führen Sie die folgenden Schritte aus, um den INSTALLATIONStreiber mit der JBoss Management CLI zu installieren:

  1. Verbinden Sie sich per SSH mit adminVM, indem Sie den folgenden Befehl verwenden. Sie können diesen Schritt überspringen, wenn Sie bereits eine Verbindung geöffnet haben.

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

  2. Verwenden Sie die folgenden Befehle, um DEN ELEMENTTREIBER AUF adminVM herunterzuladen:

    # 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. Verwenden Sie die folgenden Befehle, um den ELEMENTTREIBER AUF die Hostcontroller zu kopieren:

    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"

    Die Log-Dateien des Servers befinden sich auf mspVM1 und mspVM2 unter /var/opt/rh/eap7/lib/wildfly/domain/servers/mspvm1-server0/log/server.log. Wenn die Bereitstellung fehlschlägt, prüfen Sie diese Log-Datei und beheben Sie das Problem, bevor Sie fortfahren.

  1. Verwenden Sie die folgenden Befehle, um den BEFEHL ZU registrieren:

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

Konfigurieren der Datenbankverbindung für den Red Hat JBoss EAP-Cluster

Sie haben den Datenbankserver gestartet, die erforderliche Ressourcen-ID abgerufen und den JDBC-Treiber installiert. Die nächsten Schritte in diesem Abschnitt zeigen Ihnen, wie Sie die JBoss CLI verwenden, um eine Datenquellenverbindung mit der zuvor erstellten PostgreSQL-Instanz zu konfigurieren.

  1. Öffnen Sie ein Terminal und verbinden Sie sich per SSH mit adminVM, indem Sie den folgenden Befehl verwenden:

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

  2. Erstellen Sie die Datenquelle mit Hilfe der folgenden Befehle:

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

Sie haben erfolgreich eine Datenquelle mit dem Namen java:jboss/datasources/JavaEECafeDB konfiguriert.

Java EE Cafe-Beispielanwendung bereitstellen

Führen Sie die folgenden Schritte aus, um die Java EE Cafe-Beispielanwendung auf dem Red Hat JBoss EAP-Cluster bereitzustellen:

  1. Verwenden Sie die folgenden Schritte, um Java EE Cafe zu erstellen. Diese Schritte setzen voraus, dass Sie über eine lokale Umgebung mit installiertem Git und Maven verfügen:

    1. Verwenden Sie den folgenden Befehl, um den Quellcode von GitHub zu klonen:

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

    2. Verwenden Sie den folgenden Befehl, um den Quellcode zu erstellen:

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

      Dieser Befehl erstellt die Datei eap-coffee-app/target/javaee-cafe.war. Diese Datei laden Sie im nächsten Schritt hoch.

  2. Öffnen Sie einen Webbrowser und rufen Sie die Verwaltungskonsole unter http://<adminVM-public-IP>:9990 auf. Melden Sie sich dann mit dem Benutzernamen jbossadmin und dem Kennwort Secret123456 an.

  3. Führen Sie die folgenden Schritte aus, um die Datei javaee-cafe.war in das Content Repository hochzuladen:

    1. Wählen Sie auf der Registerkarte Deployments der Red Hat JBoss EAP-Verwaltungskonsole im Navigationsbereich Content Repository.

    2. Klicken Sie auf die Schaltfläche Add, und wählen Sie dann Upload Content.

      Screenshot der Registerkarte Deplyments von Red Hat JBoss Enterprise Application Platform mit hervorgehobener Menüoption Upload Content.

    3. Verwenden Sie Dateiauswahl des Browsers, um die Datei javaee-cafe.war auszuwählen.

    4. Wählen Sie Weiter aus.

    5. Übernehmen Sie auf dem nächsten Bildschirm die Standardwerte, und wählen Sie anschließend Finish aus.

    6. Wählen Sie View content aus.

  4. Führen Sie die folgenden Schritte aus, um eine Anwendung auf main-server-group bereitzustellen:

    1. Wählen Sie unter Content Repository die Option javaee-cafe.war aus.

    2. Wählen Sie im Dropdown-Menü Deploy.

    3. Wählen Sie main-server-group als Servergruppe für die Bereitstellung von javaee-cafe.war.

    4. Wählen Sie Bereitstellen aus, um die Bereitstellung zu starten. Daraufhin sollte ein Hinweis wie der folgende angezeigt werden:

      Screenshot: Hinweis für eine erfolgreiche Bereitstellung

Testen der Red Hat JBoss EAP-Cluster-Konfiguration

Sie haben den JBoss EAP-Cluster konfiguriert und die Anwendung darauf bereitgestellt. Verwenden Sie die folgenden Schritte, um auf die Anwendung zuzugreifen und alle Einstellungen zu überprüfen:

  1. Verwenden Sie den folgenden Befehl, um die öffentliche IP-Adresse des Azure Application Gateway abzurufen:

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

  2. Öffnen Sie einen Webbrowser.

  3. Navigieren Sie zu der Anwendung mit der URL http://<gateway-public-ip-address>/javaee-cafe/. Vergessen Sie den abschließenden Schrägstrich nicht.

  4. Versuchen Sie, Kaffees hinzuzufügen und zu entfernen.

Bereinigen von Ressourcen

Zum Vermeiden von Azure-Gebühren sollten Sie nicht benötigte Ressourcen bereinigen. Wenn Sie den auf einer Azure-VM bereitgestellten Red Hat JBoss EAP-Cluster nicht mehr benötigen, heben Sie die Registrierung der Red Hat JBoss EAP-Server auf und entfernen Sie die Ressourcen von Azure.

Verwenden Sie die folgenden Befehle, um die Registrierung der Red Hat JBoss EAP-Server und -VMs aus der Red Hat Abonnement-Verwaltung aufzuheben:

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

Verwenden Sie den folgenden Befehl, um die Ressourcengruppe $RESOURCE_GROUP_NAME zu löschen:

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

Nächste Schritte

Entdecken Sie weitere Optionen, um JBoss EAP auf Azure auszuführen.

Red Hat JBoss EAP in Azure