Configurar la conmutación por error de los balanceadores de carga de red de paso a través internos

En esta guía se usa un ejemplo para mostrarte cómo configurar la conmutación por error de un balanceador de carga de red interno de transferencia directa Google Cloud . Antes de seguir esta guía, familiarícese con lo siguiente:

Permisos

Para seguir esta guía, debes crear instancias y modificar una red en un proyecto. Debes tener el rol de propietario o editor del proyecto, o bien tener todos los roles de gestión de identidades y accesos de Compute Engine siguientes:

Tarea Rol obligatorio
Crear redes, subredes y componentes de balanceador de carga Administrador de red
Añadir y eliminar reglas de cortafuegos Administrador de seguridad
Crear instancias Administrador de instancias de Compute

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

Configuración

En esta guía se explica cómo configurar y probar un balanceador de carga de red interno de tipo pasarela que usa la conmutación por error. En los pasos de esta sección se describe cómo configurar lo siguiente:

  1. Una red de VPC de ejemplo con subredes personalizadas
  2. Reglas de cortafuegos que permiten las conexiones entrantes a las VMs de backend
  3. VMs de backend:
    • Un backend principal en un grupo de instancias sin gestionar de la zona us-west1-a
    • Un backend de conmutación por error en un grupo de instancias sin gestionar de la zona us-west1-c
  4. Una máquina virtual de cliente para probar las conexiones y observar el comportamiento de la conmutación por error
  5. Los siguientes componentes del balanceador de carga de red de paso a través interno:
    • Una comprobación del estado del servicio de backend
    • Un servicio de backend interno en la región us-west1 para gestionar la distribución de conexiones entre las VMs de backend
    • Una regla de reenvío interna y una dirección IP interna para el frontend del balanceador de carga

La arquitectura de este ejemplo es la siguiente:

Ejemplo sencillo de conmutación por error de un balanceador de carga de red de paso a través interno.
Ejemplo de conmutación por error simple de un balanceador de carga de red de paso a través interno (haz clic para ampliar la imagen).

En este ejemplo, los grupos de instancias sin gestionar se usan tanto para los back-ends principales como para los de conmutación por error. Para obtener más información, consulta la sección sobre los grupos de instancias admitidos.

Configurar una red, una región y una subred

En este ejemplo se usan la siguiente red de VPC, región y subred:

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

Consola

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

    Ir a redes de VPC

  2. Haz clic en Crear red VPC.

  3. Asigne un Nombre de lb-network.

  4. En la sección Subredes:

    • Elige Personalizado en Modo de creación de subred.
    • En la sección Nueva subred, introduce la siguiente información:
      • Nombre: lb-subnet
      • Región: us-west1
      • Intervalo de direcciones IP: 10.1.2.0/24
      • Haz clic en Listo.

  5. Haz clic en Crear.

gcloud

  1. Crea la red VPC personalizada:

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

  2. Crea una subred en la red lb-network de la región us-west1:

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

API

Haz 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
}

Haz una solicitud POST al método subnetworks.insert. Sustituye PROJECT_ID por el ID de tu proyecto. Google Cloud

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
}

Configurar reglas de cortafuegos

En este ejemplo se usan las siguientes reglas de cortafuegos:

  • fw-allow-lb-subnet: una regla de entrada aplicable a todos los destinos de la red VPC que permite el tráfico de fuentes del intervalo 10.1.2.0/24. Esta regla permite el tráfico entrante de cualquier fuente dentro de lb-subnet a las instancias (VMs) que se están balanceando.

  • fw-allow-ssh: regla de entrada aplicada a las instancias que se están balanceando, que permite la conectividad SSH entrante en el puerto TCP 22 desde cualquier dirección. Puede elegir un intervalo de IPs de origen más restrictivo para esta regla. Por ejemplo, puede especificar los intervalos de IPs de los sistemas desde los que tiene previsto iniciar sesiones SSH. En este ejemplo se usa la etiqueta de destino allow-ssh para identificar las VMs a las que se aplica la regla de cortafuegos.

  • fw-allow-health-check: una regla de entrada, aplicable a las instancias con balanceo de carga, que permite el tráfico de los sistemas de comprobación del 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 se debe aplicar.

Sin estas reglas de cortafuegos, la regla denegar predeterminada de entrada bloquea el tráfico entrante a las instancias de backend.

Consola

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

    Ir a Políticas de cortafuegos

  2. Haz clic en Crear regla de cortafuegos e introduce la siguiente información para crear la regla que permita el tráfico de subred:

    • Nombre: fw-allow-lb-subnet
    • Red: lb-network
    • Prioridad: 1000
    • Dirección del tráfico: entrada
    • Acción tras coincidencia: permitir
    • Destinos: todas las instancias de la red
    • Filtro de origen: Intervalos de IPv4
    • Intervalos de IPv4 de origen: 10.1.2.0/24
    • Protocolos y puertos: permitir todos

  3. Haz clic en Crear.

  4. Vuelve a hacer clic en Crear regla de cortafuegos para crear la regla que permita las conexiones SSH entrantes:

    • Nombre: fw-allow-ssh
    • Red: lb-network
    • Prioridad: 1000
    • Dirección del tráfico: entrada
    • Acción tras coincidencia: permitir
    • Destinos: etiquetas de destino especificadas
    • Etiquetas de destino: allow-ssh
    • Filtro de origen: Intervalos de IPv4
    • Intervalos de IPv4 de origen: 0.0.0.0/0
    • Protocolos y puertos: elige Protocolos y puertos especificados y, a continuación, escribe tcp:22.

  5. Haz clic en Crear.

  6. Haz clic en Crear regla de cortafuegos por tercera vez para crear la regla que permita las comprobaciones del estado:Google Cloud

    • Nombre: fw-allow-health-check
    • Red: lb-network
    • Prioridad: 1000
    • Dirección del tráfico: entrada
    • Acción tras coincidencia: permitir
    • Destinos: etiquetas de destino especificadas
    • Etiquetas de destino: allow-health-check
    • Filtro de origen: Intervalos de IPv4
    • Intervalos de IPv4 de origen: 130.211.0.0/22 y 35.191.0.0/16
    • Protocolos y puertos: permitir todos

  7. Haz clic en Crear.

