Configura un balanceador de cargas de red de transferencia interna con backends de grupos de instancias de VM para varios protocolos

En esta página, se proporcionan instrucciones a fin de crear balanceadores de cargas de red internos para balancear las cargas del tráfico de varios protocolos.

Si deseas configurar un balanceador de cargas para varios protocolos, incluidos TCP y UDP, debes crear una regla de reenvío con el protocolo configurado como L3_DEFAULT. Esta regla de reenvío apunta a un servicio de backend con un protocolo configurado como UNSPECIFIED.

En este ejemplo, usamos un balanceador de cargas de red de transferencia interna para distribuir el tráfico entre una VM de backend en la región us-west1. El balanceador de cargas tiene una regla de reenvío con el protocolo L3_DEFAULT para controlar TCP, UDP, ICMP, ICMPv6, SCTP, ESP, AH y GRE.

Balanceo de cargas de tráfico IPv4 e IPv6 basado en los protocolos con servicios de backend para administrar la distribución de conexiones a un solo grupo de instancias zonal.
Balanceador de cargas de red de transferencia interna para varios protocolos (haz clic para ampliar).

Antes de comenzar

Permisos

Para obtener los permisos que necesitas a fin de completar esta guía, pídele a tu administrador que te otorgue los siguientes roles de IAM en el proyecto:

Si quieres obtener más información para otorgar roles, consulta Administra el acceso.

También puedes obtener los permisos necesarios mediante roles personalizados o cualquier otro rol predefinido.

Configura el balanceador de cargas para el tráfico L3_DEFAULT

En los pasos de esta sección, se describen las siguientes configuraciones:

  • Un ejemplo en el que se usa una red de VPC en modo personalizado con el nombre lb-network. Puedes usar una red de modo automático si solo deseas controlar el tráfico IPv4. Sin embargo, el tráfico IPv6 requiere una subred de modo personalizado.
  • Una subred de pila única (stack-type configurada en IPv4), que es necesaria para el tráfico IPv4. Cuando creas una subred de pila única en una red de VPC de modo personalizado, eliges un rango de subred IPv4 para la subred. Para el tráfico IPv6 requerimos una subred de doble pila (stack-type configurada en IPv4_IPv6). Cuando creas una subred de doble pila en una red de VPC de modo personalizado, eliges un tipo de acceso IPv6 para la subred. Para este ejemplo, establecemos el parámetro ipv6-access-type de la subred en INTERNAL. Esto significa que a las VMs nuevas de esta subred se les pueden asignar direcciones IPv4 y IPv6 internas.
  • Reglas de firewall que permiten conexiones entrantes a VMs de backend.
  • El grupo de instancias de backend y los componentes del balanceador de cargas usados para este ejemplo se encuentran en la región y la subred que se incluyen a continuación:
    • Región: us-west1
    • Subred: lb-subnet, con el rango de direcciones IPv4 principal 10.1.2.0/24. Aunque elijas qué rango de direcciones IPv4 se configurará en la subred, el rango de direcciones IPv6 se asigna automáticamente. Google proporciona un bloque CIDR IPv6 de tamaño fijo (/64).
  • Una VM de backend en un grupo de instancias administrado en la zona us-west1-a.
  • Una VM de cliente para probar conexiones a los backends.
  • Un balanceador de cargas de red interno de transferencia con los siguientes componentes:
    • Una verificación de estado del servicio de backend.
    • Un servicio de backend en la región us-west1 con el protocolo configurado en UNSPECIFIED para administrar la distribución de conexiones en el grupo de instancias zonal.
    • Una regla de reenvío con el protocolo configurado en L3_DEFAULT y el puerto configurado en ALL.

Configura una red, una región y una subred

Para configurar subredes con rangos de IPv6 internos, habilita un rango de IPv6 interno de ULA de la red de nube privada virtual (VPC). Los rangos de subredes IPv6 internas se asignan a partir de este rango. Para crear la red y subred de ejemplo, sigue estos pasos:

Consola

Para admitir el tráfico IPv4 e IPv6, sigue estos pasos:

  1. En la consola de Google Cloud, ve a la página Redes de VPC.

    Ir a las redes de VPC

  2. Haz clic en Crear red de VPC.

  3. En Nombre, ingresa lb-network.

  4. Si deseas configurar rangos de direcciones IPv6 internos en subredes de esta red, completa estos pasos:

    1. En Rango de IPv6 interno de ULA de la red de VPC, selecciona Habilitado.
    2. En Asignar rango de IPv6 interno, selecciona Automáticamente o Manualmente.

  5. En Modo de creación de subred, selecciona Personalizado.

  6. En la sección Subred nueva, especifica los siguientes parámetros de configuración para una subred:

    1. En Nombre, ingresa lb-subnet.
    2. En Región, selecciona us-west1.
    3. Para crear una subred de pila doble, en Tipo de pila de IP, selecciona IPv4 e IPv6 (pila doble).
    4. En el Rango de IPv4, ingresa 10.1.2.0/24.
    5. En Tipo de acceso IPv6, selecciona Interno.

  7. Haz clic en Listo.

  8. Haz clic en Crear.

Para que sea compatible con el tráfico IPv4, sigue estos pasos:

  1. En la consola de Google Cloud, ve a la página Redes de VPC.

    Ir a las redes de VPC

  2. Haz clic en Crear red de VPC.

  3. En Nombre, ingresa lb-network.

  4. En la sección Subredes:

    • Establece Modo de creación de subred en Personalizado.
    • En la sección Nueva subred, ingresa la siguiente información:
      • Nombre: lb-subnet
      • Región: us-west1
      • Tipo de pila IP: IPv4 (pila única)
      • Rangos de direcciones IP: 10.1.2.0/24
    • Haz clic en Listo.

  5. Haz clic en Crear.

gcloud

Para el tráfico IPv4 e IPv6, usa los siguientes comandos:

  1. Para crear una nueva red de VPC en modo personalizado, ejecuta el comando gcloud compute networks create.

    Para configurar los rangos de IPv6 internos en cualquier subred de esta red, usa la marca --enable-ula-internal-ipv6. Esta opción asigna un prefijo ULA /48 que pertenece al rango fd20::/20 que usa Google para los rangos de subred IPv6 internos.

    gcloud compute networks create lb-network \
 --subnet-mode=custom \
 --enable-ula-internal-ipv6

  2. Dentro de lb-network, crea una subred para backends en la región us-west1.

    Para crear las subredes, ejecuta el comando gcloud compute networks subnets create:

    gcloud compute networks subnets create lb-subnet \
 --network=lb-network \
 --range=10.1.2.0/24 \
 --region=us-west1 \
 --stack-type=IPV4_IPV6 --ipv6-access-type=INTERNAL

