Partager via

Tutoriel : Installer manuellement JBoss EAP sur des machines virtuelles (VM) Azure

  • Article

Ce tutoriel montre les étapes pour installer Red Hat JBoss Enterprise Application Platform (EAP) et configurer un cluster en mode domaine sur des machines virtuelles (VM) Azure, sur Red Hat Enterprise Linux (RHEL).

Dans ce tutoriel, vous allez apprendre à effectuer les opérations suivantes :

  • Créez un réseau virtuel personnalisé et créez les machines virtuelles au sein du réseau.
  • Installez le JDK souhaité et Red Hat JBoss EAP sur les machines virtuelles en utilisant manuellement la ligne de commande.
  • Configurez un cluster Red Hat JBoss EAP en mode domaine à l'aide de l'interface de ligne de commande (CLI).
  • Configurez une connexion de source de données PostgreSQL dans le cluster.
  • Déployez et exécutez un exemple d'application Java EE dans le cluster.
  • Exposez l'application à l'internet public via Azure Application Gateway.
  • Validez la réussite de la configuration.

Si vous préférez une solution entièrement automatisée qui effectue toutes ces étapes en votre nom sur des machines virtuelles GNU/Linux, directement depuis le portail Azure, consultez la section Démarrage rapide : Déployer un cluster JBoss EAP sur des machines virtuelles (VM) Azure.

Si vous souhaitez fournir des commentaires ou travailler étroitement sur vos scénarios de migration avec l’équipe d’ingénierie qui développe JBoss EAP sur des solutions Azure, renseignez cette courte enquête sur la migration JBoss EAP et incluez vos coordonnées. L’équipe de gestionnaires de programmes, d’architectes et d’ingénieurs vous contactera rapidement pour lancer une collaboration étroite.

Remarque

Cet article contient des références au terme esclave, un terme que Microsoft n’utilise plus. Lorsque le terme sera supprimé du logiciel, nous le supprimerons de cet article.

Prérequis

  • Un abonnement Azure. Si vous n’avez pas d’abonnement Azure, créez un compte gratuit avant de commencer.

  • Installez la version 2.51.0 ou supérieure d'Azure CLI pour exécuter les commandes Azure CLI.

    • Lorsque vous y êtes invité, installez les extensions Azure CLI lors de la première utilisation. Pour plus d’informations sur les extensions, consultez Utiliser des extensions avec Azure CLI.
    • Exécutez az version pour rechercher la version et les bibliothèques dépendantes installées. Pour effectuer une mise à niveau vers la dernière version, exécutez az upgrade.

  • Vérifiez que vous disposez des licences Red Hat nécessaires. Vous devez disposer d'un compte Red Hat avec des droits de gestion des abonnements Red Hat (RHSM) pour Red Hat JBoss EAP. Ce droit permet à la solution entièrement automatisée (dans Démarrage rapide : Déployer un cluster JBoss EAP sur des machines virtuelles Azure) d'installer la version de JBoss EAP testée et certifiée par Red Hat.

    Remarque

    Si vous ne disposez pas d’un droit EAP, vous pouvez vous inscrire pour bénéficier d’un abonnement développeur gratuit via l’abonnement Red Hat Developer pour les particuliers. Sauvegardez de côté les détails du compte, qui seront utilisés comme nom d'utilisateur et mot de passe RHSM dans la section suivante.

  • Si vous êtes déjà inscrit, ou après avoir terminé l'inscription, vous pouvez localiser les informations d'identification nécessaires (Pool ID) en suivant les étapes suivantes. Ces ID de pool sont également utilisés comme ID de pool RHSM avec les droits EAP dans les étapes suivantes.

    1. Connectez-vous à votre compte Red Hat.

    2. La première fois que vous vous connectez, vous êtes invité à compléter votre profil. En fonction de votre utilisation, sélectionnez Personnel ou Entreprise pour le Type de compte, comme indiqué dans la capture d'écran suivante :

      Capture d'écran de la fenêtre du compte Red Hat montrant les options de Type de compte avec Personnel sélectionné.

    3. Ouvrez Abonnement développeur Red Hat pour les particuliers. Ce lien vous permet d’accéder à tous les abonnements de votre compte pour la référence SKU appropriée.

    4. Dans la ligne de contrôles sous le tableau Tous les abonnements achetés, sélectionnez Actif.

    5. Sélectionnez l'en-tête de colonne triable pour la Date de fin jusqu'à ce que la valeur la plus éloignée dans le futur soit affichée comme première ligne.

    6. Sélectionnez la première ligne. Ensuite, copiez et enregistrez de côté la valeur suivante Master Pools from Pool IDs.

  • Un Kit de développement Java (JDK), version 11. Dans ce guide, nous recommandons la version Red Hat d'OpenJDK. Assurez-vous que la variable d'environnement JAVA_HOME est correctement définie dans les interpréteurs de commandes dans lesquels vous exécutez les commandes.

  • Git; utilisez git --version pour vérifier si git fonctionne. Ce tutoriel a été testé avec la version 2.25.1.

  • Maven; utilisez mvn -version pour vérifier si mvn fonctionne. Ce tutoriel a été testé avec la version 3.6.3.

