In diesem Artikel erfahren Sie, wie Sie eine Dual-Stack-Anwendung (IPv4 + IPv6) mithilfe des Standardlastenausgleichs in Azure bereitstellen. Das Szenario umfasst ein virtuelles Dualstapel-Netzwerk mit einem Dualstapel-Subnetz, einen Standardlastenausgleich mit dualen (IPv4 + IPv6)-Front-End-Konfigurationen, VMs mit NICs mit einer dualen IP-Konfiguration, Regeln für duale Netzwerksicherheitsgruppen und duale öffentliche IPs.
Befolgen Sie diese Anweisungen in Azure PowerShell, um eine Dual-Stack-Anwendung (IPv4 + IPv6) mithilfe des Standardlastenausgleichs in Azure bereitzustellen.
Erstellen einer Ressourcengruppe
Bevor Sie Ihr virtuelles Dual-Stack-Netzwerk erstellen können, müssen Sie eine Ressourcengruppe mit New-AzResourceGroup erstellen. Im folgenden Beispiel wird eine Ressourcengruppe namens "myRGDualStack " am Standort "east us " erstellt:
$rg = New-AzResourceGroup `
-ResourceGroupName "dsRG1" `
-Location "east us"
Erstellen von öffentlichen IPv4- und IPv6-IP-Adressen
Um über das Internet auf Ihre virtuellen Computer zuzugreifen, benötigen Sie öffentliche IPv4- und IPv6-IP-Adressen für das Lastenausgleichsmodul. Erstellen Sie öffentliche IP-Adressen mit New-AzPublicIpAddress. Im folgenden Beispiel wird die öffentliche IP-Adresse "IPv4" und "IPv6" mit dem Namen dsPublicIP_v4 und dsPublicIP_v6 in der Ressourcengruppe "dsRG1 " erstellt:
$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
Um mit einer RDP-Verbindung auf Ihre virtuellen Computer zuzugreifen, erstellen Sie IPv4-öffentliche IP-Adressen für die virtuellen Computer mit 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
Standard-Load-Balancer erstellen
In diesem Abschnitt konfigurieren Sie die duale Frontend-IP (IPv4 und IPv6) und den Back-End-Adresspool für das Lastenausgleichsmodul und erstellen dann einen Standardlastenausgleich.
Erstellen einer Front-End-IP
Erstellen Sie eine Frontend-IP-Konfiguration mit New-AzLoadBalancerFrontendIpConfig. Im folgenden Beispiel werden IPv4- und IPv6-Front-End-IP-Konfigurationen namens dsLbFrontEnd_v4 und dsLbFrontEnd_v6 erstellt:
$frontendIPv4 = New-AzLoadBalancerFrontendIpConfig `
-Name "dsLbFrontEnd_v4" `
-PublicIpAddress $PublicIP_v4
$frontendIPv6 = New-AzLoadBalancerFrontendIpConfig `
-Name "dsLbFrontEnd_v6" `
-PublicIpAddress $PublicIP_v6
Erstellen Sie einen Back-End-Adresspool mit New-AzLoadBalancerBackendAddressPoolConfig für die später bereitgestellten virtuellen Computer. Im folgenden Beispiel werden Back-End-Adresspools mit dem Namen dsLbBackEndPool_v4 und dsLbBackEndPool_v6 erstellt, um virtuelle Computer mit IPV4- und IPv6-NIC-Konfigurationen einzuschließen:
$backendPoolv4 = New-AzLoadBalancerBackendAddressPoolConfig `
-Name "dsLbBackEndPool_v4"
$backendPoolv6 = New-AzLoadBalancerBackendAddressPoolConfig `
-Name "dsLbBackEndPool_v6"
Erstellen eines Integritätstests
Verwenden Sie Add-AzLoadBalancerProbeConfig , um einen Integritätstest zu erstellen, um die Integrität der virtuellen Computer zu überwachen.
$probe = New-AzLoadBalancerProbeConfig -Name MyProbe -Protocol tcp -Port 3389 -IntervalInSeconds 15 -ProbeCount 2
Erstellen einer Load Balancer-Regel
Mithilfe einer Load Balancer-Regel wird definiert, wie Datenverkehr auf die virtuellen Computer verteilt werden soll. Sie definieren die Front-End-IP-Konfiguration für den eingehenden Datenverkehr und den Back-End-IP-Pool zum Empfangen des Datenverkehrs zusammen mit dem erforderlichen Quell- und Zielport. Um sicherzustellen, dass nur fehlerfreie VMs Datenverkehr empfangen, können Sie optional eine Integritätssonde definieren. Der grundlegende Lastenausgleicher verwendet eine IPv4-Probe, um den Zustand für IPv4- und IPv6-Endpunkte auf den virtuellen Computern zu bewerten. Der Standardlastenausgleich unterstützt explizite IPv6-Integritätstests.
Erstellen Sie eine Lastenausgleichsregel mit Add-AzLoadBalancerRuleConfig. Das folgende Beispiel erstellt Load Balancer-Regeln mit den Namen dsLBrule_v4 und dsLBrule_v6 und führt Lastenausgleich des Datenverkehrs an TCP-Port 80 zu den IPv4- und IPv6-Front-End-IP-Konfigurationen aus:
$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 erstellen
Erstellen Sie einen Standardlastenausgleich mit New-AzLoadBalancer. Im folgenden Beispiel wird ein öffentlicher Standardlastenausgleichsmodul namens myLoadBalancer mit den IPv4- und IPv6-Front-End-IP-Konfigurationen, Back-End-Pools und Lastenausgleichsregeln erstellt, die Sie in den vorherigen Schritten erstellt haben:
$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
Erstellen von Netzwerkressourcen
Bevor Sie einige virtuelle Computer bereitstellen und Ihren Balancer testen können, müssen Sie unterstützende Netzwerkressourcen erstellen – Verfügbarkeitsgruppe, Netzwerksicherheitsgruppe, virtuelles Netzwerk und virtuelle NICs.
Verfügbarkeitsgruppe erstellen
Um die hohe Verfügbarkeit Ihrer App zu verbessern, platzieren Sie Ihre virtuellen Computer in einem Verfügbarkeitssatz.
Erstellen Sie einen Verfügbarkeitssatz mit New-AzAvailabilitySet. Im folgenden Beispiel wird ein Verfügbarkeitssatz namens myAvailabilitySet erstellt:
$avset = New-AzAvailabilitySet `
-ResourceGroupName $rg.ResourceGroupName `
-Location $rg.Location `
-Name "dsAVset" `
-PlatformFaultDomainCount 2 `
-PlatformUpdateDomainCount 2 `
-Sku aligned
Erstellen einer Netzwerksicherheitsgruppe
Erstellen Sie eine Netzwerksicherheitsgruppe für die Regeln, die eingehende und ausgehende Kommunikation in Ihrem virtuellen Netzwerk steuern.
Erstellen einer Netzwerksicherheitsgruppenregel für Port 3389
Erstellen Sie eine Netzwerksicherheitsgruppenregel, um RDP-Verbindungen über Port 3389 mit New-AzNetworkSecurityRuleConfig zuzulassen.
$rule1 = New-AzNetworkSecurityRuleConfig `
-Name 'myNetworkSecurityGroupRuleRDP' `
-Description 'Allow RDP' `
-Access Allow `
-Protocol Tcp `
-Direction Inbound `
-Priority 100 `
-SourceAddressPrefix * `
-SourcePortRange * `
-DestinationAddressPrefix * `
-DestinationPortRange 3389
Erstellen einer Netzwerksicherheitsgruppenregel für Port 80
Erstellen Sie eine Netzwerksicherheitsgruppenregel, um Internetverbindungen über Port 80 mit New-AzNetworkSecurityRuleConfig zuzulassen.
$rule2 = New-AzNetworkSecurityRuleConfig `
-Name 'myNetworkSecurityGroupRuleHTTP' `
-Description 'Allow HTTP' `
-Access Allow `
-Protocol Tcp `
-Direction Inbound `
-Priority 200 `
-SourceAddressPrefix * `
-SourcePortRange * `
-DestinationAddressPrefix * `
-DestinationPortRange 80
Erstellen einer Netzwerksicherheitsgruppe
Erstellen Sie mit New-AzNetworkSecurityGroup eine Netzwerksicherheitsgruppe.
$nsg = New-AzNetworkSecurityGroup `
-ResourceGroupName $rg.ResourceGroupName `
-Location $rg.Location `
-Name "dsNSG1" `
-SecurityRules $rule1,$rule2
Erstellen eines virtuellen Netzwerks
Erstellen Sie mit New-AzVirtualNetwork ein virtuelles Netzwerk. Im folgenden Beispiel wird ein virtuelles Netzwerk namens "dsVnet " mit mySubnet erstellt:
# 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
Erstellen von NICs
Erstellen Sie virtuelle NICs mit New-AzNetworkInterface. Im folgenden Beispiel werden zwei virtuelle NICs sowohl mit IPv4- als auch mit IPv6-Konfigurationen erstellt. (Eine virtuelle NIC für jeden virtuellen Computer, den Sie für Ihre App in den folgenden Schritten erstellen).
$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
Erstellen von virtuellen Computern
Legen Sie einen Administratorbenutzernamen und ein Kennwort für die virtuellen Computer mit Get-Credential fest:
$cred = get-credential -Message "DUAL STACK VNET SAMPLE: Please enter the Administrator credential to log into the VMs."
Jetzt können Sie die virtuellen Computer mit New-AzVM erstellen. Im folgenden Beispiel werden zwei virtuelle Computer und die erforderlichen Komponenten für virtuelle Netzwerke erstellt, sofern sie noch nicht vorhanden sind.
$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
Ermitteln von IP-Adressen der IPv4- und IPv6-Endpunkte
Rufen Sie alle Netzwerkschnittstellenobjekte in der Ressourcengruppe ab, um die in dieser Bereitstellung verwendeten IP-Adressen mit get-AzNetworkInterface
zusammenzufassen. Rufen Sie außerdem die Frontend-Adressen des Load Balancers der IPv4- und IPv6-Endpunkte mit get-AzpublicIpAddress
ab.
$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
Die folgende Abbildung zeigt eine Beispielausgabe, in der die privaten IPv4- und IPv6-Adressen der beiden virtuellen Computer sowie die Front-End-IPv4- und IPv6-IP-Adressen des Lastenausgleichs aufgelistet sind.
Anzeigen des virtuellen IPv6-Dual Stack-Netzwerks im Azure-Portal
Sie können das virtuelle IPv6-Dual Stack-Netzwerk im Azure-Portal wie folgt anzeigen:
- Geben Sie in der Suchleiste des Portals dsVnet ein.
- Wenn dsVnet in den Suchergebnissen angezeigt wird, wählen Sie es aus. Dadurch wird die Seite Übersicht des virtuellen Dual Stack-Netzwerks namens dsVnet gestartet. Das virtuelle Dual Stack-Netzwerk zeigt die beiden NICs mit IPv4- und IPv6-Konfigurationen im Dual Stack-Subnetz namens dsSubnet.
Bereinigen von Ressourcen
Wenn sie nicht mehr benötigt wird, können Sie den Befehl "Remove-AzResourceGroup " verwenden, um die Ressourcengruppe, den virtuellen Computer und alle zugehörigen Ressourcen zu entfernen.
Remove-AzResourceGroup -Name dsRG1
Befolgen Sie diese Anweisungen in Azure CLI, um eine duale Stapelanwendung (IPv4 + IPv6) mithilfe des Standardlastenausgleichs in Azure bereitzustellen.
Erstellen einer Ressourcengruppe
Bevor Sie Ihr virtuelles Dual-Stack-Netzwerk erstellen können, müssen Sie eine Ressourcengruppe mit az group erstellen. Im folgenden Beispiel wird eine Ressourcengruppe namens "DsResourceGroup01" in der Region East US erstellt.
az group create \
--name DsResourceGroup01 \
--___location eastus
Erstellen von öffentlichen IPv4- und IPv6-IP-Adressen für den Lastenausgleich
Für den Zugriff auf Ihre IPv4- und IPv6-Endpunkte im Internet benötigen Sie öffentliche IPv4- und IPv6-IP-Adressen für das Lastenausgleichsmodul. Erstellen Sie eine öffentliche IP-Adresse mit az network public-ip create. Im folgenden Beispiel wird die öffentliche IP-Adresse "IPv4" und "IPv6" mit dem Namen dsPublicIP_v4 und dsPublicIP_v6 in der Ressourcengruppe "DsResourceGroup01 " erstellt:
# 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
Erstellen öffentlicher IP-Adressen für VMs
Um remote auf Ihre virtuellen Computer im Internet zuzugreifen, benötigen Sie öffentliche IPv4-IP-Adressen für die virtuellen Computer. Erstellen Sie eine öffentliche IP-Adresse mit 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
Standard-Load-Balancer erstellen
In diesem Abschnitt konfigurieren Sie die duale Frontend-IP (IPv4 und IPv6) und den Back-End-Adresspool für das Lastenausgleichsmodul und erstellen dann einen Standardlastenausgleich.
Load Balancer erstellen
Erstellen Sie den Standard-Load Balancer mit az network lb create, benannt dsLB, der einen Frontend-Pool namens dsLbFrontEnd_v4 und einen Backend-Pool namens dsLbBackEndPool_v4 enthält, der mit der IPv4 öffentlichen IP-Adresse dsPublicIP_v4 verbunden ist, die Sie im vorherigen Schritt erstellt haben.
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-Frontend erstellen
Erstellen Sie eine IPV6-Frontend-IP mit az network lb frontend-ip create. Im folgenden Beispiel wird eine Front-End-IP-Konfiguration namens dsLbFrontEnd_v6 erstellt und die dsPublicIP_v6 Adresse angefügt:
az network lb frontend-ip create \
--lb-name dsLB \
--name dsLbFrontEnd_v6 \
--resource-group DsResourceGroup01 \
--public-ip-address dsPublicIP_v6
Erstellen Sie einen IPv6-Backend-Adresspool mit az network lb address-pool create. Im folgenden Beispiel wird der Back-End-Adresspool namens dsLbBackEndPool_v6 erstellt, um VMs mit IPv6-NIC-Konfigurationen einzuschließen:
az network lb address-pool create \
--lb-name dsLB \
--name dsLbBackEndPool_v6 \
--resource-group DsResourceGroup01
Erstellen eines Integritätstests
Erstellen Sie mit az network lb probe create einen Integritätstest zur Überwachung der Integrität von virtuellen Computern.
az network lb probe create -g DsResourceGroup01 --lb-name dsLB -n dsProbe --protocol tcp --port 3389
Erstellen einer Load Balancer-Regel
Mithilfe einer Load Balancer-Regel wird definiert, wie Datenverkehr auf die virtuellen Computer verteilt werden soll. Sie definieren die Front-End-IP-Konfiguration für den eingehenden Datenverkehr und den Back-End-IP-Pool zum Empfangen des Datenverkehrs zusammen mit dem erforderlichen Quell- und Zielport.
Erstellen Sie mit az network lb rule create eine Load Balancer-Regel. Das folgende Beispiel erstellt Load Balancer-Regeln mit den Namen dsLBrule_v4 und dsLBrule_v6 und führt Lastenausgleich des Datenverkehrs an TCP-Port 80 zu den IPv4- und IPv6-Front-End-IP-Konfigurationen aus:
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
Erstellen von Netzwerkressourcen
Bevor Sie einige virtuelle Computer bereitstellen, müssen Sie unterstützende Netzwerkressourcen erstellen – Verfügbarkeitsgruppe, Netzwerksicherheitsgruppe, virtuelles Netzwerk und virtuelle NICs.
Verfügbarkeitsgruppe erstellen
Um die Verfügbarkeit Ihrer App zu verbessern, platzieren Sie Ihre virtuellen Computer in einem Verfügbarkeitssatz.
Erstellen Sie einen Verfügbarkeitssatz mit az vm availability-set create. Im folgenden Beispiel wird eine Verfügbarkeitsgruppe namens dsAVset erstellt:
az vm availability-set create \
--name dsAVset \
--resource-group DsResourceGroup01 \
--___location eastus \
--platform-fault-___domain-count 2 \
--platform-update-___domain-count 2
Erstellen einer Netzwerksicherheitsgruppe
Erstellen Sie eine Netzwerksicherheitsgruppe für die Regeln, die eingehende und ausgehende Kommunikation in Ihrem virtuellen Netzwerk steuern.
Erstellen einer Netzwerksicherheitsgruppe
Erstellen einer Netzwerksicherheitsgruppe mit az network nsg create
az network nsg create \
--name dsNSG1 \
--resource-group DsResourceGroup01 \
--___location eastus
Erstellen einer Netzwerksicherheitsgruppenregel für eingehende und ausgehende Verbindungen
Erstellen Sie eine Regel für die Netzwerksicherheitsgruppe, um RDP-Verbindungen über Port 3389 zu ermöglichen, Internetverbindungen über Port 80 zuzulassen und ausgehende Verbindungen mit az network nsg rule create festzulegen.
# 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 "*"
Erstellen eines virtuellen Netzwerks
Erstellen Sie mit az network vnet create ein virtuelles Netzwerk. Im folgenden Beispiel wird ein virtuelles Netzwerk namens dsVNET mit Subnetzen dsSubNET_v4 und dsSubNET_v6 erstellt:
# 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
Erstellen von NICs
Erstellen Sie virtuelle NICs für jeden virtuellen Computer mit az network nic create. Im folgenden Beispiel wird für jeden virtuellen Computer eine virtuelle NIC erstellt. Jede NIC verfügt über zwei IP-Konfigurationen (1 IPv4-Konfiguration, 1 IPv6-Konfiguration). Sie erstellen die IPV6-Konfiguration mit az network nic ip-config erstellen.
# 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
Erstellen von virtuellen Computern
Erstellen Sie die virtuellen Computer mit az vm create. Im folgenden Beispiel werden zwei virtuelle Computer und die erforderlichen Komponenten für virtuelle Netzwerke erstellt, sofern sie noch nicht vorhanden sind.
Erstellen Sie den virtuellen Computer dsVM0 wie folgt:
az vm create \
--name dsVM0 \
--resource-group DsResourceGroup01 \
--nics dsNIC0 \
--size Standard_A2 \
--availability-set dsAVset \
--image MicrosoftWindowsServer:WindowsServer:2019-Datacenter:latest
Erstellen Sie die virtuelle Maschine dsVM1 wie folgt:
az vm create \
--name dsVM1 \
--resource-group DsResourceGroup01 \
--nics dsNIC1 \
--size Standard_A2 \
--availability-set dsAVset \
--image MicrosoftWindowsServer:WindowsServer:2019-Datacenter:latest
Anzeigen des virtuellen IPv6-Dual Stack-Netzwerks im Azure-Portal
Sie können das virtuelle IPv6-Dual Stack-Netzwerk im Azure-Portal wie folgt anzeigen:
- Geben Sie in der Suchleiste des Portals dsVnet ein.
- Wenn myVirtualNetwork in den Suchergebnissen angezeigt wird, können Sie den Begriff auswählen. Dadurch wird die Seite Übersicht des virtuellen Dual Stack-Netzwerks namens dsVnet gestartet. Das virtuelle Dual Stack-Netzwerk zeigt die beiden NICs mit IPv4- und IPv6-Konfigurationen im Dual Stack-Subnetz namens dsSubnet.
Bereinigen von Ressourcen
Wenn Ressourcengruppe, virtueller Computer und alle zugehörigen Ressourcen nicht mehr benötigt werden, können Sie sie mit dem Befehl az group delete entfernen.
az group delete --name DsResourceGroup01
Verwenden Sie die in diesem Artikel beschriebene Vorlage, um eine Dual-Stack-Anwendung (IPv4 + IPv6) mithilfe des Standardlastenausgleichs in Azure bereitzustellen.
Erforderliche Konfigurationen
Suchen Sie nach den Vorlagenabschnitten in der Vorlage, um zu sehen, wo sie auftreten sollen.
IPv6 addressSpace für das virtuelle Netzwerk
Hinzuzufügenden Vorlagenabschnitt:
"addressSpace": {
"addressPrefixes": [
"[variables('vnetv4AddressRange')]",
"[variables('vnetv6AddressRange')]"
IPv6-Subnetz innerhalb des virtuellen IPv6-Netzwerkadressraums
Hinzuzufügenden Vorlagenabschnitt:
{
"name": "V6Subnet",
"properties": {
"addressPrefix": "[variables('subnetv6AddressRange')]"
}
IPv6-Konfiguration für die NIC
Vorlagenabschnitt zum Hinzufügen:
{
"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-Netzwerksicherheitsgruppe (NSG)-Regeln
{
"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"
}
Bedingte Konfiguration
Wenn Sie eine virtuelle Netzwerk-Appliance verwenden, fügen Sie IPv6-Routen in der Route-Tabelle hinzu. Andernfalls ist diese Konfiguration optional.
{
"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"
}
Optionale Konfiguration
IPv6-Internetzugriff für das virtuelle Netzwerk
{
"name": "LBFE-v6",
"properties": {
"publicIPAddress": {
"id": "[resourceId('Microsoft.Network/publicIPAddresses','lbpublicip-v6')]"
}
Öffentliche 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 für Lastenausgleich
{
"name": "LBFE-v6",
"properties": {
"publicIPAddress": {
"id": "[resourceId('Microsoft.Network/publicIPAddresses','lbpublicip-v6')]"
}
IPv6-Backend-Adresspool für Load Balancer
"backendAddressPool": {
"id": "[concat(resourceId('Microsoft.Network/loadBalancers', 'loadBalancer'), '/backendAddressPools/LBBAP-v6')]"
},
"protocol": "Tcp",
"frontendPort": 8080,
"backendPort": 8080
},
"name": "lbrule-v6"
IPv6-Lastenausgleichsregeln zum Zuordnen von eingehenden und ausgehenden Ports
{
"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')]"
}
BEISPIEL für EINE VM-Vorlage JSON
Um eine IPv6 Dual-Stack-Anwendung in einem Azure Virtual Network mithilfe einer Azure Resource Manager-Vorlage bereitzustellen, können Sie die Beispielvorlage hier ansehen.