Exercice – Configurer un équilibreur de charge public

  • 10 minutes

Vous pouvez configurer Azure Load Balancer à partir du portail Azure, de PowerShell ou d’Azure CLI.

Dans votre organisation médicale, vous souhaitez équilibrer la charge du trafic client afin de fournir une réponse homogène en fonction de l’intégrité des serveurs web du portail des patients. Vous disposez de deux machines virtuelles (VM) dans un même groupe à haute disponibilité qui doivent jouer le rôle d’application web du portail médical.

Ici, vous allez créer une ressource d’équilibreur de charge et l’utiliser pour répartir une charge entre les machines virtuelles.

Déployer l’application web du portail des patients

Pour commencer, déployez l’application de portail des patients sur deux machines virtuelles dans un même groupe à haute disponibilité. Pour gagner du temps, commençons par exécuter un script qui va créer cette application. Le script :

  • Crée un réseau virtuel et une infrastructure réseau pour les machines virtuelles.
  • Crée deux machines virtuelles dans ce réseau virtuel.

Pour déployer l’application web du portail des patients :

  1. Exécutez la commande git clone suivante dans Azure Cloud Shell. La commande clone le dépôt qui contient la source de l’application et exécute le script d’installation à partir de GitHub. Vous passez ensuite au répertoire du référentiel cloné.

    git clone https://github.com/MicrosoftDocs/mslearn-improve-app-scalability-resiliency-with-load-balancer.git
cd mslearn-improve-app-scalability-resiliency-with-load-balancer

  2. Comme son nom l’indique, le script génère deux machines virtuelles dans un même groupe à haute disponibilité. Son exécution prend environ deux minutes.

    bash create-high-availability-vm-with-sets.sh <rgn>[sandbox resource group name]</rgn>

  3. Une fois le script terminé, dans le menu du portail Azure ou dans la page Accueil, sélectionnez Groupes de ressources, puis choisissez le groupe de ressources [nom du groupe de ressources de bac à sable]. Examinez les ressources créées par le script.

Créer un équilibreur de charge

À présent, créons l’équilibreur de charge.

  1. Dans le menu du portail Azure ou la page Accueil, sous Services Azure, sélectionnez Créer une ressource. Le volet Créer une ressource apparaît.

  2. Dans la zone de recherche dans les services et la marketplace, entrez Load Balancer, puis appuyez sur Entrée.

  3. Dans la liste suivante, sélectionnez Load Balancer – Microsoft, puis sélectionnez Créer.

    Créer une instance de Load Balancer dans le portail Azure.

  4. Sous l’onglet Informations de base, entrez les valeurs suivantes pour chaque paramètre :

    Paramètre Valeur
    Détails du projet
    Abonnement Votre abonnement
    Resource group Sélectionnez [nom du groupe de ressources de bac à sable]
    Détails de l’instance
    Nom Entrez un nom unique. Par exemple, Pub-LB-PatientsPortal.
    Région Sélectionnez l’emplacement où les machines virtuelles ont été créées.
    Référence (SKU) Standard
    Type Public
    Niveau Regional

    Capture d’écran montrant l’onglet Informations de base de l’écran Créer un équilibreur de charge dans le portail Azure

Ajouter une configuration IP frontale

  1. Sélectionnez Suivant : Configuration d’adresse IP frontale.

  2. Sélectionnez + Ajouter une configuration IP front-end. Le volet Ajouter une configuration IP front-end s’affiche.

  3. Entrez les valeurs suivantes pour chaque paramètre.

    Paramètre Valeur
    Nom Entrez un nom unique pour la configuration IP front-end. Par exemple, myFrontendIP
    Version IP Sélectionnez IPv4
    Type IP Sélectionnez Adresse IP
    Adresse IP publique Sélectionnez Créer une nouvelle adresse IP, puis donnez un nom à votre adresse IP. Ensuite, sélectionnez Enregistrer
    Équilibreur de charge de passerelle Sélectionnez Aucun

    Capture d’écran montrant les paramètres renseignés dans Ajouter une configuration IP front-end.

  4. Pour fermer la boîte de dialogue, sélectionnez Enregistrer. Le volet Créer un équilibreur de charge s’affiche.

