Distribuera ett IPv6-program med dubbla stackar i Azure – PowerShell

Artikel
10/02/2021
8 minuter för att läsa

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

Använda 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 av ett kodblock. Om du väljer Prova kopieras koden inte 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 kör du koden i den här artikeln i Azure Cloud Shell:

Starta Cloud Shell.
Kopiera koden genom att klicka på knappen Kopiera på ett kodblock.
Klistra in koden i Cloud Shell-sessionen genom att välja Ctrl+Skift+V på Windows och Linux eller genom att välja Cmd+Skift+V på macOS.
Välj Retur för att köra koden.

Om du väljer att installera och använda PowerShell lokalt kräver den här artikeln Azure PowerShell 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 ditt virtuella nätverk med dubbla stackar 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 komma åt 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 IP-adress för IPv4 och IPv6 med 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 en RDP-anslutning skapar du en offentlig IP-adress för IPV4 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 dubbla IP-adresser för frontend (IPv4 och IPv6) och backend-adresspoolen för lastbalanseraren och skapar sedan en Standard Load Balancer.

Skapa klientdels-IP

Skapa en IP-adress på klientdelen med hjälp av New-AzLoadBalancerFrontendIpConfig. I följande exempel skapas IP-konfigurationer för IPv4 och IPv6 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 backend-adresspool med New-AzLoadBalancerBackendAddressPoolConfig. De virtuella datorerna ansluter till den här serverdelspoolen i de återstående stegen. I följande exempel skapas backend-adresspooler med dsLbBackEndPool_v4 och dsLbBackEndPool_v6 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 de virtuella datorernas hälsa.

$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. Om du vill se till att endast felfria virtuella datorer tar emot trafik kan du även definiera en hälsoavsökning. Den grundläggande lastbalanseraren 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. Standard Load Balancer har stöd för explicita IPv6-hälsoavsökningar.

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

$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 ip-konfigurationerna för IPv4 och IPv6, serverpooler och regler för belastningsutjämning 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 balanserare måste du skapa stöd för nätverksresurser – 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 som tillåter 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 de virtuella nätverkskomponenter som krävs, 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-adressen som används i den här distributionen med get-AzNetworkInterface . Hämta även Load Balancer klientadresserna 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, samt ip-adresserna för IPv4 och IPv6 på Load Balancer.

IP-sammanfattning av distribution av dubbla stackprogram (IPv4/IPv6) i Azure

Visa virtuella IPv6-nätverk med dubbla stackar i Azure Portal

Du kan visa det virtuella nätverket med dubbla IPv6-stackar Azure Portal följande:

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

Virtuellt IPv6-nätverk med dubbla staplar i Azure

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 dubbel IP-konfiguration för frontend (IPv4 och IPv6). Du har också skapat två virtuella datorer som innehåller nätverkskort med dubbla IP-konfigurationer (IPV4 + IPv6) som har lagts till i lastbalanseringspoolens serverpool. Mer information om IPv6-stöd i virtuella Azure-nätverk finns i [Vad är IPv6 för Azure Virtual Network?] ((.. /virtual-network/ip-services/ipv6-overview.md)