Een IPv6-toepassing met dubbele stack implementeren in een virtueel Azure-netwerk met behulp van PowerShell

Artikel
09/30/2024

In dit artikel wordt beschreven hoe u een IPv4- en IPv6-toepassing (Dual Stack+ IPv6) implementeert met behulp van Standard Load Balancer in Azure met een virtueel netwerk en subnet met twee stacks, een Standard Load Balancer met dubbele front-endconfiguraties (IPv4 + IPv6), VM's met NIC's met een dubbele IP-configuratie, netwerkbeveiligingsgroep en openbare IP-adressen.

Azure Cloud Shell

Azure host Azure Cloud Shell, een interactieve shell-omgeving die u via uw browser kunt gebruiken. U kunt Bash of PowerShell gebruiken met Cloud Shell om met Azure-services te werken. U kunt de vooraf geïnstalleerde Cloud Shell-opdrachten gebruiken om de code in dit artikel uit te voeren zonder dat u iets hoeft te installeren in uw lokale omgeving.

Om Azure Cloud Shell op te starten:

Optie	Voorbeeld/koppeling
Selecteer Uitproberen in de rechterbovenhoek van een code- of opdrachtblok. Als u Try It selecteert, wordt de code of opdracht niet automatisch gekopieerd naar Cloud Shell.
Ga naar https://shell.azure.com, of selecteer de knop Cloud Shell starten om Cloud Shell in uw browser te openen.
Klik op de knop Cloud Shell in het menu in de balk rechtsboven in de Azure-portal.

Azure Cloud Shell gebruiken:

Start Cloud Shell.
Selecteer de knop Kopiëren op een codeblok (of opdrachtblok) om de code of opdracht te kopiëren.
Plak de code of opdracht in de Cloud Shell-sessie door Ctrl+Shift+V in Windows en Linux te selecteren of door Cmd+Shift+V te selecteren in macOS.
Selecteer Enter om de code of opdracht uit te voeren.

Als u PowerShell lokaal wilt installeren en gebruiken, is voor dit artikel versie 6.9.0 of hoger van de Azure PowerShell-module vereist. Voer Get-Module -ListAvailable Az uit om te kijken welke versie is geïnstalleerd. Als u PowerShell wilt upgraden, raadpleegt u De Azure PowerShell-module installeren. Als u PowerShell lokaal uitvoert, moet u ook Connect-AzAccount uitvoeren om verbinding te kunnen maken met Azure.

Een brongroep maken

Voordat u uw virtuele dual-stack-netwerk kunt maken, moet u een resourcegroep maken met New-AzResourceGroup. In het volgende voorbeeld wordt een resourcegroep met de naam myRGDualStack gemaakt op de locatie vs - oost :

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

Openbare IP-adressen voor IPv4 en IPv6 maken

Voor toegang tot uw virtuele machines via internet hebt u openbare IPv4- en IPv6-adressen nodig voor de load balancer. Maak openbare IP-adressen met New-AzPublicIpAddress. In het volgende voorbeeld worden IPv4- en IPv6-openbaar IP-adres gemaakt met de naam dsPublicIP_v4 en dsPublicIP_v6 in de resourcegroep 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

Als u toegang wilt krijgen tot uw virtuele machines met behulp van een RDP-verbinding, maakt u een openbare IPV4-adressen voor de virtuele machines met 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

Een Standard Load Balancer maken

In deze sectie configureert u dubbele front-end-IP (IPv4 en IPv6) en de back-endadresgroep voor de load balancer en maakt u vervolgens een Standard Load Balancer.

Front-end-IP maken

Maak een front-end-IP met New-AzLoadBalancerFrontendIpConfig. In het volgende voorbeeld worden IPv4- en IPv6-front-end-IP-configuraties met de naam dsLbFrontEnd_v4 en dsLbFrontEnd_v6 gemaakt:

$frontendIPv4 = New-AzLoadBalancerFrontendIpConfig `
  -Name "dsLbFrontEnd_v4" `
  -PublicIpAddress $PublicIP_v4

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

Een back-endadresgroep configureren

Maak een back-end-adresgroep met New-AzLoadBalancerBackendAddressPoolConfig. In de resterende stappen worden de VM’s aan deze back-end-groep gekoppeld. In het volgende voorbeeld worden back-endadresgroepen met de naam dsLbBackEndPool_v4 en dsLbBackEndPool_v6 gemaakt om VM's op te nemen met zowel IPV4- als IPv6-NIC-configuraties:

$backendPoolv4 = New-AzLoadBalancerBackendAddressPoolConfig `
-Name "dsLbBackEndPool_v4"

$backendPoolv6 = New-AzLoadBalancerBackendAddressPoolConfig `
-Name "dsLbBackEndPool_v6"

Een statustest maken

Gebruik Add-AzLoadBalancerProbeConfig om een statustest te maken om de status van de VM's te bewaken.

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

Een load balancer-regel maken

Een load balancer-regel wordt gebruikt om de verdeling van het verkeer over de VM's te definiëren. U definieert de front-end-IP-configuratie voor het inkomende verkeer en de back-end-IP-groep om het verkeer te ontvangen, samen met de gewenste bron- en doelpoort. Als u ervoor wilt zorgen dat alleen vm's met een goede status verkeer ontvangen, kunt u desgewenst een statustest definiëren. Basic Load Balancer maakt gebruik van een IPv4-test om de status te beoordelen voor zowel IPv4- als IPv6-eindpunten op de VM's. Standard load balancer bevat ondersteuning voor explicietE IPv6-statustests.

