Configura un balanceador de cargas de aplicaciones interno entre regiones con conectividad híbrida.

En esta página, se muestra cómo implementar un balanceador de cargas de aplicaciones interno entre regiones para balancear las cargas del tráfico a los extremos de red locales o en otras nubes públicas y a los que se puede acceder mediante la conectividad híbrida

Si aún no lo hiciste, revisa la descripción general de los NEG de conectividad híbrida para comprender los requisitos de red para configurar el balanceo de cargas híbrido.

Descripción general de la configuración

En el ejemplo, se configura un balanceador de cargas de aplicaciones interno entre regiones para backends de NEGs de conectividad híbrida y zonal, como se muestra en la siguiente figura:

Ejemplo del balanceador de cargas de aplicaciones interno entre regiones para backends de NEGs de conectividad híbrida y zonal
Ejemplo del balanceador de cargas de aplicaciones interno entre regiones para backends de NEGs de conectividad híbrida y zonal (haz clic para ampliar).

Debes configurar la conectividad híbrida antes de configurar una implementación de balanceo de cargas híbrido. Según el producto de conectividad híbrida que elijas, usa Cloud VPN o Cloud Interconnect (dedicado o de socio).

Configura un recurso de certificado SSL

Crea un recurso de certificado SSL del Administrador de certificados como se describe a continuación:

Recomendamos que uses un certificado administrado por Google.

Permisos

Para configurar el balanceo de cargas híbrido, debes tener los siguientes permisos:

  • En Google Cloud

  • En tu entorno local o en otro entorno de nube que no sea de Google Cloud

    • Permisos para configurar los extremos de red que permiten que se pueda acceder a los servicios en tu entorno local o en otros entornos de nube desde Google Cloud a través de una combinación IP:Port. Para obtener más información, comunícate con el administrador de red de tu entorno.
    • Permisos para crear reglas de firewall en tu entorno local o en otros entornos de nube a fin de permitir que los sondeos de verificación de estado de Google lleguen a los extremos.

Además, a fin de completar las instrucciones de esta página, debes crear un NEG de conectividad híbrida, un balanceador de cargas y NEG zonales (y sus extremos) que funcionen como backends basados en Google Cloud para el balanceador de cargas.

Debes ser Propietario o Editor de un proyecto o tener los siguientes roles de IAM de Compute Engine.

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

Establece una conectividad híbrida

Tu Google Cloud y otros entornos de nube deben estar conectados a través de la conectividad híbrida, mediante adjuntos de VLAN de Cloud Interconnect o túneles de Cloud VPN con Cloud Router. Te recomendamos usar una conexión de alta disponibilidad.

Un Cloud Router habilitado con enrutamiento dinámico global aprende sobre el extremo específico a través del protocolo de puerta de enlace de frontera (BGP) y lo programa en tu red de VPC de Google Cloud. No se admite el enrutamiento dinámico regional. Tampoco se admiten las rutas estáticas.

La red de VPC que usas para configurar Cloud Interconnect o Cloud VPN es la misma red que usas a fin de configurar la implementación del balanceo de cargas híbrido. Asegúrate de que los rangos de CIDR de la subred de la red de VPC no entren en conflicto con los rangos de CIDR remotos. Cuando las direcciones IP se superponen, las rutas de subred se priorizan por sobre la conectividad remota.

Para obtener instrucciones, consulta la siguiente documentación:

Configura tu entorno fuera de Google Cloud

Realiza los pasos siguientes a fin de configurar tu entorno local o algún otro entorno de nube para el balanceo de cargas híbrido:

  • Configura los extremos de red para exponer los servicios locales a Google Cloud (IP:Port).
  • Configura reglas de firewall en tu entorno local o en otro entorno de nube.
  • Configura Cloud Router para anunciar ciertas rutas obligatorias a tu entorno privado.

Configura extremos de red

Luego de configurar la conectividad híbrida, configura uno o más extremos de red en tus entornos de nube locales o en otros a los que se pueda acceder mediante Cloud Interconnect o Cloud VPN mediante una combinación IP:port. Esta combinación IP:port se configura como uno o más extremos para el NEG de conectividad híbrida que se crea más adelante en Google Cloud en este proceso.

Si hay varias rutas de acceso al extremo de IP, el enrutamiento seguirá el comportamiento descrito en la descripción general de Cloud Router.

Configura reglas de firewall

Las siguientes reglas de firewall se deben crear en tu entorno local o en otro entorno de nube:

  • Crea una regla de firewall de permiso de entrada en entornos locales o en otros entornos de nube para permitir que el tráfico de la subred de solo proxy de la región llegue a los extremos.

  • No se requiere incluir en la lista de entidades permitidas los rangos de sondeo de verificación de estado de Google para los NEG híbridos. Sin embargo, si usas una combinación de NEG híbridos y zonales en un solo servicio de backend, debes incluir en la lista de anunciantes permitidos los rangos de sondeo de verificación de estado de Google para los NEG zonales.

Configura Cloud Router para Anunciar los siguientes rangos de IP personalizados a tu entorno local o a otro entorno de nube:

  • El rango de la subred solo de proxy de la región.

Configura el entorno de Google Cloud

Para los siguientes pasos, asegúrate de usar la misma red de VPC (llamada NETWORK en este procedimiento) que se usó para configurar la conectividad híbrida entre los entornos.

Además, asegúrate de que las regiones que se usan (llamadas REGION_A y REGION_B en este procedimiento) sean las mismas que se usan para crear el túnel de Cloud VPN o la VLAN de Cloud Interconnect. adjuntos.

