Configurar un balanceador de carga de aplicaciones interno con VPC compartida

En este documento se muestran dos configuraciones de ejemplo para configurar un balanceador de carga de aplicaciones interno en un entorno de VPC compartida:

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

En ambos ejemplos se requiere la misma configuración inicial para conceder permisos y configurar la VPC compartida antes de poder crear balanceadores de carga.

Estas no son las únicas configuraciones de VPC compartida compatibles con los balanceadores de carga de aplicaciones internos. Para ver otras arquitecturas de VPC compartida válidas, consulta Arquitecturas de VPC compartida.

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

Antes de empezar

  1. Consulta la descripción general de la VPC compartida.
  2. Consulta la información general sobre los balanceadores de carga de aplicación internos, incluida la sección Arquitecturas de VPC compartida.

Los permisos que requiere

Para configurar un balanceador de carga en una red de VPC compartida, un administrador debe llevar a cabo una configuración y un aprovisionamiento iniciales. Tras la configuración inicial, el propietario de un proyecto de servicio puede hacer lo siguiente:

  • Despliega todos los componentes del balanceador de carga y sus backends en un proyecto de servicio.
  • Implementa los componentes de backend del balanceador de carga (servicio de backend y backends) en proyectos de servicio a los que se pueda hacer referencia mediante un mapa de URLs en otro proyecto de servicio o de host.

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

Configurar VPC compartida

Se necesitan los siguientes roles para llevar a cabo las tareas que se indican a continuación:

  1. Realizar tareas administrativas puntuales, como configurar la VPC compartida y habilitar un proyecto host.
  2. Realizar tareas administrativas que deben repetirse cada vez que quieras incorporar un nuevo proyecto de servicio. Esto incluye vincular el proyecto de servicio, aprovisionar y configurar recursos de red, y conceder acceso al administrador del proyecto de servicio.

Estas tareas deben realizarse en el proyecto host de la VPC compartida. Te recomendamos que el administrador de la VPC compartida también sea el propietario del proyecto host de la VPC compartida. De esta forma, se conceden automáticamente los roles Administrador de red y Administrador de seguridad.

Tarea Rol necesario
Configurar la VPC compartida, habilitar el proyecto del host y dar acceso a los administradores del proyecto de servicio Administrador de VPC compartida
Crea subredes en el proyecto host de la VPC compartida y concede acceso a los administradores del proyecto de servicio Administrador de red
Añadir y eliminar reglas de cortafuegos Administrador de seguridad

Una vez que se hayan aprovisionado las subredes, el propietario del proyecto host debe conceder el rol Usuario de red en el proyecto host a cualquier persona (normalmente, administradores, desarrolladores o cuentas de servicio del proyecto de servicio) que necesite usar estos recursos.

Tarea Rol necesario
Usar redes y subredes de VPC que pertenezcan al proyecto host Usuario de red

Este rol se puede asignar a nivel de proyecto o a subredes concretas. Te recomendamos que asignes el rol a subredes concretas. Si se asigna el rol en el proyecto, se concede acceso a todas las subredes actuales y futuras de la red VPC del proyecto host.

Desplegar un balanceador de carga y backends

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

Roles concedidos en el proyecto de servicio
Tarea Rol necesario
Crear componentes de balanceador de carga Administrador de red
Crear instancias Administrador de instancias
Crear y modificar certificados SSL Administrador de seguridad

Requisitos previos

En esta sección, debes seguir estos pasos:

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

No es necesario que sigas los pasos de esta sección cada vez que quieras crear un balanceador de carga. Sin embargo, debes asegurarte de que tienes acceso a los recursos que se describen aquí antes de crear el balanceador de carga.

Configurar la red y las subredes en el proyecto del host

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

En este ejemplo se usan la siguiente red, región y subredes:

  • Red. La red se llama lb-network.

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

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

Configurar la subred para el frontend y los backends del balanceador de carga

No es necesario realizar este paso cada vez que quieras crear un balanceador de carga. Solo tienes que asegurarte de que el proyecto de servicio tenga acceso a una subred de 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.

Consola

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

    Ir a redes de VPC

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

  4. En la sección Subredes:

    1. Elige Personalizado en Modo de creación de subred.

    2. En la sección Nueva subred, introduce la siguiente información:

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

      • Región: us-west1

      • Intervalo 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 de 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
}

Configurar la subred de solo proxy

Todos los balanceadores de carga regionales basados en Envoy de la us-west1 región usan la subred de solo proxy en la red de VPC lb-network. Solo puede haber una subred 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.

Consola

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

    Ir a redes de VPC

  2. Haz clic en el nombre de la red de VPC compartida: lb-network.
  3. Haz clic en Añadir subred.
  4. En Nombre, escribe proxy-only-subnet.
  5. En Región, selecciona us-west1.
  6. En Propósito, selecciona Proxy gestionado regional.
  7. En Intervalo de direcciones IP, introduce 10.129.0.0/23.
  8. Haz clic en Añadir.

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
}