Préparer l’environnement

Dans cette section, vous configurez l'infrastructure dans laquelle vous installez le JDK, Red Hat JBoss EAP et le pilote PostgreSQL Java Database Connectivity (JDBC).

Hypothèses

Ce didacticiel configure un cluster Red Hat JBoss EAP en mode domaine avec un serveur d'administration et deux serveurs gérés sur un total de trois machines virtuelles. Pour configurer le cluster, vous devez créer les trois machines virtuelles Azure suivantes :

  • Une VM d'administration (nommé adminVM) s'exécute en tant que contrôleur de domaine.
  • Deux machines virtuelles gérées (nommées mspVM1 et mspVM2) s'exécutent en tant que contrôleur d'hôte.

Connexion à Azure

Si ce n’est pas déjà fait, connectez-vous à votre abonnement Azure à l’aide de la commande az login suivante et suivez les instructions à l’écran :

az login

Remarque

Si plusieurs locataires Azure sont associés à vos informations d’identification Azure, vous devez spécifier le locataire auquel vous souhaitez vous connecter. Vous pouvez le faire avec l'option --tenant. Par exemple : az login --tenant contoso.onmicrosoft.com.

Créer un groupe de ressources

Créez un groupe de ressources avec la commande az group create. Les noms de groupes de ressources doivent être globalement uniques au sein d’un abonnement. Pour cette raison, pensez à ajouter un identifiant unique à tous les noms que vous créez et qui doivent être uniques. Une technique utile consiste à utiliser vos initiales suivies de la date du jour au formatmmdd. Cet exemple crée un groupe de ressources nommé $RESOURCE_GROUP_NAME à l’emplacementwestus :

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

Créez un réseau virtuel

Les ressources composant votre cluster Red Hat JBoss EAP doivent communiquer entre elles, ainsi qu'avec l'internet public, à l'aide d'un réseau virtuel. Pour obtenir un guide complet sur la planification de votre réseau virtuel, consultez le guide du cadre d'adoption du cloud pour Azure Planifier des réseaux virtuels. Pour plus d'informations, consultez les questions fréquemment posées sur les réseaux virtuels Azure.

L'exemple de cette section crée un réseau virtuel avec l'espace d'adressage 192.168.0.0/16 et crée un sous-réseau utilisé pour les machines virtuelles.

Premièrement, créez un réseau virtuel à l’aide de la commande az network vnet create. L'exemple suivant crée un réseau nommé myVNet :

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

Créez un sous-réseau pour le cluster Red Hat JBoss EAP en utilisant az network vnet subnet create. L’exemple suivant permet de créer un sous-réseau nommé mySubnet :

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

Créez un sous-réseau pour Application Gateway en utilisant az network vnet subnet create. L’exemple suivant permet de créer un sous-réseau nommé jbossVMGatewaySubnet :

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

Créez un groupe de sécurité réseau et attribuez-lui des sous-réseaux.

Avant de créer des machines virtuelles avec des IP publiques, créez un groupe de sécurité réseau (NSG) pour sécuriser le réseau virtuel et les sous-réseaux créés précédemment.

Créez un groupe de sécurité réseau à l’aide de la commande az network nsg create. L’exemple suivant permet de créer un groupe de sécurité réseau nommé mynsg :

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

Créez des règles de groupe de sécurité réseau en utilisant az network nsg rule create. L'exemple suivant crée des règles de groupe de sécurité réseau nommées ALLOW_APPGW et ALLOW_HTTP_ACCESS. Ces règles permettent à App Gateway d'accepter le trafic entrant sur les ports HTTP utilisés par 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

Associez les sous-réseaux créés précédemment à ce groupe de sécurité réseau à l'aide de az network vnet subnet update, comme indiqué dans l'exemple suivant :

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

