Configura un balanceador de cargas de aplicaciones interno con VPC compartida

En este documento, se muestran dos opciones de configuración de muestra para configurar el balanceador de cargas de aplicaciones interno en un entorno de VPC compartida:

  • En el primer ejemplo, se crean todos los componentes y backends del balanceador de cargas en un proyecto de servicio.
  • En el segundo ejemplo, se crean los componentes de frontend y el mapa de URL del balanceador de cargas en un proyecto de servicio, mientras que el servicio de backend y los backends del balanceador de cargas se crean en un proyecto de servicio diferente. Este tipo de implementación, en el que el mapa de URL hace referencia a un servicio de backend en otro proyecto, se conoce como referencia de servicio entre proyectos.

Ambos ejemplos requieren la misma configuración previa para otorgar permisos y configurar la VPC compartida antes de que puedas comenzar a crear balanceadores de cargas.

Estas no son las únicas opciones de configuración de VPC compartida compatibles con los balanceadores de cargas de aplicaciones internos. Para obtener más información sobre otras arquitecturas válidas de VPC compartida, consulta Arquitecturas de VPC compartida.

Si no quieres usar una red de VPC compartida, consulta Configura un balanceador de cargas de aplicaciones interno.

Antes de comenzar

  1. Lee la Descripción general de la VPC compartida.
  2. Lee la Descripción general del balanceador de cargas de aplicaciones interno, incluida la sección Arquitecturas de VPC compartida.

Permisos necesarios

La configuración de un balanceador de cargas en una red de VPC compartida requiere cierta configuración y aprovisionamiento iniciales por parte de un administrador. Después de la configuración inicial, el propietario de un proyecto de servicio puede realizar una de las siguientes acciones:

  • Implementar todos los componentes del balanceador de cargas y sus backends en un proyecto de servicio.
  • Implementar los componentes de backend del balanceador de cargas (backend y servicio de backend) en proyectos de servicio a los que puede hacer referencia un mapa de URL en otro servicio o proyecto host.

En esta sección, se resumen los permisos necesarios para seguir esta guía a fin de configurar un balanceador de cargas en una red de VPC compartida.

Configura la VPC compartida

Se requieren los siguientes roles para las siguientes tareas:

  1. Realizar tareas administrativas únicas, como configurar la VPC compartida y habilitar un proyecto host.
  2. Realizar tareas administrativas que se deben repetir cada vez que desees incorporar un proyecto de servicio nuevo. Esto incluye conectar el proyecto de servicio, aprovisionar y configurar recursos de red, y otorgar acceso al administrador del proyecto de servicio.

Estas tareas deben realizarse en el proyecto host de la VPC compartida. Recomendamos que el administrador de la VPC compartida también sea el propietario del proyecto host de la VPC compartida. Esto otorga de forma automática las funciones de administrador de red y administrador de seguridad.

Tarea Función requerida
Configurar la VPC compartida, habilitar el proyecto host y otorgar acceso a los administradores del proyecto de servicio Administrador de VPC compartida
Crea subredes en el proyecto host de VPC compartida y otorga acceso a los administradores del proyecto de servicio Administrador de redes
Agrega y quita reglas de firewall Administrador de seguridad

Después de que se aprovisionan las subredes, el propietario del proyecto host debe otorgar el rol de usuario de red en el proyecto host a cualquier persona (generalmente, desarrolladores, administradores del proyecto de servicio o cuentas de servicio) que necesite usar estos recursos.

Tarea Función requerida
Usar redes y subredes de VPC que pertenezcan al proyecto host Usuario de red

Esta función se puede otorgar a nivel de proyecto o para subredes individuales. Se recomienda que otorgues la función en subredes individuales. Otorgar el rol en el proyecto proporciona acceso a todas las subredes actuales y futuras en la red de VPC del proyecto host.

Implementa un balanceador de cargas y backends

Los administradores de proyectos de servicio necesitan los siguientes roles en el proyecto de servicio para crear recursos y backends de balanceo de cargas. Estos permisos se otorgan automáticamente al propietario o editor del proyecto de servicio.

Funciones otorgadas en el proyecto de servicio
Tarea Función requerida
Crear componentes del balanceador de cargas Administrador de redes
Crea instancias Administrador de instancias
Crear y modificar certificados SSL Administrador de seguridad

Requisitos previos

En esta sección, debes realizar los siguientes pasos:

  1. Configurar la red y las subredes en el proyecto host
  2. Configurar la VPC compartida en el proyecto host.

No es necesario realizar los pasos de esta sección cada vez que quieras crear un balanceador de cargas nuevo. Sin embargo, debes asegurarte de tener acceso a los recursos descritos aquí antes de continuar con la creación del balanceador de cargas.

Configura la red y las subredes en el proyecto host

Necesitas una red de VPC compartida con dos subredes: una para el frontend y los backends del balanceador de cargas una para los proxies del balanceador de cargas.

En este ejemplo, se usan las siguientes subredes, red y región:

  • Red. La red se llama lb-network.

  • Subred para el frontend y los backends del balanceador de cargas. Una subred llamada lb-frontend-and-backend-subnet en la región us-west1 usa 10.1.2.0/24 para su rango de IP principal.

  • Subred para proxies. Una subred llamada proxy-only-subnet en la región us-west1 usa 10.129.0.0/23 en su rango de IP principal.

Configura la subred para el frontend y los backends del balanceador de cargas

No es necesario realizar este paso cada vez que quieras crear un balanceador de cargas nuevo. Solo debes asegurarte de que el proyecto de servicio tenga acceso a una subred en la red de VPC compartida (además de la subred de solo proxy).

Todos los pasos de esta sección deben realizarse en el proyecto host.

Console

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

    Ir a las redes de VPC

  2. Haz clic en Crear red de VPC.
  3. En Nombre, ingresa lb-network.

  4. En la sección Subredes:

    1. Configura el Modo de creación de subred como Personalizado.

    2. En la sección Subred nueva, ingresa la siguiente información:

      • Nombre: lb-frontend-and-backend-subnet

      • Región: us-west1

      • Rangos de direcciones IP: 10.1.2.0/24

    3. Haz clic en Listo.

  5. Haz clic en Crear.

gcloud

  1. Crea una red de VPC con el comando gcloud compute networks create:

    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-frontend-and-backend-subnet 
    
    --network=lb-network 
    
    --range=10.1.2.0/24 
    
    --region=us-west1

Terraform

  1. Crea una red de VPC: 

    # Shared VPC network
resource "google_compute_network" "lb_network" {
  name                    = "lb-network"
  provider                = google-beta
  project                 = "my-host-project-id"
  auto_create_subnetworks = false
}

  2. Crea una subred en la región us-west1: 

    # Shared VPC network - backend subnet
resource "google_compute_subnetwork" "lb_frontend_and_backend_subnet" {
  name          = "lb-frontend-and-backend-subnet"
  provider      = google-beta
  project       = "my-host-project-id"
  region        = "us-west1"
  ip_cidr_range = "10.1.2.0/24"
  role          = "ACTIVE"
  network       = google_compute_network.lb_network.id
}

Configura la subred de solo proxy

Todos los balanceadores de cargas regionales basados en Envoy usan la subred de solo proxy en la región us-west1, en la red de VPC lb-network. Solo puede haber una subred de solo proxy activa por región y por red.

No realices este paso si ya hay una subred de solo proxy reservada en la región us-west1 de esta red.

Todos los pasos de esta sección deben realizarse en el proyecto host.

Console

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

    Ir a las redes de VPC

  2. Haz clic en el nombre de la red de VPC compartida: lb-network.
  3. Haz clic en Agregar subred.
  4. En Nombre, ingresa proxy-only-subnet.
  5. En Región, selecciona us-west1.
  6. Configura Propósito como Proxy administrado regional.
  7. En Rango de direcciones IP, ingresa 10.129.0.0/23.
  8. Haz clic en Agregar.

gcloud

Crea la subred de solo proxy con el comando gcloud compute networks subnets create:

gcloud compute networks subnets create proxy-only-subnet \
    --purpose=REGIONAL_MANAGED_PROXY \
    --role=ACTIVE \
    --region=us-west1 \
    --network=lb-network \
    --range=10.129.0.0/23

Terraform

Crea la subred de solo proxy:

# Shared VPC network - proxy-only subnet
resource "google_compute_subnetwork" "proxy_only_subnet" {
  name          = "proxy-only-subnet"
  provider      = google-beta
  project       = "my-host-project-id"
  region        = "us-west1"
  ip_cidr_range = "10.129.0.0/23"
  role          = "ACTIVE"
  purpose       = "REGIONAL_MANAGED_PROXY"
  network       = google_compute_network.lb_network.id
}

Otorga a los administradores de proyectos de servicio acceso a la subred de backend

Los administradores de proyectos de servicio requieren acceso a la subred lb-frontend-and-backend-subnet para poder aprovisionar los backends del balanceador de cargas.

Un administrador de VPC compartida debe otorgar acceso a la subred de backend a los administradores del proyecto de servicio (o desarrolladores que implementan recursos y backends que usan la subred). Si deseas obtener instrucciones, consulta Administradores de proyectos de servicio para algunas subredes.