De manera opcional, puedes configurar políticas de enrutamiento de DNS de tipo GEO para enrutar el tráfico del cliente a la VIP del balanceador de cargas en la región más cercana al cliente durante las interrupciones regionales.

Configura las subredes de backend

Usa esta subred para crear los backends de NEGs zonales del balanceador de cargas:

Console

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

    Ir a las redes de VPC

  2. Ve a la red que se usó para configurar la conectividad híbrida entre los entornos.

  3. 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:
      • Proporciona un Nombre para la subred.
      • Selecciona una Región: REGION_A
      • Ingresa un Rango de direcciones IP.
    • Haz clic en Listo.

  4. Haz clic en Crear.

  5. Para agregar más subredes en diferentes regiones, haz clic en Agregar subred y repite los pasos anteriores de REGION_B.

gcloud

  1. Crea subredes en la red que se usó para configurar la conectividad híbrida entre los entornos.

    gcloud compute networks subnets create SUBNET_A \
    --network=NETWORK \
    --range=LB_SUBNET_RANGE1 \
    --region=REGION_A

    gcloud compute networks subnets create SUBNET_B \
    --network=NETWORK \
    --range=LB_SUBNET_RANGE2 \
    --region=REGION_B

API

Realiza una solicitud POST al método subnetworks.insert. Reemplaza PROJECT_ID con el ID del proyecto.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION_A/subnetworks

{
 "name": "SUBNET_A",
 "network": "projects/PROJECT_ID/global/networks/NETWORK",
 "ipCidrRange": "LB_SUBNET_RANGE1",
 "region": "projects/PROJECT_ID/regions/REGION_A",
}

Realiza una solicitud POST al método subnetworks.insert. Reemplaza PROJECT_ID con el ID del proyecto.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION_B/subnetworks

{
 "name": "SUBNET_B",
 "network": "projects/PROJECT_ID/global/networks/NETWORK",
 "ipCidrRange": "LB_SUBNET_RANGE2",
 "region": "projects/PROJECT_ID/regions/REGION_B",
}

Reemplaza lo siguiente:

  • SUBNET_A y SUBNET_B: el nombre de las subredes.
  • LB_SUBNET_RANGE1 y LB_SUBNET_RANGE2: el rango de direcciones IP para las subredes
  • REGION_A y REGION_B: las regiones en las que configuraste el balanceador de cargas.

Configura la subred de solo proxy

La subred de solo proxy proporciona un conjunto de direcciones IP que Google usa para ejecutar proxies de Envoy en tu nombre. Los proxies finalizan las conexiones del cliente y crean conexiones nuevas a los backends.

Todos los balanceadores de cargas regionales basados en Envoy usan esta subred de solo proxy en la misma región de la red de VPC . Solo puede haber una subred de solo proxy activa para un propósito determinado, por región, por red.

Console

Si usas la consola de Google Cloud, puedes esperar y crear la subred de solo proxy más adelante en la página Balanceo de cargas.

Si quieres crear la subred de solo proxy ahora, sigue estos pasos:

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

    Ir a las redes de VPC

  2. Haz clic en el nombre de la red de VPC.
  3. En la pestaña Subredes, haz clic en Agregar subred.
  4. Proporciona un Nombre para la subred de solo proxy.
  5. En la lista Región, selecciona REGION_A.
  6. En la lista Propósito, selecciona Proxy administrado entre regiones.
  7. En el campo Rango de direcciones IP, ingresa 10.129.0.0/23.
  8. Haz clic en Agregar.

Crea la subred de solo proxy en REGION_B

  1. Haz clic en Agregar subred.
  2. Proporciona un Nombre para la subred de solo proxy.
  3. En la lista Región, selecciona REGION_B.
  4. En la lista Propósito, selecciona Proxy administrado entre regiones.
  5. En el campo Rango de direcciones IP, ingresa 10.130.0.0/23.
  6. Haz clic en Agregar.

gcloud

Crea las subredes de solo proxy con el comando gcloud compute networks subnets create.

    gcloud compute networks subnets create PROXY_SN_A \
        --purpose=GLOBAL_MANAGED_PROXY \
        --role=ACTIVE \
        --region=REGION_A \
        --network=NETWORK \
        --range=PROXY_ONLY_SUBNET_RANGE1
    
    gcloud compute networks subnets create PROXY_SN_B \
        --purpose=GLOBAL_MANAGED_PROXY \
        --role=ACTIVE \
        --region=REGION_B \
        --network=NETWORK \
        --range=PROXY_ONLY_SUBNET_RANGE2

Reemplaza lo siguiente:

  • PROXY_SN_A y PROXY_SN_B: el nombre de las subredes de solo proxy
  • PROXY_ONLY_SUBNET_RANGE1 y PROXY_ONLY_SUBNET_RANGE2: el rango de direcciones IP para las subredes de solo proxy
  • REGION_A y REGION_B: las regiones en las que configuraste el balanceador de cargas.

API

Crea las subredes de solo proxy con el método subnetworks.insert y reemplaza PROJECT_ID por el ID del proyecto.

    POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION_A/subnetworks

    {
      "name": "PROXY_SN_A",
      "ipCidrRange": "PROXY_ONLY_SUBNET_RANGE1",
      "network": "projects/PROJECT_ID/global/networks/NETWORK",
      "region": "projects/PROJECT_ID/regions/REGION_A",
      "purpose": "GLOBAL_MANAGED_PROXY",
      "role": "ACTIVE"
    }
  
    POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION_B/subnetworks

    {
      "name": " PROXY_SN_B",
      "ipCidrRange": "PROXY_ONLY_SUBNET_RANGE2",
      "network": "projects/PROJECT_ID/global/networks/NETWORK",
      "region": "projects/PROJECT_ID/regions/REGION_B",
      "purpose": "GLOBAL_MANAGED_PROXY",
      "role": "ACTIVE"
    }

