Déployer une application double pile IPv6 avec un équilibreur de charge interne standard dans Azure à l’aide de PowerShell

Article
06/27/2024

Cet article montre comment déployer dans Azure une application double pile (IPv4 + IPv6) incluant un sous-réseau et un réseau virtuel double pile, un équilibreur de charge Standard Load Balancer interne avec des configurations front-end doubles (IPv4 + IPv6), des machines virtuelles dont les cartes réseau présentent une configuration double IP, des groupes de sécurité réseau et des adresses IP publiques.

La procédure de création d’un équilibreur de charge interne compatible IPv6 est quasiment identique à la procédure de création d’un Load Balancer IPv6 exposé à Internet décrite ici. Les seules différences pour créer un équilibreur de charge interne concernent la configuration front-end, comme illustré dans l’exemple PowerShell ci-dessous :

 $frontendIPv6 = New-AzLoadBalancerFrontendIpConfig `
 -Name "dsLbFrontEnd_v6" `
 -PrivateIpAddress "fd00:db8:deca:deed::100" `
 -PrivateIpAddressVersion "IPv6" `
 -Subnet $DsSubnet

Les modifications qui font de la configuration ci-dessus une configuration front-end d’équilibreur de charge interne sont les suivantes :

« IPv6 » est spécifié pour PrivateIpAddressVersion.
L’argument -PublicIpAddress a été omis ou remplacé par -PrivateIpAddress. Notez que l’adresse privée doit être comprise dans la plage de l’espace d’adressage IP de sous-réseau dans lequel l’équilibreur de charge interne sera déployé. Si une -PrivateIpAddress statique est omise, l’adresse IPv6 libre suivante est sélectionnée à partir du sous-réseau sur lequel l’équilibreur de charge interne est déployé.
Le sous-réseau double pile sur lequel l’équilibreur de charge interne sera déployé est spécifié avec un argument -Subnet ou -SubnetId.

Azure Cloud Shell

Azure héberge Azure Cloud Shell, un environnement d’interpréteur de commandes interactif que vous pouvez utiliser dans votre navigateur. Vous pouvez utiliser Bash ou PowerShell avec Cloud Shell pour utiliser les services Azure. Vous pouvez utiliser les commandes préinstallées Cloud Shell pour exécuter le code de cet article sans avoir à installer quoi que ce soit dans votre environnement local.

Pour démarrer Azure Cloud Shell :

Option	Exemple/Lien
Sélectionnez Essayer dans le coin supérieur droite d’un bloc de codes ou de commandes. La sélection de Essayer ne copie pas automatiquement le code ni la commande dans Cloud Shell.
Accédez à https://shell.azure.com ou sélectionnez le bouton Lancer Cloud Shell pour ouvrir Cloud Shell dans votre navigateur.
Sélectionnez le bouton Cloud Shell dans la barre de menus en haut à droite du portail Azure.

Pour utiliser Azure Cloud Shell :

Démarrez Cloud Shell.
Sélectionnez le bouton Copier sur un bloc de codes (ou un bloc de commandes) pour copier le code ou la commande.
Collez le code ou la commande dans la session Cloud Shell en sélectionnant Ctrl+Maj+V sur Windows et Linux ou en sélectionnant Cmd+Maj+V sur macOS.
Sélectionnez Entrée pour exécuter le code ou la commande.

Si vous choisissez d’installer et d’utiliser PowerShell en local, vous devez exécuter le module Azure PowerShell version 6.9.0 ou ultérieure pour les besoins de cet article. Exécutez Get-Module -ListAvailable Az pour rechercher la version installée. Si vous devez effectuer une mise à niveau, consultez Installer le module Azure PowerShell. Si vous exécutez PowerShell en local, vous devez également lancer Connect-AzAccount pour créer une connexion avec Azure.

Créer un groupe de ressources

Avant de pouvoir créer un réseau virtuel double pile, vous devez créer un groupe de ressources avec la commande New-AzResourceGroup. L’exemple suivant crée un groupe de ressources nommé dsStd_ILB_RG à l’emplacement east us :

$rg = New-AzResourceGroup `
  -ResourceGroupName "dsStd_ILB_RG"  `
  -Location "east us"

Créer des adresses IP IPv4 et IPv6 publiques

Pour accéder à vos machines virtuelles à partir d’Internet, vous avez besoin d’adresses IP publiques IPv4 et IPv6 pour les machines virtuelles. Créez des adresses IP publiques avec la commande New-AzPublicIpAddress. L’exemple suivant crée des adresses IP IPv4 et IPv6 publiques nommées RdpPublicIP_1 and RdpPublicIP_2 dans le groupe de ressources dsStd_ILB_RG :