gcloud

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

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

  2. Crea la regla de cortafuegos fw-allow-ssh para permitir la conectividad SSH a las VMs con la etiqueta de red allow-ssh. Si omite source-ranges, Google Cloud interpreta que la regla se aplica a 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 Google Cloud las comprobaciones del estado.

    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 cortafuegos fw-allow-lb-subnet haciendo una solicitud POST al método firewalls.insert. Sustituye PROJECT_ID por el ID de tu proyecto. Google Cloud

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

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

Crea la regla de cortafuegos fw-allow-ssh haciendo una solicitud POST al método firewalls.insert. Sustituye PROJECT_ID por el ID de tu proyecto. Google Cloud

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 cortafuegos fw-allow-health-check haciendo una solicitud POST al método firewalls.insert. Sustituye PROJECT_ID por el ID de tu proyecto. Google Cloud

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
}

Crear VMs y grupos de instancias de backend

En este paso, crearás las VMs de backend y los grupos de instancias sin gestionar:

  • El grupo de instancias ig-a de us-west1-a es un backend principal con dos VMs:
    • vm-a1
    • vm-a2
  • El grupo de instancias ig-c de us-west1-c es un backend de conmutación por error con dos VMs:
    • vm-c1
    • vm-c2

Los back-ends principal y de conmutación por error se colocan en zonas independientes para que las instrucciones sean más claras y para gestionar la conmutación por error en caso de que una de las zonas deje de funcionar.

Cada VM principal y de copia de seguridad está configurada para ejecutar un servidor web Apache en los puertos TCP 80 y 443. A cada VM se le asigna una dirección IP interna en lb-subnet para el acceso de los clientes y una dirección IP externa (pública) efímera para el acceso SSH. Para obtener información sobre cómo quitar direcciones IP externas, consulta el artículo sobre cómo quitar direcciones IP externas de máquinas virtuales de backend.

De forma predeterminada, Apache está configurado para enlazarse a cualquier dirección IP. Los balanceadores de carga de red de paso a través internos envían paquetes conservando la dirección IP de destino.

Asegúrate de que el software del servidor que se ejecuta en tus máquinas virtuales principal y de copia de seguridad esté escuchando en la dirección IP de la regla de reenvío interna del balanceador de carga. Si configuras varias reglas de reenvío internas, asegúrate de que tu software escuche la dirección IP interna asociada a cada una de ellas. La dirección IP de destino de un paquete que un balanceador de carga de red pasante interno entrega a una máquina virtual de backend es la dirección IP interna de la regla de reenvío.

Para simplificar las instrucciones, todas las máquinas virtuales principales y de copia de seguridad ejecutan Debian GNU/Linux 12.

Consola

Crear VMs de backend

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

    Ir a instancias de VM

  2. Repite los pasos siguientes para crear cuatro VMs con 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. Asigna el Nombre como se indica en el paso 2.

  5. En Región, elige us-west1 y, en Zona, selecciona la opción que se indica en el paso 2.

  6. En la sección Disco de arranque, comprueba que la imagen seleccionada sea Debian GNU/Linux 12 (bookworm). Haz clic en Elegir para cambiar la imagen si es necesario.

  7. Haz clic en Advanced options (Opciones avanzadas).

  8. Haga clic en Redes y configure los siguientes campos:

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

  9. Haz clic en Gestión. Introduce la siguiente secuencia de comandos en el campo Secuencia de comandos de inicio. El contenido de la secuencia de comandos es idéntico en las cuatro VMs:

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

  10. Haz clic en Crear.

Crear grupos de instancias

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

    Ir a Grupos de instancias

  2. Repite los pasos siguientes para crear dos grupos de instancias no gestionados, cada uno con dos VMs, usando estas combinaciones.

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

  3. Haz clic en Crear grupo de instancias.

  4. Haga clic en Nuevo grupo de instancias sin gestionar.

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

  6. En la sección Ubicación, elija us-west1 en Región y, a continuación, seleccione una Zona como se indica en el paso 2.

  7. En Red, escribe lb-network.

  8. En Subred, introduce lb-subnet.

  9. En la sección Instancias de VM, añade las VMs como se indica en el paso 2.

  10. Haz clic en Crear.

