Déployer une application double pile IPv6 dans un réseau virtuel Azure à l’aide de PowerShell

Article
03/05/2024

Cet article montre comment déployer une application double pile (IPv4 + IPv6) en utilisant un équilibreur de charge standard dans Azure, et incluant un sous-réseau et un réseau virtuel double pile, un équilibreur de charge standard avec des configurations de front-end doubles (IPv4 + IPv6), des machines virtuelles dont les cartes réseau ont une configuration IP double, un groupe de sécurité réseau et des IP publiques.

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 exécuter 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é myRGDualStack à l’emplacement east us :

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

Créer des adresses IP IPv4 et IPv6 publiques

Pour accéder à vos machines virtuelles depuis Internet, vous avez besoin d’adresses IP IPv4 et IPv6 publiques destinées à l’équilibreur de charge. 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 dsPublicIP_v4 and dsPublicIP_v6 dans le groupe de ressources dsRG1 :

$PublicIP_v4 = New-AzPublicIpAddress `
  -Name "dsPublicIP_v4" `
  -ResourceGroupName $rg.ResourceGroupName `
  -Location $rg.Location  `
  -AllocationMethod Static `
  -IpAddressVersion IPv4 `
  -Sku Standard
  
$PublicIP_v6 = New-AzPublicIpAddress `
  -Name "dsPublicIP_v6" `
  -ResourceGroupName $rg.ResourceGroupName `
  -Location $rg.Location  `
  -AllocationMethod Static `
  -IpAddressVersion IPv6 `
  -Sku Standard

Pour accéder à vos machines virtuelles à l’aide d’une connexion RDP, créez une adresse IP publique IPV4 pour les machines virtuelles avec New-AzPublicIpAddress.

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

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" `
  -PublicIpAddress $PublicIP_v4

$frontendIPv6 = New-AzLoadBalancerFrontendIpConfig `
  -Name "dsLbFrontEnd_v6" `
  -PublicIpAddress $PublicIP_v6

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 des pools d’adresses de back-end nommés dsLbBackEndPool_v4 et dsLbBackEndPool_v6 pour inclure des machines virtuelles ayant à 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 sonde d’intégrité

Pour créer une sonde d’intégrité afin de superviser l’intégrité des machines virtuelles, utilisez New-AzLoadBalancerProbeConfig.

$probe = New-AzLoadBalancerProbeConfig -Name MyProbe -Protocol tcp -Port 3389 -IntervalInSeconds 15 -ProbeCount 2

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 `
   -probe $probe

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

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é myLoadBalancer à l’aide des configurations IP front-end IPv4 et IPv6, des pools principaux 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 "MyLoadBalancer" `
-Sku "Standard" `
-FrontendIpConfiguration $frontendIPv4,$frontendIPv6 `
-BackendAddressPool $backendPoolv4,$backendPoolv6 `
-LoadBalancingRule $lbrule_v4,$lbrule_v6 `
-Probe $probe

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, réseau virtuel 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é myAvailabilitySet :

$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égissent les communications entrantes et sortantes de votre 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 * `
  -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éez un réseau virtuel

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

# Create dual stack subnet
$subnet = 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 $subnet

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

  $Ip4Config=New-AzNetworkInterfaceIpConfig `
    -Name dsIp4Config `
    -Subnet $vnet.subnets[0] `
    -PrivateIpAddressVersion IPv4 `
    -LoadBalancerBackendAddressPool $backendPoolv4 `
    -PublicIpAddress  $RdpPublicIP_1
      
  $Ip6Config=New-AzNetworkInterfaceIpConfig `
    -Name dsIp6Config `
    -Subnet $vnet.subnets[0] `
    -PrivateIpAddressVersion IPv6 `
    -LoadBalancerBackendAddressPool $backendPoolv6
    
  $NIC_1 = New-AzNetworkInterface `
    -Name "dsNIC1" `
    -ResourceGroupName $rg.ResourceGroupName `
    -Location $rg.Location  `
    -NetworkSecurityGroupId $nsg.Id `
    -IpConfiguration $Ip4Config,$Ip6Config 
    
  $Ip4Config=New-AzNetworkInterfaceIpConfig `
    -Name dsIp4Config `
    -Subnet $vnet.subnets[0] `
    -PrivateIpAddressVersion IPv4 `
    -LoadBalancerBackendAddressPool $backendPoolv4 `
    -PublicIpAddress  $RdpPublicIP_2  

  $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 VMs."

Vous pouvez maintenant créer les machines virtuelles avec New-AzVM. L’exemple suivant crée deux machines virtuelles, ainsi que les composants nécessaires du réseau virtuel, 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

Déterminer les adresses IP des points de terminaison IPv4 et IPv6

Obtenez tous les objets Interface réseau dans le groupe de ressources pour récapituler les adresses IP utilisées dans ce déploiement avec get-AzNetworkInterface. Vous pouvez également obtenir les adresses front-end de l’équilibreur de charge des points de terminaison IPv4 et IPv6 avec get-AzpublicIpAddress.

$rgName= "dsRG1"
$NICsInRG= get-AzNetworkInterface -resourceGroupName $rgName 
write-host `nSummary of IPs in this Deployment: 
write-host ******************************************
foreach ($NIC in $NICsInRG) {
 
    $VMid= $NIC.virtualmachine.id 
    $VMnamebits= $VMid.split("/") 
    $VMname= $VMnamebits[($VMnamebits.count-1)] 
    write-host `nPrivate IP addresses for $VMname 
    $IPconfigsInNIC= $NIC.IPconfigurations 
    foreach ($IPconfig in $IPconfigsInNIC) {
 
        $IPaddress= $IPconfig.privateipaddress 
        write-host "    "$IPaddress 
        IF ($IPconfig.PublicIpAddress.ID) {
 
            $IDbits= ($IPconfig.PublicIpAddress.ID).split("/")
            $PipName= $IDbits[($IDbits.count-1)]
            $PipObject= get-azPublicIpAddress -name $PipName -resourceGroup $rgName
            write-host "    "RDP address:  $PipObject.IpAddress
                 }
         }
 }
 
 
 
  write-host `nPublic IP addresses on Load Balancer:
 
  (get-AzpublicIpAddress -resourcegroupname $rgName | where { $_.name -notlike "RdpPublicIP*" }).IpAddress

La figure suivante illustre un exemple de sortie qui répertorie les adresses IPv4 et IPv6 privées des deux machines virtuelles, ainsi que les adresses IP front-end IPv4 et IPv6 de l’équilibreur de charge.

IP summary of dual stack (IPv4/IPv6) application deployment in Azure

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.

IPv6 dual stack virtual network in Azure

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 dsRG1

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