Configura reglas de firewall en el proyecto host

En este ejemplo, se usan las siguientes reglas 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 TCP de los sistemas de verificación de estado de Google Cloud (en 130.211.0.0/22 y 35.191.0.0/16). En este ejemplo, se usa la etiqueta de destino load-balanced-backend para identificar las instancias a las que debe aplicarse.
  • fw-allow-proxies. Es una regla de entrada, aplicable a las instancias con balanceo de cargas, que permite el tráfico de TCP en los puertos 80, 443 y 8080 desde los proxies administrados del balanceador de cargas. En este ejemplo, se usa la etiqueta de destino load-balanced-backend para identificar las instancias a las que se debe aplicar.
  • fw-allow-ssh. Es una regla de entrada, aplicable a las instancias con balanceo de cargas, y que permite la conectividad SSH entrante en el puerto TCP 22 desde cualquier dirección. Puedes elegir un rango de IP de origen más restrictivo para esta regla. Por ejemplo, puedes especificar solo los rangos de IP del sistema desde el que inicias sesiones SSH. En este ejemplo, se usa la etiqueta de destino allow-ssh para identificar las máquinas virtuales (VM) a las que se aplica la regla de firewall.
Sin estas reglas de firewall, la regla predeterminada de denegación de entrada bloquea el tráfico entrante a las instancias de backend.

Todos los pasos de esta sección deben realizarse en el proyecto host.

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 permitirá las verificaciones de estado de Google Cloud:
    • Nombre: fw-allow-health-check
    • Red: lb-network
    • Dirección del tráfico: entrada
    • Acción si hay coincidencia: permitir
    • Objetivos: etiquetas de destino especificadas
    • Etiquetas de destino: load-balanced-backend
    • 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:
      • Elige Protocolos y puertos especificados.
      • Marca TCP e ingresa 80 para el número de puerto.

        • Como práctica recomendada, limita esta regla solo a los protocolos y puertos que coincidan con los que usa tu verificación de estado. Si usas tcp:80 en el protocolo y el puerto, Google Cloud puede usar HTTP en el puerto 80 a fin de contactar las VMs, pero no puede usar HTTPS en el puerto 443 para comunicarse con ellas.

  3. Haz clic en Crear.
  4. Haz clic en Crear regla de firewall para crear la regla que permitirá las verificaciones de estado de Google Cloud:
    • Nombre: fw-allow-proxies
    • Red: lb-network
    • Dirección del tráfico: entrada
    • Acción si hay coincidencia: permitir
    • Objetivos: etiquetas de destino especificadas
    • Etiquetas de destino: load-balanced-backend
    • Filtro de fuente: Rangos de IPv4
    • Rangos de IPv4 de origen: 10.129.0.0/23
    • Protocolos y puertos:
      • Elige Protocolos y puertos especificados.
      • Marca TCP e ingresa 80, 443, 8080 para los números de puerto.
  5. Haz clic en Crear.
  6. Haz clic en Crear regla de firewall para crear la regla que permitirá las verificaciones de estado de Google Cloud:
    • Nombre: fw-allow-ssh
    • Red: lb-network
    • 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.
      • Marca TCP e ingresa 22 para el número de puerto.
  7. Haz clic en Crear.

gcloud

  1. Crea la regla de firewall fw-allow-health-check para permitir las verificaciones de estado de Google Cloud. Este ejemplo permite todo el tráfico de TCP proveniente de la verificación de estado. Sin embargo, puedes configurar un conjunto más limitado de puertos para satisfacer tus necesidades.

    gcloud compute firewall-rules create fw-allow-health-check \
   --network=lb-network \
   --action=allow \
   --direction=ingress \
   --source-ranges=130.211.0.0/22,35.191.0.0/16 \
   --target-tags=load-balanced-backend \
   --rules=tcp

  2. Crea la regla de firewall fw-allow-proxies para permitir que el tráfico de la subred de solo proxy de Envoy llegue a tus backends.

    gcloud compute firewall-rules create fw-allow-proxies \
   --network=lb-network \
   --action=allow \
   --direction=ingress \
   --source-ranges=10.129.0.0/23 \
   --target-tags=load-balanced-backend \
   --rules=tcp:80,tcp:443,tcp:8080

  3. Crea la regla de firewall fw-allow-ssh para permitir la conectividad SSH a las VM con la etiqueta de red allow-ssh. Cuando omites source-ranges, Google Cloud interpreta que la regla significa cualquier fuente.

    gcloud compute firewall-rules create fw-allow-ssh \
   --network=lb-network \
   --action=allow \
   --direction=ingress \
   --target-tags=allow-ssh \
   --rules=tcp:22

Terraform

  1. Crea una regla de firewall para permitir las verificaciones de estado de Google Cloud. 

    resource "google_compute_firewall" "fw_allow_health_check" {
  name          = "fw-allow-health-check"
  provider      = google-beta
  project       = "my-host-project-id"
  direction     = "INGRESS"
  network       = google_compute_network.lb_network.id
  source_ranges = ["130.211.0.0/22", "35.191.0.0/16"]
  allow {
    protocol = "tcp"
  }
  target_tags = ["load-balanced-backend"]
}

  2. Crea una regla de firewall para permitir que el tráfico de la subred de solo proxy de Envoy llegue a tus backends. 

    resource "google_compute_firewall" "fw_allow_proxies" {
  name          = "fw-allow-proxies"
  provider      = google-beta
  project       = "my-host-project-id"
  direction     = "INGRESS"
  network       = google_compute_network.lb_network.id
  source_ranges = ["10.129.0.0/23"]
  allow {
    protocol = "tcp"
    ports    = ["80", "443", "8080"]
  }
  target_tags = ["load-balanced-backend"]
}

  3. Crea una regla de firewall para permitir la conectividad SSH a las VMs con la etiqueta de red allow-ssh. 

    resource "google_compute_firewall" "fw_allow_ssh" {
  name          = "fw-allow-ssh"
  provider      = google-beta
  project       = "my-host-project-id"
  direction     = "INGRESS"
  network       = google_compute_network.lb_network.id
  source_ranges = ["0.0.0.0/0"]
  allow {
    protocol = "tcp"
    ports    = ["22"]
  }
  target_tags = ["allow-ssh"]
}

Configura la VPC compartida en el proyecto host

Este paso implica habilitar un proyecto host de VPC compartida, compartir subredes del proyecto host y conectar proyectos de servicio al proyecto host para que los proyectos de servicio puedan usar la red de VPC compartida. Para configurar una VPC compartida en el proyecto host, consulta las siguientes páginas:

En el resto de estas instrucciones, se supone que ya configuraste una VPC compartida. Esto incluye configurar políticas de IAM para tu organización y designar los proyectos host y de servicio.

No continúes hasta configurar la VPC compartida y habilitado los proyectos host y de servicio.

Después de completar los pasos definidos en esta sección de requisitos previos, puedes realizar una de las siguientes configuraciones:

Configura un balanceador de cargas en el proyecto de servicio

En este ejemplo, se crea un balanceador de cargas de aplicaciones interno en el que todos los componentes de balanceo de cargas (regla de reenvío, proxy de destino, mapa de URL y servicio de backend) y backends se crean en el proyecto de servicio.

Los recursos de herramientas de redes del balanceador de cargas de aplicaciones interno, como la subred de solo proxy y la subred para las instancias de backend, se crean en el proyecto host. Las reglas de firewall para las instancias de backend también se crean en el proyecto host.

Figura 1: Balanceador de cargas de aplicaciones interno en una VPC compartida
Figura 1. Balanceador de cargas de aplicaciones interno en una VPC compartida

En esta sección, se muestra cómo configurar el balanceador de cargas y los backends. Estos pasos debe realizarlos el administrador del proyecto de servicio (o un desarrollador que opera dentro del proyecto de servicio) y no requieren participación del administrador del proyecto host. Los pasos de esta sección son muy similares a los pasos estándar para configurar el balanceador de cargas de aplicaciones interno.

El ejemplo en esta página configura de manera explícita una dirección IP interna reservada para la regla de reenvío del balanceador de cargas de aplicaciones interno, en lugar de permitir que se asigne una dirección IP interna efímera. Recomendamos reservar direcciones IP para las reglas de reenvío.

Crea el backend del grupo de instancias administrado

En esta sección, se muestra cómo crear una plantilla y un grupo de instancias administrado. El grupo de instancias administrado proporciona instancias de VM que ejecutan los servidores de backend de un balanceador de cargas interno de aplicaciones de ejemplo. Las cargas del tráfico de los clientes se balancean a estos servidores de backend. A modo de demostración, los backends entregan sus propios nombres de host.