Para el tráfico IPv4, usa el siguiente comando:

  1. Para crear la red de VPC personalizada, usa el comando gcloud compute networks create.

    gcloud compute networks create lb-network --subnet-mode=custom

  2. Si deseas crear la subred para backends en la región us-west1 dentro de la red lb-network, usa el comando gcloud compute networks subnets create.

    gcloud compute networks subnets create lb-subnet \
    --network=lb-network \
    --range=10.1.2.0/24 \
    --region=us-west1

API

Para el tráfico IPv4 e IPv6, usa los siguientes comandos:

  1. Crea una nueva red de VPC en modo personalizado. Realiza una solicitud POST al método networks.insert.

    Para configurar rangos IPv6 internos en cualquier subred de esta red, configura enableUlaInternalIpv6 como true. Esta opción asigna un rango /48 que pertenece al rango fd20::/20 que usa Google para los rangos de subred IPv6 internos.

    POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks
{
  "autoCreateSubnetworks": false,
  "name": "lb-network",
  "mtu": MTU,
  "enableUlaInternalIpv6": true,
}

    Reemplaza lo siguiente:

  2. Realiza una solicitud POST al método subnetworks.insert.

    POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION/subnetworks
{
"ipCidrRange": "10.1.2.0/24",
"network": "lb-network",
"name": "lb-subnet"
"stackType": IPV4_IPV6,
"ipv6AccessType": Internal
}

Para el tráfico IPv4, sigue estos pasos:

  1. Realiza una solicitud POST al método networks.insert. Reemplaza PROJECT_ID por el ID del proyecto de Google Cloud.

    POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks
{
"name": "lb-network",
"autoCreateSubnetworks": false
}

  2. Realiza dos solicitudes POST al método subnetworks.insert.

    POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks
{
"name": "lb-subnet",
"network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
"ipCidrRange": "10.1.2.0/24",
"privateIpGoogleAccess": false
}

Configura reglas de firewall

En este ejemplo, se usan las siguientes reglas de firewall:

  • fw-allow-lb-access: Es una regla de entrada aplicable a todos los destinos en la red de VPC, de modo que se admite el tráfico de las fuentes en los rangos 10.1.2.0/24. Con esta regla, se permite el tráfico entrante desde cualquier cliente ubicado en la subred.

  • fw-allow-lb-access-ipv6: Es una regla de entrada aplicable a todos los destinos en la red de VPC, de modo que se admite el tráfico de las fuentes en el rango de IPv6 configurado en la subred. Con esta regla, se permite el tráfico de IPv6 entrante desde cualquier cliente ubicado en la subred.

  • fw-allow-ssh: Una regla de entrada aplicable a las instancias con balanceo de cargas y que permite la conectividad SSH entrante en el puerto TCP 22 desde cualquier dirección. Puedes elegir un rango de IP de origen más restrictivo para esta regla; por ejemplo, puedes especificar solo los rangos de IP del sistema desde el cual iniciarás sesiones SSH. En este ejemplo se usa la etiqueta de destino allow-ssh para identificar las VM a las que se debe aplicar.

  • fw-allow-health-check: es una regla de entrada aplicable a las instancias con balanceo de cargas, que permite el tráfico de los sistemas de verificación de estado de Google Cloud (130.211.0.0/22 y 35.191.0.0/16). En este ejemplo se usa la etiqueta de destino allow-health-check para identificar las instancias a las que debe aplicarse.

  • fw-allow-health-check-ipv6: Es una regla de entrada aplicable a las instancias con balanceo de cargas, que permite el tráfico de los sistemas de verificación de estado de Google Cloud (2600:2d00:1:b029::/64). En este ejemplo se usa la etiqueta de destino allow-health-check-ipv6 para identificar las instancias a las que debe aplicarse.

Sin estas reglas de firewall, la regla predeterminada de denegación de entrada bloquea el tráfico entrante a las instancias de backend.

Consola

  1. En la consola de Google Cloud, ve a la página Políticas de firewall.

    Ir a Políticas de firewall

  2. Para permitir que el tráfico de TCP, ICMP, UDP y IPv4 llegue al grupo de instancias de backend ig-a, haz lo siguiente:

    • Haz clic en Crear regla de firewall.
    • Nombre: fw-allow-lb-access
    • Red: lb-network
    • Prioridad: 1000
    • Dirección del tráfico: Entrada
    • Acción si hay coincidencia: permitir
    • Objetivos: todas las instancias de la red
    • Filtro de fuente: Rangos de IPv4
    • Rangos de IPv4 de origen: 10.1.2.0/24
    • En Protocolos y puertos, selecciona Protocolos y puertos especificados.
      • Selecciona TCP y, luego, ingresa ALL.
      • Selecciona UDP.
      • Selecciona Otro y, luego, ingresa ICMP.

  3. Haz clic en Crear.

  4. Para permitir conexiones SSH entrantes, haz lo siguiente:

    • Haz clic en Crear regla de firewall.
    • Nombre: fw-allow-ssh
    • Red: lb-network
    • Prioridad: 1000
    • Dirección del tráfico: Entrada
    • Acción si hay coincidencia: permitir
    • Objetivos: etiquetas de destino especificadas
    • Etiquetas de destino: allow-ssh
    • Filtro de fuente: Rangos de IPv4
    • Rangos de IPv4 de origen: 0.0.0.0/0
    • Protocolos y puertos: Elige Protocolos y puertos especificados y, luego, ingresa tcp:22.

  5. Haz clic en Crear.

  6. Para permitir que el tráfico de TCP, ICMP, IPv6 y UDP llegue al grupo de instancias de backend ig-a:

    • Haz clic en Crear regla de firewall.
    • Nombre: fw-allow-lb-access-ipv6
    • Red: lb-network
    • Prioridad: 1000
    • Dirección del tráfico: Entrada
    • Acción si hay coincidencia: permitir
    • Objetivos: todas las instancias de la red
    • Filtro de fuente: Rangos de IPv6
    • Rangos de IPv6 de origen: IPV6_ADDRESS asignados en lb-subnet
    • En Protocolos y puertos, selecciona Protocolos y puertos especificados.
      • Selecciona TCP y, luego, ingresa 0-65535.
      • Selecciona UDP.
      • Selecciona Otro y, para el protocolo ICMPv6, ingresa 58.

  7. Haz clic en Crear.

  8. Para permitir las verificaciones de estado de IPv6 de Google Cloud, sigue estos pasos:

    • Haz clic en Crear regla de firewall.
    • Nombre: fw-allow-health-check-ipv6
    • Red: lb-network
    • Prioridad: 1000
    • Dirección del tráfico: Entrada
    • Acción si hay coincidencia: permitir
    • Objetivos: etiquetas de destino especificadas
    • Etiquetas de destino: allow-health-check-ipv6
    • Filtro de fuente: Rangos de IPv6
    • Rangos de IPv6 de origen: 2600:2d00:1:b029::/64
    • Protocolos y puertos: permitir todos

  9. Haz clic en Crear.

  10. Para permitir las verificaciones de estado de IPv4 de Google Cloud, sigue estos pasos:

    • Haz clic en Crear regla de firewall.
    • Nombre: fw-allow-health-check
    • Red: lb-network
    • Prioridad: 1000
    • Dirección del tráfico: Entrada
    • Acción si hay coincidencia: permitir
    • Objetivos: etiquetas de destino especificadas
    • Etiquetas de destino: allow-health-check
    • Filtro de fuente: Rangos de IPv4
    • Rangos de IPv4 de origen: 130.211.0.0/22 y 35.191.0.0/16
    • Protocolos y puertos: permitir todos

  11. Haz clic en Crear.

