Configura un balanceador de cargas de red de transferencia externo global para varios protocolos IP

Vista previa

Este producto o función está sujeto a las "Condiciones de la Oferta de la Fase Previa a la DG" en la sección Condiciones Generales del Servicio de las Condiciones Específicas del Servicio. Los productos y las funciones de la fase previa a la DG están disponibles “tal como están” y pueden estar sujetos a asistencia limitada. Para obtener más información, consulta las descripciones de la etapa de lanzamiento.

En este documento, se muestra cómo crear un balanceador de cargas de red de transferencia externo global para balancear el tráfico de TCP, UDP, ESP, GRE, ICMP y ICMPv6.

Puedes usar esta configuración para hacer lo siguiente:

• Balancear las cargas del tráfico que usa protocolos IP distintos de TCP o UDP

• Publica varios protocolos con un solo balanceador de cargas. Por ejemplo, los servicios IPSec suelen controlar una combinación de tráfico IKE y NAT-T basado en ESP y UDP.

Antes de comenzar

Asegúrate de que tu configuración cumpla con los requisitos.

Instala Google Cloud CLI

En las instrucciones de esta guía, se usa Google Cloud CLI para configurar un balanceador de cargas de red de transferencia externo global. Para instalarla, consulta Instala gcloud CLI.

Roles obligatorios

Si eres el creador del proyecto, se te otorga el rol de propietario (roles/owner). De forma predeterminada, el rol de propietario (roles/owner) o el rol de editor (roles/editor) incluyen los permisos necesarios para seguir este documento.

Si no eres el creador del proyecto, se deben otorgar los permisos necesarios en el proyecto a la principal correspondiente. Por ejemplo, una principal puede ser una Cuenta de Google (para usuarios finales) o una cuenta de servicio.

Para obtener los permisos que necesitas para configurar un balanceador de cargas de red externo global de transferencia con backends de grupos de instancias de VM, pídele a tu administrador que te otorgue los siguientes roles de IAM en tu proyecto:

• Crea una red de VPC, una subred y componentes de balanceo de cargas: Rol de administrador de red de Compute (roles/compute.networkAdmin)
• Crea reglas de firewall: Rol de administrador de seguridad de Compute (roles/compute.securityAdmin)
• Crear instancias de VM: Rol de administrador de instancias de Compute (roles/compute.instanceAdmin)

Para obtener más información sobre cómo otorgar roles, consulta Administra el acceso a proyectos, carpetas y organizaciones.

También puedes obtener los permisos necesarios a través de roles personalizados o cualquier otro rol predefinido.

Para obtener más información sobre los roles y permisos de Cloud Load Balancing, consulta Roles y permisos. Si deseas obtener más información para definir políticas de IAM con permisos condicionales para reglas de reenvío, consulta Condiciones de IAM para reglas de reenvío.

Descripción general de la configuración

En el siguiente diagrama, se muestran dos balanceadores de cargas de red de transferencia externos globales para el mismo par de direcciones IP, cada uno de los cuales entrega un conjunto diferente de protocolos y puertos de IP. Para comprender cómo funciona un balanceador de cargas de red de transferencia externo global, consulta la sección Arquitectura de la guía de descripción general.

Nota: Debes configurar los componentes de un balanceador de cargas de red de transferencia externo global con gcloud o la API de REST, y no con la consola de Google Cloud .

1. TCP balanceador de cargas en el puerto 80

   La regla de reenvío de este balanceador de cargas está configurada para capturar solo el tráfico de TCP que llega específicamente al puerto 80.

   • Cuando un paquete llega a la dirección IP de una regla de reenvío,Google Cloud primero verifica si es un paquete TCP y si su puerto de destino es exactamente 80.
   • Si se cumplen esas condiciones, este paquete se captura con esta regla de reenvío TCP específica y se enruta a un backend según el servicio de backend al que se hace referencia.

2. Balanceador de cargas L3_DEFAULT para el tráfico de TCP:8080 y UDP

   La regla de reenvío de este balanceador de cargas usa el protocolo L3_DEFAULT y está configurada para aceptar tráfico en todos los puertos. En esta configuración, actúa como la regla de captura general que controla el tráfico que la primera regla de reenvío no controla (como UDP, ICMP y todo el tráfico de TCP que no sea el puerto 80).

   • Si un paquete llega a una dirección IP de regla de reenvío que no coincide con la regla específica de tráfico de TCP que llega al puerto 80 (por ejemplo, si es tráfico de UDP, un ping de ICMP o tráfico de TCP en el puerto 8080 o 443), la regla de reenvío L3_DEFAULT captura este paquete.
   • Agrega una regla de firewall para permitir que solo el tráfico de TCP:8080 y UDP llegue a las instancias de VM de backend. Por lo tanto, aunque la regla de reenvío L3_DEFAULT captura todo el tráfico de protocolo IP en todos los puertos, la regla de firewall limita el tráfico con balanceo de cargas al tráfico de TCP:8080 y UDP.
   • Luego, el paquete se enruta a un backend según el servicio de backend al que se hace referencia.

   Google Cloud prioriza la regla TCP más específica en el puerto 80 antes de permitir que el tráfico restante fluya a una regla L3_DEFAULT en la misma dirección IP.

   Nota: Dado que L3_DEFAULT es una regla de captura general, como práctica recomendada de seguridad, debes configurar reglas de firewall de permiso de entrada que solo permitan los protocolos y puertos IP que necesitas.