Console

  1. Crea una plantilla de instancias. En la consola de Google Cloud, ve a la página Plantillas de instancia.

    Ir a Plantillas de instancia

    1. Haz clic en Crear plantilla de instancias.
    2. En Nombre, ingresa l7-ilb-backend-template.
    3. Asegúrate de que el disco de arranque esté configurado como una imagen de Debian, como Debian GNU/Linux 12 (bookworm). En estas instrucciones, se usan comandos que solo están disponibles en Debian, como apt-get. Si necesitas cambiar el Disco de arranque, haz clic en Cambiar.
      1. En Sistema operativo, selecciona Debian.
      2. En Versión, selecciona una de las imágenes de Debian disponibles, como Debian GNU/Linux 12 (bookworm).
      3. Haz clic en Seleccionar.
    4. Haz clic en Opciones avanzadas y, luego, en Herramientas de redes.
    5. Ingresa las siguientes Etiquetas de red: allow-ssh,load-balanced-backend.
    6. En la sección Interfaces de red, selecciona Redes compartidas conmigo (del proyecto host: HOST_PROJECT_ID).
    7. Selecciona la subred lb-frontend-and-backend-subnet de la red lb-network.
    8. Haz clic en Administración. En Administración, inserta la siguiente secuencia de comandos en el campo Secuencia de comandos de inicio. 
       #! /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.

  2. Crea un grupo de instancias administrado. En la consola de Google Cloud, ve a la página Grupos de instancias.

    Ir a Grupos de instancias

    1. Haga clic en Crear grupo de instancias.
    2. Selecciona Nuevo grupo de instancias administrado (sin estado). Para obtener más información, consulta MIG con o sin estado.
    3. En Nombre, ingresa l7-ilb-backend-example.
    4. En Ubicación, selecciona Zona única.
    5. En Región, selecciona us-west1.
    6. En Zona, selecciona us-west1-a.
    7. En Plantilla de instancias, selecciona l7-ilb-backend-template.

    8. Especifica la cantidad de instancias que quieres crear en el grupo.

      En este ejemplo, especifica las siguientes opciones en Ajuste de escala automático:

      • En Modo de ajuste de escala automático, selecciona Off:do not autoscale.
      • En Cantidad máxima de instancias, ingresa 2.

      De manera opcional, en la sección de Ajuste de escala automático de la IU, puedes configurar el grupo de instancias para que agregue o quite instancias de forma automática en función del uso de CPU de la instancia.

    9. Haz clic en Crear.

gcloud

En las instrucciones de gcloud que se incluyen en esta guía, se supone que usas Cloud Shell o algún otro entorno con bash instalado.

  1. Crea una plantilla de instancias de VM con el servidor de HTTP con el comando gcloud compute instance-templates create.

    gcloud compute instance-templates create l7-ilb-backend-template \
--region=us-west1 \
--network=projects/HOST_PROJECT_ID/global/networks/lb-network \
--subnet=projects/HOST_PROJECT_ID/regions/us-west1/subnetworks/lb-frontend-and-backend-subnet \
--tags=allow-ssh,load-balanced-backend \
--image-family=debian-12 \
--image-project=debian-cloud \
--metadata=startup-script='#! /bin/bash
apt-get update
apt-get install apache2 -y
a2ensite default-ssl
a2enmod ssl
vm_hostname="$(curl -H "Metadata-Flavor:Google" \
http://metadata.google.internal/computeMetadata/v1/instance/name)"
echo "Page served from: $vm_hostname" | \
tee /var/www/html/index.html
systemctl restart apache2' \
--project=SERVICE_PROJECT_ID

  2. Crea un grupo de instancias administrado en la zona con el comando gcloud compute instance-groups managed create.

    gcloud compute instance-groups managed create l7-ilb-backend-example \
    --zone=us-west1-a \
    --size=2 \
    --template=l7-ilb-backend-template \
    --project=SERVICE_PROJECT_ID

Terraform

  1. Crea una plantilla de instancia de VM.

    # Instance template
resource "google_compute_instance_template" "default" {
  name     = "l7-ilb-backend-template"
  provider = google-beta
  project  = "my-service-project-id"
  region   = "us-west1"
  # For machine type, using small. For more options check https://cloud.google.com/compute/docs/machine-types
  machine_type = "e2-small"
  tags         = ["allow-ssh", "load-balanced-backend"]
  network_interface {
    network    = google_compute_network.lb_network.id
    subnetwork = google_compute_subnetwork.lb_frontend_and_backend_subnet.id
    access_config {
      # add external ip to fetch packages like apache2, ssl
    }
  }
  disk {
    source_image = "debian-cloud/debian-12"
    auto_delete  = true
    boot         = true
  }

  # install apache2 and serve a simple web page
  metadata = {
    startup-script = <<EOF
    #! /bin/bash
    sudo apt-get update
    sudo apt-get install apache2 -y
    sudo a2ensite default-ssl
    sudo a2enmod ssl
    vm_hostname="$(curl -H "Metadata-Flavor:Google" \
    http://metadata.google.internal/computeMetadata/v1/instance/name)"
    sudo echo "Page served from: $vm_hostname" | \
    tee /var/www/html/index.html
    sudo systemctl restart apache2
    EOF
  }
}

  2. Crea un grupo de instancias administrado.

    Para HTTP:

    # MIG
resource "google_compute_instance_group_manager" "default" {
  name               = "l7-ilb-backend-example"
  provider           = google-beta
  project            = "my-service-project-id"
  zone               = "us-west1-a"
  base_instance_name = "vm"
  target_size        = 2
  version {
    instance_template = google_compute_instance_template.default.id
    name              = "primary"
  }
  named_port {
    name = "http"
    port = 80
  }
}

    Para HTTPS:

    # MIG
resource "google_compute_instance_group_manager" "default" {
  name               = "l7-ilb-backend-example"
  provider           = google-beta
  project            = "my-service-project-id"
  zone               = "us-west1-a"
  base_instance_name = "vm"
  target_size        = 2
  version {
    instance_template = google_compute_instance_template.default.id
    name              = "primary"
  }
  named_port {
    name = "https"
    port = 443
  }
}

Configura el balanceador de cargas

En esta sección, se muestra cómo crear los recursos internos del balanceador de cargas de aplicaciones:

  • Verificación de estado de HTTP
  • Servicio de backend con un grupo de instancias administrado como backend
  • Un mapa de URL
  • Certificado SSL (obligatorio solo para HTTPS)
  • Proxy de destino
  • Regla de reenvío

Disponibilidad del proxy

Según la cantidad de proyectos de servicio que usen la misma red de VPC compartida, podrías alcanzar cuotas o límites más rápido que en el modelo de implementación de redes en el que cada proyecto de Google Cloud aloja su propia red.

Por ejemplo, a veces las regiones de Google Cloud no tienen suficiente capacidad de proxy para un balanceador de cargas de aplicaciones interno nuevo. Si esto sucede, la consola de Google Cloud muestra un mensaje de advertencia de disponibilidad del proxy cuando creas el balanceador de cargas. Para resolver este problema, puedes realizar una de las siguientes acciones:

  • Espera a que se resuelva el problema de capacidad.

  • Comunicarte con tu equipo de ventas de Google Cloud para aumentar estos límites

Console

Cambia el contexto al proyecto de servicio

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

    Ir al panel

  2. Haz clic en la lista Seleccionar de en la parte superior de la página. En la ventana Seleccionar una opción que aparece, selecciona el proyecto de servicio en el que deseas crear el balanceador de cargas.

Inicia tu configuración

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

    Ir a Balanceo de cargas

  2. Haz clic en Crear balanceador de cargas.
  3. En Tipo de balanceador de cargas, selecciona Balanceador de cargas de aplicaciones (HTTP/HTTPS) y haz clic en Siguiente.
  4. En Orientado al público o interno, selecciona Interno y haz clic en Siguiente.
  5. En Implementación entre regiones o de una sola región, selecciona Ideal para cargas de trabajo regionales y haz clic en Siguiente.
  6. Haz clic en Configurar.

Configuración básica

  1. Para el Nombre del balanceador de cargas, ingresa l7-ilb-shared-vpc.
  2. En Región, selecciona us-west1.

  3. En Red, selecciona lb-network (de Proyecto: HOST_PROJECT_ID).

    Si ves una advertencia sobre la subred de solo proxy que se requiere en la red de VPC compartida, confirma que el administrador del proyecto host haya creado proxy-only-subnet en la región us-west1 en la red de VPC compartida lb-network. La creación del balanceador de cargas tendrá éxito incluso si no tienes permiso para ver la subred de solo proxy en esta página.

  4. Mantén la ventana abierta para continuar.

Configure el backend

  1. Haga clic en Configuración de backend.
  2. En el menú Crear o seleccionar servicios de backend, selecciona Crear un servicio de backend.
  3. Otorga el Nombre l7-ilb-backend-service para el servicio de backend.
  4. Configura el Tipo de backend como grupos de instancias.
  5. En la sección Nuevo backend, sigue estos pasos:
    1. Establece el Grupo de instancias en l7-ilb-backend-example.
    2. Establece el campo Números de puerto en 80.
    3. Establece el campo Modo de balanceo en Uso.
    4. Haz clic en Listo.
  6. En la sección Verificación de estado, elige Crear una verificación de estado con los parámetros siguientes:
    1. Nombre: l7-ilb-basic-check
    2. Protocolo: HTTP
    3. Puerto: 80
  7. Haz clic en Guardar y continuar.
  8. Haz clic en Crear.

