Udostępnij za pośrednictwem

Samouczek: ręczne instalowanie protokołu JBoss EAP na maszynach wirtualnych platformy Azure

  • Artykuł

W tym samouczku przedstawiono kroki instalacji platformy EAP (Red Hat JBoss Enterprise Application Platform) i konfigurowania klastra w trybie domeny na maszynach wirtualnych platformy Azure w systemie Red Hat Enterprise Linux (RHEL).

Z tego samouczka dowiesz się, jak wykonywać następujące zadania:

  • Utwórz niestandardową sieć wirtualną i utwórz maszyny wirtualne w sieci.
  • Zainstaluj żądane zestawy JDK i Red Hat JBoss EAP na maszynach wirtualnych przy użyciu wiersza polecenia ręcznie.
  • Skonfiguruj klaster EAP Red Hat JBoss w trybie domeny przy użyciu interfejsu wiersza polecenia (CLI).
  • Skonfiguruj połączenie źródła danych PostgreSQL w klastrze.
  • Wdróż i uruchom przykładową aplikację Java EE w klastrze.
  • Uwidocznij aplikację w publicznym Internecie za pośrednictwem usługi aplikacja systemu Azure Gateway.
  • Zweryfikuj pomyślną konfigurację.

Jeśli wolisz w pełni zautomatyzowane rozwiązanie, które wykonuje wszystkie te kroki w Twoim imieniu na maszynach wirtualnych GNU/Linux, bezpośrednio w witrynie Azure Portal, zobacz Szybki start: wdrażanie klastra EAP JBoss na maszynach wirtualnych platformy Azure.

Jeśli chcesz przekazać opinię lub ściśle pracować nad scenariuszami migracji z zespołem inżynierów opracowującym rozwiązanie JBoss EAP na platformie Azure, wypełnij tę krótką ankietę dotyczącą migracji JBoss EAP i dołącz swoje informacje kontaktowe. Zespół menedżerów programów, architektów i inżynierów natychmiast skontaktuje się z Tobą w celu zainicjowania ścisłej współpracy.

Uwaga

Ten artykuł zawiera odwołania do terminu slave (element podrzędny), który nie jest już używany przez firmę Microsoft. Po usunięciu terminu z oprogramowania usuniemy go z tego artykułu.

Wymagania wstępne

  • Subskrypcja platformy Azure. Jeśli nie masz subskrypcji platformy Azure, przed rozpoczęciem utwórz bezpłatne konto.

  • Zainstaluj interfejs wiersza polecenia platformy Azure w wersji 2.51.0 lub nowszej , aby uruchomić polecenia interfejsu wiersza polecenia platformy Azure.

  • Upewnij się, że masz wymagane licencje oprogramowania Red Hat. Musisz mieć konto Red Hat z uprawnieniem Red Hat Subscription Management (RHSM) dla oprogramowania Red Hat JBoss EAP. To uprawnienie pozwala na zainstalowanie w pełni zautomatyzowanego rozwiązania (w przewodniku Szybki start: wdrażanie klastra JBoss EAP na maszynach wirtualnych platformy Azure) przy użyciu przetestowanej i certyfikowanej wersji oprogramowania JBoss EAP.

    Uwaga

    Jeśli nie masz uprawnień do korzystania z protokołu EAP, możesz zarejestrować się w celu uzyskania bezpłatnej subskrypcji dla deweloperów za pośrednictwem subskrypcji red hat developer dla użytkowników indywidualnych. Zapisz szczegóły konta, które są używane jako nazwa użytkownika RHSM i hasło RHSM w następnej sekcji.

  • Jeśli jesteś już zarejestrowany lub po zakończeniu rejestracji, możesz zlokalizować niezbędne poświadczenia (identyfikatory puli), wykonując następujące kroki. Te identyfikatory puli są również używane jako identyfikator puli RHSM z uprawnieniem EAP w kolejnych krokach.

    1. Zaloguj się do konta usługi Red Hat.

    2. Po pierwszym zalogowaniu zostanie wyświetlony monit o ukończenie profilu. W zależności od użycia wybierz pozycję Osobiste lub Firmowe dla pozycji Typ konta, jak pokazano na poniższym zrzucie ekranu:

      Zrzut ekranu przedstawiający okno Konta Red Hat z wybraną opcją Typ konta z wybraną opcją Osobiste.

    3. Otwórz subskrypcję platformy Red Hat Dla deweloperów dla użytkowników indywidualnych. Ten link umożliwia przejście do wszystkich subskrypcji na koncie dla odpowiedniej jednostki SKU.

    4. W wierszu kontrolek w tabeli Wszystkie zakupione subskrypcje wybierz pozycję Aktywne.

    5. Wybierz nagłówek kolumny sortowalnej w polu Data zakończenia, dopóki wartość nie zostanie wyświetlona w przyszłości jako pierwszy wiersz.

    6. Wybierz pierwszy wiersz. Następnie skopiuj i zapisz wartość obok następujących pul głównych z identyfikatorów puli.

  • Zestaw Java Development Kit (JDK), wersja 11. W tym przewodniku zalecamy red hat build of OpenJDK. Upewnij się, że JAVA_HOME zmienna środowiskowa jest poprawnie ustawiona w powłokach, w których uruchamiasz polecenia.

  • Git; użyj polecenia git --version , aby sprawdzić, czy git działa. Ten samouczek został przetestowany przy użyciu wersji 2.25.1.

  • Maven; użyj polecenia mvn -version , aby sprawdzić, czy mvn działa. Ten samouczek został przetestowany przy użyciu wersji 3.6.3.