Créez une machine Red Hat Enterprise Linux pour l'administrateur

Générer des clés SSH

Utilisez la commande suivante pour générer des clés SSH pour adminVM:

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

Créez la machine virtuelle admin

L'image Marketplace que vous utilisez pour créer les machines virtuelles est RedHat:rhel-raw:86-gen2:latest. Pour d'autres images, consultez les images Red Hat Enterprise Linux (RHEL) disponibles dans Azure.

Remarque

Vous pouvez interroger toutes les images Red Hat Enterprise Linux disponibles fournies par Red Hat à l'aide de la commande az vm image list - par exemple : az vm image list --offer RHEL --publisher RedHat --output table --all. Pour plus d'informations, voir Vue d'ensemble des images Red Hat Enterprise Linux.

Si vous utilisez une image différente, vous devrez peut-être installer des bibliothèques supplémentaires pour activer l'infrastructure utilisée dans ce guide.

Créez une machine virtuelle de base, installez-y tous les outils requis, prenez-en un instantané, puis créez des répliques basées sur l'instantané.

Créez une machine virtuelle à l’aide de la commande az vm create. Vous exécutez le serveur d'administration sur cette machine virtuelle.

L’exemple suivant crée une identité managée Azure et une machine virtuelle Red Hat Enterprise Linux à l’aide de l’authentification 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

Installer Red Hat JBoss EAP

Suivez les étapes suivantes pour l'installation :

  1. Utilisez la commande suivante pour obtenir l'adresse IP publique de adminVM :

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

  2. Ouvrez un terminal et accédez au adminVM par SSH à l'aide de la commande suivante :

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

  3. Configurez le pare-feu pour les ports à l'aide de la commande suivante :

    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

    Vous devriez voir le mot success après les deux premières commandes. Vous devriez voir une sortie similaire à l'exemple suivant après la troisième commande :

    # 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

Remarque

Les RHSM_USER valeurs et RHSM_PASSWORD les valeurs sont requises pour installer Red Hat JBoss EAP. Nous vous recommandons d’utiliser un compte de service avec des autorisations limitées pour accéder au portail client Red Hat.

  1. Utilisez les commandes suivantes pour enregistrer l'hôte administrateur dans votre compte de gestion des abonnements 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

    Vous devez obtenir une sortie similaire à la suivante :

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

  2. Utilisez la commande suivante pour attacher l'hôte administrateur au pool Red Hat JBoss EAP :

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

    Remarque

    Cette commande est ignorée si vous utilisez le mode Simple Content Access.

  3. Utilisez les commandes suivantes pour installer 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

Pour les deuxième et troisième commandes, vous devriez voir plusieurs lignes de sortie se terminant par Complete!

  1. Utilisez les commandes suivantes pour définir les configurations de permission et de réseau :

    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. Utilisez les commandes suivantes pour configurer les variables d'environnement :

    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. Quittez la connexion SSH en tapant exit.

Créer des machines pour les serveurs gérés

Vous avez installé Red Hat JBoss EAP sur adminVM, qui fonctionne en tant que serveur de contrôleur de domaine. Vous devez encore préparer des machines pour exécuter les deux serveurs de contrôleur d'hôte. Ensuite, vous créez un instantané de adminVM et préparez des machines pour deux serveurs gérés, mspVM1 et mspVM2.

Cette section présente une approche pour préparer les machines avec l'instantané de adminVM. Retournez à votre terminal dans lequel Azure CLI est connecté, puis procédez comme suit :

  1. Utilisez la commande suivante pour arrêter adminVM :

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

  2. Utilisez az snapshot create pour prendre un instantané du disque du système d'exploitation adminVM, comme indiqué dans l'exemple suivant :

    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. Utilisez la commande suivante pour démarrer adminVM :

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

  4. Pour créer mspVM1, procédez comme suit :

    1. Tout d'abord, créez un disque géré pour mspVM1 avec 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. Ensuite, utilisez les commandes suivantes pour créer la machine virtuelle mspVM1, en y attachant le disque du système d'exploitation mspVM1_OsDisk_1 :

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

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

    3. Vous avez créé mspVM1 avec Red Hat JBoss EAP installé. Comme la machine virtuelle a été créée à partir d'un instantané du disque adminVM du système d'exploitation, les deux machines virtuelles ont le même nom d'hôte. Utilisez az vm run-command invoke pour changer le nom d'hôte à la valeurmspVM1 :

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

      Lorsque la commande se termine avec succès, vous obtenez une sortie similaire à l'exemple suivant :

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

  5. Utilisez les mêmes commandes pour créer 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"