Crea reglas de firewall

En este ejemplo, se crean las siguientes reglas de firewall para los backends de NEG zonales en Google Cloud:

  • 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 los NEGs a los que debe aplicarse.
  • fw-allow-ssh: una regla de entrada que permita 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 instancias de máquina virtual (VM) a las que se debe aplicar.

  • fw-allow-proxy-only-subnet: Una regla de entrada que permite que las conexiones de la subred de solo proxy lleguen a los backends de NEGs zonales.

Console

  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 para crear la regla que permite el tráfico de los sondeos de verificación de estado:

    1. Ingresa un Nombre de fw-allow-health-check.
    2. En Red, selecciona NETWORK.
    3. En Destinos, selecciona Etiquetas de destino especificadas.
    4. Propaga el campo Etiquetas de destino con allow-health-check.
    5. Configura Filtro de fuente como Rangos de IPv4.
    6. Establece Rangos de IPv4 de origen en 130.211.0.0/22 y 35.191.0.0/16.
    7. En Protocolos y puertos, selecciona Puertos y protocolos especificados.
    8. Selecciona TCP y, luego, ingresa 80 para el número de puerto.
    9. Haz clic en Crear.

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

    1. Nombre: fw-allow-ssh
    2. Red: NETWORK
    3. Prioridad: 1000
    4. Dirección del tráfico: entrada
    5. Acción si hay coincidencia: permitir
    6. Objetivos: etiquetas de destino especificadas
    7. Etiquetas de destino: allow-ssh
    8. Filtro de fuente: Rangos de IPv4
    9. Rangos de IPv4 de origen: 0.0.0.0/0
    10. Protocolos y puertos: Elige Protocolos y puertos especificados.
    11. Selecciona TCP y, luego, ingresa 22 para el número de puerto.
    12. Haz clic en Crear.

  4. Haz clic en Crear regla de firewall de nuevo para crear la regla que permite conexiones entrantes desde la subred de solo proxy:

    1. Nombre: fw-allow-proxy-only-subnet
    2. Red: NETWORK
    3. Prioridad: 1000
    4. Dirección del tráfico: entrada
    5. Acción si hay coincidencia: permitir
    6. Objetivos: etiquetas de destino especificadas
    7. Etiquetas de destino: allow-proxy-only-subnet
    8. Filtro de fuente: Rangos IPv4
    9. Rangos IPv4 de origen: PROXY_ONLY_SUBNET_RANGE1 y PROXY_ONLY_SUBNET_RANGE2
    10. Protocolos y puertos: Elige Protocolos y puertos especificados
    11. Selecciona TCP y, luego, ingresa 80 para el número de puerto.
    12. Haz clic en Crear.

gcloud

  1. Crea la regla fw-allow-health-check-and-proxy para permitir que las verificaciones de estado de Google Cloud lleguen a las instancias de backend en el puerto TCP 80:

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

  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=NETWORK \
    --action=allow \
    --direction=ingress \
    --target-tags=allow-ssh \
    --rules=tcp:22

  3. Crea una regla de firewall de permiso de entrada para la subred de solo proxy a fin de permitir que el balanceador de cargas se comunique con instancias de backend en el puerto TCP 80:

    gcloud compute firewall-rules create fw-allow-proxy-only-subnet \
    --network=NETWORK \
    --action=allow \
    --direction=ingress \
    --target-tags=allow-proxy-only-subnet \
    --source-ranges=PROXY_ONLY_SUBNET_RANGE1,PROXY_ONLY_SUBNET_RANGE2 \
    --rules=tcp:80

Configura el NEG zonal

Para los backends basados en Google Cloud, te recomendamos configurar varios NEG zonales en la misma región en la que configuraste la conectividad híbrida.

Para este ejemplo, configura un NEG zonal (con extremos de tipo GCE_VM_IP_PORT) en la región REGION_A. Primero, crea las VMs en la zona ZONE_A. Luego, crea un NEG zonal en la zona ZONE_A y, luego, agrega los extremos de red de las VMs al NEG. Para admitir la alta disponibilidad, configuramos un NEG zonal similar en la región REGION_B. Si los backends en una región están inactivos, el tráfico se dirige a la otra región.

Crea las VM

Console

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

    Ir a Instancias de VM

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

    • Nombre de vm-a1
      • Zona: ZONE_A en la región REGION_A
      • Subred: SUBNET_A
    • Nombre de vm-b1
      • Zona: ZONE_B en la región REGION_B
      • Subred: SUBNET_B

  3. Haz clic en Crear instancia.

  4. Configura el nombre como se indica en el paso anterior.

  5. En Región, elige como se indicó en el paso anterior.

  6. En Zona, elige como se indicó en el paso anterior.

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

  8. En la sección Opciones avanzadas, expande Herramientas de redes y, luego, haz lo siguiente:

    • Agrega las siguientes etiquetas de red: allow-ssh, allow-health-check y allow-proxy-only-subnet.
    • En la sección Interfaces de red, haz clic en Agregar una interfaz de red, realiza los siguientes cambios y, luego, haz clic en Listo:
      • Red: NETWORK
      • Subred: como se indicó en el paso anterior
      • IP interna principal: efímera (automática)
      • IP externa: efímera

    • Expande Administración. En el campo Automatización, copia y pega el siguiente contenido de la secuencia de comandos. El contenido de la secuencia de comandos es idéntico para todas las 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

  9. Haz clic en Crear.