Ajouter un pool principal

  1. Sélectionnez Suivant : Pools principaux.

  2. Sélectionnez + Ajouter un pool de back-ends. Le volet Ajouter un pool principal s’affiche.

  3. Entrez les valeurs suivantes pour chaque paramètre.

    Paramètre Valeur
    Nom Entrez un nom unique pour le pool de back-ends. Par exemple, bepool-http.
    Réseau virtuel Vérifiez que bePortalVnet est sélectionné.

  4. Sous Configurations IP, sélectionnez Ajouter. Le volet Ajouter des configurations IP au pool de back-ends s’affiche.

  5. Sous Machine virtuelle, sélectionnez les machines virtuelles webVM1 et webVM2, puis sélectionnez Ajouter.

    Capture d’écran montrant les paramètres dans le volet Ajouter des configurations IP au pool de back-ends.

  6. L’écran Ajouter un pool de back-ends. réapparaît. Sous Configurations IP, sélectionnez les machines virtuelles webVM1 et webVM2, puis sélectionnez Enregistrer. L’écran Créer un équilibreur de charge réapparaît.

    Capture d’écran montrant les paramètres renseignés dans l’écran Ajouter un pool de back-ends.

Ajouter une règle d’équilibrage de charge

Pour finir, nous allons créer une règle pour l’équilibreur de charge.

  1. Sélectionnez Suivant : Règles de trafic entrant.

  2. Dans la section Règle d’équilibrage de charge, sélectionnez + Ajouter une règle d’équilibrage de charge. Le volet Ajouter une règle d’équilibrage de charge s’affiche.

  3. Entrez les valeurs suivantes pour chaque paramètre.

    Paramètre Valeur
    Nom Nom de la règle d’équilibrage de charge. Par exemple, lbrule-http.
    Version de l’adresse IP IPv4
    Adresse IP du serveur frontal Sélectionnez l’adresse IP front-end que vous avez nommée précédemment.
    Pool principal Sélectionnez le pool de back-ends que vous avez nommé précédemment. Par exemple, bepool-http.
    Protocol TCP
    Port Entrez 80 (valeur par défaut).
    Port principal Entrez 80 (valeur par défaut).
    Sonde d’intégrité Sélectionnez le lien Créer nouveau. La boîte de dialogue Ajouter une sonde d’intégrité s’affiche.

  4. Entrez les valeurs suivantes pour chaque paramètre.

    Paramètre Valeur
    Nom Nom de la sonde d’intégrité. Par exemple, healthprobe-http.
    Protocol TCP
    Port Entrez 80 (valeur par défaut).
    Intervalle Entrez 5 (valeur par défaut). Cette valeur correspond au temps qui s’écoule entre les sondes.

  5. Sélectionnez Enregistrer pour fermer la boîte de dialogue. Le volet Ajouter une règle d’équilibrage de charge réapparaît.

  6. Entrez les valeurs suivantes pour chaque paramètre.

    Paramètre Valeur
    Persistance de session* Aucun (par défaut)
    Délai d’inactivité (minutes) Sélectionnez 4 (valeur par défaut). Cette valeur correspond au temps nécessaire pour maintenir une connexion du protocole TCP ou HTTP ouverte sans que les clients n’envoient de messages keep-alive.
    IP flottante Désactivé (valeur par défaut).

    Ajouter une nouvelle règle d’équilibrage de charge.

  7. Sélectionnez Enregistrer pour achever la configuration de la règle d’équilibrage de charge.

  8. L’écran Créer un équilibreur de charge réapparaît. Sélectionnez Revoir + créer.

  9. Quand la validation réussit, sélectionnez Créer. Une fois le déploiement terminé, sélectionnez Accéder à la ressource.

  10. Dans la page Vue d’ensemble, copiez et enregistrez l’Adresse IP publique. Vous devrez peut-être sélectionner Afficher plus... pour voir l’adresse IP publique.

Créer des adresses IP