gcloud

  1. Para permitir que el tráfico TCP IPv4 llegue al grupo de instancias de backend ig-a, crea la siguiente regla:

    gcloud compute firewall-rules create fw-allow-lb-access \
    --network=lb-network \
    --action=allow \
    --direction=ingress \
    --source-ranges=10.1.2.0/24 \
    --rules=tcp,udp,icmp

  2. Crea la fw-allow-ssh regla de firewall para permitir la conectividad SSH a las VMs mediante la etiqueta de red allow-ssh. Cuando omites source-ranges, Google Cloud interpreta que la regla significa cualquier fuente.

    gcloud compute firewall-rules create fw-allow-ssh \
    --network=lb-network \
    --action=allow \
    --direction=ingress \
    --target-tags=allow-ssh \
    --rules=tcp:22

  3. Para permitir que el tráfico IPv6 llegue al grupo de instancias de backend ig-a, crea la siguiente regla:

    gcloud compute firewall-rules create fw-allow-lb-access-ipv6 \
    --network=lb-network \
    --action=allow \
    --direction=ingress \
    --source-ranges=IPV6_ADDRESS \
    --rules=all

    Reemplaza IPV6_ADDRESS por la dirección IPv6 asignada en lb-subnet.

  4. Crea la regla de firewall fw-allow-health-check para permitir las verificaciones de estado de Google Cloud.

    gcloud compute firewall-rules create fw-allow-health-check \
    --network=lb-network \
    --action=allow \
    --direction=ingress \
    --target-tags=allow-health-check \
    --source-ranges=130.211.0.0/22,35.191.0.0/16 \
    --rules=tcp,udp,icmp

  5. Crea la regla fw-allow-health-check-ipv6 para permitir las verificaciones de estado IPv6 de Google Cloud.

    gcloud compute firewall-rules create fw-allow-health-check-ipv6 \
   --network=lb-network \
   --action=allow \
   --direction=ingress \
   --target-tags=allow-health-check-ipv6 \
   --source-ranges=2600:2d00:1:b029::/64 \
   --rules=tcp,udp,icmp

API

  1. Para crear la regla de firewall fw-allow-lb-access, realiza una solicitud POST al método firewalls.insert. Reemplaza PROJECT_ID por el ID del proyecto de Google Cloud.

    POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/firewalls
{
"name": "fw-allow-lb-access",
"network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
"priority": 1000,
"sourceRanges": [
  "10.1.2.0/24"
],
"allPorts": true,
"allowed": [
  {
    "IPProtocol": "tcp"
  },
  {
    "IPProtocol": "udp"
  },
  {
    "IPProtocol": "icmp"
  }
],
"direction": "INGRESS",
"logConfig": {
  "enable": false
},
"disabled": false
}

  2. Crea la regla de firewall fw-allow-lb-access-ipv6 mediante una solicitud POST al método firewalls.insert.

    POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/firewalls
{
 "name": "fw-allow-lb-access-ipv6",
 "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
 "priority": 1000,
 "sourceRanges": [
   "IPV6_ADDRESS"
 ],
 "allPorts": true,
 "allowed": [
   {
      "IPProtocol": "tcp"
    },
    {
      "IPProtocol": "udp"
    },
    {
      "IPProtocol": "58"
    }
 ],
 "direction": "INGRESS",
 "logConfig": {
    "enable": false
 },
 "disabled": false
}

    Reemplaza IPV6_ADDRESS por la dirección IPv6 asignada en lb-subnet.

  3. Para crear la regla de firewall fw-allow-ssh, realiza una solicitud POST al método firewalls.insert:

    POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/firewalls
{
"name": "fw-allow-ssh",
     "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
"priority": 1000,
"sourceRanges": [
  "0.0.0.0/0"
],
"targetTags": [
  "allow-ssh"
],
"allowed": [
 {
   "IPProtocol": "tcp",
   "ports": [
     "22"
   ]
 }
],
"direction": "INGRESS",
"logConfig": {
 "enable": false
},
"disabled": false
}

  4. Para crear la regla de firewall fw-allow-health-check, realiza una solicitud POST al método firewalls.insert:

    POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/firewalls
{
"name": "fw-allow-health-check",
"network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
"priority": 1000,
"sourceRanges": [
  "130.211.0.0/22",
  "35.191.0.0/16"
],
"targetTags": [
  "allow-health-check"
],
"allowed": [
  {
    "IPProtocol": "tcp"
  },
  {
    "IPProtocol": "udp"
  },
  {
    "IPProtocol": "icmp"
  }
],
"direction": "INGRESS",
"logConfig": {
  "enable": false
},
"disabled": false
}

  5. Crea la regla de firewall fw-allow-health-check-ipv6 mediante una solicitud POST al método firewalls.insert.

    POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/firewalls
{
"name": "fw-allow-health-check-ipv6",
"network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
"priority": 1000,
"sourceRanges": [
  "2600:2d00:1:b029::/64"
],
"targetTags": [
  "allow-health-check-ipv6"
],
"allowed": [
  {
    "IPProtocol": "tcp"
  },
  {
    "IPProtocol": "udp"
  }
],
"direction": "INGRESS",
"logConfig": {
  "enable": false
},
"disabled": false
}

Crea VMs de backend y grupos de instancias

Para esta situación de balanceo de cargas, crearás un grupo de instancias administrado zonal de Compute Engine y, luego, instalarás un servidor web Apache.

Para manejar el tráfico IPv4 e IPv6, configura las VM de backend a fin de que sean de pila doble. Establece stack-type de la VM en IPv4_IPv6. Las VM también heredan la configuración ipv6-access-type (en este ejemplo, INTERNAL) de la subred. Para obtener más detalles sobre los requisitos de IPv6, consulta la descripción general del balanceador de cargas de red de transferencia interno: reglas de reenvío.