gcloud

Para crear las VMs, ejecuta el siguiente comando, con estas combinaciones para el nombre de la VM y su zona. El contenido de la secuencia de comandos es idéntico para ambas VMs.

gcloud compute instances create VM_NAME \
    --zone=GCP_NEG_ZONE \
    --image-family=debian-12 \
    --image-project=debian-cloud \
    --tags=allow-ssh,allow-health-check,allow-proxy-only-subnet \
    --subnet=LB_SUBNET_NAME \
    --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'
  • VM_NAME de vm-a1
    • La zona GCP_NEG_ZONE como ZONE_A en la región REGION_A
    • La subred LB_SUBNET_NAME como SUBNET_A
  • VM_NAME de vm-b1
    • Zona GCP_NEG_ZONE como ZONE_B en la región REGION_B
    • Subred LB_SUBNET_NAME como SUBNET_B

Crea el NEG zonal

Console

Para crear un grupo de extremos de red por zonas, sigue estos pasos:

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

    Ir a Grupos de extremos de red

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

    • Nombre: neg-1
      • Zona: ZONE_A en la región REGION_A
      • Subred: SUBNET_A
    • Nombre: neg-2
      • Zona: ZONE_B en la región REGION_B
      • Subred: SUBNET_B

  3. Haz clic en Crear un grupo de extremos de red.

  4. Configura el nombre como se indica en el paso anterior.

  5. Selecciona el Tipo de grupo de extremos de red: Grupo de extremos de red (zonal).

  6. Selecciona la Red: NETWORK

  7. Selecciona la Subred como se indicó en el paso anterior.

  8. Selecciona la Zona como se indicó en el paso anterior.

  9. Ingresa el Puerto predeterminado: 80.

  10. Haz clic en Crear.

Agrega extremos al NEG zonal.

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

    Ir a los grupos de extremos de red

  2. Haz clic en el Nombre del grupo de extremos de red que se creó en el paso anterior. Verás la página Detalles del grupo de extremos de red.

  3. En la sección Extremos de red de este grupo, haz clic en Agregar extremo de red. Verás la página Agregar extremo de red.

  4. Selecciona una instancia de VM para agregar sus direcciones IP internas como extremos de red. En la sección Interfaz de red, se muestra el nombre, la zona y la subred de la VM.

  5. Ingresa la dirección IP del extremo de red nuevo.

  6. Selecciona el tipo de puerto.

    1. Si seleccionas Predeterminado, el extremo usará el puerto predeterminado 80 para todos los extremos del grupo de extremos de red. Esto es suficiente para nuestro ejemplo, ya que el servidor Apache entrega solicitudes en el puerto 80.
    2. Si seleccionas Personalizado, deberás ingresar el número de puerto para el extremo que se usará.

  7. Para agregar más extremos, haz clic en Agregar extremo de red y repite los pasos anteriores.

  8. Después de agregar todos los extremos, haz clic en Crear.

gcloud

  1. Crea NEGs zonales (con extremos GCE_VM_IP_PORT) mediante las combinaciones de nombre, zona y subred. Usa el comando gcloud compute network-endpoint-groups create.

    gcloud compute network-endpoint-groups create GCP_NEG_NAME \
    --network-endpoint-type=GCE_VM_IP_PORT \
    --zone=GCP_NEG_ZONE \
    --network=NETWORK \
    --subnet=LB_SUBNET_NAME
    • Nombre: neg-1
      • Zona GCP_NEG_ZONE: ZONE_A en la región REGION_A
      • Subred LB_SUBNET_NAME: SUBNET_A
    • Nombre: neg-2
      • Zona GCP_NEG_ZONE: ZONE_B en la región REGION_B
      • Subred LB_SUBNET_NAME: SUBNET_B

    Puedes especificar un puerto mediante la opción --default-port mientras creas el NEG o especificar un número de puerto para cada extremo, como se muestra en el siguiente paso.

  2. Agrega extremos a neg1 y neg2.

    gcloud compute network-endpoint-groups update neg1 \
    --zone=ZONE_A \
    --add-endpoint='instance=vm-a1,port=80'

    gcloud compute network-endpoint-groups update neg2 \
    --zone=ZONE_B \
    --add-endpoint='instance=vm-b1,port=80'

Configura el NEG de conectividad híbrida

Cuando crees el NEG, usa una zona que minimice la distancia geográfica entre Google Cloud y tu entorno local o de otra nube. Por ejemplo, si alojas un servicio en un entorno local en Fráncfort, Alemania, puedes especificar la zona europe-west3-a de Google Cloud cuando crees el NEG.

Si usas Cloud Interconnect, la zona que se usa para crear el NEG se encuentra en la misma región en la que se configuró el adjunto de Cloud Interconnect.

Los NEGs híbridos solo admiten las verificaciones de estado de Envoy distribuidas.

Console

Para crear un grupo de extremos de red de conectividad híbrida, haz lo siguiente:

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

    Ir a Grupos de extremos de red

  2. Haz clic en Crear un grupo de extremos de red.

  3. Repite los pasos 4 a 9 para cada NEG híbrido y usa las siguientes combinaciones de nombre y zona.

    • Nombre ON_PREM_NEG_NAME: hybrid-1
      • Zona: ON_PREM_NEG_ZONE1
      • Subred: SUBNET_A
    • Nombre ON_PREM_NEG_NAME: hybrid-2
      • Zona: ON_PREM_NEG_ZONE2
      • Subred: SUBNET_B

  4. Configura el nombre como se indica en el paso anterior.

  5. Selecciona el Tipo de grupo de extremos de red: Grupo de extremos de red de conectividad híbrida (zonal).

  6. Selecciona la Red: NETWORK

  7. En Subred, elige como se indica en el paso anterior.

  8. En Zona, elige como se indica en el paso anterior.

  9. Ingresa el Puerto predeterminado.

  10. Haz clic en Crear.

