Creación de un equilibrador de carga público con IPv6 mediante la CLI de AzureCreate a public load balancer with IPv6 using Azure CLI

Nota

En este artículo se describe una característica de IPv6 introductoria que permite que los equilibradores de carga básicos proporcionen conectividad IPv4 e IPv6.This article describes an introductory IPv6 feature to allow Basic Load Balancers to provide both IPv4 and IPv6 connectivity. Ahora hay disponible conectividad IPv6 completa con IPv6 para redes virtuales de Azure que integra conectividad IPv6 con las redes virtuales e incluye características clave como las reglas de grupo de seguridad de red IPv6, el enrutamiento definido por el usuario IPv6, el equilibrio de carga de IPv6 básico y estándar, y mucho más.Comprehensive IPv6 connectivity is now available with IPv6 for Azure VNETs which integrates IPv6 connectivity with your Virtual Networks and includes key features such as IPv6 Network Security Group rules, IPv6 User-defined routing, IPv6 Basic and Standard load balancing, and more. IPv6 para redes virtuales de Azure es el estándar recomendado para las aplicaciones IPv6 en Azure.IPv6 for Azure VNETs is the recommended standard for IPv6 applications in Azure. Vea IPv6 para la implementación de PowerShell de red virtual de Azure.See IPv6 for Azure VNET Powershell Deployment

Azure Load Balancer es un equilibrador de carga de nivel 4 (TCP y UDP)An Azure load balancer is a Layer-4 (TCP, UDP) load balancer. Los equilibradores de carga proporcionan una alta disponibilidad mediante la distribución del tráfico entrante entre las instancias de servicio correctas de los servicios en la nube o las máquinas virtuales de un conjunto de equilibradores de carga.Load balancers provide high availability by distributing incoming traffic among healthy service instances in cloud services or virtual machines in a load balancer set. Los equilibradores de carga también pueden prestar estos servicios en varios puertos, varias direcciones IP o ambos.Load balancers can also present these services on multiple ports or multiple IP addresses or both.

Escenario de implementación de ejemploExample deployment scenario

En el siguiente diagrama se ilustra la solución de equilibrio de carga que se implementa mediante la plantilla de ejemplo descrita en este artículo.The following diagram illustrates the load balancing solution that's deployed by using the example template described in this article.

Escenario del equilibrador de carga

En este escenario puede crear los siguientes recursos de Azure:In this scenario, you create the following Azure resources:

  • Dos máquinas virtuales (VM)Two virtual machines (VMs)
  • Una interfaz de red virtual para cada máquina virtual con las direcciones IPv4 e IPv6 asignadasA virtual network interface for each VM with both IPv4 and IPv6 addresses assigned
  • Un equilibrador de carga público con una dirección IP pública IPv4 e IPv6A public load balancer with an IPv4 and an IPv6 public IP address
  • Un conjunto de disponibilidad con las dos máquinas virtualesAn availability set that contains the two VMs
  • Dos reglas de equilibrio de carga para asignar las VIP públicas a los puntos de conexión privadosTwo load balancing rules to map the public VIPs to the private endpoints

Implementación de la solución mediante la CLI de AzureDeploy the solution by using Azure CLI

Los pasos siguientes muestran cómo crear un equilibrador de carga público mediante la CLI de Azure.The following steps show how to create a public load balancer by using Azure CLI. Con la interfaz de la línea de comandos, cree y configure cada objeto de forma individual y, después, únalos para crear un recurso.Using CLI, you create and configure each object individually, and then put them together to create a resource.

Para implementar un equilibrador de carga, cree y configure los objetos siguientes:To deploy a load balancer, create and configure the following objects:

  • Configuración de direcciones IP de front-end: contiene direcciones IP públicas para el tráfico de red entrante.Front-end IP configuration: Contains public IP addresses for incoming network traffic.
  • Grupo de direcciones de back-end: contiene interfaces de red (NIC) para que las máquinas virtuales reciban tráfico de red del equilibrador de carga.Back-end address pool: Contains network interfaces (NICs) for the virtual machines to receive network traffic from the load balancer.
  • Reglas de equilibrio de carga: contiene reglas que asignan un puerto público en el equilibrador de carga a un puerto del grupo de direcciones de back-end.Load balancing rules: Contains rules that map a public port on the load balancer to a port in the back-end address pool.
  • Reglas NAT de entrada: contiene reglas de traslación de direcciones de red (NAT) que asignan un puerto público en el equilibrador de carga a un puerto de una máquina virtual específica en el grupo de direcciones de back-end.Inbound NAT rules: Contains network address translation (NAT) rules that map a public port on the load balancer to a port for a specific virtual machine in the back-end address pool.
  • Sondeos: contiene los sondeos de estado que se usan para comprobar la disponibilidad de las instancias de las máquinas virtuales del grupo de direcciones de back-end.Probes: Contains health probes that are used to check the availability of virtual machine instances in the back-end address pool.