gcloud

  1. Crea cuatro VMs ejecutando el siguiente comando cuatro veces y usando estas cuatro combinaciones para VM_NAME y ZONE. El contenido de la secuencia de comandos es idéntico en las cuatro VMs.

    • VM_NAME de vm-a1 y ZONE de us-west1-a
    • VM_NAME de vm-a2 y ZONE de us-west1-a
    • VM_NAME de vm-c1 y ZONE de us-west1-c
    • VM_NAME de vm-c2 y ZONE de 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
      apt-get update
      apt-get install apache2 -y
      a2ensite default-ssl
      a2enmod ssl
      vm_hostname="$(curl -H "Metadata-Flavor:Google" \
      http://metadata.google.internal/computeMetadata/v1/instance/name)"
      echo "Page served from: $vm_hostname" | \
      tee /var/www/html/index.html
      systemctl restart apache2'

  2. Crea los dos grupos de instancias sin gestionar 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. Añade las VMs a los grupos de instancias correspondientes:

    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

Crea cuatro VMs backend haciendo cuatro solicitudes POST al método instances.insert.

En las cuatro VMs, usa los siguientes nombres y zonas:

  • VM_NAME de vm-a1 y ZONE de us-west1-a
  • VM_NAME de vm-a2 y ZONE de us-west1-a
  • VM_NAME de vm-c1 y ZONE de us-west1-c
  • VM_NAME de vm-c2 y ZONE de us-west1-c

Haz los cambios siguientes:

  • PROJECT_ID: tu ID de proyecto
  • ZONE: la zona de la instancia

  • DEBIAN_IMAGE_NAME: el nombre de la imagen de Debian de la instancia. La DEBIAN_IMAGE_NAME actual se puede obtener ejecutando el siguiente comando gcloud:

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

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\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\nsystemctl restart apache2"
     }
   ]
 },
 "scheduling": {
   "preemptible": false
 },
 "deletionProtection": false
}

Crea dos grupos de instancias haciendo una solicitud POST al método instanceGroups.insert. Sustituye PROJECT_ID por el ID de tu proyecto. Google Cloud

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

Añade instancias a cada grupo de instancias haciendo una solicitud POST al método instanceGroups.addInstances. Sustituye PROJECT_ID por el ID de tu proyecto. Google Cloud

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"
   }
 ]
}

Crear una VM cliente

En este ejemplo, se crea una VM de cliente (vm-client) en la misma región que el balanceador de carga. El cliente se usa para demostrar cómo funciona la conmutación por error.

Consola

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

    Ir a instancias de VM

  2. Haz clic en Crear instancia.

  3. Asigna el valor vm-client a Nombre.

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

  5. Haz clic en Advanced options (Opciones avanzadas).

  6. Haga clic en Redes y configure los siguientes campos:

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

  7. Haz clic en Crear.

gcloud

La VM cliente puede estar en cualquier zona de la misma región que el balanceador de carga y puede usar cualquier subred de esa región. En este ejemplo, el cliente está en la zona us-west1-a y usa la misma subred que las VMs principal y de copia de seguridad.

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

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

Haz los cambios siguientes:

  • PROJECT_ID: tu ID de proyecto

  • DEBIAN_IMAGE_NAME: el nombre de la imagen de Debian de la instancia. La DEBIAN_IMAGE_NAME actual se puede obtener ejecutando el siguiente comando gcloud:

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

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
}

Configurar componentes de balanceadores de carga

En estos pasos se configuran todos los componentes del balanceador de carga de red de pases interno, empezando por la comprobación de estado y el servicio de backend, y, a continuación, los componentes de frontend:

  • Comprobación del estado: en este ejemplo se usa una comprobación del estado de HTTP que simplemente comprueba si hay una respuesta HTTP 200 (Correcto). Para obtener más información, consulta la sección de comprobaciones del estado del artículo sobre el balanceador de carga de red interno de pases.

  • Servicio de backend: como el ejemplo envía tráfico HTTP a través del balanceador de carga, la configuración especifica TCP, no UDP. Para ilustrar la conmutación por error, este servicio de backend tiene una proporción de conmutación por error de 0.75.

  • Regla de reenvío: en este ejemplo se crea una única regla de reenvío interna.

  • Dirección IP interna: en este ejemplo, especificamos una dirección IP interna, 10.1.2.99, al crear la regla de reenvío.

Consola

Iniciar la configuración

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

    Ir a Balanceo de carga

  2. Haga clic en Crear balanceador de carga.
  3. En Tipo de balanceador de carga, selecciona Balanceador de carga de red (TCP/UDP/SSL) y haz clic en Siguiente.
  4. En Proxy o pasarela, selecciona Balanceador de carga de pasarela y haz clic en Siguiente.
  5. En Público o interno, selecciona Interno y haz clic en Siguiente.
  6. Haz clic en Configurar.