Configura las reglas de enrutamiento

  • Haga clic en Reglas de enrutamiento. Asegúrate de que l7-ilb-backend-service sea el único servicio de backend para los hosts y rutas de acceso no coincidentes.

Para obtener información sobre la administración del tráfico, consulta Configura la administración del tráfico.

Configura el frontend

Para HTTP:

  1. Haga clic en Configuración de frontend.
  2. Ingresa l7-ilb-forwarding-rule en Nombre.
  3. Configura el Protocolo en HTTP.
  4. Establece Subred en lb-frontend-and-backend-subnet. No selecciones la subred de solo proxy para el frontend, incluso si es una opción en la lista.
  5. Configura el Puerto en 80.
  6. Haz clic en el menú Dirección IP y, luego, en Crear dirección IP.
  7. En el panel Reservar una dirección IP interna estática, proporciona los siguientes detalles:
    1. En Nombre, ingresa ip-address-shared-vpc.
    2. En Dirección IP estática, haz clic en Let me choose. En Dirección IP personalizada, ingresa 10.1.2.99.
    3. (Opcional) Si deseas compartir esta dirección IP con diferentes frontends, configura Propósito como Compartido.
  8. Haz clic en Listo.

Para HTTPS:

Si usas HTTPS entre el cliente y el balanceador de cargas, necesitas uno o más recursos de certificado SSL para configurar el proxy. Para obtener información sobre cómo crear recursos de certificados SSL, consulta Certificados SSL. Por el momento, los certificados administrados por Google no son compatibles con los balanceadores de cargas de aplicaciones internos.

  1. Haz clic en Configuración de frontend.
  2. En el campo Nombre, ingresa l7-ilb-forwarding-rule.
  3. En el campo Protocolo, selecciona HTTPS (includes HTTP/2).
  4. Establece Subred en lb-frontend-and-backend-subnet. No selecciones la subred de solo proxy para el frontend, incluso si es una opción en la lista.
  5. Asegúrate de que el Puerto esté establecido en 443 para permitir el tráfico HTTPS.
  6. Haz clic en el menú Dirección IP y, luego, en Crear dirección IP.
  7. En el panel Reservar una dirección IP interna estática, proporciona los siguientes detalles:
    1. En Nombre, ingresa ip-address-shared-vpc.
    2. En Dirección IP estática, haz clic en Let me choose. En Dirección IP personalizada, ingresa 10.1.2.99.
    3. (Opcional) Si deseas compartir esta dirección IP con diferentes frontends, configura Propósito como Compartido.
  8. Haz clic en la lista Certificado.
    1. Si ya tienes un recurso de certificado SSL autoadministrado que deseas usar como certificado SSL principal, selecciónalo en el menú.
    2. De lo contrario, selecciona Crear un nuevo certificado.
      1. En Nombre, ingresa l7-ilb-cert.
      2. En los campos correspondientes, sube los archivos con formato PEM:
        • Certificado de clave pública
        • Cadena de certificado
        • Clave privada
      3. Haz clic en Crear.
  9. Para agregar otros recursos de certificado, además del recurso de certificado SSL principal, haz lo siguiente:
    1. Haz clic en Agregar certificado.
    2. Selecciona un certificado de la lista Certificados o haz clic en Crear un certificado nuevo y sigue las instrucciones anteriores.
  10. Haz clic en Listo.

Revise y finalice la configuración

  • Haz clic en Crear.

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 l7-ilb-basic-check \
   --region=us-west1 \
   --use-serving-port \
   --project=SERVICE_PROJECT_ID

  2. Define el servicio de backend con el comando gcloud compute backend-services create.

    gcloud compute backend-services create l7-ilb-backend-service \
  --load-balancing-scheme=INTERNAL_MANAGED \
  --protocol=HTTP \
  --health-checks=l7-ilb-basic-check \
  --health-checks-region=us-west1 \
  --region=us-west1 \
  --project=SERVICE_PROJECT_ID

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

    gcloud compute backend-services add-backend l7-ilb-backend-service \
  --balancing-mode=UTILIZATION \
  --instance-group=l7-ilb-backend-example \
  --instance-group-zone=us-west1-a \
  --region=us-west1 \
  --project=SERVICE_PROJECT_ID

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

    gcloud compute url-maps create l7-ilb-map \
  --default-service=l7-ilb-backend-service \
  --region=us-west1 \
  --project=SERVICE_PROJECT_ID

  5. Crea el proxy de destino.

    Para HTTP:

    Para un balanceador de cargas de HTTP interno, crea el proxy de destino con el comando gcloud compute target-http-proxies create.

    gcloud compute target-http-proxies create l7-ilb-proxy \
  --url-map=l7-ilb-map \
  --url-map-region=us-west1 \
  --region=us-west1 \
  --project=SERVICE_PROJECT_ID

    Para HTTPS:

    Para obtener información sobre cómo crear recursos de certificados SSL, consulta Certificados SSL. Por el momento, los certificados administrados por Google no son compatibles con los balanceadores de cargas de aplicaciones internos.

    Asigna tus rutas de archivos a nombres de variables.

    export LB_CERT=path to PEM-formatted file

    export LB_PRIVATE_KEY=path to PEM-formatted file

    Crea un certificado SSL regional con el comando gcloud compute ssl-certificates create.

    gcloud compute ssl-certificates create l7-ilb-cert \
  --certificate=$LB_CERT \
  --private-key=$LB_PRIVATE_KEY \
  --region=us-west1

    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 l7-ilb-proxy \
  --url-map=l7-ilb-map \
  --region=us-west1 \
  --ssl-certificates=l7-ilb-cert \
  --project=SERVICE_PROJECT_ID

  6. Crea la regla de reenvío.

    Para redes personalizadas, debes hacer referencia a la subred en la regla de reenvío.

    Para la dirección IP de la regla de reenvío, usa lb-frontend-and-backend-subnet. Si intentas usar la subred de solo proxy, la creación de la regla de reenvío fallará.

    Para HTTP:

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

    gcloud compute forwarding-rules create l7-ilb-forwarding-rule \
  --load-balancing-scheme=INTERNAL_MANAGED \
  --network=projects/HOST_PROJECT_ID/global/networks/lb-network \
  --subnet=projects/HOST_PROJECT_ID/regions/us-west1/subnetworks/lb-frontend-and-backend-subnet \
  --address=IP_ADDRESS_NAME \
  --ports=80 \
  --region=us-west1 \
  --target-http-proxy=l7-ilb-proxy \
  --target-http-proxy-region=us-west1 \
  --project=SERVICE_PROJECT_ID

    Para HTTPS:

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

    gcloud compute forwarding-rules create l7-ilb-forwarding-rule \
  --load-balancing-scheme=INTERNAL_MANAGED \
  --network=projects/HOST_PROJECT_ID/global/networks/lb-network \
  --subnet=projects/HOST_PROJECT_ID/regions/us-west1/subnetworks/lb-frontend-and-backend-subnet \
  --address=IP_ADDRESS_NAME \
  --ports=443 \
  --region=us-west1 \
  --target-https-proxy=l7-ilb-proxy \
  --target-https-proxy-region=us-west1 \
  --project=SERVICE_PROJECT_ID

Terraform

  1. Define la verificación de estado de HTTP.

    Para HTTP: 

    # health check
resource "google_compute_health_check" "default" {
  name               = "l7-ilb-basic-check"
  provider           = google-beta
  project            = "my-service-project-id"
  timeout_sec        = 1
  check_interval_sec = 1
  http_health_check {
    port = "80"
  }
}

    Para HTTPS: 

    # health check
resource "google_compute_health_check" "default" {
  name               = "l7-ilb-basic-check"
  provider           = google-beta
  project            = "my-service-project-id"
  timeout_sec        = 1
  check_interval_sec = 1
  https_health_check {
    port = "443"
  }
}

  2. Define el servicio de backend.

    # backend service
resource "google_compute_region_backend_service" "default" {
  name                  = "l7-ilb-backend-service"
  provider              = google-beta
  project               = "my-service-project-id"
  region                = "us-west1"
  protocol              = "HTTP"
  load_balancing_scheme = "INTERNAL_MANAGED"
  timeout_sec           = 10
  health_checks         = [google_compute_health_check.default.id]
  backend {
    group           = google_compute_instance_group_manager.default.instance_group
    balancing_mode  = "UTILIZATION"
    capacity_scaler = 1.0
  }
}

  3. Crea el mapa de URL.

    # URL map
resource "google_compute_region_url_map" "default" {
  name            = "l7-ilb-map"
  provider        = google-beta
  project         = "my-service-project-id"
  region          = "us-west1"
  default_service = google_compute_region_backend_service.default.id
}

  4. Crea el proxy de destino.

    Para HTTP: 

    # HTTP target proxy
resource "google_compute_region_target_http_proxy" "default" {
  name     = "l7-ilb-proxy"
  provider = google-beta
  project  = "my-service-project-id"
  region   = "us-west1"
  url_map  = google_compute_region_url_map.default.id
}

    Para HTTPS: crea un certificado SSL regional

    Para obtener información sobre cómo crear recursos de certificados SSL, consulta Certificados SSL. Por el momento, los certificados administrados por Google no son compatibles con los balanceadores de cargas de aplicaciones internos.

    # Use self-signed SSL certificate