Dar acceso a la subred backend a los administradores del proyecto de servicio

Los administradores del proyecto de servicio necesitan acceso a la subred lb-frontend-and-backend-subnet para poder aprovisionar los back-ends del balanceador de carga.

Un administrador de VPC compartida debe conceder acceso a la subred de backend a los administradores de proyectos de servicio (o a los desarrolladores que implementen recursos y backends que utilicen la subred). Para obtener instrucciones, consulta Administradores de proyectos de servicio para algunas subredes.

Configurar reglas de cortafuegos en el proyecto host

En este ejemplo se usan las siguientes reglas de cortafuegos:
  • fw-allow-health-check. Una regla de entrada, aplicable a las instancias que se van a balancear, que permite todo el tráfico TCP de los sistemas de comprobación del estado de Google Cloud, 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 se debe aplicar.
  • fw-allow-proxies. Una regla de entrada, aplicable a las instancias que se van a balancear, que permite el tráfico TCP en los puertos 80, 443 y 8080 desde los proxies gestionados del balanceador de carga. 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. Una regla de entrada aplicable a las instancias que se van a balancear de carga que permita la conectividad SSH entrante en el puerto TCP 22 desde cualquier dirección. Puedes elegir un intervalo de IPs de origen más restrictivo para esta regla. Por ejemplo, puede especificar solo los intervalos de IP del sistema desde el que inicia sesiones SSH. En este ejemplo se usa la etiqueta de destino allow-ssh para identificar las máquinas virtuales a las que se aplica la regla de cortafuegos.
Sin estas reglas de cortafuegos, la regla denegar predeterminada 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.

Consola

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

    Ir a Políticas de cortafuegos

  2. Haz clic en Crear regla de cortafuegos para crear la regla que permita las comprobaciones del estado: Google Cloud
    • Nombre: fw-allow-health-check
    • Red: lb-network
    • Dirección del tráfico: entrada
    • Acción tras coincidencia: permitir
    • Destinos: etiquetas de destino especificadas
    • Etiquetas de destino: load-balanced-backend
    • Filtro de origen: intervalos de IPv4
    • Intervalos de IPv4 de origen: 130.211.0.0/22 y 35.191.0.0/16
    • Protocolos y puertos:
      • Elige Protocolos y puertos especificados.
      • Marca TCP e introduce 80 como número de puerto.

        • Como práctica recomendada, limita esta regla a los protocolos y puertos que coincidan con los que usa tu comprobación del estado. Si usas tcp:80 para el protocolo y el puerto, Google Cloud puedes usar HTTP en el puerto 80 para comunicarte con tus VMs, pero no puedes usar HTTPS en el puerto 443 para comunicarte con ellas.

  3. Haz clic en Crear.
  4. Haz clic en Crear regla de cortafuegos para crear la regla que permita las comprobaciones del estado: Google Cloud
    • Nombre: fw-allow-proxies
    • Red: lb-network
    • Dirección del tráfico: entrada
    • Acción tras coincidencia: permitir
    • Destinos: etiquetas de destino especificadas
    • Etiquetas de destino: load-balanced-backend
    • Filtro de origen: intervalos de IPv4
    • Intervalos de IPv4 de origen: 10.129.0.0/23
    • Protocolos y puertos:
      • Elige Protocolos y puertos especificados.
      • Marca TCP e introduce 80, 443, 8080 en los números de puerto.
  5. Haz clic en Crear.
  6. Haz clic en Crear regla de cortafuegos para crear la regla que permita las comprobaciones del estado: Google Cloud
    • Nombre: fw-allow-ssh
    • Red: lb-network
    • Dirección del tráfico: entrada
    • Acción tras coincidencia: permitir
    • Destinos: etiquetas de destino especificadas
    • Etiquetas de destino: allow-ssh
    • Filtro de origen: intervalos de IPv4
    • Intervalos de IPv4 de origen: 0.0.0.0/0
    • Protocolos y puertos:
      • Elige Protocolos y puertos especificados.
      • Marca TCP e introduce 22 como número de puerto.
  7. Haz clic en Crear.

gcloud

  1. Crea la regla de cortafuegos fw-allow-health-check para permitir las comprobaciones del estadoGoogle Cloud . En este ejemplo, se permite todo el tráfico TCP de los verificadores de comprobación del estado. Sin embargo, puedes configurar un conjunto de puertos más reducido 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 cortafuegos 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 cortafuegos fw-allow-ssh para permitir la conectividad SSH a las VMs con la etiqueta de red allow-ssh. Si omite source-ranges, Google Cloud interpreta que la regla se aplica a cualquier fuente.

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