Przygotowywanie środowiska

W tej sekcji skonfigurujesz infrastrukturę, w ramach której zainstalujesz zestaw JDK, Red Hat JBoss EAP oraz sterownik JDBC (Java Database Connectivity) postgreSQL.

Założenia

W tym samouczku skonfigurowaliśmy klaster EAP Red Hat JBoss w trybie domeny z serwerem administracyjnym i dwoma serwerami zarządzanymi na łącznie trzech maszynach wirtualnych. Aby skonfigurować klaster, należy utworzyć następujące trzy maszyny wirtualne platformy Azure:

  • Maszyna wirtualna administratora (nazwa adminVMmaszyny wirtualnej ) jest uruchamiana jako kontroler domeny.
  • Dwie zarządzane maszyny wirtualne (nazwy mspVM1 maszyn wirtualnych i mspVM2) działają jako kontroler hosta.

Logowanie się do platformy Azure

Jeśli jeszcze tego nie zrobiono, zaloguj się do subskrypcji platformy Azure przy użyciu polecenia az login i postępując zgodnie z instrukcjami wyświetlanymi na ekranie.

az login

Uwaga

Jeśli masz wiele dzierżaw platformy Azure skojarzonych z poświadczeniami platformy Azure, musisz określić dzierżawę, do której chcesz się zalogować. Możesz to zrobić za --tenant pomocą opcji . Na przykład az login --tenant contoso.onmicrosoft.com.

Tworzenie grupy zasobów

Utwórz grupę zasobów za pomocą polecenia az group create. Nazwy grup zasobów muszą być globalnie unikatowe w ramach subskrypcji. Z tego powodu rozważ wstępne tworzenie unikatowych identyfikatorów, które muszą być unikatowe. Przydatną techniką jest użycie inicjałów, po których następuje dzisiejsza data w mmdd formacie. W tym przykładzie westus zostanie utworzona grupa zasobów o nazwie $RESOURCE_GROUP_NAME w lokalizacji:

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

Tworzenie sieci wirtualnej

Zasoby składające się z klastra Red Hat JBoss EAP muszą komunikować się ze sobą, a publiczny Internet przy użyciu sieci wirtualnej. Aby uzyskać kompletny przewodnik planowania sieci wirtualnej, zobacz Przewodnik Cloud Adoption Framework dla platformy Azure Planowanie sieci wirtualnych. Aby uzyskać więcej informacji, zobacz Często zadawane pytania dotyczące usługi Azure Virtual Network.

Przykład w tej sekcji tworzy sieć wirtualną z przestrzenią adresową 192.168.0.0/16 i tworzy podsieć używaną dla maszyn wirtualnych.

Najpierw utwórz sieć wirtualną przy użyciu polecenia az network vnet create. Poniższy przykład tworzy sieć o nazwie myVNet:

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

Utwórz podsieć dla klastra EAP Red Hat JBoss przy użyciu polecenia az network vnet subnet create. Poniższy przykład tworzy podsieć o nazwie mySubnet:

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

Utwórz podsieć dla usługi Application Gateway przy użyciu polecenia az network vnet subnet create. Poniższy przykład tworzy podsieć o nazwie jbossVMGatewaySubnet:

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

Tworzenie sieciowej grupy zabezpieczeń i przypisywanie do niej podsieci