Configuración básica

  1. Asigna el valor be-ilb a Nombre.
  2. Define Región como us-west1.
  3. Selecciona Red y, a continuación, lb-network.
  4. Haz clic en Configuración de backend y haz los siguientes cambios:
    1. En Backends (Back-ends), en la sección New item (Nuevo elemento), seleccione el grupo de instancias ig-a. Comprueba que la opción Usar este grupo de instancias como grupo de conmutaciones por error alternativo no esté marcada. Haz clic en Hecho.
    2. Haz clic en Añadir backend. En la sección Nuevo elemento que aparece, selecciona el grupo de instancias ig-c. Marca Usar este grupo de instancias como grupo de conmutaciones por error alternativo. Haz clic en Listo.
    3. En Comprobación del estado, elige Crear otra comprobación del estado, introduce la siguiente información y haz clic en Guardar y continuar:
      • Nombre: hc-http-80
      • Protocolo: HTTP
      • Puerto: 80
      • Protocolo de proxy: NONE
      • Ruta de la solicitud: / Ten en cuenta que, cuando usas la consola Google Cloud para crear tu balanceador de carga, la comprobación del estado es global. Si quieres crear una comprobación del estado regional, usa gcloud o la API.
    4. Haz clic en Configuraciones avanzadas. En la sección Política de conmutación por error, configure lo siguiente:
      • Índice de conmutación por error: 0.75
      • Marca Habilitar desviación de conexiones al producirse una conmutación por error.
    5. Comprueba que haya una marca de verificación azul junto a Configuración del backend antes de continuar. Si no es así, revisa este paso.
  5. Haz clic en Configuración de frontend. En la sección IP de frontend y puerto nuevos, haz los siguientes cambios:
    1. Nombre: fr-ilb
    2. Subred: ilb-subnet
    3. En IP interna, elige Reservar dirección IP estática interna, introduce la siguiente información y haz clic en Reservar:
      • Nombre: ip-ilb
      • Dirección IP estática: Quiero elegir
      • Dirección IP personalizada: 10.1.2.99
    4. Puertos: elige Único e introduce 80 en el campo Número de puerto.
    5. Verifica que haya una marca de verificación azul junto a Configuración del frontend antes de continuar. Si no es así, revisa este paso.
  6. Haz clic en Revisar y finalizar. Comprueba tu configuración.
  7. Haz clic en Crear.

gcloud

  1. Crea una comprobación del estado de HTTP para probar la conectividad TCP a las VMs en el puerto 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 \
    --failover-ratio 0.75

  3. Añade el backend principal 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

  4. Añade el backend de failover al servicio backend:

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

  5. Crea una regla de reenvío para el servicio de backend. Cuando cree la regla de reenvío, especifique 10.1.2.99 para la IP interna de 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 \
    --backend-service=be-ilb \
    --backend-service-region=us-west1

API

Para crear la comprobación del estado, haz una solicitud POST al método regionHealthChecks.insert. Sustituye PROJECT_ID por el ID de tu proyecto.

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 backend regional haciendo una solicitud POST al método regionBackendServices.insert. Sustituye PROJECT_ID por el ID de tu proyecto.

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"
    "failover": true
  }
],
"failoverPolicy": {
  "failoverRatio": 0.75
},
"healthChecks": [
  "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/healthChecks/hc-http-80"
],
"loadBalancingScheme": "INTERNAL",
"connectionDraining": {
  "drainingTimeoutSec": 0
 }
}

Crea la regla de reenvío haciendo una solicitud POST al método forwardingRules.insert. Sustituye PROJECT_ID por el ID de tu proyecto.

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

Pruebas

Estas pruebas muestran cómo validar la configuración del balanceador de carga y cómo conocer su comportamiento esperado.

Procedimiento de prueba de cliente

Este procedimiento se pone en contacto con el balanceador de carga desde la VM cliente. Seguirás este procedimiento para completar las demás pruebas.

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

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

  2. Haz una solicitud web al balanceador de carga mediante curl para ponerte en contacto con su dirección IP.

    curl http://10.1.2.99

  3. Fíjate en el texto devuelto por el comando curl. El nombre de la VM backend que genera la respuesta se muestra en ese texto. Por ejemplo: Page served from: vm-a1

Prueba del estado inicial

Una vez que hayas configurado el balanceador de carga de ejemplo, las cuatro VMs de backend deberían estar en buen estado:

  • Las dos máquinas virtuales principales, vm-a1 y vm-a2
  • las dos VMs de copia de seguridad, vm-c1 y vm-c2

Sigue el procedimiento de prueba del cliente. Repite el segundo paso varias veces. Lo normal es que el tráfico se sirva mediante las dos máquinas virtuales principales, vm-a1 y vm-a2, ya que ambas están en buen estado. Deberías ver que cada VM principal sirve una respuesta aproximadamente la mitad del tiempo, porque no se ha configurado ninguna afinidad de sesión para este balanceador de carga.

Prueba de conmutación por error

Esta prueba simula el fallo de vm-a1 para que puedas observar el comportamiento de la conmutación por error.

  1. Conéctate a la VM vm-a1.

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

  2. Detén el servidor web Apache. Después de diez segundos, Google Cloudconsidera que esta VM no está en buen estado. (La comprobación del estado hc-http-80 que has creado en la configuración usa el intervalo de comprobación predeterminado de cinco segundos y el umbral de mal estado de dos sondeos fallidos consecutivos).

    sudo apachectl stop

  3. Sigue el procedimiento de prueba del cliente. Repite el segundo paso varias veces. Lo normal es que el tráfico se publique en las dos VMs de copia de seguridad, vm-c1 y vm-c2. Como solo hay una VM principal en buen estado (vm-a2), la proporción de VMs principales en buen estado con respecto al total de VMs principales es 0.5. Este número es inferior al umbral de conmutación por error de 0.75, por lo queGoogle Cloud ha vuelto a configurar el grupo activo del balanceador de carga para que use las VMs de copia de seguridad. Deberías ver que cada VM de copia de seguridad responde aproximadamente la mitad del tiempo siempre que no se haya configurado ninguna afinidad de sesión para este balanceador de carga.

Prueba de conmutación por error