Pour commencer, nous avons besoin d’une adresse IP publique pour l’équilibreur de charge.

  1. Dans Cloud Shell, démarrez PowerShell en exécutant cette commande :

    pwsh

  2. Dans PowerShell, créez une adresse IP publique :

    $Location = $(Get-AzureRmResourceGroup -ResourceGroupName <rgn>[sandbox resource group name]</rgn>).Location

$publicIP = New-AzPublicIpAddress `
  -ResourceGroupName <rgn>[sandbox resource group name]</rgn> `
  -Location $Location `
  -AllocationMethod "Static" `
  -Name "myPublicIP"

  3. Créez un IP front-end en utilisant l’applet de commande New-AzLoadBalancerFrontendIpConfig. Le code suivant crée une configuration IP front-end nommée myFrontEnd et joint l’adresse myPublicIP :

    $frontendIP = New-AzLoadBalancerFrontendIpConfig `
  -Name "myFrontEnd" `
  -PublicIpAddress $publicIP

Créer l’équilibreur de charge

Quand vous utilisez PowerShell pour configurer un équilibreur de charge, vous devez créer le pool d’adresses back-end, la sonde d’intégrité et la règle avant de créer l’équilibreur lui-même.

  1. Créez un pool d’adresses back-end en exécutant l’applet de commande New-AzLoadBalancerBackendAddressPoolConfig. Vous attacherez les machines virtuelles à ce pool de back-ends au cours des dernières étapes. L’exemple suivant crée un pool d’adresses back-end nommé myBackEndPool :

    $backendPool = New-AzLoadBalancerBackendAddressPoolConfig -Name "myBackEndPool"

  2. Créez une sonde d’intégrité pour permettre à l’équilibreur de charge de superviser l’état du portail médical. La sonde d’intégrité ajoute ou supprime dynamiquement des machines virtuelles de la rotation de l’équilibreur de charge en fonction de leur réponse aux vérifications d’intégrité.

    $probe = New-AzLoadBalancerProbeConfig `
  -Name "myHealthProbe" `
  -Protocol http `
  -Port 80 `
  -IntervalInSeconds 5 `
  -ProbeCount 2 `
  -RequestPath "/"

  3. Vous avez maintenant besoin d’une règle d’équilibreur de charge pour définir le mode de distribution du trafic aux machines virtuelles. Vous définissez la configuration IP frontale pour le trafic entrant et le pool d’adresses IP principal pour recevoir le trafic, ainsi que le port source et le port de destination requis. Pour faire en sorte que seules les machines virtuelles saines reçoivent le trafic, vous devez aussi définir la sonde d’intégrité à utiliser.

    $lbrule = New-AzLoadBalancerRuleConfig `
  -Name "myLoadBalancerRule" `
  -FrontendIpConfiguration $frontendIP `
  -BackendAddressPool $backendPool `
  -Protocol Tcp `
  -FrontendPort 80 `
  -BackendPort 80 `
  -Probe $probe

  4. Maintenant, vous pouvez créer l’équilibreur de charge de base en exécutant l’applet de commande New-AzLoadBalancer :

    $lb = New-AzLoadBalancer `
  -ResourceGroupName <rgn>[sandbox resource group name]</rgn> `
  -Name 'MyLoadBalancer' `
  -Location $Location `
  -FrontendIpConfiguration $frontendIP `
  -BackendAddressPool $backendPool `
  -Probe $probe `
  -LoadBalancingRule $lbrule

  5. Connectez les machines virtuelles au pool de back-ends en mettant à jour les interfaces réseau que le script a créées pour utiliser les informations du pool de back-ends.

    $nic1 = Get-AzNetworkInterface -ResourceGroupName <rgn>[sandbox resource group name]</rgn> -Name "webNic1"
$nic2 = Get-AzNetworkInterface -ResourceGroupName <rgn>[sandbox resource group name]</rgn> -Name "webNic2"

$nic1.IpConfigurations[0].LoadBalancerBackendAddressPools = $backendPool
$nic2.IpConfigurations[0].LoadBalancerBackendAddressPools = $backendPool