Si deseas usar las VM existentes como backends, actualiza las VM para que sean de pila doble mediante el comando gcloud compute instances network-interfaces update.

Las instancias que participan como VMs de backend para los balanceadores de cargas de red de transferencia internos deben ejecutar el entorno invitado de Linux o el entorno invitado de Windows adecuados, o algún otro proceso que proporcione una funcionalidad equivalente.

Para simplificar el instructivo, las VMs de backend ejecutan Debian GNU/Linux 10.

Crea el grupo de instancias

Consola

Para admitir el tráfico IPv4 e IPv6, sigue estos pasos:

  1. Crear una plantilla de instancias En la consola de Google Cloud, ve a la página Plantillas de instancia.

    Ir a Plantillas de instancia

    1. Haga clic en Crear plantilla de instancias.
    2. En Nombre, ingresa vm-a1.
    3. Asegúrate de que el disco de arranque esté configurado como una imagen de Debian, como Debian GNU/Linux 10 (buster). En estas instrucciones, se usan comandos que solo están disponibles en Debian, como apt-get.
    4. Expande la sección Opciones avanzadas.

    5. Expande la sección Administración y, luego, copia la siguiente secuencia de comandos en el campo Secuencia de comandos de inicio. La secuencia de comandos de inicio también configura el servidor Apache para que escuche en el puerto 8080 en lugar de en el puerto 80.

      #! /bin/bash
apt-get update
apt-get install apache2 -y
a2ensite default-ssl
a2enmod ssl
vm_hostname="$(curl -H "Metadata-Flavor:Google" \
http://metadata.google.internal/computeMetadata/v1/instance/name)"
echo "Page served from: $vm_hostname" | \
tee /var/www/html/index.html
sed -ire 's/^Listen 80$/Listen 8080/g' /etc/apache2/ports.conf
systemctl restart apache2

    6. Expande la sección Herramientas de redes y, luego, especifica lo siguiente:

      1. En Etiquetas de red, agrega allow-ssh y allow-health-check-ipv6.
      2. En Interfaces de red, haz clic en la interfaz predeterminada y configura los siguientes campos:
        • Red: lb-network
        • Subred: lb-subnet
        • Tipo de pila IP: IPv4 e IPv6 (pila doble)

    7. Haz clic en Crear.

Para que sea compatible con el tráfico IPv4, sigue estos pasos:

  1. Crear una plantilla de instancias En la consola de Google Cloud, ve a la página Plantillas de instancia.

    Ir a Plantillas de instancia

  2. Haga clic en Crear plantilla de instancias.

    1. En Nombre, ingresa vm-a1.
    2. Asegúrate de que el disco de arranque esté configurado como una imagen de Debian, como Debian GNU/Linux 10 (buster). En estas instrucciones, se usan comandos que solo están disponibles en Debian, como apt-get.
    3. Expande la sección Opciones avanzadas.

    4. Expande la sección Administración y, luego, copia la siguiente secuencia de comandos en el campo Secuencia de comandos de inicio. La secuencia de comandos de inicio también configura el servidor Apache para que escuche en el puerto 8080 en lugar de en el puerto 80.

      #! /bin/bash
apt-get update
apt-get install apache2 -y
a2ensite default-ssl
a2enmod ssl
vm_hostname="$(curl -H "Metadata-Flavor:Google" \
http://metadata.google.internal/computeMetadata/v1/instance/name)"
echo "Page served from: $vm_hostname" | \
tee /var/www/html/index.html
sed -ire 's/^Listen 80$/Listen 8080/g' /etc/apache2/ports.conf
systemctl restart apache2

    5. Expande la sección Herramientas de redes y, luego, especifica lo siguiente:

      1. En Etiquetas de red, agrega allow-ssh y allow-health-check.
      2. En Interfaces de red, haz clic en la interfaz predeterminada y configura los siguientes campos:
        • Red: lb-network
        • Subred: lb-subnet
        • Tipo de pila IP: IPv4 (pila única)

    6. Haz clic en Crear.

  3. Cree un grupo de instancias administrado. Ve a la página Grupos de instancias en la consola de Google Cloud.

    Ir a Grupos de instancias

    1. Haga clic en Crear grupo de instancias.
    2. Selecciona Nuevo grupo de instancias administrado (sin estado). Para obtener más información, consulta MIG con o sin estado.
    3. En Nombre, ingresa ig-a.
    4. En Ubicación, selecciona Zona única.
    5. En Región, selecciona us-west1.
    6. En Zona, selecciona us-west1-a.
    7. En Plantilla de instancias, selecciona vm-a1.

    8. Especifica la cantidad de instancias que quieres crear en el grupo.

      En este ejemplo, especifica las siguientes opciones en Ajuste de escala automático:

      • En Modo de ajuste de escala automático, selecciona Off:do not autoscale.
      • En Cantidad máxima de instancias, ingresa 2.

    9. Haz clic en Crear.

gcloud

En las instrucciones de gcloud que se incluyen en esta guía, se supone que usas Cloud Shell o algún otro entorno con bash instalado.

  1. Crea una plantilla de instancias de VM con el servidor de HTTP con el comando gcloud compute instance-templates create.

    La secuencia de comandos de inicio también configura el servidor Apache para que escuche en el puerto 8080 en lugar de en el puerto 80.

    Para controlar el tráfico IPv4 e IPv6, usa el siguiente comando.

    gcloud compute instance-templates create vm-a1 \
    --region=us-west1 \
    --network=lb-network \
    --subnet=lb-subnet \
    --ipv6-network-tier=PREMIUM \
    --stack-type=IPv4_IPv6 \
    --tags=allow-ssh \
    --image-family=debian-10 \
    --image-project=debian-cloud \
    --metadata=startup-script='#! /bin/bash
      apt-get update
      apt-get install apache2 -y
      a2ensite default-ssl
      a2enmod ssl
      vm_hostname="$(curl -H "Metadata-Flavor:Google" \
      http://metadata.google.internal/computeMetadata/v1/instance/name)"
      echo "Page served from: $vm_hostname" | \
      tee /var/www/html/index.html
      sed -ire "s/^Listen 80$/Listen 8080/g" /etc/apache2/ports.conf
      systemctl restart apache2'

    O bien, si deseas controlar solo el tráfico IPv4, usa el siguiente comando.

    gcloud compute instance-templates create vm-a1 \
    --region=us-west1 \
    --network=lb-network \
    --subnet=lb-subnet \
    --tags=allow-ssh \
    --image-family=debian-10 \
    --image-project=debian-cloud \
    --metadata=startup-script='#! /bin/bash
      apt-get update
      apt-get install apache2 -y
      a2ensite default-ssl
      a2enmod ssl
      vm_hostname="$(curl -H "Metadata-Flavor:Google" \
      http://metadata.google.internal/computeMetadata/v1/instance/name)"
      echo "Page served from: $vm_hostname" | \
      tee /var/www/html/index.html
      sed -ire "s/^Listen 80$/Listen 8080/g" /etc/apache2/ports.conf
      systemctl restart apache2'

  2. Crea un grupo de instancias administrado en la zona con el comando gcloud compute instance-groups managed create.

    gcloud compute instance-groups managed create ig-a \
    --zone us-west1-a \
    --size 2 \
    --template vm-a1