Esta prueba simula una conmutación por recuperación reiniciando el servidor Apache en vm-a1.

  1. Conéctate a la VM vm-a1.

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

  2. Inicia el servidor web Apache y espera 10 segundos.

    sudo apachectl start

  3. Sigue el procedimiento de prueba del cliente. Repite el segundo paso varias veces. Lo normal es que el tráfico se publique en las dos máquinas virtuales principales, vm-a1 y vm-a2. Como ambas VMs principales están en buen estado, la proporción de VMs principales en buen estado con respecto al total de VMs principales es 1.0, que es superior al umbral de conmutación por error de 0.75, por lo que Google Cloud ha configurado el grupo activo para que vuelva a usar las VMs principales.

Añadir más VMs de backend

En esta sección se amplía la configuración de ejemplo añadiendo más VMs principales y de copia de seguridad al balanceador de carga. Para ello, crea dos grupos de instancias de backend más para demostrar que puedes distribuir las VMs principales y de copia de seguridad entre varias zonas de la misma región:

  • Un tercer grupo de instancias, ig-d en us-west1-c, actúa como backend principal con dos VMs:
    • vm-d1
    • vm-d2
  • Un cuarto grupo de instancias, ig-b en us-west1-a, actúa como backend de conmutación por error con dos VMs:
    • vm-b1
    • vm-b2

La arquitectura modificada de este ejemplo es la siguiente:

Conmutación por error de balanceadores de carga de red de paso a través internos multizona.
Conmutación por error del balanceador de carga de red de paso a través interno multizona (haz clic para ampliar).

Crear más VMs y grupos de instancias

Sigue estos pasos para crear las VMs principales y de copia de seguridad adicionales, así como los grupos de instancias no gestionados correspondientes.

Consola

Crear VMs de backend

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

    Ir a instancias de VM

  2. Repite los pasos siguientes para crear cuatro VMs con las siguientes combinaciones de nombre y zona.

    • Nombre: vm-b1, zona: us-west1-a
    • Nombre: vm-b2, zona: us-west1-a
    • Nombre: vm-d1, zona: us-west1-c
    • Nombre: vm-d2, zona: us-west1-c

  3. Haz clic en Crear instancia.

  4. Asigna el Nombre como se indica en el paso 2.

  5. En Región, elige us-west1 y, en Zona, selecciona la opción que se indica en el paso 2.

  6. En la sección Disco de arranque, comprueba que la imagen seleccionada sea Debian GNU/Linux 12 (bookworm). Haz clic en Elegir para cambiar la imagen si es necesario.

  7. Haz clic en Opciones avanzadas y haz los siguientes cambios:

    • Haga clic en Redes y añada las siguientes etiquetas de red: allow-ssh y allow-health-check.
    • Haz clic en el botón de edición situado debajo de Interfaces de red y haz los siguientes cambios. A continuación, haz clic en Hecho:
      • Red: lb-network
      • Subred: lb-subnet
      • IP interna principal: efímera (automática)
      • IP externa: efímera

    • Haz clic en Gestión. En el campo Startup script (Secuencia de comandos de inicio), copia y pega el siguiente contenido de la secuencia de comandos. El contenido de la secuencia de comandos es idéntico en las cuatro VMs:

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

  8. Haz clic en Crear.

Crear grupos de instancias

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

    Ir a Grupos de instancias

  2. Repite los pasos siguientes para crear dos grupos de instancias no gestionados, cada uno con dos VMs, usando estas combinaciones.

    • Grupo de instancias: ig-b, zona: us-west1-a, VMs: vm-b1 y vm-b2
    • Grupo de instancias: ig-d, zona: us-west1-c, VMs: vm-d1 y vm-d2

  3. Haz clic en Crear grupo de instancias.

  4. Haga clic en Nuevo grupo de instancias sin gestionar.

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

  6. En la sección Ubicación, elija us-west1 en Región y, a continuación, seleccione una Zona como se indica en el paso 2.

  7. En Red, escribe lb-network.

  8. En Subred, introduce lb-subnet.

  9. En la sección Instancias de VM, añade las VMs como se indica en el paso 2.

  10. Haz clic en Crear.

gcloud

  1. Crea cuatro VMs ejecutando el siguiente comando cuatro veces y usando estas cuatro combinaciones para VM_NAME y ZONE. El contenido de la secuencia de comandos es idéntico en las cuatro VMs.

    • VM_NAME de vm-b1 y ZONE de us-west1-a
    • VM_NAME de vm-b2 y ZONE de us-west1-a
    • VM_NAME de vm-d1 y ZONE de us-west1-c
    • VM_NAME de vm-d2 y ZONE de 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
      apt-get update
      apt-get install apache2 -y
      a2ensite default-ssl
      a2enmod ssl
      vm_hostname="$(curl -H "Metadata-Flavor:Google" \
      http://metadata.google.internal/computeMetadata/v1/instance/name)"
      echo "Page served from: $vm_hostname" | \
      tee /var/www/html/index.html
      systemctl restart apache2'

  2. Crea los dos grupos de instancias sin gestionar en cada zona:

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

  3. Añade las VMs a los grupos de instancias correspondientes:

    gcloud compute instance-groups unmanaged add-instances ig-b \
    --zone=us-west1-a \
    --instances=vm-b1,vm-b2
gcloud compute instance-groups unmanaged add-instances ig-d \
    --zone=us-west1-c \
    --instances=vm-d1,vm-d2