Dos balanceadores de cargas de red de transferencia externos globales para el mismo par de direcciones IP, cada uno con un conjunto diferente de protocolos y puertos de IP (haz clic para ampliar).

Configura la red y las subredes

En el ejemplo, se usa una red de VPC en modo personalizado llamada lb-network con subredes en dos regiones diferentes.

En la siguiente tabla, se resume la compatibilidad entre los tipos de tráfico del balanceador de cargas, las interfaces de red de la VM de backend y los tipos de pila de subred de VPC. Asegúrate de conocer los requisitos de compatibilidad de la interfaz de red de la VM de backend con las subredes de VPC que se describen en la guía de arquitectura del balanceador de cargas de red de transferencia externo global.

Tipo de tráfico del balanceador de cargas	Tipo de pila de la interfaz de red de la VM de backend	Tipo de pila de la subred de VPC
Solo tráfico IPv4	IPV4_ONLY	IPV4_ONLY o IPV4_IPV6
	IPV4_IPV6	IPV4_IPV6
Solo tráfico IPv6	IPV6_ONLY	IPV6_ONLY o IPV4_IPV6
	IPV4_IPV6	IPV4_IPV6
Tráfico IPv4 e IPv6	IPV4_IPV6	IPV4_IPV6

Los backends que se usan en este ejemplo se encuentran en las siguientes regiones y subredes. Aunque puedes elegir qué rango de direcciones IPv4 se configura en la subred, Google Cloud asigna automáticamente un rango de direcciones IPv6 de /64 a toda la subred.

• Región: us-west1

  • Subred: lb-subnet-us, con el rango de direcciones IPv4 principal 10.1.2.0/24.

• Región: europe-west2

  • Subred: lb-subnet-eu, con el rango de direcciones IPv4 principal 10.1.3.0/24.

gcloud

1. Crear una red de VPC. En este ejemplo, la red de VPC se llama lb-network.

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

2. Dentro de la red de VPC (lb-network), crea subredes en dos regiones.

   Crea una subred llamada lb-subnet-us para los backends en la región us-west1.

   Para crear una subred de solo IPv4, usa el siguiente comando:

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

   Para crear una subred de pila doble, usa el siguiente comando:

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

   Para crear una subred de solo IPv6, usa el siguiente comando:

   gcloud compute networks subnets create lb-subnet-us \
       --stack-type=IPV6_ONLY \
       --ipv6-access-type=EXTERNAL \
       --network=lb-network \
       --region=us-west1
   

   Crea una subred llamada lb-subnet-eu para los backends en la región europe-west2.

   Para crear una subred de solo IPv4, usa el siguiente comando:

   gcloud compute networks subnets create lb-subnet-eu \
       --stack-type=IPV4_ONLY \
       --network=lb-network \
       --range=10.1.3.0/24 \
       --region=europe-west2
   

   Para crear una subred de pila doble, usa el siguiente comando:

   gcloud compute networks subnets create lb-subnet-eu \
       --stack-type=IPV4_IPV6 \
       --ipv6-access-type=EXTERNAL \
       --network=lb-network \
       --range=10.1.3.0/24 \
       --region=europe-west2
   

   Para crear una subred de solo IPv6, usa el siguiente comando:

   gcloud compute networks subnets create lb-subnet-eu \
       --stack-type=IPV6_ONLY \
       --ipv6-access-type=EXTERNAL \
       --network=lb-network \
       --range=10.1.3.0/24 \
       --region=europe-west2
   

Reserva direcciones IP externas globales

Reserva dos direcciones IP externas globales, una de cada grupo de disponibilidad. Como se muestra en la Descripción general de la configuración, los dos balanceadores de cargas de red de transferencia externos globales comparten el mismo par de direcciones IP.

En el caso de un balanceador de cargas de red de transferencia externo global, las direcciones IP de la regla de reenvío están completamente desacopladas de las subredes de VPC. Las direcciones IP pertenecen a grupos de direcciones IP externas globales propiedad de Google o a prefijos delegados públicos IPv4 externos globales de BYOIP de distintos grupos de disponibilidad y no están asociadas a ninguna subred de VPC.

