Tutoriel : Équilibrer la charge des machines virtuelles Windows dans Azure pour créer une application hautement disponible avec Azure PowerShell

S’applique aux : ✔️ Machines virtuelles Windows ✔️ Ensembles de machines virtuelles uniformes

L’équilibrage de charge offre un niveau de disponibilité plus élevé en répartissant les requêtes entrantes sur plusieurs machines virtuelles. Dans ce tutoriel, vous allez découvrir les différents composants de l’équilibreur de charge Azure qui distribuent le trafic et fournissent une haute disponibilité. Vous apprenez à :

Vue d’ensemble de l’équilibreur de charge Azure

Un équilibreur de charge Azure est un équilibreur de charge de couche 4 (TCP, UDP) qui fournit une haute disponibilité en distribuant le trafic entrant entre des machines virtuelles saines. Une sonde d’intégrité de l’équilibreur de charge surveille un port donné sur chaque machine virtuelle et distribue uniquement le trafic vers une machine virtuelle opérationnelle.

Vous définissez une configuration d’adresse IP frontale qui contient une ou plusieurs adresses IP publiques. Cette configuration IP frontale permet à votre équilibreur de charge et à vos applications d’être accessibles via Internet.

Les machines virtuelles se connectent à un équilibreur de charge à l’aide de leur carte d’interface réseau virtuelle. Pour distribuer le trafic vers les machines virtuelles, un pool d’adresses back-end contient les adresses IP des cartes réseau connectées à l’équilibreur de charge.

Pour contrôler le flux de trafic, vous définissez des règles d’équilibreur de charge pour des ports et protocoles spécifiques mappés à vos machines virtuelles.

Démarrer Azure Cloud Shell

Azure Cloud Shell est un interpréteur de commandes interactif et gratuit que vous pouvez utiliser pour exécuter les étapes de cet article. Il dispose d’outils Azure courants préinstallés et configurés pour être utilisés avec votre compte.

Pour ouvrir Cloud Shell, sélectionnez simplement Essayer en haut à droite d’un bloc de code. Vous pouvez aussi lancer Cloud Shell dans un onglet distinct du navigateur en accédant à https://shell.azure.com/powershell. Sélectionnez Copier pour copier les blocs de code, collez-les dans Cloud Shell, puis appuyez sur Entrée pour les exécuter.

Créer un équilibreur de charge Azure

Cette section explique comment créer et configurer chaque composant de l’équilibreur de charge. Avant de pouvoir créer votre équilibreur de charge, créez un groupe de ressources avec New-AzResourceGroup. L’exemple suivant crée un groupe de ressources nommé myResourceGroupLoadBalancer à l’emplacement EastUS :

New-AzResourceGroup `
  -ResourceGroupName "myResourceGroupLoadBalancer" `
  -Location "EastUS"

Créer une adresse IP publique

Pour accéder à votre application sur Internet, vous avez besoin d’une adresse IP publique pour l’équilibreur de charge. Créez une adresse IP publique avec New-AzPublicIpAddress. L’exemple suivant crée une adresse IP publique nommée myPublicIP dans le groupe de ressources myResourceGroupLoadBalancer :

$publicIP = New-AzPublicIpAddress `
  -ResourceGroupName "myResourceGroupLoadBalancer" `
  -Location "EastUS" `
  -AllocationMethod "Static" `
  -Name "myPublicIP"

Créer un équilibrage de charge

Créez un pool d’adresses IP de façade avec New-AzLoadBalancerFrontendIpConfig. L’exemple suivant crée un pool d’adresses IP frontales nommé myFrontEndPool et attache l’adresse myPublicIP :

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

Créez un pool d'adresses backend avec New-AzLoadBalancerBackendAddressPoolConfig. Les machines virtuelles s’attachent à ce pool principal lors des étapes suivantes. L’exemple suivant crée un pool d’adresses back-end nommé myBackEndPool:

$backendPool = New-AzLoadBalancerBackendAddressPoolConfig `
  -Name "myBackEndPool"

À présent, créez l’équilibreur de charge avec New-AzLoadBalancer. L’exemple suivant crée un équilibreur de charge nommé myLoadBalancer à l’aide des pools IP frontend et back-end créés aux étapes précédentes :

$lb = New-AzLoadBalancer `
  -ResourceGroupName "myResourceGroupLoadBalancer" `
  -Name "myLoadBalancer" `
  -Location "EastUS" `
  -FrontendIpConfiguration $frontendIP `
  -BackendAddressPool $backendPool

Créer une sonde de santé

Pour permettre à l'équilibreur de charge de surveiller l'état de votre application, vous utilisez une sonde de santé. La sonde d’intégrité ajoute ou supprime dynamiquement les machines virtuelles de la rotation de l’équilibreur de charge en fonction de leur réponse aux vérifications d’intégrité. Par défaut, une machine virtuelle est supprimée de la distribution de l’équilibreur de charge après deux échecs consécutifs à des intervalles de 15 secondes. Vous créez une sonde d’intégrité basée sur un protocole ou une page de vérification d’intégrité spécifique pour votre application.

