Een openbare load balancer maken met IPv6 met behulp van Azure CLI

Notitie

In dit artikel wordt een inleidende IPv6-functie beschreven waarmee Basic Load Balancers zowel IPv4- als IPv6-connectiviteit kunnen bieden. Uitgebreide IPv6-connectiviteit is nu beschikbaar met IPv6 voor Azure VNETs die IPv6-connectiviteit integreert met uw virtuele netwerken en belangrijke functies bevat, zoals IPv6-regels voor netwerkbeveiligingsgroepen , door de gebruiker gedefinieerde IPv6-routering, IPv6 Basic- en Standard-taakverdeling en meer. IPv6 voor Azure VNET's is de aanbevolen standaard voor IPv6-toepassingen in Azure. IPv6 voor Azure VNET PowerShell-implementatie bekijken

Azure Load Balancer is een Layer-4 (TCP, UDP) load balancer. Load balancers bieden hoge beschikbaarheid door binnenkomend verkeer te distribueren tussen gezonde service-exemplaren in cloudservices of virtuele machines in een load balancer-set. Load balancers kunnen deze services ook presenteren op meerdere poorten of meerdere IP-adressen of beide.

Voorbeeldimplementatiescenario

In het volgende diagram ziet u de oplossing voor taakverdeling die is geïmplementeerd met behulp van de voorbeeldsjabloon die in dit artikel wordt beschreven.

In dit scenario maakt u de volgende Azure-resources:

• Twee virtuele machines (VM's)
• Een virtuele netwerkinterface voor elke VM met zowel IPv4- als IPv6-adressen toegewezen
• Een openbare load balancer met een IPv4 en een openbaar IPv6-IP-adres
• Een beschikbaarheidsset die de twee VM's bevat
• Twee taakverdelingsregels om de openbare VIP's toe te wijzen aan de privé-eindpunten

De oplossing implementeren met behulp van Azure CLI

De volgende stappen laten zien hoe u een openbare load balancer maakt met behulp van Azure CLI. Met CLI maakt en configureert u elk object afzonderlijk en stelt u ze vervolgens samen om een resource te maken.

Als u een load balancer wilt implementeren, maakt en configureert u de volgende objecten:

• Front-end-IP-configuratie: bevat openbare IP-adressen voor binnenkomend netwerkverkeer.
• Back-endadresgroep: bevat netwerkinterfaces (NIC's) voor de virtuele machines om netwerkverkeer van de load balancer te ontvangen.
• Taakverdelingsregels: bevat regels die een openbare poort op de load balancer toewijzen aan een poort in de back-endadresgroep.
• Inkomende NAT-regels: bevat NAT-regels (Network Address Translation) die een openbare poort op de load balancer toewijzen aan een poort voor een specifieke virtuele machine in de back-endadresgroep.
• Tests: Bevat statustests die worden gebruikt om de beschikbaarheid van exemplaren van virtuele machines in de back-endadresgroep te controleren.

Azure CLI instellen

In dit voorbeeld voert u de Azure CLI-hulpprogramma's uit in een PowerShell-opdrachtvenster. Als u de leesbaarheid en het hergebruik wilt verbeteren, gebruikt u de scriptmogelijkheden van PowerShell, niet de Azure PowerShell-cmdlets.

1. Installeer en configureer de Azure CLI door de stappen in het gekoppelde artikel te volgen en u aan te melden bij uw Azure-account.

2. PowerShell-variabelen instellen voor gebruik met de Azure CLI-opdrachten:

   $subscriptionid = "########-####-####-####-############"  # enter subscription id
   $location = "southcentralus"
   $rgName = "pscontosorg1southctrlus09152016"
   $vnetName = "contosoIPv4Vnet"
   $vnetPrefix = "10.0.0.0/16"
   $subnet1Name = "clicontosoIPv4Subnet1"
   $subnet1Prefix = "10.0.0.0/24"
   $subnet2Name = "clicontosoIPv4Subnet2"
   $subnet2Prefix = "10.0.1.0/24"
   $dnsLabel = "contoso09152016"
   $lbName = "myIPv4IPv6Lb"
   

Een resourcegroep, een load balancer, een virtueel netwerk en subnetten maken

1. Een resourcegroep maken:

   az group create --name $rgName --location $location
   

2. Een load balancer maken:

   $lb = az network lb create --resource-group $rgname --location $location --name $lbName
   

3. Een virtueel netwerk maken:

   $vnet = az network vnet create  --resource-group $rgname --name $vnetName --location $location --address-prefixes $vnetPrefix
   

4. Maak in dit virtuele netwerk twee subnetten:

   $subnet1 = az network vnet subnet create --resource-group $rgname --name $subnet1Name --address-prefix $subnet1Prefix --vnet-name $vnetName
   $subnet2 = az network vnet subnet create --resource-group $rgname --name $subnet2Name --address-prefix $subnet2Prefix --vnet-name $vnetName
   

Openbare IP-adressen voor de front-endpool maken

1. De PowerShell-variabelen instellen:

   $publicIpv4Name = "myIPv4Vip"
   $publicIpv6Name = "myIPv6Vip"
   

2. Maak een openbaar IP-adres voor de front-end-IP-adresgroep:

   $publicipV4 = az network public-ip create --resource-group $rgname --name $publicIpv4Name --location $location --version IPv4 --allocation-method Dynamic --dns-name $dnsLabel
   $publicipV6 = az network public-ip create --resource-group $rgname --name $publicIpv6Name --location $location --version IPv6 --allocation-method Dynamic --dns-name $dnsLabel
   

   Belangrijk

   De load balancer gebruikt het domeinlabel van het openbare IP-adres als FQDN (Fully Qualified Domain Name). Dit is een wijziging van de klassieke implementatie, die gebruikmaakt van de naam van de cloudservice als de FQDN van de load balancer.

   In dit voorbeeld is de FQDN contoso09152016.southcentralus.cloudapp.azure.com.

Front-end- en back-endpools maken

In deze sectie maakt u de volgende IP-adresgroepen:

• De front-end-IP-adresgroep die het binnenkomende netwerkverkeer op de load balancer ontvangt.
• De back-end-IP-pool waar de front-endpool het netwerkverkeer met gelijke taakverdeling verzendt.

1. De PowerShell-variabelen instellen:

   $frontendV4Name = "FrontendVipIPv4"
   $frontendV6Name = "FrontendVipIPv6"
   $backendAddressPoolV4Name = "BackendPoolIPv4"
   $backendAddressPoolV6Name = "BackendPoolIPv6"
   

2. Maak een front-end-IP-adresgroep en koppel deze aan het openbare IP-adres dat u in de vorige stap en de load balancer hebt gemaakt.

   $frontendV4 = az network lb frontend-ip create --resource-group $rgname --name $frontendV4Name --public-ip-address $publicIpv4Name --lb-name $lbName
   $frontendV6 = az network lb frontend-ip create --resource-group $rgname --name $frontendV6Name --public-ip-address $publicIpv6Name --lb-name $lbName
   $backendAddressPoolV4 = az network lb address-pool create --resource-group $rgname --name $backendAddressPoolV4Name --lb-name $lbName
   $backendAddressPoolV6 = az network lb address-pool create --resource-group $rgname --name $backendAddressPoolV6Name --lb-name $lbName
   

De test-, NAT-regels en load balancer-regels maken

In dit voorbeeld worden de volgende items gemaakt:

• Een testregel om te controleren op connectiviteit met TCP-poort 80.
• Een NAT-regel voor het vertalen van al het binnenkomende verkeer op poort 3389 naar poort 3389 voor RDP.*
• Een NAT-regel voor het vertalen van al het binnenkomende verkeer op poort 3391 naar poort 3389 voor extern bureaublad-protocol (RDP).*
• Een load balancer-regel voor het verdelen van al het binnenkomende verkeer op poort 80 naar poort 80 op de adressen in de back-endpool.

* NAT-regels zijn gekoppeld aan een specifiek exemplaar van een virtuele machine achter de load balancer. Het netwerkverkeer dat binnenkomt op poort 3389, wordt verzonden naar de specifieke virtuele machine en poort die is gekoppeld aan de NAT-regel. U moet een protocol (UDP of TCP) voor een NAT-regel opgeven. U kunt beide protocollen niet toewijzen aan dezelfde poort.

1. De PowerShell-variabelen instellen:

   $probeV4V6Name = "ProbeForIPv4AndIPv6"
   $natRule1V4Name = "NatRule-For-Rdp-VM1"
   $natRule2V4Name = "NatRule-For-Rdp-VM2"
   $lbRule1V4Name = "LBRuleForIPv4-Port80"
   $lbRule1V6Name = "LBRuleForIPv6-Port80"
   

2. Maak de test.

   In het volgende voorbeeld wordt een TCP-test gemaakt die elke 15 seconden controleert op connectiviteit met de TCP-poort 80 van de back-end. Na twee opeenvolgende fouten wordt de back-endresource gemarkeerd als niet beschikbaar.

   $probeV4V6 = az network lb probe create --resource-group $rgname --name $probeV4V6Name --protocol tcp --port 80 --interval 15 --threshold 2 --lb-name $lbName
   

3. Maak binnenkomende NAT-regels waarmee RDP-verbindingen met de back-endbronnen zijn toegestaan:

   $inboundNatRuleRdp1 = az network lb inbound-nat-rule create --resource-group $rgname --name $natRule1V4Name --frontend-ip-name $frontendV4Name --protocol Tcp --frontend-port 3389 --backend-port 3389 --lb-name $lbName
   $inboundNatRuleRdp2 = az network lb inbound-nat-rule create --resource-group $rgname --name $natRule2V4Name --frontend-ip-name $frontendV4Name --protocol Tcp --frontend-port 3391 --backend-port 3389 --lb-name $lbName
   

4. Maak load balancer-regels waarmee verkeer naar verschillende back-endpoorten wordt verzonden, afhankelijk van de front-end die de aanvraag heeft ontvangen.

   $lbruleIPv4 = az network lb rule create --resource-group $rgname --name $lbRule1V4Name --frontend-ip-name $frontendV4Name --backend-pool-name $backendAddressPoolV4Name --probe-name $probeV4V6Name --protocol Tcp --frontend-port 80 --backend-port 80 --lb-name $lbName
   $lbruleIPv6 = az network lb rule create --resource-group $rgname --name $lbRule1V6Name --frontend-ip-name $frontendV6Name --backend-pool-name $backendAddressPoolV6Name --probe-name $probeV4V6Name --protocol Tcp --frontend-port 80 --backend-port 8080 --lb-name $lbName
   

5. Controleer uw instellingen:

   az network lb show --resource-group $rgName --name $lbName
   

   Verwachte uitvoer:

   info:    Executing command network lb show
   info:    Looking up the load balancer "myIPv4IPv6Lb"
   data:    Id                              : /subscriptions/########-####-####-####-############/resourceGroups/pscontosorg1southctrlus09152016/providers/Microsoft.Network/loadBalancers/myIPv4IPv6Lb
   data:    Name                            : myIPv4IPv6Lb
   data:    Type                            : Microsoft.Network/loadBalancers
   data:    Location                        : southcentralus
   data:    Provisioning state              : Succeeded
   data:
   data:    Frontend IP configurations:
   data:    Name             Provisioning state  Private IP allocation  Private IP   Subnet  Public IP
   data:    ---------------  ------------------  ---------------------  -----------  ------  ---------
   data:    FrontendVipIPv4  Succeeded           Dynamic                                     myIPv4Vip
   data:    FrontendVipIPv6  Succeeded           Dynamic                                     myIPv6Vip
   data:
   data:    Probes:
   data:    Name                 Provisioning state  Protocol  Port  Path  Interval  Count
   data:    -------------------  ------------------  --------  ----  ----  --------  -----
   data:    ProbeForIPv4AndIPv6  Succeeded           Tcp       80          15        2
   data:
   data:    Backend Address Pools:
   data:    Name             Provisioning state
   data:    ---------------  ------------------
   data:    BackendPoolIPv4  Succeeded
   data:    BackendPoolIPv6  Succeeded
   data:
   data:    Load Balancing Rules:
   data:    Name                  Provisioning state  Load distribution  Protocol  Frontend port  Backend port  Enable floating IP  Idle timeout in minutes
   data:    --------------------  ------------------  -----------------  --------  -------------  ------------  ------------------  -----------------------
   data:    LBRuleForIPv4-Port80  Succeeded           Default            Tcp       80             80            false               4
   data:    LBRuleForIPv6-Port80  Succeeded           Default            Tcp       80             8080          false               4
   data:
   data:    Inbound NAT Rules:
   data:    Name                 Provisioning state  Protocol  Frontend port  Backend port  Enable floating IP  Idle timeout in minutes
   data:    -------------------  ------------------  --------  -------------  ------------  ------------------  -----------------------
   data:    NatRule-For-Rdp-VM1  Succeeded           Tcp       3389           3389          false               4
   data:    NatRule-For-Rdp-VM2  Succeeded           Tcp       3391           3389          false               4
   info:    network lb show
   

NIC's maken

Maak NIC's en koppel deze aan NAT-regels, load balancer-regels en tests.

1. De PowerShell-variabelen instellen:

   $nic1Name = "myIPv4IPv6Nic1"
   $nic2Name = "myIPv4IPv6Nic2"
   $subnet1Id = "/subscriptions/$subscriptionid/resourceGroups/$rgName/providers/Microsoft.Network/VirtualNetworks/$vnetName/subnets/$subnet1Name"
   $subnet2Id = "/subscriptions/$subscriptionid/resourceGroups/$rgName/providers/Microsoft.Network/VirtualNetworks/$vnetName/subnets/$subnet2Name"
   $backendAddressPoolV4Id = "/subscriptions/$subscriptionid/resourceGroups/$rgname/providers/Microsoft.Network/loadbalancers/$lbName/backendAddressPools/$backendAddressPoolV4Name"
   $backendAddressPoolV6Id = "/subscriptions/$subscriptionid/resourceGroups/$rgname/providers/Microsoft.Network/loadbalancers/$lbName/backendAddressPools/$backendAddressPoolV6Name"
   $natRule1V4Id = "/subscriptions/$subscriptionid/resourceGroups/$rgname/providers/Microsoft.Network/loadbalancers/$lbName/inboundNatRules/$natRule1V4Name"
   $natRule2V4Id = "/subscriptions/$subscriptionid/resourceGroups/$rgname/providers/Microsoft.Network/loadbalancers/$lbName/inboundNatRules/$natRule2V4Name"
   

2. Maak een NIC voor elke back-end en voeg een IPv6-configuratie toe:

   $nic1 = az network nic create --name $nic1Name --resource-group $rgname --location $location --private-ip-address-version "IPv4" --subnet $subnet1Id --lb-address-pools $backendAddressPoolV4Id --lb-inbound-nat-rules $natRule1V4Id
   $nic1IPv6 = az network nic ip-config create --resource-group $rgname --name "IPv6IPConfig" --private-ip-address-version "IPv6" --lb-address-pools $backendAddressPoolV6Id --nic-name $nic1Name
   
   $nic2 = az network nic create --name $nic2Name --resource-group $rgname --location $location --private-ip-address-version "IPv4" --subnet $subnet2Id --lb-address-pools $backendAddressPoolV4Id --lb-inbound-nat-rules $natRule2V4Id
   $nic2IPv6 = az network nic ip-config create --resource-group $rgname --name "IPv6IPConfig" --private-ip-address-version "IPv6" --lb-address-pools $backendAddressPoolV6Id --nic-name $nic2Name
   

Maak de back-end-VM-resources en koppel elke NIC

Als u VM's wilt maken, moet u een opslagaccount hebben. Voor taakverdeling moeten de VM's lid zijn van een beschikbaarheidsset. Zie Een Virtuele Azure-machine maken met behulp van PowerShell voor meer informatie over het maken van VM's.

1. De PowerShell-variabelen instellen:

   $availabilitySetName = "myIPv4IPv6AvailabilitySet"
   $vm1Name = "myIPv4IPv6VM1"
   $vm2Name = "myIPv4IPv6VM2"
   $nic1Id = "/subscriptions/$subscriptionid/resourceGroups/$rgname/providers/Microsoft.Network/networkInterfaces/$nic1Name"
   $nic2Id = "/subscriptions/$subscriptionid/resourceGroups/$rgname/providers/Microsoft.Network/networkInterfaces/$nic2Name"
   $imageurn = "MicrosoftWindowsServer:WindowsServer:2012-R2-Datacenter:latest"
   $vmUserName = "vmUser"
   $mySecurePassword = "PlainTextPassword*1"
   

   Waarschuwing

   In dit voorbeeld wordt de gebruikersnaam en het wachtwoord voor de VIRTUELE machines in duidelijke tekst gebruikt. Zorg ervoor dat u deze referenties in duidelijke tekst gebruikt. Zie de cmdlet voor een veiligere methode voor het Get-Credential afhandelen van referenties in PowerShell.

2. Maak de beschikbaarheidsset:

   $availabilitySet = az vm availability-set create --name $availabilitySetName --resource-group $rgName --location $location
   

3. Maak de virtuele machines met de bijbehorende NIC's:

   az vm create --resource-group $rgname --name $vm1Name --image $imageurn --admin-username $vmUserName --admin-password $mySecurePassword --nics $nic1Id --location $location --availability-set $availabilitySetName --size "Standard_A1" 
   
   az vm create --resource-group $rgname --name $vm2Name --image $imageurn --admin-username $vmUserName --admin-password $mySecurePassword --nics $nic2Id --location $location --availability-set $availabilitySetName --size "Standard_A1"