api

Para controlar el tráfico IPv4 e IPv6, sigue estos pasos:

  1. Crea una VM mediante la realización de solicitudes POST al método instances.insert:

    POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances
{
"name": "vm-a1",
"tags": {
 "items": [
   "allow-health-check-ipv6",
   "allow-ssh"
 ]
},
"machineType": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/machineTypes/e2-standard-2",
"canIpForward": false,
"networkInterfaces": [
 {
   "stackType": "IPV4_IPV6",
   "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
   "subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet",
   "accessConfigs": [
     {
       "type": "ONE_TO_ONE_NAT",
       "name": "external-nat",
       "networkTier": "PREMIUM"
     }
   ]
 }
],
"disks": [
 {
   "type": "PERSISTENT",
   "boot": true,
   "mode": "READ_WRITE",
   "autoDelete": true,
   "deviceName": "vm-a1",
   "initializeParams": {
     "sourceImage": "projects/debian-cloud/global/images/DEBIAN_IMAGE_NAME",
     "diskType": "projects/PROJECT_ID/zones/ZONE/diskTypes/pd-standard",
     "diskSizeGb": "10"
   }
 }
],
"metadata": {
 "items": [
   {
     "key": "startup-script",
     "value": "#! /bin/bash\napt-get update\napt-get install apache2 -y\na2ensite default-ssl\na2enmod ssl\nvm_hostname="$(curl -H "Metadata-Flavor:Google" \\\nhttp://metadata.google.internal/computeMetadata/v1/instance/name)"\necho "Page served from: $vm_hostname" | \\\ntee /var/www/html/index.html\nsed -ire "s/^Listen 80$/Listen 8080/g" /etc/\\napache2/ports.conf\nsystemctl restart apache2"
   }
 ]
},
"scheduling": {
 "preemptible": false
},
"deletionProtection": false
}

Para controlar el tráfico IPv4, sigue estos pasos:

  1. Crea una VM mediante la realización de solicitudes POST al método instances.insert:

    POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances
{
"name": "vm-a1",
"tags": {
 "items": [
   "allow-health-check",
   "allow-ssh"
 ]
},
"machineType": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/machineTypes/e2-standard-2",
"canIpForward": false,
"networkInterfaces": [
 {
   "stackType": "IPV4",
   "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
   "subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet",
   "accessConfigs": [
     {
       "type": "ONE_TO_ONE_NAT",
       "name": "external-nat",
       "networkTier": "PREMIUM"
     }
   ]
 }
],
"disks": [
 {
   "type": "PERSISTENT",
   "boot": true,
   "mode": "READ_WRITE",
   "autoDelete": true,
   "deviceName": "vm-a1",
   "initializeParams": {
     "sourceImage": "projects/debian-cloud/global/images/DEBIAN_IMAGE_NAME",
     "diskType": "projects/PROJECT_ID/zones/ZONE/diskTypes/pd-standard",
     "diskSizeGb": "10"
   }
 }
],
"metadata": {
 "items": [
   {
     "key": "startup-script",
     "value": "#! /bin/bash\napt-get update\napt-get install apache2 -y\na2ensite default-ssl\na2enmod ssl\nvm_hostname="$(curl -H "Metadata-Flavor:Google" \\\nhttp://metadata.google.internal/computeMetadata/v1/instance/name)"\necho "Page served from: $vm_hostname" | \\\ntee /var/www/html/index.html\nsed -ire "s/^Listen 80$/Listen 8080/g" /etc/\\napache2/ports.conf\nsystemctl restart apache2"
   }
 ]
},
"scheduling": {
 "preemptible": false
},
"deletionProtection": false
}

  2. Crea un grupo de instancias mediante una solicitud POST al método instanceGroups.insert.

    POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instanceGroups

{
"name": "ig-a",
"network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
"subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet"
}

  3. Agrega instancias a cada grupo de instancias mediante una solicitud POST al método instanceGroups.addInstances.

    POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instanceGroups/ig-a/addInstances

{
"instances": [
{
 "instance": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instances/vm-a1"
}
]
}

Crear una VM de cliente

En este ejemplo se crea una VM de cliente en la misma región en la que están las VM de backend (servidor). El cliente se usa para validar la configuración del balanceador de cargas y demostrar el comportamiento esperado, como se describe en la sección de pruebas.

Para el tráfico IPv4 e IPv6, haz lo siguiente:

Consola

  1. En la consola de Google Cloud, ve a la página Instancias de VM.

    Ir a Instancias de VM

  2. Haga clic en Crear instancia.

  3. Configura el campo Nombre como vm-client-ipv6.

  4. En Zona establece us-west1-a.

  5. Expande la sección Opciones avanzadas y, a continuación, realiza los siguientes cambios:

    • Expande Herramientas de redes y, luego, agrega allow-ssh a Etiquetas de red.
    • En Interfaces de red, haz clic en Editar, realiza los siguientes cambios y, luego, haz clic en Listo:
      • Red: lb-network
      • Subred: lb-subnet
      • Tipo de pila IP: IPv4 e IPv6 (pila doble)
      • IP interna principal: efímera (automática)
      • IP externa: Efímera

  6. Haz clic en Crear.

gcloud

La VM de cliente puede estar en cualquier zona de la misma región que el balanceador de cargas y puede usar cualquier subred en esa región. En este ejemplo el cliente se encuentra en la zona us-west1-a y usa la misma subred que las VM de backend.

gcloud compute instances create vm-client-ipv6 \
    --zone=us-west1-a \
    --image-family=debian-10 \
    --image-project=debian-cloud \
    --stack-type=IPV4_IPV6 \
    --tags=allow-ssh \
    --subnet=lb-subnet

api

Realiza una solicitud POST al método instances.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instances

{
 "name": "vm-client-ipv6",
 "tags": {
   "items": [
     "allow-ssh"
   ]
 },
 "machineType": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/machineTypes/e2-standard-2",
 "canIpForward": false,
 "networkInterfaces": [
   {
     "stackType": "IPV4_IPV6",
     "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
     "subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet",
     "accessConfigs": [
       {
         "type": "ONE_TO_ONE_NAT",
         "name": "external-nat",
         "networkTier": "PREMIUM"
       }
     ]
   }
 ],
 "disks": [
   {
     "type": "PERSISTENT",
     "boot": true,
     "mode": "READ_WRITE",
     "autoDelete": true,
     "deviceName": "vm-client",
     "initializeParams": {
       "sourceImage": "projects/debian-cloud/global/images/debian-image-name",
       "diskType": "projects/PROJECT_ID/zones/us-west1-a/diskTypes/pd-standard",
       "diskSizeGb": "10"
     }
   }
 ],
 "scheduling": {
   "preemptible": false
 },
 "deletionProtection": false
}

Para el tráfico IPv4, haz lo siguiente:

Consola

  1. En la consola de Google Cloud, ve a la página Instancias de VM.

    Ir a Instancias de VM

  2. Haz clic en Crear instancia.

  3. En Nombre, ingresa vm-client.

  4. En Zona, ingresa us-west1-a.

  5. Expande la sección Opciones avanzadas.

  6. Expande Herramientas de redes y, a continuación, configura los siguientes campos:

    1. En Etiquetas de red, ingresa allow-ssh.
    2. En Interfaces de red, selecciona lo siguiente:
      • Red: lb-network
      • Subred: lb-subnet

  7. Haz clic en Crear.

gcloud

La VM de cliente puede estar en cualquier zona de la misma región que el balanceador de cargas y puede usar cualquier subred en esa región. En este ejemplo el cliente se encuentra en la zona us-west1-a y usa la misma subred que las VM de backend.

gcloud compute instances create vm-client \
    --zone=us-west1-a \
    --image-family=debian-10 \
    --image-project=debian-cloud \
    --tags=allow-ssh \
    --subnet=lb-subnet

API

Realiza una solicitud POST al método instances.insert. Reemplaza PROJECT_ID por el ID del proyecto de Google Cloud.

 POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instances
 {
    "name": "vm-client",
    "tags": {
      "items": [
        "allow-ssh"
      ]
  },
    "machineType": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/machineTypes/e2-standard-2",
    "canIpForward": false,
    "networkInterfaces": [
      {
        "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
        "subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet",
        "accessConfigs": [
          {
            "type": "ONE_TO_ONE_NAT",
            "name": "external-nat",
            "networkTier": "PREMIUM"
          }
        ]
      }
    ],
    "disks": [
      {
        "type": "PERSISTENT",
        "boot": true,
        "mode": "READ_WRITE",
        "autoDelete": true,
        "deviceName": "vm-client",
        "initializeParams": {
          "sourceImage": "projects/debian-cloud/global/images/debian-image-name",
          "diskType": "projects/PROJECT_ID/zones/us-west1-a/diskTypes/pd-standard",
          "diskSizeGb": "10"
        }
      }
    ],
    "scheduling": {
      "preemptible": false
     },
    "deletionProtection": false
  }

Configura los componentes del balanceador de cargas

Crea un balanceador de cargas para varios protocolos

gcloud

  1. Crea una verificación de estado HTTP para el puerto 80. Esta verificación de estado se usa para comprobar el estado de los backends en el grupo de instancias ig-a.

    gcloud compute health-checks create http hc-http-80 \
    --region=us-west1 \
    --port=80

  2. Crea un servicio de backend con el protocolo configurado como UNSPECIFIED:

    gcloud compute backend-services create be-ilb-l3-default \
    --load-balancing-scheme=internal \
    --protocol=UNSPECIFIED \
    --region=us-west1 \
    --health-checks=hc-http-80 \
    --health-checks-region=us-west1

  3. Agrega el grupo de instancias al servicio de backend:

    gcloud compute backend-services add-backend be-ilb-l3-default \
    --region=us-west1 \
    --instance-group=ig-a \
    --instance-group-zone=us-west1-a

  4. Para el tráfico IPv6: Crea una regla de reenvío con el protocolo configurado como L3_DEFAULT a fin de controlar todo el tráfico de protocolo IPv6 compatible. Todos los puertos se deben configurar con reglas de reenvío L3_DEFAULT.

    gcloud compute forwarding-rules create fr-ilb-ipv6 \
   --region=us-west1 \
   --load-balancing-scheme=internal \
   --subnet=lb-subnet \
   --ip-protocol=L3_DEFAULT \
   --ports=ALL \
   --backend-service=be-ilb-l3-default \
   --backend-service-region=us-west1 \
   --ip-version=IPV6

  5. Para el tráfico IPv4: Crea una regla de reenvío con el protocolo configurado como L3_DEFAULT para controlar todo el tráfico de protocolo IPv4 compatible. Todos los puertos se deben configurar con reglas de reenvío L3_DEFAULT. Usa 10.1.2.99 como la dirección IP interna.

    gcloud compute forwarding-rules create fr-ilb-l3-default \
   --region=us-west1 \
   --load-balancing-scheme=internal \
   --network=lb-network \
   --subnet=lb-subnet \
   --address=10.1.2.99 \
   --ip-protocol=L3_DEFAULT \
   --ports=ALL \
   --backend-service=be-ilb-l3-default \
   --backend-service-region=us-west1

API

  1. Para crear la verificación de estado, realiza una solicitud POST al método regionHealthChecks.insert. Reemplaza PROJECT_ID por el ID del proyecto de Google Cloud.

    POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/regionHealthChecks

{
"name": "hc-http-80",
"type": "HTTP",
"httpHealthCheck": {
 "port": 80
}
}

  2. Crea el servicio de backend regional mediante una solicitud POST al método regionBackendServices.insert.

    POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/backendServices

{
"name": "be-ilb-l3-default",
"backends": [
 {
   "group": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instanceGroups/ig-a",
   "balancingMode": "CONNECTION"
 }
],
"healthChecks": [
 "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/healthChecks/hc-http-80"
],
"loadBalancingScheme": "INTERNAL",
"protocol": "UNSPECIFIED",
"connectionDraining": {
 "drainingTimeoutSec": 0
}
}

  3. Para el tráfico IPv6: Crea la regla de reenvío mediante una solicitud POST al método forwardingRules.insert.

    POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/forwardingRules

{
"name": "fr-ilb-ipv6",
"IPProtocol": "L3_DEFAULT",
"allPorts": true,
"loadBalancingScheme": "INTERNAL",
"subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet",
"backendService": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/backendServices/be-ilb-l3-default",
"ipVersion": "IPV6",
"networkTier": "PREMIUM"
}

  4. Para el tráfico IPv4: Crea la regla de reenvío mediante una solicitud POST al método forwardingRules.insert:

    POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/forwardingRules

{
"name": "fr-ilb-l3-default",
"IPAddress": "10.1.2.99",
"IPProtocol": "L3_DEFAULT",
"allPorts": true,
"loadBalancingScheme": "INTERNAL",
"subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet",
"network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
"backendService": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/backendServices/be-ilb-l3-default",
"networkTier": "PREMIUM"
}

Prueba el balanceador de cargas

En las siguientes pruebas, se muestra cómo validar la configuración del balanceador de cargas y conocer su comportamiento esperado.

Prueba la conexión desde la VM del cliente

En esta prueba, se contacta al balanceador de cargas desde una VM de cliente diferente, es decir, no desde una VM de backend del balanceador de cargas.

gcloud:IPv6

  1. Conéctate a la instancia de VM de cliente.

    gcloud compute ssh vm-client-ipv6 --zone=us-west1-a

  2. Describe la regla de reenvío de IPv6 fr-ilb-ipv6. Ten en cuenta la IPV6_ADDRESS en la descripción.

    gcloud compute forwarding-rules describe fr-ilb-ipv6 --region=us-west1

  3. Desde los clientes con conectividad IPv6, ejecuta el siguiente comando: Reemplaza IPV6_ADDRESS por la dirección IPv6 efímera en la regla de reenvío fr-ilb-ipv6.

    curl -m 10 -s http://IPV6_ADDRESS:80

    Por ejemplo, si la dirección IPv6 asignada es [fd20:1db0:b882:802:0:46:0:0/96]:80, el comando debe verse de la siguiente manera:

    curl -m 10 -s http://[fd20:1db0:b882:802:0:46:0:0]:80

gcloud:IPv4

  1. Conéctate a la instancia de VM de cliente.

    gcloud compute ssh vm-client --zone=us-west1-a

  2. Describe la regla de reenvío de IPv4 fr-ilb.

    gcloud compute forwarding-rules describe fr-ilb --region=us-west1

  3. Realiza una solicitud web al balanceador de cargas mediante curl para establecer contacto con su dirección IP. Repite la solicitud para que puedas ver que las respuestas provienen de diferentes VMs de backend. El nombre de la VM que genera la respuesta se muestra en el texto de la respuesta HTML, en virtud del contenido de /var/www/html/index.html en cada VM de backend. Las respuestas esperadas tienen el aspecto Page served from: vm-a1.

    curl http://10.1.2.99

    La regla de reenvío está configurada para entregar en los puertos 80 y 53. Para enviar tráfico a esos otros puertos, agrega dos puntos (:) y el número de puerto después de la dirección IP, de esta manera:

    curl http://10.1.2.99:80

Haz ping en la dirección IP del balanceador de cargas

En esta prueba se demuestra un comportamiento esperado: puedes hacer ping a la dirección IP del balanceador de cargas.

gcloud:IPv6

  1. Conéctate a la instancia de VM de cliente.

    gcloud compute ssh vm-client-ipv6 --zone=us-west1-a

  2. Intenta hacer ping en la dirección IPv6 del balanceador de cargas. Reemplaza IPV6_ADDRESS por la dirección IPv6 efímera en la regla de reenvío fr-ilb-ipv6.

    Ten en cuenta que obtienes una respuesta y que el comando ping funciona en este ejemplo.

    ping6 IPV6_ADDRESS

    Por ejemplo, si la dirección IPv6 asignada es [2001:db8:1:1:1:1:1:1/96], el comando es el siguiente:

    ping6 2001:db8:1:1:1:1:1:1

    El resultado es similar a este:

    @vm-client: ping IPV6_ADDRESS
PING IPV6_ADDRESS (IPV6_ADDRESS) 56(84) bytes of data.
64 bytes from IPV6_ADDRESS: icmp_seq=1 ttl=64 time=1.58 ms

gcloud:IPv4

  1. Conéctate a la instancia de VM de cliente.

    gcloud compute ssh vm-client --zone=us-west1-a

  2. Intenta hacer ping en la dirección IPv4 del balanceador de cargas. Ten en cuenta que obtienes una respuesta y que el comando ping funciona en este ejemplo.

    ping 10.1.2.99

    Esta es la salida:

    @vm-client: ping 10.1.2.99
PING 10.1.2.99 (10.1.2.99) 56(84) bytes of data.
64 bytes from 10.1.2.99: icmp_seq=1 ttl=64 time=1.58 ms
64 bytes from 10.1.2.99: icmp_seq=2 ttl=64 time=0.242 ms
64 bytes from 10.1.2.99: icmp_seq=3 ttl=64 time=0.295 ms

Opciones de configuración adicionales

En esta sección se expande el ejemplo de configuración para proporcionar opciones de configuración alternativas y adicionales. Todas las tareas son opcionales. Puedes realizarlas en cualquier orden.

Puedes reservar una dirección IP interna estática para tu ejemplo. Esta configuración permite que varias reglas de reenvío interno usen la misma dirección IP con diferentes protocolos y puertos. De todos modos, los backends del balanceador de cargas de ejemplo deben ubicarse en la región us-west1.

En el siguiente diagrama, se muestra la arquitectura para este ejemplo:

Balanceo de cargas de tráfico basado en protocolos, con servicios de backend para administrar la distribución de conexiones a un solo grupo de instancias zonal.
Un balanceador de cargas de red de paso interno para varios protocolos que usan una dirección IP interna estática (haz clic para ampliar).

También puedes considerar usar las siguientes opciones de configuración de reglas de reenvío:

  • Reglas de reenvío con varios puertos:

    • Protocolo TCP con los puertos 80,8080
    • Protocolo L3_DEFAULT con los puertos ALL

  • Reglas de reenvío con todos los puertos:

    • Protocolo TCP con los puertos ALL
    • Protocolo L3_DEFAULT con los puertos ALL

Reservar dirección IPv4 interna estática

Reserva una dirección IP interna estática para 10.1.2.99 y establece su marca --purpose en SHARED_LOADBALANCER_VIP. La marca --purpose es obligatoria para que muchas reglas de reenvío puedan usar la misma dirección IP interna.

gcloud

Usa el comando gcloud compute addresses create:

gcloud compute addresses create internal-lb-ipv4 \
    --region us-west1 \
    --subnet lb-subnet \
    --purpose SHARED_LOADBALANCER_VIP \
    --addresses 10.1.2.99

API

Llama al método addresses.insert. Reemplaza PROJECT_ID por el ID del proyecto de Google Cloud.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/addresses

El cuerpo de la solicitud debe incluir el addressType que debe ser INTERNAL, el name de la dirección y la subnetwork a la que pertenece la dirección IP. Debes especificar el address como 10.1.2.99.

{
  "addressType": "INTERNAL",
  "name": "internal-lb-ipv4",
  "subnetwork": "regions/us-west1/subnetworks/lb-subnet",
  "purpose": "SHARED_LOADBALANCER_VIP",
  "address": "10.1.2.99"
}

Configura los componentes del balanceador de cargas

Configura tres balanceadores de cargas con los siguientes componentes:

  • El primer balanceador de cargas tiene una regla de reenvío con el protocolo TCP y el puerto 80. El tráfico de TCP que llega a la dirección IP interna en el puerto 80 se controla mediante la regla de reenvío TCP.
  • El segundo balanceador de cargas tiene una regla de reenvío con el protocolo UDP y el puerto 53. El tráfico de UDP que llega a la dirección IP interna en el puerto 53 se controla mediante la regla de reenvío UDP.
  • El tercer balanceador de cargas tiene una regla de reenvío con el protocolo L3_DEFAULT y el puerto ALL. El resto del tráfico que no coincide con las reglas de reenvío TCP o UDP se controla mediante la regla de reenvío L3_DEFAULT.
  • Los tres balanceadores de cargas comparten la misma dirección IP interna estática (internal-lb-ipv4) en sus reglas de reenvío.

Crea el primer balanceador de cargas

Crea el primer balanceador de cargas para el tráfico de TCP en el puerto 80.

gcloud

  1. Crea el servicio de backend para el tráfico TCP:

    gcloud compute backend-services create be-ilb \
    --load-balancing-scheme=internal \
    --protocol=tcp \
    --region=us-west1 \
    --health-checks=hc-http-80 \
    --health-checks-region=us-west1

  2. Agrega el grupo de instancias al servicio de backend:

    gcloud compute backend-services add-backend be-ilb \
    --region=us-west1 \
    --instance-group=ig-a \
    --instance-group-zone=us-west1-a

  3. Crea una regla de reenvío para el servicio de backend. Usa la dirección IP interna reservada estática (internal-lb-ipv4) para la dirección IP interna.

    gcloud compute forwarding-rules create fr-ilb \
    --region=us-west1 \
    --load-balancing-scheme=internal \
    --network=lb-network \
    --subnet=lb-subnet \
    --address=internal-lb-ipv4 \
    --ip-protocol=TCP \
    --ports=80 \
    --backend-service=be-ilb \
    --backend-service-region=us-west1

API

  1. Crea el servicio de backend regional mediante una solicitud POST al método regionBackendServices.insert. Reemplaza PROJECT_ID por el ID del proyecto de Google Cloud.

    POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/backendServices
{
"name": "be-ilb",
"backends": [
 {
   "group": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instanceGroups/ig-a",
   "balancingMode": "CONNECTION"
 }
],
"healthChecks": [
 "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/healthChecks/hc-http-80"
],
"loadBalancingScheme": "INTERNAL",
"protocol": "TCP",
"connectionDraining": {
 "drainingTimeoutSec": 0
}
}

  2. Create the forwarding rule by making a POST request to the forwardingRules.insert method:

    POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/forwardingRules

{
"name": "fr-ilb",
"IPAddress": "internal-lb-ipv4",
"IPProtocol": "TCP",
"ports": [
 "80"
],
"loadBalancingScheme": "INTERNAL",
"subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet",
"network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
"backendService": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/backendServices/be-ilb",
"networkTier": "PREMIUM"
}

Crea el segundo balanceador de cargas

Crea el segundo balanceador de cargas para el tráfico UDP en el puerto 53.

gcloud

  1. Crea un servicio de backend con el protocolo configurado como UDP.

    gcloud compute backend-services create be-ilb-udp \
    --load-balancing-scheme=internal \
    --protocol=UDP \
    --region=us-west1 \
    --health-checks=hc-http-80 \
    --health-checks-region=us-west1

  2. Agrega el grupo de instancias al servicio de backend:

    gcloud compute backend-services add-backend be-ilb-udp \
    --region=us-west1 \
    --instance-group=ig-a \
    --instance-group-zone=us-west1-a

  3. Crea una regla de reenvío para el servicio de backend. Usa la dirección IP interna reservada estática (internal-lb-ipv4) para la dirección IP interna.

    gcloud compute forwarding-rules create fr-ilb-udp \
    --region=us-west1 \
    --load-balancing-scheme=internal \
    --network=lb-network \
    --subnet=lb-subnet \
    --address=internal-lb-ipv4 \
    --ip-protocol=UDP \
    --ports=53 \
    --backend-service=be-ilb-udp \
    --backend-service-region=us-west1

API

  1. Crea el servicio de backend regional mediante una solicitud POST al método regionBackendServices.insert. Reemplaza PROJECT_ID por el ID del proyecto de Google Cloud.

    POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/backendServices
{
"name": "be-ilb-udp",
"backends": [
 {
  "group": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instanceGroups/ig-a",
  "balancingMode": "CONNECTION"
 }
],
"healthChecks": [
 "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/healthChecks/hc-http-80"
],
"loadBalancingScheme": "INTERNAL",
"protocol": "UDP",
"connectionDraining": {
 "drainingTimeoutSec": 0
}
}

  2. Para crear la regla de reenvío, realiza una solicitud POST al método forwardingRules.insert.

    POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/forwardingRules

{
"name": "fr-ilb-udp",
"IPAddress": "internal-lb-ipv4",
"IPProtocol": "UDP",
"ports": [
 "53"
],
"loadBalancingScheme": "INTERNAL",
"subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet",
"network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
"backendService": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/backendServices/be-ilb-udp",
"networkTier": "PREMIUM"
}

Crea el tercer balanceador de cargas

Crea la regla de reenvío del tercer balanceador de cargas para que use la dirección IP interna reservada estática.

gcloud

Crea la regla de reenvío con el protocolo configurado en L3_DEFAULT para controlar todo el resto de tráfico del protocolo IPv4 compatible. Usa la dirección IP interna reservada estática (internal-lb-ipv4) como la dirección IP interna.

gcloud compute forwarding-rules create fr-ilb-l3-default \
    --region=us-west1 \
    --load-balancing-scheme=internal \
    --network=lb-network \
    --subnet=lb-subnet \
    --address=internal-lb-ipv4 \
    --ip-protocol=L3_DEFAULT \
    --ports=ALL \
    --backend-service=be-ilb-l3-default \
    --backend-service-region=us-west1

API

Para crear la regla de reenvío, realiza una solicitud POST al método forwardingRules.insert. Reemplaza PROJECT_ID por el ID del proyecto de Google Cloud.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/forwardingRules

{
"name": "fr-ilb-l3-default",
"IPAddress": "internal-lb-ipv4",
"IPProtocol": "L3_DEFAULT",
"ports": [
  "ALL"
],
"loadBalancingScheme": "INTERNAL",
"subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet",
"network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
"backendService": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/backendServices/be-ilb-l3-default",
"networkTier": "PREMIUM"
}

Prueba el balanceador de cargas

Para probar tu balanceador de cargas, sigue los pasos en la sección anterior.

¿Qué sigue?