L’exemple suivant crée une sonde TCP. Vous pouvez également créer des sondes HTTP sur mesure pour des contrôles de santé plus détaillés. Lorsque vous utilisez une sonde HTTP personnalisée, vous devez créer la page de vérification d’intégrité, telle que healthcheck.aspx. La sonde doit retourner une réponse HTTP 200 OK pour que l’équilibreur de charge conserve l’hôte en rotation.

Pour créer une sonde d’intégrité TCP, vous utilisez Add-AzLoadBalancerProbeConfig. L’exemple suivant crée une sonde d’intégrité nommée myHealthProbe qui surveille chaque machine virtuelle sur port TCP80:

Add-AzLoadBalancerProbeConfig `
  -Name "myHealthProbe" `
  -LoadBalancer $lb `
  -Protocol tcp `
  -Port 80 `
  -IntervalInSeconds 15 `
  -ProbeCount 2

Pour appliquer la sonde de santé, mettez à jour l’équilibreur de charge avec Set-AzLoadBalancer:

Set-AzLoadBalancer -LoadBalancer $lb

Créer une règle d’équilibreur de charge

Une règle d’équilibrage de charge est utilisée pour définir la distribution du trafic vers les 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 vous assurer que seules les machines virtuelles saines reçoivent du trafic, vous définissez également la sonde d’intégrité à utiliser.

Créez une règle d’équilibreur de charge avec Add-AzLoadBalancerRuleConfig. L’exemple suivant crée une règle d’équilibreur de charge nommée myLoadBalancerRule et équilibre le trafic sur port TCP80:

$probe = Get-AzLoadBalancerProbeConfig -LoadBalancer $lb -Name "myHealthProbe"

Add-AzLoadBalancerRuleConfig `
  -Name "myLoadBalancerRule" `
  -LoadBalancer $lb `
  -FrontendIpConfiguration $lb.FrontendIpConfigurations[0] `
  -BackendAddressPool $lb.BackendAddressPools[0] `
  -Protocol Tcp `
  -FrontendPort 80 `
  -BackendPort 80 `
  -Probe $probe

Mettez à jour l’équilibreur de charge avec set-AzLoadBalancer:

Set-AzLoadBalancer -LoadBalancer $lb

Configurer un réseau virtuel

Avant de déployer des machines virtuelles et de tester votre répartiteur de charges, créez les ressources de réseau virtuel nécessaires. Pour plus d’informations sur les réseaux virtuels, consultez le didacticiel Gérer les réseaux virtuels Azure.

Créer des ressources réseau

Créez un réseau virtuel avec New-AzVirtualNetwork. L’exemple suivant crée un réseau virtuel nommé myVnet avec un sous-réseau nommé mySubnet :

# Create subnet config
$subnetConfig = New-AzVirtualNetworkSubnetConfig `
  -Name "mySubnet" `
  -AddressPrefix 192.168.1.0/24

# Create the virtual network
$vnet = New-AzVirtualNetwork `
  -ResourceGroupName "myResourceGroupLoadBalancer" `
  -Location "EastUS" `
  -Name "myVnet" `
  -AddressPrefix 192.168.0.0/16 `
  -Subnet $subnetConfig

Les cartes réseau virtuelles sont créées avec New-AzNetworkInterface. L’exemple suivant crée trois cartes réseau virtuelles. (Une carte d’interface réseau virtuelle pour chaque machine virtuelle que vous créez pour votre application dans les étapes suivantes). Vous pouvez créer des cartes réseau virtuelles et des machines virtuelles supplémentaires à tout moment et les ajouter à l’équilibreur de charge :

for ($i=1; $i -le 3; $i++)
{
   New-AzNetworkInterface `
     -ResourceGroupName "myResourceGroupLoadBalancer" `
     -Name myVM$i `
     -Location "EastUS" `
     -Subnet $vnet.Subnets[0] `
     -LoadBalancerBackendAddressPool $lb.BackendAddressPools[0]
}

Créer des machines virtuelles

Pour améliorer la haute disponibilité de votre application, placez vos machines virtuelles dans un groupe à haute disponibilité.

Créez un ensemble de disponibilités avec la commande New-AzAvailabilitySet. L’exemple suivant permet de créer un groupe à haute disponibilité nommé myAvailabilitySet :

$availabilitySet = New-AzAvailabilitySet `
  -ResourceGroupName "myResourceGroupLoadBalancer" `
  -Name "myAvailabilitySet" `
  -Location "EastUS" `
  -Sku aligned `
  -PlatformFaultDomainCount 2 `
  -PlatformUpdateDomainCount 2

Définissez un nom d’utilisateur administrateur et un mot de passe pour les machines virtuelles avec Get-Credential :

$cred = Get-Credential

Vous pouvez maintenant créer les machines virtuelles avec New-AzVM. L’exemple suivant crée trois machines virtuelles et les composants de réseau virtuel requis s’ils n’existent pas déjà :