Agrega extremos al NEG de conectividad híbrida:

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

    Ir a Grupos de extremos de red

  2. Haz clic en el Nombre del grupo de extremos de red que se creó en el paso anterior. Verás la página Detalles del grupo de extremos de red.

  3. En la sección Extremos de red de este grupo, haz clic en Agregar extremo de red. Verás la página Agregar extremo de red.

  4. Ingresa la dirección IP del extremo de red nuevo.

  5. Selecciona el tipo de puerto.

    1. Si seleccionas Predeterminado, el extremo usará el puerto predeterminado para todos los extremos del grupo de extremos de red.
    2. Si seleccionas Personalizado, puedes ingresar un Número de puerto diferente para que lo use el extremo.

  6. Para agregar más extremos, haz clic en Agregar extremo de red y repite los pasos anteriores.

  7. Después de agregar todos los extremos que no son de Google Cloud, haz clic en Crear.

gcloud

  1. Crea un NEG de conectividad híbrida que use las siguientes combinaciones de nombre. Usa el comando gcloud compute network-endpoint-groups create.

    gcloud compute network-endpoint-groups create ON_PREM_NEG_NAME \
    --network-endpoint-type=NON_GCP_PRIVATE_IP_PORT \
    --zone=ON_PREM_NEG_ZONE \
    --network=NETWORK
    • Nombre ON_PREM_NEG_NAME: hybrid-1
      • Zona ON_PREM_NEG_ZONE: ON_PREM_NEG_ZONE1
    • Nombre ON_PREM_NEG_NAME: hybrid-2
      • Zona GCP_NEG_ZONE: ON_PREM_NEG_ZONE2

  2. Agrega el extremo de la VM de backend local a ON_PREM_NEG_NAME:

    gcloud compute network-endpoint-groups update ON_PREM_NEG_NAME \
    --zone=ON_PREM_NEG_ZONE \
    --add-endpoint="ip=ON_PREM_IP_ADDRESS_1,port=PORT_1" \
    --add-endpoint="ip=ON_PREM_IP_ADDRESS_2,port=PORT_2"

Puedes usar este comando para agregar los extremos de red que configuraste antes de forma local o en tu entorno de nube. Repite --add-endpoint tantas veces como sea necesario.

Configura el balanceador de cargas

Console