Utilisez les commandes suivantes pour obtenir et afficher les adresses IP privées, que vous utiliserez dans les sections suivantes :

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

Les trois machines sont maintenant prêtes. Ensuite, vous configurez un cluster Red Hat JBoss EAP en mode domaine géré.

Configurez le domaine géré et le cluster

Configurez le cluster avec la réplication de session activée. Pour plus d'informations, reportez-vous à la section Réplication de session.

Pour activer la réplication de session, utilisez Red Hat JBoss EAP High Availability pour le cluster. Microsoft Azure ne prend pas en charge les protocoles de découverte JGroups basés sur la multidiffusion. Bien que vous puissiez utiliser d'autres protocoles de découverte JGroups (tels qu'une configuration statique (TCPPING), une base de données partagée (JDBC_PING), un ping basé sur un système de fichiers partagés (FILE_PING), ou TCPGOSSIP), nous vous recommandons fortement d'utiliser le protocole de découverte de fichiers partagés développé pour Azure : AZURE_PING. Pour plus d'informations, voir Utilisation de JBoss EAP High Availability dans Microsoft Azure.

Créer un compte de stockage Azure et un conteneur Blob pour AZURE_PING

Utilisez les commandes suivantes pour créer un compte de stockage et un conteneur 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

Ensuite, récupérez la clé du compte de stockage pour une utilisation ultérieure à l'aide de la commande suivante. Si vous voyez une erreur, attendez quelques minutes et réessayez. Il se peut que la commande précédente de création du compte de stockage n'ait pas encore été exécutée.

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}

Vous devez normalement voir la sortie suivante :

{
  "created": true
}

