Configura un balanceador de cargas de red de transferencia interno con backends de grupos de instancias de VM

En esta guía, se usa un ejemplo para enseñar los aspectos principales de los balanceadores de cargas de red de transferencia internos. Google CloudAntes de seguir esta guía, familiarízate con la siguiente documentación:

Para seguir la guía paso a paso sobre esta tarea directamente en la consola Google Cloud , haz clic en Guiarme:

GUIARME

Permisos

Para seguir esta guía, debes crear instancias y modificar una red en un proyecto. Debes ser propietario o editor de un proyecto o tener todas las siguientes funciones de IAM de Compute Engine:

Tarea Función requerida
Crear redes, subredes y componentes del balanceador de cargas Administrador de red de Compute
(roles/compute.networkAdmin)
Agregar y quitar reglas de firewall Administrador de seguridad de Compute
(roles/compute.securityAdmin)
Crea instancias Administrador de instancias de Compute
(roles/compute.instanceAdmin)

Si deseas obtener más información, consulta las siguientes guías:

Configura el balanceador de cargas con subredes y backends solo para IPv4

En esta guía, se muestra cómo configurar y probar un balanceador de cargas de red de transferencia interno. En esta sección, se explica cómo configurar los siguientes puntos:

  1. Un ejemplo en el que se usa una red de VPC en modo personalizado con el nombre lb-network.
  2. 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.
  3. Reglas de firewall que permiten conexiones entrantes a instancias de máquina virtual (VM) de backend.
  4. El grupo de instancias de backend, que se encuentra en la siguiente región y subred para este ejemplo:
    • Región: us-west1
    • Subred: lb-subnet, con el rango de direcciones IPv4 principal 10.1.2.0/24.
  5. Cuatro VMs de backend: dos VMs en un grupo de instancias no administrado en la zona us-west1-a y dos VMs en un grupo de instancias no administrado en la zona us-west1-c. Para demostrar el acceso global, en este ejemplo, se crea una segunda VM de cliente de prueba en una región y una subred diferentes:
    • Región: europe-west1
    • Subred: europe-subnet, con el rango de direcciones IP principales 10.3.4.0/24
  6. Una VM cliente para probar conexiones.
  7. Los siguientes componentes del balanceador de cargas de red de transferencia interno:
    • Una verificación de estado del servicio de backend.
    • Un servicio de backend interno en la región us-west1 para administrar la distribución de conexiones en los dos grupos de instancias zonales.
    • Una regla de reenvío interno y una dirección IP interna para el frontend del balanceador de cargas.

Así se ve la arquitectura de este ejemplo:

Configuración de ejemplo del balanceador de cargas de red de transferencia interno
Configuración de ejemplo del balanceador de cargas de red de transferencia interno (haz clic para ampliar).

Configura una red, una región y una subred

Para crear la red y la subred de ejemplo, sigue estos pasos:

Console

  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, haz lo siguiente:

    1. Establece Modo de creación de subred en Personalizado.
    2. 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
    3. Haz clic en Listo.
    4. Haz clic en Agregar subred e ingresa la siguiente información:
      • Nombre: europe-subnet
      • Región: europe-west1
      • Tipo de pila IP: IPv4 (pila única)
      • Rangos de direcciones IP: 10.3.4.0/24
    5. Haz clic en Listo.

  5. Haz clic en Crear.

gcloud

  1. Crea la red de VPC personalizada:

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

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

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

  3. En la red lb-network, crea otra subred para probar el acceso global en la región europe-west1:

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

API

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

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks

{
 "routingConfig": {
   "routingMode": "REGIONAL"
 },
 "name": "lb-network",
 "autoCreateSubnetworks": false
}

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
}

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/europe-west1/subnetworks

{
 "name": "europe-subnet",
 "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
  "ipCidrRange": "10.3.4.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 y 10.3.4.0/24. Con esta regla se permite el tráfico entrante desde cualquier cliente ubicado en cualquiera de las dos subredes. Más adelante te permitirá configurar y probar el acceso global.

  • 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 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.

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

Console

  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 el tráfico de subred, haz clic en Crear regla de firewall y, luego, ingresa la siguiente información:

    • Nombre: fw-allow-lb-access
    • Red: lb-network
    • Prioridad: 1000
    • Dirección del tráfico: Entrada
    • Acción en caso de coincidencia: Permitir
    • Objetivos: All instances in the network
    • Filtro de fuente: Rangos de IPv4
    • Rangos de IPv4 de origen: 10.1.2.0/24
    • Protocols y puertos: Permitirlos todos

  3. Haz clic en Crear.

  4. Para permitir conexiones SSH entrantes, vuelve a hacer clic en Crear regla de firewall y, luego, ingresa la siguiente información:

    • Nombre: fw-allow-ssh
    • Red: lb-network
    • Prioridad: 1000
    • Dirección del tráfico: Entrada
    • Acción en caso de coincidencia: Permitir
    • Destinos: 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: Selecciona Protocolos y puertos especificados, elige la casilla de verificación TCP y, luego, ingresa 22 en Puertos

  5. Haz clic en Crear.

  6. Para permitir las verificaciones de estado de Google Cloud , haz clic en Crear regla de firewall por tercera vez y, luego, ingresa la siguiente información:

    • Nombre: fw-allow-health-check
    • Red: lb-network
    • Prioridad: 1000
    • Dirección del tráfico: Entrada
    • Acción en caso de coincidencia: Permitir
    • Destinos: 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
    • Protocols y puertos: Permitirlos todos

  7. Haz clic en Crear.

gcloud

  1. Crea la regla de firewall fw-allow-lb-access para permitir la comunicación desde la subred:

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

  2. Crea la regla de firewall fw-allow-ssh para permitir la conectividad SSH a las VM con 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. Crea la regla 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

API

Crea la regla de firewall fw-allow-lb-access 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",
 "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
 "priority": 1000,
 "sourceRanges": [
   "10.1.2.0/24", "10.3.4.0/24"
 ],
 "allowed": [
   {
     "IPProtocol": "tcp"
   },
   {
     "IPProtocol": "udp"
   },
   {
     "IPProtocol": "icmp"
   }
 ],
 "direction": "INGRESS",
 "logConfig": {
   "enable": false
 },
 "disabled": false
}

Crea la regla de firewall fw-allow-ssh mediante 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
}

Crea la regla de firewall fw-allow-health-check 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",
 "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
}

Crea VMs de backend y grupos de instancias

En este ejemplo se usan dos grupos de instancias no administrados, cada uno con dos VM de backend (servidor). Para demostrar la naturaleza regional de los balanceadores de cargas de red de transferencia internos, los dos grupos de instancias se colocan en zonas diferentes: us-west1-a y us-west1-c.

  • El grupo de instancias ig-a contiene estas dos VM:
    • vm-a1
    • vm-a2
  • El grupo de instancias ig-c contiene estas dos VM:
    • vm-c1
    • vm-c2

El tráfico a las cuatro VM de backend cuenta con balanceo de cargas.

Para admitir este ejemplo y las opciones de configuración adicionales, cada una de las cuatro VM ejecuta un Apache Web Server que escucha en los siguientes puertos TCP: 80, 8008, 8080, 8088, 443 y 8443.

A cada VM se le asigna una dirección IP interna en la lb-subnet y una dirección IP externa (pública) y efímera. Puedes quitar las direcciones IP externas más adelante.

No se requieren direcciones IP externas para las VMs de backend. Sin embargo, son útiles para este ejemplo porque permiten que las VMs de backend descarguen Apache de Internet y pueden conectarse a través de SSH.

De forma predeterminada, Apache está configurado para vincularse a cualquier dirección IP. Los balanceadores de cargas de red de transferencia internos entregan paquetes mediante la preservación de la IP de destino. Asegúrate de que el software del servidor que se ejecuta en las VM de backend escuche la dirección IP de la regla de reenvío interno del balanceador de cargas. Si configuras múltiples reglas de reenvío interno, asegúrate de que el software escuche la dirección IP interna asociada con cada una. La dirección IP de destino de un paquete que un balanceador de cargas de red de transferencia interna entrega a una VM de backend es la dirección IP interna de la regla de reenvío.

Para simplificar el instructivo, estas VMs de backend ejecutan Debian GNU/Linux 12.

Console

Crea VM de backend

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

    Ir a Instancias de VM

  2. Repite los pasos 3 a 8 para cada VM y usa las siguientes combinaciones de nombre y zona.

    • Nombre: vm-a1, zona: us-west1-a
    • Nombre: vm-a2, zona: us-west1-a
    • Nombre: vm-c1, zona: us-west1-c
    • Nombre: vm-c2, zona: us-west1-c

  3. Haz clic en Crear instancia.

  4. En Nombre establece lo que se indica en el paso 2.

  5. En Región, selecciona us-west1 y selecciona una Zona como se indica en el paso 2.

  6. En la sección Disco de arranque, asegúrate de que Debian GNU/Linux 12 (bookWorm) esté seleccionado como las opciones del disco de arranque. Si es necesario, haz clic en Cambiar para cambiar la imagen.

  7. Haz clic en Opciones avanzadas.

  8. Haz clic en Herramientas de redes y configura los siguientes campos:

    1. En Etiquetas de red, ingresa allow-ssh y allow-health-check.
    2. En Interfaces de red, selecciona lo siguiente:
      • Red: lb-network
      • Subred: lb-subnet
      • Tipo de pila IP: IPv4 (pila única)
      • Dirección IPv4 interna principal: efímera (automática)
      • Dirección IPv4 externa:efímera

  9. Haz clic en Administración y, luego, en el campo Secuencia de comandos de inicio, ingresa la siguiente secuencia de comandos. El contenido de secuencia de comandos es idéntico para las cuatro VM.

    
#! /bin/bash
if [ -f /etc/startup_script_completed ]; then
exit 0
fi
apt-get update
apt-get install apache2 -y
a2ensite default-ssl
a2enmod ssl
file_ports="/etc/apache2/ports.conf"
file_http_site="/etc/apache2/sites-available/000-default.conf"
file_https_site="/etc/apache2/sites-available/default-ssl.conf"
http_listen_prts="Listen 80\nListen 8008\nListen 8080\nListen 8088"
http_vh_prts="*:80 *:8008 *:8080 *:8088"
https_listen_prts="Listen 443\nListen 8443"
https_vh_prts="*:443 *:8443"
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
prt_conf="$(cat "$file_ports")"
prt_conf_2="$(echo "$prt_conf" | sed "s|Listen 80|${http_listen_prts}|")"
prt_conf="$(echo "$prt_conf_2" | sed "s|Listen 443|${https_listen_prts}|")"
echo "$prt_conf" | tee "$file_ports"
http_site_conf="$(cat "$file_http_site")"
http_site_conf_2="$(echo "$http_site_conf" | sed "s|*:80|${http_vh_prts}|")"
echo "$http_site_conf_2" | tee "$file_http_site"
https_site_conf="$(cat "$file_https_site")"
https_site_conf_2="$(echo "$https_site_conf" | sed "s|_default_:443|${https_vh_prts}|")"
echo "$https_site_conf_2" | tee "$file_https_site"
systemctl restart apache2
touch /etc/startup_script_completed

  10. Haz clic en Crear.

Crea grupos de instancias

  1. En la consola de Google Cloud , ve a la página Grupos de instancias.

    Ir a Grupos de instancias

  2. Repite estos pasos para crear dos grupos de instancias no administrados, cada uno con dos VM, mediante estas combinaciones.

    • Nombre del grupo de instancias: ig-a, zona: us-west1-a, VMs: vm-a1 y vm-a2
    • Nombre del grupo de instancias: ig-c, zona: us-west1-c, VMs: vm-c1 y vm-c2

  3. Haz clic en Crear grupo de instancias.

  4. Haz clic en Crear un nuevo grupo de instancias no administrado.

  5. Configura Nombre como se indica en el paso 2.

  6. En la sección Ubicación, elige us-west1 para Región y, luego, elige una opción en Zona, como se indica en el paso 2.

  7. En Red, selecciona lb-network

  8. En Subred, selecciona lb-subnet.

  9. En la sección Instancias de VM, agrega las VM como se indica en el paso 2.

  10. Haz clic en Crear.

gcloud

  1. A fin de crear cuatro VM, ejecuta el siguiente comando cuatro veces, con estas cuatro combinaciones para [VM-NAME] y [ZONE]. El contenido de la secuencia de comandos es idéntico para las cuatro VM.

    • VM-NAME: vm-a1, ZONE: us-west1-a
    • VM-NAME: vm-a2, ZONE: us-west1-a
    • VM-NAME: vm-c1, ZONE: us-west1-c
    • VM-NAME: vm-c2, ZONE: us-west1-c
    gcloud compute instances create VM-NAME \
    --zone=ZONE \
    --image-family=debian-12 \
    --image-project=debian-cloud \
    --tags=allow-ssh,allow-health-check \
    --subnet=lb-subnet \
    --metadata=startup-script='#! /bin/bash
if [ -f /etc/startup_script_completed ]; then
exit 0
fi
apt-get update
apt-get install apache2 -y
a2ensite default-ssl
a2enmod ssl
file_ports="/etc/apache2/ports.conf"
file_http_site="/etc/apache2/sites-available/000-default.conf"
file_https_site="/etc/apache2/sites-available/default-ssl.conf"
http_listen_prts="Listen 80\nListen 8008\nListen 8080\nListen 8088"
http_vh_prts="*:80 *:8008 *:8080 *:8088"
https_listen_prts="Listen 443\nListen 8443"
https_vh_prts="*:443 *:8443"
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
prt_conf="$(cat "$file_ports")"
prt_conf_2="$(echo "$prt_conf" | sed "s|Listen 80|${http_listen_prts}|")"
prt_conf="$(echo "$prt_conf_2" | sed "s|Listen 443|${https_listen_prts}|")"
echo "$prt_conf" | tee "$file_ports"
http_site_conf="$(cat "$file_http_site")"
http_site_conf_2="$(echo "$http_site_conf" | sed "s|*:80|${http_vh_prts}|")"
echo "$http_site_conf_2" | tee "$file_http_site"
https_site_conf="$(cat "$file_https_site")"
https_site_conf_2="$(echo "$https_site_conf" | sed "s|_default_:443|${https_vh_prts}|")"
echo "$https_site_conf_2" | tee "$file_https_site"
systemctl restart apache2
touch /etc/startup_script_completed'

  2. Crea los dos grupos de instancias no administrados en cada zona:

    gcloud compute instance-groups unmanaged create ig-a \
    --zone=us-west1-a
gcloud compute instance-groups unmanaged create ig-c \
    --zone=us-west1-c

  3. Agrega las VM a los grupos de instancias adecuados:

    gcloud compute instance-groups unmanaged add-instances ig-a \
    --zone=us-west1-a \
    --instances=vm-a1,vm-a2
gcloud compute instance-groups unmanaged add-instances ig-c \
    --zone=us-west1-c \
    --instances=vm-c1,vm-c2

API

Para las cuatro VM, usa los siguientes nombres de VM y zonas:

  • VM-NAME: vm-a1, ZONE: us-west1-a
  • VM-NAME: vm-a2, ZONE: us-west1-a
  • VM-NAME: vm-c1, ZONE: us-west1-c
  • VM-NAME: vm-c2, ZONE: us-west1-c

Puedes obtener el DEBIAN_IMAGE_NAME actual si ejecutas el siguiente comando de gcloud:

gcloud compute images list \
 --filter="family=debian-12"

Crea cuatro VM de backend mediante cuatro solicitudes POST al método instances.insert:

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances

