Delen via


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

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. Schermopname van een voorbeeld van Probeer het nu voor Azure Cloud Shell.
Ga naar https://shell.azure.com, of selecteer de knop Cloud Shell starten om Cloud Shell in uw browser te openen. Knop om Azure Cloud Shell te starten.
Klik op de knop Cloud Shell in het menu in de balk rechtsboven in de Azure-portal. Schermopname van de knop Cloud Shell in Azure Portal

Azure Cloud Shell gebruiken:

  1. Start Cloud Shell.

  2. Selecteer de knop Kopiëren op een codeblok (of opdrachtblok) om de code of opdracht te kopiëren.

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

  4. 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:

  1. Voer in de zoekbalk van de portal dsVnet in.
  2. 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?