Configurez le contrôleur de domaine (noeud d'administration)

Ce didacticiel utilise les commandes CLI de gestion de Red Hat JBoss EAP pour configurer le contrôleur de domaine. Pour plus d'informations, reportez-vous au Guide de l'interface CLI de gestion.

Les étapes suivantes établissent la configuration du contrôleur de domaine sur adminVM. Utilisez SSH pour vous connecter au adminVM en tant qu'utilisateur azureuser. Rappelez-vous que l'adresse IP publique de adminVM a été saisie précédemment dans la variable d'environnement ADMIN_VM_PUBLIC_IP.

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

Tout d'abord, utilisez les commandes suivantes pour configurer le profil HA et les JGroups à l'aide du protocole AZURE_PING :

export HOST_VM_IP=$(hostname -I)
export STORAGE_ACCOUNT_NAME=azurepingstgabc1111rg
export CONTAINER_NAME=azurepingcontainerabc1111rg
export STORAGE_ACCESS_KEY=<the-value-from-before-you-connected-with-SSH>


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

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

La dernière strophe de sortie doit ressembler à l'exemple suivant. Si ce n'est pas le cas, recherchez et résolvez le problème avant de continuer.

[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

Ensuite, utilisez les commandes suivantes pour configurer le serveur JBoss et le service EAP :

Remarque

Les JBOSS_EAP_USER valeurs et JBOSS_EAP_PASSWORD les valeurs sont requises pour configurer l’utilisateur de gestion JBoss EAP.

# Configure the JBoss server and setup EAP service
echo 'WILDFLY_HOST_CONFIG=host-master.xml' | sudo tee -a $EAP_RPM_CONF_DOMAIN

# Configure JBoss EAP management user
export JBOSS_EAP_USER=jbossadmin
export JBOSS_EAP_PASSWORD=Secret123456
sudo $EAP_HOME/wildfly/bin/add-user.sh  -u $JBOSS_EAP_USER -p $JBOSS_EAP_PASSWORD -g 'guest,mgmtgroup'

La sortie doit être semblable à l’exemple suivant :

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'

Enfin, utilisez les commandes suivantes pour démarrer le service 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

La sortie doit être semblable à l’exemple suivant :

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

Tapez q pour quitter le pager. Quittez la connexion SSH en tapant exit.

Après avoir démarré le service Red Hat JBoss EAP, vous pouvez accéder à la console de gestion par l'intermédiaire de http://$ADMIN_VM_PUBLIC_IP:9990 dans votre navigateur Web. Connectez-vous avec le nom d'utilisateur configuré jbossadmin et le mot de passe Secret123456.

Capture d'écran de la console de gestion du contrôleur de domaine de Red Hat JBoss Enterprise Application Platform.

Sélectionnez l’onglet Runtime. Dans le volet de navigation, sélectionnez Topology. Vous devriez voir que pour l'instant votre cluster ne contient qu'un seul contrôleur de domaine :

Configurez les contrôleurs d'hôte (nœuds de travail)

Utilisez SSH pour vous connecter à mspVM1 en tant qu'utilisateur azureuser. Obtenez l'adresse IP publique de la machine virtuelle à l'aide de la commande suivante :

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

Utilisez les commandes suivantes pour configurer le contrôleur d'hôte sur 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

Utilisez les commandes suivantes pour appliquer les modifications apportées au contrôleur d'hôte à 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})"

La dernière strophe de sortie doit ressembler à l'exemple suivant. Si ce n'est pas le cas, recherchez et résolvez le problème avant de continuer.

[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

Ensuite, utilisez les commandes suivantes pour configurer le serveur JBoss et configurer le service 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

La sortie doit être semblable à l’exemple suivant :

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

Tapez q pour quitter le pager. Quittez la connexion SSH en tapant exit.

Utilisez SSH pour vous connecter à mspVM2 en tant qu'utilisateur azureuser. Obtenez l'adresse IP publique de la machine virtuelle à l'aide de la commande suivante :

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

Répétez les étapes précédentes sur mspVM2, puis quittez la connexion SSH en tapant exit.

Une fois que deux contrôleurs d'hôte sont connectés à adminVM, vous devriez être en mesure de voir la topologie du cluster, comme le montre la capture d'écran suivante :

Exposer le cluster Red Hat JBoss EAP avec Azure Application Gateway

Maintenant que vous avez créé le cluster sur des machines virtuelles Azure, cette section vous guide dans l'exposition de JBoss EAP à Internet avec Azure Application Gateway.

Créer l’instance Azure Application Gateway

Pour exposer Red Hat JBoss EAP à Internet, une adresse IP publique est nécessaire. Créez l'adresse IP publique, puis associez-y une passerelle d'applications Azure. Utilisez az network public-ip create pour la créer, comme indiqué dans l'exemple suivant :

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

Ensuite, ajoutez les serveurs backend au pool de backend de la passerelle d'applications. Demandez les adresses IP des serveurs dorsaux à l'aide des commandes suivantes. Seuls les contrôleurs d'hôte (nœuds de travail) sont configurés en tant que serveurs dorsaux.

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)

Ensuite, créez une passerelle d'applications Azure. L'exemple suivant crée une passerelle d'applications avec des contrôleurs d'hôte dans le pool de backend par défaut :

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}

Remarque

Cet exemple configure un accès simple aux serveurs Red Hat JBoss EAP avec HTTP. Si vous souhaitez un accès sécurisé, configurez la terminaison TLS/SSL en suivant les instructions de la section End to end TLS with Application Gateway.

Cet exemple expose les contrôleurs d'hôte au port 8080. Vous déployez un exemple d'application avec une connexion de base de données au cluster dans les étapes ultérieures.

Connecter Azure Database pour un serveur flexible PostgreSQL

Cette section vous montre comment créer une instance d'Azure Database for serveur flexible PostgreSQL et configurer une connexion à PostgreSQL sur votre cluster Red Hat JBoss EAP.

Créer une instance d'Azure Database pour serveur flexible PostgreSQL

Suivez les étapes suivantes pour créer l'instance de base de données :

  1. Utilisez az postgres flexible-server create pour provisionner une instance d'Azure Database pour serveur flexible PostgreSQL, comme indiqué dans l'exemple suivant :

    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. Utilisez les commandes suivantes pour autoriser l'accès à partir des services 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. Utilisez la commande suivante pour créer la base de données :

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

Installer le pilote

Pour installer le pilote JDBC avec l’interface CLI de gestion JBoss, procédez comme suit :

  1. Accédez en SSH à adminVM à l'aide de la commande suivante. Vous pouvez sauter cette étape si une connexion est déjà ouverte.

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

  2. Utilisez les commandes suivantes pour télécharger le pilote JDBC sur 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. Utilisez les commandes suivantes pour copier le pilote JDBC vers les contrôleurs hôtes :

    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"

    Le journal du serveur se trouve sur mspVM1 et mspVM2 à /var/opt/rh/eap7/lib/wildfly/domain/servers/mspvm1-server0/log/server.log. Si le déploiement échoue, examinez ce fichier journal et résolvez le problème avant de continuer.

  1. Utilisez les commandes suivantes pour inscrire le pilote 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)"