Terraform

  1. Crea una regla de cortafuegos para permitir las comprobaciones del estado. 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 cortafuegos 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 cortafuegos 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"]
}

Configurar la VPC compartida en el proyecto host

En este paso, se habilita un proyecto host de VPC compartida, se comparten subredes del proyecto host y se vinculan proyectos de servicio al proyecto host para que los proyectos de servicio puedan usar la red de VPC compartida. Para configurar la VPC compartida en el proyecto host, consulta las siguientes páginas:

En el resto de estas instrucciones se da por hecho que ya has configurado la VPC compartida. Esto incluye configurar políticas de gestión de identidades y accesos para tu organización y designar los proyectos host y de servicio.

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

Una vez que hayas completado los pasos definidos en esta sección de requisitos previos, puedes llevar a cabo una de las siguientes configuraciones:

Configurar un balanceador de carga en el proyecto de servicio

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

Los recursos de red del balanceador de carga de aplicaciones interno, como la subred de solo proxy y la subred de las instancias de backend, se crean en el proyecto host. Las reglas de cortafuegos de las instancias de backend también se crean en el proyecto host.

Figura 1. Balanceador de carga de aplicación interno en una VPC compartida
Imagen 1. Balanceador de carga de aplicación interno en una VPC compartida

En esta sección se explica cómo configurar el balanceador de carga y los backends. El administrador del proyecto de servicio (o un desarrollador que trabaje en el proyecto de servicio) debe seguir estos pasos, que no requieren la participación del administrador del proyecto host. Los pasos de esta sección son muy similares a los pasos estándar para configurar un balanceador de carga de aplicaciones interno.

En el ejemplo de esta página se asigna explícitamente una dirección IP interna reservada a la regla de reenvío del balanceador de carga de aplicaciones interno, en lugar de permitir que se asigne una dirección IP interna efímera. Como práctica recomendada, te sugerimos que reserves direcciones IP para las reglas de reenvío.

Crea el backend del grupo de instancias gestionado

.

En esta sección se muestra cómo crear una plantilla y un grupo de instancias gestionado. El grupo de instancias gestionado proporciona instancias de VM que ejecutan los servidores backend de un balanceador de carga de aplicaciones interno de ejemplo. El tráfico de los clientes se balancea entre estos servidores de backend. Para hacer demostraciones, los back-ends sirven sus propios nombres de host.

