Configura la conmutación por error para balanceadores de cargas de red de transferencia internos

En esta guía, se usa un ejemplo a fin de enseñarte cómo configurar la conmutación por error para un balanceador de cargas de red interno de Google Cloud. Antes de seguir esta guía, familiarízate con los siguientes conceptos:

• Conceptos del balanceador de cargas de red de transferencia interna
• Conceptos de conmutación por error para balanceadores de cargas de red de transferencia internos
• Descripción general de las reglas de firewall
• Conceptos de verificación de estado

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 redes
Agrega y quita reglas de firewall	Administrador de seguridad
Crea instancias	Administrador de instancias de Compute

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

• Control de acceso
• Condiciones de IAM

Crear

En esta guía, se muestra cómo configurar y probar un balanceador de cargas de red interno de transferencia que usa la conmutación por error. En los pasos de esta sección, se describe cómo configurar los siguientes elementos:

1. Una red de VPC de muestra con subredes personalizadas
2. Reglas de firewall que permiten conexiones entrantes a VM de backend
3. VM de backend:
   • Un backend principal en un grupo de instancias no administrado en la zona us-west1-a
   • Un backend de conmutación por error en un grupo de instancias no administrado en la zona us-west1-c
4. Una VM cliente para probar conexiones y observar el comportamiento de conmutación por error
5. 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 entre las VM de backend
   • 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:

Ejemplo de conmutación por error simple para un balanceador de cargas de red de transferencia interno (haz clic para agrandar).

Nota: En este ejemplo, los grupos de instancias no administrados se usan para los backends principales y de conmutación por error. Para obtener más información, consulta los grupos de instancias compatibles.

Configura una red, una región y una subred

En este ejemplo, se usan la red de VPC, la región y la subred que se describen a continuación:

• Red: la red es una red de VPC de modo personalizado denominada lb-network.

• Región: La región es us-west1.

• Subnet: La subred, lb-subnet, usa el rango de IP 10.1.2.0/24.

Nota: Puedes cambiar el nombre de la red, la región y los parámetros de la subred; sin embargo, en los pasos posteriores de esta guía, se usan los parámetros de red, región y subred como se describió antes.

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

Consola

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

   Ir a las redes de VPC

2. Haga clic en Crear red de VPC.

3. En Nombre ingresa lb-network.

4. En la sección Subredes:

   • Establece Modo de creación de subred en Personalizado.
   • En la sección Nueva subred, ingresa la siguiente información:
     • Nombre: lb-subnet
     • Región: us-west1
     • Rangos de direcciones IP: 10.1.2.0/24
     • 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. Crea una subred en la red lb-network 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
   

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 una solicitud POST al método subnetworks.insert. Reemplaza PROJECT_ID por el ID del proyecto de Google Cloud.

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

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

Configura las reglas de firewall

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

• fw-allow-lb-subnet: Es una regla de entrada, aplicable a todos los destinos en la red de VPC, que permite el tráfico de fuentes en el rango 10.1.2.0/24. Esta regla permite que el tráfico entrante desde cualquier origen dentro de lb-subnet a las instancias (VM) en las que se realiza el balanceo de cargas.

• fw-allow-ssh: Es una regla de entrada aplicada a las instancias en las que se realiza el balanceo de cargas, 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 los rangos de IP de los sistemas desde los que planeas iniciar sesiones SSH. En este ejemplo, se usa la etiqueta de destino allow-ssh para identificar las VM a las que se aplica la regla de firewall.

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

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

Nota: Debes crear una regla de firewall para permitir las verificaciones de estado de los rangos de IP de los sistemas de sondeo de Google Cloud. Consulta los rangos de IP de sondeo para obtener más información.

Consola

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

   Ir a Políticas de firewall

2. Haz clic en Crear regla de firewall y, luego, ingresa la siguiente información para crear la regla a fin de permitir el tráfico de subred:

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