{
 "name": "VM-NAME",
 "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": [
   {
     "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-NAME",
     "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\nfile_ports=\"/etc/apache2/ports.conf\"\nfile_http_site=\"/etc/apache2/sites-available/000-default.conf\"\nfile_https_site=\"/etc/apache2/sites-available/default-ssl.conf\"\nhttp_listen_prts=\"Listen 80\\nListen 8008\\nListen 8080\\nListen 8088\"\nhttp_vh_prts=\"*:80 *:8008 *:8080 *:8088\"\nhttps_listen_prts=\"Listen 443\\nListen 8443\"\nhttps_vh_prts=\"*:443 *:8443\"\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\nprt_conf=\"$(cat \"$file_ports\")\"\nprt_conf_2=\"$(echo \"$prt_conf\" | sed \"s|Listen 80|${http_listen_prts}|\")\"\nprt_conf=\"$(echo \"$prt_conf_2\" | sed \"s|Listen 443|${https_listen_prts}|\")\"\necho \"$prt_conf\" | tee \"$file_ports\"\nhttp_site_conf=\"$(cat \"$file_http_site\")\"\nhttp_site_conf_2=\"$(echo \"$http_site_conf\" | sed \"s|*:80|${http_vh_prts}|\")\"\necho \"$http_site_conf_2\" | tee \"$file_http_site\"\nhttps_site_conf=\"$(cat \"$file_https_site\")\"\nhttps_site_conf_2=\"$(echo \"$https_site_conf\" | sed \"s|_default_:443|${https_vh_prts}|\")\"\necho \"$https_site_conf_2\" | tee \"$file_https_site\"\nsystemctl restart apache2"
     }
   ]
 },
 "scheduling": {
   "preemptible": false
 },
 "deletionProtection": false
}

Crea dos grupos 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"
}

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

{
 "name": "ig-c",
 "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"
}

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",
     "instance": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instances/vm-a2"
   }
 ]
}

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

{
 "instances": [
   {
     "instance": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-c/instances/vm-c1",
     "instance": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-c/instances/vm-c2"
   }
 ]
}

Configura los componentes del balanceador de cargas

Con estos pasos se configuran todos los componentes del balanceador de cargas de red de transferencia interna; se comienza con la verificación de estado y el servicio de backend y, luego, los componentes de frontend:

  • Verificación de estado: en este ejemplo usamos una verificación de estado de HTTP que comprueba si hay una respuesta HTTP 200 (OK). Para obtener más información, consulta la sección de verificaciones de estado de la descripción general del balanceador de cargas de red de transferencia interna.

  • Servicio de backend: Como necesitamos pasar tráfico HTTP a través del balanceador de cargas interno, debemos usar TCP, no UDP.

  • Regla de reenvío: en este ejemplo se crea una sola regla de reenvío interno.

  • Dirección IP interna: En este ejemplo, se especifica una dirección IP interna, 10.1.2.99, cuando creas la regla de reenvío.

Console

Inicia tu configuración

  1. En la consola de Google Cloud , ve a la página Balanceo de cargas.

    Ir a Balanceo de cargas

  2. Haz clic en Crear balanceador de cargas.
  3. En Tipo de balanceador de cargas, selecciona Balanceador de cargas de red (TCP/UDP/SSL) y haz clic en Siguiente.
  4. En Proxy o de transferencia, selecciona Balanceador de cargas de transferencia y haz clic en Siguiente.
  5. En Orientado al público o interno, selecciona Interno y haz clic en Siguiente.
  6. Haz clic en Configurar.

Configuración básica

En la página Crear un balanceador de cargas de red de transferencia interna, ingresa la siguiente información:

  • Nombre del balanceador de cargas: be-ilb
  • Región: us-west1
  • Red: lb-network

Configura los backends

  1. Haz clic en Configuración de backend.
  2. Para controlar solo el tráfico IPv4, en la sección del Backend nuevo de Backends, selecciona la opción Tipo de pila de IP como IPv4 (pila única).
  3. En Grupo de instancias, elige el grupo de instancias ig-c y haz clic en Listo.
  4. Haz clic en Agregar backend y repite este paso para agregar ig-a.

  5. En el menú desplegable Verificación de estado, elige Crear una verificación de estado, ingresa la siguiente información y haz clic en Guardar.

    • Nombre: hc-http-80
    • Protocolo: HTTP
    • Puerto: 80
    • Protocolo de proxy: NONE
    • Ruta de la solicitud: /

    Ten en cuenta que, cuando usas la consola de Google Cloud para crear el balanceador de cargas, la verificación de estado es global. Si quieres crear una verificación de estado regional, usa gcloud o la API.

  6. Verifica que haya una marca de verificación azul junto a Configuración de backend antes de continuar.

Configura el frontend

  1. Haz clic en Configuración de frontend.
  2. En la sección IP y puerto de frontend nuevos, haz lo siguiente:
    1. En Nombre, ingresa fr-ilb.
    2. En Subred, selecciona lb-subnet.
    3. En el Propósito de la IP interna, en la lista de Direcciones IP, seleccionar Crear dirección IP, ingresa la siguiente información y, luego, haz clic en Reservar.
      • Nombre: ip-ilb
      • Versión de IP: IPv4
      • Dirección IP estática: permíteme elegir
      • Dirección IP personalizada: 10.1.2.99
    4. En Puertos, selecciona Varios y, luego, en Números de puerto, ingresa 80, 8008, 8080 y 8088.
    5. Verifica que haya una marca de verificación azul junto a Configuración de frontend antes de continuar.

Revisa la configuración

  1. Haz clic en Revisar y finalizar.
  2. Revisa la configuración del balanceador de cargas.
  3. Opcional: Haz clic en Código equivalente a fin de ver la solicitud a la API de REST que se usará para crear el balanceador de cargas.
  4. Haz clic en Crear.

gcloud

  1. Crea una verificación de estado HTTP regional nueva para probar la conectividad HTTP a las VM en 80.

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

  2. Crea el servicio de backend para el tráfico HTTP:

    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

  3. Agrega los dos grupos 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
gcloud compute backend-services add-backend be-ilb \
    --region=us-west1 \
    --instance-group=ig-c \
    --instance-group-zone=us-west1-c

  4. Crea una regla de reenvío para el servicio de backend. Cuando crees la regla de reenvío, especifica 10.1.2.99 como la dirección IP interna en la subred.

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

API

Para crear la verificación de estado, realiza una solicitud POST al método regionHealthChecks.insert.

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

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

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",
"backends": [
  {
    "group": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instanceGroups/ig-a",
    "balancingMode": "CONNECTION"
  },
  {
    "group": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-c/instanceGroups/ig-c",
    "balancingMode": "CONNECTION"
  }
],
"healthChecks": [
  "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/healthChecks/hc-http-80"
],
"loadBalancingScheme": "INTERNAL",
"connectionDraining": {
  "drainingTimeoutSec": 0
 }
}

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",
"IPAddress": "10.1.2.99",
"IPProtocol": "TCP",
"ports": [
  "80", "8008", "8080", "8088"
],
"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"
}

Prueba el balanceador de cargas

Mediante estas pruebas se muestra cómo validar la configuración del balanceador de cargas y conocer su comportamiento esperado.

Crear una VM de cliente

En este ejemplo se crea una VM de cliente (vm-client) 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.

Console

  1. En la Google Cloud consola, 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 Región, selecciona us-west1..

  5. En Zona, selecciona us-west1-a.

  6. Haz clic en Opciones avanzadas.

  7. Haz clic en Herramientas de redes y 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

  8. 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-12 \
    --image-project=debian-cloud \
    --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",
 "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
}

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. El comportamiento esperado consiste en que el tráfico se distribuya entre las cuatro VM de backend porque no se configuró ninguna afinidad de sesión.

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

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

  2. 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 VM 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. Por ejemplo, las respuestas esperadas tienen el aspecto Page served from: vm-a1 y Page served from: vm-a2.

    curl http://10.1.2.99

    La regla de reenvío está configurada para entregar en los puertos 80, 8008, 8080 y 8088. 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:8008

    Si agregas una etiqueta de servicio a la regla de reenvío interno, puedes usar DNS interno para contactar al balanceador de cargas con su nombre de servicio.

      curl http://web-test.fr-ilb.il4.us-west1.lb.PROJECT_ID.internal

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

En esta prueba se demuestra un comportamiento esperado: no puedes hacer ping a la dirección IP del balanceador de cargas. Esto se debe a que los balanceadores de cargas de red de transferencia interno se implementan en la programación de red virtual. No son dispositivos diferentes.

  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 IP del balanceador de cargas. Ten en cuenta que no recibirás una respuesta y que se agotará el tiempo de espera del comando ping después de 10 segundos en este ejemplo.

    timeout 10 ping 10.1.2.99

Envía solicitudes desde VMs con balanceo de cargas

En esta prueba se demuestra que cuando una VM de backend envía paquetes a la dirección IP de la regla de reenvío de su balanceador de cargas, esas solicitudes se enrutan de vuelta a sí mismas. Esto sucede sin importar el estado de la verificación de estado de la VM de backend.

Los balanceadores de cargas de red de transferencia internos se implementan mediante la programación de red virtual y la configuración de VM en el SO invitado. En las VMs de Linux, el entorno invitado crea una ruta para la dirección IP del balanceador de cargas en la tabla de enrutamiento local del sistema operativo.

Debido a que esta ruta local está dentro de la VM (no en la ruta de la red de VPC), la red de VPC no procesa los paquetes enviados a la dirección IP del balanceador de cargas. En su lugar, los paquetes enviados a la dirección IP del balanceador de cargas permanecen dentro del sistema operativo de la VM.

  1. Conéctate a una VM de backend, como vm-a1:

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

  2. Realiza una solicitud web al balanceador de cargas (por dirección IP o nombre del servicio) mediante curl. La respuesta proviene de la misma VM de backend que realiza la solicitud. Las solicitudes repetidas se responden de la misma manera. La respuesta esperada cuando se realiza una prueba desde vm-a1 siempre es Page served from: vm-a1.

    curl http://10.1.2.99

  3. Inspecciona la tabla de enrutamiento local en busca de un destino que coincida con la dirección IP del balanceador de cargas, 10.1.2.99. Esta ruta es una parte necesaria del balanceador de cargas de red de transferencia interno, pero también demuestra por qué una solicitud desde una VM detrás del balanceador de cargas siempre recibe respuestas de la misma VM.

    ip route show table local | grep 10.1.2.99

Cuando una VM de backend para un balanceador de cargas de red de transferencia interno envía paquetes a la dirección IP de la regla de reenvío del balanceador de cargas, los paquetes siempre se enrutan de vuelta a la VM que realiza la solicitud. Esto se debe a que un balanceador de cargas de red de transferencia interno es un balanceador de cargas de transferencia y se implementa mediante la creación de una ruta local para la dirección IP del balanceador de cargas dentro del SO invitado de la VM, como se indica en esta sección. Si tienes un caso de uso en el que los backends con balanceo de cargas deben enviar el tráfico de TCP a la dirección IP del balanceador de cargas y necesitas que el tráfico se distribuya como si se originara desde una carga que no es de carga, se recomienda usar un balanceador de cargas de red del proxy interno regional en su lugar.

Para obtener más información, consulta Balanceadores de cargas de red de transferencia internos como próximos saltos.

Configura el balanceador de cargas con subredes y backends de pila doble

En este documento, se muestra cómo configurar y probar un balanceador de cargas de red de transferencia interno que admite tráfico IPv4 e IPv6. En los pasos de esta sección, se describe cómo configurar los siguientes elementos:

  1. En el ejemplo de esta página, se usa una red de VPC en modo personalizado con el nombre lb-network-dual-stack. El tráfico IPv6 requiere una subred de modo personalizado.
  2. Una subred de pila doble (stack-type configurado como IPv4_IPv6), que es obligatoria para el tráfico IPv6. Cuando creas una subred de pila doble 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. Para obtener instrucciones, consulta la documentación de VPC sobre Agrega una subred de pila doble.
  3. Reglas de firewall que permiten conexiones entrantes a VMs de backend.
  4. El grupo de instancias de backend, que se encuentra en la siguiente región y subred para este ejemplo:
    • 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 configurar en la subred, el rango de direcciones IPv6 se asigna automáticamente. Google proporciona un bloque CIDR IPv6 de tamaño fijo (/64).
  5. Cuatro VMs de pila doble de backend: dos VMs en un grupo de instancias no administrado en la zona us-west1-a y dos VMs en un grupo de instancias no administrado en la zona us-west1-c. Para demostrar el acceso global, en este ejemplo, se crea una segunda VM de cliente de prueba en una región y una subred diferentes:
    • Región: europe-west1
    • Subred: europe-subnet, con el rango de direcciones IP principales 10.3.4.0/24
  6. Una VM cliente para probar conexiones.
  7. Los siguientes componentes del balanceador de cargas de red de transferencia interno:
    • Una verificación de estado del servicio de backend.
    • Un servicio de backend interno en la región us-west1 para administrar la distribución de conexiones en los dos grupos de instancias zonales.
    • Dos reglas de reenvío interno para el frontend del balanceador de cargas.

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

Una red de VPC de pila doble con un servicio de backend para administrar la distribución de la conexión a dos grupos de instancias zonales.
Configuración de ejemplo del balanceador de cargas de red de transferencia interno (haz clic para ampliar)

Configura una red, una región y una subred

El ejemplo del balanceador de cargas de red de transferencia interno descrito en esta página se crea en una red de VPC de modo personalizado llamada lb-network-dual-stack.

Para configurar subredes con rangos de IPv6 internos, habilita un rango de IPv6 interno de ULA de la red de VPC. Los rangos de subredes IPv6 internas se asignan a partir de este rango.

Console

  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-dual-stack.

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

    1. En Configuración de la dirección IPv6 privada, selecciona Configurar un rango de IPv6 interno de ULA para esta red de VPC.
    2. En Asignar rango de IPv6 interno, selecciona Automáticamente o Manualmente. Si seleccionas Manualmente, ingresa un rango /48 que pertenezca al rango fd20::/20. Si el rango está en uso, se te solicitará que proporciones un rango diferente.

  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:

    • Nombre: lb-subnet
    • Región: us-west1
    • Tipo de pila IP: IPv4 e IPv6 (pila doble)
    • Rango IPv4: 10.1.2.0/24.
    • Tipo de acceso IPv6: Interno

  7. Haz clic en Listo.

  8. Haz clic en Agregar subred e ingresa la siguiente información:

    • Nombre: europe-subnet
    • Región: europe-west1
    • Tipo de pila IP: IPv4 (pila única)
    • Rangos de direcciones IP: 10.3.4.0/24

  9. Haz clic en Listo.

  10. Haz clic en Crear.

gcloud

  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 Cloud para los rangos de subred IPv6 internos. Si deseas seleccionar el rango de IPv6 /48 que se asigna, usa la marca --internal-ipv6-range para especificar un rango.

    gcloud compute networks create lb-network-dual-stack \
 --subnet-mode=custom \
 --enable-ula-internal-ipv6 \
 --internal-ipv6-range=ULA_IPV6_RANGE \
 --bgp-routing-mode=regional

    Reemplaza ULA_IPV6_RANGE por un prefijo /48 que pertenezca al rango fd20::/20 que usa Google para los rangos de subred IPv6 internos. Si no usas la marca --internal-ipv6-range, Google selecciona un prefijo /48 para la red, como fd20:bc7:9a1c::/48.

  2. Dentro de la red NETWORK, crea una subred para backends en la región us-west1 y otra subred a fin de probar el acceso global en la región europe-west1.

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

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

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

API

Crea una nueva red de VPC en modo personalizado.