Consola

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

    Ir a Plantillas de instancia

    1. Haz clic en Crear plantilla de instancia.
    2. En Nombre, escribe l7-ilb-backend-template.
    3. Asegúrate de que el disco de arranque esté configurado con 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, a continuación, en Redes.
    5. Introduce las siguientes etiquetas de red: allow-ssh,load-balanced-backend.
    6. En la sección Interfaces de red, selecciona Redes compartidas conmigo (del proyecto del host: HOST_PROJECT_ID).
    7. Selecciona la subred lb-frontend-and-backend-subnet de la red lb-network.
    8. Haz clic en Gestión. En Management (Gestión), inserta la siguiente secuencia de comandos en el campo Startup script (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 gestionado. En la Google Cloud consola, ve a la página Grupos de instancias.

    Ir a Grupos de instancias

    1. Haz clic en Crear grupo de instancias.
    2. Elige Nuevo grupo de instancias gestionado (sin reconocimiento del estado). Para obtener más información, consulta Grupos de instancias gestionados con o sin reconocimiento del estado.
    3. En Nombre, escribe l7-ilb-backend-example.
    4. En Ubicación, selecciona Una sola zona.
    5. En Región, selecciona us-west1.
    6. En Zona, selecciona us-west1-a.
    7. En Plantilla de instancia, selecciona l7-ilb-backend-template.

    8. Especifica el número de instancias que quieres crear en el grupo.

      En este ejemplo, especifica las siguientes opciones para Escalado automático:

      • En Modo de autoescalado, selecciona Off:do not autoscale.
      • En Número máximo de instancias, introduce 2.

      Opcionalmente, en la sección Auto escalado de la interfaz de usuario, puede configurar el grupo de instancias para que añada o elimine instancias automáticamente en función del uso de la CPU de las instancias.

    9. Haz clic en Crear.

gcloud

En las gcloud instrucciones de esta guía se presupone que usas Cloud Shell u otro entorno con bash instalado.

  1. Crea una plantilla de instancia de VM con un servidor HTTP mediante 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 gestionado 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 gestionado.

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

Configurar el balanceador de carga

En esta sección se explica cómo crear los recursos del balanceador de carga de aplicaciones interno:

  • Comprobación del estado de HTTP
  • Servicio de backend con un grupo de instancias gestionado como backend
  • Un mapa de URLs
  • Certificado SSL (solo es obligatorio para HTTPS)
  • Proxy de destino
  • Regla de reenvío

Disponibilidad de proxy

En función del número de proyectos de servicio que utilicen la misma red de VPC compartida, es posible que alcances las cuotas o los límites más rápido que en el modelo de implementación de red en el que cada proyecto aloja su propia red. Google Cloud

Por ejemplo, a veces las Google Cloud regiones no tienen suficiente capacidad de proxy para un nuevo balanceador de carga de aplicación interno. Si esto ocurre, la Google Cloud consola proporciona un mensaje de advertencia de disponibilidad de proxy cuando creas tu balanceador de carga. Para solucionar este problema, puedes hacer lo siguiente:

  • Espera a que se resuelva el problema de capacidad.

  • Ponte en contacto con tu Google Cloud equipo de Ventas para aumentar estos límites.

Consola

Cambiar el contexto al proyecto de servicio

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

    Ir al panel de control

  2. En la parte superior de la página, haz clic en la lista Seleccionar de. En la ventana Seleccionar de que aparece, selecciona el proyecto de servicio en el que quieres crear el balanceador de carga.

Selecciona el tipo de balanceador de carga

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

    Ir a Balanceo de carga

  2. Haga clic en Crear balanceador de carga.
  3. En Tipo de balanceador de carga, selecciona Balanceador de carga de aplicación (HTTP/HTTPS) y haz clic en Siguiente.
  4. En Público o interno, selecciona Interno y haz clic en Siguiente.
  5. En Implementación en una sola región o en varias regiones, selecciona La mejor opción para cargas de trabajo regionales y haz clic en Siguiente.
  6. Haz clic en Configurar.

Configuración básica

  1. En Name (Nombre) del balanceador de carga, introduce l7-ilb-shared-vpc.
  2. En Región, seleccione us-west1.

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

    Si ves la advertencia La subred de solo proxy es obligatoria en la red VPC compartida, confirma que el administrador del proyecto host ha creado la proxy-only-subnet en la región us-west1 de la red VPC compartida lb-network. La creación del balanceador de carga se realiza correctamente aunque no tengas permiso para ver la subred de solo proxy en esta página.

  4. Mantén la ventana abierta para continuar.

Configurar el backend

  1. Haz clic en Configuración de backend.
  2. En el menú Crear o seleccionar servicios de backend, selecciona Crear un servicio de backend.
  3. Asigna el valor l7-ilb-backend-service al Nombre del servicio de backend.
  4. En Tipo de backend, selecciona Grupos de instancias.
  5. En la sección Nuevo backend, haz lo siguiente:
    1. Asigna el valor l7-ilb-backend-example a Grupo de instancias.
    2. Define Números de puerto en 80.
    3. En Modo de balanceo, seleccione Utilización.
    4. Haz clic en Listo.
  6. En la sección Comprobación del estado, elige Crear comprobación del estado con los siguientes parámetros:
    1. Nombre: l7-ilb-basic-check
    2. Protocolo: HTTP
    3. Puerto: 80
  7. Haz clic en Guardar y continuar.
  8. Haz clic en Crear.

Configurar las reglas de enrutamiento

  • Haz clic en Reglas de enrutamiento. Asegúrate de que l7-ilb-backend-service sea el único servicio de backend para cualquier host o ruta sin coincidencia.

Para obtener información sobre la gestión del tráfico, consulta Configurar la gestión del tráfico.

Configurar el frontend

En HTTP:

  1. Haz clic en Configuración de frontend.
  2. Asigna el valor l7-ilb-forwarding-rule a Nombre.
  3. Define Protocol (Protocolo) como HTTP.
  4. Asigna el valor lb-frontend-and-backend-subnet a Subred. No selecciones la subred solo proxy para el frontend, aunque sea una opción de la lista.
  5. Asigna el valor 80 a Port.
  6. Haz clic en el menú Dirección IP y, a continuación, en Crear dirección IP.
  7. En el panel Reservar una dirección IP interna estática, proporciona los siguientes detalles:
    1. En Nombre, escribe ip-address-shared-vpc.
    2. En Dirección IP estática, haz clic en Quiero elegir. En Dirección IP personalizada, introduce 10.1.2.99.
    3. (Opcional) Si quieres compartir esta dirección IP con diferentes frontends, define Propósito como Compartido.
  8. Haz clic en Listo.

Para HTTPS:

Si usas HTTPS entre el cliente y el balanceador de carga, necesitas uno o varios recursos de certificado SSL para configurar el proxy. Para obtener información sobre cómo crear recursos de certificados SSL, consulta Certificados SSL. Actualmente, los certificados gestionados por Google no se admiten en los balanceadores de carga de aplicaciones internos.

  1. Haz clic en Configuración de frontend.
  2. En el campo Name (Nombre), introduce l7-ilb-forwarding-rule.
  3. En el campo Protocol (Protocolo), selecciona HTTPS (includes HTTP/2).
  4. Asigna el valor lb-frontend-and-backend-subnet a Subred. No selecciones la subred solo proxy para el frontend, aunque sea una opción de la lista.
  5. Asegúrate de que el Puerto esté configurado como 443 para permitir el tráfico HTTPS.
  6. Haz clic en el menú Dirección IP y, a continuación, en Crear dirección IP.
  7. En el panel Reservar una dirección IP interna estática, proporciona los siguientes detalles:
    1. En Nombre, escribe ip-address-shared-vpc.
    2. En Dirección IP estática, haz clic en Quiero elegir. En Dirección IP personalizada, introduce 10.1.2.99.
    3. (Opcional) Si quieres compartir esta dirección IP con diferentes frontends, define Propósito como Compartido.
  8. Haz clic en la lista Certificado.
    1. Si ya tienes un recurso de certificado SSL autogestionado que quieres usar como certificado SSL principal, selecciónalo en el menú.
    2. De lo contrario, selecciona Crear un certificado.
      1. Escribe un nombre de l7-ilb-cert.
      2. En los campos correspondientes, sube los archivos con formato PEM:
        • Certificado de clave pública
        • Cadena de certificados
        • Clave privada
      3. Haz clic en Crear.
  9. Para añadir recursos de certificado además del recurso de certificado SSL principal, sigue estos pasos:
    1. Haz clic en Añadir certificado.
    2. Selecciona un certificado de la lista Certificados o haz clic en Crear un certificado y sigue las instrucciones anteriores.
  10. Haz clic en Listo.

Revisar y finalizar la configuración

  • Haz clic en Crear.

gcloud

  1. Define la comprobación del 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. Añade 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 URLs 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.

    En HTTP:

    En el caso de un balanceador de carga 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. Actualmente, los certificados gestionados por Google no se admiten en los balanceadores de carga de aplicaciones internos.

    Asigna las rutas de los 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.

    En el caso de las redes personalizadas, debes hacer referencia a la subred en la regla de reenvío.

    En la dirección IP de la regla de reenvío, usa lb-frontend-and-backend-subnet. Si intentas usar la subred de solo proxy, se producirá un error al crear la regla de reenvío.

    En 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 comprobación del estado de HTTP.

    En 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 URLs.

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

    En 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. Actualmente, los certificados gestionados por Google no se admiten en los balanceadores de carga 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
}

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

    En el caso de las redes personalizadas, debes hacer referencia a la subred en la regla de reenvío.

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