API

Crea cuatro VMs backend haciendo cuatro solicitudes POST al método instances.insert.

En las cuatro VMs, usa los siguientes nombres y zonas:

  • VM_NAME de vm-b1 y ZONE de us-west1-a
  • VM_NAME de vm-b2 y ZONE de us-west1-a
  • VM_NAME de vm-d1 y ZONE de us-west1-c
  • VM_NAME de vm-d2 y ZONE de us-west1-c

Haz los cambios siguientes:

  • PROJECT_ID: tu ID de proyecto

  • DEBIAN_IMAGE_NAME: el nombre de la imagen de Debian de la instancia. La DEBIAN_IMAGE_NAME actual se puede obtener ejecutando el siguiente comando gcloud:

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

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\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\nsystemctl restart apache2"
     }
   ]
 },
 "scheduling": {
   "preemptible": false
 },
 "deletionProtection": false
}

Crea dos grupos de instancias haciendo una solicitud POST al método instanceGroups.insert. Sustituye PROJECT_ID por el ID de tu proyecto.

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

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

Añade instancias a cada grupo de instancias haciendo una solicitud POST al método instanceGroups.addInstances. Sustituye PROJECT_ID por el ID de tu proyecto.

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

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

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

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

Añadir un backend principal

Puedes usar este procedimiento como plantilla para añadir un grupo de instancias no gestionado al servicio de backend de un balanceador de carga de red interno de transferencia directa como backend principal. En la configuración de ejemplo, este procedimiento muestra cómo añadir el grupo de instancias ig-d como backend principal al balanceador de carga be-ilb.

Consola

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

    Ir a Balanceo de carga

  2. En la pestaña Balanceadores de carga, haz clic en el nombre de un balanceador de carga TCP interno o UDP interno (en este ejemplo, be-ilb).

  3. Haz clic en Editar .

  4. En Configuración de backend, haga clic en Añadir backend y seleccione un grupo de instancias no gestionado (en este ejemplo, ig-d).

  5. Asegúrate de que la opción Usar este grupo de instancias como grupo de conmutaciones por error alternativo no esté marcada.

  6. Haz clic en Hecho y, a continuación, en Actualizar.

gcloud

Usa el siguiente comando gcloud para añadir un backend principal al servicio de backend de un balanceador de carga de red interno de transferencia existente.

gcloud compute backend-services add-backend BACKEND_SERVICE_NAME \
   --instance-group INSTANCE_GROUP_NAME \
   --instance-group-zone INSTANCE_GROUP_ZONE \
   --region REGION

Haz los cambios siguientes:

  • BACKEND_SERVICE_NAME: el nombre del servicio de backend del balanceador de carga. En este ejemplo, usa be-ilb.
  • INSTANCE_GROUP_NAME: el nombre del grupo de instancias que se va a añadir como backend principal. En este ejemplo, usa ig-d.
  • INSTANCE_GROUP_ZONE: es la zona en la que se define el grupo de instancias. En este ejemplo, usa us-west1-c.
  • REGION: la región del balanceador de carga. En este ejemplo, usa us-west1.

API

Añade un backend principal a un servicio de backend que ya tengas con el método regionBackendServices.patch.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION/backendServices/BACKEND_SERVICE_NAME

{
  "backends":
  [
    {
      "balancingMode": "connection",
      "failover": false,
      "group": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/INSTANCE_GROUP_ZONE/instanceGroups/INSTANCE_GROUP_NAME"
    }
  ]
}

Haz los cambios siguientes:

  • PROJECT_ID: tu ID de proyecto
  • REGION: la región del balanceador de carga. Por ejemplo, usa us-west1.
  • BACKEND_SERVICE_NAME: el nombre del servicio de backend del balanceador de carga. En este ejemplo, usa be-ilb.
  • INSTANCE_GROUP_NAME: el nombre del grupo de instancias que se va a añadir como backend principal. En este ejemplo, usa ig-d.
  • INSTANCE_GROUP_ZONE: la zona en la que se define el grupo de instancias. En este ejemplo, usa us-west1-c.

Añadir un backend de failover

Puedes usar este procedimiento como plantilla para añadir un grupo de instancias no gestionado al servicio de backend de un balanceador de carga de red interno de transferencia directa como backend de conmutación por error. En la configuración de ejemplo, este procedimiento muestra cómo añadir el grupo de instancias ig-b como backend de conmutación por error al balanceador de carga be-ilb.

Consola

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

    Ir a Balanceo de carga

  2. En la pestaña Balanceadores de carga, haga clic en el nombre de un balanceador de carga de tipo TCP/UDP (interno) (en este ejemplo, be-ilb).

  3. Haz clic en Editar .

  4. En Configuración de backend, haga clic en Añadir backend y seleccione un grupo de instancias no gestionado (en este ejemplo, ig-b).

  5. Marca Usar este grupo de instancias como grupo de conmutaciones por error alternativo.

  6. Haz clic en Hecho y, a continuación, en Actualizar.

gcloud

Usa el siguiente comando gcloud para añadir un backend de failover al servicio de backend de un balanceador de carga de red de paso a través interno.

gcloud compute backend-services add-backend BACKEND_SERVICE_NAME \
   --instance-group INSTANCE_GROUP_NAME \
   --instance-group-zone INSTANCE_GROUP_ZONE \
   --region REGION \
   --failover