Cuando configuras una regla de reenvío de IPv6, las direcciones IP de la regla de reenvío se asignan como prefijos /96.

gcloud

Para el tráfico IPv4, haz lo siguiente:

1. Reserva la primera dirección IP externa global llamada lb-ipv4-ag0 en el grupo de disponibilidad 0.

   gcloud beta compute addresses create lb-ipv4-ag0 \
       --global \
       --purpose=PASSTHROUGH_LOAD_BALANCER_AVAILABILITY_GROUP0 \
       --ip-version=IPV4
   

2. Reserva la segunda dirección IP externa global lb-ipv4-ag1 en el grupo de disponibilidad 1.

   gcloud beta compute addresses create lb-ipv4-ag1 \
       --global \
       --purpose=PASSTHROUGH_LOAD_BALANCER_AVAILABILITY_GROUP1 \
       --ip-version=IPV4
   

Para el tráfico IPv6, haz lo siguiente:

1. Reserva la primera dirección IP externa global llamada lb-ipv6-ag0 en el grupo de disponibilidad 0.

   gcloud beta compute addresses create lb-ipv6-ag0 \
       --global \
       --purpose=PASSTHROUGH_LOAD_BALANCER_AVAILABILITY_GROUP0 \
       --ip-version=IPV6
   

2. Reserva la segunda dirección IP externa global lb-ipv6-ag1 en el grupo de disponibilidad 1.

   gcloud beta compute addresses create lb-ipv6-ag1 \
       --global \
       --purpose=PASSTHROUGH_LOAD_BALANCER_AVAILABILITY_GROUP1 \
       --ip-version=IPV6
   

Configura un balanceador de cargas para el tráfico de TCP en el puerto 80

Sigue los pasos de esta sección para configurar un balanceador de cargas de red de transferencia externo global que capture el tráfico de TCP en el puerto 80.

Crea reglas de firewall para permitir solo el tráfico de TCP:80

Para configurar de forma segura tu entorno de producción, debes crear dos reglas de firewall separadas:

• Regla de firewall de verificación de estado, que está configurada para permitir el tráfico de entrada desde los siguientes rangos:

  • Los rangos de IP de verificación de estado de Google
  • El protocolo IP y los puertos que se configuran en tu verificación de estado

• Regla de firewall de tráfico del usuario, que está configurada para permitir el tráfico de entrada desde los siguientes rangos:

  • Los rangos de IP de origen del cliente específicos que necesitan acceder a tu balanceador de cargas
  • El protocolo IP y los puertos que se configuran en tus reglas de reenvío

Ten en cuenta lo siguiente:

• Si tu aplicación entrega contenido a todos los usuarios de Internet sin limitaciones, configura los rangos de IP de origen 0.0.0.0/0 para el tráfico de IPv4 y ::/0 para el tráfico de IPv6.

• Si configuraste tu verificación de estado para sondear el protocolo y los puertos de IP del balanceo de cargas, puedes configurar una sola regla de firewall combinando las reglas de firewall de verificación de estado y de tráfico del usuario.

gcloud

Crea una regla de firewall que permita que el tráfico de TCP de todos los rangos de origen llegue a tus instancias de VM de backend en el puerto 80. Este puerto y protocolo se usan tanto para el balanceo de cargas como para la verificación de estado.

• Para permitir todo el tráfico IPv4, ejecuta el siguiente comando:

    gcloud compute firewall-rules create allow-traffic-tcp-80-ipv4 \
        --network=lb-network \
        --target-tags=allow-traffic-tcp-80 \
        --allow=tcp:80 \
        --source-ranges=0.0.0.0/0
  

• Para permitir todo el tráfico IPv6, ejecuta el siguiente comando:

    gcloud compute firewall-rules create allow-traffic-tcp-80-ipv6 \
        --network=lb-network \
        --target-tags=allow-traffic-tcp-80 \
        --allow=tcp:80 \
        --source-ranges=::/0
  

Crea instancias de VM de backend

Para este ejemplo de balanceo de cargas, crea grupos de instancias administrados en las zonas us-west1-a y europe-west2-a. El grupo de instancias administrado consta de instancias de VM que alojan los servidores de backend del balanceador de cargas. A modo de demostración, los servidores de backend ejecutan el servidor Apache en el puerto 80. En respuesta a las solicitudes del cliente, entregan sus propios nombres de host.

El grupo de instancias hace referencia a una plantilla de instancias, que se usa para crear VMs de backend.

En la siguiente tabla, se resume la compatibilidad entre los tipos de tráfico del balanceador de cargas, las interfaces de red de la VM de backend y los tipos de pila de subred de VPC. Asegúrate de conocer los requisitos de compatibilidad de la interfaz de red de la VM de backend con las subredes de VPC que se describen en la guía de arquitectura del balanceador de cargas de red de transferencia externo global.

