Distribuera ett IPv6-program med dubbla staplar i ett virtuellt Azure-nätverk med Hjälp av PowerShell

Den här artikeln visar hur du distribuerar ett program med dubbla staplar (IPv4 + IPv6) med Standard Load Balancer i Azure som innehåller ett virtuellt nätverk och undernät med dubbla staplar, en Standard Load Balancer med dubbla (IPv4 + IPv6) klientdelskonfigurationer, virtuella datorer med nätverkskort som har en dubbel IP-konfiguration, nätverkssäkerhetsgrupp och offentliga IP-adresser.

Azure Cloud Shell

Azure är värd för Azure Cloud Shell, en interaktiv gränssnittsmiljö som du kan använda via webbläsaren. Du kan använda antingen Bash eller PowerShell med Cloud Shell för att arbeta med Azure-tjänster. Du kan använda förinstallerade Cloud Shell-kommandon för att köra koden i den här artikeln, utan att behöva installera något i din lokala miljö.

Så här startar du Azure Cloud Shell:

Alternativ	Exempel/länk
Välj Prova i det övre högra hörnet i en kod eller ett kommandoblock. Om du väljer Prova kopieras inte koden eller kommandot automatiskt till Cloud Shell.
Gå till https://shell.azure.com eller Välj knappen Starta Cloud Shell för att öppna Cloud Shell i webbläsaren.
Välj knappen Cloud Shell på menyn längst upp till höger i Azure-portalen.

Så här använder du Azure Cloud Shell:

1. Starta Cloud Shell.

2. Välj knappen Kopiera i ett kodblock (eller kommandoblock) för att kopiera koden eller kommandot.

3. Klistra in koden eller kommandot i Cloud Shell-sessionen genom att välja Ctrl+Skift+V i Windows och Linux, eller genom att välja Cmd+Shift+V på macOS.

4. Välj Retur för att köra koden eller kommandot.

Om du väljer att installera och använda PowerShell lokalt kräver den här artikeln Azure PowerShell-modulen version 6.9.0 eller senare. Kör Get-Module -ListAvailable Az för att hitta den installerade versionen. Om du behöver uppgradera kan du läsa Install Azure PowerShell module (Installera Azure PowerShell-modul). Om du kör PowerShell lokalt måste du också köra Connect-AzAccount för att skapa en anslutning till Azure.

Skapa en resursgrupp

Innan du kan skapa det virtuella nätverket med dubbla staplar måste du skapa en resursgrupp med New-AzResourceGroup. I följande exempel skapas en resursgrupp med namnet myRGDualStack på platsen usa , östra:

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

Skapa offentliga IP-adresser för IPv4 och IPv6

För att få åtkomst till dina virtuella datorer från Internet behöver du offentliga IP-adresser för IPv4 och IPv6 för lastbalanseraren. Skapa offentliga IP-adresser med New-AzPublicIpAddress. I följande exempel skapas en offentlig IPv4- och IPv6-IP-adress med namnet dsPublicIP_v4 och dsPublicIP_v6 i resursgruppen 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

Om du vill komma åt dina virtuella datorer med hjälp av en RDP-anslutning skapar du en offentlig IPV4-IP-adress för de virtuella datorerna med 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

Skapa en Standard Load Balancer

I det här avsnittet konfigurerar du IP med dubbla klientdelar (IPv4 och IPv6) och serverdelsadresspoolen för lastbalanseraren och skapar sedan en Standard Load Balancer.

Skapa klientdels-IP

Skapa en klientdels-IP med New-AzLoadBalancerFrontendIpConfig. I följande exempel skapas IP-konfigurationer för IPv4- och IPv6-klientdelen med namnet dsLbFrontEnd_v4 och dsLbFrontEnd_v6:

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

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

Konfigurera en serverdelsadresspool

Skapa en adresspool på serverdelen med hjälp av New-AzLoadBalancerBackendAddressPoolConfig. Virtuella datorer ansluter till den här adresspoolen i de resterande stegen. I följande exempel skapas serverdelsadresspooler med namnet dsLbBackEndPool_v4 och dsLbBackEndPool_v6 för att inkludera virtuella datorer med både IPV4- och IPv6 NIC-konfigurationer:

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

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

Skapa en hälsoavsökning

Använd Add-AzLoadBalancerProbeConfig för att skapa en hälsoavsökning för att övervaka hälsotillståndet för de virtuella datorerna.

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

Skapa en lastbalanseringsregel

En lastbalanseringsregel används för att definiera hur trafiken ska distribueras till de virtuella datorerna. Du definierar IP-konfigurationen på klientdelen för inkommande trafik och IP-poolen på serverdelen för att ta emot trafik samt nödvändig käll- och målport. För att se till att endast felfria virtuella datorer tar emot trafik kan du definiera en hälsoavsökning. Grundläggande lastbalanserare använder en IPv4-avsökning för att utvärdera hälsotillståndet för både IPv4- och IPv6-slutpunkter på de virtuella datorerna. Standardlastbalanserare innehåller stöd för explicitAPv6-hälsoavsökningar.