Configurez la connexion à la base de données pour le cluster Red Hat JBoss EAP

Vous avez démarré le serveur de base de données, obtenu l'ID de ressource nécessaire et installé le pilote JDBC. Ensuite, les étapes de cette section vous montrent comment utiliser le CLI JBoss pour configurer une connexion de source de données avec l'instance PostgreSQL que vous avez créée précédemment.

  1. Ouvrez un terminal et connectez-vous en SSH à adminVM à l'aide de la commande suivante :

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

  2. Créez la source de données à l'aide des commandes suivantes :

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

Vous avez configuré avec succès une source de données nommée java:jboss/datasources/JavaEECafeDB.

Déployer l'exemple d'application Java EE Cafe

Suivez les étapes suivantes pour déployer l'exemple d'application Java EE Cafe sur le cluster Red Hat JBoss EAP :

  1. Utilisez les étapes suivantes pour construire Java EE Cafe. Ces étapes supposent que vous disposez d'un environnement local avec Git et Maven installés :

    1. Utilisez la commande suivante pour cloner le code source à partir de GitHub :

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

    2. Utilisez la commande suivante pour générer le code source :

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

      Cette commande crée le fichier eap-coffee-app/target/javaee-cafe.war. Vous chargez ce fichier à l'étape suivante.

  2. Ouvrez un navigateur Web et rendez-vous sur la console de gestion à l'adresse http://<adminVM-public-IP>:9990, puis connectez-vous avec le nom d'utilisateur jbossadmin et le mot de passe Secret123456.

  3. Suivez les étapes suivantes pour charger le fichier javaee-cafe.war dans le référentiel de contenu :

    1. Dans l'onglet Déploiements de la console de gestion de Red Hat JBoss EAP, sélectionnez Référentiel de contenu dans le volet de navigation.

    2. Sélectionnez le bouton Ajouter, puis sélectionnez Charger le contenu.

      Capture d'écran de l'onglet Déploiements de Red Hat JBoss Enterprise Application Platform avec l'option de menu Charger du contenu en surbrillance.

    3. Utilisez le sélecteur de fichier de navigateur pour sélectionner le fichier javaee-cafe.war.

    4. Cliquez sur Suivant.

    5. Acceptez les valeurs par défaut sur l’écran suivant, puis sélectionnez Finish.

    6. Sélectionnez View content.

  4. Suivez les étapes suivantes pour déployer une application sur main-server-group :

    1. Dans Content Repository, sélectionnez javaee-cafe.war.

    2. Dans le menu déroulant, sélectionnez Déployer.

    3. Sélectionnez main-server-group comme groupe de serveurs pour déployer javaee-cafe.war.

    4. Sélectionnez Déployer pour démarrer le déploiement. Une notification similaire à la capture d’écran suivante doit s’afficher :

      Capture d’écran de la notification de réussite du déploiement.

Testez la configuration du cluster Red Hat JBoss EAP

Vous avez configuré le cluster JBoss EAP et y avez déployé l'application. Suivez les étapes suivantes pour accéder à l'application et valider tous les paramètres :

  1. Utilisez la commande suivante pour obtenir l'adresse IP publique de la passerelle d'applications Azure :

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

  2. Ouvrez un navigateur web.

  3. Accédez à l’application avec l’URL http://<gateway-public-ip-address>/javaee-cafe/. N'oubliez pas la barre oblique de fin.

  4. Essayez d’ajouter et de supprimer des cafés.

Nettoyer les ressources

Pour éviter des frais Azure, vous devez nettoyer les ressources non nécessaires. Lorsque vous n'avez plus besoin du cluster Red Hat JBoss EAP déployé sur une machine virtuelle Azure, désenregistrez les serveurs Red Hat JBoss EAP et supprimez les ressources Azure.

Utilisez les commandes suivantes pour désenregistrer les serveurs Red Hat JBoss EAP et les machines virtuelles de la gestion des abonnements 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"

Utilisez la commande suivante pour supprimer le groupe de ressources $RESOURCE_GROUP_NAME :

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

Étapes suivantes

Continuez à explorer les options permettant d'exécuter JBoss EAP sur Azure.

Explorer JBoss EAP sur Azure