Para configurar rangos IPv6 internos en cualquier subred de esta red, configura enableUlaInternalIpv6 como verdadero. Esta opción asigna un rango /48 que pertenece al rango fd20::/20 que usa Google para los rangos de subred IPv6 internos. Si deseas seleccionar el rango de IPv6 /48 que se asigna, también usa el campo internalIpv6Range para especificar un rango.

 POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks
 {
   "autoCreateSubnetworks": false,
   "name": "lb-network-dual-stack",
   "mtu": MTU,
   "enableUlaInternalIpv6": true,
   "internalIpv6Range": "ULA_IPV6_RANGE",
   "routingConfig": {
   "routingMode": "DYNAMIC_ROUTING_MODE"
  }
 }

Reemplaza lo siguiente:

  • PROJECT_ID: es el ID del proyecto en el que se crea la red de VPC.
  • MTU: es la unidad de transmisión máxima de la red. Puede ser 1460 (predeterminada) o 1500. Revisa la descripción general de la unidad de transmisión máxima antes de configurar la MTU como 1500.
  • ULA_IPV6_RANGE: es un prefijo /48 desde el rango fd20::/20 que usa Google para los rangos de subred IPv6 internos. Si no proporcionas un valor para internalIpv6Range, Google selecciona un prefijo /48 para la red.

  • DYNAMIC_ROUTING_MODE: Es global o regional para controlar el comportamiento del anuncio de ruta de Cloud Routers en la red. Para obtener más información, consulta Modo de enrutamiento dinámico.

    Para obtener más información, consulta el método networks.insert.

Realiza dos solicitudes 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-dual-stack",
   "name": "lb-subnet"
   "stackType": IPV4_IPV6,
   "ipv6AccessType": Internal
 }
 

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

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 y 10.3.4.0/24. Con esta regla se permite el tráfico entrante desde cualquier cliente ubicado en cualquiera de las dos subredes. Más adelante, puedes configurar y probar el acceso global.

  • 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 entrante de IPv6 desde cualquier cliente ubicado en cualquiera de las dos subredes. Más adelante, puedes configurar y probar el acceso global.

  • 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 que inicias 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 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.

Console

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

    Ir a Políticas de firewall

  2. Para crear la regla que permite el tráfico de subred, haz clic en Crear regla de firewall y, luego, ingresa la siguiente información:

    • Nombre: fw-allow-lb-access
    • Red: lb-network-dual-stack
    • Prioridad: 1000
    • Dirección del tráfico: Entrada
    • Acción en caso de coincidencia: Permitir
    • Objetivos: All instances in the network
    • Filtro de fuente: Rangos de IPv4
    • Rangos de IPv4 de origen: 10.1.2.0/24 y 10.3.4.0/24
    • Protocols y puertos: Permitirlos todos

  3. Haz clic en Crear.

  4. Para permitir el tráfico de subred de IPv6, vuelve a hacer clic en Crear regla de firewall y, luego, ingresa la siguiente información:

    • Nombre: fw-allow-lb-access-ipv6
    • Red: lb-network-dual-stack
    • Prioridad: 1000
    • Dirección del tráfico: Entrada
    • Acción en caso de coincidencia: Permitir
    • Objetivos: All instances in the network
    • Filtro de fuente: Rangos de IPv6
    • Rangos de IPv6 de origen: IPV6_ADDRESS asignados en lb-subnet
    • Protocols y puertos: Permitirlos todos

  5. Haz clic en Crear.

  6. Para permitir conexiones SSH entrantes, vuelve a hacer clic en Crear regla de firewall y, luego, ingresa la siguiente información:

    • Nombre: fw-allow-ssh
    • Red: lb-network-dual-stack
    • Prioridad: 1000
    • Dirección del tráfico: Entrada
    • Acción en caso de coincidencia: Permitir
    • Destinos: 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: Selecciona Protocolos y puertos especificados, elige la casilla de verificación TCP y, luego, ingresa 22 en Puertos

  7. Haz clic en Crear.

  8. Para permitir las Google Cloud verificaciones de estado de IPv6, vuelve a hacer clic en Crear regla de firewall y, luego, ingresa la siguiente información:

    • Nombre: fw-allow-health-check-ipv6
    • Red: lb-network-dual-stack
    • Prioridad: 1000
    • Dirección del tráfico: Entrada
    • Acción en caso de coincidencia: Permitir
    • Destinos: 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
    • Protocols y puertos: Permitirlos todos

  9. Haz clic en Crear.

  10. Para permitir las verificaciones de estado de Google Cloud , vuelve a hacer clic en Crear regla de firewall y, luego, ingresa la siguiente información:

    • Nombre: fw-allow-health-check
    • Red: lb-network-dual-stack
    • Prioridad: 1000
    • Dirección del tráfico: Entrada
    • Acción en caso de coincidencia: Permitir
    • Destinos: 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
    • Protocols y puertos: Permitirlos todos

  11. Haz clic en Crear.

gcloud

  1. Crea la regla de firewall fw-allow-lb-access para permitir la comunicación con la subred:

    gcloud compute firewall-rules create fw-allow-lb-access \
    --network=lb-network-dual-stack \
    --action=allow \
    --direction=ingress \
    --source-ranges=10.1.2.0/24,10.3.4.0/24 \
    --rules=all

  2. Crea la regla de firewall fw-allow-lb-access-ipv6 para permitir la comunicación con la subred:

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

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

  3. Crea la regla de firewall fw-allow-ssh para permitir la conectividad SSH a las VM con 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-dual-stack \
    --action=allow \
    --direction=ingress \
    --target-tags=allow-ssh \
    --rules=tcp:22

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

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

  5. Crea la regla 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-dual-stack \
    --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

API

  1. Crea la regla de firewall fw-allow-lb-access 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",
"network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network-dual-stack",
"priority": 1000,
"sourceRanges": [
  "10.1.2.0/24", "10.3.4.0/24"
],
"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-dual-stack",
 "priority": 1000,
 "sourceRanges": [
   "IPV6_ADDRESS"
 ],
 "allowed": [
   {
      "IPProtocol": "tcp"
    },
    {
      "IPProtocol": "udp"
    },
    {
      "IPProtocol": "icmp"
    }
 ],
 "direction": "INGRESS",
 "logConfig": {
    "enable": false
 },
 "disabled": false
}

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

  3. Crea la regla de firewall fw-allow-ssh mediante 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-dual-stack",
"priority": 1000,
"sourceRanges": [
  "0.0.0.0/0"
],
"targetTags": [
  "allow-ssh"
],
"allowed": [
 {
   "IPProtocol": "tcp",
   "ports": [
     "22"
   ]
 }
],
"direction": "INGRESS",
"logConfig": {
 "enable": false
},
"disabled": false
}

  4. 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-dual-stack",
"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
}

  5. Crea la regla de firewall fw-allow-health-check 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",
"network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network-dual-stack",
"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
}

Crea VMs de backend y grupos de instancias

En este ejemplo se usan dos grupos de instancias no administrados, cada uno con dos VM de backend (servidor). Para demostrar la naturaleza regional de los balanceadores de cargas de red de transferencia internos, los dos grupos de instancias se colocan en zonas diferentes: us-west1-a y us-west1-c.

  • El grupo de instancias ig-a contiene estas dos VM:
    • vm-a1
    • vm-a2
  • El grupo de instancias ig-c contiene estas dos VM:
    • vm-c1
    • vm-c2

El tráfico a las cuatro VM de backend cuenta con balanceo de cargas.

Para admitir este ejemplo y las opciones de configuración adicionales, cada una de las cuatro VM ejecuta un Apache Web Server que escucha en los siguientes puertos TCP: 80,8008, 8080, 8088, 443 y 8443.

A cada VM se le asigna una dirección IP interna en la lb-subnet y una dirección IP externa (pública) y efímera. Puedes quitar las direcciones IP externas más adelante.

No se requieren direcciones IP externas para las VMs de backend. Sin embargo, son útiles para este ejemplo porque permiten que las VMs de backend descarguen Apache de Internet y pueden conectarse a través de SSH.

De forma predeterminada, Apache está configurado para vincularse a cualquier dirección IP. Los balanceadores de cargas de red de transferencia internos entregan paquetes mediante la preservación de la IP de destino.

Asegúrate de que el software del servidor que se ejecuta en las VM de backend escuche la dirección IP de la regla de reenvío interno del balanceador de cargas. Si configuras múltiples reglas de reenvío interno, asegúrate de que el software escuche la dirección IP interna asociada con cada una. La dirección IP de destino de un paquete que un balanceador de cargas de red de transferencia interna entrega a una VM de backend es la dirección IP interna de la regla de reenvío.

Si usas grupos de instancias administrados, asegúrate de que el tipo de pila de la subred coincida con el tipo de pila de las plantillas de instancias que usan los grupos de instancias administrados. La subred debe ser de pila doble si el grupo de instancias administrado usa una plantilla de instancias de pila doble.

Para simplificar el instructivo, estas VMs de backend ejecutan Debian GNU/Linux 12.

Console

Crea VM de backend

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

    Ir a Instancias de VM

  2. Repite los pasos 3 a 8 para cada VM y usa las siguientes combinaciones de nombre y zona.

    • Nombre: vm-a1, zona: us-west1-a
    • Nombre: vm-a2, zona: us-west1-a
    • Nombre: vm-c1, zona: us-west1-c
    • Nombre: vm-c2, zona: us-west1-c

  3. Haz clic en Crear instancia.

  4. En Nombre establece lo que se indica en el paso 2.

  5. En Región, selecciona us-west1 y selecciona una Zona como se indica en el paso 2.

  6. En la sección Disco de arranque, asegúrate de que Debian GNU/Linux 12 (bookWorm) esté seleccionado como las opciones del disco de arranque. Si es necesario, haz clic en Cambiar para cambiar la imagen.

  7. Haz clic en Opciones avanzadas.

  8. Haz clic en Herramientas de redes y configura los siguientes campos:

    1. En Etiquetas de red, ingresa allow-ssh y allow-health-check-ipv6.
    2. En Interfaces de red, selecciona lo siguiente:
      • Red: lb-network-dual-stack
      • Subred: lb-subnet
      • Tipo de pila IP: IPv4 e IPv6 (pila doble)
      • Dirección IPv4 interna principal: efímera (automática)
      • Dirección IPv4 externa:efímera

    3. Haz clic en Administración y, luego, en el campo Secuencia de comandos de inicio, ingresa la siguiente secuencia de comandos. El contenido de secuencia de comandos es idéntico para las cuatro VM.

      #! /bin/bash
if [ -f /etc/startup_script_completed ]; then
exit 0
fi
apt-get update
apt-get install apache2 -y
a2ensite default-ssl
a2enmod ssl
file_ports="/etc/apache2/ports.conf"
file_http_site="/etc/apache2/sites-available/000-default.conf"
file_https_site="/etc/apache2/sites-available/default-ssl.conf"
http_listen_prts="Listen 80\nListen 8008\nListen 8080\nListen 8088"
http_vh_prts="*:80 *:8008 *:8080 *:8088"
https_listen_prts="Listen 443\nListen 8443"
https_vh_prts="*:443 *:8443"
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
prt_conf="$(cat "$file_ports")"
prt_conf_2="$(echo "$prt_conf" | sed "s|Listen 80|${http_listen_prts}|")"
prt_conf="$(echo "$prt_conf_2" | sed "s|Listen 443|${https_listen_prts}|")"
echo "$prt_conf" | tee "$file_ports"
http_site_conf="$(cat "$file_http_site")"
http_site_conf_2="$(echo "$http_site_conf" | sed "s|*:80|${http_vh_prts}|")"
echo "$http_site_conf_2" | tee "$file_http_site"
https_site_conf="$(cat "$file_https_site")"
https_site_conf_2="$(echo "$https_site_conf" | sed "s|_default_:443|${https_vh_prts}|")"
echo "$https_site_conf_2" | tee "$file_https_site"
systemctl restart apache2
touch /etc/startup_script_completed

  9. Haz clic en Crear.

Crea grupos de instancias

  1. En la consola de Google Cloud , ve a la página Grupos de instancias.

    Ir a Grupos de instancias

  2. Repite estos pasos para crear dos grupos de instancias no administrados, cada uno con dos VM, mediante estas combinaciones.

    • Nombre del grupo de instancias: ig-a, zona: us-west1-a, VMs: vm-a1 y vm-a2
    • Nombre del grupo de instancias: ig-c, zona: us-west1-c, VMs: vm-c1 y vm-c2

  3. Haz clic en Crear grupo de instancias.

  4. Haz clic en Crear un nuevo grupo de instancias no administrado.

  5. Configura Nombre como se indica en el paso 2.

  6. En la sección Ubicación, elige us-west1 para Región y, luego, elige una opción en Zona, como se indica en el paso 2.

  7. En Red, selecciona lb-network-dual-stack.

  8. En Subred, selecciona lb-subnet.

  9. En la sección Instancias de VM, agrega las VM como se indica en el paso 2.

  10. Haz clic en Crear.

gcloud

  1. A fin de crear cuatro VMs, ejecuta el comando gcloud compute instances create cuatro veces, con estas cuatro combinaciones para [VM-NAME] y [ZONE]. El contenido de la secuencia de comandos es idéntico para las cuatro VM.

    • VM-NAME: vm-a1, ZONE: us-west1-a
    • VM-NAME: vm-a2, ZONE: us-west1-a
    • VM-NAME: vm-c1, ZONE: us-west1-c

    • VM-NAME: vm-c2, ZONE: us-west1-c

      gcloud compute instances create VM-NAME \
  --zone=ZONE \
  --image-family=debian-12 \
  --image-project=debian-cloud \
  --tags=allow-ssh,allow-health-check-ipv6 \
  --subnet=lb-subnet \
  --stack-type=IPV4_IPV6 \
  --metadata=startup-script='#! /bin/bash
if [ -f /etc/startup_script_completed ]; then
exit 0
fi
apt-get update
apt-get install apache2 -y
a2ensite default-ssl
a2enmod ssl
file_ports="/etc/apache2/ports.conf"
file_http_site="/etc/apache2/sites-available/000-default.conf"
file_https_site="/etc/apache2/sites-available/default-ssl.conf"
http_listen_prts="Listen 80\nListen 8008\nListen 8080\nListen 8088"
http_vh_prts="*:80 *:8008 *:8080 *:8088"
https_listen_prts="Listen 443\nListen 8443"
https_vh_prts="*:443 *:8443"
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
prt_conf="$(cat "$file_ports")"
prt_conf_2="$(echo "$prt_conf" | sed "s|Listen 80|${http_listen_prts}|")"
prt_conf="$(echo "$prt_conf_2" | sed "s|Listen 443|${https_listen_prts}|")"
echo "$prt_conf" | tee "$file_ports"
http_site_conf="$(cat "$file_http_site")"
http_site_conf_2="$(echo "$http_site_conf" | sed "s|*:80|${http_vh_prts}|")"
echo "$http_site_conf_2" | tee "$file_http_site"
https_site_conf="$(cat "$file_https_site")"
https_site_conf_2="$(echo "$https_site_conf" | sed "s|_default_:443|${https_vh_prts}|")"
echo "$https_site_conf_2" | tee "$file_https_site"
systemctl restart apache2
touch /etc/startup_script_completed'

  2. Crea los dos grupos de instancias no administrados en cada zona:

    gcloud compute instance-groups unmanaged create ig-a \
    --zone=us-west1-a
gcloud compute instance-groups unmanaged create ig-c \
    --zone=us-west1-c

  3. Agrega las VM a los grupos de instancias adecuados:

    gcloud compute instance-groups unmanaged add-instances ig-a \
    --zone=us-west1-a \
    --instances=vm-a1,vm-a2