Przed utworzeniem maszyn wirtualnych z publicznymi adresami IP utwórz sieciową grupę zabezpieczeń w celu zabezpieczenia utworzonej wcześniej sieci wirtualnej sieci i podsieci.

Utwórz sieciową grupę zabezpieczeń przy użyciu polecenia az network nsg create. Poniższy przykład tworzy sieciową grupę zabezpieczeń o nazwie mynsg:

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

Utwórz reguły sieciowej grupy zabezpieczeń za pomocą polecenia az network nsg rule create. Poniższy przykład tworzy reguły sieciowej grupy zabezpieczeń o nazwach ALLOW_APPGW i ALLOW_HTTP_ACCESS. Te reguły umożliwiają usłudze App Gateway akceptowanie ruchu przychodzącego na portach HTTP używanych przez protokół Red Hat JBoss EAP:

az network nsg rule create \
    --resource-group $RESOURCE_GROUP_NAME \
    --nsg-name mynsg \
    --name ALLOW_APPGW \
    --protocol Tcp \
    --destination-port-ranges 65200-65535 \
    --source-address-prefix GatewayManager \
    --destination-address-prefix '*' \
    --access Allow \
    --priority 500 \
    --direction Inbound

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

Skojarz podsieci utworzone wcześniej z tą sieciową grupą zabezpieczeń przy użyciu polecenia az network vnet subnet update, jak pokazano w poniższym przykładzie:

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

Tworzenie maszyny z systemem Red Hat Enterprise Linux dla administratora

Generowanie kluczy SSH

Użyj następującego polecenia, aby wygenerować klucze SSH dla adminVMprogramu :

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

Tworzenie maszyny wirtualnej administratora

Obraz witryny Marketplace używany do tworzenia maszyn wirtualnych to RedHat:rhel-raw:86-gen2:latest. Aby zapoznać się z innymi obrazami, zobacz Obrazy systemu Red Hat Enterprise Linux (RHEL) dostępne na platformie Azure.

Uwaga

Możesz wykonać zapytanie dotyczące wszystkich dostępnych obrazów systemu Red Hat Enterprise Linux dostarczonych przez firmę Red Hat za pomocą polecenia az vm image list — na przykład: az vm image list --offer RHEL --publisher RedHat --output table --all. Aby uzyskać więcej informacji, zobacz Omówienie obrazów systemu Red Hat Enterprise Linux.

Jeśli używasz innego obrazu, może być konieczne zainstalowanie dodatkowych bibliotek w celu włączenia infrastruktury używanej w tym przewodniku.

Utwórz podstawową maszynę wirtualną, zainstaluj na niej wszystkie wymagane narzędzia, utwórz migawkę, a następnie utwórz repliki na podstawie migawki.

Utwórz maszynę wirtualną przy użyciu polecenia az vm create. Na tej maszynie wirtualnej uruchomisz serwer administracyjny.

Poniższy przykład tworzy tożsamość zarządzaną platformy Azure i maszynę wirtualną z systemem Linux z systemem Red Hat Enterprise przy użyciu uwierzytelniania TLS/SSL.

az identity create \
    --name "passwordless-managed-identity" \
    --resource-group $RESOURCE_GROUP_NAME \
    --location westus

az vm create \
    --resource-group $RESOURCE_GROUP_NAME \
    --name adminVM \
    --image RedHat:rhel-raw:86-gen2:latest \
    --assign-identity "/subscriptions/$SUBSCRIPTION/resourceGroups/$RESOURCE_GROUP_NAME/providers/Microsoft.ManagedIdentity/userAssignedIdentities/passwordless-managed-identity" \
    --size Standard_DS1_v2  \
    --admin-username azureuser \
    --ssh-key-values ~/.ssh/jbosseapvm.pub \
    --public-ip-sku Standard \
    --nsg mynsg \
    --vnet-name myVnet \
    --subnet mySubnet

Instalowanie oprogramowania Red Hat JBoss EAP

Aby zainstalować następujące kroki:

  1. Użyj następującego polecenia, aby uzyskać publiczny adres IP polecenia adminVM:

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

  2. Otwórz terminal i połączenie SSH z serwerem adminVM przy użyciu następującego polecenia:

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

  3. Skonfiguruj zaporę dla portów przy użyciu następującego polecenia:

    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

    Po dwóch pierwszych poleceniach powinien zostać wyświetlony wyraz success . Powinny zostać wyświetlone dane wyjściowe podobne do poniższego przykładu po trzecim poleceniu:

    # 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

Uwaga