Probar el balanceador de carga

Para probar el balanceador de carga, primero crea una VM cliente de muestra. A continuación, establece una sesión SSH con la VM y envía tráfico desde esta VM al balanceador de carga.

Crear una instancia de VM de prueba

Los clientes pueden estar ubicados en el proyecto del host o en cualquier proyecto de servicio conectado. En este ejemplo, comprobarás que el balanceador de carga funciona desplegando una VM 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 carga.

Consola

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

    Ir a instancias de VM

  2. Haz clic en Crear instancia.

  3. Asigna el valor client-vm a Nombre.

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

  5. Haz clic en Opciones avanzadas y, a continuación, en Redes.

  6. Introduce las siguientes etiquetas de red: allow-ssh,load-balanced-backend.

  7. En la sección Interfaces de red, selecciona Redes compartidas conmigo (del proyecto del 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"]
    ]
  }
}

Enviar tráfico al balanceador de carga

Usa SSH para conectarte a la instancia que acabas de crear y comprueba que se puede acceder a los servicios HTTP(S) de los backends a través de la dirección IP de la regla de reenvío del balanceador de carga de aplicaciones interno y que el tráfico se balancea entre las instancias de backend.

  1. Conéctate a la instancia de cliente con SSH.

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

  2. Verifica que la dirección IP esté sirviendo su nombre de host. Sustituye LB_IP_ADDRESS por la dirección IP del balanceador de carga.

    curl LB_IP_ADDRESS

    Para las pruebas de HTTPS, sustituye curl por lo siguiente:

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

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

Configurar un balanceador de carga 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 carga y sus backends se crean en el proyecto de servicio.

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

Puede usar los pasos de esta sección como referencia para configurar cualquiera de las combinaciones admitidas que se indican a continuación:

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

Se pueden usar referencias de servicios entre proyectos con grupos de instancias, NEGs sin servidor o cualquier otro tipo de backend admitido. Si usas NEGs sin servidor, debes crear una VM en la red de VPC en la que quieras crear el frontend del balanceador de carga. Para ver un ejemplo, consulta Crear una instancia de VM en una subred específica en Configurar un balanceador de carga de aplicaciones interno con Cloud Run.

Requisitos de configuración

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

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

Figura 2. Componentes frontend y backend del balanceador de carga en diferentes proyectos de servicio
Imagen 2. Componentes frontend y backend del balanceador de carga en diferentes proyectos de servicio

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