3. Haz clic en Crear.

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

   • Nombre: fw-allow-ssh
   • Red: lb-network
   • Prioridad: 1000
   • Dirección del tráfico: entrada
   • Acción si hay coincidencia: permitir
   • Objetivos: etiquetas de destino especificadas
   • Etiquetas de destino: allow-ssh
   • Filtro de fuente: Rangos de IPv4
   • Rangos de IPv4 de origen: 0.0.0.0/0
   • Protocolos y puertos: elige Protocolos y puertos especificados y escribe tcp:22

5. Haz clic en Crear.

6. Haz clic en Crear regla de firewall por tercera vez para crear la regla que permitirá las verificaciones de estado de Google Cloud:

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

7. Haz clic en Crear.

gcloud

1. Crea la regla de firewall 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 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-subnet mediante una solicitud POST al método firewalls.insert. Reemplaza PROJECT_ID por el ID del proyecto de Google Cloud.

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

{
 "name": "fw-allow-lb-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 firewall fw-allow-ssh mediante una solicitud POST al método firewalls.insert. Reemplaza PROJECT_ID por el ID del proyecto de Google Cloud.

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

{
 "name": "fw-allow-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. Reemplaza PROJECT_ID por el ID del proyecto de Google Cloud.

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

{
 "name": "fw-allow-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 grupos de instancias y VM de backend

En este paso, crearás las VM de backend y los grupos de instancias no administrados:

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

Los backends principales y de conmutación por error se colocan en zonas diferentes para favorecer la claridad de instrucción y manejar la conmutación por error en caso de que una zona se desconecte.

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 del cliente 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 Quita direcciones IP externas de VM de backend.

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

Asegúrate de que el software del servidor que se ejecuta en las VM principales y de copia de seguridad esté escuchando en 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 en 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 las instrucciones, todas las VM principales y de copia de seguridad ejecutan Debian GNU/Linux 10.

Console

Crea VM 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 siguientes pasos para crear cuatro VM 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. En Nombre establece lo que se indica en el paso 2.

5. En Región, elige 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 la imagen seleccionada sea Debian GNU/Linux 10 (buster). Haz clic en Elegir para cambiar la imagen si es necesario.

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-health-check y allow-ssh.
   2. En Interfaces de red, selecciona lo siguiente:
      • Red: lb-network
      • Subred: lb-subnet

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

   #! /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.

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.

   • Grupo de instancias: ig-a, zona: us-west1-a, VM: vm-a1 y vm-a2
   • Grupo de instancias: ig-c, zona: us-west1-c, VM: 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, ingresa lb-network.

8. En Subred, ingresa 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 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-10 \
       --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 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

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

Para las cuatro VM, usa los siguientes nombres de VM 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

Reemplaza lo siguiente:

• PROJECT_ID: Es el ID de tu proyecto.
• ZONE: Es la zona de la instancia.

• DEBIAN_IMAGE_NAME: El nombre de la imagen de Debian para la instancia. Para obtener el DEBIAN_IMAGE_NAME actual, ejecuta el siguiente comando de gcloud:

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

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 mediante una solicitud POST al método instanceGroups.insert. Reemplaza PROJECT_ID por el ID del proyecto de Google Cloud.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/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. Reemplaza PROJECT_ID por el ID del proyecto de Google Cloud.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/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"
   }
 ]
}

Crea una VM cliente

En este ejemplo, se crea una VM de cliente (vm-client) en la misma región que el balanceador de cargas. 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. Haga clic en Crear instancia.

3. Configura el campo Nombre como vm-client.

4. En Zona establece us-west1-a.

5. Haz clic en Opciones avanzadas.

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

7. Haz clic en Crear.

gcloud

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

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

API

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

Reemplaza lo siguiente:

• PROJECT_ID: El ID de tu proyecto

• DEBIAN_IMAGE_NAME: El nombre de la imagen de Debian para la instancia. Para obtener el DEBIAN_IMAGE_NAME actual, ejecuta el siguiente comando de gcloud:

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

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

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