Wartości RHSM_USER i RHSM_PASSWORD są wymagane do zainstalowania aplikacji Red Hat JBoss EAP. Zalecamy używanie konta usługi z ograniczonymi uprawnieniami dostępu do portalu klienta Red Hat.

  1. Użyj następujących poleceń, aby zarejestrować hosta administracyjnego na koncie zarządzania subskrypcjami red hat (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

    Powinny zostać wyświetlone dane wyjściowe podobne do następującego przykładu:

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

  2. Użyj następującego polecenia, aby dołączyć hosta administratora do puli EAP red Hat JBoss:

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

    Uwaga

    To polecenie jest ignorowane, jeśli używasz trybu prostego dostępu do zawartości.

  3. Użyj następujących poleceń, aby zainstalować aplikację Red Hat JBoss EAP:

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

W przypadku drugich i trzecich poleceń powinien zostać wyświetlonych wiele wierszy danych wyjściowych kończących się na Complete!

  1. Użyj następujących poleceń, aby ustawić uprawnienia i konfiguracje sieci:

    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. Aby skonfigurować zmienne środowiskowe, użyj następujących poleceń:

    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. Wyjdź z połączenia SSH, wpisując polecenie exit .

Tworzenie maszyn dla serwerów zarządzanych

Zainstalowano aplikację Red Hat JBoss EAP na serwerze adminVM, który działa jako serwer kontrolera domeny. Nadal trzeba przygotować maszyny do uruchamiania dwóch serwerów kontrolera hosta. Następnie utworzysz migawkę adminVM maszyn i przygotujesz maszyny dla dwóch zarządzanych serwerów i mspVM1 mspVM2.

W tej sekcji przedstawiono podejście do przygotowywania maszyn za pomocą migawki elementu adminVM. Wróć do terminalu z zalogowanym interfejsem wiersza polecenia platformy Azure, a następnie wykonaj następujące kroki:

  1. Aby zatrzymać adminVMpolecenie , użyj następującego polecenia:

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

  2. Użyj polecenia az snapshot create , aby utworzyć migawkę adminVM dysku systemu operacyjnego, jak pokazano w poniższym przykładzie:

    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. Użyj następującego polecenia, aby uruchomić polecenie adminVM:

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

  4. Aby utworzyć mspVM1program , wykonaj następujące czynności:

    1. Najpierw utwórz dysk zarządzany za mspVM1 pomocą polecenia 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. Następnie użyj następujących poleceń, aby utworzyć maszynę wirtualną mspVM1, dołączając dysk mspVM1_OsDisk_1systemu operacyjnego :

      #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. Utworzono aplikację mspVM1 Red Hat JBoss EAP. Ponieważ maszyna wirtualna została utworzona na podstawie migawki adminVM dysku systemu operacyjnego, obie maszyny wirtualne mają tę samą nazwę hosta. Użyj polecenia az vm run-command invoke , aby zmienić nazwę hosta na wartość mspVM1:

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

      Po pomyślnym zakończeniu polecenia zobaczysz dane wyjściowe podobne do następującego przykładu:

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

  5. Użyj tych samych poleceń, aby utworzyć polecenie mspVM2:

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

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

#Create VM by attaching existing managed disks as OS
az vm create \
    --resource-group $RESOURCE_GROUP_NAME \
    --name mspVM2 \
    --assign-identity "/subscriptions/$SUBSCRIPTION/resourceGroups/$RESOURCE_GROUP_NAME/providers/Microsoft.ManagedIdentity/userAssignedIdentities/passwordless-managed-identity" \
    --attach-os-disk ${MSPVM2_DISK_ID} \
    --os-type linux \
    --public-ip-sku Standard \
    --nsg mynsg \
    --vnet-name myVnet \
    --subnet mySubnet

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

Użyj następujących poleceń, aby pobrać i wyświetlić prywatne adresy IP, które są używane w kolejnych sekcjach:

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

Teraz wszystkie trzy maszyny są gotowe. Następnie skonfigurujesz klaster EAP Red Hat JBoss w trybie domeny zarządzanej.

Konfigurowanie domeny zarządzanej i klastra

Skonfiguruj klaster z włączoną replikacją sesji. Aby uzyskać więcej informacji, zobacz Replikacja sesji.

Aby włączyć replikację sesji, użyj protokołu Red Hat JBoss EAP High Availability dla klastra. Platforma Microsoft Azure nie obsługuje protokołów odnajdywania JGroups opartych na multiemisji. Mimo że można używać innych protokołów odnajdywania JGroups (takich jak konfiguracja statyczna ),TCPPING udostępniona baza danych (), współużytkowany system plików ping (JDBC_PING) (FILE_PING) lub TCPGOSSIP), zdecydowanie zalecamy użycie udostępnionego protokołu odnajdywania plików opracowanego dla platformy Azure: AZURE_PING. Aby uzyskać więcej informacji, zobacz Using JBoss EAP High Availability in Microsoft Azure (Korzystanie z wysokiej dostępności protokołu JBoss EAP na platformie Microsoft Azure).