Tipo de tráfico del balanceador de cargas	Tipo de pila de la interfaz de red de la VM de backend	Tipo de pila de la subred de VPC
Solo tráfico IPv4	IPV4_ONLY	IPV4_ONLY o IPV4_IPV6
	IPV4_IPV6	IPV4_IPV6
Solo tráfico IPv6	IPV6_ONLY	IPV6_ONLY o IPV4_IPV6
	IPV4_IPV6	IPV4_IPV6
Tráfico IPv4 e IPv6	IPV4_IPV6	IPV4_IPV6

Crea una plantilla de instancias

En este ejemplo, crearás plantillas de instancias regionales en las regiones us-west1 y europe-west2.

gcloud

1. Crea una plantilla de instancias en la región us-west1.

   Para crear VMs de backend con interfaces de red solo IPv4, usa el siguiente comando.

   gcloud compute instance-templates create ig-template-us-tcp-80 \
       --region=us-west1 \
       --network=lb-network \
       --subnet=lb-subnet-us \
       --stack-type=IPV4_ONLY \
       --tags=allow-traffic-tcp-80 \
       --image-family=debian-12 \
       --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
       systemctl restart apache2'
   

   Para crear VMs de backend con interfaces de red de pila doble, usa el siguiente comando.

   gcloud compute instance-templates create ig-template-us-tcp-80 \
       --region=us-west1 \
       --network=lb-network \
       --subnet=lb-subnet-us \
       --ipv6-network-tier=PREMIUM \
       --stack-type=IPV4_IPV6 \
       --tags=allow-traffic-tcp-80 \
       --image-family=debian-12 \
       --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
       systemctl restart apache2'
   

   Para crear VMs de backend con interfaces de red solo IPv6, usa el siguiente comando.

   gcloud compute instance-templates create ig-template-us-tcp-80 \
       --region=us-west1 \
       --network=lb-network \
       --subnet=lb-subnet-us \
       --ipv6-network-tier=PREMIUM \
       --stack-type=IPV6_ONLY \
       --tags=allow-traffic-tcp-80 \
       --image-family=debian-12 \
       --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
       systemctl restart apache2'
   

2. Crea una plantilla de instancias en la región europe-west2.

   Para crear VMs de backend con interfaces de red solo IPv4, usa el siguiente comando.

   gcloud compute instance-templates create ig-template-eu-tcp-80 \
       --region=europe-west2 \
       --network=lb-network \
       --subnet=lb-subnet-eu \
       --stack-type=IPV4_ONLY \
       --tags=allow-traffic-tcp-80 \
       --image-family=debian-12 \
       --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
       systemctl restart apache2'
   

   Para crear VMs de backend con interfaces de red de pila doble, usa el siguiente comando.

   gcloud compute instance-templates create ig-template-eu-tcp-80 \
       --region=europe-west2 \
       --network=lb-network \
       --subnet=lb-subnet-eu \
       --ipv6-network-tier=PREMIUM \
       --stack-type=IPV4_IPV6 \
       --tags=allow-traffic-tcp-80 \
       --image-family=debian-12 \
       --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
       systemctl restart apache2'
   

   Para crear VMs de backend con interfaces de red solo IPv6, usa el siguiente comando.

   gcloud compute instance-templates create ig-template-eu-tcp-80 \
       --region=europe-west2 \
       --network=lb-network \
       --subnet=lb-subnet-eu \
       --ipv6-network-tier=PREMIUM \
       --stack-type=IPV6_ONLY \
       --tags=allow-traffic-tcp-80 \
       --image-family=debian-12 \
       --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
       systemctl restart apache2'
   

Crea grupos de instancias administrados zonales

En este ejemplo, crearás dos grupos de instancias administrados zonales: uno en la zona us-west1-a y el otro en la zona europe-west2-a.

gcloud

1. Crea un grupo de instancias administrado en la zona us-west1-a.

   gcloud compute instance-groups managed create ig-us-tcp-80 \
     --template=ig-template-us-tcp-80 \
     --size=2 \
     --zone=us-west1-a
   

2. Crea un grupo de instancias administrado en la zona europe-west2-a.

   gcloud compute instance-groups managed create ig-eu-tcp-80 \
     --template=ig-template-eu-tcp-80 \
     --size=2 \
     --zone=europe-west2-a
   

Crea los componentes de Cloud Load Balancing

Para crear los componentes de Cloud Load Balancing de un balanceador de cargas de red de transferencia externo global, haz lo siguiente.

gcloud