Consola

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

    Ir a Plantillas de instancia

    1. Haz clic en Crear plantilla de instancia.
    2. Introduce un nombre para la plantilla de instancia: cross-ref-backend-template.
    3. Asegúrate de que el disco de arranque esté configurado con 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, a continuación, en Redes.
    5. Introduce las siguientes etiquetas de red: allow-ssh,load-balanced-backend.
    6. En la sección Interfaces de red, selecciona Redes compartidas conmigo (del proyecto del host: HOST_PROJECT_ID).
    7. Selecciona la subred lb-frontend-and-backend-subnet de la red lb-network.
    8. Haz clic en Gestión. En Management (Gestión), inserta la siguiente secuencia de comandos en el campo Startup script (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 gestionado. En la Google Cloud consola, ve a la página Grupos de instancias.

    Ir a Grupos de instancias

    1. Haz clic en Crear grupo de instancias.
    2. Elige Nuevo grupo de instancias gestionado (sin reconocimiento del estado). Para obtener más información, consulta Grupos de instancias gestionados con o sin reconocimiento del estado.
    3. Introduzca un nombre para el grupo de instancias: cross-ref-ig-backend.
    4. En Ubicación, selecciona Una sola zona.
    5. En Región, selecciona us-west1.
    6. En Zona, selecciona us-west1-a.
    7. En Plantilla de instancia, selecciona cross-ref-backend-template.

    8. Especifica el número de instancias que quieres crear en el grupo.

      En este ejemplo, especifica las siguientes opciones para Escalado automático:

      • En Modo de autoescalado, selecciona Off:do not autoscale.
      • En Número máximo de instancias, introduce 2.

      Opcionalmente, en la sección Auto escalado de la interfaz de usuario, puede configurar el grupo de instancias para que añada o elimine instancias automáticamente en función del uso de la CPU de las instancias.

    9. Haz clic en Crear.

  3. Crea un servicio backend regional. Como parte de este paso, también crearemos la comprobación del estado y añadiremos back-ends al servicio de back-end. En la Google Cloud consola, ve a la página Backends.

    Ir a Backends

    1. Haz clic en Crear servicio backend regional.
    2. Introduce un nombre para el servicio de backend: cross-ref-backend-service.
    3. En Region (Región), selecciona us-west1.
    4. En Tipo de balanceador de carga, selecciona Balanceador de carga de aplicación interno regional (INTERNAL_MANAGED).
    5. En Tipo de backend, seleccione Grupos de instancias.
    6. En la sección Backends, defina Network como lb-network.
    7. Haz clic en Añadir backend y define los siguientes campos:
      1. Asigna el valor cross-ref-ig-backend al campo Grupo de instancias.
      2. Introduce los números de puerto: 80.
      3. En Modo de balanceo, selecciona Utilización.
      4. Haz clic en Listo.
    8. En la sección Comprobación del estado, elige Crear comprobación del estado con los siguientes parámetros:
      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 Añadir permisos, introduce las entidades de IAM (normalmente, una dirección de correo electrónico) de los administradores de balanceadores de carga de otros proyectos para que puedan usar este servicio de backend en los balanceadores de carga de sus propios proyectos. Sin este permiso, no puedes usar referencias de servicios entre proyectos.

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

    11. Haz clic en Crear.

gcloud

  1. Crea una plantilla de instancia de VM con un servidor HTTP mediante 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

    Haz los cambios siguientes:

    • BACKEND_IG_TEMPLATE: el nombre de la plantilla del grupo de instancias.
    • SERVICE_PROJECT_B_ID: el ID del proyecto de servicio B, donde se están creando los backends del balanceador de carga y el servicio de backend.
    • HOST_PROJECT_ID: el ID del proyecto host de la VPC compartida.

  2. Crea un grupo de instancias gestionado 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

    Haz los cambios siguientes:

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

  3. Define la comprobación del 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

    Haz los cambios siguientes:

    • HTTP_HEALTH_CHECK_NAME: nombre de la comprobación de estado 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

    Haz los cambios siguientes:

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

  5. Añade 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. Crea una plantilla de instancia.

    # 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 gestionado.

    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 comprobación del estado del 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 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 carga y el mapa de URLs en el proyecto de servicio A

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

Consola

Selecciona el tipo de balanceador de carga

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

    Ir a Balanceo de carga

  2. Haga clic en Crear balanceador de carga.
  3. En Tipo de balanceador de carga, selecciona Balanceador de carga de aplicación (HTTP/HTTPS) y haz clic en Siguiente.
  4. En Público o interno, selecciona Interno y haz clic en Siguiente.
  5. En Implementación en una sola región o en varias regiones, selecciona La mejor opción para cargas de trabajo regionales y haz clic en Siguiente.
  6. Haz clic en Configurar.

Configuración básica

  1. Introduce un nombre para el balanceador de carga.
  2. En Región, seleccione us-west1.

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

    Si ves la advertencia La subred de solo proxy es obligatoria en la red VPC compartida, confirma que el administrador del proyecto host ha creado la proxy-only-subnet en la región us-west1 de la red VPC compartida lb-network. La creación del balanceador de carga se realiza correctamente aunque no tengas permiso para ver la subred de solo proxy en esta página.

  4. Mantén la ventana abierta para continuar.

Configurar el backend

  1. Haz clic en Configuración de backend.
  2. Haz clic en Servicios de backend entre proyectos.
  3. En ID del proyecto, introduce el ID del proyecto del proyecto de servicio B.
  4. En la lista Seleccionar servicios backend, elige los servicios backend del proyecto de servicio B que quieras usar. En este ejemplo, escribe cross-ref-backend-service.
  5. Haz clic en Aceptar.

Configurar las reglas de enrutamiento

  • Haz clic en Reglas de enrutamiento. Asegúrate de que cross-ref-backend-service sea el único servicio de backend para cualquier host y ruta sin coincidencia.

Para obtener información sobre la gestión del tráfico, consulta Configurar la gestión del tráfico.

Configurar el frontend

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

En HTTP:

  1. Haz clic en Configuración de frontend.
  2. Escribe un nombre para la regla de reenvío: cross-ref-http-forwarding-rule.
  3. Define Protocol (Protocolo) como HTTP.
  4. Asigna el valor lb-frontend-and-backend-subnet a Subred. No selecciones la subred solo proxy para el frontend, aunque sea una opción de la lista.
  5. Asigna el valor 80 a Port.
  6. Haz clic en el menú Dirección IP y, a continuación, en Crear dirección IP.
  7. En el panel Reservar una dirección IP interna estática, proporciona los siguientes detalles:
    1. En Nombre, escribe cross-ref-ip-address.
    2. En Dirección IP estática, haz clic en Quiero elegir. En Dirección IP personalizada, introduce 10.1.2.98.
    3. (Opcional) Si quieres compartir esta dirección IP con diferentes frontends, define Propósito como Compartido.
  8. Haz clic en Listo.

Para HTTPS:

Si usas HTTPS entre el cliente y el balanceador de carga, necesitas uno o varios recursos de certificado SSL para configurar el proxy. Para obtener información sobre cómo crear recursos de certificados SSL, consulta Certificados SSL. Actualmente, los certificados gestionados por Google no se admiten en los balanceadores de carga de aplicaciones internos.

  1. Haz clic en Configuración de frontend.
  2. Escribe un nombre para la regla de reenvío: cross-ref-https-forwarding-rule.
  3. En el campo Protocol (Protocolo), selecciona HTTPS (includes HTTP/2).
  4. Asigna el valor lb-frontend-and-backend-subnet a Subred. No selecciones la subred solo proxy para el frontend, aunque sea una opción de la lista.
  5. Asegúrate de que el Puerto esté configurado como 443 para permitir el tráfico HTTPS.
  6. Haz clic en el menú Dirección IP y, a continuación, en Crear dirección IP.
  7. En el panel Reservar una dirección IP interna estática, proporciona los siguientes detalles:
    1. En Nombre, escribe cross-ref-ip-address.
    2. En Dirección IP estática, haz clic en Quiero elegir. En Dirección IP personalizada, introduce 10.1.2.98.
    3. (Opcional) Si quieres compartir esta dirección IP con diferentes frontends, define Propósito como Compartido.
  8. Haz clic en la lista Certificado.
    1. Si ya tienes un recurso de certificado SSL autogestionado que quieras usar como certificado SSL principal, selecciónalo en el menú.
    2. De lo contrario, selecciona Crear un certificado.
      1. Introduce un nombre para el certificado SSL.
      2. En los campos correspondientes, sube los archivos con formato PEM:
        • Certificado de clave pública
        • Cadena de certificados
        • Clave privada
      3. Haz clic en Crear.
  9. Para añadir recursos de certificado además del recurso de certificado SSL principal, sigue estos pasos:
    1. Haz clic en Añadir certificado.
    2. Selecciona un certificado de la lista Certificados o haz clic en Crear un certificado y sigue las instrucciones anteriores.
  10. Haz clic en Listo.

Revisar y finalizar la configuración

  • Haz clic en Crear.

Probar el balanceador de carga

Una vez creado el balanceador de carga, pruébalo siguiendo los pasos descritos en Probar el balanceador de carga.

gcloud

  1. Opcional: Antes de crear un balanceador de carga con servicios de backend de referencia cruzada, averigua si los servicios de backend a los que quieres hacer referencia se pueden referenciar mediante un mapa de URLs:

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

  2. Crea el mapa de URLs y define 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

    Haz los cambios siguientes:

    • URL_MAP_NAME: nombre del mapa de URLs.
    • BACKEND_SERVICE_NAME: el nombre del servicio backend creado en el proyecto de servicio B.
    • SERVICE_PROJECT_B_ID: el ID del proyecto de servicio B, donde se crean los backends del balanceador de carga y el servicio de backend.
    • SERVICE_PROJECT_A_ID: el ID del proyecto de servicio A, donde se está creando el frontend del balanceador de carga.

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

  3. Crea el proxy de destino.

    En 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

    Haz los cambios siguientes:

    • HTTP_TARGET_PROXY_NAME: 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

    Haz los cambios siguientes:

    • SSL_CERTIFICATE_NAME: nombre del recurso de certificado SSL.
    • PATH_TO_CERTIFICATE: ruta al archivo de certificado SSL local en formato PEM.
    • PATH_TO_PRIVATE_KEY: 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

    Haz los cambios siguientes:

    • HTTPS_TARGET_PROXY_NAME: nombre del proxy HTTPS de destino.

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

    En 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

    Haz los cambios siguientes:

    • HTTP_FORWARDING_RULE_NAME: el nombre de la regla de reenvío que se usa para gestionar 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

    Haz los cambios siguientes:

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

  5. Para probar el balanceador de carga, sigue los pasos que se describen en Probar el balanceador de carga.

Terraform

  1. Crea el mapa de URLs.

    # 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

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

    Usar 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 carga, sigue los pasos que se describen en Probar el balanceador de carga.

Concede permisos al administrador del balanceador de carga para usar el servicio de backend

Si quieres que los balanceadores de carga hagan referencia a servicios de backend de otros proyectos de servicio, el administrador del balanceador de carga debe tener el permiso compute.backendServices.use. Para conceder este permiso, puedes usar el rol de gestión de identidades y accesos predefinido llamado Usuario de servicios de balanceador de carga de Compute (roles/compute.loadBalancerServiceUser). El administrador del proyecto de servicio debe conceder este rol, que se puede aplicar a nivel de proyecto o a nivel de servicio de backend individual.

Este paso no es obligatorio si ya has concedido los permisos necesarios a nivel del servicio backend al crear el servicio backend. Puedes saltarte esta sección o seguir leyendo para saber cómo conceder acceso a todos los servicios de backend de este proyecto para que no tengas que conceder acceso cada vez que crees un nuevo servicio de backend.

En este ejemplo, un administrador del proyecto de servicio B debe ejecutar uno de los siguientes comandos para conceder el permiso compute.backendServices.use a un administrador del balanceador de carga del proyecto de servicio A. Puedes hacerlo a nivel de proyecto (para todos los servicios de backend del proyecto) o por servicio de backend.

Consola

Permisos de nivel de proyecto

Sigue estos pasos para conceder permisos a todos los servicios backend de tu proyecto.

Para completar este paso, necesitas los permisos compute.regionBackendServices.setIamPolicy y resourcemanager.projects.setIamPolicy.

  1. En la consola, ve a la página Gestión de identidades y accesos. Google Cloud

    Ir a IAM

  2. Selecciona el proyecto.

  3. Haz clic en Conceder acceso.

  4. En el campo Nuevos principales, introduce la dirección de correo u otro identificador del principal.

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

  6. Opcional: Añade una condición al rol.

  7. Haz clic en Guardar.

Permisos a nivel de recurso para servicios de backend concretos

Sigue estos pasos para conceder permisos a servicios backend concretos de tu proyecto.

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

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

    Ir a Backends

  2. En la lista de back-ends, selecciona el servicio de back-end al que quieras dar acceso y haz clic en Permisos.

  3. Haz clic en Añadir principal.

  4. En el campo Nuevos principales, introduce la dirección de correo u otro identificador del principal.

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

  6. Haz clic en Guardar.

gcloud

Permisos de nivel de proyecto

Sigue estos pasos para conceder permisos a todos los servicios backend de tu proyecto.

Para completar este paso, necesitas los permisos compute.regionBackendServices.setIamPolicy y resourcemanager.projects.setIamPolicy. 

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 concretos

A nivel de servicio backend, los administradores del proyecto de servicio pueden usar cualquiera de los siguientes comandos para conceder el rol Usuario de servicios de balanceador de carga 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, sustituye LOAD_BALANCER_ADMIN por el principal del usuario. Por ejemplo, test-user@gmail.com.

También puedes configurar permisos de gestión de identidades y accesos para que solo se apliquen a un subconjunto de servicios backend regionales mediante condiciones y especificando atributos de condición.

Para ver los mapas de URLs que hacen referencia a un servicio de backend de VPC compartida concreto, 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

Haz los cambios siguientes:

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

En el resultado del comando, consulta el campo usedBy, que muestra los recursos que hacen referencia al servicio de backend, tal 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

Siguientes pasos