$RdpPublicIP_1 = New-AzPublicIpAddress `
  -Name "RdpPublicIP_1" `
  -ResourceGroupName $rg.ResourceGroupName `
  -Location $rg.Location  `
  -AllocationMethod Static `
  -IpAddressVersion IPv4  `
  -sku Standard
  
$RdpPublicIP_2 = New-AzPublicIpAddress `
  -Name "RdpPublicIP_2" `
  -ResourceGroupName $rg.ResourceGroupName `
  -Location $rg.Location  `
  -AllocationMethod Static `
  -IpAddressVersion IPv6  `
  -sku Standard

Créer le réseau virtuel et le sous-réseau

Créez un réseau virtuel à l’aide d’New-AzVirtualNetwork avec une configuration de sous-réseau double pile à l’aide de New-AzVirtualNetworkSubnetConfig. L’exemple suivant crée un réseau virtuel nommé dsVnet avec dsSubnet.

# Create dual stack subnet config
$DsSubnet = New-AzVirtualNetworkSubnetConfig `
  -Name "dsSubnet" `
  -AddressPrefix "10.0.0.0/24","fd00:db8:deca:deed::/64"

# Create the virtual network
$vnet = New-AzVirtualNetwork `
  -ResourceGroupName $rg.ResourceGroupName `
  -Location $rg.Location  `
  -Name "dsVnet" `
  -AddressPrefix "10.0.0.0/16","fd00:db8:deca::/48"  `
  -Subnet $DsSubnet

#Refresh the fully populated subnet for use in load balancer frontend configuration
$DsSubnet = get-AzVirtualNetworkSubnetconfig -name dsSubnet -VirtualNetwork $vnet

Créer un Standard Load Balancer

Dans cette section, vous configurez une IP de front-end double (IPv4 et IPv6) et le pool d’adresses de back-end pour l’équilibreur de charge, puis créez un équilibreur de charge standard.

Créer une adresse IP de serveur frontal

Créez une IP de front-end avec New-AzLoadBalancerFrontendIpConfig. L’exemple suivant crée les configurations IP front-end IPv4 et IPv6 nommées dsLbFrontEnd_v4 et dsLbFrontEnd_v6 :

$frontendIPv4 = New-AzLoadBalancerFrontendIpConfig `
  -Name "dsLbFrontEnd_v4" `
  -PrivateIpAddress "10.0.0.100"  `
  -PrivateIpAddressVersion "IPv4"   `
  -Subnet $DsSubnet

$frontendIPv6 = New-AzLoadBalancerFrontendIpConfig `
  -Name "dsLbFrontEnd_v6" `
  -PrivateIpAddress "fd00:db8:deca:deed::100"  `
  -PrivateIpAddressVersion "IPv6"   `
  -Subnet $DsSubnet

Configurer un pool d’adresses principales

Créez un pool d’adresses principales avec New-AzLoadBalancerBackendAddressPoolConfig. Les machines virtuelles s’attachent à ce pool principal lors des étapes suivantes. L’exemple suivant crée les pools d’adresses back-end nommés dsLbBackEndPool_v4 et dsLbBackEndPool_v6 pour inclure des machines virtuelles présentant à la fois des configurations de carte réseau IPv4 et IPv6 :

$backendPoolv4 = New-AzLoadBalancerBackendAddressPoolConfig -Name "dsLbBackEndPool_v4"

$backendPoolv6 = New-AzLoadBalancerBackendAddressPoolConfig -Name "dsLbBackEndPool_v6"

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 veiller à ce que seules les machines virtuelles saines reçoivent le trafic, vous devez également définir une sonde d’intégrité, le cas échéant. L’équilibreur de charge de base utilise une sonde IPv4 pour évaluer l’intégrité des points de terminaison IPv4 et IPv6 sur les machines virtuelles. L’équilibreur de charge standard prend en charge de manière explicite les sondes d’intégrité IPv6.

Créez une règle d’équilibreur de charge avec Add-AzLoadBalancerRuleConfig. L’exemple suivant crée des règles d’équilibreur de charge nommées dsLBrule_v4 et dsLBrule_v6 et équilibre le trafic sur le port TCP80 vers les configurations IP front-end IPv4 et IPv6 :

$lbrule_v4 = New-AzLoadBalancerRuleConfig `
  -Name "dsLBrule_v4" `
  -FrontendIpConfiguration $frontendIPv4 `
  -BackendAddressPool $backendPoolv4 `
  -Protocol Tcp `
  -FrontendPort 80 `
  -BackendPort 80

$lbrule_v6 = New-AzLoadBalancerRuleConfig `
  -Name "dsLBrule_v6" `
  -FrontendIpConfiguration $frontendIPv6 `
  -BackendAddressPool $backendPoolv6 `
  -Protocol Tcp `
  -FrontendPort 80 `
  -BackendPort 80

Créer un équilibreur de charge

Créez un équilibreur de charge Standard Load Balancer avec New-AzLoadBalancer. L’exemple suivant crée un équilibreur de charge Standard Load Balancer public nommé myInternalLoadBalancer à l’aide des configurations IP front-end IPv4 et IPv6, des pools de back-ends et des règles d’équilibrage de charge que vous avez créés lors des étapes précédentes :

$lb = New-AzLoadBalancer  `
  -ResourceGroupName $rg.ResourceGroupName  `
  -Location $rg.Location  `
  -Name  "MyInternalLoadBalancer"  `
  -Sku "Standard"  `
  -FrontendIpConfiguration  $frontendIPv4,$frontendIPv6  `
  -BackendAddressPool  $backendPoolv4,$backendPoolv6  `
  -LoadBalancingRule  $lbrule_v4,$lbrule_v6