1. Crea una verificación de estado de TCP configurada para generar sondeos TCP:80.

   gcloud compute health-checks create tcp hc-tcp-80 \
     --global \
     --port=80
   

2. Crea un servicio de backend global con el esquema de balanceo de cargas EXTERNAL_PASSTHROUGH.

   gcloud beta compute backend-services create lb-backend-service-tcp-80 \
     --load-balancing-scheme=EXTERNAL_PASSTHROUGH \
     --health-checks=hc-tcp-80 \
     --global
   

3. Agrega los grupos de instancias como backends al servicio de backend.

   Agrega el grupo de instancias en la zona us-west1-a al servicio de backend.

   gcloud beta compute backend-services add-backend lb-backend-service-tcp-80 \
       --instance-group=ig-us-tcp-80 \
       --instance-group-zone=us-west1-a \
       --balancing-mode=UTILIZATION \
       --max-utilization=0.7 \
       --global
   

   Agrega el grupo de instancias en la zona europe-west2-a al servicio de backend.

   gcloud beta compute backend-services add-backend lb-backend-service-tcp-80 \
       --instance-group=ig-eu-tcp-80 \
       --instance-group-zone=europe-west2-a \
       --balancing-mode=UTILIZATION \
       --max-utilization=0.7 \
       --global
   

4. Crea una regla de reenvío global para atender el tráfico de TCP:80.

   Asegúrate de que la versión de IP de tu regla de reenvío coincida con el tipo de pila de las interfaces de red de tu VM de backend.

   La regla de reenvío hace referencia a las direcciones IP de cada grupo de disponibilidad.

   Para el tráfico IPv4, haz lo siguiente:

   gcloud beta compute forwarding-rules create lb-forwarding-rule-tcp-80-ipv4 \
     --load-balancing-scheme=EXTERNAL_PASSTHROUGH \
     --ip-protocol=TCP \
     --ports=80 \
     --backend-service=lb-backend-service-tcp-80 \
     --global \
     --ip-addresses=lb-ipv4-ag0,lb-ipv4-ag1
   

   Para el tráfico IPv6, haz lo siguiente:

   gcloud beta compute forwarding-rules create lb-forwarding-rule-tcp-80-ipv6 \
     --load-balancing-scheme=EXTERNAL_PASSTHROUGH \
     --ip-protocol=TCP \
     --ports=80 \
     --backend-service=lb-backend-service-tcp-80 \
     --global \
     --ip-addresses=lb-ipv6-ag0,lb-ipv6-ag1
   

Configura un balanceador de cargas para el tráfico de TCP:8080 y UDP

Sigue los pasos de esta sección para configurar un balanceador de cargas de red de transferencia externo global que procese el tráfico de TCP:8080 y UDP.

Crea reglas de firewall para permitir solo el tráfico de TCP:8080 y UDP.

Para configurar de forma segura tu entorno de producción, debes crear dos reglas de firewall separadas:

• Regla de firewall de verificación de estado, que está configurada para permitir el tráfico de entrada desde los siguientes rangos:

  • Los rangos de IP de verificación de estado de Google
  • El protocolo IP y los puertos que se configuran en tu verificación de estado

• Regla de firewall de tráfico del usuario, que está configurada para permitir el tráfico de entrada desde los siguientes rangos:

  • Los rangos de IP de origen del cliente específicos que necesitan acceder a tu balanceador de cargas
  • El protocolo IP y los puertos que se configuran en tus reglas de reenvío

Ten en cuenta lo siguiente:

• Si tu aplicación entrega contenido a todos los usuarios de Internet sin limitaciones, configura los rangos de IP de origen 0.0.0.0/0 para el tráfico de IPv4 y ::/0 para el tráfico de IPv6.

• Si configuraste tu verificación de estado para sondear el protocolo y los puertos de IP del balanceo de cargas, puedes configurar una sola regla de firewall combinando las reglas de firewall de verificación de estado y de tráfico del usuario.

gcloud

Crea una regla de firewall que permita que el tráfico de TCP:8080 y UDP de todos los rangos de origen llegue a tus instancias de VM de backend. Estos protocolos se usan para el balanceo de cargas, mientras que el puerto TCP 8080 también se usa para la verificación de estado.

1. Para permitir que el tráfico IPv4 llegue a los backends en los grupos de instancias ig-us-l3-default y ig-eu-l3-default, crea la siguiente regla de firewall.

   gcloud compute firewall-rules create allow-traffic-l3-default-ipv4 \
       --network=lb-network \
       --target-tags=allow-traffic-l3-default \
       --allow=tcp:8080,udp \
       --source-ranges=0.0.0.0/0
   