gcloud

  1. Define la verificación de estado de HTTP con el comando gcloud compute health-checks create http.

    gcloud compute health-checks create http gil7-basic-check \
   --use-serving-port \
   --global

  2. Crea el servicio de backend y habilita el registro con el comando gcloud compute backend-services create.

    gcloud compute backend-services create BACKEND_SERVICE \
  --load-balancing-scheme=INTERNAL_MANAGED \
  --protocol=HTTP \
  --enable-logging \
  --logging-sample-rate=1.0 \
  --health-checks=gil7-basic-check \
  --global-health-checks \
  --global

  3. Agrega backends al servicio de backend con el comando gcloud compute backend-services add-backend.

    gcloud compute backend-services add-backend BACKEND_SERVICE \
  --global \
  --balancing-mode=RATE \
  --max-rate-per-endpoint=MAX_REQUEST_RATE_PER_ENDPOINT \
  --network-endpoint-group=neg1 \
  --network-endpoint-group-zone=ZONE_A \
  --network-endpoint-group=neg2 \
  --network-endpoint-group-zone=ZONE_B

    Si deseas obtener detalles sobre la configuración del modo de balanceo, consulta la documentación de la CLI de gcloud para la marca --max-rate-per-endpoint.

  4. Agrega los NEGs híbridos como un backend al servicio de backend: 

    gcloud compute backend-services add-backend BACKEND_SERVICE \
  --global \
  --balancing-mode=RATE \
  --max-rate-per-endpoint=MAX_REQUEST_RATE_PER_ENDPOINT \
  --network-endpoint-group=hybrid1 \
  --network-endpoint-group-zone=ON_PREM_NEG_ZONE1 \
  --network-endpoint-group=hybrid2 \
  --network-endpoint-group-zone=ON_PREM_NEG_ZONE2 \

    Si deseas obtener detalles sobre la configuración del modo de balanceo, consulta la documentación de la CLI de gcloud para el parámetro --max-rate-per-endpoint.

  5. Crea el mapa de URL con el comando gcloud compute url-maps create.

    gcloud compute url-maps create gil7-map \
  --default-service=BACKEND_SERVICE \
  --global

  6. Crea el proxy de destino.

    Para HTTP:

    Crea el proxy de destino con el comando gcloud compute target-http-proxies create.

    gcloud compute target-http-proxies create gil7-http-proxy \
  --url-map=gil7-map \
  --global

    Para HTTPS:

    Para crear un certificado administrado por Google, consulta la siguiente documentación:

    Después de crear el certificado administrado por Google, adjunta el certificado al proxy de destino. Los balanceadores de cargas de aplicaciones internos entre regiones no admiten mapas de certificados.

    Para crear un certificado autoadministrado, consulta la siguiente documentación:

    Asigna tus rutas de archivos a nombres de variables.

    export LB_CERT=PATH_TO_PEM_FORMATTED_FILE

    export LB_PRIVATE_KEY=PATH_TO_PEM_LB_PRIVATE_FILE

    Crea un certificado SSL para todas las regiones con el comando gcloud certificate-manager certificates create.

    gcloud certificate-manager certificates create gilb-certificate \
  --private-key-file=$LB_CERT \
  --certificate-file=$LB_PRIVATE_KEY \
  --scope=all-regions

    Usa el certificado SSL regional para crear un proxy de destino con el comando gcloud compute target-https-proxies create.

    gcloud compute target-https-proxies create gil7-https-proxy \
  --url-map=gil7-map \
  --certificate-manager-certificates=gilb-certificate \
  --global

  7. Crea dos reglas de reenvío, una con una VIP IP_ADDRESS1 en la región REGION_A y otra con una VIP IP_ADDRESS2 en la región REGION_B. Para la dirección IP de la regla de reenvío, usa el rango de direcciones IP LB_SUBNET_RANGE1 o LB_SUBNET_RANGE2. Si intentas usar la subred de solo proxy, la creación de la regla de reenvío fallará.

    Para redes personalizadas, debes hacer referencia a la subred en la regla de reenvío. Ten en cuenta que esta es la subred de VM, no la subred de proxy.

    Para HTTP:

    Usa el comando gcloud compute forwarding-rules create con las marcas correctas.

    gcloud compute forwarding-rules create FWRULE_A \
  --load-balancing-scheme=INTERNAL_MANAGED \
  --network=NETWORK \
  --subnet=SUBNET_A \
  --subnet-region=REGION_A \
  --address=IP_ADDRESS1 \
  --ports=80 \
  --target-http-proxy=gil7-http-proxy \
  --global

    gcloud compute forwarding-rules create FWRULE_B \
  --load-balancing-scheme=INTERNAL_MANAGED \
  --network=NETWORK \
  --subnet=SUBNET_B \
  --subnet-region=REGION_B \
  --address=IP_ADDRESS2 \
  --ports=80 \
  --target-http-proxy=gil7-http-proxy \
  --global

    Para HTTPS:

    Crea la regla de reenvío con el comando gcloud compute forwarding-rules create con las marcas correctas.

    gcloud compute forwarding-rules create FWRULE_A \
  --load-balancing-scheme=INTERNAL_MANAGED \
  --network=NETWORK \
  --subnet=SUBNET_A \
  --subnet-region=REGION_A \
  --address=IP_ADDRESS1 \
  --ports=443 \
  --target-https-proxy=gil7-https-proxy \
  --global

    gcloud compute forwarding-rules create FWRULE_B \
  --load-balancing-scheme=INTERNAL_MANAGED \
  --network=NETWORK \
  --subnet=SUBNET_B \
  --subnet-region=REGION_B \
  --address=IP_ADDRESS2 \
  --ports=443 \
  --target-https-proxy=gil7-https-proxy \
  --global

Conecta tu dominio al balanceador de cargas

Después de crear el balanceador de cargas, toma nota de la dirección IP asociada con este: por ejemplo, IP_ADDRESS1 y IP_ADDRESS2. Para apuntar tu dominio al balanceador de cargas, crea un registro A mediante Cloud DNS o el servicio de registro de dominio. Si agregaste varios dominios a tu certificado SSL, debes agregar un registro A para cada uno, que apunte a la dirección IP del balanceador de cargas.

Prueba el balanceador de cargas

Crea una instancia de VM para probar la conectividad

  1. Crea una VM de cliente:

    gcloud compute instances create l7-ilb-client-a \
    --image-family=debian-12 \
    --image-project=debian-cloud \
    --network=NETWORK \
    --subnet=SUBNET_A \
    --zone=ZONE_A \
    --tags=allow-ssh

    gcloud compute instances create l7-ilb-client-b \
    --image-family=debian-12 \
    --image-project=debian-cloud \
    --network=NETWORK \
    --subnet=SUBNET_B \
    --zone=ZONE_B \
    --tags=allow-ssh

  2. Usa SSH para conectarte a cada instancia de cliente.

    gcloud compute ssh l7-ilb-client-a \
   --zone=ZONE_A

    gcloud compute ssh l7-ilb-client-b \
   --zone=ZONE_B

  3. Verifica que la IP entregue su nombre de host.

    • Verifica que la VM del cliente pueda acceder a ambas direcciones IP. El comando debería ejecutarse correctamente y mostrar el nombre de la VM de backend que entregó la solicitud:

      curl IP_ADDRESS1

      curl IP_ADDRESS2

      Para la prueba de HTTPS, reemplaza curl por lo siguiente:

      curl -k -s 'https://test.example.com:443' --connect-to test.example.com:443:IP_ADDRESS1:443

      curl -k -s 'https://test.example.com:443' --connect-to test.example.com:443:IP_ADDRESS2:443

      La marca -k hace que curl omita la validación del certificado.

    • (Opcional): Usa el registro DNS configurado para resolver la dirección IP más cercana a la VM cliente. Por ejemplo, DNS_ENTRY puede ser service.example.com.

      curl DNS_ENTRY

Ejecuta 100 solicitudes

Ejecuta 100 solicitudes curl y confirma que las respuestas tienen balanceo de cargas.