Configuración de la CLI de AzureSet up Azure CLI

En este ejemplo, puede ejecutar las herramientas de la CLI de Azure en una ventana de comandos de PowerShell.In this example, you run the Azure CLI tools in a PowerShell command window. Para mejorar la legibilidad y la reutilización, puede usar las funcionalidades de scripting de PowerShell en lugar de los cmdlets de Azure PowerShell.To improve readability and reuse, you use PowerShell's scripting capabilities, not the Azure PowerShell cmdlets.

  1. Instale y configure la CLI de Azure siguiendo los pasos que se describen en el artículo vinculado e inicie sesión en la cuenta de Azure.Install and Configure the Azure CLI by following the steps in the linked article and sign in to your Azure account.

  2. Configure variables de PowerShell para usarlas con los comandos de la CLI de Azure:Set up PowerShell variables for use with the Azure CLI commands:

    $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"
    

Creación de un grupo de recursos, un equilibrador de carga, una red virtual y subredesCreate a resource group, a load balancer, a virtual network, and subnets

  1. Cree un grupo de recursos:Create a resource group:

    az group create --name $rgName --location $location
    
  2. Cree un equilibrador de carga:Create a load balancer:

    $lb = az network lb create --resource-group $rgname --location $location --name $lbName
    
  3. Cree una red virtual:Create a virtual network:

    $vnet = az network vnet create  --resource-group $rgname --name $vnetName --location $location --address-prefixes $vnetPrefix
    
  4. En esta red virtual, cree dos subredes:In this virtual network, create two subnets:

    $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
    

Creación de direcciones IP públicas para el grupo de servidores front-endCreate public IP addresses for the front-end pool

  1. Configure las variables de PowerShell:Set up the PowerShell variables:

    $publicIpv4Name = "myIPv4Vip"
    $publicIpv6Name = "myIPv6Vip"
    
  2. Cree una dirección IP pública para el grupo de servidores front-end:Create a public IP address for the front-end IP pool:

    $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
    

    Importante

    El equilibrador de carga usa la etiqueta de dominio de la dirección IP pública como nombre de dominio completo (FQDN).The load balancer uses the domain label of the public IP as its fully qualified domain name (FQDN). Esto representa un cambio en la implementación clásica, que usa el nombre del servicio en la nube como el FQDN del equilibrador de carga.This a change from classic deployment, which uses the cloud service name as the load balancer FQDN.

    En este ejemplo, el FQDN es contoso09152016.southcentralus.cloudapp.azure.com.In this example, the FQDN is contoso09152016.southcentralus.cloudapp.azure.com.

Creación de grupos de servidores front-end y back-endCreate front-end and back-end pools

En esta sección, puede crear los siguientes grupos de direcciones IP:In this section, you create the following IP pools:

  • El grupo de direcciones IP de front-end que recibe el tráfico de red entrante en el equilibrador de carga.The front-end IP pool that receives the incoming network traffic on the load balancer.
  • El grupo de direcciones IP de back-end al que el grupo de front-end envía el tráfico de red de carga equilibrada.The back-end IP pool where the front-end pool sends the load-balanced network traffic.
  1. Configure las variables de PowerShell:Set up the PowerShell variables:

    $frontendV4Name = "FrontendVipIPv4"
    $frontendV6Name = "FrontendVipIPv6"
    $backendAddressPoolV4Name = "BackendPoolIPv4"
    $backendAddressPoolV6Name = "BackendPoolIPv6"
    
  2. Cree un grupo de direcciones IP de front-end y asócielo con la dirección IP pública que creó en el paso anterior y el equilibrador de carga.Create a front-end IP pool, and associate it with the public IP that you created in the previous step and the load balancer.

    $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
    

Creación del sondeo, las reglas NAT y las reglas del equilibrador de cargaCreate the probe, NAT rules, and load balancer rules