2. Para permitir que el tráfico IPv6 llegue a los backends en los grupos de instancias ig-us-l3-default y ig-eu-l3-default, crea la siguiente regla de firewall.

   gcloud compute firewall-rules create allow-traffic-l3-default-ipv6 \
       --network=lb-network \
       --target-tags=allow-traffic-l3-default \
       --allow=tcp:8080,udp \
       --source-ranges=::/0
   

Crea instancias de VM de backend

Para este ejemplo de balanceo de cargas, crea grupos de instancias administrados en las zonas us-west1-a y europe-west2-a. El grupo de instancias administrado consta de instancias de VM que alojan los servidores de backend del balanceador de cargas. A modo de demostración, los backends entregan sus propios nombres de host. La secuencia de comandos de inicio también configura el servidor Apache para que escuche en el puerto 8080 en lugar del puerto 80.

El grupo de instancias hace referencia a una plantilla de instancias, que se usa para crear VMs de backend.

En la siguiente tabla, se resume la compatibilidad entre los tipos de tráfico del balanceador de cargas, las interfaces de red de la VM de backend y los tipos de pila de subred de VPC. Asegúrate de conocer los requisitos de compatibilidad de la interfaz de red de la VM de backend con las subredes de VPC que se describen en la guía de arquitectura del balanceador de cargas de red de transferencia externo global.

Tipo de tráfico del balanceador de cargas	Tipo de pila de la interfaz de red de la VM de backend	Tipo de pila de la subred de VPC
Solo tráfico IPv4	IPV4_ONLY	IPV4_ONLY o IPV4_IPV6
	IPV4_IPV6	IPV4_IPV6
Solo tráfico IPv6	IPV6_ONLY	IPV6_ONLY o IPV4_IPV6
	IPV4_IPV6	IPV4_IPV6
Tráfico IPv4 e IPv6	IPV4_IPV6	IPV4_IPV6

Crea una plantilla de instancias

En este ejemplo, crearás plantillas de instancias regionales en las regiones us-west1 y europe-west2.

gcloud

1. Crea una plantilla de instancias en la región us-west1.

   Para crear VMs de backend con interfaces de red solo IPv4, usa el siguiente comando.

   gcloud compute instance-templates create ig-template-us-l3-default \
       --region=us-west1 \
       --network=lb-network \
       --subnet=lb-subnet-us \
       --stack-type=IPV4_ONLY \
       --tags=allow-traffic-l3-default \
       --image-family=debian-12 \
       --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'
   

   Para crear VMs de backend con interfaces de red de pila doble, usa el siguiente comando.

   gcloud compute instance-templates create ig-template-us-l3-default \
       --region=us-west1 \
       --network=lb-network \
       --subnet=lb-subnet-us \
       --ipv6-network-tier=PREMIUM \
       --stack-type=IPV4_IPV6 \
       --tags=allow-traffic-l3-default \
       --image-family=debian-12 \
       --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'
   

   Para crear VMs de backend con interfaces de red solo IPv6, usa el siguiente comando.

   gcloud compute instance-templates create ig-template-us-l3-default \
       --region=us-west1 \
       --network=lb-network \
       --subnet=lb-subnet-us \
       --ipv6-network-tier=PREMIUM \
       --stack-type=IPV6_ONLY \
       --tags=allow-traffic-l3-default \
       --image-family=debian-12 \
       --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 una plantilla de instancias en la región europe-west2.

   Para crear VMs de backend con interfaces de red solo IPv4, usa el siguiente comando.

   gcloud compute instance-templates create ig-template-eu-l3-default \
       --region=europe-west2 \
       --network=lb-network \
       --subnet=lb-subnet-eu \
       --stack-type=IPV4_ONLY \
       --tags=allow-traffic-l3-default \
       --image-family=debian-12 \
       --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'
   

   Para crear VMs de backend con interfaces de red de pila doble, usa el siguiente comando.

   gcloud compute instance-templates create ig-template-eu-l3-default \
       --region=europe-west2 \
       --network=lb-network \
       --subnet=lb-subnet-eu \
       --ipv6-network-tier=PREMIUM \
       --stack-type=IPV4_IPV6 \
       --tags=allow-traffic-l3-default \
       --image-family=debian-12 \
       --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'
   

   Para crear VMs de backend con interfaces de red solo IPv6, usa el siguiente comando.

   gcloud compute instance-templates create ig-template-eu-l3-default \
       --region=europe-west2 \
       --network=lb-network \
       --subnet=lb-subnet-eu \
       --ipv6-network-tier=PREMIUM \
       --stack-type=IPV6_ONLY \
       --tags=allow-traffic-l3-default \
       --image-family=debian-12 \
       --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'
   

Crea grupos de instancias administrados zonales

En este ejemplo, crearás dos grupos de instancias administrados zonales: uno en la zona us-west1-a y el otro en la zona europe-west2-a.

gcloud