Skapa en lastbalanseringsregel med hjälp av Add-AzLoadBalancerRuleConfig. I följande exempel skapas lastbalanseringsregler med namnet dsLBrule_v4 och dsLBrule_v6 och balanserar trafik på TCP-port 80 till IP-konfigurationerna för IPv4- och IPv6-klientdelen:

$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

Skapa en lastbalanserare

Skapa en Standard Load Balancer med New-AzLoadBalancer. I följande exempel skapas en offentlig Standard Load Balancer med namnet myLoadBalancer med IPv4- och IPv6-klientdels-IP-konfigurationer, serverdelspooler och belastningsutjämningsregler som du skapade i föregående steg:

$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

Skapa nätverksresurser

Innan du distribuerar vissa virtuella datorer och kan testa din balancer måste du skapa nätverksresurser som stöds – tillgänglighetsuppsättning, nätverkssäkerhetsgrupp, virtuellt nätverk och virtuella nätverkskort.

Skapa en tillgänglighetsuppsättning

Placera dina virtuella datorer i en tillgänglighetsuppsättning för att förbättra tillgängligheten för din app.

Skapa en tillgänglighetsuppsättning med hjälp av New-AzAvailabilitySet. I följande exempel skapas en tillgänglighetsuppsättning med namnet myAvailabilitySet:

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

Skapa nätverkssäkerhetsgrupp

Skapa en nätverkssäkerhetsgrupp för de regler som styr inkommande och utgående kommunikation i ditt virtuella nätverk.

Skapa en regel för nätverkssäkerhetsgruppen för port 3389

Skapa en regel för nätverkssäkerhetsgruppen som tillåter RDP-anslutningar via port 3389 med New-AzNetworkSecurityRuleConfig.

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

Skapa en regel för nätverkssäkerhetsgruppen för port 80

Skapa en regel för nätverkssäkerhetsgrupp för att tillåta internetanslutningar via port 80 med New-AzNetworkSecurityRuleConfig.

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

Skapa en nätverkssäkerhetsgrupp

Skapa en nätverkssäkerhetsgrupp med New-AzNetworkSecurityGroup.

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

Skapa ett virtuellt nätverk

Skapa ett virtuellt nätverk med hjälp av New-AzVirtualNetwork. I följande exempel skapas ett virtuellt nätverk med namnet dsVnet med 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

Skapa nätverkskort

Skapa virtuella nätverkskort med New-AzNetworkInterface. I följande exempel skapas två virtuella nätverkskort både med IPv4- och IPv6-konfigurationer. (Det vill säga ett virtuellt nätverkskort för varje virtuell dator som du skapar för din app i följande steg.)

  $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 

Skapa virtuella datorer

Ange ett administratörsanvändarnamn och lösenord för de virtuella datorerna med Get-Credential:

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

Nu kan du skapa de virtuella datorerna med hjälp av New-AzVM. I följande exempel skapas två virtuella datorer och nödvändiga virtuella nätverkskomponenter om de inte redan finns.

$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

Fastställa IP-adresser för IPv4- och IPv6-slutpunkterna

Hämta alla nätverksgränssnittsobjekt i resursgruppen för att sammanfatta ip-adresserna som används i den här distributionen med get-AzNetworkInterface. Hämta även Lastbalanserarens klientdelsadresser för IPv4- och IPv6-slutpunkterna med 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

Följande bild visar ett exempel på utdata som visar de privata IPv4- och IPv6-adresserna för de två virtuella datorerna och klientdels-IPv4- och IPv6-IP-adresserna för lastbalanseraren.

Visa virtuellt IPv6-nätverk med dubbla staplar i Azure-portalen

Du kan visa det virtuella IPv6-nätverket med dubbla staplar i Azure-portalen på följande sätt:

1. I portalens sökfält anger du dsVnet.
2. När dsVnet visas i sökresultatet väljer du det. Då startas översiktssidan för det virtuella nätverket med dubbla staplar med namnet dsVnet. Det virtuella nätverket med dubbla staplar visar de två nätverkskorten med både IPv4- och IPv6-konfigurationer i undernätet med dubbla staplar med namnet dsSubnet.

Rensa resurser

När den inte längre behövs du använda kommandot Remove-AzResourceGroup för att ta bort resursgruppen, den virtuella datorn och alla relaterade resurser.

Remove-AzResourceGroup -Name dsRG1

Nästa steg

I den här artikeln har du skapat en Standard Load Balancer med en IP-konfiguration med dubbla klientdelar (IPv4 och IPv6). Du har också skapat två virtuella datorer som inkluderade nätverkskort med dubbla IP-konfigurationer (IPV4 + IPv6) som lades till i lastbalanserarens serverdelspool. Mer information om IPv6-stöd i virtuella Azure-nätverk finns i Vad är IPv6 för Azure Virtual Network?