gcloud compute instance-groups unmanaged add-instances ig-c \
    --zone=us-west1-c \
    --instances=vm-c1,vm-c2

api

Para las cuatro VM, usa los siguientes nombres de VM y zonas:

  • VM-NAME: vm-a1, ZONE: us-west1-a
  • VM-NAME: vm-a2, ZONE: us-west1-a
  • VM-NAME: vm-c1, ZONE: us-west1-c
  • VM-NAME: vm-c2, ZONE: us-west1-c

Puedes obtener el DEBIAN_IMAGE_NAME actual si ejecutas el siguiente comando de gcloud:

gcloud compute images list \
 --filter="family=debian-12"

Crea cuatro VM de backend mediante cuatro solicitudes POST al método instances.insert:

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances

{
 "name": "VM-NAME",
 "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-dual-stack",
     "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-NAME",
     "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\nfile_ports=\"/etc/apache2/ports.conf\"\nfile_http_site=\"/etc/apache2/sites-available/000-default.conf\"\nfile_https_site=\"/etc/apache2/sites-available/default-ssl.conf\"\nhttp_listen_prts=\"Listen 80\\nListen 8008\\nListen 8080\\nListen 8088\"\nhttp_vh_prts=\"*:80 *:8008 *:8080 *:8088\"\nhttps_listen_prts=\"Listen 443\\nListen 8443\"\nhttps_vh_prts=\"*:443 *:8443\"\nvm_hostname=\"$(curl -H \"Metadata-Flavor:Google\" \\\nhttp://169.254.169.254/computeMetadata/v1/instance/name)\"\necho \"Page served from: $vm_hostname\" | \\\ntee /var/www/html/index.html\nprt_conf=\"$(cat \"$file_ports\")\"\nprt_conf_2=\"$(echo \"$prt_conf\" | sed \"s|Listen 80|${http_listen_prts}|\")\"\nprt_conf=\"$(echo \"$prt_conf_2\" | sed \"s|Listen 443|${https_listen_prts}|\")\"\necho \"$prt_conf\" | tee \"$file_ports\"\nhttp_site_conf=\"$(cat \"$file_http_site\")\"\nhttp_site_conf_2=\"$(echo \"$http_site_conf\" | sed \"s|*:80|${http_vh_prts}|\")\"\necho \"$http_site_conf_2\" | tee \"$file_http_site\"\nhttps_site_conf=\"$(cat \"$file_https_site\")\"\nhttps_site_conf_2=\"$(echo \"$https_site_conf\" | sed \"s|_default_:443|${https_vh_prts}|\")\"\necho \"$https_site_conf_2\" | tee \"$file_https_site\"\nsystemctl restart apache2"
     }
   ]
 },
 "scheduling": {
   "preemptible": false
 },
 "deletionProtection": false
}

Crea dos grupos 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-dual-stack",
 "subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet"
}

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

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

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",
     "instance": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instances/vm-a2"
   }
 ]
}

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

{
 "instances": [
   {
     "instance": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-c/instances/vm-c1",
     "instance": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-c/instances/vm-c2"
   }
 ]
}

Configura los componentes del balanceador de cargas

Con estos pasos se configuran todos los componentes del balanceador de cargas de red de transferencia interna; se comienza con la verificación de estado y el servicio de backend y, luego, los componentes de frontend:

  • Verificación de estado: en este ejemplo usamos una verificación de estado de HTTP que comprueba si hay una respuesta HTTP 200 (OK). Para obtener más información, consulta la sección de verificaciones de estado de la descripción general del balanceador de cargas de red de transferencia interno.

  • Servicio de backend: Como necesitamos pasar tráfico HTTP a través del balanceador de cargas interno, debemos usar TCP, no UDP.

  • Regla de reenvío: en este ejemplo se crean dos reglas de reenvío internas para el tráfico IPv4 e IPv6.

  • Dirección IP interna: en este ejemplo, se especifica una dirección IP interna, 10.1.2.99, cuando creas la regla de reenvío IPv4. Para obtener más información, consulta Dirección IP interna. Aunque elijas qué dirección IPv4 se configurará, la dirección IPv6 se asignará de forma automática.

Console

Inicia tu configuración

  1. En la consola de Google Cloud , ve a la página Balanceo de cargas.

    Ir a Balanceo de cargas

  2. Haz clic en Crear balanceador de cargas.
  3. En Tipo de balanceador de cargas, selecciona Balanceador de cargas de red (TCP/UDP/SSL) y haz clic en Siguiente.
  4. En Proxy o de transferencia, selecciona Balanceador de cargas de transferencia y haz clic en Siguiente.
  5. En Orientado al público o interno, selecciona Interno y haz clic en Siguiente.
  6. Haz clic en Configurar.

Configuración básica

En la página Crear un balanceador de cargas de red de transferencia interna, ingresa la siguiente información:

  • Nombre del balanceador de cargas: be-ilb
  • Región: us-west1
  • Red: lb-network-dual-stack

Configuración de backend

  1. Haz clic en Configuración de backend.
  2. En la sección Backend nuevo de Backends, selecciona el Tipo de pila de IP como IPv4 e IPv6 (pila doble).
  3. En Grupo de instancias, elige el grupo de instancias ig-a y haz clic en Listo.
  4. Haz clic en Agregar backend y repite este paso para agregar ig-c.
  5. En el menú desplegable Verificación de estado, elige Crear una verificación de estado, ingresa la siguiente información y haz clic en Guardar:
    • Nombre: hc-http-80.
    • Permiso: Regional.
    • Protocolo: HTTP.
    • Puerto: 80.
    • Protocolo de proxy: NONE.
    • Ruta de la solicitud: /.
  6. Verifica que aparezca una marca de verificación azul junto a Configuración de backend.

Configuración de frontend

  1. Haz clic en Configuración de frontend. En la sección IP y puerto de frontend nuevos, haz lo siguiente:
    1. En Nombre, ingresa fr-ilb-ipv6.
    2. Para controlar el tráfico IPv6, haz lo siguiente:
      1. En Versión de la IP, selecciona IPv6.
      2. En Subred, selecciona lb-subnet. El rango de direcciones IPv6 en la regla de reenvío siempre es efímero.
      3. En Puertos, selecciona Varios y, luego, en el campo Número de puerto, ingresa 80,8008,8080,8088.
      4. Haz clic en Listo.
    3. Para controlar el tráfico IPv4, haz lo siguiente:
      1. Haz clic en Agregar IP y puerto de frontend.
      2. En Nombre, ingresa fr-ilb.
      3. En Subred, selecciona lb-subnet.
      4. En el Propósito de la IP interna, en la lista de Direcciones IP, seleccionar Crear dirección IP, ingresa la siguiente información y, luego, haz clic en Reservar.
        • Nombre: ip-ilb
        • Versión de IP: IPv4
        • Dirección IP estática: permíteme elegir
        • Dirección IP personalizada: 10.1.2.99
      5. En Puertos, selecciona Varios y, luego, en Números de puerto, ingresa 80,8008,8080 y, 8088
      6. Haz clic en Listo.
      7. Verifica que haya una marca de verificación azul junto a Configuración de frontend antes de continuar.

Revisa la configuración

  1. Haz clic en Revisar y finalizar. Comprueba toda la configuración.
  2. Si la configuración es correcta, haz clic en Crear. La creación del balanceador de cargas de red de transferencia interno tarda unos minutos.

gcloud

  1. Crea una verificación de estado HTTP regional nueva para probar la conectividad HTTP a las VM en 80.

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

  2. Crea el servicio de backend para el tráfico HTTP:

    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

  3. Agrega los dos grupos 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
gcloud compute backend-services add-backend be-ilb \
    --region=us-west1 \
    --instance-group=ig-c \
    --instance-group-zone=us-west1-c

  4. Crea dos reglas de reenvío para el servicio de backend. Cuando crees la regla de reenvío de IPv4, especifica 10.1.2.99 para la dirección IP interna en la subred de las direcciones IPv4.

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

    gcloud compute forwarding-rules create fr-ilb-ipv6 \
    --region=us-west1 \
    --load-balancing-scheme=internal \
    --subnet=lb-subnet \
    --ip-protocol=TCP \
    --ports=80,8008,8080,8088 \
    --backend-service=be-ilb \
    --backend-service-region=us-west1 \
    --ip-version=IPV6

api

Para crear la verificación de estado, realiza una solicitud POST al método regionHealthChecks.insert.

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

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

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",
"backends": [
  {
    "group": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instanceGroups/ig-a",
    "balancingMode": "CONNECTION"
  },
  {
    "group": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-c/instanceGroups/ig-c",
    "balancingMode": "CONNECTION"
  }
],
"healthChecks": [
  "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/healthChecks/hc-http-80"
],
"loadBalancingScheme": "INTERNAL",
"connectionDraining": {
  "drainingTimeoutSec": 0
 }
}

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-ipv6",
"IPProtocol": "TCP",
"ports": [
  "80", "8008", "8080", "8088"
],
"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",
"ipVersion": "IPV6",
"networkTier": "PREMIUM"
}

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",
"IPAddress": "10.1.2.99",
"IPProtocol": "TCP",
"ports": [
  "80", "8008", "8080", "8088"
],
"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",
"networkTier": "PREMIUM"
}

Prueba el balanceador de cargas

Para probar el balanceador de cargas, crea una VM de cliente en la misma región que el balanceador de cargas y, luego, envía tráfico del cliente al balanceador de cargas.

Crear una VM de cliente

En este ejemplo se crea una VM de cliente (vm-client) 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.

Console

  1. En la Google Cloud consola, 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 Región, selecciona us-west1..

  5. En Zona, selecciona us-west1-a.

  6. Haz clic en Opciones avanzadas.

  7. Haz clic en Herramientas de redes y configura los siguientes campos:

    1. En Etiquetas de red, ingresa allow-ssh.
    2. En Interfaces de red, selecciona lo siguiente:
      • Red: lb-network-dual-stack
      • Subred: lb-subnet
      • Tipo de pila IP: IPv4 e IPv6 (pila doble)
      • IP interna principal: efímera (automática)
      • IP externa: Efímera
    3. Haz clic en Listo.

  8. 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-12 \
    --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",
 "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-dual-stack",
     "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
}

Prueba la conexión

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. El comportamiento esperado consiste en que el tráfico se distribuya entre las cuatro VMs de backend.

  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 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. Describe la regla de reenvío de IPv4 fr-ilb.

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

  4. Desde los clientes con conectividad IPv6, ejecuta el siguiente comando:

    $ 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

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

    $ curl -m 10 -s http://10.1.2.99:80

    Reemplaza los marcadores de posición por valores válidos:

    • IPV6_ADDRESS es la dirección IPv6 efímera en la regla de reenvío fr-ilb-ipv6.

Configura el balanceador de cargas con subredes y backends solo para IPv6

En este documento, se muestra cómo configurar y probar un balanceador de cargas de red de transferencia interno que solo admite tráfico IPv6. En los pasos de esta sección, se describe cómo configurar los siguientes elementos:

  1. Una red de VPC en modo personalizado llamada lb-network-ipv6-only. El tráfico IPv6 requiere una subred de modo personalizado.
  2. Una subred interna solo IPv6 llamada lb-subnet-ipv6-only (stack-type establecida en IPv6_ONLY), que es obligatoria para el tráfico solo IPv6.
  3. Reglas de firewall que permiten conexiones entrantes a VMs de backend.
  4. El grupo de instancias de backend, que se encuentra en la siguiente región y subred para este ejemplo:
    • Región: us-west1
    • Subred: lb-subnet-ipv6-only El rango de direcciones IPv6 de la subred se asigna automáticamente. Google proporciona un bloque CIDR IPv6 de tamaño fijo (/64).
  5. Cuatro VMs de backend solo IPv6: Dos VMs en un grupo de instancias no administrado en la zona us-west1-a y dos VMs en un grupo de instancias no administrado en la zona us-west1-c.
  6. Un servidor TCP IPv6 en las VMs de backend El servidor escucha las conexiones entrantes en la VIP especificada de la regla de reenvío del balanceador de cargas y en la interfaz de red especificada. El servidor acepta conexiones de clientes entrantes, envía una respuesta y, luego, cierra la conexión.
  7. Una VM cliente para probar conexiones.
  8. Los siguientes componentes del balanceador de cargas de red de transferencia interno son:
    • Una verificación de estado del servicio de backend
    • Un servicio de backend interno en la región us-west1 para administrar la distribución de conexiones en los dos grupos de instancias zonales
    • Una regla de reenvío de IPv6

Configura una red, una región y una subred

El ejemplo del balanceador de cargas de red de transferencia interno descrito en esta página se crea en una red de VPC de modo personalizado llamada lb-network-ipv6-only.

Para configurar subredes con rangos de IPv6 internos, habilita un rango de IPv6 interno de ULA de la red de VPC. Los rangos de subredes IPv6 internas se asignan a partir de este rango.

Más adelante, en la sección Instala un servidor TCP de IPv6 en las VMs de backend con una secuencia de comandos de Bash de inicio de este documento, se usa el rango de subred de IPv6 interno para crear una regla de enrutamiento que enrute el tráfico desde la subred de VPC a través de la puerta de enlace y la interfaz de red especificadas.

Console

  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-ipv6-only.

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

    1. En Configuración de la dirección IPv6 privada, selecciona Configurar un rango de IPv6 interno de ULA para esta red de VPC.
    2. En Asignar rango de IPv6 interno, selecciona Automáticamente o Manualmente. Si seleccionas Manualmente, ingresa un rango /48 que pertenezca al rango fd20::/20. Si el rango ya está en uso, se te solicitará que proporciones un rango diferente.

  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:

    • Nombre: lb-subnet-ipv6-only
    • Región: us-west1
    • Tipo de pila IP: IPv6 (pila única)
    • Tipo de acceso IPv6: Interno

  7. Haz clic en Listo.

  8. Haz clic en Crear.

gcloud

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

    Para configurar rangos de IPv6 internos en cualquier subred de esta red, usa la marca --enable-ula-internal-ipv6.

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

  2. Configura una subred con ipv6-access-type establecido en INTERNAL. Esto indica que las VMs de esta subred solo pueden tener direcciones IPv6 internas.Para crear la subred, ejecuta el comando gcloud compute networks subnets create.

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

Configura reglas de firewall

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

  • fw-allow-lb-access-ipv6-only: Es una regla de entrada aplicable a todos los destinos en la red de VPC, de modo que se admite el tráfico de todas las fuentes IPv6.

  • fw-allow-ssh: Es 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 que inicias sesiones SSH. En este ejemplo, se usa la etiqueta de destino allow-ssh para identificar las VMs a las que se debe aplicar.

  • fw-allow-health-check-ipv6-only: 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 se debe aplicar.

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