En este ejemplo se crean los siguientes elementos:This example creates the following items:

  • Una regla de sondeo para comprobar la conectividad con el puerto TCP 80.A probe rule to check for connectivity to TCP port 80.
  • Una regla NAT para trasladar todo el tráfico entrante del puerto 3389 al puerto 3389 para RDP.*A NAT rule to translate all incoming traffic on port 3389 to port 3389 for RDP.*
  • Una regla NAT para trasladar todo el tráfico entrante del puerto 3391 al puerto 3389 para el protocolo de escritorio remoto (RDP).*A NAT rule to translate all incoming traffic on port 3391 to port 3389 for remote desktop protocol (RDP).*
  • Una regla de equilibrador de carga para equilibrar todo el tráfico entrante del puerto 80 al puerto 80 en las direcciones del grupo de back-end.A load balancer rule to balance all incoming traffic on port 80 to port 80 on the addresses in the back-end pool.

* Las reglas NAT están asociadas a una instancia de máquina virtual específica detrás del equilibrador de carga.* NAT rules are associated with a specific virtual-machine instance behind the load balancer. El tráfico de red que llega al puerto 3389 se envía a la máquina virtual específica y al puerto que está asociado a la regla NAT.The network traffic that arrives on port 3389 is sent to the specific virtual machine and port that's associated with the NAT rule. Debe especificar un protocolo (UDP o TCP) para una regla NAT.You must specify a protocol (UDP or TCP) for a NAT rule. No puede asignar ambos protocolos al mismo puerto.You cannot assign both protocols to the same port.

  1. Configure las variables de PowerShell:Set up the PowerShell variables:

    $probeV4V6Name = "ProbeForIPv4AndIPv6"
    $natRule1V4Name = "NatRule-For-Rdp-VM1"
    $natRule2V4Name = "NatRule-For-Rdp-VM2"
    $lbRule1V4Name = "LBRuleForIPv4-Port80"
    $lbRule1V6Name = "LBRuleForIPv6-Port80"
    
  2. Cree el sondeo.Create the probe.

    En el siguiente ejemplo se crea un sondeo TCP que comprueba la conectividad con el puerto TCP 80 de back-end cada 15 segundos.The following example creates a TCP probe that checks for connectivity to the back-end TCP port 80 every 15 seconds. Este marcará el recurso de back-end como no disponible si se producen dos errores consecutivos.After two consecutive failures, it marks the back-end resource as unavailable.

    $probeV4V6 = az network lb probe create --resource-group $rgname --name $probeV4V6Name --protocol tcp --port 80 --interval 15 --threshold 2 --lb-name $lbName
    
  3. Cree reglas NAT de entrada que permitan conexiones RDP a los recursos de back-end:Create inbound NAT rules that allow RDP connections to the back-end resources:

    $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. Cree reglas de equilibrador de carga que envíen tráfico a distintos puertos de back-end dependiendo de qué front-end recibió la solicitud.Create load balancer rules that send traffic to different back-end ports, depending on the front end that received the request.

    $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. Compruebe la configuración:Check your settings:

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

    Resultado esperado:Expected output:

    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
    

Creación de tarjetas NICCreate NICs

Cree tarjetas NIC y asócielas a reglas NAT, reglas de equilibrador de carga y sondeos.Create NICs and associate them with NAT rules, load balancer rules, and probes.

  1. Configure las variables de PowerShell:Set up the PowerShell variables:

    $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. Cree una NIC para cada back-end y agregue una configuración de IPv6:Create a NIC for each back end, and add an IPv6 configuration:

    $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
    

Creación de los recursos de la máquina virtual de back-end y conexión de cada NICCreate the back-end VM resources, and attach each NIC

Para crear máquinas virtuales, debe tener una cuenta de almacenamiento.To create VMs, you must have a storage account. Para el equilibrio de carga, es necesario que las máquinas virtuales formen parte de un conjunto de disponibilidad.For load balancing, the VMs need to be members of an availability set. Para más información sobre cómo crear máquinas virtuales, consulte Creación de una máquina virtual de Azure con PowerShell.For more information about creating VMs, see Create an Azure VM by using PowerShell.

  1. Configure las variables de PowerShell:Set up the PowerShell variables:

    $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"
    

    Advertencia

    En este ejemplo se usa el nombre de usuario y la contraseña de las máquinas virtuales en texto no cifrado.This example uses the username and password for the VMs in cleartext. Tome las precauciones necesarias cuando use estas credenciales en texto no cifrado.Take appropriate care when you use these credentials in cleartext. Para ver un método más seguro de administración de credenciales en PowerShell, consulte el cmdlet Get-Credential.For a more secure method of handling credentials in PowerShell, see the Get-Credential cmdlet.

  2. Cree el conjunto de disponibilidad:Create the availability set:

    $availabilitySet = az vm availability-set create --name $availabilitySetName --resource-group $rgName --location $location
    
  3. Cree las máquinas virtuales con las NIC asociadas:Create the virtual machines with the associated NICs:

    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"