Configura 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, se usa una verificación de estado HTTP que busca 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: Debido a que el ejemplo transmite tráfico HTTP a través del balanceador de cargas, 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 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 se crea la regla de reenvío.

Console

Inicia la 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. Configura el campo Nombre como be-ilb.
2. Establece la Región en us-west1.
3. Configura Red como lb-network.
4. Haz clic en Configuración de backend y realiza los siguientes cambios:
   1. En Backends, en la sección Elemento nuevo, selecciona el grupo de instancias ig-a. Asegúrate de que la opción Usar este grupo de instancias como grupo de conmutación por error para la copia de seguridad no esté marcada. Haz clic en Listo.
   2. Haz clic en Agregar backend. En la sección Elemento nuevo que aparece, selecciona el grupo de instancias ig-c. Marca Usar este grupo de instancias como grupo de conmutación por error para la copia de seguridad. Haz clic en Listo.
   3. En Verificación de estado, elige Crear otra verificación de estado, ingresa 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 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.
   4. Haz clic en Configuración avanzada. En la sección Política de conmutación por error, configura lo siguiente:
      • Proporción de conmutación por error: 0.75
      • Marca Habilitar el vaciado de conexiones en la conmutación por error.
   5. Verifica que haya una marca de verificación azul junto a Configuración de backend antes de continuar. Si no, revisa este paso.
5. Haz clic en Configuración de frontend. En la sección IP y puerto de frontend nuevos, realiza los siguientes cambios:
   1. Nombre: fr-ilb
   2. Subred: ilb-subnet
   3. En IP interna elige Reserva una nueva dirección IP interna estática, ingresa la siguiente información y haz clic en Reservar:
      • Nombre: ip-ilb
      • Dirección IP estática: permíteme elegir
      • Dirección IP personalizada: 10.1.2.99
   4. Puertos: elige Individual e ingresa 80 en el Número de puerto.
   5. Verifica que haya una marca de verificación azul junto a Configuración de frontend antes de continuar. Si no, revisa este paso.
6. Haz clic en Revisar y finalizar. Vuelve a verificar la configuración.
7. Haga clic en Crear.

gcloud

1. Crea una verificación de estado HTTP nueva para probar la conectividad TCP 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 \
       --failover-ratio 0.75
   

3. Agrega 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. Agrega el backend de conmutación por error al servicio de 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 crees la regla de reenvío, especifica 10.1.2.99 para la 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 \
       --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. Reemplaza PROJECT_ID con el ID del 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 de backend regional mediante una solicitud POST al método regionBackendServices.insert. Reemplaza PROJECT_ID con el ID del 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
 }
}

Para crear la regla de reenvío, realiza una solicitud POST al método forwardingRules.insert. Reemplaza PROJECT_ID con el ID del 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"
}

Prueba

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

Procedimiento de prueba del cliente

En este procedimiento, se contacta al balanceador de cargas desde la VM de cliente. Usarás este procedimiento para completar las otras pruebas.

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.

   curl http://10.1.2.99
   

3. Ten en cuenta el texto que muestra el comando curl. El nombre de la VM de backend que genera la respuesta se muestra en ese texto; por ejemplo: Page served from: vm-a1.

Realiza una prueba de estado inicial

Después de configurar el balanceador de cargas de ejemplo, las cuatro VM de backend deberían estar en buen estado:

• las dos VM principales, vm-a1 y vm-a2
• las dos VM de copia de seguridad, vm-c1 y vm-c2

Sigue el procedimiento de prueba del cliente. Repite el segundo paso varias veces. El comportamiento esperado es que las dos VM principales entreguen tráfico, vm-a1 y vm-a2, ya que ambas están en buen estado. Cada VM principal debería entregar una respuesta aproximadamente la mitad del tiempo porque no se configuró ninguna afinidad de sesión para este balanceador de cargas.

Realiza una prueba de conmutación por error