Console

  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 el tráfico de subred de IPv6, vuelve a hacer clic en Crear regla de firewall y, luego, ingresa la siguiente información:

    • Nombre: fw-allow-lb-access-ipv6-only
    • Red: lb-network-ipv6-only
    • Prioridad: 1000
    • Dirección del tráfico: Entrada
    • Acción en caso de coincidencia: Permitir
    • Objetivos: All instances in the network
    • Filtro de fuente: Rangos de IPv6
    • Rangos de IPv6 de origen: ::/0
    • Protocols y puertos: Permitirlos todos

  3. Haz clic en Crear.

  4. Para permitir conexiones SSH entrantes, vuelve a hacer clic en Crear regla de firewall y, luego, ingresa la siguiente información:

    • Nombre: fw-allow-ssh
    • Red: lb-network-ipv6-only
    • Prioridad: 1000
    • Dirección del tráfico: Entrada
    • Acción en caso de coincidencia: Permitir
    • Destinos: 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: Selecciona Protocolos y puertos especificados, elige la casilla de verificación TCP y, luego, ingresa 22 en Puertos

  5. Haz clic en Crear.

  6. Para permitir las Google Cloud verificaciones de estado de IPv6, vuelve a hacer clic en Crear regla de firewall y, luego, ingresa la siguiente información:

    • Nombre: fw-allow-health-check-ipv6-only
    • Red: lb-network-ipv6-only
    • Prioridad: 1000
    • Dirección del tráfico: Entrada
    • Acción en caso de coincidencia: Permitir
    • Destinos: 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
    • Protocols y puertos: Permitirlos todos

  7. Haz clic en Crear.

gcloud

  1. Crea la regla de firewall fw-allow-lb-access-ipv6-only para permitir el tráfico IPv6 a todas las instancias de VM en la red de VPC.

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

  2. Crea la regla de firewall fw-allow-ssh para permitir la conectividad SSH a las VM con 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-ipv6-only \
    --action=allow \
    --direction=ingress \
    --target-tags=allow-ssh \
    --rules=tcp:22

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

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

Crea VMs de backend y grupos de instancias

En este ejemplo, se usan dos grupos de instancias no administrados, cada uno con dos VMs de backend. Para demostrar la naturaleza regional de los balanceadores de cargas de red de transferencia internos, los dos grupos de instancias se colocan en zonas diferentes: us-west1-a y us-west1-c.

  • El grupo de instancias ig-a contiene estas dos VM:
    • vm-a1
    • vm-a2
  • El grupo de instancias ig-c contiene estas dos VM:
    • vm-c1
    • vm-c2

El tráfico a las cuatro VM de backend cuenta con balanceo de cargas.

Console

Crea VM de backend

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

    Ir a Instancias de VM

  2. Repite estos pasos para cada VM y usa las siguientes combinaciones de nombre y zona.

    • Nombre: vm-a1, zona: us-west1-a
    • Nombre: vm-a2, zona: us-west1-a
    • Nombre: vm-c1, zona: us-west1-c
    • Nombre: vm-c2, zona: us-west1-c

  3. Haz clic en Crear instancia.

  4. En Nombre establece lo que se indica en el paso 2.

  5. En Región, selecciona us-west1 y selecciona una Zona como se indica en el paso 2.

  6. En la sección Disco de arranque, asegúrate de que Debian GNU/Linux 12 (bookWorm) esté seleccionado como las opciones del disco de arranque. Si es necesario, haz clic en Cambiar para cambiar la imagen.

  7. Haz clic en Opciones avanzadas.

  8. Haz clic en Herramientas de redes y configura los siguientes campos:

    1. En Etiquetas de red, ingresa allow-ssh y allow-health-check-ipv6.
    2. En Interfaces de red, selecciona lo siguiente:
      • Red: lb-network-ipv6-only
      • Subred: lb-subnet-ipv6-only
      • Tipo de pila IP: IPv6 (pila única)
      • Dirección IPv6 interna principal: Efímera (automática)

  9. Haz clic en Crear.

La VM de backend debe ejecutar un servidor TCP IPv6 que escuche las conexiones entrantes. Instalarás este servidor en las VMs de backend después de configurar el balanceador de cargas. Esto se debe a que la secuencia de comandos del servidor crea un socket que se vincula a la regla de reenvío del balanceador de cargas.

Crea grupos de instancias

  1. En la consola de Google Cloud , ve a la página Grupos de instancias.

    Ir a Grupos de instancias

  2. Repite estos pasos para crear dos grupos de instancias no administrados, cada uno con dos VM, mediante estas combinaciones.

    • Nombre del grupo de instancias: ig-a, zona: us-west1-a, VMs: vm-a1 y vm-a2
    • Nombre del grupo de instancias: ig-c, zona: us-west1-c, VMs: vm-c1 y vm-c2

  3. Haz clic en Crear grupo de instancias.

  4. Haz clic en Crear un nuevo grupo de instancias no administrado.

  5. Configura Nombre como se indica en el paso 2.

  6. En la sección Ubicación, elige us-west1 para Región y, luego, elige una opción en Zona, como se indica en el paso 2.

  7. En Red, selecciona lb-network-ipv6-only.

  8. En Subred, selecciona lb-subnet-ipv6-only.

  9. En la sección Instancias de VM, agrega las VM como se indica en el paso 2.

  10. Haz clic en Crear.

gcloud

  1. A fin de crear cuatro VMs, ejecuta el comando gcloud compute instances create cuatro veces, con estas cuatro combinaciones para [VM-NAME] y [ZONE].

    • VM-NAME: vm-a1, ZONE: us-west1-a
    • VM-NAME: vm-a2, ZONE: us-west1-a
    • VM-NAME: vm-c1, ZONE: us-west1-c
    • VM-NAME: vm-c2, ZONE: us-west1-c
    gcloud beta compute instances create VM-NAME \
    --zone=ZONE \
    --image-family=debian-12 \
    --image-project=debian-cloud \
    --tags=allow-ssh,allow-health-check-ipv6 \
    --subnet=lb-subnet-ipv6-only \
    --stack-type=IPV6_ONLY

    La VM de backend debe ejecutar un servidor TCP IPv6 que escuche las conexiones entrantes. Instalarás este servidor en las VMs de backend después de configurar el balanceador de cargas. Esto se debe a que la secuencia de comandos del servidor crea un socket que se vincula a la regla de reenvío del balanceador de cargas.

  2. Crea los dos grupos de instancias no administrados en cada zona:

    gcloud beta compute instance-groups unmanaged create ig-a \
    --zone=us-west1-a
gcloud beta compute instance-groups unmanaged create ig-c \
    --zone=us-west1-c

  3. Agrega las VM a los grupos de instancias adecuados:

    gcloud beta compute instance-groups unmanaged add-instances ig-a \
  --zone=us-west1-a \
  --instances=vm-a1,vm-a2
gcloud beta compute instance-groups unmanaged add-instances ig-c \
  --zone=us-west1-c \
  --instances=vm-c1,vm-c2

Configura los componentes del balanceador de cargas

Con estos pasos se configuran todos los componentes del balanceador de cargas de red de transferencia interna; se comienza con la verificación de estado y el servicio de backend y, luego, los componentes de frontend:

Console

Inicia tu configuración

  1. En la consola de Google Cloud , ve a la página Balanceo de cargas.

    Ir a Balanceo de cargas

  2. Haz clic en Crear balanceador de cargas.
  3. En Tipo de balanceador de cargas, selecciona Balanceador de cargas de red (TCP/UDP/SSL) y haz clic en Siguiente.
  4. En Proxy o de transferencia, selecciona Balanceador de cargas de transferencia y haz clic en Siguiente.
  5. En Orientado al público o interno, selecciona Interno y haz clic en Siguiente.
  6. Haz clic en Configurar.

Configuración básica

En la página Crear un balanceador de cargas de red de transferencia interna, ingresa la siguiente información:

  • Nombre del balanceador de cargas: ilb-ipv6-only
  • Región: us-west1
  • Red: lb-network-ipv6-only

Configuración de backend

  1. Haz clic en Configuración de backend.
  2. En la sección Backend nuevo de Backends, selecciona el Tipo de pila de IP como IPv6 (pila única).
  3. En Grupo de instancias, selecciona el grupo de instancias ig-a y haz clic en Listo.
  4. Haz clic en Agregar backend y repite este paso para agregar ig-c.
  5. En el menú desplegable Verificación de estado, elige Crear una verificación de estado, ingresa la siguiente información y haz clic en Guardar:
    • Nombre: hc-http-80.
    • Permiso: Regional.
    • Protocolo: HTTP.
    • Puerto: 80.
    • Protocolo de proxy: NONE.
    • Ruta de la solicitud: /.
  6. Verifica que aparezca una marca de verificación azul junto a Configuración de backend.

Configuración de frontend

  1. Haz clic en Configuración de frontend. En la sección IP y puerto de frontend nuevos, haz lo siguiente:
    1. En Nombre, ingresa fr-ilb-ipv6-only.
    2. Para controlar el tráfico IPv6, haz lo siguiente:
      1. En Versión de la IP, selecciona IPv6. El servidor TCP IPv6 que crearás en la siguiente sección se vincula a la VIP de la regla de reenvío.
      2. En Subred, selecciona lb-subnet-ipv6-only. El rango de direcciones IPv6 en la regla de reenvío siempre es efímero.
      3. En Puertos, selecciona Varios y, luego, en el campo Número de puerto, ingresa 80,8008,8080,8088.
      4. Haz clic en Listo.
    3. Verifica que haya una marca de verificación azul junto a Configuración de frontend antes de continuar.

Revisa la configuración

  1. Haz clic en Revisar y finalizar. Comprueba toda la configuración.
  2. Si la configuración es correcta, haz clic en Crear. La creación del balanceador de cargas de red de transferencia interno tarda unos minutos.

gcloud

  1. Crea una verificación de estado HTTP regional nueva para probar la conectividad HTTP a las VM en 80.

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

  2. Crea el servicio de backend:

    gcloud beta compute backend-services create ilb-ipv6-only \
    --load-balancing-scheme=INTERNAL \
    --protocol=tcp \
    --region=us-west1 \
    --health-checks=hc-http-80 \
    --health-checks-region=us-west1

  3. Agrega los dos grupos de instancias al servicio de backend:

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

    gcloud beta compute backend-services add-backend ilb-ipv6-only \
    --region=us-west1 \
    --instance-group=ig-c \
    --instance-group-zone=us-west1-c

  4. Crea la regla de reenvío de IPv6 con una dirección IPv6 efímera.

    gcloud beta compute forwarding-rules create fr-ilb-ipv6-only \
    --region=us-west1 \
    --load-balancing-scheme=INTERNAL \
    --subnet=lb-subnet-ipv6-only \
    --ip-protocol=TCP \
    --ports=80,8008,8080,8088 \
    --backend-service=ilb-ipv6-only \
    --backend-service-region=us-west1 \
    --ip-version=IPV6

    El servidor TCP IPv6 que crearás en la siguiente sección se vincula a la VIP de la regla de reenvío.

Instala un servidor TCP de IPv6 en las VMs de backend con una secuencia de comandos de inicio de Bash

En este ejemplo, la secuencia de comandos de inicio de Bash para las VMs de backend contiene lo siguiente:

  • Comandos de redes para enrutar todos los paquetes salientes que se originan en una subred a través de una puerta de enlace y una interfaz de red especificadas
  • Secuencia de comandos del servidor de Python (server.py), que es un servidor TCP IPv6 que escucha las conexiones entrantes en la VIP y la interfaz de red especificadas. Acepta conexiones de clientes entrantes, envía una respuesta y, luego, cierra la conexión.

Debes agregar los siguientes detalles en la secuencia de comandos de Bash:

  • Dirección de puerta de enlace
  • Rango de subred
  • VIP de la regla de reenvío
  • Interfaz de red

Para identificar la dirección de la puerta de enlace y el rango de subred, ejecuta el comando ip -6 route show table all en la VM de backend. Para obtener más información sobre los comandos que se usan en la secuencia de comandos de inicio de Bash, consulta la sección Apéndice.

Para agregar una secuencia de comandos de inicio a la instancia de VM, haz lo siguiente:

Console

  1. En la lista de instancias de VM que creaste antes, haz clic en la instancia de VM que necesitas actualizar.

  2. Haz clic en Editar.

  3. En la sección Metadatos, ingresa la siguiente secuencia de comandos en el campo Secuencia de comandos de inicio.

    #!/bin/bash

# Replace these with your actual values. Run the 'ip -6 route show table all' command to find the correct values.
GATEWAY_ADDRESS=fe80::57:2ff:fe36:ffbe
SUBNET_RANGE=fd20:307:120c:2000::/64

# Add a custom default route to routing table 1.
# The following command sends packets to the gateway using the network interface named 'ens4'.
sudo ip route add default via $GATEWAY_ADDRESS dev ens4 table 1

# Add a source-based policy routing rule.
# The following command adds a rule to route all outgoing packets originating
# from a specified subnet. If the source address matches the subnet,
# the system uses the default route defined in table 1 to forward the traffic.
sudo ip -6 rule add from $SUBNET_RANGE table 1

# Allow the server to bind to a non-local IPv6 address--the VIP of the load balancer.
sudo sysctl -w net.ipv6.ip_nonlocal_bind=1

# Overview:
# This script sets up a simple IPv6 TCP server using Python's socket library.
# The server binds to a specific network interface and listens on a specified Virtual IP (VIP) address and port (default: 80).
# It accepts incoming client connections, sends a simple response ("Thank you for connecting"), and then closes the connection.
# Key features:
# - Uses IPv6 (AF_INET6) for networking.
# - Binds to a specific network interface using SO_BINDTODEVICE.
# - Handles multiple client connections in a loop.
# - Demonstrates basic socket programming concepts like binding, listening, accepting, and sending data.
# Note: Replace placeholders like 'FORWARDING_RULE_VIP' and 'ens4' with actual values for your setup.

# Write the Python file locally.
cat << 'EOF' > server.py

# Import the socket library to work with network connections
import socket
import urllib.request

# Fetch the VM hostname from Google Cloud metadata server
def get_vm_hostname():
    url = "http://metadata.google.internal/computeMetadata/v1/instance/name"
    req = urllib.request.Request(url, headers={"Metadata-Flavor": "Google"})
    with urllib.request.urlopen(req) as response:
        return response.read().decode()

vm_hostname = get_vm_hostname()

# Create a socket object for IPv6 and TCP connections
# AF_INET6 specifies IPv6, SOCK_STREAM specifies TCP
server_socket = socket.socket(socket.AF_INET6, socket.SOCK_STREAM)

# Set the SO_REUSEADDR option to allow reusing the address
# This is useful to avoid "address already in use" errors when restarting the server
server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)

# Specify the network interface to bind the server to
# Replace "ens4" with the name of your network interface
interface_name = "ens4"
# Get the index of the network interface
interface_index = socket.if_nametoindex(interface_name)
# Bind the socket to the specified network interface
server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_BINDTODEVICE, interface_name.encode())

# Bind the socket to an address and port
# Replace 'FORWARDING_RULE_VIP' with the actual VIP (Virtual IP) address
server_address = ('FORWARDING_RULE_VIP', 80, 0, 0)
server_socket.bind(server_address)

# Start listening for incoming connections
# The argument '5' specifies the maximum number of queued connections
server_socket.listen(5)

# Print a message indicating that the server is ready to accept connections
print(f"Server listening on {server_address}, bound to {interface_name}")

# Serve incoming connections
while True:
    client_socket, client_address = server_socket.accept()
    print(f"Accepted connection from {client_address}")

    # Generate response body
    body = f"Thank you for connecting to {vm_hostname}\n"

    # Construct a proper HTTP/1.1 response
    response = (
        "HTTP/1.1 200 OK\r\n"
        f"Content-Length: {len(body)}\r\n"
        "Content-Type: text/plain\r\n"
        "Connection: close\r\n"
        "\r\n"
        f"{body}"
    )

    # Send the response and close the connection
    client_socket.sendall(response.encode())
    client_socket.close()
EOF

# Make the Python script executable
chmod +x server.py

# Run the server
sudo python3 server.py

  4. Haz clic en Guardar.

  5. Reinicia la instancia.

gcloud

  1. Crea una secuencia de comandos de inicio.

    nano startup.sh

  2. Agrega la siguiente secuencia de comandos y guarda el archivo.

    #!/bin/bash