1. Crea un grupo de instancias administrado en la zona us-west1-a.

   gcloud compute instance-groups managed create ig-us-l3-default \
     --template=ig-template-us-l3-default \
     --size=2 \
     --zone=us-west1-a
   

2. Crea un grupo de instancias administrado en la zona europe-west2-a.

   gcloud compute instance-groups managed create ig-eu-l3-default \
     --template=ig-template-eu-l3-default \
     --size=2 \
     --zone=europe-west2-a
   

Crea los componentes de Cloud Load Balancing

Para crear los componentes de Cloud Load Balancing de un balanceador de cargas de red de transferencia externo global, haz lo siguiente.

gcloud

1. Crea una verificación de estado de TCP configurada para generar sondeos TCP:8080.

   gcloud compute health-checks create tcp hc-tcp-8080 \
     --global \
     --port=8080
   

2. Crea un servicio de backend global con el esquema de balanceo de cargas EXTERNAL_PASSTHROUGH.

   gcloud beta compute backend-services create lb-backend-service-l3-default \
     --load-balancing-scheme=EXTERNAL_PASSTHROUGH \
     --health-checks=hc-tcp-8080 \
     --global
   

3. Agrega los grupos de instancias como backends al servicio de backend.

   Agrega el grupo de instancias en la zona us-west1-a al servicio de backend.

   gcloud beta compute backend-services add-backend lb-backend-service-l3-default \
       --instance-group=ig-us-l3-default \
       --instance-group-zone=us-west1-a \
       --balancing-mode=UTILIZATION \
       --max-utilization=0.7 \
       --global
   

   Agrega el grupo de instancias en la zona europe-west2-a al servicio de backend.

   gcloud beta compute backend-services add-backend lb-backend-service-l3-default \
       --instance-group=ig-eu-l3-default \
       --instance-group-zone=europe-west2-a \
       --balancing-mode=UTILIZATION \
       --max-utilization=0.7 \
       --global
   

4. Crea una regla de reenvío global con su campo ip-protocol establecido en L3_DEFAULT para controlar todo el tráfico de protocolo IP (tráfico de TCP que no sea el puerto 80, UDP, ICMP y ESP). Debes crear dos reglas de reenvío para controlar el tráfico IPv4 e IPv6.

   Asegúrate de que la versión de IP de tu regla de reenvío coincida con el tipo de pila de las interfaces de red de tu VM de backend.

   La regla de reenvío hace referencia a las direcciones IP de cada grupo de disponibilidad.

   Nota: Aunque la regla de reenvío L3_DEFAULT captura todo el tráfico de protocolo IP en todos los puertos, la regla de firewall solo permite que el tráfico TCP:8080 y UDP llegue a las instancias de VM de backend.

   Para el tráfico IPv4, haz lo siguiente:

   gcloud beta compute forwarding-rules create lb-forwarding-rule-l3-default-ipv4 \
     --load-balancing-scheme=EXTERNAL_PASSTHROUGH \
     --ip-protocol=L3_DEFAULT \
     --ports=all \
     --backend-service=lb-backend-service-l3-default \
     --global \
     --ip-addresses=lb-ipv4-ag0,lb-ipv4-ag1
   

   Para el tráfico IPv6, haz lo siguiente:

   gcloud beta compute forwarding-rules create lb-forwarding-rule-l3-default-ipv6 \
     --load-balancing-scheme=EXTERNAL_PASSTHROUGH \
     --ip-protocol=L3_DEFAULT \
     --ports=all \
     --backend-service=lb-backend-service-l3-default \
     --global \
     --ip-addresses=lb-ipv6-ag0,lb-ipv6-ag1
   

Prueba el balanceador de cargas

Ahora que el servicio de balanceo de cargas está configurado, puedes comenzar a enviar tráfico a las direcciones IP externas del balanceador de cargas y ver cómo se distribuye el tráfico a las instancias de backend.

Obtén las direcciones IP externas del balanceador de cargas

1. Obtén las direcciones IP reservadas asociadas a la regla de reenvío. La regla de reenvío para ambos balanceadores de cargas usa el mismo par de direcciones IP, por lo que puedes usar lb-forwarding-rule-tcp-80-ipv4 o lb-forwarding-rule-l3-default-ipv4 para ver las direcciones IP externas.

     gcloud compute forwarding-rules describe lb-forwarding-rule-tcp-80-ipv4 \
         --global
   

   Esto devuelve dos direcciones IP, una para cada grupo de disponibilidad. En los siguientes pasos, se hará referencia a estas direcciones IP como IP_ADDRESS_AVAILABILITY_GROUP_0 y IP_ADDRESS_AVAILABILITY_GROUP_1.

Envía tráfico al balanceador de cargas