Tworzenie konta usługi Azure Storage i kontenera obiektów blob dla AZURE_PING

Użyj następujących poleceń, aby utworzyć konto magazynu i kontener obiektów blob:

# Define your storage account name
export STORAGE_ACCOUNT_NAME=azurepingstgabc1111rg
# Define your Blob container name
export CONTAINER_NAME=azurepingcontainerabc1111rg

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

Następnie pobierz klucz konta magazynu do późniejszego użycia przy użyciu następującego polecenia. Jeśli zostanie wyświetlony błąd, zaczekaj kilka minut i spróbuj ponownie. Poprzednie polecenie do utworzenia konta magazynu może jeszcze nie zostać wykonane.

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}

Powinny zostać wyświetlone następujące dane wyjściowe:

{
  "created": true
}

Konfigurowanie kontrolera domeny (węzeł administracyjny)

W tym samouczku użyto poleceń interfejsu wiersza polecenia zarządzania EAP red Hat JBoss do skonfigurowania kontrolera domeny. Aby uzyskać więcej informacji, zobacz Przewodnik po interfejsie wiersza polecenia zarządzania.

Poniższe kroki umożliwiają skonfigurowanie konfiguracji kontrolera domeny w programie adminVM. Użyj protokołu SSH, aby nawiązać adminVM połączenie z użytkownikiem azureuser . Przypomnij sobie, że publiczny adres IP elementu adminVM został przechwycony wcześniej w zmiennej środowiskowej ADMIN_VM_PUBLIC_IP .

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

Najpierw użyj następujących poleceń, aby skonfigurować profil wysokiej dostępności i grupy JGroup przy użyciu AZURE_PING protokołu:

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

Ostatnia stanza danych wyjściowych powinna wyglądać podobnie do poniższego przykładu. Jeśli tak nie jest, przed kontynuowaniem rozwiąż problem i rozwiąż go.

[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

Następnie użyj następujących poleceń, aby skonfigurować serwer JBoss i skonfigurować usługę EAP:

Uwaga

Wartości JBOSS_EAP_USER i JBOSS_EAP_PASSWORD są wymagane do skonfigurowania użytkownika zarządzania EAP JBoss.

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

Dane wyjściowe powinny wyglądać mniej więcej tak jak w tym przykładzie:

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'

Na koniec użyj następujących poleceń, aby uruchomić usługę 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

Dane wyjściowe powinny wyglądać mniej więcej tak jak w tym przykładzie:

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

Wpisz q , aby zamknąć pager. Wyjdź z połączenia SSH, wpisując polecenie exit .

Po uruchomieniu usługi Red Hat JBoss EAP możesz uzyskać dostęp do konsoli zarządzania za pośrednictwem http://$ADMIN_VM_PUBLIC_IP:9990 przeglądarki internetowej. Zaloguj się przy użyciu skonfigurowanej nazwy użytkownika jbossadmin i hasła Secret123456.

Zrzut ekranu przedstawiający konsolę zarządzania kontrolerem domeny red Hat JBoss Enterprise Application Platform.

Wybierz kartę Środowisko uruchomieniowe . W okienku nawigacji wybierz pozycję Topologia. Na razie klaster powinien zawierać tylko jeden kontroler domeny:

Konfigurowanie kontrolerów hosta (węzłów procesu roboczego)

Użyj protokołu SSH, aby nawiązać mspVM1 połączenie jako azureuser użytkownik. Pobierz publiczny adres IP maszyny wirtualnej za pomocą następującego polecenia:

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

Użyj następujących poleceń, aby skonfigurować kontroler hosta w programie mspVM1:

# environment variables
export DOMAIN_CONTROLLER_PRIVATE_IP=<adminVM-private-IP>
export HOST_VM_NAME=$(hostname)
export HOST_VM_NAME_LOWERCASE=$(echo "${HOST_VM_NAME,,}")
export HOST_VM_IP=$(hostname -I)

export JBOSS_EAP_USER=jbossadmin
export JBOSS_EAP_PASSWORD=Secret123456

# Save default domain configuration as backup
sudo -u jboss mv $EAP_HOME/wildfly/domain/configuration/domain.xml $EAP_HOME/wildfly/domain/configuration/domain.xml.backup

# Fetch domain.xml from domain controller
scp azureuser@${DOMAIN_CONTROLLER_PRIVATE_IP}:/tmp/domain.xml /tmp/domain.xml
sudo mv /tmp/domain.xml $EAP_HOME/wildfly/domain/configuration/domain.xml
sudo chown jboss:jboss $EAP_HOME/wildfly/domain/configuration/domain.xml

Użyj następujących poleceń, aby zastosować zmiany kontrolera hosta w programie 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})"