# Replace these with your actual values. Run the 'ip -6 route show table all' command to find the correct values.
GATEWAY_ADDRESS=fe80::57:2ff:fe36:ffbe
SUBNET_RANGE=fd20:307:120c:2000::/64

# Add a custom default route to routing table 1.
# The following command sends packets to the gateway using the network interface named 'ens4'.
sudo ip route add default via $GATEWAY_ADDRESS dev ens4 table 1

# Add a source-based policy routing rule.
# The following command adds a rule to route all outgoing packets originating
# from a specified subnet. If the source address matches the subnet,
# the system uses the default route defined in table 1 to forward the traffic.
sudo ip -6 rule add from $SUBNET_RANGE table 1

# Allow the server to bind to a non-local IPv6 address--the VIP of the load balancer.
sudo sysctl -w net.ipv6.ip_nonlocal_bind=1

# Overview:
# This script sets up a simple IPv6 TCP server using Python's socket library.
# The server binds to a specific network interface and listens on a specified Virtual IP (VIP) address and port (default: 80).
# It accepts incoming client connections, sends a simple response ("Thank you for connecting"), and then closes the connection.
# Key features:
# - Uses IPv6 (AF_INET6) for networking.
# - Binds to a specific network interface using SO_BINDTODEVICE.
# - Handles multiple client connections in a loop.
# - Demonstrates basic socket programming concepts like binding, listening, accepting, and sending data.
# Note: Replace placeholders like 'FORWARDING_RULE_VIP' and 'ens4' with actual values for your setup.

# Write the Python file locally.
cat << 'EOF' > server.py

# Import the socket library to work with network connections
import socket
import urllib.request

# Fetch the VM hostname from Google Cloud metadata server
def get_vm_hostname():
    url = "http://metadata.google.internal/computeMetadata/v1/instance/name"
    req = urllib.request.Request(url, headers={"Metadata-Flavor": "Google"})
    with urllib.request.urlopen(req) as response:
        return response.read().decode()

vm_hostname = get_vm_hostname()

# Create a socket object for IPv6 and TCP connections
# AF_INET6 specifies IPv6, SOCK_STREAM specifies TCP
server_socket = socket.socket(socket.AF_INET6, socket.SOCK_STREAM)

# Set the SO_REUSEADDR option to allow reusing the address
# This is useful to avoid "address already in use" errors when restarting the server
server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)

# Specify the network interface to bind the server to
# Replace "ens4" with the name of your network interface
interface_name = "ens4"
# Get the index of the network interface
interface_index = socket.if_nametoindex(interface_name)
# Bind the socket to the specified network interface
server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_BINDTODEVICE, interface_name.encode())

# Bind the socket to an address and port
# Replace 'FORWARDING_RULE_VIP' with the actual VIP (Virtual IP) address
server_address = ('FORWARDING_RULE_VIP', 80, 0, 0)
server_socket.bind(server_address)

# Start listening for incoming connections
# The argument '5' specifies the maximum number of queued connections
server_socket.listen(5)

# Print a message indicating that the server is ready to accept connections
print(f"Server listening on {server_address}, bound to {interface_name}")

# Serve incoming connections
while True:
    client_socket, client_address = server_socket.accept()
    print(f"Accepted connection from {client_address}")

    # Generate response body
    body = f"Thank you for connecting to {vm_hostname}\n"

    # Construct a proper HTTP/1.1 response
    response = (
        "HTTP/1.1 200 OK\r\n"
        f"Content-Length: {len(body)}\r\n"
        "Content-Type: text/plain\r\n"
        "Connection: close\r\n"
        "\r\n"
        f"{body}"
    )

    # Send the response and close the connection
    client_socket.sendall(response.encode())
    client_socket.close()
EOF

# Make the Python script executable
chmod +x server.py

# Run the server
sudo python3 server.py

  3. Agrega el archivo de metadatos a la instancia de VM.

    gcloud compute instances add-metadata VM-NAME \
  --metadata-from-file=startup-script=startup.sh

  4. Reinicia la instancia.

Prueba el balanceador de cargas

Para probar el balanceador de cargas, crea una VM de cliente en la misma región que el balanceador de cargas y, luego, envía tráfico del cliente al balanceador de cargas.

Crear una VM de cliente

En este ejemplo se crea una VM de cliente (vm-client) 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.

Console

  1. En la Google Cloud consola, 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 Región, selecciona us-west1..

  5. En Zona, selecciona us-west1-a.

  6. Haz clic en Opciones avanzadas.

  7. Haz clic en Herramientas de redes y configura los siguientes campos:

    1. En Etiquetas de red, ingresa allow-ssh.
    2. En Interfaces de red, selecciona lo siguiente:
      • Red: lb-network-ipv6-only
      • Subred: lb-subnet-ipv6-only
      • Tipo de pila IP: IPv6 (pila única)
    3. Haz clic en Listo.

  8. 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 beta compute instances create vm-client \
    --zone=us-west1-a \
    --image-family=debian-12 \
    --image-project=debian-cloud \
    --stack-type=IPV6_ONLY \
    --tags=allow-ssh \
    --subnet=lb-subnet-ipv6-only

Prueba la conexión

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. El comportamiento esperado consiste en que el tráfico se distribuya entre las cuatro VMs de backend.

  1. Conéctate a la instancia de VM del cliente a través de SSH.

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

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

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

  3. Desde los clientes con conectividad IPv6, ejecuta el siguiente comando:

    curl http://IPV6_ADDRESS:80

    Por ejemplo, si la dirección IPv6 asignada es [fd20:307:120c:2000:0:1:0:0/96]:80, el comando debe verse de la siguiente manera:

    curl http://[fd20:307:120c:2000:0:1:0:0]:80

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.

Habilitar el acceso global

Puedes habilitar el acceso global para tu balanceador de cargas de red de transferencia interno de ejemplo a fin de que sea accesible a los clientes en todas las regiones. De todos modos, los backends del balanceador de cargas de ejemplo deben ubicarse en una región (us-west1).

Balanceador de cargas de red interno con acceso global.
Balanceador de cargas de red de transferencia interno con acceso global (haz clic para ampliar).

Para configurar el acceso global, realiza los siguientes cambios de configuración.

Console

Modifica la regla de reenvío del balanceador de cargas

  1. En la consola de Google Cloud , ve a la página Balanceo de cargas.

    Ir a Balanceo de cargas

  2. En la columna Nombre, haz clic en el balanceador de cargas de red de transferencia interno. El balanceador de cargas de ejemplo se llama be-ilb.

  3. Haz clic en Configuración de frontend.

  4. Haz clic en Editar .

  5. En Acceso global, selecciona Habilitar.

  6. Haz clic en Listo.

  7. Haz clic en Actualizar.

En la página Detalles del balanceador de cargas, verifica que la configuración de frontend indique Regional (REGION) con acceso global.

gcloud

  1. Actualiza la regla de reenvío del balanceador de cargas de ejemplo, fr-ilb, para incluir la marca --allow-global-access.

    gcloud compute forwarding-rules update fr-ilb \
   --region=us-west1 \
   --allow-global-access

  2. Puedes usar el comando forwarding-rules describe para determinar si una regla de reenvío tiene habilitado el acceso global. Por ejemplo:

    gcloud compute forwarding-rules describe fr-ilb \
   --region=us-west1 \
   --format="get(name,region,allowGlobalAccess)"

    La palabra True aparece en la salida, después del nombre y la región de la regla de reenvío, cuando el acceso global está habilitado.

API

Realiza una solicitud PATCH al método forwardingRules/patch.

PATCH https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/forwardingRules/fr-ilb

{
"allowGlobalAccess": true
}

Crea un cliente de VM para probar el acceso global

Console

  1. En la Google Cloud consola, 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-client2.

  4. Establece la Región en europe-west1.

  5. Establecer la zona en europe-west1-b.

  6. Haz clic en Opciones avanzadas.

  7. Haz clic en Herramientas de redes y configura los siguientes campos:

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

  8. 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 europe-west1-b y usa la misma subred que las VM de backend.

gcloud compute instances create vm-client2 \
    --zone=europe-west1-b \
    --image-family=debian-12 \
    --image-project=debian-cloud \
    --tags=allow-ssh \
    --subnet=europe-subnet

API

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

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/europe-west1-b/instances

{
"name": "vm-client2",
"tags": {
  "items": [
    "allow-ssh"
  ]
},
"machineType": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/europe-west1-b/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/europe-west1/subnetworks/europe-subnet",
    "accessConfigs": [
      {
        "type": "ONE_TO_ONE_NAT",
        "name": "external-nat",
        "networkTier": "PREMIUM"
      }
    ]
  }
],
"disks": [
  {
    "type": "PERSISTENT",
    "boot": true,
    "mode": "READ_WRITE",
    "autoDelete": true,
    "deviceName": "vm-client2",
    "initializeParams": {
      "sourceImage": "projects/debian-cloud/global/images/debian-image-name",
      "diskType": "projects/PROJECT_ID/zones/europe-west1-b/diskTypes/pd-standard",
      "diskSizeGb": "10"
    }
  }
],
"scheduling": {
  "preemptible": false
},
"deletionProtection": false
}

Conéctate al cliente de VM y prueba la conectividad

Para probar la conectividad, ejecuta el siguiente comando:

  gcloud compute ssh vm-client2 --zone=europe-west1-b

Prueba conectarte al balanceador de cargas en todos los puertos configurados, como lo hiciste desde vm-client en la región us-west1. Prueba la conectividad de HTTP en los cuatro puertos configurados en la regla de reenvío:

  curl http://10.1.2.99
  curl http://10.1.2.99:8008
  curl http://10.1.2.99:8080
  curl http://10.1.2.99:8088

Configura grupos de instancias administrados

Con la configuración de ejemplo, se crearon dos grupos de instancias no administrados. En su lugar, puedes usar grupos de instancias administrados, incluidos los grupos de instancias administrados zonales y regionales, como backends para balanceadores de cargas de red de transferencia internos.

Los grupos de instancias administrados requieren que crees una plantilla de instancias. En este procedimiento, se muestra cómo reemplazar los dos grupos de instancias zonales no administrados del ejemplo por un solo grupo de instancias administrado regional. Un grupo de instancias administrado regional crea VM de forma automática en varias zonas de la región, lo que simplifica la distribución del tráfico de producción entre las zonas.

Los grupos de instancias administrados también admiten el ajuste de escala automático y la reparación automática. Si usas el ajuste de escala automático con balanceadores de cargas de red de transferencia internos, no puedes escalar según el balanceo de cargas.

En este procedimiento se muestra cómo modificar el servicio de backend para el balanceador de cargas de red de transferencia interno de ejemplo a fin de que use un grupo de instancias administrado regional.

Console

Plantilla de instancias

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

    Ir a plantillas de instancias de VM

  2. Haz clic en Crear plantilla de instancias.

  3. Ingresa template-vm-ilb en Nombre.

  4. Elige un tipo de máquina.

  5. En la sección Disco de arranque, asegúrate de que Debian GNU/Linux 12 (bookWorm) esté seleccionado como las opciones del disco de arranque. Si es necesario, haz clic en Cambiar para cambiar la imagen.

  6. Haz clic en Opciones avanzadas.

  7. Haz clic en Herramientas de redes y configura los siguientes campos:

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

  8. Haz clic en Administración y, luego, en el campo Secuencia de comandos de inicio, ingresa la siguiente secuencia de comandos:

    #! /bin/bash
if [ -f /etc/startup_script_completed ]; then
exit 0
fi
apt-get update
apt-get install apache2 -y
a2ensite default-ssl
a2enmod ssl
file_ports="/etc/apache2/ports.conf"
file_http_site="/etc/apache2/sites-available/000-default.conf"
file_https_site="/etc/apache2/sites-available/default-ssl.conf"
http_listen_prts="Listen 80\nListen 8008\nListen 8080\nListen 8088"
http_vh_prts="*:80 *:8008 *:8080 *:8088"
https_listen_prts="Listen 443\nListen 8443"
https_vh_prts="*:443 *:8443"
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
prt_conf="$(cat "$file_ports")"
prt_conf_2="$(echo "$prt_conf" | sed "s|Listen 80|${http_listen_prts}|")"
prt_conf="$(echo "$prt_conf_2" | sed "s|Listen 443|${https_listen_prts}|")"
echo "$prt_conf" | tee "$file_ports"
http_site_conf="$(cat "$file_http_site")"
http_site_conf_2="$(echo "$http_site_conf" | sed "s|*:80|${http_vh_prts}|")"
echo "$http_site_conf_2" | tee "$file_http_site"
https_site_conf="$(cat "$file_https_site")"
https_site_conf_2="$(echo "$https_site_conf" | sed "s|_default_:443|${https_vh_prts}|")"
echo "$https_site_conf_2" | tee "$file_https_site"
systemctl restart apache2
touch /etc/startup_script_completed

  9. Haz clic en Crear.

Grupo de instancias administrado

  1. En la consola de Google Cloud , ve a la página Grupos de instancias.

    Ir a Grupos de instancias

  2. Haz clic en Crear grupo de instancias.

  3. Configura el campo Nombre como ig-ilb.

  4. En Ubicación, elige Varias zonas y establece Región en us-west1.

  5. Establece Plantilla de instancias en template-vm-ilb.

  6. Configura el ajuste de escala automático (opcional). No puedes usar el ajuste de escala automático en el grupo de instancias en función del uso del balanceo de cargas de HTTP porque el grupo de instancias es un backend para el balanceador de cargas de red de transferencia interno.

  7. En Cantidad mínima de instancias, establece el valor en 1 y, en Cantidad máxima de instancias, establece el valor en 6.

  8. Configura la reparación automática (opcional). Si configuras la reparación automática, debes usar la misma verificación de estado que usa el servicio de backend para el balanceador de cargas de red de transferencia interno. En este ejemplo usa hc-http-80.

  9. Haz clic en Crear.

gcloud

  1. Crea la plantilla de instancias. De forma opcional, puedes establecer otros parámetros, como el tipo de máquina, para que los use la plantilla de imágenes.

    gcloud compute instance-templates create template-vm-ilb \
    --image-family=debian-12 \
    --image-project=debian-cloud \
    --tags=allow-ssh,allow-health-check \
    --subnet=lb-subnet \
    --region=us-west1 \
    --network=lb-network \
    --metadata=startup-script='#! /bin/bash
if [ -f /etc/startup_script_completed ]; then
exit 0
fi
apt-get update
apt-get install apache2 -y
a2ensite default-ssl
a2enmod ssl
file_ports="/etc/apache2/ports.conf"
file_http_site="/etc/apache2/sites-available/000-default.conf"
file_https_site="/etc/apache2/sites-available/default-ssl.conf"
http_listen_prts="Listen 80\nListen 8008\nListen 8080\nListen 8088"
http_vh_prts="*:80 *:8008 *:8080 *:8088"
https_listen_prts="Listen 443\nListen 8443"
https_vh_prts="*:443 *:8443"
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
prt_conf="$(cat "$file_ports")"
prt_conf_2="$(echo "$prt_conf" | sed "s|Listen 80|${http_listen_prts}|")"
prt_conf="$(echo "$prt_conf_2" | sed "s|Listen 443|${https_listen_prts}|")"
echo "$prt_conf" | tee "$file_ports"
http_site_conf="$(cat "$file_http_site")"
http_site_conf_2="$(echo "$http_site_conf" | sed "s|*:80|${http_vh_prts}|")"
echo "$http_site_conf_2" | tee "$file_http_site"
https_site_conf="$(cat "$file_https_site")"
https_site_conf_2="$(echo "$https_site_conf" | sed "s|_default_:443|${https_vh_prts}|")"
echo "$https_site_conf_2" | tee "$file_https_site"
systemctl restart apache2
touch /etc/startup_script_completed'

  2. Crea un grupo de instancias administrado regional con la plantilla:

    gcloud compute instance-groups managed create ig-ilb \
    --template=template-vm-ilb \
    --region=us-west1 \
    --size=6

  3. Agrega el grupo de instancias administrado regional como un backend al servicio de backend que ya creaste:

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

  4. Desconecta los dos grupos de instancias no administrados (zonales) del servicio de backend:

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