resource "google_compute_region_ssl_certificate" "default" {
  name        = "l7-ilb-cert"
  provider    = google-beta
  project     = "my-service-project-id"
  region      = "us-west1"
  private_key = file("sample-private.key") # path to PEM-formatted file
  certificate = file("sample-server.cert") # path to PEM-formatted file
}

    Usa el certificado SSL regional para crear un proxy de destino

    # HTTPS target proxy
resource "google_compute_region_target_https_proxy" "default" {
  name             = "l7-ilb-proxy"
  provider         = google-beta
  project          = "my-service-project-id"
  region           = "us-west1"
  url_map          = google_compute_region_url_map.default.id
  ssl_certificates = [google_compute_region_ssl_certificate.default.id]
}

  5. Crea la regla de reenvío.

    Para redes personalizadas, debes hacer referencia a la subred en la regla de reenvío.

    Para HTTP: 

    # Forwarding rule
resource "google_compute_forwarding_rule" "default" {
  name                  = "l7-ilb-forwarding-rule"
  provider              = google-beta
  project               = "my-service-project-id"
  region                = "us-west1"
  ip_protocol           = "TCP"
  port_range            = "80"
  load_balancing_scheme = "INTERNAL_MANAGED"
  target                = google_compute_region_target_http_proxy.default.id
  network               = google_compute_network.lb_network.id
  subnetwork            = google_compute_subnetwork.lb_frontend_and_backend_subnet.id
  network_tier          = "PREMIUM"
  depends_on            = [google_compute_subnetwork.lb_frontend_and_backend_subnet]
}

    Para HTTPS: 

    # Forwarding rule
resource "google_compute_forwarding_rule" "default" {
  name                  = "l7-ilb-forwarding-rule"
  provider              = google-beta
  project               = "my-service-project-id"
  region                = "us-west1"
  ip_protocol           = "TCP"
  port_range            = "443"
  load_balancing_scheme = "INTERNAL_MANAGED"
  target                = google_compute_region_target_https_proxy.default.id
  network               = google_compute_network.lb_network.id
  subnetwork            = google_compute_subnetwork.lb_frontend_and_backend_subnet.id
  network_tier          = "PREMIUM"
  depends_on            = [google_compute_subnetwork.lb_frontend_and_backend_subnet]
}

Prueba el balanceador de cargas

Para probar el balanceador de cargas, primero debes crear una VM de cliente de muestra. Luego, establece una sesión SSH con la VM y envía tráfico desde esta VM al balanceador de cargas.

Crea una instancia de VM de prueba

Los clientes pueden estar ubicados en el proyecto host o en cualquier proyecto de servicio conectado. En este ejemplo, probarás que el balanceador de cargas funcione mediante la implementación de una VM de cliente en un proyecto de servicio. El cliente debe usar la misma red de VPC compartida y estar en la misma región que el balanceador de cargas.

Console

  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 client-vm.

  4. Establece la Zona en us-west1-a.

  5. Haz clic en Opciones avanzadas y, luego, en Herramientas de redes.

  6. Ingresa las siguientes Etiquetas de red: allow-ssh,load-balanced-backend.

  7. En la sección Interfaces de red, selecciona Redes compartidas conmigo (del proyecto host: HOST_PROJECT_ID).

  8. Selecciona la subred lb-frontend-and-backend-subnet de la red lb-network.

  9. Haz clic en Crear.

gcloud

Crea una instancia de VM de prueba.

gcloud compute instances create client-vm \
    --image-family=debian-12 \
    --image-project=debian-cloud \
    --subnet=projects/HOST_PROJECT_ID/regions/us-west1/subnetworks/lb-frontend-and-backend-subnet \
    --zone=us-west1-a \
    --tags=allow-ssh \
    --project=SERVICE_PROJECT_ID

Terraform

Crea una instancia de VM de prueba.

resource "google_compute_instance" "vm_test" {
  name         = "client-vm"
  provider     = google-beta
  project      = "my-service-project-id"
  zone         = "us-west1-a"
  machine_type = "e2-small"
  tags         = ["allow-ssh"]
  network_interface {
    network    = google_compute_network.lb_network.id
    subnetwork = google_compute_subnetwork.lb_frontend_and_backend_subnet.id
  }
  boot_disk {
    initialize_params {
      image = "debian-cloud/debian-12"
    }
  }
  lifecycle {
    ignore_changes = [
      metadata["ssh-keys"]
    ]
  }
}

Envía tráfico al balanceador de cargas

Usa SSH para conectarte a la instancia que acabas de crear y probar que los servicios HTTP(S) en los backends sean accesibles a través de la dirección IP de la regla de reenvío del balanceador de cargas de aplicaciones interno y que las cargas del tráfico se balanceen entre las instancias de backend.

  1. Conéctate a la instancia con SSH.

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

  2. Verifica que la IP entregue su nombre de host. Reemplaza LB_IP_ADDRESS por la dirección IP del balanceador de cargas.

    curl LB_IP_ADDRESS

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

    curl -k -s 'https://LB_IP_ADDRESS:443'

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

Configura un balanceador de cargas con un servicio de backend entre proyectos

En el ejemplo anterior de esta página, se muestra cómo configurar una implementación de VPC compartida en la que todos los componentes del balanceador de cargas y sus backends se crean en el proyecto de servicio.

Los balanceadores de cargas de aplicaciones regionales internos también te permiten configurar implementaciones de VPC compartida en las que un mapa de URL de un proyecto host o de servicio puede hacer referencia a servicios de backend (y backends) ubicados en varios proyectos de servicio en entornos de VPC compartida. Esto se conoce como referencia de servicio entre proyectos.

Puedes usar los pasos en esta sección como referencia para configurar cualquiera de las combinaciones compatibles que se enumeran aquí:

  • Regla de reenvío, proxy de destino y mapa de URL en el proyecto host, y servicio de backend en un proyecto de servicio
  • Regla de reenvío, mapa de URL y proxy de destino en un proyecto de servicio, y backend de servicio en otro proyecto de servicio

La referencia del servicio entre proyectos se puede usar con grupos de instancias, NEG sin servidores o cualquier otro tipo de backend compatible. Si usas NEG sin servidores, debes crear una VM en la red de VPC en la que desees crear el frontend del balanceador de cargas. Si deseas ver un ejemplo, consulta Crea una instancia de VM en una subred específica en Configura un balanceador de cargas de aplicaciones interno con Cloud Run.

Requisitos de configuración

En este ejemplo se configura un balanceador de cargas de muestra con su frontend y backend en dos proyectos de servicio diferentes.

Si aún no lo hiciste, debes completar todos los pasos de requisitos previos para configurar la VPC compartida y configurar la red, las subredes y las reglas firewall necesarias para este ejemplo. Para obtener instrucciones, consulta lo siguiente:

Figura 2: Frontend y backend del balanceador de cargas en diferentes proyectos de servicio
Figura 2.. Frontend y backend del balanceador de cargas en diferentes proyectos de servicio

Crea los backends y el servicio de backend en el proyecto de servicio B

Todos los pasos de esta sección deben realizarse en el proyecto de servicio B.