Para HTTP:

  • Verifica que la VM del cliente pueda acceder a ambas direcciones IP. El comando debería ejecutarse correctamente y mostrar el nombre de la VM de backend que entregó la solicitud:

    {
  RESULTS=
  for i in {1..100}
  do
    RESULTS="$RESULTS:$(curl --silent IP_ADDRESS1)"
  done
  echo "***"
  echo "*** Results of load-balancing to IP_ADDRESS1: "
  echo "***"
  echo "$RESULTS" | tr ':' '\n' | grep -Ev "^$" | sort | uniq -c
  echo
}

    {
  RESULTS=
  for i in {1..100}
  do
    RESULTS="$RESULTS:$(curl --silent IP_ADDRESS2)"
  done
  echo "***"
  echo "*** Results of load-balancing to IP_ADDRESS2: "
  echo "***"
  echo "$RESULTS" | tr ':' '\n' | grep -Ev "^$" | sort | uniq -c
  echo
}

Para HTTPS:

  • Verifica que la VM del cliente pueda acceder a ambas direcciones IP. El comando debería ejecutarse correctamente y mostrar el nombre de la VM de backend que entregó la solicitud:

    {
  RESULTS=
  for i in {1..100}
  do
    RESULTS="$RESULTS:$(curl -k -s 'https://test.example.com:443' --connect-to test.example.com:443:IP_ADDRESS1:443)"
  done
  echo "***"
  echo "*** Results of load-balancing to IP_ADDRESS1: "
  echo "***"
  echo "$RESULTS" | tr ':' '\n' | grep -Ev "^$" | sort | uniq -c
  echo
}

    {
  RESULTS=
  for i in {1..100}
  do
    RESULTS="$RESULTS:$(curl -k -s 'https://test.example.com:443' --connect-to test.example.com:443:IP_ADDRESS2:443)"
  done
  echo "***"
  echo "*** Results of load-balancing to IP_ADDRESS2: "
  echo "***"
  echo "$RESULTS" | tr ':' '\n' | grep -Ev "^$" | sort | uniq -c
  echo
}

Prueba la conmutación por error

  1. Verifica la conmutación por error a los backends en la región REGION_A cuando los backends en REGION_B estén en mal estado o sean inaccesibles. Simulamos esto mediante la eliminación de todos los backends de REGION_B:

    gcloud compute backend-services remove-backend BACKEND_SERVICE \
   --balancing-mode=RATE \
   --network-endpoint-group=neg2 \
   --network-endpoint-group-zone=ZONE_B

  2. Usa SSH para conectarte a la VM de cliente en REGION_B.

    gcloud compute ssh l7-ilb-client-b \
   --zone=ZONE_B

  3. Envía solicitudes a la dirección IP del balanceo de cargas en la región REGION_B. El resultado es similar al siguiente:

    {
RESULTS=
for i in {1..100}
do
  RESULTS="$RESULTS:$(curl -k -s 'https://test.example.com:443' --connect-to test.example.com:443:IP_ADDRESS2:443)"
done
echo "***"
echo "*** Results of load-balancing to IP_ADDRESS2: "
echo "***"
echo "$RESULTS" | tr ':' '\n' | grep -Ev "^$" | sort | uniq -c
echo
}

Opciones de configuración adicionales

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

Configura políticas de enrutamiento de DNS

Si tus clientes están en varias regiones, es posible que desees hacer que el balanceador de cargas de aplicaciones interno entre regiones sea accesible mediante VIPs en estas regiones. Esta configuración multirregional minimiza la latencia y los costos de tránsito de la red. Además, te permite configurar una solución de balanceo de cargas global basada en DNS que proporcione resiliencia contra interrupciones regionales. Para obtener más información, consulta Administra políticas de enrutamiento de DNS y verificaciones de estado.

gcloud

Para crear una entrada de DNS con un TTL de 30 segundos, usa el comando gcloud dns record-sets create.

gcloud dns record-sets create DNS_ENTRY --ttl="30" \
  --type="A" --zone="service-zone" \
  --routing-policy-type="GEO" \
  --routing-policy-data="REGION_A=gil7-forwarding-rule-a@global;REGION_B=gil7-forwarding-rule-b@global" \
  --enable-health-checking

Reemplaza lo siguiente:

  • DNS_ENTRY: el nombre de dominio o DNS del conjunto de registros.

    Por ejemplo, service.example.com

  • REGION_A y REGION_B: las regiones en las que configuraste el balanceador de cargas.

API

Crea el registro DNS mediante una solicitud POST al método ResourceRecordSets.create. Reemplaza PROJECT_ID con el ID del proyecto.

POST https://www.googleapis.com/dns/v1/projects/PROJECT_ID/managedZones/SERVICE_ZONE/rrsets
{
  "name": "DNS_ENTRY",
  "type": "A",
  "ttl": 30,
  "routingPolicy": {
    "geo": {
      "items": [
        {
          "location": "REGION_A",
          "healthCheckedTargets": {
            "internalLoadBalancers": [
              {
                "loadBalancerType": "globalL7ilb",
                "ipAddress": "IP_ADDRESS",
                "port": "80",
                "ipProtocol": "tcp",
                "networkUrl": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
                "project": "PROJECT_ID"
              }
            ]
          }
        },
        {
          "location": "REGION_B",
          "healthCheckedTargets": {
            "internalLoadBalancers": [
              {
                "loadBalancerType": "globalL7ilb",
                "ipAddress": "IP_ADDRESS_B",
                "port": "80",
                "ipProtocol": "tcp",
                "networkUrl": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
                "project": "PROJECT_ID"
              }
            ]
          }
        }
      ]
    }
  }
}

Habilitar la detección de valores atípicos

Puedes habilitar la detección de valores atípicos en los servicios de backend globales para identificar los NEGs sin servidores y reducir la cantidad de solicitudes enviadas a los NEGs sin servidores en mal estado.