Quita direcciones IP externas de las VMs de backend

Cuando creaste las VM de backend, a cada una se le asignó una dirección IP externa efímera para que pudiera descargar Apache a través de una secuencia de comandos de inicio. Debido a que a las VMs de backend solo las usa un balanceador de cargas de red de transferencia interno, puedes quitar sus direcciones IP externas. Quitar las direcciones IP externas evita que las VM de backend accedan a Internet directamente.

Console

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

    Ir a Instancias de VM

  2. Repite los siguientes pasos para cada VM de backend.

  3. Haz clic en el nombre de la VM de backend, por ejemplo, vm-a1.

  4. Haz clic en Editar.

  5. En la sección Interfaces de red, haz clic en la red.

  6. En la lista IP externa, selecciona Ninguna y haz clic en Listo.

  7. Haz clic en Guardar.

gcloud

  1. Si deseas buscar la zona de una instancia (por ejemplo, si usas un grupo de instancias administrado regional), ejecuta el siguiente comando para cada instancia a fin de determinar su zona. Reemplaza [SERVER-VM] por el nombre de la VM que deseas buscar.

    gcloud compute instances list --filter="name=[SERVER-VM]"

  2. Repite el siguiente paso para cada VM de backend. Reemplaza [SERVER-VM] por el nombre de la VM y [ZONE] por la zona de la VM.

    gcloud compute instances delete-access-config [SERVER-VM] \
    --zone=[ZONE] \
    --access-config-name=external-nat

API

Realiza una solicitud POST al método instances.deleteAccessConfig para cada VM de backend, y reemplaza vm-a1 por el nombre de la VM y us-west1-a por la zona de la VM.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instances/vm-a1/deleteAccessConfig?accessConfig=external-nat&networkInterface=None

Usa una dirección IP interna reservada

Cuando creas VMs de grupo de backend y grupos de instancias, la instancia de VM usa una dirección IPv4 o IPv6 interna efímera.

En los siguientes pasos, se muestra cómo ascender una dirección IPv4 o IPv6 interna a una dirección IPv4 o IPv6 interna estática y, luego, actualizar la instancia de VM para usar la dirección IP interna estática:

  1. Promueve una dirección IPv4 o IPv6 interna efímera en uso a una dirección estática.
  2. Cambia o asigna una dirección IPv6 interna a una instancia existente.

Como alternativa, con los siguientes pasos se muestra cómo reservar una dirección IPv4 o IPv6 interna estática nueva y, luego, actualizar la instancia de VM para usar la dirección IP interna estática:

  1. Reserva una nueva dirección IPv4 o IPv6 interna estática.

    A diferencia de la reserva IPv4 interna, la reserva IPv6 interna no admite la reserva de una dirección IP específica de la subred. En su lugar, un rango de direcciones IPv6 internas /96 se asigna de forma automática a partir del rango de direcciones IPv6 interna de la subred /64.

  2. Cambia o asigna una dirección IPv6 interna a una instancia existente.

Para obtener más información, consulta Cómo reservar una dirección IP interna estática.

Acepta el tráfico en todos los puertos

La regla de reenvío del balanceador de cargas, no su servicio de backend, determina los puertos en los que el balanceador de cargas acepta tráfico. Para obtener información sobre el propósito de cada componente, consulta Componentes.

Cuando creaste este ejemplo de regla de reenvío del balanceador de cargas, configuraste los puertos 80, 8008, 8080 y 8088. La secuencia de comandos de inicio con la que se instala Apache también sirve para configurar Apache a fin de que acepte conexiones HTTPS en los puertos 443 y 8443.

Para admitir estos seis puertos, puedes configurar la regla de reenvío a fin de aceptar el tráfico en todos los puertos. Con esta estrategia también puedes configurar las reglas del firewall que admiten conexiones entrantes en las VM de backend para que solo permitan determinados puertos.

En este procedimiento, se muestra cómo borrar la regla de reenvío actual del balanceador de cargas y crear una nueva que acepte el tráfico en todos los puertos.

Para obtener más información sobre el balanceo de cargas y las reglas de reenvío, consulta Balanceadores de cargas de red de transferencia internos y reglas de reenvío con una dirección IP común.

Console

Borra tu regla de reenvío y crea una nueva

  1. En la consola de Google Cloud , ve a la página Balanceo de cargas.

    Ir a Balanceo de cargas

  2. Haz clic en tu balanceador de cargas be-ilb y, luego, en Editar.

  3. Haz clic en Configuración de frontend.

  4. Mantén el puntero sobre la regla de reenvío 10.1.2.9 y haz clic en Borrar.

  5. Haz clic en Agregar IP y puerto de frontend.

  6. En la sección IP y puerto de frontend nuevos, ingresa la siguiente información y haz clic en Listo:

    • Nombre: fr-ilb
    • Subred: lb-subnet
    • IP interna: ip-ilb
    • Puertos: todos

  7. Verifica que haya una marca de verificación azul junto a Configuración de frontend antes de continuar.

  8. Haz clic en Revisar y finalizar y revisa la configuración del balanceador de cargas.

  9. Haz clic en Crear.

gcloud

  1. Borra la regla de reenvío existente, fr-ilb.

    gcloud compute forwarding-rules delete fr-ilb \
    --region=us-west1

  2. Crea una regla de reenvío de reemplazo, con el mismo nombre, cuya configuración de puerto use la palabra clave ALL. Los demás parámetros de la regla de reenvío siguen siendo los mismos.

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

API

Borra la regla de reenvío mediante una solicitud DELETE al método forwardingRules.delete.

DELETE https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/forwardingRules/fr-ilb

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",
"IPAddress": "10.1.2.99",
"IPProtocol": "TCP",
"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",
"networkTier": "PREMIUM"
}

Prueba el tráfico en la configuración de todos los puertos

Conéctate a la instancia de VM de cliente y prueba las conexiones HTTP y HTTPS.

  • Conéctate a la VM de cliente:

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

  • Prueba la conectividad HTTP en los cuatro puertos:

    curl http://10.1.2.99
curl http://10.1.2.99:8008
curl http://10.1.2.99:8080
curl http://10.1.2.99:8088

  • Prueba la conectividad de HTTPS en los puertos 443 y 8443. La marca --insecure es obligatoria, ya que cada servidor Apache en la configuración de ejemplo usa un certificado autofirmado. 

    curl https://10.1.2.99 --insecure
curl https://10.1.2.99:8443 --insecure

  • Observa que las solicitudes HTTP (en los cuatro puertos) y las solicitudes HTTPS (en ambos puertos) se distribuyan entre todas las VM de backend.

Acepta tráfico en varios puertos mediante dos reglas de reenvío

Cuando creaste este ejemplo de regla de reenvío del balanceador de cargas, configuraste los puertos 80, 8008, 8080 y 8088. La secuencia de comandos de inicio con la que se instala Apache también sirve para configurar Apache a fin de que acepte conexiones HTTPS en los puertos 443 y 8443.

Una estrategia alternativa a la configuración de una regla de reenvío única para aceptar el tráfico en todos los puertos consiste en crear varias reglas de reenvío, y que cada una admita cinco puertos o menos.

Mediante este procedimiento se muestra cómo reemplazar la regla de reenvío del balanceador de cargas de ejemplo con dos reglas de reenvío: una que controla el tráfico en los puertos 80, 8008, 8080 y 8088, y otra que controla el tráfico en los puertos 443 y 8443.

Para obtener más información sobre el balanceo de cargas y las reglas de reenvío, consulta Balanceadores de cargas de red de transferencia internos y reglas de reenvío con una dirección IP común.

Console

  1. En la consola de Google Cloud , ve a la página Reglas de reenvío.

    Ir a Reglas de reenvío

  2. En la columna Nombre, haz clic en fr-ilb y, luego, en Borrar.

  3. En la consola de Google Cloud , ve a la página Balanceo de cargas.

    Ir a Balanceo de cargas

  4. En la columna Nombre, haz clic en be-ilb.

  5. Haz clic en Editar.

  6. Haz clic en Configuración de frontend.

  7. Haz clic en Agregar IP y puerto de frontend.

  8. En la sección IP y puerto de frontend nuevos, haz lo siguiente:

    1. En Nombre, ingresa fr-ilb-http.
    2. En Subred, selecciona lb-subnet.
    3. En Propósito de IP interna, selecciona Compartido.
    4. En la lista Dirección IP, selecciona Crear dirección IP, ingresa la siguiente información y haz clic en Reservar:
      • Nombre: internal-10-1-2-99
      • Dirección IP estática: Permíteme elegir
      • Dirección IP personalizada: 10.1.2.99
    5. En Puertos, selecciona Varios y, luego, en Números de puerto, ingresa 80,8008,8080 y, 8088
    6. Haz clic en Listo.

  9. Haz clic en Agregar IP y puerto de frontend.

  10. En la sección IP y puerto de frontend nuevos, haz lo siguiente:

    1. En Nombre, ingresa fr-ilb-https.
    2. En Subred, selecciona lb-subnet.
    3. En Propósito de IP interna, selecciona Compartido.
    4. En la lista Dirección IP, selecciona internal-10-1-2-99.
    5. En Puertos, selecciona Varios y, luego, en Números de puerto, ingresa 443 y 8443.
    6. Haz clic en Listo.

  11. Haz clic en Revisar y finalizar y revisa la configuración del balanceador de cargas.

  12. Haz clic en Actualizar.

gcloud

  1. Borra la regla de reenvío existente, fr-ilb.

    gcloud compute forwarding-rules delete fr-ilb \
    --region=us-west1

  2. Crea una dirección IP interna (reservada) y estática para 10.1.2.99 y establece su marca --purpose en SHARED_LOADBALANCER_VIP. Se requiere la marca --purpose para que dos reglas de reenvío interno puedan usar la misma dirección IP interna.

    gcloud compute addresses create internal-10-1-2-99 \
    --region=us-west1 \
    --subnet=lb-subnet \
    --addresses=10.1.2.99 \
    --purpose=SHARED_LOADBALANCER_VIP
    1. Crea dos reglas de reenvío de reemplazo con los siguientes parámetros:
    gcloud compute forwarding-rules create fr-ilb-http \
    --region=us-west1 \
    --load-balancing-scheme=internal \
    --network=lb-network \
    --subnet=lb-subnet \
    --address=10.1.2.99 \
    --ip-protocol=TCP \
    --ports=80,8008,8080,8088 \
    --backend-service=be-ilb \
    --backend-service-region=us-west1

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

API

Borra la regla de reenvío mediante una solicitud DELETE al método forwardingRules.delete.

DELETE https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/forwardingRules/fr-ilb

Crea una dirección IP interna (reservada) y estática para 10.1.2.99 y establece su propósito en SHARED_LOADBALANCER_VIP mediante una solicitud POST al método addresses.insert.

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

{
"name": "internal-10-1-2-99",
"address": "10.1.2.99",
"prefixLength": 32,
"addressType": INTERNAL,
"purpose": SHARED_LOADBALANCER_VIP,
"subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet"
}

Crea dos reglas de reenvío mediante dos solicitudes POST al método forwardingRules.insert.

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

{
"name": "fr-ilb-http",
"IPAddress": "10.1.2.99",
"IPProtocol": "TCP",
"ports": [
  "80", "8008", "8080",  "8088"
],
"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"
}

{
"name": "fr-ilb-https",
"IPAddress": "10.1.2.99",
"IPProtocol": "TCP",
"ports": [
  "443", "8443"
],
"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"
}

Prueba el tráfico en la configuración de varios puertos

Conéctate a la instancia de VM de cliente y prueba las conexiones HTTP y HTTPS.

  • Conéctate a la VM de cliente:

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

  • Prueba la conectividad HTTP en los cuatro puertos:

    curl http://10.1.2.99
curl http://10.1.2.99:8008
curl http://10.1.2.99:8080
curl http://10.1.2.99:8088

  • Prueba la conectividad de HTTPS en los puertos 443 y 8443. La marca --insecure es obligatoria, ya que cada servidor Apache en la configuración de ejemplo usa un certificado autofirmado.

    curl https://10.1.2.99 --insecure
curl https://10.1.2.99:8443 --insecure

  • Observa que las solicitudes HTTP (en los cuatro puertos) y las solicitudes HTTPS (en ambos puertos) se distribuyan entre todas las VM de backend.

Usa la afinidad de sesión

En la configuración de ejemplo, se crea un servicio de backend sin afinidad de sesión.

Mediante este procedimiento se muestra cómo actualizar el servicio de backend para el balanceador de cargas de red de transferencia interno de ejemplo, de modo que se use la afinidad de sesión en función de un hash creado a partir de las direcciones IP del cliente y la dirección IP de la regla de reenvío interno del balanceador de cargas.

Para conocer los tipos de afinidad de sesión compatibles, consulta Opciones de afinidad de sesión.

Console

  1. En la consola de Google Cloud , ve a la página Balanceo de cargas.

    Ir a Balanceo de cargas

  2. Haz clic en be-ilb (nombre del servicio de backend que creaste para este ejemplo) y, luego, en Editar.

  3. En la página Editar el balanceador de cargas de red de transferencia interno, haz clic en Configuración de backend.

  4. En la lista Afinidad de sesión, selecciona IP de cliente.

  5. Haz clic en Actualizar.

gcloud

Usa el siguiente comando de gcloud para actualizar el servicio de backend be-ilb y especifica la afinidad de sesión de IP de cliente:

gcloud compute backend-services update be-ilb \
    --region=us-west1 \
    --session-affinity CLIENT_IP

API

Realiza una solicitud PATCH al método regionBackendServices/patch.

PATCH https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/backendServices/be-ilb

{
"sessionAffinity": "CLIENT_IP"
}

Configura una política de seguimiento de conexiones

En esta sección, se muestra cómo actualizar el servicio de backend para cambiar la política predeterminada de seguimiento de conexiones del balanceador de cargas.

Una política de seguimiento de conexión incluye la siguiente configuración:

gcloud

Usa el siguiente comando gcloud compute backend-services para actualizar la política de seguimiento de conexiones del servicio de backend:

gcloud compute backend-services update BACKEND_SERVICE \
    --region=REGION \
    --tracking-mode=TRACKING_MODE \
    --connection-persistence-on-unhealthy-backends=CONNECTION_PERSISTENCE_BEHAVIOR \
    --idle-timeout-sec=IDLE_TIMEOUT_VALUE