En esta prueba, se simula la falla de vm-a1 para que puedas observar el comportamiento de 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 Cloud considera que esta VM no está en buen estado. La verificación de estado hc-http-80 que creaste en la configuración usa el intervalo de comprobación predeterminado de cinco segundos y el límite 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. El comportamiento esperado es que vm-c1 y vm-c2, las dos VM de copia de seguridad, entreguen tráfico. Debido a que solo una VM principal, vm-a2, está en buen estado, la proporción de VM principales en buen estado respecto al total de VM principales es de 0.5. Este número es menor que el límite de conmutación por error de 0.75, por lo que Google Cloud volvió a configurar el grupo activo del balanceador de cargas para usar las VM de copia de seguridad. Deberías ver que cada VM de copia de seguridad entregue una respuesta aproximadamente la mitad del tiempo siempre y cuando no se haya configurado la afinidad de sesión para este balanceador de cargas.

Realiza una prueba de recuperación

En esta prueba, se simula la conmutación por recuperación mediante el reinicio del servidor de 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. El comportamiento esperado es que vm-a1 y vm-a2, las dos VM principales, entreguen tráfico. Con ambas VM principales en buen estado, la proporción de VM principales en buen estado respecto al total de VM principales es de 1.0, más que el límite de conmutación por error de 0.75, por lo que Google Cloud configuró el grupo activo para usar las VM principales otra vez.

Agrega más VM de backend

En esta sección, se amplía la configuración de ejemplo mediante el agregado de más VM principales y de copia de seguridad al balanceador de cargas. Para ello, se crean dos grupos de instancias de backend a fin de demostrar que puedes distribuir VM 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, funciona como backend principal con dos VM:
  • vm-d1
  • vm-d2
• Un cuarto grupo de instancias, ig-b en us-west1-a, funciona como un backend de conmutación por error con dos VM:
  • vm-b1
  • vm-b2

Así se ve la arquitectura modificada de este ejemplo:

Conmutación por error del balanceador de cargas de red de transferencia interna de múltiples zonas (haz clic para ampliar).

Crea VM y grupos de instancias adicionales

Sigue estos pasos para crear las VM principales y de copia de seguridad adicionales y sus grupos de instancias no administrados correspondientes.

Console

Crea VM 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 siguientes pasos para crear cuatro VM 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. En Nombre establece lo que se indica en el paso 2.

5. En Región, elige 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 la imagen seleccionada sea Debian GNU/Linux 10 (buster). Haz clic en Elegir para cambiar la imagen si es necesario.

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

   • Haz clic en Herramientas de redes y agrega las siguientes Etiquetas de red: allow-ssh y allow-health-check.
   • Haz clic en el botón Editar, en Interfaces de red, y realiza los siguientes cambios. Luego, haz clic en Listo:
     • Red: lb-network
     • Subred: lb-subnet
     • IP interna principal: efímera (automática)
     • IP externa: efímera

   • Haz clic en Administración. En el campo Secuencia de comandos de inicio, copia y pega el siguiente contenido de la secuencia de comandos. El contenido de secuencia de comandos es idéntico para las cuatro VM:

     #! /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.

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 los siguientes pasos para crear dos grupos de instancias no administrados, cada uno con dos VM, con estas combinaciones.

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

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, ingresa lb-network.

8. En Subred, ingresa 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 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-10 \
       --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 no administrados 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. Agrega las VM a los grupos de instancias adecuados:

   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 VM de backend mediante cuatro solicitudes POST al método instances.insert.

Para las cuatro VM, usa los siguientes nombres de VM 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

Reemplaza lo siguiente:

• PROJECT_ID: El ID de tu proyecto

• DEBIAN_IMAGE_NAME: El nombre de la imagen de Debian para la instancia. Para obtener el DEBIAN_IMAGE_NAME actual, ejecuta el siguiente comando de gcloud:

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

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 mediante una solicitud POST al método instanceGroups.insert. Reemplaza PROJECT_ID con el ID del 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"
}

Agrega instancias a cada grupo de instancias mediante una solicitud POST al método instanceGroups.addInstances. Reemplaza PROJECT_ID con el ID del 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"
   }
 ]
}