Ostatnia stanza danych wyjściowych powinna wyglądać podobnie do poniższego przykładu. Jeśli tak nie jest, przed kontynuowaniem rozwiąż problem i rozwiąż go.

[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

Następnie użyj następujących poleceń, aby skonfigurować serwer JBoss i skonfigurować usługę 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

Dane wyjściowe powinny wyglądać mniej więcej tak jak w tym przykładzie:

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

Wpisz q , aby zamknąć pager. Wyjdź z połączenia SSH, wpisując polecenie exit .

Użyj protokołu SSH, aby nawiązać mspVM2 połączenie jako azureuser użytkownik. Pobierz publiczny adres IP maszyny wirtualnej za pomocą następującego polecenia:

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

Powtórz poprzednie kroki w pliku mspVM2, a następnie zakończ połączenie SSH, wpisując polecenie exit ( Zakończ).

Po połączeniu dwóch kontrolerów hosta z adminVMusługą powinna być widoczna topologia klastra, jak pokazano na poniższym zrzucie ekranu:

Uwidacznij klaster Red Hat JBoss EAP przy użyciu bramy aplikacja systemu Azure

Po utworzeniu klastra na maszynach wirtualnych platformy Azure w tej sekcji przedstawiono udostępnianie protokołu JBoss EAP do Internetu za pomocą usługi aplikacja systemu Azure Gateway.

Tworzenie bramy aplikacja systemu Azure

Aby uwidocznić aplikację Red Hat JBoss EAP w Internecie, wymagany jest publiczny adres IP. Utwórz publiczny adres IP, a następnie skojarz z nim bramę aplikacja systemu Azure. Użyj polecenia az network public-ip create , aby go utworzyć, jak pokazano w poniższym przykładzie:

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

Następnie dodaj serwery zaplecza do puli zaplecza usługi Application Gateway. Wykonaj zapytanie o adresy IP zaplecza przy użyciu następujących poleceń. Kontrolery hosta (węzły robocze) są skonfigurowane tylko jako serwery zaplecza.

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)

Następnie utwórz bramę aplikacja systemu Azure. Poniższy przykład tworzy bramę aplikacji z kontrolerami hostów w domyślnej puli zaplecza:

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}

Uwaga

W tym przykładzie skonfigurowaliśmy prosty dostęp do serwerów EAP Red Hat JBoss przy użyciu protokołu HTTP. Jeśli chcesz uzyskać bezpieczny dostęp, skonfiguruj kończenie żądań protokołu TLS/SSL, postępując zgodnie z instrukcjami w temacie End to end TLS with Application Gateway (Kończenie szyfrowania TLS w usłudze Application Gateway).

Ten przykład uwidacznia kontrolery hosta na porcie 8080. Przykładowa aplikacja jest wdrażana przy użyciu połączenia bazy danych z klastrem w kolejnych krokach.

Łączenie serwera elastycznego usługi Azure Database for PostgreSQL

W tej sekcji pokazano, jak utworzyć wystąpienie serwera elastycznego usługi Azure Database for PostgreSQL i skonfigurować połączenie z bazą danych PostgreSQL w klastrze Red Hat JBoss EAP.

Tworzenie wystąpienia serwera elastycznego usługi Azure Database for PostgreSQL

Aby utworzyć wystąpienie bazy danych, wykonaj następujące czynności:

  1. Użyj polecenia az postgres flexible-server create , aby aprowizować wystąpienie serwera elastycznego usługi Azure Database for PostgreSQL, jak pokazano w poniższym przykładzie:

    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. Użyj następujących poleceń, aby zezwolić na dostęp z usług platformy Azure:

    # Save aside the following names for later use