Reemplaza los marcadores de posición por valores válidos:

  • BACKEND_SERVICE: El servicio de backend que estás actualizando.
  • REGION: Es la región del servicio de backend que deseas actualizar.
  • TRACKING_MODE: Es el modo de seguimiento de conexión que se usará para los paquetes entrantes. Si deseas obtener la lista de valores admitidos, consulta Modo de seguimiento.
  • CONNECTION_PERSISTENCE_BEHAVIOR: Es el comportamiento de la conexión persistente cuando los backends están en mal estado. Para obtener la lista de los valores admitidos, consulta Persistencia de conexiones en backends en mal estado.

  • IDLE_TIMEOUT_VALUE: Es la cantidad de segundos que se debe mantener una entrada de la tabla de seguimiento de conexión después de que el balanceador de cargas procese el último paquete que coincidió con la entrada.

    Solo puedes modificar esta propiedad cuando el seguimiento de conexión sea inferior a 5 tuplas (es decir, cuando la afinidad de sesión está configurada para ser CLIENT_IP o bien, puedes hacer lo siguiente: CLIENT_IP_PROTO, y el modo de seguimiento es el siguiente: PER_SESSION).

    El valor predeterminado es 600 segundos (10 minutos). El valor de tiempo de espera de inactividad máximo configurable es de 57,600 segundos (16 horas).

Usa la afinidad zonal

En esta sección, se muestra cómo configurar un balanceador de cargas de red de transferencia interno para habilitar la afinidad zonal en el servicio de backend del balanceador de cargas. De forma predeterminada, la afinidad zonal está inhabilitada. Para obtener más información, consulta Afinidad zonal para los balanceadores de cargas de red de transferencia internos.

  • Usa el siguiente comando para configurar la opción de afinidad zonal ZONAL_AFFINITY_STAY_WITHIN_ZONE. Para obtener más información sobre cómo funciona esta opción, consulta Cómo funciona ZONAL_AFFINITY_STAY_WITHIN_ZONE.

    gcloud beta compute backend-services update be-ilb \
    --zonal-affinity-spillover=ZONAL_AFFINITY_STAY_WITHIN_ZONE \
    --region=us-west1

  • Usa el siguiente comando para configurar la afinidad zonal con la proporción de desbordamiento 0.0 predeterminada.ZONAL_AFFINITY_SPILL_CROSS_ZONE Para obtener más información sobre cómo funciona esta opción, consulta las secciones Cómo funcionan ZONAL_AFFINITY_SPILL_CROSS_ZONE y el coeficiente de derrame y Coeficiente de derrame cero.

    gcloud beta compute backend-services update be-ilb \
    --zonal-affinity-spillover=ZONAL_AFFINITY_SPILL_CROSS_ZONE \
    --region=us-west1

  • Usa el siguiente comando para configurar la afinidad zonal de ZONAL_AFFINITY_SPILL_CROSS_ZONE con una proporción de desbordamiento del 30%. Para obtener más información sobre cómo funciona esta opción, consulta las secciones Cómo funcionan ZONAL_AFFINITY_SPILL_CROSS_ZONE y el coeficiente de derrame y Coeficiente de derrame distinto de cero.

    gcloud beta compute backend-services update be-ilb \
    --zonal-affinity-spillover=ZONAL_AFFINITY_SPILL_CROSS_ZONE \
    --zonal-affinity-spillover-ratio=0.3 \
    --region=us-west1

Crea una regla de reenvío en otra subred

En este procedimiento, se crea una segunda dirección IP y regla de reenvío en una subred diferente a fin de demostrar que se pueden crear múltiples reglas de reenvío para un balanceador de cargas de red de transferencia interno. La región de la regla de reenvío debe coincidir con la región del servicio de backend.

Sujeto a las reglas de firewall, los clientes en cualquier subred de la región pueden contactarse con 'dirección IP del balanceador de cargas de red de transferencia interna.

Console

Agrega la segunda subred

  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. Haz clic en lb-network.

  4. En la sección Subredes, haz lo siguiente:

    1. Haz clic en Agregar subred.
    2. En la sección Nueva subred, ingresa la siguiente información:
      • Nombre: second-subnet
      • Región: us-west1
      • Rango de direcciones IP: 10.5.6.0/24
    3. Haz clic en Agregar.

Agrega la segunda regla de reenvío

  1. En la consola de Google Cloud , ve a la página Balanceo de cargas.

    Ir a Balanceo de cargas

  2. Haz clic en tu balanceador de cargas be-ilb y, luego, en Editar.

  3. Haz clic en Configuración de frontend.

  4. Haz clic en Agregar IP y puerto de frontend.

  5. En la sección IP y puerto de frontend nuevos, establece los siguientes campos y haz clic en Listo:

    • Nombre: fr-ilb-2
    • Versión de IP: IPv4
    • Subred: second-subnet
    • IP interna: ip-ilb
    • Puertos: 80 y 443

  6. Verifica que haya una marca de verificación azul junto a Configuración de frontend antes de continuar.

  7. Haz clic en Revisar y finalizar y revisa la configuración del balanceador de cargas.

  8. Haz clic en Crear.

gcloud

  1. Crea una segunda subred en la red lb-network, en la región us-west1:

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

  2. Crea una segunda regla de reenvío para los puertos 80 y 443. Los otros parámetros de esta regla, incluido el servicio de backend y la dirección IP, son los mismos que los de la regla de reenvío principal, fr-ilb.

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

API

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

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

{
 "name": "second-subnet",
 "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
 "ipCidrRange": "10.5.6.0/24",
 "privateIpGoogleAccess": false
}

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-2",
"IPAddress": "10.5.6.99",
"IPProtocol": "TCP",
"ports": [
  "80", "443"
],
"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"
}

Prueba la nueva regla de reenvío

Conéctate a la instancia de VM de cliente y prueba las conexiones HTTP y HTTPS en las direcciones IP.

  1. Conéctate a la VM de cliente:

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

  2. Prueba la conectividad HTTP en las direcciones IP:

    curl http://10.1.2.99
curl http://10.5.6.99

  3. Prueba la conectividad de HTTPS. El uso de --insecure es obligatorio porque la configuración del servidor Apache en la configuración de ejemplo usa certificados autofirmados.

    curl https://10.1.2.99 --insecure
curl https://10.5.6.99 --insecure

  4. Observa que todas las VM de backend manejen las solicitudes, sin importar el protocolo (HTTP o HTTPS) o la dirección IP que se usa.

Usa la subdivisión de backend

En la configuración de ejemplo, se crea un servicio de backend sin subdivisión.

En este procedimiento, se muestra cómo habilitar la subdivisión en el servicio de backend para el balanceador de cargas de red de transferencia interno de ejemplo a fin de que la implementación pueda escalar a una mayor cantidad de instancias de backend.

Solo debes habilitar la subdivisión si necesitas admitir más de 250 VM de backend en un solo balanceador de cargas.

Para obtener más información sobre este caso de uso, consulta Subdivisión de backend.

gcloud

Usa el siguiente comando de gcloud para actualizar el servicio de backend be-ilb y especifica la política de subdivisión:

gcloud compute backend-services update be-ilb \
    --subsetting-policy=CONSISTENT_HASH_SUBSETTING

API

Realiza una solicitud PATCH al método regionBackendServices/patch.

PATCH https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/backendServices/be-ilb

{
"subsetting":
  {
    "policy": CONSISTENT_HASH_SUBSETTING
  }
}

Crea un balanceador de cargas para la duplicación de paquetes

La Duplicación de paquetes te permite copiar y recopilar datos de paquetes de instancias específicas en una VPC. Los datos recopilados pueden ayudarte a detectar amenazas de seguridad y supervisar el rendimiento de las aplicaciones.

La duplicación de paquetes requiere un balanceador de cargas de red de transferencia interno para balancear el tráfico a un grupo de instancias de destinos de colector. Para crear un balanceador de cargas de red de transferencia interno para la duplicación de paquetes, sigue estos pasos.

Console

Inicia tu configuración

  1. En la consola de Google Cloud , ve a la página Balanceo de cargas.

    Ir a Balanceo de cargas

  2. Haz clic en Crear balanceador de cargas.
  3. En Tipo de balanceador de cargas, selecciona Balanceador de cargas de red (TCP/UDP/SSL) y haz clic en Siguiente.
  4. En Proxy o de transferencia, selecciona Balanceador de cargas de transferencia y haz clic en Siguiente.
  5. En Orientado al público o interno, selecciona Interno y haz clic en Siguiente.
  6. Haz clic en Configurar.

Configuración básica

  1. En Nombre del balanceador de cargas, ingresa un nombre.
  2. En Región, selecciona la región de las instancias de VM en las que quieres duplicar los paquetes.
  3. En Red, selecciona la red en la que deseas duplicar los paquetes.
  4. Haz clic en Configuración de backend.
  5. En la sección Backend nuevo, en Grupo de instancias, selecciona el grupo de instancias al que se reenviarán los paquetes.
  6. En el menú desplegable Verificación de estado, elige Crear una verificación de estado, ingresa la siguiente información y haz clic en Guardar:
    1. En Nombre, ingresa un nombre para la verificación de estado.
    2. En Protocolo, selecciona HTTP.
    3. En Puerto, ingresa 80.
  7. Haz clic en Configuración de frontend.
  8. En la sección IP y puerto de frontend nuevos, haz lo siguiente:
    1. En Nombre, ingresa un nombre.
    2. En Subred, selecciona una subred en la misma región que las instancias que deseas duplicar.
    3. En Puertos, selecciona Todos.
    4. Haz clic en Configuración avanzada y selecciona la casilla de verificación Habilitar este balanceador de cargas para la duplicación de paquetes.
    5. Haz clic en Listo.
  9. Haz clic en Crear.

gcloud

  1. Crea una verificación de estado HTTP regional nueva para probar la conectividad HTTP a un grupo de instancias en el puerto 80:

    gcloud compute health-checks create http HEALTH_CHECK_NAME \
    --region=REGION \
    --port=80

    Reemplaza lo siguiente:

    • HEALTH_CHECK_NAME: el nombre de la verificación de estado.
    • REGION: la región de las instancias de VM en la que deseas duplicar los paquetes.

  2. Crea un servicio de backend para el tráfico HTTP:

    gcloud compute backend-services create COLLECTOR_BACKEND_SERVICE \
    --region=REGION \
    --health-checks-region=REGION \
    --health-checks=HEALTH_CHECK_NAME \
    --load-balancing-scheme=internal \
    --protocol=tcp

    Reemplaza lo siguiente:

    • COLLECTOR_BACKEND_SERVICE: el nombre del servicio de backend.
    • REGION: la región de las instancias de VM en la que deseas duplicar paquetes.
    • HEALTH_CHECK_NAME: el nombre de la verificación de estado.

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

    gcloud compute backend-services add-backend COLLECTOR_BACKEND_SERVICE \
    --region=REGION \
    --instance-group=INSTANCE_GROUP \
    --instance-group-zone=ZONE

    Reemplaza lo siguiente:

    • COLLECTOR_BACKEND_SERVICE: el nombre del servicio de backend.
    • REGION: la región del grupo de instancias.
    • INSTANCE_GROUP: el nombre del grupo de instancias.
    • ZONE: la zona del grupo de instancias.

  4. Crea una regla de reenvío para el servicio de backend:

    gcloud compute forwarding-rules create FORWARDING_RULE_NAME \
    --region=REGION \
    --network=NETWORK \
    --subnet=SUBNET \
    --backend-service=COLLECTOR_BACKEND_SERVICE \
    --load-balancing-scheme=internal \
    --ip-protocol=TCP \
    --ports=all \
    --is-mirroring-collector

    Reemplaza lo siguiente:

    • FORWARDING_RULE_NAME: el nombre de la regla de reenvío.
    • REGION: la región para la regla de reenvío.
    • NETWORK: la red de la regla de reenvío.
    • SUBNET: una subred en la región de las VMs en la que deseas duplicar los paquetes
    • COLLECTOR_BACKEND_SERVICE: el servicio de backend para este balanceador de cargas.

¿Qué sigue?

Apéndice: Introducción a los scripts de Bash para IPv6

En esta sección, se proporciona una breve descripción de los diferentes comandos de redes relacionados con la secuencia de comandos de inicio de Bash que se usa para instalar un servidor TCP IPv6 en las VMs de backend. No es necesario que vuelvas a realizar estos pasos. Aquí solo se describen para proporcionar contexto y ayudar a la comprensión.

  1. Muestra todas las rutas IPv6.

    ip -6 route show table all

    El resultado es el siguiente:

    fd20:307:120c:2000::/64 via fe80::57:2ff:fe36:ffbe dev ens4 proto ra metric 100 expires 62sec pref medium
fe80::/64 dev ens4 proto kernel metric 256 pref medium
default via fe80::57:2ff:fe36:ffbe dev ens4 proto ra metric 100 expires 62sec mtu 1460 pref medium
local ::1 dev lo table local proto kernel metric 0 pref medium
local fd20:307:120c:2000:0:b:: dev ens4 table local proto kernel metric 0 pref medium
local fe80::56:24ff:feb1:59b3 dev ens4 table local proto kernel metric 0 pref medium
multicast ff00::/8 dev ens4 table local proto kernel metric 256 pref medium

    En el resultado del paso anterior, identifica lo siguiente:

    • Dirección IPv6 de vínculo local (comienza con fe80::/10): En el ejemplo de salida, la dirección de vínculo local es fe80::57:2ff:fe36:ffbe. Esta dirección local de vínculo se usa en la ruta predeterminada que se define en la tabla de enrutamiento 1. Esta ruta predeterminada se crea en el paso 2.
    • Subred /64: Se hace referencia a esta subred en la regla de enrutamiento de políticas basada en la fuente del paso 3.

  2. Agrega una ruta predeterminada personalizada en la tabla de enrutamiento 1.

    El siguiente comando envía paquetes a la puerta de enlace con la interfaz de red llamada ens4.

    sudo ip route add default via GATEWAY_ADDRESS dev ens4 table 1

    Después de ejecutar este comando, se agrega una ruta predeterminada a una tabla de enrutamiento personalizada (tabla 1), que apunta a la puerta de enlace fe80::57:2ff:fe36:ffbe a través de la interfaz ens4.

    Si volvieras a ejecutar el comando ip -6 route show table all, el resultado sería el siguiente:

    default via fe80::57:2ff:fe36:ffbe dev ens4 table 1 metric 1024 pref medium
fd20:307:120c:2000::/64 via fe80::57:2ff:fe36:ffbe dev ens4 proto ra metric 100 expires 89sec pref medium
fe80::/64 dev ens4 proto kernel metric 256 pref medium
default via fe80::57:2ff:fe36:ffbe dev ens4 proto ra metric 100 expires 89sec mtu 1460 pref medium
local ::1 dev lo table local proto kernel metric 0 pref medium
local fd20:307:120c:2000:0:1::/96 dev ens4 table local proto 66 metric 1024 pref medium
local fd20:307:120c:2000:0:b:: dev ens4 table local proto kernel metric 0 pref medium
local fe80::56:24ff:feb1:59b3 dev ens4 table local proto kernel metric 0 pref medium
multicast ff00::/8 dev ens4 table local proto kernel metric 256 pref medium

  3. Agrega una regla de enrutamiento basada en políticas de origen.

    El siguiente comando agrega una regla para enrutar todos los paquetes salientes que se originan en una subred especificada. Si la dirección de origen coincide con la subred, el sistema usa la ruta predeterminada definida en la tabla 1 para reenviar el tráfico.

    sudo ip -6 rule add from SUBNET_RANGE table 1

  4. Para ver la lista de reglas de enrutamiento de políticas, ejecuta el siguiente comando.

    ip -6 rule show

    El resultado es el siguiente:

    0:      from all lookup local
32765:  from fd20:307:120c:2000::/64 lookup 1
32766:  from all lookup main

    La línea con from fd20:... lookup 1 es la regla que agregaste, que le indica al kernel que use la tabla de enrutamiento 1 para el tráfico que se origina en esa subred.

  5. Permite que el servidor se vincule a una dirección IPv6 no local, la VIP del balanceador de cargas.

    sudo sysctl -w net.ipv6.ip_nonlocal_bind=1