Maak een load balancer-regel met Add-AzLoadBalancerRuleConfig. In het volgende voorbeeld worden load balancer-regels gemaakt met de naam dsLBrule_v4 en dsLBrule_v6 en wordt verkeer op TCP-poort 80 verdeeld over de IPv4- en IPv6-front-end-IP-configuraties:

$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

Load balancer maken

Maak een Standard Load Balancer met New-AzLoadBalancer. In het volgende voorbeeld wordt een openbare Standard Load Balancer met de naam myLoadBalancer gemaakt met behulp van de IPv4- en IPv6-front-end-IP-configuraties, back-endpools en taakverdelingsregels die u in de voorgaande stappen hebt gemaakt:

$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

Netwerkbronnen maken

Voordat u enkele VM's implementeert en uw balancer kunt testen, moet u ondersteunende netwerkbronnen maken: beschikbaarheidsset, netwerkbeveiligingsgroep, virtueel netwerk en virtuele NIC's.

Een beschikbaarheidsset maken

Verbeter de hoge beschikbaarheid van uw app door uw VM's in een beschikbaarheidsset te plaatsen.

Maak een beschikbaarheidsset met New-AzAvailabilitySet. In het volgende voorbeeld wordt een beschikbaarheidsset met de naam myAvailabilitySet gemaakt:

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

Netwerkbeveiligingsgroep maken

Maak een netwerkbeveiligingsgroep voor de regels voor binnenkomende en uitgaande communicatie in uw VNET.

Een netwerkbeveiligingsgroepsregel maken voor poort 3389

Maak een netwerkbeveiligingsgroepsregel die RDP-verbindingen via poort 3389 toestaat met New-AzNetworkSecurityRuleConfig.

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

Een netwerkbeveiligingsgroepsregel maken voor poort 80

Maak een netwerkbeveiligingsgroepregel om internetverbinding via poort 80 toe te staan met New-AzNetworkSecurityRuleConfig.

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

Een netwerkbeveiligingsgroep maken

Maak een netwerkbeveiligingsgroep met New-AzNetworkSecurityGroup.

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

Een virtueel netwerk maken

Maak een virtueel netwerk met New-AzVirtualNetwork. In het volgende voorbeeld wordt een virtueel netwerk gemaakt met de naam dsVnet met 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

NIC's maken

Maak virtuele NIC's met New-AzNetworkInterface. In het volgende voorbeeld worden twee virtuele NIC's gemaakt met IPv4- en IPv6-configuraties. (Eén virtuele NIC voor elke VM die u in de volgende stappen voor uw app maakt).

  $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

Virtuele machines maken

Stel een beheerdersnaam en -wachtwoord voor de VM’s in met Get-Credential:

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

Nu kunt u de VM’s maken met New-AzVM. In het volgende voorbeeld worden twee VM's en de vereiste onderdelen van het virtuele netwerk gemaakt als deze nog niet bestaan.

$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

IP-adressen van de IPv4- en IPv6-eindpunten bepalen

Haal alle netwerkinterfaceobjecten in de resourcegroep op om de IP-adressen samen te vatten die in deze implementatie worden gebruikt.get-AzNetworkInterface Haal ook de front-endadressen van de IPv4- en IPv6-eindpunten van de Load Balancer op met 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

In de volgende afbeelding ziet u een voorbeelduitvoer met de privé-IPv4- en IPv6-adressen van de twee VIRTUELE machines en de front-end-IPv4- en IPv6-IP-adressen van de Load Balancer.

IP-samenvatting van de implementatie van IPv4-/IPv6-toepassingen in Azure

Virtueel IPv6-netwerk met dubbele stack weergeven in Azure Portal

U kunt het virtuele IPv6-netwerk met dubbele stack als volgt weergeven in Azure Portal:

Voer in de zoekbalk van de portal dsVnet in.
Wanneer dsVnet wordt weergegeven in de zoekresultaten, selecteert u het. Hiermee opent u de pagina Overzicht van het virtuele netwerk met dubbele stack met de naam dsVnet. Het virtuele netwerk met dubbele stack toont de twee NIC's met zowel IPv4- als IPv6-configuraties in het subnet met dubbele stack met de naam dsSubnet.

Virtueel IPv6-netwerk met dubbele stack in Azure

Resources opschonen

U kunt de opdracht Remove-AzResourceGroup gebruiken om de resourcegroep, de VM en alle gerelateerde resources te verwijderen wanneer u ze niet meer nodig hebt.

Remove-AzResourceGroup -Name dsRG1

Volgende stappen

In dit artikel hebt u een Standard Load Balancer gemaakt met een dubbele front-end-IP-configuratie (IPv4 en IPv6). U hebt ook twee virtuele machines gemaakt met NIC's met dubbele IP-configuraties (IPV4 + IPv6) die zijn toegevoegd aan de back-endpool van de load balancer. Zie Wat is IPv6 voor Azure Virtual Network voor meer informatie over IPv6-ondersteuning in virtuele Azure-netwerken?

Delen via