for ($i=1; $i -le 3; $i++)
{
    New-AzVm `
        -ResourceGroupName "myResourceGroupLoadBalancer" `
        -Name "myVM$i" `
        -Location "East US" `
        -VirtualNetworkName "myVnet" `
        -SubnetName "mySubnet" `
        -SecurityGroupName "myNetworkSecurityGroup" `
        -OpenPorts 80 `
        -AvailabilitySetName "myAvailabilitySet" `
        -Credential $cred `
        -AsJob
}

Le paramètre -AsJob crée la machine virtuelle en tant que tâche en arrière-plan. Par conséquent, PowerShell vous invite à revenir. Vous pouvez afficher les détails des travaux en arrière-plan avec l’applet de commande Job. La création et la configuration des trois machines virtuelles prennent quelques minutes.

Installer IIS avec l’extension de script personnalisé

Dans un didacticiel précédent sur Comment personnaliser une machine virtuelle Windows, vous avez appris à automatiser la personnalisation des machines virtuelles avec l’extension de script personnalisé pour Windows. Vous pouvez utiliser la même approche pour installer et configurer IIS sur vos machines virtuelles.

Utilisez Set-AzVMExtension pour installer l’extension de script personnalisé. L’extension s’exécute powershell Add-WindowsFeature Web-Server pour installer le serveur web IIS, puis met à jour la page Default.htm pour afficher le nom d’hôte de la machine virtuelle :

for ($i=1; $i -le 3; $i++)
{
   Set-AzVMExtension `
     -ResourceGroupName "myResourceGroupLoadBalancer" `
     -ExtensionName "IIS" `
     -VMName myVM$i `
     -Publisher Microsoft.Compute `
     -ExtensionType CustomScriptExtension `
     -TypeHandlerVersion 1.8 `
     -SettingString '{"commandToExecute":"powershell Add-WindowsFeature Web-Server; powershell Add-Content -Path \"C:\\inetpub\\wwwroot\\Default.htm\" -Value $($env:computername)"}' `
     -Location EastUS
}

Tester l’équilibreur de charge

Obtenez l’adresse IP publique de votre équilibreur de charge avec Get-AzPublicIPAddress. L’exemple suivant obtient l’adresse IP de myPublicIP créée précédemment :

Get-AzPublicIPAddress `
  -ResourceGroupName "myResourceGroupLoadBalancer" `
  -Name "myPublicIP" | select IpAddress

Vous pouvez ensuite entrer l’adresse IP publique dans un navigateur web. Le site web s’affiche, y compris le nom d’hôte de la machine virtuelle vers laquelle l’équilibreur de charge a distribué le trafic comme dans l’exemple suivant :

Pour voir l’équilibreur de charge distribuer le trafic sur l'ensemble des trois machines virtuelles exécutant votre application, vous pouvez effectuer un rafraîchissement forcé de votre navigateur web.

Ajouter et supprimer des machines virtuelles

Vous devrez peut-être effectuer une maintenance sur les machines virtuelles exécutant votre application, telles que l’installation des mises à jour du système d’exploitation. Pour gérer l’augmentation du trafic vers votre application, vous devrez peut-être ajouter des machines virtuelles supplémentaires. Cette section vous montre comment supprimer ou ajouter une machine virtuelle de l’équilibreur de charge.

Supprimer une machine virtuelle de l’équilibreur de charge

Obtenez la carte d’interface réseau avec Get-AzNetworkInterface, puis définissez la propriété LoadBalancerBackendAddressPools de la carte réseau virtuelle sur $null. Enfin, mettez à jour la carte réseau virtuelle .

$nic = Get-AzNetworkInterface `
    -ResourceGroupName "myResourceGroupLoadBalancer" `
    -Name "myVM2"
$nic.Ipconfigurations[0].LoadBalancerBackendAddressPools=$null
Set-AzNetworkInterface -NetworkInterface $nic

Pour voir l’équilibreur de charge répartir le trafic entre les deux machines virtuelles restantes exécutant votre application, vous pouvez actualiser votre navigateur web de manière forcée. Vous pouvez maintenant effectuer une maintenance sur la machine virtuelle, comme l’installation des mises à jour du système d’exploitation ou l’exécution d’un redémarrage de machine virtuelle.

Ajouter une machine virtuelle à l’équilibreur de charge

Après avoir effectué une maintenance de machine virtuelle, ou si vous devez étendre la capacité, définissez la propriété LoadBalancerBackendAddressPools de la carte réseau virtuelle sur la BackendAddressPool à partir de Get-AzLoadBalancer:

Obtenez l’équilibreur de charge :

$lb = Get-AzLoadBalancer `
    -ResourceGroupName myResourceGroupLoadBalancer `
    -Name myLoadBalancer 
$nic.IpConfigurations[0].LoadBalancerBackendAddressPools=$lb.BackendAddressPools[0]
Set-AzNetworkInterface -NetworkInterface $nic

Étapes suivantes

Dans ce tutoriel, vous avez créé un équilibreur de charge et des machines virtuelles attachées à celui-ci. Vous avez appris à :

Passez au tutoriel suivant pour apprendre à gérer la mise en réseau des machines virtuelles.