export fullyQualifiedDomainName=$(az postgres flexible-server show \
    --resource-group $RESOURCE_GROUP_NAME \
    --name ${DB_SERVER_NAME} \
    --query "fullyQualifiedDomainName" \
    --output tsv)
export name=$(az postgres flexible-server show \
    --resource-group $RESOURCE_GROUP_NAME \
    --name ${DB_SERVER_NAME} \
    --query "name" \
    --output tsv)

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

  3. Użyj następującego polecenia, aby utworzyć bazę danych:

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

Sterownik instalacji

Wykonaj następujące kroki, aby zainstalować sterownik JDBC za pomocą interfejsu wiersza polecenia zarządzania JBoss:

  1. Użyj następującego polecenia za pomocą protokołu SSH adminVM . Jeśli masz już otwarte połączenie, możesz pominąć ten krok.

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

  2. Użyj następujących poleceń, aby pobrać sterownik JDBC na maszynie adminVM:

    # Create JDBC driver and module directory
jdbcDriverModuleDirectory="$EAP_HOME"/wildfly/modules/com/postgresql/main

sudo mkdir -p "$jdbcDriverModuleDirectory"

# Download JDBC driver and passwordless extensions

extensionJarName=azure-identity-extensions-1.1.20.jar
extensionPomName=azure-identity-extensions-1.1.20.pom
sudo curl --retry 5 -Lo ${jdbcDriverModuleDirectory}/${extensionJarName} https://repo1.maven.org/maven2/com/azure/azure-identity-extensions/1.1.20/$extensionJarName
sudo curl --retry 5 -Lo ${jdbcDriverModuleDirectory}/${extensionPomName} https://repo1.maven.org/maven2/com/azure/azure-identity-extensions/1.1.20/$extensionPomName

sudo yum install maven -y
sudo mvn dependency:copy-dependencies  -f ${jdbcDriverModuleDirectory}/${extensionPomName} -Ddest=${jdbcDriverModuleDirectory}

# Create module for JDBC driver
jdbcDriverModule=module.xml
sudo cat <<EOF >${jdbcDriverModule}
<?xml version="1.0" ?>
<module xmlns="urn:jboss:module:1.1" name="com.postgresql">
  <resources>
    <resource-root path="${extensionJarName}"/>
EOF