Este procedimiento envía tráfico externo al balanceador de cargas. Ejecuta las siguientes pruebas para verificar que los grupos de instancias ig-us-tcp-80 o ig-eu-tcp-80 balanceen las cargas del tráfico de TCP en el puerto 80, mientras que los grupos de instancias ig-us-l3-default o ig-eu-l3-default balanceen las cargas de todo el resto del tráfico (TCP:8080 y UDP).

Verifica el comportamiento con las solicitudes de TCP en el puerto 80

1. Realiza solicitudes web (a través de TCP en el puerto 80) al balanceador de cargas mediante curl para contactar a su dirección IP.

   • Desde los clientes con conectividad IPv4, ejecuta el siguiente comando:

     while true; do curl -m1 IP_ADDRESS_AVAILABILITY_GROUP_0; done
     

   Ten en cuenta el texto que muestra el comando curl. El texto muestra el nombre de la VM de backend que genera la respuesta, por ejemplo, Page served from: VM_NAME. Las respuestas provienen solo de instancias en los grupos de instancias ig-us-tcp-80 o ig-eu-tcp-80.

   Esto muestra que el tráfico de TCP enviado a la dirección IP del balanceador de cargas en el puerto 80 se controla con la regla de reenvío TCP.

Verifica el comportamiento con las solicitudes de TCP en el puerto 8080

Realiza solicitudes web (a través de TCP en el puerto 8080) al balanceador de cargas con curl para contactar su dirección IP.

• Desde los clientes con conectividad IPv4, ejecuta el siguiente comando:

  while true; do curl -m1 IP_ADDRESS_AVAILABILITY_GROUP_0:8080; done
  

  Ten en cuenta el texto que muestra el comando curl. Las respuestas provienen solo de instancias en los grupos de instancias ig-us-l3-default o ig-eu-l3-default.

  Esto muestra que el tráfico de TCP enviado a la dirección IP del balanceador de cargas en el puerto 8080 se controla con la regla de reenvío L3_DEFAULT.

Verifica la tabla de enrutamiento local para ver las direcciones IP del balanceador de cargas

Las tablas de enrutamiento locales de las VMs de backend contienen las direcciones IP del balanceador de cargas de red de transferencia externo global.

Para verificar las rutas locales en la VM de backend, conéctate a ella a través de SSH y ejecuta el siguiente comando:

  ip route list table local

El resultado es el siguiente:

local 10.1.2.5 dev ens4 proto kernel scope host src 10.1.2.5
local 127.0.0.0/8 dev lo proto kernel scope host src 127.0.0.1
local 127.0.0.1 dev lo proto kernel scope host src 127.0.0.1
broadcast 127.255.255.255 dev lo proto kernel scope link src 127.0.0.1
local 136.124.69.214 dev ens4 proto 66 scope host
local 136.124.83.205 dev ens4 proto 66 scope host

En el ejemplo anterior, 136.124.69.214 y 136.124.83.205 son las direcciones IP asignadas a la regla de reenvío del balanceador de cargas. Las entradas de línea local 136.124.69.214 dev ens4 proto 66 scope host y local 136.124.83.205 dev ens4 proto 66 scope host en la tabla de enrutamiento local de la VM permiten que el backend acepte los paquetes dirigidos a las direcciones IP del balanceador de cargas. El Google Cloud entorno invitado es responsable de agregar esta entrada.

La entrada de la tabla de enrutamiento local en la VM de backend acepta el paquete para la entrega del host local, en la que la pila de red lo entrega a la aplicación en espera. Luego, los paquetes de respuesta de la aplicación se envían directamente al cliente.

Ten en cuenta que la dirección IP del balanceador de cargas no se configura en realidad en la interfaz de red de la VM. Para verificarlo, ejecuta el siguiente comando:

  ip addr list

El resultado es el siguiente. Las direcciones IP (136.124.69.214 y 136.124.83.205) aparecen en la tabla de enrutamiento local, pero no están configuradas en la interfaz de red.

1: lo:  mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
    inet 127.0.0.1/8 scope host lo
       valid_lft forever preferred_lft forever
    inet6 ::1/128 scope host noprefixroute
       valid_lft forever preferred_lft forever
2: ens4:  mtu 1460 qdisc fq_codel state UP group default qlen 1000
    link/ether 42:01:0a:01:02:0d brd ff:ff:ff:ff:ff:ff
    altname enp0s4
    inet 10.1.2.13/32 metric 100 scope global dynamic ens4
       valid_lft 84283sec preferred_lft 84283sec
    inet6 fe80::4001:aff:fe01:20d/64 scope link
       valid_lft forever preferred_lft forever

¿Qué sigue?

• Referencias de la API de Cloud Load Balancing y gcloud CLI gcloud
• Limpia una configuración de balanceo de cargas