Créer des ressources réseau

Avant de déployer des machines virtuelles et de tester l’équilibreur de charge, vous devez créer des ressources réseau de prise en charge (groupe à haute disponibilité, groupe de sécurité réseau et cartes réseau virtuelles).

Créer un groupe à haute disponibilité

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

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

$avset = New-AzAvailabilitySet `
  -ResourceGroupName $rg.ResourceGroupName `
  -Location $rg.Location  `
  -Name "dsAVset" `
  -PlatformFaultDomainCount 2 `
  -PlatformUpdateDomainCount 2 `
  -Sku aligned

Création d’un groupe de sécurité réseau

Créez un groupe de sécurité réseau pour les règles qui régiront les communications entrantes et sortantes de votre VNet (réseau virtuel).

Créer une règle de groupe de sécurité réseau pour le port 3389

Créez une règle de groupe de sécurité réseau pour autoriser les connexions RDP via le port 3389 avec New-AzNetworkSecurityRuleConfig.

$rule1 = New-AzNetworkSecurityRuleConfig `
  -Name 'myNetworkSecurityGroupRuleRDP' `
  -Description 'Allow RDP' `
  -Access Allow `
  -Protocol Tcp `
  -Direction Inbound `
  -Priority 100 `
  -SourceAddressPrefix * `
  -SourcePortRange * `
  -DestinationAddressPrefix * `
  -DestinationPortRange 3389

Créer une règle de groupe de sécurité réseau pour le port 80

Créez une règle de groupe de sécurité réseau pour autoriser les connexions Internet entrantes via le port 80 avec New-AzNetworkSecurityRuleConfig.

$rule2 = New-AzNetworkSecurityRuleConfig `
  -Name 'myNetworkSecurityGroupRuleHTTP' `
  -Description 'Allow HTTP' `
  -Access Allow `
  -Protocol Tcp `
  -Direction Inbound `
  -Priority 200 `
  -SourceAddressPrefix * `
  -SourcePortRange 80 `
  -DestinationAddressPrefix * `
  -DestinationPortRange 80

Créer un groupe de sécurité réseau

Créez un groupe de sécurité réseau avec New-AzNetworkSecurityGroup.

$nsg = New-AzNetworkSecurityGroup `
  -ResourceGroupName $rg.ResourceGroupName `
  -Location $rg.Location  `
  -Name "dsNSG1"  `
  -SecurityRules $rule1,$rule2

Créer des cartes réseau

Créez des cartes réseau virtuelles avec New-AzNetworkInterface. L’exemple suivant crée deux cartes réseau virtuelles avec des configurations à la fois IPv4 et IPv6. (Une carte d’interface réseau virtuelle pour chaque machine virtuelle que vous créez pour votre application dans les étapes suivantes).


# Create the IPv4 configuration for NIC 1
$Ip4Config=New-AzNetworkInterfaceIpConfig `
  -Name dsIp4Config `
  -Subnet $vnet.subnets[0] `
  -PrivateIpAddressVersion IPv4 `
  -LoadBalancerBackendAddressPool $backendPoolv4 `
  -PublicIpAddress  $RdpPublicIP_1

# Create the IPv6 configuration
$Ip6Config=New-AzNetworkInterfaceIpConfig `
  -Name dsIp6Config `
  -Subnet $vnet.subnets[0] `
  -PrivateIpAddressVersion IPv6 `
  -LoadBalancerBackendAddressPool $backendPoolv6

# Create NIC 1
$NIC_1 = New-AzNetworkInterface `
  -Name "dsNIC1" `
  -ResourceGroupName $rg.ResourceGroupName `
  -Location $rg.Location  `
  -NetworkSecurityGroupId $nsg.Id `
  -IpConfiguration $Ip4Config,$Ip6Config