Haz los cambios siguientes:

  • BACKEND_SERVICE_NAME: el nombre del servicio de backend del balanceador de carga. En este ejemplo, usa be-ilb.
  • INSTANCE_GROUP_NAME: el nombre del grupo de instancias que se va a añadir como backend principal. En este ejemplo, usa ig-b.
  • INSTANCE_GROUP_ZONE: es la zona en la que se define el grupo de instancias. En este ejemplo, usa us-west1-a.
  • REGION es la región del balanceador de carga. En este ejemplo, usa us-west1.

API

Añade un backend de failover a un servicio backend con el método regionBackendServices.patch.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION/backendServices/BACKEND_SERVICE_NAME

{
  "backends":
  [
    {
      "balancingMode": "connection",
      "failover": true,
      "group": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/INSTANCE_GROUP_ZONE/instanceGroups/INSTANCE_GROUP_NAME"
    }
  ]
}

Haz los cambios siguientes:

  • PROJECT_ID: tu ID de proyecto
  • BACKEND_SERVICE_NAME: el nombre del servicio de backend del balanceador de carga. En este ejemplo, usa be-ilb.
  • INSTANCE_GROUP_NAME: el nombre del grupo de instancias que se va a añadir como backend principal. En este ejemplo, usa ig-b.
  • INSTANCE_GROUP_ZONE: es la zona en la que se define el grupo de instancias. En este ejemplo, usa us-west1-a.
  • REGION: la región del balanceador de carga. En este ejemplo, usa us-west1.

Convertir un backend principal o de failover

Puedes convertir un backend principal en un backend de failover o viceversa sin tener que quitar el grupo de instancias del servicio de backend del balanceador de carga de red de pases interno.

Consola

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

    Ir a Balanceo de carga

  2. En la pestaña Balanceadores de carga, haz clic en el nombre de un balanceador de carga de tipo TCP/UDP (interno).

  3. Haz clic en Editar .

  4. En Configuración de backend, haga clic en el nombre de uno de los grupos de instancias de backend. A continuación, haz lo siguiente:

    • Para convertir el grupo de instancias en un backend de conmutación por error, marca la opción Usar este grupo de instancias como grupo de conmutaciones por error alternativo.
    • Para que el grupo de instancias sea un backend principal, desmarca la opción Usar este grupo de instancias como grupo de conmutaciones por error alternativo.

  5. Haz clic en Hecho y, a continuación, en Actualizar.

gcloud

Usa el siguiente comando gcloud para convertir un backend principal en un backend de conmutación por error:

gcloud compute backend-services update-backend BACKEND_SERVICE_NAME \
   --instance-group INSTANCE_GROUP_NAME \
   --instance-group-zone INSTANCE_GROUP_ZONE \
   --region REGION \
   --failover

Usa el siguiente comando gcloud para convertir un backend de conmutación por error en un backend principal:

gcloud compute backend-services update-backend BACKEND_SERVICE_NAME \
   --instance-group INSTANCE_GROUP_NAME \
   --instance-group-zone INSTANCE_GROUP_ZONE \
   --region REGION \
   --no-failover

Haz los cambios siguientes:

  • BACKEND_SERVICE_NAME: el nombre del servicio de backend del balanceador de carga
  • INSTANCE_GROUP_NAME: el nombre del grupo de instancias que se va a añadir como backend principal.
  • INSTANCE_GROUP_ZONE: la zona en la que se define el grupo de instancias
  • REGION: la región del balanceador de carga

API

Convierte un backend principal en un backend de conmutación por error (o viceversa) mediante el método regionBackendServices.patch.

Para convertir un backend principal en un backend de failover, sigue estos pasos:

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION/backendServices/BACKEND_SERVICE_NAME

{
  "backends":
  [
    {
      "failover": true,
      "group": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/INSTANCE_GROUP_ZONE/instanceGroups/INSTANCE_GROUP_NAME"
    }
  ]
}

Para convertir un backend de failover en un backend principal, sigue estos pasos:

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION/backendServices/BACKEND_SERVICE_NAME

{
  "backends":
  [
    {
      "failover": false,
      "group": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/INSTANCE_GROUP_ZONE/instanceGroups/INSTANCE_GROUP_NAME"
    }
  ],
}

Haz los cambios siguientes:

  • PROJECT_ID: tu ID de proyecto
  • BACKEND_SERVICE_NAME: el nombre del servicio de backend del balanceador de carga
  • INSTANCE_GROUP_NAME: el nombre del grupo de instancias que se va a añadir como backend principal.
  • INSTANCE_GROUP_ZONE: la zona en la que se define el grupo de instancias
  • REGION: la región del balanceador de carga

Configurar políticas de conmutación por error

En esta sección se describe cómo gestionar una política de conmutación por error de un servicio de backend de un balanceador de carga de red interno de tipo pasarela. Una política de conmutación por error consta de lo siguiente:

  • Índice de conmutación por error
  • Eliminar el tráfico cuando todas las VMs de backend estén en mal estado
  • Vaciado de conexiones al producirse una conmutación por error

Para obtener más información sobre los parámetros de una política de conmutación por error, consulta los siguientes artículos:

Definir una política de conmutación por error

En las siguientes instrucciones se describe cómo definir la política de conmutación por error de un balanceador de carga de red interno de pases ya creado.

Consola