La detección de valores atípicos se habilita en el servicio de backend mediante uno de los siguientes métodos:

  • El método consecutiveErrors (outlierDetection.consecutiveErrors), en el que un código de estado HTTP de la serie 5xx califica como un error.
  • El método consecutiveGatewayFailure (outlierDetection.consecutiveGatewayFailure), en el que solo los códigos de estado HTTP 502, 503 y 504 califican como un error.

Sigue los pasos a continuación para habilitar la detección de valores atípicos para un servicio de backend existente. Ten en cuenta que, incluso después de habilitar la detección de valores atípicos, algunas solicitudes se pueden enviar al servicio en mal estado y mostrar un código de estado 5xx a los clientes. Para reducir aún más la tasa de error, puedes configurar valores más agresivos para los parámetros de detección de valores atípicos. Para obtener más información, consulta el campo outlierDetection.

Console

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

    Ir a Balanceo de cargas

  2. Haz clic en el nombre del balanceador de cargas cuyo servicio de backend quieres editar.

  3. En la página Detalles del balanceador de cargas, haz clic en Editar.

  4. En la página Editar el balanceador de cargas de aplicaciones interno entre regiones, haz clic en Configuración de backend.

  5. En la página de Configuración de backend, haz clic en Editar en el servicio de backend que deseas modificar.

  6. Desplázate hacia abajo y expande la sección Configuración avanzada.

  7. En la sección Detección de valores atípicos, selecciona la casilla de verificación Habilitar.

  8. Haz clic en Editar para configurar la detección de valores atípicos.

    Verifica que las siguientes opciones estén configuradas con estos valores:

    Propiedad Valor
    Errores consecutivos 5
    Interval 1000
    Tiempo de expulsión base 30,000
    Porcentaje de expulsión máximo 50
    Aplicación de errores consecutivos 100

    En este ejemplo, el análisis de detección de valores atípicos se ejecuta cada segundo. Si la cantidad de códigos de estado HTTP 5xx consecutivos que recibe un proxy de Envoy es de cinco o más, el extremo de backend se expulsa del grupo de balanceo de cargas de ese proxy de Envoy durante 30 segundos. Cuando el porcentaje de aplicación se establece en el 100%, el servicio de backend aplica la expulsión de extremos en mal estado de los grupos de balanceo de cargas de esos proxies de Envoy específicos cada vez que se ejecuta el análisis de detección de valores atípicos. Si se cumplen las condiciones de expulsión, se puede expulsar hasta el 50% de los extremos de backend del grupo de balanceo de cargas.

  9. Haz clic en Guardar.

  10. Para actualizar el servicio de backend, haz clic en Actualizar.

  11. Para actualizar el balanceador de cargas, en la página Edita el balanceador de cargas de aplicaciones interno entre regiones, haz clic en Actualizar.

gcloud

  1. Exporta el servicio de backend a un archivo YAML.

    gcloud compute backend-services export BACKEND_SERVICE_NAME \
  --destination=BACKEND_SERVICE_NAME.yaml --global

    Reemplaza BACKEND_SERVICE_NAME por el nombre del servicio de backend.

  2. Edita la configuración YAML del servicio de backend para agregar los campos para la detección de valores atípicos, como se destaca en la siguiente configuración de YAML, en la sección outlierDetection:

    En este ejemplo, el análisis de detección de valores atípicos se ejecuta cada segundo. Si la cantidad de códigos de estado HTTP 5xx consecutivos que recibe un proxy de Envoy es de cinco o más, el extremo de backend se expulsa del grupo de balanceo de cargas de ese proxy de Envoy durante 30 segundos. Cuando el porcentaje de aplicación se establece en el 100%, el servicio de backend aplica la expulsión de extremos en mal estado de los grupos de balanceo de cargas de esos proxies de Envoy específicos cada vez que se ejecuta el análisis de detección de valores atípicos. Si se cumplen las condiciones de expulsión, se puede expulsar hasta el 50% de los extremos de backend del grupo de balanceo de cargas. 

    name: BACKEND_SERVICE_NAME
backends:
- balancingMode: UTILIZATION
  capacityScaler: 1.0
  group: https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION_A/networkEndpointGroups/SERVERLESS_NEG_NAME
- balancingMode: UTILIZATION
  capacityScaler: 1.0
  group: https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION_B/networkEndpointGroups/SERVERLESS_NEG_NAME_2
outlierDetection:
  baseEjectionTime:
    nanos: 0
    seconds: 30
  consecutiveErrors: 5
  enforcingConsecutiveErrors: 100
  interval:
    nanos: 0
    seconds: 1
  maxEjectionPercent: 50
port: 80
selfLink: https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/backendServices/BACKEND_SERVICE_NAME
sessionAffinity: NONE
timeoutSec: 30
...

    Reemplaza lo siguiente:

    • BACKEND_SERVICE_NAME: es el nombre del servicio de backend.
    • PROJECT_ID: Es el ID de tu proyecto.
    • REGION_A y REGION_B: las regiones en las que se configuró el balanceador de cargas.
    • SERVERLESS_NEG_NAME: Es el nombre del primer NEG sin servidores.
    • SERVERLESS_NEG_NAME_2: es el nombre del segundo NEG sin servidores.

  3. Importa la configuración más reciente para actualizar el servicio de backend.

    gcloud compute backend-services import BACKEND_SERVICE_NAME \
  --source=BACKEND_SERVICE_NAME.yaml --global

    La detección de valores atípicos ahora está habilitada en el servicio de backend.

¿Qué sigue?