Console

  1. Crea una plantilla de instancias. En la consola de Google Cloud, ve a la página Plantillas de instancia.

    Ir a Plantillas de instancia

    1. Haga clic en Crear plantilla de instancias.
    2. Ingresa un Nombre para la plantilla de instancias: cross-ref-backend-template.
    3. Asegúrate de que el disco de arranque esté configurado como una imagen de Debian, como Debian GNU/Linux 12 (bookworm). En estas instrucciones, se usan comandos que solo están disponibles en Debian, como apt-get. Si necesitas cambiar el Disco de arranque, haz clic en Cambiar.
      1. En Sistema operativo, selecciona Debian.
      2. En Versión, selecciona una de las imágenes de Debian disponibles, como Debian GNU/Linux 12 (bookworm).
      3. Haz clic en Seleccionar.
    4. Haz clic en Opciones avanzadas y, luego, en Herramientas de redes.
    5. Ingresa las siguientes Etiquetas de red: allow-ssh,load-balanced-backend.
    6. En la sección Interfaces de red, selecciona Redes compartidas conmigo (del proyecto host: HOST_PROJECT_ID).
    7. Selecciona la subred lb-frontend-and-backend-subnet de la red lb-network.
    8. Haz clic en Administración. En Administración, inserta la siguiente secuencia de comandos en el campo Secuencia de comandos de inicio. 
      #! /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.

  2. Crea un grupo de instancias administrado. En la consola de Google Cloud, ve a la página Grupos de instancias.

    Ir a Grupos de instancias

    1. Haga clic en Crear grupo de instancias.
    2. Selecciona Nuevo grupo de instancias administrado (sin estado). Para obtener más información, consulta MIG con o sin estado.
    3. Ingresa un Nombre para el grupo de instancias: cross-ref-ig-backend.
    4. En Ubicación, selecciona Zona única.
    5. En Región, selecciona us-west1.
    6. En Zona, selecciona us-west1-a.
    7. En Plantilla de instancias, selecciona cross-ref-backend-template.

    8. Especifica la cantidad de instancias que quieres crear en el grupo.

      En este ejemplo, especifica las siguientes opciones en Ajuste de escala automático:

      • En Modo de ajuste de escala automático, selecciona Off:do not autoscale.
      • En Cantidad máxima de instancias, ingresa 2.

      De manera opcional, en la sección de Ajuste de escala automático de la IU, puedes configurar el grupo de instancias para que agregue o quite instancias de forma automática en función del uso de CPU de la instancia.

    9. Haz clic en Crear.

  3. Crea un servicio de backend regional. Como parte de este paso, también crearemos la verificación de estado y agregaremos backends al servicio de backend. En la consola de Google Cloud, ve a la página Backends.

    Ir a Backends

    1. Haz clic en Crear servicio de backend regional.
    2. Ingresa un Nombre para el servicio de backend: cross-ref-backend-service.
    3. En Región, selecciona us-west1.
    4. En Tipo de balanceador de cargas, selecciona Balanceador de cargas de aplicaciones interno regional (INTERNAL_MANAGED).
    5. Configura el Tipo de backend como grupos de instancias.
    6. En la sección Backends, configura Red como lb-network.
    7. Haz clic en Agregar backend y configura los siguientes campos:
      1. Configura el Grupo de instancias como cross-ref-ig-backend.
      2. Ingresa los Números de puerto: 80.
      3. Establece el campo Modo de balanceo en Uso.
      4. Haz clic en Listo.
    8. En la sección Verificación de estado, elige Crear una verificación de estado con los parámetros siguientes:
      1. Nombre: cross-ref-http-health-check
      2. Protocolo: HTTP
      3. Puerto: 80
      4. Haz clic en Guardar.
    9. Haz clic en Continuar.

    10. Opcional: En la sección Agregar permisos, ingresa las principales de IAM (por lo general, una dirección de correo electrónico) de los administradores del balanceador de cargas de otros proyectos para que puedan usar este servicio de backend en los balanceadores de cargas de sus propios proyectos. Sin este permiso, no puedes usar la referencia de servicios entre proyectos.

      Si no tienes permiso para configurar políticas de control de acceso en los servicios de backend de este proyecto, aún puedes crear el servicio de backend, y un usuario autorizado puede realizar este paso más adelante, como se describe en la sección Otorga permisos al administrador del balanceador de cargas para usar el servicio de backend. En esa sección, también se describe cómo otorgar acceso a todos los servicios de backend de este proyecto para que no tengas que otorgar acceso cada vez que crees un servicio de backend nuevo.

    11. Haz clic en Crear.

gcloud

  1. Crea una plantilla de instancias de VM con el servidor de HTTP con el comando gcloud compute instance-templates create.

    gcloud compute instance-templates create BACKEND_IG_TEMPLATE \
    --region=us-west1 \
    --network=projects/HOST_PROJECT_ID/global/networks/lb-network \
    --subnet=projects/HOST_PROJECT_ID/regions/us-west1/subnetworks/lb-frontend-and-backend-subnet \
    --tags=allow-ssh,load-balanced-backend \
    --image-family=debian-12 \
    --image-project=debian-cloud \
    --metadata=startup-script='#! /bin/bash
    apt-get update
    apt-get install apache2 -y
    a2ensite default-ssl
    a2enmod ssl
    vm_hostname="$(curl -H "Metadata-Flavor:Google" \
    http://metadata.google.internal/computeMetadata/v1/instance/name)"
    echo "Page served from: $vm_hostname" | \
    tee /var/www/html/index.html
    systemctl restart apache2' \
    --project=SERVICE_PROJECT_B_ID

    Reemplaza lo siguiente:

    • BACKEND_IG_TEMPLATE: es el nombre de la plantilla de grupo de instancias.
    • SERVICE_PROJECT_B_ID: es el ID del proyecto del servicio B, en el que se crean los backends del balanceador de cargas y el servicio de backend.
    • HOST_PROJECT_ID: es el ID del proyecto host de la VPC compartida.

  2. Crea un grupo de instancias administrado en la zona con el comando gcloud compute instance-groups managed create.

    gcloud compute instance-groups managed create BACKEND_MIG \
    --zone=us-west1-a \
    --size=2 \
    --template=BACKEND_IG_TEMPLATE \
    --project=SERVICE_PROJECT_B_ID

    Reemplaza lo siguiente:

    • BACKEND_MIG: es el nombre del grupo de instancias de backend.

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

    gcloud compute health-checks create http HTTP_HEALTH_CHECK_NAME \
  --region=us-west1 \
  --use-serving-port \
  --project=SERVICE_PROJECT_B_ID

    Reemplaza lo siguiente:

    • HTTP_HEALTH_CHECK_NAME: es el nombre de la verificación de estado de HTTP.

  4. Define el servicio de backend con el comando gcloud compute backend-services create.

    gcloud compute backend-services create BACKEND_SERVICE_NAME \
  --load-balancing-scheme=INTERNAL_MANAGED \
  --protocol=HTTP \
  --health-checks=HTTP_HEALTH_CHECK_NAME \
  --health-checks-region=us-west1 \
  --region=us-west1 \
  --project=SERVICE_PROJECT_B_ID

    Reemplaza lo siguiente:

    • BACKEND_SERVICE_NAME: es el nombre del servicio de backend creado en el proyecto de servicio B.

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

    gcloud compute backend-services add-backend BACKEND_SERVICE_NAME \
  --balancing-mode=UTILIZATION \
  --instance-group=BACKEND_MIG \
  --instance-group-zone=us-west1-a \
  --region=us-west1 \
  --project=SERVICE_PROJECT_B_ID

Terraform

  1. Crear una plantilla de instancias

    # Instance template
resource "google_compute_instance_template" "default" {
  name     = "l7-ilb-backend-template"
  provider = google-beta
  project  = "my-service-project-b-id"
  region   = "us-west1"
  # For machine type, using small. For more options check https://cloud.google.com/compute/docs/machine-types
  machine_type = "e2-small"
  tags         = ["allow-ssh", "load-balanced-backend"]
  network_interface {
    network    = google_compute_network.lb_network.id
    subnetwork = google_compute_subnetwork.lb_frontend_and_backend_subnet.id
    access_config {
      # add external ip to fetch packages like apache2, ssl
    }
  }
  disk {
    source_image = "debian-cloud/debian-12"
    auto_delete  = true
    boot         = true
  }

  # install apache2 and serve a simple web page
  metadata = {
    startup-script = <<EOF
    #! /bin/bash
    sudo apt-get update
    sudo apt-get install apache2 -y
    sudo a2ensite default-ssl
    sudo a2enmod ssl
    vm_hostname="$(curl -H "Metadata-Flavor:Google" \
    http://metadata.google.internal/computeMetadata/v1/instance/name)"
    sudo echo "Page served from: $vm_hostname" | \
    tee /var/www/html/index.html
    sudo systemctl restart apache2
    EOF
  }
}

  2. Crea un grupo de instancias administrado.

    Para HTTP:

    # MIG
resource "google_compute_instance_group_manager" "default" {
  name               = "l7-ilb-backend-example"
  provider           = google-beta
  project            = "my-service-project-b-id"
  zone               = "us-west1-a"
  base_instance_name = "vm"
  target_size        = 2
  version {
    instance_template = google_compute_instance_template.default.id
    name              = "primary"
  }
  named_port {
    name = "http"
    port = 80
  }
}

    Para HTTPS

    # MIG
resource "google_compute_instance_group_manager" "default" {
  name               = "l7-ilb-backend-example"
  provider           = google-beta
  project            = "my-service-project-b-id"
  zone               = "us-west1-a"
  base_instance_name = "vm"
  target_size        = 2
  version {
    instance_template = google_compute_instance_template.default.id
    name              = "primary"
  }
  named_port {
    name = "https"
    port = 443
  }
}

  3. Crea una verificación de estado para el backend.

    Para HTTP:

    # health check
resource "google_compute_health_check" "default" {
  name               = "l7-ilb-basic-check"
  provider           = google-beta
  project            = "my-service-project-b-id"
  timeout_sec        = 1
  check_interval_sec = 1
  http_health_check {
    port = "80"
  }
}

    Para HTTPS

    # health check
resource "google_compute_health_check" "default" {
  name               = "l7-ilb-basic-check"
  provider           = google-beta
  project            = "my-service-project-b-id"
  timeout_sec        = 1
  check_interval_sec = 1
  https_health_check {
    port = "443"
  }
}

  4. Crea un servicio de backend regional.

    # backend service
resource "google_compute_region_backend_service" "default" {
  name                  = "l7-ilb-backend-service"
  provider              = google-beta
  project               = "my-service-project-b-id"
  region                = "us-west1"
  protocol              = "HTTP"
  load_balancing_scheme = "INTERNAL_MANAGED"
  timeout_sec           = 10
  health_checks         = [google_compute_health_check.default.id]
  backend {
    group           = google_compute_instance_group_manager.default.instance_group
    balancing_mode  = "UTILIZATION"
    capacity_scaler = 1.0
  }
}

Crea el frontend del balanceador de cargas y el mapa de URL en el proyecto de servicio A