# Create the IPv4 configuration for NIC 2
$Ip4Config=New-AzNetworkInterfaceIpConfig `
  -Name dsIp4Config `
  -Subnet $vnet.subnets[0] `
  -PrivateIpAddressVersion IPv4 `
  -LoadBalancerBackendAddressPool $backendPoolv4 `
  -PublicIpAddress  $RdpPublicIP_2

# Create NIC 2 reusing the IPv6 configuration from NIC 1
$NIC_2 = New-AzNetworkInterface `
  -Name "dsNIC2" `
  -ResourceGroupName $rg.ResourceGroupName `
  -Location $rg.Location  `
  -NetworkSecurityGroupId $nsg.Id `
  -IpConfiguration $Ip4Config,$Ip6Config

Créer des machines virtuelles

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

$cred = get-credential -Message "DUAL STACK VNET SAMPLE:  Please enter the Administrator credential to log into the VM's"

Vous pouvez maintenant créer les machines virtuelles avec New-AzVM. L’exemple suivant crée deux machines virtuelles ainsi que les composants de réseau virtuel nécessaires s’ils n’existent pas encore.

$vmsize = "Standard_A2"
$ImagePublisher = "MicrosoftWindowsServer"
$imageOffer = "WindowsServer"
$imageSKU = "2019-Datacenter"

$vmName= "dsVM1"
$VMconfig1 = New-AzVMConfig -VMName $vmName -VMSize $vmsize -AvailabilitySetId $avset.Id 3> $null | Set-AzVMOperatingSystem -Windows -ComputerName $vmName -Credential $cred -ProvisionVMAgent 3> $null | Set-AzVMSourceImage -PublisherName $ImagePublisher -Offer $imageOffer -Skus $imageSKU -Version "latest" 3> $null | Set-AzVMOSDisk -Name "$vmName.vhd" -CreateOption fromImage  3> $null | Add-AzVMNetworkInterface -Id $NIC_1.Id  3> $null
$VM1 = New-AzVM -ResourceGroupName $rg.ResourceGroupName  -Location $rg.Location  -VM $VMconfig1


$vmName= "dsVM2"
$VMconfig2 = New-AzVMConfig -VMName $vmName -VMSize $vmsize -AvailabilitySetId $avset.Id 3> $null | Set-AzVMOperatingSystem -Windows -ComputerName $vmName -Credential $cred -ProvisionVMAgent 3> $null | Set-AzVMSourceImage -PublisherName $ImagePublisher -Offer $imageOffer -Skus $imageSKU -Version "latest" 3> $null | Set-AzVMOSDisk -Name "$vmName.vhd" -CreateOption fromImage  3> $null | Add-AzVMNetworkInterface -Id $NIC_2.Id  3> $null
$VM2 = New-AzVM -ResourceGroupName $rg.ResourceGroupName  -Location $rg.Location  -VM $VMconfig2

Afficher le réseau virtuel double pile IPv6 dans le Portail Microsoft Azure

Vous pouvez afficher le réseau virtuel double pile IPv6 dans le Portail Microsoft Azure en procédant comme suit :

Dans la barre de recherche du portail, saisissez dsVnet.
Quand le nom dsVnet apparaît dans les résultats de la recherche, sélectionnez-le. Cette opération affiche la page Vue d’ensemble du réseau virtuel double pile nommé dsVnet. Le réseau virtuel de pile double présente les deux cartes réseau, avec des configurations IPv4 et IPv6 situées dans le sous-réseau double pile nommé dsSubnet.

Réseau virtuel double pile IPv6 avec Standard Load Balancer interne

Notes

L’adresse IPv6 du réseau virtuel Azure est disponible dans le Portail Microsoft Azure en lecture seule pour cette préversion.

Nettoyer les ressources

Quand vous n’en avez plus besoin, vous pouvez utiliser la commande Remove-AzResourceGroup pour supprimer le groupe de ressources, la machine virtuelle et toutes les ressources associées.

Remove-AzResourceGroup -Name dsStd_ILB_RG

Étapes suivantes

Cet article vous a permis de créer un équilibreur de charge Standard Load Balancer avec une configuration IP front-end double (IPv4 et IPv6). Vous avez également créé deux machines virtuelles incluant des cartes réseau avec des configurations IP doubles (IPV4 + IPv6), qui ont été ajoutées au pool de back-ends de l’équilibreur de charge. Pour en savoir plus sur la prise en charge du protocole IPv6 dans les réseaux virtuels Azure, voir What is IPv6 for Azure Virtual Network? (Rôle d’iPv6 pour un réseau virtuel Azure).

Partager via