# Add all jars from target/dependency
for jar in ${jdbcDriverModuleDirectory}/target/dependency/*.jar; do
if [ -f "$jar" ]; then
# Extract just the filename from the path
jarname=$(basename "$jar")
echo "    <resource-root path=\"target/dependency/${jarname}\"/>" >> ${jdbcDriverModule}
fi
done

# Add the closing tags
cat <<EOF >> ${jdbcDriverModule}
</resources>
<dependencies>
<module name="javaee.api"/>
<module name="sun.jdk"/>
<module name="ibm.jdk"/>
<module name="javax.api"/>
<module name="javax.transaction.api"/>
</dependencies>
</module>
EOF

chmod 644 $jdbcDriverModule
sudo mv $jdbcDriverModule $jdbcDriverModuleDirectory/$jdbcDriverModule

  3. Użyj następujących poleceń, aby skopiować sterownik JDBC do kontrolerów hosta:

    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"

    Dziennik serwera znajduje się w lokalizacji mspVM1 i mspVM2 w /var/opt/rh/eap7/lib/wildfly/domain/servers/mspvm1-server0/log/server.loglokalizacji . Jeśli wdrożenie zakończy się niepowodzeniem, sprawdź ten plik dziennika i rozwiąż problem przed kontynuowaniem.

  1. Użyj następujących poleceń, aby zarejestrować sterownik JDBC:

    # Register JDBC driver
sudo -u jboss $EAP_HOME/wildfly/bin/jboss-cli.sh --connect --controller=$(hostname -I) --echo-command \
"/profile=ha/subsystem=datasources/jdbc-driver=postgresql:add(driver-name=postgresql,driver-module-name=com.postgresql,driver-xa-datasource-class-name=org.postgresql.xa.PGXADataSource)"

Konfigurowanie połączenia bazy danych dla klastra EAP red Hat JBoss

Uruchomiono serwer bazy danych, uzyskano niezbędny identyfikator zasobu i zainstalowano sterownik JDBC. Następnie kroki opisane w tej sekcji pokazują, jak za pomocą interfejsu wiersza polecenia narzędzia JBoss skonfigurować połączenie źródła danych z utworzonym wcześniej wystąpieniem postgreSQL.

  1. Otwórz terminal i protokół SSH, używając adminVM następującego polecenia:

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

  2. Utwórz źródło danych przy użyciu następujących poleceń:

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

Pomyślnie skonfigurowano źródło danych o nazwie java:jboss/datasources/JavaEECafeDB.

Wdrażanie przykładowej aplikacji Java EE Cafe

Wykonaj następujące kroki, aby wdrożyć przykładową aplikację Java EE Cafe w klastrze Red Hat JBoss EAP:

  1. Wykonaj poniższe kroki, aby utworzyć środowisko Java EE Cafe. W poniższych krokach założono, że masz zainstalowane środowisko lokalne z zainstalowanymi usługami Git i Maven:

    1. Użyj następującego polecenia, aby sklonować kod źródłowy z usługi GitHub:

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

    2. Użyj następującego polecenia, aby skompilować kod źródłowy:

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

      To polecenie tworzy plik eap-coffee-app/target/javaee-café.war. Ten plik zostanie przekazany w następnym kroku.

  2. Otwórz przeglądarkę internetową i przejdź do konsoli zarządzania pod adresem http://<adminVM-public-IP>:9990, a następnie zaloguj się przy użyciu nazwy użytkownika jbossadmin i hasła Secret123456.

  3. Wykonaj następujące kroki, aby przekazać plik javaee-café.war do repozytorium zawartości:

    1. Na karcie Wdrożenia konsoli zarządzania red hat JBoss EAP wybierz pozycję Repozytorium zawartości w okienku nawigacji.

    2. Wybierz przycisk Dodaj, a następnie wybierz pozycję Przekaż zawartość.

      Zrzut ekranu przedstawiający kartę Wdrożenia platformy aplikacji dla przedsiębiorstw w systemie Red Hat JBoss z wyróżnioną opcją menu Przekaż zawartość.

    3. Użyj selektora plików przeglądarki, aby wybrać plik javaee-café.war .

    4. Wybierz Dalej.

    5. Zaakceptuj wartości domyślne na następnym ekranie, a następnie wybierz pozycję Zakończ.

    6. Wybierz pozycję Wyświetl zawartość.

  4. Aby wdrożyć aplikację w main-server-groupprogramie , wykonaj następujące czynności:

    1. W obszarze Repozytorium zawartości wybierz pozycję javaee-café.war.

    2. Z menu rozwijanego wybierz pozycję Wdróż.

    3. Wybierz main-server-group jako grupę serwerów do wdrożenia pliku javaee-café.war.

    4. Wybierz pozycję Wdróż , aby rozpocząć wdrażanie. Powinna zostać wyświetlona informacja podobna do poniższego zrzutu ekranu:

      Zrzut ekranu przedstawiający powiadomienie o pomyślnym wdrożeniu.

Testowanie konfiguracji klastra EAP Red Hat JBoss

Skonfigurowano klaster JBoss EAP i wdrożono w niej aplikację. Aby uzyskać dostęp do aplikacji, wykonaj następujące kroki, aby zweryfikować wszystkie ustawienia:

  1. Użyj następującego polecenia, aby uzyskać publiczny adres IP bramy aplikacja systemu Azure:

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

  2. Otwórz przeglądarkę internetową.

  3. Przejdź do aplikacji przy użyciu adresu URL http://<gateway-public-ip-address>/javaee-cafe/. Nie zapomnij o końcowym ukośniku.

  4. Spróbuj dodać i usunąć kawę.

Czyszczenie zasobów

Aby uniknąć opłat za platformę Azure, należy wyczyścić niepotrzebne zasoby. Jeśli nie potrzebujesz już klastra Red Hat JBoss EAP wdrożonego na maszynie wirtualnej platformy Azure, wyrejestruj serwery Red Hat JBoss EAP i usuń zasoby platformy Azure.

Użyj następujących poleceń, aby wyrejestrować serwery eAP i maszyny wirtualne red hat JBoss z zarządzania subskrypcjami oprogramowania Red Hat:

# Unregister domain controller
az vm run-command invoke \
    --resource-group $RESOURCE_GROUP_NAME \
    --name adminVM \
    --command-id RunShellScript \
    --scripts "sudo subscription-manager unregister"

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

Użyj następującego polecenia, aby usunąć grupę $RESOURCE_GROUP_NAMEzasobów :

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

Następne kroki

Kontynuuj eksplorowanie opcji uruchamiania protokołu EAP JBoss na platformie Azure.

Eksplorowanie aplikacji JBoss EAP na platformie Azure