Todos los pasos de esta sección deben realizarse en el proyecto de servicio A.

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 aplicaciones (HTTP/HTTPS) y haz clic en Siguiente.
  4. En Orientado al público o interno, selecciona Interno y haz clic en Siguiente.
  5. En Implementación entre regiones o de una sola región, selecciona Ideal para cargas de trabajo regionales y haz clic en Siguiente.
  6. Haz clic en Configurar.

Configuración básica

  1. Ingresa un Nombre para el balanceador de cargas.
  2. En Región, selecciona us-west1.

  3. En Red, selecciona lb-network (de Proyecto: HOST_PROJECT_NAME).

    Si ves una advertencia sobre la subred de solo proxy que se requiere en la red de VPC compartida, confirma que el administrador del proyecto host haya creado proxy-only-subnet en la región us-west1 en la red de VPC compartida lb-network. La creación del balanceador de cargas tendrá éxito incluso si no tienes permiso para ver la subred de solo proxy en esta página.

  4. Mantén la ventana abierta para continuar.

Configure el backend

  1. Haga clic en Configuración de backend.
  2. Haz clic en Servicios de backend entre proyectos.
  3. En ID del proyecto, ingresa el ID del proyecto para el proyecto de servicio B.
  4. En la lista Seleccionar servicios de backend, selecciona los servicios de backend del proyecto de servicio B que deseas usar. Para este ejemplo, debes ingresar cross-ref-backend-service.
  5. Haz clic en Aceptar.

Configura las reglas de enrutamiento

  • Haga clic en Reglas de enrutamiento. Asegúrate de que cross-ref-backend-service sea el único servicio de backend para cualquier host y ruta de acceso no coincidentes.

Para obtener información sobre la administración del tráfico, consulta Configura la administración del tráfico.

Configura el frontend

Para que el servicio entre proyectos funcione, el frontend debe usar la misma red (lb-network) del proyecto host de VPC compartida que se usó para crear el servicio de backend.

Para HTTP:

  1. Haga clic en Configuración de frontend.
  2. Ingresa un nombre para la regla de reenvío: cross-ref-http-forwarding-rule.
  3. Configura el Protocolo en HTTP.
  4. Establece Subred en lb-frontend-and-backend-subnet. No selecciones la subred de solo proxy para el frontend, incluso si es una opción en la lista.
  5. Configura el Puerto en 80.
  6. Haz clic en el menú Dirección IP y, luego, en Crear dirección IP.
  7. En el panel Reservar una dirección IP interna estática, proporciona los siguientes detalles:
    1. En Nombre, ingresa cross-ref-ip-address.
    2. En Dirección IP estática, haz clic en Let me choose. En Dirección IP personalizada, ingresa 10.1.2.98.
    3. (Opcional) Si deseas compartir esta dirección IP con diferentes frontends, configura Propósito como Compartido.
  8. Haz clic en Listo.

Para HTTPS:

Si usas HTTPS entre el cliente y el balanceador de cargas, necesitas uno o más recursos de certificado SSL para configurar el proxy. Para obtener información sobre cómo crear recursos de certificados SSL, consulta Certificados SSL. Por el momento, los certificados administrados por Google no son compatibles con los balanceadores de cargas de aplicaciones internos.

  1. Haz clic en Configuración de frontend.
  2. Ingresa un nombre para la regla de reenvío: cross-ref-https-forwarding-rule.
  3. En el campo Protocolo, selecciona HTTPS (includes HTTP/2).
  4. Establece Subred en lb-frontend-and-backend-subnet. No selecciones la subred de solo proxy para el frontend, incluso si es una opción en la lista.
  5. Asegúrate de que el Puerto esté establecido en 443 para permitir el tráfico HTTPS.
  6. Haz clic en el menú Dirección IP y, luego, en Crear dirección IP.
  7. En el panel Reservar una dirección IP interna estática, proporciona los siguientes detalles:
    1. En Nombre, ingresa cross-ref-ip-address.
    2. En Dirección IP estática, haz clic en Let me choose. En Dirección IP personalizada, ingresa 10.1.2.98.
    3. (Opcional) Si deseas compartir esta dirección IP con diferentes frontends, configura Propósito como Compartido.
  8. Haz clic en la lista Certificado.
    1. Si ya tienes un recurso de certificado SSL autoadministrado que deseas usar como certificado SSL principal, selecciónalo en el menú.
    2. De lo contrario, selecciona Crear un nuevo certificado.
      1. Ingresa un Nombre para el certificado SSL.
      2. En los campos correspondientes, sube los archivos con formato PEM:
        • Certificado de clave pública
        • Cadena de certificado
        • Clave privada
      3. Haz clic en Crear.
  9. Para agregar otros recursos de certificado, además del recurso de certificado SSL principal, haz lo siguiente:
    1. Haz clic en Agregar certificado.
    2. Selecciona un certificado de la lista Certificados o haz clic en Crear un certificado nuevo y sigue las instrucciones anteriores.
  10. Haz clic en Listo.

Revise y finalice la configuración

  • Haz clic en Crear.

Prueba el balanceador de cargas

Después de crear el balanceador de cargas, pruébalo con los pasos descritos en Prueba el balanceador de cargas.

gcloud

  1. Opcional: Antes de crear un balanceador de cargas con servicios de backend de referencia cruzada, descubre si se puede hacer referencia a los servicios de backend a los que deseas hacer referencia mediante un mapa de URL:

    gcloud compute backend-services list-usable \
    --region=us-west1 \
    --project=SERVICE_PROJECT_B_ID

  2. Crea el mapa de URL y configura el servicio predeterminado como el servicio de backend creado en el proyecto de servicio B.

    gcloud compute url-maps create URL_MAP_NAME \
    --default-service=projects/SERVICE_PROJECT_B_ID/regions/us-west1/backendServices/BACKEND_SERVICE_NAME \
    --region=us-west1 \
    --project=SERVICE_PROJECT_A_ID

    Reemplaza lo siguiente:

    • URL_MAP_NAME: es el nombre del mapa de URL.
    • BACKEND_SERVICE_NAME: es el nombre del servicio de backend creado en el proyecto de servicio B.
    • SERVICE_PROJECT_B_ID: es el ID del proyecto del servicio B, en el que se crean los backends del balanceador de cargas y el servicio de backend.
    • SERVICE_PROJECT_A_ID: es el ID del proyecto del servicio A, en el que se crea el frontend del balanceador de cargas.

    La creación del mapa de URL falla si no tienes el permiso compute.backendServices.use para el servicio de backend en el proyecto de servicio B.

  3. Crea el proxy de destino.

    Para HTTP:

    gcloud compute target-http-proxies create HTTP_TARGET_PROXY_NAME \
  --url-map=URL_MAP_NAME \
  --url-map-region=us-west1 \
  --region=us-west1 \
  --project=SERVICE_PROJECT_A_ID

    Reemplaza lo siguiente:

    • HTTP_TARGET_PROXY_NAME: es el nombre del proxy HTTP de destino.

    Para HTTPS:

    Crea un certificado SSL regional con el comando gcloud compute ssl-certificates create.

    gcloud compute ssl-certificates create SSL_CERTIFICATE_NAME \
  --certificate=PATH_TO_CERTIFICATE \
  --private-key=PATH_TO_PRIVATE_KEY \
  --region=us-west1 \
  --project=SERVICE_PROJECT_A_ID

    Reemplaza lo siguiente:

    • SSL_CERTIFICATE_NAME: el nombre del recurso de certificado SSL.
    • PATH_TO_CERTIFICATE: es la ruta al archivo del certificado SSL local en formato PEM.
    • PATH_TO_PRIVATE_KEY: es la ruta a la clave privada del certificado SSL local en formato PEM.

    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 HTTPS_TARGET_PROXY_NAME \
  --url-map=URL_MAP_NAME \
  --region=us-west1 \
  --ssl-certificates=SSL_CERTIFICATE_NAME \
  --project=SERVICE_PROJECT_A_ID

    Reemplaza lo siguiente:

    • HTTPS_TARGET_PROXY_NAME: un nombre para el proxy HTTPS de destino.

  4. Crea la regla de reenvío. Para que el servicio entre proyectos haga referencia al trabajo, la regla de reenvío debe usar la misma red (lb-network) del proyecto host de VPC compartida que se usó para crear el servicio de backend.

    Para HTTP:

    gcloud compute forwarding-rules create HTTP_FORWARDING_RULE_NAME \
  --load-balancing-scheme=INTERNAL_MANAGED \
  --network=projects/HOST_PROJECT_ID/global/networks/lb-network \
  --subnet=projects/HOST_PROJECT_ID/regions/us-west1/subnetworks/lb-frontend-and-backend-subnet \
  --address=IP_ADDRESS_CROSS_REF \
  --ports=80 \
  --region=us-west1 \
  --target-http-proxy=HTTP_TARGET_PROXY_NAME \
  --target-http-proxy-region=us-west1 \
  --project=SERVICE_PROJECT_A_ID

    Reemplaza lo siguiente:

    • HTTP_FORWARDING_RULE_NAME: es el nombre de la regla de reenvío que se usa para controlar el tráfico HTTP.

    Para HTTPS:

    gcloud compute forwarding-rules create HTTPS_FORWARDING_RULE_NAME \
  --load-balancing-scheme=INTERNAL_MANAGED \
  --network=projects/HOST_PROJECT_ID/global/networks/lb-network \
  --subnet=projects/HOST_PROJECT_ID/regions/us-west1/subnetworks/lb-frontend-and-backend-subnet \
  --address=IP_ADDRESS_CROSS_REF \
  --ports=443 \
  --region=us-west1 \
  --target-https-proxy=HTTPS_TARGET_PROXY_NAME \
  --target-https-proxy-region=us-west1 \
  --project=SERVICE_PROJECT_A_ID

    Reemplaza lo siguiente:

    • HTTPS_FORWARDING_RULE_NAME: es el nombre de la regla de reenvío que se usa para controlar el tráfico HTTPS.

  5. Para probar el balanceador de cargas, sigue los pasos descritos en Prueba el balanceador de cargas.