Para definir una política de conmutación por error mediante la consola Google Cloud , debes tener al menos un backend de conmutación por error.

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

    Ir a Balanceo de carga

  2. En la pestaña Balanceadores de carga, haz clic en el nombre de un balanceador de carga de tipo TCP/UDP (interno).

  3. Haz clic en Editar .

  4. Asegúrate de que tienes al menos un backend de conmutación por error. Al menos uno de los back-ends del balanceador de carga debe tener seleccionada la opción Usar este grupo de instancias como grupo de conmutación por error alternativo.

  5. Haz clic en Configuraciones avanzadas.

    • En Política de conmutación por error, asigna al Índice de conmutación por error un valor entre 0.0 y 1.0, ambos incluidos.
    • Marca la casilla situada junto a Habilitar eliminación de tráfico si quieres eliminar tráfico cuando todas las VMs activas y todas las VMs de copia de seguridad no estén en buen estado.
    • Marca la casilla situada junto a Habilitar desviación de conexiones al producirse una conmutación por error si quieres finalizar las conexiones actuales rápidamente durante la conmutación por error.

  6. Haz clic en Revisar y finalizar y, a continuación, en Actualizar.

gcloud

Para definir una política de conmutación por error con gcloud CLI, actualiza el servicio de backend del balanceador de carga:

gcloud compute backend-services update BACKEND_SERVICE_NAME \
   --region REGION \
   --failover-ratio FAILOVER_RATIO \
   --drop-traffic-if-unhealthy \
   --no-connection-drain-on-failover

Haz los cambios siguientes:

  • BACKEND_SERVICE_NAME: el nombre del servicio de backend del balanceador de carga. En este ejemplo, usa be-ilb.
  • REGION: la región del balanceador de carga. En este ejemplo, usa us-west1.
  • FAILOVER_RATIO: el índice de conmutación por error. Los valores posibles están comprendidos entre 0.0 y 1.0, ambos incluidos. En este ejemplo, usa 0.75.
  • --drop-traffic-if-unhealthy indica al balanceador de carga que elimine el tráfico cuando todas las VMs principales y todas las VMs de copia de seguridad no estén en buen estado. Cambia este valor a --no-drop-traffic-if-unhealthy si quieres distribuir el tráfico entre todas las VMs principales cuando todas las VMs de backend estén en mal estado.
  • --no-connection-drain-on-failover indica al balanceador de carga que cancele rápidamente las conexiones TCP existentes durante la conmutación por error. Usa --connection-drain-on-failover para habilitar la purga de conexión durante la conmutación por error.

API

Usa el método regionBackendServices.patch para definir la política de conmutación por error.

PATCH https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION/backendServices/BACKEND_SERVICE_NAME

{
  "failoverPolicy":
  {
    "failoverRatio": FAILOVER_RATIO,
    "dropTrafficIfUnhealthy": [true|false],
    "disableConnectionDrainOnFailover": [true|false]
  }
}

Haz los cambios siguientes:

  • PROJECT_ID: tu ID de proyecto
  • REGION: la región del balanceador de carga
  • BACKEND_SERVICE_NAME: el nombre del servicio de backend del balanceador de carga
  • FAILOVER_RATIO: el índice de conmutación por error. Los valores posibles están comprendidos entre 0.0 y 1.0, ambos incluidos.
  • Si se asigna el valor dropTrafficIfUnhealthy a true, se indica al balanceador de carga que elimine el tráfico cuando todas las VMs principales y todas las VMs de copia de seguridad no estén en buen estado. Asigna el valor false si quieres distribuir el tráfico entre todas las VMs principales cuando todas las VMs de backend estén en mal estado.
  • Si se asigna el valor disableConnectionDrainOnFailover a true, se indica al balanceador de carga que finalice rápidamente las conexiones TCP existentes cuando se realice una conmutación por error. Defina este valor en false para habilitar la purga de conexiones durante la conmutación por error.

Ver una política de conmutación por error

En las siguientes instrucciones se describe cómo ver la política de conmutación por error de un balanceador de carga de red de paso a través interno.

Consola

La Google Cloud consola muestra la configuración de la política de conmutación por error cuando editas un balanceador de carga de red pasante interno. Consulta las instrucciones para definir una política de conmutación por error.

gcloud

Para enumerar los ajustes de la política de conmutación por error con gcloud CLI, usa el siguiente comando. Los ajustes indefinidos de una política de conmutación por error usan los valores predeterminados de la política de conmutación por error.

gcloud compute backend-services describe BACKEND_SERVICE_NAME \
   --region REGION \
   --format="get(failoverPolicy)"

Haz los cambios siguientes:

  • BACKEND_SERVICE_NAME: el nombre del servicio de backend del balanceador de carga
  • REGION: la región del balanceador de carga

API

Usa el método regionBackendServices.get para ver la política de conmutación por error.

La respuesta a la solicitud de la API muestra la política de conmutación por error. A continuación, se muestra un ejemplo.

GET https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION/backendServices/BACKEND_SERVICE_NAME

Haz los cambios siguientes:

  • PROJECT_ID: tu ID de proyecto
  • REGION: la región del balanceador de carga
  • BACKEND_SERVICE_NAME: el nombre del servicio de backend del balanceador de carga
{
...
"failoverPolicy": {
  "disableConnectionDrainOnFailover": false,
  "dropTrafficIfUnhealthy": false,
  "failoverRatio": 0.75
...
}

Siguientes pasos