In dit artikel leest u hoe u een IPv4- en IPv6-toepassing (Dual Stack+ IPv6) implementeert met behulp van Standard Load Balancer in Azure. Het scenario omvat een virtueel netwerk met dubbele stack en een subnet met dubbele stack, een Standard Load Balancer met dubbele frontendconfiguraties voor IPv4 en IPv6, VM's met NIC's die een dubbele IP-configuratie hebben, regels voor dubbele netwerkbeveiligingsgroepen en dubbele openbare IP-adressen.
Volg deze instructies in Azure PowerShell om een IPv4- en IPv6-toepassing (Dual Stack+ IPv6) te implementeren met behulp van Standard Load Balancer in 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 oost VS.
$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
Maak een back-endadresgroep met New-AzLoadBalancerBackendAddressPoolConfig voor de virtuele machines die later zullen worden geïmplementeerd. In het volgende voorbeeld worden back-endadresgroepen met de naam dsLbBackEndPool_v4 en dsLbBackEndPool_v6 gemaakt om virtuele machines op te nemen met zowel IPV4- als IPv6-NIC-configuraties:
$backendPoolv4 = New-AzLoadBalancerBackendAddressPoolConfig `
-Name "dsLbBackEndPool_v4"
$backendPoolv6 = New-AzLoadBalancerBackendAddressPoolConfig `
-Name "dsLbBackEndPool_v6"
Een gezondheidstest 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-gezondheidsonderzoeken.
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 virtuele netwerk.
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
NICs 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.
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.
Hulpmiddelen opruimen
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
Volg deze instructies in Azure CLI om een IPv4- en IPv6-toepassing (Dual Stack+ IPv6) te implementeren met behulp van Standard Load Balancer in Azure.
Een brongroep maken
Voordat u uw virtuele dual-stack-netwerk kunt maken, moet u een resourcegroep maken met az group create. In het volgende voorbeeld wordt een resourcegroep met de naam DsResourceGroup01 gemaakt op de locatie eastus :
az group create \
--name DsResourceGroup01 \
--location eastus
Openbare IP-adressen voor IPv4 en IPv6 maken voor load balancer
Voor toegang tot uw IPv4- en IPv6-eindpunten op internet hebt u openbare IPv4- en IPv6-adressen nodig voor de load balancer. Maak een openbaar IP-adres met az network public-ip create. In het volgende voorbeeld worden IPv4 en IPv6 openbaar IP-adres gemaakt met de naam dsPublicIP_v4 en dsPublicIP_v6 in de resourcegroep 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
Openbare IP-adressen voor VM's maken
Als u op afstand toegang wilt krijgen tot uw VIRTUELE machines op internet, hebt u openbare IPv4-IP-adressen voor de VM's nodig. Maak een openbaar IP-adres met 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
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.
Load balancer maken
Maak de Standard Load Balancer met az network lb create met de naam dsLB met een front-endpool met de naam dsLbFrontEnd_v4, een back-endpool met de naam dsLbBackEndPool_v4 die is gekoppeld aan het openbare IPv4-IP-adres dsPublicIP_v4 dat u in de vorige stap hebt gemaakt.
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
IPv6-front-end maken
Maak een IPV6-front-end-IP met az network lb frontend-ip create. In het volgende voorbeeld wordt een front-end-IP-configuratie gemaakt met de naam dsLbFrontEnd_v6 en wordt het dsPublicIP_v6-adres gekoppeld:
az network lb frontend-ip create \
--lb-name dsLB \
--name dsLbFrontEnd_v6 \
--resource-group DsResourceGroup01 \
--public-ip-address dsPublicIP_v6
Maak een IPv6-back-endadrespool met az network lb address-pool create. In het volgende voorbeeld wordt een back-endadresgroep met de naam dsLbBackEndPool_v6 gemaakt om VM's met IPv6 NIC-configuraties op te nemen:
az network lb address-pool create \
--lb-name dsLB \
--name dsLbBackEndPool_v6 \
--resource-group DsResourceGroup01
Een gezondheidstest maken
Maak een statustest met az network lb probe create om de status van de virtuele machines te bewaken.
az network lb probe create -g DsResourceGroup01 --lb-name dsLB -n dsProbe --protocol tcp --port 3389
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.
Gebruik az network lb rule create om een load balancer-regel te maken. 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:
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
Netwerkbronnen maken
Voordat u enkele VM's implementeert, moet u ondersteunende netwerkbronnen maken: beschikbaarheidsset, netwerkbeveiligingsgroep, virtueel netwerk en virtuele NIC's.
Een beschikbaarheidsset maken
Als u de beschikbaarheid van uw app wilt verbeteren, plaatst u uw VM's in een beschikbaarheidsset.
Maak een beschikbaarheidsset met az vm availability-set create. In het volgende voorbeeld wordt een beschikbaarheidsset met de naam dsAVset gemaakt:
az vm availability-set create \
--name dsAVset \
--resource-group DsResourceGroup01 \
--location eastus \
--platform-fault-domain-count 2 \
--platform-update-domain-count 2
Netwerkbeveiligingsgroep maken
Maak een netwerkbeveiligingsgroep voor de regels voor binnenkomende en uitgaande communicatie in uw virtuele netwerk.
Een netwerkbeveiligingsgroep maken
Een netwerkbeveiligingsgroep maken met az network nsg create
az network nsg create \
--name dsNSG1 \
--resource-group DsResourceGroup01 \
--location eastus
Een regel voor een netwerkbeveiligingsgroep maken voor binnenkomende en uitgaande verbindingen
Maak een regel voor een netwerkbeveiligingsgroep om RDP-verbindingen toe te staan via poort 3389, internetverbinding via poort 80 en voor uitgaande verbindingen met 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 "*"
Een virtueel netwerk maken
Maak een virtueel netwerk met az network vnet create. In het volgende voorbeeld wordt een virtueel netwerk met de naam dsVNET gemaakt met subnetten dsSubNET_v4 en 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
NICs maken
Maak virtuele NIC's voor elke virtuele machine met az network nic create. In het volgende voorbeeld wordt een virtuele NIC voor elke virtuele machine gemaakt. Elke NIC heeft twee IP-configuraties (1 IPv4-configuratie, 1 IPv6-configuratie). U maakt de IPV6-configuratie met 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
Virtuele machines maken
Maak de VM's met az vm create. In het volgende voorbeeld worden twee VM's en de vereiste onderdelen van het virtuele netwerk gemaakt als deze nog niet bestaan.
Maak als volgt virtuele machine dsVM0 :
az vm create \
--name dsVM0 \
--resource-group DsResourceGroup01 \
--nics dsNIC0 \
--size Standard_A2 \
--availability-set dsAVset \
--image MicrosoftWindowsServer:WindowsServer:2019-Datacenter:latest
Maak de virtuele machine dsVM1 als volgt:
az vm create \
--name dsVM1 \
--resource-group DsResourceGroup01 \
--nics dsNIC1 \
--size Standard_A2 \
--availability-set dsAVset \
--image MicrosoftWindowsServer:WindowsServer:2019-Datacenter:latest
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 myVirtualNetwork wordt weergegeven in de zoekresultaten, selecteert u dit. 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.
Hulpmiddelen opruimen
U kunt de opdracht az group delete gebruiken om de resourcegroep, de VM en alle gerelateerde resources te verwijderen wanneer u ze niet meer nodig hebt.
az group delete --name DsResourceGroup01
Gebruik de sjabloon die in dit artikel wordt beschreven om een IPv4- en IPv6-toepassing (Dual Stack+ IPv6) te implementeren met behulp van Standard Load Balancer in Azure.
Vereiste configuraties
Zoek naar de sjabloonsecties in de sjabloon om te zien waar ze moeten plaatsvinden.
IPv6-adresruimte voor het virtuele netwerk
Sjabloonsectie die u wilt toevoegen:
"addressSpace": {
"addressPrefixes": [
"[variables('vnetv4AddressRange')]",
"[variables('vnetv6AddressRange')]"
IPv6-subnet binnen de adresruimte van het virtuele IPv6-netwerk
Sjabloonsectie die u wilt toevoegen:
{
"name": "V6Subnet",
"properties": {
"addressPrefix": "[variables('subnetv6AddressRange')]"
}
IPv6-configuratie voor de NIC
Sjabloonsectie die u wilt toevoegen:
{
"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')]"
}
NSG-regels (IPv6-netwerkbeveiligingsgroep)
{
"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"
}
Voorwaardelijke configuratie
Als u een virtueel netwerkapparaat gebruikt, voegt u IPv6-routes toe in de routetabel. Anders is deze configuratie optioneel.
{
"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"
}
Optionele configuratie
IPv6-internettoegang voor het virtuele netwerk
{
"name": "LBFE-v6",
"properties": {
"publicIPAddress": {
"id": "[resourceId('Microsoft.Network/publicIPAddresses','lbpublicip-v6')]"
}
Openbare IPv6-IP-adressen
{
"apiVersion": "[variables('ApiVersion')]",
"type": "Microsoft.Network/publicIPAddresses",
"name": "lbpublicip-v6",
"location": "[resourceGroup().location]",
"sku": {
"name": "Standard"
},
"properties": {
"publicIPAllocationMethod": "Static",
"publicIPAddressVersion": "IPv6"
}
IPv6-front-end voor Load Balancer
{
"name": "LBFE-v6",
"properties": {
"publicIPAddress": {
"id": "[resourceId('Microsoft.Network/publicIPAddresses','lbpublicip-v6')]"
}
IPv6-back-endadresgroep voor Load Balancer
"backendAddressPool": {
"id": "[concat(resourceId('Microsoft.Network/loadBalancers', 'loadBalancer'), '/backendAddressPools/LBBAP-v6')]"
},
"protocol": "Tcp",
"frontendPort": 8080,
"backendPort": 8080
},
"name": "lbrule-v6"
IPv6-regels voor load balancer om binnenkomende en uitgaande poorten te koppelen
{
"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')]"
}
VM-sjabloon JSON-voorbeeld
Als u een IPv6-toepassing met dubbele stack in een virtueel Azure-netwerk wilt implementeren met behulp van een Azure Resource Manager-sjabloon, bekijkt u hier een voorbeeldsjabloon.