Set-AzNetworkInterface -NetworkInterface $nic1 -AsJob
Set-AzNetworkInterface -NetworkInterface $nic2 -AsJob

  6. Exécutez la commande suivante pour obtenir l’adresse IP publique de l’équilibreur de charge et l’URL de votre site web :

    Write-Host http://$($(Get-AzPublicIPAddress `
  -ResourceGroupName <rgn>[sandbox resource group name]</rgn> `
  -Name "myPublicIP").IpAddress)

Créer un équilibreur de charge

Utilisons Azure CLI pour créer l’équilibreur de charge et ses ressources associées.

  1. Créez une adresse IP publique.

    az network public-ip create \
  --resource-group <rgn>[sandbox resource group name]</rgn> \
  --allocation-method Static \
  --name myPublicIP

  2. Créez l’équilibreur de charge.

    az network lb create \
  --resource-group <rgn>[sandbox resource group name]</rgn> \
  --name myLoadBalancer \
  --public-ip-address myPublicIP \
  --frontend-ip-name myFrontEndPool \
  --backend-pool-name myBackEndPool

  3. Créez une sonde d’intégrité qui permet à l’équilibreur de charge de surveiller l’état du portail de santé. La sonde d’intégrité ajoute ou supprime dynamiquement des machines virtuelles de la rotation de l’équilibreur de charge en fonction de leur réponse aux vérifications d’intégrité.

    az network lb probe create \
  --resource-group <rgn>[sandbox resource group name]</rgn> \
  --lb-name myLoadBalancer \
  --name myHealthProbe \
  --protocol tcp \
  --port 80

  4. Il vous faut maintenant une règle d’équilibreur de charge pour définir le mode de distribution du trafic aux machines virtuelles. Vous définissez la configuration IP frontale pour le trafic entrant et le pool d’adresses IP principal pour recevoir le trafic, ainsi que le port source et le port de destination requis. Pour faire en sorte que seules les machines virtuelles saines reçoivent le trafic, vous devez aussi définir la sonde d’intégrité à utiliser.

    az network lb rule create \
  --resource-group <rgn>[sandbox resource group name]</rgn> \
  --lb-name myLoadBalancer \
  --name myHTTPRule \
  --protocol tcp \
  --frontend-port 80 \
  --backend-port 80 \
  --frontend-ip-name myFrontEndPool \
  --backend-pool-name myBackEndPool \
  --probe-name myHealthProbe

  5. Connectez les machines virtuelles au pool de back-ends en mettant à jour les interfaces réseau que le script a créées pour utiliser les informations du pool de back-ends.

    az network nic ip-config update \
  --resource-group <rgn>[sandbox resource group name]</rgn> \
  --nic-name webNic1 \
  --name ipconfig1 \
  --lb-name myLoadBalancer \
  --lb-address-pools myBackEndPool

az network nic ip-config update \
  --resource-group <rgn>[sandbox resource group name]</rgn> \
  --nic-name webNic2 \
  --name ipconfig1 \
  --lb-name myLoadBalancer \
  --lb-address-pools myBackEndPool

  6. Exécutez la commande suivante pour obtenir l’adresse IP publique de l’équilibreur de charge et l’URL de votre site web :

    echo http://$(az network public-ip show \
                --resource-group <rgn>[sandbox resource group name]</rgn> \
                --name myPublicIP \
                --query ipAddress \
                --output tsv)

Tester la configuration de l’équilibreur de charge

Testons la configuration de l’équilibreur de charge pour voir comment il peut gérer les problèmes de disponibilité et d’intégrité de manière dynamique.

  1. Sous un nouvel onglet du navigateur, accédez à l’adresse IP publique que vous avez notée. Une réponse de l’une des machines virtuelles s’affiche dans le navigateur.

  2. Tentez une « actualisation forcée » en appuyant plusieurs fois sur Ctrl+F5 pour vérifier que la réponse est bien retournée de manière aléatoire par les deux machines virtuelles.

  3. Dans le menu du portail Azure ou dans la page Accueil, sélectionnez Toutes les ressources. Sélectionnez ensuite webVM1, puis Arrêter.

  4. Revenez à l’onglet où figure le site web et forcez une actualisation de la page web. Toutes les requêtes sont retournées par webVM2.