Terraform

  1. Crea el mapa de URL.

    # URL map
resource "google_compute_region_url_map" "default" {
  name            = "l7-ilb-map"
  provider        = google-beta
  project         = "my-service-project-a-id"
  region          = "us-west1"
  default_service = google_compute_region_backend_service.default.id
}

  2. Crea el proxy de destino.

    Para HTTP:

    # HTTP target proxy
resource "google_compute_region_target_http_proxy" "default" {
  name     = "l7-ilb-proxy"
  provider = google-beta
  project  = "my-service-project-a-id"
  region   = "us-west1"
  url_map  = google_compute_region_url_map.default.id
}

    Para HTTPS

    Creación de un certificado SSL regional

    # Use self-signed SSL certificate
resource "google_compute_region_ssl_certificate" "default" {
  name        = "l7-ilb-cert"
  provider    = google-beta
  project     = "my-service-project-a-id"
  region      = "us-west1"
  private_key = file("sample-private.key") # path to PEM-formatted file
  certificate = file("sample-server.cert") # path to PEM-formatted file
}

    Usa el certificado SSL regional para crear un proxy de destino

    # HTTPS target proxy
resource "google_compute_region_target_https_proxy" "default" {
  name             = "l7-ilb-proxy"
  provider         = google-beta
  project          = "my-service-project-a-id"
  region           = "us-west1"
  url_map          = google_compute_region_url_map.default.id
  ssl_certificates = [google_compute_region_ssl_certificate.default.id]
}

  3. Crea la regla de reenvío.

    Para HTTP:

    # Forwarding rule
resource "google_compute_forwarding_rule" "default" {
  name                  = "l7-ilb-forwarding-rule"
  provider              = google-beta
  project               = "my-service-project-a-id"
  region                = "us-west1"
  ip_protocol           = "TCP"
  port_range            = "80"
  load_balancing_scheme = "INTERNAL_MANAGED"
  target                = google_compute_region_target_http_proxy.default.id
  network               = google_compute_network.lb_network.id
  subnetwork            = google_compute_subnetwork.lb_frontend_and_backend_subnet.id
  network_tier          = "PREMIUM"
  depends_on            = [google_compute_subnetwork.lb_frontend_and_backend_subnet]
}

    Para HTTPS

    # Forwarding rule
resource "google_compute_forwarding_rule" "default" {
  name                  = "l7-ilb-forwarding-rule"
  provider              = google-beta
  project               = "my-service-project-a-id"
  region                = "us-west1"
  ip_protocol           = "TCP"
  port_range            = "443"
  load_balancing_scheme = "INTERNAL_MANAGED"
  target                = google_compute_region_target_https_proxy.default.id
  network               = google_compute_network.lb_network.id
  subnetwork            = google_compute_subnetwork.lb_frontend_and_backend_subnet.id
  network_tier          = "PREMIUM"
  depends_on            = [google_compute_subnetwork.lb_frontend_and_backend_subnet]
}

  4. Para probar el balanceador de cargas, sigue los pasos descritos en Prueba el balanceador de cargas.

Otorga permisos al administrador del balanceador de cargas para usar el servicio de backend

Si quieres que los balanceadores de cargas hagan referencia a los servicios de backend en otros proyectos de servicio, el administrador del balanceador de cargas debe tener el permiso compute.backendServices.use. Para otorgar este permiso, puedes usar el rol predefinido de IAM llamado Usuario de servicios del balanceador de cargas de Compute (roles/compute.loadBalancerServiceUser). El administrador del proyecto de servicio debe otorgar este rol, que puede aplicarse a nivel del proyecto o a nivel del servicio de backend individual.

Este paso no es necesario si ya otorgaste los permisos necesarios a nivel de servicio de backend mientras creas el servicio de backend. Puedes omitir esta sección o continuar leyendo para obtener información sobre cómo otorgar acceso a todos los servicios de backend en este proyecto, de modo que no tengas que otorgar acceso cada vez que crees un servicio de backend nuevo.

En este ejemplo, un administrador del proyecto de servicio B debe ejecutar uno de los siguientes comandos para otorgar el permiso compute.backendServices.use a un administrador del balanceador de cargas del proyecto de servicio A. Esto se puede hacer a nivel de proyecto (para todos los servicios de backend del proyecto) o por servicio de backend.

Console

Permisos a nivel del proyecto

Sigue estos pasos para otorgar permisos a todos los servicios de backend del proyecto.

Necesitas los permisos compute.regionBackendServices.setIamPolicy y resourcemanager.projects.setIamPolicy para completar este paso.

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

    Ir a IAM

  2. Elige tu proyecto.

  3. Haz clic en Otorgar acceso.

  4. En el campo Principales nuevas, ingresa la dirección de correo electrónico del principal o cualquier otro identificador.

  5. En la lista Seleccionar un rol, selecciona Usuario de servicios de balanceador de cargas de Compute.

  6. Opcional: Agrega una condición a la función.

  7. Haz clic en Guardar.

Permisos a nivel de recurso para servicios de backend individuales

Usa los siguientes pasos para otorgar permisos a servicios de backend individuales en tu proyecto.

Necesitas el permiso compute.regionBackendServices.setIamPolicy para completar este paso.

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

    Ir a Backends

  2. En la lista de backends, selecciona el servicio de backend al que deseas otorgar acceso y haz clic en Permisos.

  3. Haz clic en Agregar principal.

  4. En el campo Principales nuevas, ingresa la dirección de correo electrónico del principal o cualquier otro identificador.

  5. En la lista Seleccionar un rol, selecciona Usuario de servicios de balanceador de cargas de Compute.

  6. Haz clic en Guardar.

gcloud

Permisos a nivel del proyecto

Sigue estos pasos para otorgar permisos a todos los servicios de backend del proyecto.

Necesitas los permisos compute.regionBackendServices.setIamPolicy y resourcemanager.projects.setIamPolicy para completar este paso. 

gcloud projects add-iam-policy-binding SERVICE_PROJECT_B_ID \
    --member="user:LOAD_BALANCER_ADMIN" \
    --role="roles/compute.loadBalancerServiceUser"

Permisos a nivel de recurso para servicios de backend individuales

A nivel de servicio de backend, los Administradores de proyectos de servicio pueden usar cualquiera de los siguientes comandos para otorgar el rol Usuario de servicios del balanceador de cargas de Compute (roles/compute.loadBalancerServiceUser).

Necesitas el permiso compute.regionBackendServices.setIamPolicy para completar este paso. 

gcloud projects add-iam-policy-binding SERVICE_PROJECT_B_ID \
    --member="user:LOAD_BALANCER_ADMIN" \
    --role="roles/compute.loadBalancerServiceUser" \
    --condition='expression=resource.name=="projects/SERVICE_PROJECT_B_ID/regions/us-west1/backend-services/BACKEND_SERVICE_NAME",title=Shared VPC condition'

o

gcloud compute backend-services add-iam-policy-binding BACKEND_SERVICE_NAME \
    --member="user:LOAD_BALANCER_ADMIN" \
    --role="roles/compute.loadBalancerServiceUser" \
    --project=SERVICE_PROJECT_B_ID \
    --region=us-west1

Para usar estos comandos, reemplaza LOAD_BALANCER_ADMIN por la principal del usuario, por ejemplo, test-user@gmail.com.

También puedes configurar los permisos de IAM para que solo se apliquen a un subconjunto de servicios de backend regionales mediante condiciones y la especificación de atributos de condición.

Para ver mapas de URL que hacen referencia a un servicio de backend de VPC compartida en particular, sigue estos pasos:

gcloud

Para ver los recursos que hacen referencia a un servicio de backend de VPC compartida regional, ejecuta el siguiente comando:

gcloud compute backend-services describe BACKEND_SERVICE_NAME \
    --region REGION

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

En el resultado del comando, revisa el campo usedBy, que muestra las recursos que hacen referencia al servicio de backend, como se muestra en el siguiente ejemplo:

id: '123456789'
kind: compute#backendService
loadBalancingScheme: INTERNAL_MANAGED
...
usedBy:
-   reference: https://www.googleapis.com/compute/v1/projects/my-project/region/us-central1/urlMaps/my-url-map

¿Qué sigue?