Den här artikeln visar hur du distribuerar ett program med dubbla staplar (IPv4 + IPv6) med hjälp av Standard Load Balancer i Azure. Scenariot innehåller ett virtuellt nätverk med dubbla staplar med ett 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, regler för dubbla nätverkssäkerhetsgrupper och dubbla offentliga IP-adresser.
Följ de här anvisningarna i Azure PowerShell för att distribuera ett program med dubbla staplar (IPv4 + IPv6) med Standard Load Balancer i 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å östra USA:
$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 dubbel frontend-IP (IPv4 och IPv6) och backend-adresspoolen för lastbalanseraren och skapar sedan en Standard Lastbalanserare.
Skapa klientdels-IP
Skapa en frontend-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
Skapa en backend-adresspool med New-AzLoadBalancerBackendAddressPoolConfig för de virtuella datorer som distribueras senare. 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 explicita IPv6-hälsokontroller.
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-port80 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 några virtuella datorer och kan testa din lastbalanserare måste du skapa nödvändiga 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 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 ett virtuellt IPv6-nätverk med dubbla staplar i Azure Portal
Du kan visa det virtuella IPv6-nätverket med dubbla staplar i Azure Portal på följande sätt:
- 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 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
Följ de här anvisningarna i Azure CLI för att distribuera ett program med dubbla staplar (IPv4 + IPv6) med hjälp av Standard Load Balancer i Azure.
Skapa en resursgrupp
Innan du kan skapa det virtuella nätverket med dubbla staplar måste du skapa en resursgrupp med az group create. I följande exempel skapas en resursgrupp med namnet DsResourceGroup01 på platsen eastus :
az group create \
--name DsResourceGroup01 \
--location eastus
Skapa offentliga IP-adresser för IPv4 och IPv6 för lastbalanserare
För att få åtkomst till dina IPv4- och IPv6-slutpunkter på Internet behöver du offentliga IP-adresser för IPv4 och IPv6 för lastbalanseraren. Skapa en offentlig IP-adress med az network public-ip create. I följande exempel skapas den offentliga IP-adressen IPv4 och IPv6 med namnet dsPublicIP_v4 och dsPublicIP_v6 i resursgruppen DsResourceGroup01 :
# Create an IPV4 IP address
az network public-ip create \
--name dsPublicIP_v4 \
--resource-group DsResourceGroup01 \
--location eastus \
--sku STANDARD \
--allocation-method static \
--version IPv4
# Create an IPV6 IP address
az network public-ip create \
--name dsPublicIP_v6 \
--resource-group DsResourceGroup01 \
--location eastus \
--sku STANDARD \
--allocation-method static \
--version IPv6
Skapa offentliga IP-adresser för virtuella datorer
Om du vill fjärransluta till dina virtuella datorer på Internet behöver du offentliga IPv4-IP-adresser för de virtuella datorerna. Skapa en offentlig IP-adress med az network public-ip create.
az network public-ip create \
--name dsVM0_remote_access \
--resource-group DsResourceGroup01 \
--location eastus \
--sku Standard \
--allocation-method static \
--version IPv4
az network public-ip create \
--name dsVM1_remote_access \
--resource-group DsResourceGroup01 \
--location eastus \
--sku Standard \
--allocation-method static \
--version IPv4
Skapa en Standard Load Balancer
I det här avsnittet konfigurerar du dubbla front-end IP-adresser (IPv4 och IPv6) och back-end-adresspoolen för lastbalanseraren och skapar sedan en Standard Load Balancer.
Skapa en lastbalanserare
Skapa Standard Load Balancer med az network lb create med namnet dsLB som innehåller en klientdelspool med namnet dsLbFrontEnd_v4, en serverdelspool med namnet dsLbBackEndPool_v4 som är associerad med den offentliga IP-adressen för IPv4 dsPublicIP_v4 som du skapade i föregående steg.
az network lb create \
--name dsLB \
--resource-group DsResourceGroup01 \
--sku Standard \
--location eastus \
--frontend-ip-name dsLbFrontEnd_v4 \
--public-ip-address dsPublicIP_v4 \
--backend-pool-name dsLbBackEndPool_v4
Skapa IPv6-klientdel
Skapa en IPV6-frontends IP-adress med az network lb frontend-ip create. I följande exempel skapas en IP-konfiguration för klientdelen med namnet dsLbFrontEnd_v6 och den dsPublicIP_v6 adressen bifogas:
az network lb frontend-ip create \
--lb-name dsLB \
--name dsLbFrontEnd_v6 \
--resource-group DsResourceGroup01 \
--public-ip-address dsPublicIP_v6
Skapa IPv6-serverdelsadresspooler med az network lb address-pool create. I följande exempel skapas serverdelsadresspoolen med namnet dsLbBackEndPool_v6 för att inkludera virtuella datorer med IPv6 NIC-konfigurationer:
az network lb address-pool create \
--lb-name dsLB \
--name dsLbBackEndPool_v6 \
--resource-group DsResourceGroup01
Skapa en hälsoavsökning
Skapa en hälsoprob med az network lb probe create för att övervaka hälsotillståndet för de virtuella datorerna.
az network lb probe create -g DsResourceGroup01 --lb-name dsLB -n dsProbe --protocol tcp --port 3389
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.
Använd az network lb rule create för att skapa en regel för lastbalanseraren. I följande exempel skapas lastbalanseringsregler med namnet dsLBrule_v4 och dsLBrule_v6 och balanserar trafik på TCP-port80 till IP-konfigurationerna för IPv4- och IPv6-klientdelen:
az network lb rule create \
--lb-name dsLB \
--name dsLBrule_v4 \
--resource-group DsResourceGroup01 \
--frontend-ip-name dsLbFrontEnd_v4 \
--protocol Tcp \
--frontend-port 80 \
--backend-port 80 \
--probe-name dsProbe \
--backend-pool-name dsLbBackEndPool_v4
az network lb rule create \
--lb-name dsLB \
--name dsLBrule_v6 \
--resource-group DsResourceGroup01 \
--frontend-ip-name dsLbFrontEnd_v6 \
--protocol Tcp \
--frontend-port 80 \
--backend-port 80 \
--probe-name dsProbe \
--backend-pool-name dsLbBackEndPool_v6
Skapa nätverksresurser
Innan du distribuerar vissa virtuella datorer måste du skapa stödnätverksresurser – tillgänglighetsuppsättning, nätverkssäkerhetsgrupp, virtuellt nätverk och virtuella nätverkskort.
Skapa en tillgänglighetsuppsättning
Om du vill förbättra tillgängligheten för din app placerar du dina virtuella datorer i en tillgänglighetsuppsättning.
Skapa en tillgänglighetsuppsättning med az vm availability-set create. I följande exempel skapas en tillgänglighetsuppsättning med namnet dsAVset:
az vm availability-set create \
--name dsAVset \
--resource-group DsResourceGroup01 \
--location eastus \
--platform-fault-domain-count 2 \
--platform-update-domain-count 2
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 nätverkssäkerhetsgrupp
Skapa en nätverkssäkerhetsgrupp med az network nsg create
az network nsg create \
--name dsNSG1 \
--resource-group DsResourceGroup01 \
--location eastus
Skapa en regel för nätverkssäkerhetsgrupp för inkommande och utgående anslutningar
Skapa en regel för nätverkssäkerhetsgrupp för att tillåta RDP-anslutningar via port 3389, internetanslutning via port 80 och för utgående anslutningar med az network nsg rule create.
# Create inbound rule for port 3389
az network nsg rule create \
--name allowRdpIn \
--nsg-name dsNSG1 \
--resource-group DsResourceGroup01 \
--priority 100 \
--description "Allow Remote Desktop In" \
--access Allow \
--protocol "*" \
--direction Inbound \
--source-address-prefixes "*" \
--source-port-ranges "*" \
--destination-address-prefixes "*" \
--destination-port-ranges 3389
# Create inbound rule for port 80
az network nsg rule create \
--name allowHTTPIn \
--nsg-name dsNSG1 \
--resource-group DsResourceGroup01 \
--priority 200 \
--description "Allow HTTP In" \
--access Allow \
--protocol "*" \
--direction Inbound \
--source-address-prefixes "*" \
--source-port-ranges 80 \
--destination-address-prefixes "*" \
--destination-port-ranges 80
# Create outbound rule
az network nsg rule create \
--name allowAllOut \
--nsg-name dsNSG1 \
--resource-group DsResourceGroup01 \
--priority 300 \
--description "Allow All Out" \
--access Allow \
--protocol "*" \
--direction Outbound \
--source-address-prefixes "*" \
--source-port-ranges "*" \
--destination-address-prefixes "*" \
--destination-port-ranges "*"
Skapa ett virtuellt nätverk
Skapa ett virtuellt nätverk med kommandot az network vnet create. I följande exempel skapas ett virtuellt nätverk med namnet dsVNET med undernät dsSubNET_v4 och dsSubNET_v6:
# Create the virtual network
az network vnet create \
--name dsVNET \
--resource-group DsResourceGroup01 \
--location eastus \
--address-prefixes "10.0.0.0/16" "fd00:db8:deca::/48"
# Create a single dual stack subnet
az network vnet subnet create \
--name dsSubNET \
--resource-group DsResourceGroup01 \
--vnet-name dsVNET \
--address-prefixes "10.0.0.0/24" "fd00:db8:deca:deed::/64" \
--network-security-group dsNSG1
Skapa nätverkskort
Skapa virtuella nätverkskort för varje virtuell dator med az network nic create. I följande exempel skapas ett virtuellt nätverkskort för varje virtuell dator. Varje nätverkskort har två IP-konfigurationer (1 IPv4-konfiguration, 1 IPv6-konfiguration). Du skapar IPV6-konfigurationen med az network nic ip-config create.
# Create NICs
az network nic create \
--name dsNIC0 \
--resource-group DsResourceGroup01 \
--network-security-group dsNSG1 \
--vnet-name dsVNET \
--subnet dsSubNet \
--private-ip-address-version IPv4 \
--lb-address-pools dsLbBackEndPool_v4 \
--lb-name dsLB \
--public-ip-address dsVM0_remote_access
az network nic create \
--name dsNIC1 \
--resource-group DsResourceGroup01 \
--network-security-group dsNSG1 \
--vnet-name dsVNET \
--subnet dsSubNet \
--private-ip-address-version IPv4 \
--lb-address-pools dsLbBackEndPool_v4 \
--lb-name dsLB \
--public-ip-address dsVM1_remote_access
# Create IPV6 configurations for each NIC
az network nic ip-config create \
--name dsIp6Config_NIC0 \
--nic-name dsNIC0 \
--resource-group DsResourceGroup01 \
--vnet-name dsVNET \
--subnet dsSubNet \
--private-ip-address-version IPv6 \
--lb-address-pools dsLbBackEndPool_v6 \
--lb-name dsLB
az network nic ip-config create \
--name dsIp6Config_NIC1 \
--nic-name dsNIC1 \
--resource-group DsResourceGroup01 \
--vnet-name dsVNET \
--subnet dsSubNet \
--private-ip-address-version IPv6 \
--lb-address-pools dsLbBackEndPool_v6 \
--lb-name dsLB
Skapa virtuella datorer
Skapa de virtuella datorerna med az vm create. I följande exempel skapas två virtuella datorer och nödvändiga virtuella nätverkskomponenter om de inte redan finns.
Skapa en virtuell dator dsVM0 på följande sätt:
az vm create \
--name dsVM0 \
--resource-group DsResourceGroup01 \
--nics dsNIC0 \
--size Standard_A2 \
--availability-set dsAVset \
--image MicrosoftWindowsServer:WindowsServer:2019-Datacenter:latest
Skapa en virtuell dator dsVM1 på följande sätt:
az vm create \
--name dsVM1 \
--resource-group DsResourceGroup01 \
--nics dsNIC1 \
--size Standard_A2 \
--availability-set dsAVset \
--image MicrosoftWindowsServer:WindowsServer:2019-Datacenter:latest
Visa ett virtuellt IPv6-nätverk med dubbla staplar i Azure Portal
Du kan visa det virtuella IPv6-nätverket med dubbla staplar i Azure Portal på följande sätt:
- I portalens sökfält anger du dsVnet.
- När myVirtualNetwork 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 az group delete för att ta bort resursgruppen, den virtuella datorn och alla relaterade resurser.
az group delete --name DsResourceGroup01
Använd mallen som beskrivs i den här artikeln för att distribuera ett program med dubbla staplar (IPv4 + IPv6) med Standard Load Balancer i Azure.
Nödvändiga konfigurationer
Sök efter mallavsnitten i mallen för att se var de ska finnas.
IPv6-adressområde för det virtuella nätverket
Mallavsnitt att lägga till:
"addressSpace": {
"addressPrefixes": [
"[variables('vnetv4AddressRange')]",
"[variables('vnetv6AddressRange')]"
IPv6-undernät i det virtuella IPv6-nätverksadressområdet
Mallavsnitt att lägga till:
{
"name": "V6Subnet",
"properties": {
"addressPrefix": "[variables('subnetv6AddressRange')]"
}
IPv6-konfiguration för nätverkskortet
Mallavsnitt att lägga till:
{
"name": "ipconfig-v6",
"properties": {
"privateIPAllocationMethod": "Dynamic",
"privateIPAddressVersion":"IPv6",
"subnet": {
"id": "[variables('v6-subnet-id')]"
},
"loadBalancerBackendAddressPools": [
{
"id": "[concat(resourceId('Microsoft.Network/loadBalancers','loadBalancer'),'/backendAddressPools/LBBAP-v6')]"
}
IPv6-regler för nätverkssäkerhetsgrupp (NSG)
{
"name": "default-allow-rdp",
"properties": {
"description": "Allow RDP",
"protocol": "Tcp",
"sourcePortRange": "33819-33829",
"destinationPortRange": "5000-6000",
"sourceAddressPrefix": "fd00:db8:deca:deed::/64",
"destinationAddressPrefix": "fd00:db8:deca:deed::/64",
"access": "Allow",
"priority": 1003,
"direction": "Inbound"
}
Villkorsstyrd konfiguration
Om du använder en virtuell nätverksinstallation lägger du till IPv6-vägar i routningstabellen. Annars är den här konfigurationen valfri.
{
"type": "Microsoft.Network/routeTables",
"name": "v6route",
"apiVersion": "[variables('ApiVersion')]",
"location": "[resourceGroup().location]",
"properties": {
"routes": [
{
"name": "v6route",
"properties": {
"addressPrefix": "fd00:db8:deca:deed::/64",
"nextHopType": "VirtualAppliance",
"nextHopIpAddress": "fd00:db8:ace:f00d::1"
}
Valfri konfiguration
IPv6 Internet-åtkomst för det virtuella nätverket
{
"name": "LBFE-v6",
"properties": {
"publicIPAddress": {
"id": "[resourceId('Microsoft.Network/publicIPAddresses','lbpublicip-v6')]"
}
Offentliga IP-adresser för IPv6
{
"apiVersion": "[variables('ApiVersion')]",
"type": "Microsoft.Network/publicIPAddresses",
"name": "lbpublicip-v6",
"location": "[resourceGroup().location]",
"sku": {
"name": "Standard"
},
"properties": {
"publicIPAllocationMethod": "Static",
"publicIPAddressVersion": "IPv6"
}
IPv6-klientdel för lastbalanserare
{
"name": "LBFE-v6",
"properties": {
"publicIPAddress": {
"id": "[resourceId('Microsoft.Network/publicIPAddresses','lbpublicip-v6')]"
}
Adresspool för IPv6-backend till lastbalanserare
"backendAddressPool": {
"id": "[concat(resourceId('Microsoft.Network/loadBalancers', 'loadBalancer'), '/backendAddressPools/LBBAP-v6')]"
},
"protocol": "Tcp",
"frontendPort": 8080,
"backendPort": 8080
},
"name": "lbrule-v6"
IPv6-lastbalanseringsregler för att associera inkommande och utgående portar
{
"name": "ipconfig-v6",
"properties": {
"privateIPAllocationMethod": "Dynamic",
"privateIPAddressVersion":"IPv6",
"subnet": {
"id": "[variables('v6-subnet-id')]"
},
"loadBalancerBackendAddressPools": [
{
"id": "[concat(resourceId('Microsoft.Network/loadBalancers','loadBalancer'),'/backendAddressPools/LBBAP-v6')]"
}
Exempel på JSON för VM-mall
Om du vill distribuera ett IPv6-program med dubbla staplar i ett virtuellt Azure-nätverk med hjälp av Azure Resource Manager-mallen kan du visa exempelmallen här.