Agrega un backend principal

Puedes usar este procedimiento como una plantilla para agregar un grupo de instancias no administrado al servicio de backend de un balanceador de cargas de red de transferencia interna existente como un backend principal. Para la configuración de ejemplo, este procedimiento muestra cómo agregar el grupo de instancias ig-d como backend principal al balanceador de cargas be-ilb.

Consola

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

   Ir a Balanceo de cargas

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

3. Haz clic en Editar .

4. En Configuración de backend, haz clic en Agregar backend y selecciona un grupo de instancias no administrado (en este ejemplo, ig-d).

5. Asegúrate de que la opción Usar este grupo de instancias como grupo de conmutación por error para la copia de seguridad no esté marcada.

6. Haz clic en Listo y, luego, en Actualizar.

gcloud

Usa el siguiente comando de gcloud para agregar un backend principal a un servicio de backend del balanceador de cargas de red de transferencia interna existente.

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

Reemplaza lo siguiente:

• BACKEND_SERVICE_NAME es el nombre del servicio de backend del balanceador de cargas. Para el ejemplo, usa be-ilb.
• INSTANCE_GROUP_NAME es el nombre del grupo de instancias que se agregará como backend principal. Para el ejemplo, usa ig-d.
• INSTANCE_GROUP_ZONE es la zona en la que se define el grupo de instancias. Para el ejemplo, usa us-west1-c.
• REGION es la región del balanceador de cargas. Para el ejemplo, usa us-west1.

API

Agrega un backend principal a un servicio de backend existente 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"
    }
  ]
}

Reemplaza lo siguiente:

• PROJECT_ID: El ID de tu proyecto
• REGION es la región del balanceador de cargas. Para el ejemplo, usa us-west1.
• BACKEND_SERVICE_NAME es el nombre del servicio de backend del balanceador de cargas. Para el ejemplo, usa be-ilb.
• INSTANCE_GROUP_NAME es el nombre del grupo de instancias que se agregará como backend principal. Para el ejemplo, usa ig-d.
• INSTANCE_GROUP_ZONE es la zona en la que se define el grupo de instancias. Para el ejemplo, usa us-west1-c.

Agrega un backend de conmutación por error

Puedes usar este procedimiento como una plantilla para agregar un grupo de instancias no administrado al servicio de backend de un balanceador de cargas de red de transferencia interna existente como un backend de conmutación por error. Para la configuración de ejemplo, este procedimiento muestra cómo agregar el grupo de instancias ig-b como backend de conmutación por error al balanceador de cargas be-ilb.

Consola

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

   Ir a Balanceo de cargas

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

3. Haz clic en Editar .

4. En Configuración de backend, haz clic en Agregar backend y selecciona un grupo de instancias no administrado (en este ejemplo, ig-b).

5. Marca Usar este grupo de instancias como grupo de conmutación por error para la copia de seguridad.

6. Haz clic en Listo y, luego, en Actualizar.

gcloud

Usa el siguiente comando de gcloud para agregar un backend de conmutación por error a un servicio de backend del balanceador de cargas de red de transferencia interna existente.

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

Reemplaza lo siguiente:

• BACKEND_SERVICE_NAME es el nombre del servicio de backend del balanceador de cargas. Para el ejemplo, usa be-ilb.
• INSTANCE_GROUP_NAME es el nombre del grupo de instancias que se agregará como backend principal. Para el ejemplo, usa ig-b.
• INSTANCE_GROUP_ZONE es la zona en la que se define el grupo de instancias. Para el ejemplo, usa us-west1-a.
• REGION es la región del balanceador de cargas. Para el ejemplo, usa us-west1.

API

Agrega un backend de conmutación por error a un servicio de backend existente 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"
    }
  ]
}

Reemplaza lo siguiente:

• PROJECT_ID: El ID de tu proyecto
• BACKEND_SERVICE_NAME es el nombre del servicio de backend del balanceador de cargas. Para el ejemplo, usa be-ilb.
• INSTANCE_GROUP_NAME es el nombre del grupo de instancias que se agregará como backend principal. Para el ejemplo, usa ig-b.
• INSTANCE_GROUP_ZONE es la zona en la que se define el grupo de instancias. Para el ejemplo, usa us-west1-a.
• REGION es la región del balanceador de cargas. Para el ejemplo, usa us-west1.

Convierte un backend primario o de conmutación por error

Puedes convertir un backend principal en un backend de conmutación por error, o viceversa, sin quitar el grupo de instancias del servicio de backend del balanceador de cargas de red de transferencia interna.

Consola

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

   Ir a Balanceo de cargas

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

3. Haz clic en Editar .

4. En la Configuración de backend, haz clic en el nombre de uno de los grupos de instancias de backend. Luego:

   • Para hacer que el grupo de instancias sea un backend de conmutación por error, marca Usar este grupo de instancias como un grupo de conmutación por error para la copia de seguridad.
   • Para hacer que el grupo de instancias sea un backend principal, desmarca Usar este grupo de instancias como un grupo de conmutación por error para la copia de seguridad.

5. Haz clic en Listo y, luego, en Actualizar.

gcloud

Usa el siguiente comando de gcloud para convertir un backend principal existente 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 de gcloud para convertir un backend de conmutación por error existente 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

Reemplaza lo siguiente:

• BACKEND_SERVICE_NAME es el nombre del servicio de backend del balanceador de cargas
• INSTANCE_GROUP_NAME es el nombre del grupo de instancias que se agregará como backend principal
• INSTANCE_GROUP_ZONE es la zona en la que se define el grupo de instancias
• REGION es la región del balanceador de cargas

API

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

Haz esto para convertir un backend principal en un backend de conmutación por error:

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

Haz esto para convertir un backend de conmutación por error en un backend principal:

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

Reemplaza lo siguiente:

• PROJECT_ID: El ID de tu proyecto
• BACKEND_SERVICE_NAME es el nombre del servicio de backend del balanceador de cargas
• INSTANCE_GROUP_NAME es el nombre del grupo de instancias que se agregará como backend principal
• INSTANCE_GROUP_ZONE es la zona en la que se define el grupo de instancias
• REGION es la región del balanceador de cargas

Configura las políticas de conmutación por error

En esta sección, se describe cómo administrar una política de conmutación por error para un servicio de backend del balanceador de cargas de red de transferencia interna. Una política de conmutación por error consta de las siguientes partes:

• Proporción de conmutación por error
• Abandono del tráfico cuando todas las VM de backend están en mal estado
• Desvío de conexión en conmutación por error

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

• Configuración de una proporción de conmutación por error
• Abandono del tráfico cuando no hay una VM en buen estado
• Vaciado de conexiones en conmutación por error y recuperación

Define 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 cargas de red de transferencia interna existente.

Consola

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

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

   Ir a Balanceo de cargas

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

3. Haz clic en Editar .

4. Asegúrate de tener al menos un backend de conmutación por error. Al menos uno de los backends del balanceador de cargas debe tener seleccionada la opción Usar este grupo de instancias como un grupo de conmutación por error para la copia de seguridad.

5. Haz clic en Configuración avanzada.

   • En Política de conmutación por error, configura la Proporción de conmutación por error en un valor entre 0.0 y 1.0, incluido.
   • Marca la casilla junto a Habilitar el abandono de tráfico si deseas dejar de recibir tráfico cuando todas las VM activas y las de copia de seguridad no están en buen estado.
   • Marca la casilla junto a Habilitar el desvío de la conexión en la conmutación por error si deseas finalizar las conexiones existentes con rapidez durante la conmutación por error.

6. Haz clic en Revisar y finalizar y, luego, haz clic en Actualizar.

gcloud

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

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

Reemplaza lo siguiente:

• BACKEND_SERVICE_NAME es el nombre del servicio de backend del balanceador de cargas. Para el ejemplo, usa be-ilb.
• REGION es la región del balanceador de cargas. Para el ejemplo, usa us-west1.
• FAILOVER_RATIO es el índice de conmutación por error. Los valores posibles están entre 0.0 y 1.0, incluido. Para el ejemplo, usa 0.75.
• --drop-traffic-if-unhealthy indica al balanceador de cargas que deje de recibir tráfico cuando todas las VM principales y de copia de seguridad estén en mal estado. Cambia esto por --no-drop-traffic-if-unhealthy si deseas distribuir el tráfico entre todas las VM principales cuando todas las VM de backend estén en mal estado.
• --no-connection-drain-on-failover indica al balanceador de cargas que finalice las conexiones TCP existentes durante la conmutación por error. Usa --connection-drain-on-failover para habilitar el vaciado de conexiones 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]
  }
}

Reemplaza lo siguiente:

• PROJECT_ID: El ID de tu proyecto
• REGION es la región del balanceador de cargas
• BACKEND_SERVICE_NAME es el nombre del servicio de backend del balanceador de cargas
• FAILOVER_RATIO es el índice de conmutación por error. Los valores posibles están entre 0.0 y 1.0, incluido.
• Establecer dropTrafficIfUnhealthy en true indica al balanceador de cargas que deje de recibir tráfico cuando todas las VM principales y de copia de seguridad estén en mal estado. Configúralo como false si deseas distribuir el tráfico entre todas las VM principales cuando todas las VM de backend no estén en buen estado.
• Establecer disableConnectionDrainOnFailover en true indica al balanceador de cargas que finalice las conexiones TCP existentes cuando se realiza una conmutación por error. Configúralo como false para habilitar el vaciado de conexiones durante la conmutación por error.

Visualiza 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 existente para un balanceador de cargas de red de transferencia interna.

Consola

En la consola de Google Cloud se muestra la configuración de la política de conmutación por error existente cuando se edita un balanceador de cargas de red de transferencia interna. Consulta Define una política de conmutación por error para obtener instrucciones.

gcloud

Para mostrar la configuración de la política de conmutación por error mediante la CLI de gcloud, usa el siguiente comando. Si no se define la configuración en una política de conmutación por error, se usan los valores de la política de conmutación por error predeterminados.

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

Reemplaza lo siguiente:

• BACKEND_SERVICE_NAME es el nombre del servicio de backend del balanceador de cargas
• REGION es la región del balanceador de cargas

API

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

En la respuesta de la solicitud a la API, se 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

Reemplaza lo siguiente:

• PROJECT_ID: El ID de tu proyecto
• REGION es la región del balanceador de cargas
• BACKEND_SERVICE_NAME es el nombre del servicio de backend del balanceador de cargas

{
...
"failoverPolicy": {
  "disableConnectionDrainOnFailover": false,
  "dropTrafficIfUnhealthy": false,
  "failoverRatio": 0.75
...
}

¿Qué sigue?

• Consulta la descripción general del balanceador de cargas de red de transferencia interna para obtener información básica importante.
• Consulta la página sobre los conceptos de la conmutación por error para balanceadores de cargas de red de transferencia interna a fin de obtener información importante sobre la conmutación por error.
• Consulta Configura un balanceador de cargas de red de transferencia interna para obtener la configuración del balanceador de cargas de red de transferencia interna de ejemplo.
• Consulta Registro y supervisión del balanceador de cargas de red de transferencia interna a fin de obtener información sobre cómo configurar el registro y la supervisión para el balanceador de cargas de red de transferencia interna.
• Consulta Balanceadores de cargas de red de transferencia interna y redes conectadas para obtener información sobre cómo acceder a los balanceadores de cargas de red de transferencia interna desde redes de intercambio de tráfico conectadas a tu red de VPC.
• Consulta Soluciona problemas del balanceador de cargas de red de transferencia interna para obtener información sobre cómo solucionar los problemas del balanceador de cargas de red de transferencia interna.
• Limpia la configuración del balanceador de cargas.