Configura un balanceador de cargas de aplicaciones externo regional con backends de grupos de instancias de VM

En este documento, se proporcionan instrucciones para configurar un balanceador de cargas de aplicaciones regional externo en los servicios que se ejecutan en las VMs de Compute Engine.

Debido a que los balanceadores de cargas de aplicaciones regionales externos te permiten crear balanceadores de cargas en regiones específicas, a menudo se usan para cargas de trabajo que tienen requisitos de cumplimiento jurisdiccional. Las cargas de trabajo que requieren acceso a la salida de nivel de red estándar son otro caso de uso común para los balanceadores de cargas de aplicaciones externos regionales, ya que los balanceadores de cargas de aplicaciones externos admiten el nivel de servicio de red Estándar.

Antes de seguir con esta guía, familiarízate con lo siguiente:

• Descripción general del balanceador de cargas de aplicaciones externo
• Descripción general de las reglas de firewall de VPC

Permisos

Para seguir esta guía, debes poder crear instancias y modificar una red en un proyecto. Debes ser propietario o editor de un proyecto o tener todas las siguientes funciones de IAM de Compute Engine:

Tarea	Función requerida
Crear redes, subredes y componentes del balanceador de cargas	Administrador de redes
Agrega y quita reglas de firewall	Administrador de seguridad
Crea instancias	Administrador de instancias

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

• Control de acceso
• Condiciones de IAM

Descripción general de la configuración

Puedes configurar un balanceador de cargas de aplicaciones externo regional como se describe en el siguiente flujo de configuración de alto nivel. Los pasos numerados se refieren a los números en el diagrama.

Componentes numerados del balanceador de cargas de aplicaciones externo regional (haz clic para ampliar)

Como se muestra en el diagrama, en este ejemplo se crea un balanceador de cargas de aplicaciones externo regional en una red de VPC en la región us-west1, con un servicio de backend y dos grupos de instancias de backend.

En el diagrama se muestra lo siguiente:

1. Una red de VPC con dos subredes:

   1. Una subred se usa para backends (grupos de instancias). Su rango de direcciones IP principal es 10.1.2.0/24.

   2. Una subred es una subred de solo proxy en la región us-west1. Debes crear una subred de solo proxy en cada región de una red de VPC en la que uses balanceadores de cargas de aplicaciones externos regionales. La subred de solo proxy de la región se comparte entre todos los balanceadores de cargas regionales de la región. Las direcciones de origen de los paquetes enviados desde los balanceadores de cargas a los backends de tu servicio se asignan desde la subred de solo proxy. En este ejemplo, el rango principal de direcciones IP de la subred de solo proxy para la región es 10.129.0.0/23, que es el tamaño de subred recomendado. Para obtener más información, consulta Subredes de solo proxy.

2. Una regla de firewall que permite flujos de tráfico de subred de solo proxy en tu red. Esto significa que se agrega una regla que permita el tráfico de los puertos TCP 80, 443 y 8080 desde 10.129.0.0/23 (el rango de la subred de solo proxy en este ejemplo). Otra regla de firewall para las sondas de verificación de estado.

3. Instancias de backend.

4. Grupos de instancias:

   1. Grupos de instancias administrados o no administrados para implementaciones de VM de Compute Engine
   2. NEG para implementaciones de GKE

   En cada zona, puedes tener una combinación de tipos de grupo de backend según los requisitos de tu implementación.

5. Una verificación de estado regional que informa la preparación de tus backends.

6. Un servicio de backend regional que supervisa el uso y el estado de los backends.

7. Un mapa de URL regional que analiza la URL de una solicitud y reenvía las solicitudes a servicios de backend específicos en función del host y la ruta de acceso de la URL de la solicitud.

8. Un proxy HTTP o HTTPS de destino regional, que recibe una solicitud del usuario y la reenvía al mapa de URL. Para HTTPS, configura un recurso de certificado SSL regional. El proxy de destino puede usar el certificado SSL o el certificado del Administrador de certificados para desencriptar el tráfico SSL si configuras el balanceo de cargas de HTTPS. El proxy de destino puede reenviar tráfico a tus instancias mediante HTTP o HTTPS.

9. Una regla de reenvío, que tiene la dirección IP externa de tu balanceador de cargas, para reenviar cada solicitud entrante al proxy de destino.

   La dirección IP externa asociada con la regla de reenvío se reserva mediante el comando gcloud compute addresses create, como se describe en Reserva la dirección IP del balanceador de cargas.

Configura la red y las subredes

Necesitas una red de VPC con dos subredes: una para los backends del balanceador de cargas y la otra para los proxies del balanceador de cargas. Un balanceador de cargas de aplicaciones externo regional es regional. El tráfico dentro de la red de VPC se enruta al balanceador de cargas si la fuente de tráfico está en una subred en la misma región que el balanceador de cargas.

Este ejemplo usa la siguiente red de VPC, región y subredes:

• Red. Es una red de VPC de modo personalizado con el nombre lb-network.

• Subred para backends. Una subred llamada backend-subnet en la región us-west1 usa 10.1.2.0/24 en 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.

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

Configura la red y la subred para los backends

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:

   • Establece el Modo de creación de subred en Personalizado.
   • En la sección Nueva subred, ingresa la siguiente información:
     • Nombre: backend-subnet
     • Región: us-west1
     • Rangos de direcciones IP: 10.1.2.0/24
   • Haz clic en Listo.

5. Haz clic en Crear.

gcloud

1. Crea la red de VPC personalizada 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 con el comando gcloud compute networks subnets create:

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

Terraform

Para crear la red de VPC, usa el recurso google_compute_network.

resource "google_compute_network" "default" {
  name                    = "lb-network"
  auto_create_subnetworks = false
  routing_mode            = "REGIONAL"
}

Para crear la subred de VPC en la red lb-network, usa el recurso google_compute_subnetwork.

resource "google_compute_subnetwork" "default" {
  name                       = "backend-subnet"
  ip_cidr_range              = "10.1.2.0/24"
  network                    = google_compute_network.default.id
  private_ipv6_google_access = "DISABLE_GOOGLE_ACCESS"
  purpose                    = "PRIVATE"
  region                     = "us-west1"
  stack_type                 = "IPV4_ONLY"
}

API

1. Realiza una solicitud POST al método networks.insert y reemplaza PROJECT_ID por el ID del proyecto.

   POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks
   {
    "routingConfig": {
      "routingMode": "REGIONAL"
    },
    "name": "lb-network",
    "autoCreateSubnetworks": false
   }
   

2. Realiza una solicitud POST al método subnetworks.insert y reemplaza PROJECT_ID por el ID del proyecto.

   POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks
   {
    "name": "backend-subnet",
    "network": "projects/PROJECT_ID/global/networks/lb-network",
    "ipCidrRange": "10.1.2.0/24",
    "region": "projects/PROJECT_ID/regions/us-west1",
   }
   

Configura la subred de solo proxy

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

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

Importante: No intentes asignar direcciones de la subred de solo proxy a los backends de tus balanceadores de carga. Debes asignar las direcciones IP de la instancia de backend de un rango (o rangos) de subred diferente, no de este. Google Cloud reserva este rango de subredes para los proxies que administra Google Cloud.

Console

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

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

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

   Ir a las redes de VPC

2. Haz clic en el nombre de la red de VPC: 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

Para crear la subred de solo proxy de VPC en la red lb-network, usa el recurso google_compute_subnetwork.

resource "google_compute_subnetwork" "proxy_only" {
  name          = "proxy-only-subnet"
  ip_cidr_range = "10.129.0.0/23"
  network       = google_compute_network.default.id
  purpose       = "REGIONAL_MANAGED_PROXY"
  region        = "us-west1"
  role          = "ACTIVE"
}

API

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

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks
{
  "name": "proxy-only-subnet",
  "ipCidrRange": "10.129.0.0/23",
  "network": "projects/PROJECT_ID/global/networks/lb-network",
  "region": "projects/PROJECT_ID/regions/us-west1",
  "purpose": "REGIONAL_MANAGED_PROXY",
  "role": "ACTIVE"
}

Configura reglas de firewall

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

• fw-allow-health-check. Una regla de entrada aplicable a las instancias con balanceo de cargas y que permite todo 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 VMs a las que se aplica la regla de firewall.

• 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, y desde los proxies administrados del balanceador de cargas de aplicaciones externo regional. En este ejemplo, se usa la etiqueta de destino load-balanced-backend para identificar las VMs 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.

Las etiquetas de destino definen las instancias de backend. Sin las etiquetas de destino, las reglas de firewall se aplican a todas las instancias de backend en la red de VPC. Cuando crees las VM de backend, asegúrate de incluir las etiquetas de destino especificadas, como se muestra en Crea un grupo de instancias administrado.

Console

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

   Ir a Reglas 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 en caso de coincidencia: Permitir
   • Destinos: 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.
     • Selecciona la casilla de verificación TCP y, luego, 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 VM, pero no puede usar HTTPS en el puerto 443 para comunicarse con ellas.

3. Haga clic en Crear.

4. Haz clic en Crear regla de firewall para crear la regla a fin de permitir que los servidores proxy del balanceador de cargas conecten los backends:

   • Nombre: fw-allow-proxies
   • Red: lb-network
   • Dirección del tráfico: Entrada
   • Acción en caso de coincidencia: Permitir
   • Destinos: 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.
     • Selecciona la casilla de verificación TCP y, luego, ingresa 80, 443, 8080 para los números de puerto.

5. Haz clic en Crear.

gcloud

1. Crea la regla 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 según 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 fw-allow-proxies para permitir que los proxies del balanceador de cargas de aplicaciones externo regional se conecten con los backends. Configura source-ranges en los rangos asignados de tu subred de solo proxy, por ejemplo, 10.129.0.0/23.

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

Terraform

Para crear la regla de firewall, usa el recurso google_compute_firewall.

resource "google_compute_firewall" "default" {
  name = "fw-allow-health-check"
  allow {
    protocol = "tcp"
  }
  direction     = "INGRESS"
  network       = google_compute_network.default.id
  priority      = 1000
  source_ranges = ["130.211.0.0/22", "35.191.0.0/16"]
  target_tags   = ["load-balanced-backend"]
}

resource "google_compute_firewall" "allow_proxy" {
  name = "fw-allow-proxies"
  allow {
    ports    = ["443"]
    protocol = "tcp"
  }
  allow {
    ports    = ["80"]
    protocol = "tcp"
  }
  allow {
    ports    = ["8080"]
    protocol = "tcp"
  }
  direction     = "INGRESS"
  network       = google_compute_network.default.id
  priority      = 1000
  source_ranges = ["10.129.0.0/23"]
  target_tags   = ["load-balanced-backend"]
}

API

Crea la regla de firewall fw-allow-health-check mediante una solicitud POST al método firewalls.insert y reemplaza PROJECT_ID por el ID del proyecto.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/firewalls
{
  "name": "fw-allow-health-check",
  "network": "projects/PROJECT-ID/global/networks/lb-network",
  "sourceRanges": [
    "130.211.0.0/22",
    "35.191.0.0/16"
  ],
  "targetTags": [
    "load-balanced-backend"
  ],
  "allowed": [
    {
      "IPProtocol": "tcp"
    }
  ],
  "direction": "INGRESS"
}

Crea la regla de firewall fw-allow-proxies a fin de permitir el tráfico de TCP dentro de la subred de proxy para el método firewalls.insert y reemplaza PROJECT_ID por el ID del proyecto.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/firewalls
{
  "name": "fw-allow-proxies",
  "network": "projects/PROJECT_ID/global/networks/lb-network",
  "sourceRanges": [
    "10.129.0.0/23"
  ],
  "targetTags": [
    "load-balanced-backend"
  ],
  "allowed": [
    {
      "IPProtocol": "tcp",
      "ports": [
        "80"
      ]
    },
    {
      "IPProtocol": "tcp",
      "ports": [
        "443"
      ]
    },
    {
      "IPProtocol": "tcp",
      "ports": [
        "8080"
      ]
    }
  ],
  "direction": "INGRESS"
}

Configura un balanceador de cargas de aplicaciones externo regional con un servicio basado en VMs

En esta sección, se muestra la configuración que se requiere para los servicios que se ejecutan en las VMs de Compute Engine. Las VMs cliente se conectan a la dirección IP y al puerto que configuras en la regla de reenvío. Cuando las aplicaciones cliente envían tráfico a esta dirección IP y al puerto, sus solicitudes se reenvían a tus máquinas virtuales (VMs) de backend según el mapa de URL del balanceador de cargas de aplicaciones externo regional.

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

Crea un backend de 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 de aplicaciones externo regional 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. Crear 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-xlb-backend-template.
   3. Asegúrate de que el disco de arranque esté configurado como una imagen de Debian, como Debian GNU/Linux 10 (buster). En estas instrucciones, se usan comandos que solo están disponibles en Debian, como apt-get.
   4. Haz clic en Opciones avanzadas.
   5. Haz clic en Herramientas de redes y configura los siguientes campos:
      1. En Etiquetas de red, ingresa load-balanced-backend.
      2. En Interfaces de red, selecciona lo siguiente:
         • Red: lb-network
         • Subred: backend-subnet

   6. Haz clic en Administración. Ingresa 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
      

   7. Haz clic en Crear.

2. Cree 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. Haz clic en Crear grupo de instancias.
   2. Selecciona Nuevo grupo de instancias administrado (sin estado). Para obtener más información, consulta MIG sin estado o con estado.
   3. En Nombre, ingresa l7-xlb-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-xlb-backend-template.

   8. En Modo de ajuste de escala automático, selecciona Activado: agrega y quita instancias del grupo.

      Establece la Cantidad mínima de instancias en 2 y la Cantidad máxima de instancias en 2 o más.

   9. Haga 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-xlb-backend-template \
   --region=us-west1 \
   --network=lb-network \
   --subnet=backend-subnet \
   --tags=load-balanced-backend \
   --image-family=debian-10 \
   --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'
   

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-xlb-backend-example \
       --zone=us-west1-a \
       --size=2 \
       --template=l7-xlb-backend-template
   

Terraform

Para crear la plantilla de instancias, usa el recurso google_compute_instance_template.

resource "google_compute_instance_template" "default" {
  name = "l7-xlb-backend-template"
  disk {
    auto_delete  = true
    boot         = true
    device_name  = "persistent-disk-0"
    mode         = "READ_WRITE"
    source_image = "projects/debian-cloud/global/images/family/debian-10"
    type         = "PERSISTENT"
  }
  labels = {
    managed-by-cnrm = "true"
  }
  machine_type = "n1-standard-1"
  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://169.254.169.254/computeMetadata/v1/instance/name)"
    sudo echo "Page served from: $vm_hostname" | \
    tee /var/www/html/index.html
    sudo systemctl restart apache2
    EOF
  }
  network_interface {
    access_config {
      network_tier = "PREMIUM"
    }
    network    = google_compute_network.default.id
    subnetwork = google_compute_subnetwork.default.id
  }
  region = "us-west1"
  scheduling {
    automatic_restart   = true
    on_host_maintenance = "MIGRATE"
    provisioning_model  = "STANDARD"
  }
  service_account {
    email  = "default"
    scopes = ["https://www.googleapis.com/auth/devstorage.read_only", "https://www.googleapis.com/auth/logging.write", "https://www.googleapis.com/auth/monitoring.write", "https://www.googleapis.com/auth/pubsub", "https://www.googleapis.com/auth/service.management.readonly", "https://www.googleapis.com/auth/servicecontrol", "https://www.googleapis.com/auth/trace.append"]
  }
  tags = ["load-balanced-backend"]
}

Para crear el grupo de instancias administrado, usa el recurso google_compute_instance_group_manager.

resource "google_compute_instance_group_manager" "default" {
  name = "l7-xlb-backend-example"
  zone = "us-west1-a"
  named_port {
    name = "http"
    port = 80
  }
  version {
    instance_template = google_compute_instance_template.default.id
    name              = "primary"
  }
  base_instance_name = "vm"
  target_size        = 2
}

API

1. Crea la plantilla de instancias con el método instanceTemplates.insert y reemplaza PROJECT_ID por el ID de tu proyecto.

   POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/instanceTemplates
   {
    "name":"l7-xlb-backend-template",
    "properties": {
      "machineType":"e2-standard-2",
      "tags": {
        "items":[
          "load-balanced-backend"
        ]
      },
      "metadata": {
        "kind":"compute#metadata",
        "items":[
          {
            "key":"startup-script",
            "value":"#! /bin/bash\napt-get update\napt-get install apache2 -y\na2ensite default-ssl\na2enmod ssl\nvm_hostname=\"$(curl -H \"Metadata-Flavor:Google\" \\\nhttp://metadata.google.internal/computeMetadata/v1/instance/name)\"\necho \"Page served from: $vm_hostname\" | \\\ntee /var/www/html/index.html\nsystemctl restart apache2"
          }
        ]
      },
      "networkInterfaces":[
        {
          "network":"projects/PROJECT_ID/global/networks/lb-network",
          "subnetwork":"regions/us-west1/subnetworks/backend-subnet",
          "accessConfigs":[
            {
              "type":"ONE_TO_ONE_NAT"
            }
          ]
        }
      ],
      "disks": [
        {
          "index":0,
          "boot":true,
          "initializeParams": {
            "sourceImage":"projects/debian-cloud/global/images/family/debian-10"
          },
          "autoDelete":true
        }
      ]
    }
   }
   

2. Crea un grupo de instancias administrado en cada zona con el método instanceGroupManagers.insert y reemplaza PROJECT_ID por el ID del proyecto.

   POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/{zone}/instanceGroupManagers
   {
    "name": "l7-xlb-backend-example",
    "zone": "projects/PROJECT_ID/zones/us-west1-a",
    "instanceTemplate": "projects/PROJECT_ID/global/instanceTemplates/l7-xlb-backend-template",
    "baseInstanceName": "l7-xlb-backend-example",
    "targetSize": 2
   }
   

Agrega un puerto con nombre al grupo de instancias

En el grupo de instancias, define un servicio HTTP y asigna un nombre de puerto al puerto pertinente. El servicio de backend del balanceador de cargas reenvía el tráfico a los puertos con nombre.

Console

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

   Ir a Grupos de instancias

2. Haz clic en el nombre del grupo de instancias (en este ejemplo, l7-xlb-backend-example).

3. En la página Descripción general del grupo de instancias, haz clic en Editar .

4. Haz clic en Especificar la asignación del nombre de puerto.

5. Haz clic en Agregar elemento.

6. En el nombre de puerto, ingresa http. En el número de puerto, ingresa 80.

7. Haz clic en Guardar.

gcloud

Usa el comando gcloud compute instance-groups set-named-ports.

gcloud compute instance-groups set-named-ports l7-xlb-backend-example \
    --named-ports http:80 \
    --zone us-west1-a

Terraform

El atributo named_port se incluye en la muestra del grupo de instancias administrado.

Reserva la dirección IP del balanceador de cargas

Reserva una dirección IP externa para el balanceador de cargas Este procedimiento crea la dirección IP del balanceador de cargas en el nivel Estándar. Los balanceadores de cargas de aplicaciones externos regionales admiten los Niveles de servicio de red Premium y Estándar. Sin embargo, no se admite la creación de este balanceador de cargas en el nivel Premium en la consola de Google Cloud. En su lugar, usa gcloud o la API de REST.

Console

1. En la consola de Google Cloud, ve a la página Reserva una dirección estática.

   Ir a Reserva una dirección estática

2. Elige un nombre para la dirección nueva.

3. En Nivel de servicio de red, selecciona Estándar.

4. Para Versión de la IP, selecciona IPv4. Las direcciones IPv6 solo pueden ser globales y solo se pueden usar con balanceadores de cargas globales.

5. En Tipo, selecciona Regional.

6. En Región, selecciona us-west1.

7. Deja la opción Conectado a configurada en Ninguna. Después de crear el balanceador de cargas, esta dirección IP se adjuntará a la regla de reenvío del balanceador de cargas.

8. Haz clic en Reservar si deseas reservar la dirección IP.

gcloud

1. Para reservar una dirección IP externa estática mediante gcloud compute, usa el comando compute addresses create.

   gcloud compute addresses create ADDRESS_NAME  \
      --region=us-west1 \
      --network-tier=STANDARD
   

   Reemplaza lo siguiente:

   • ADDRESS_NAME: El nombre que quieres asignar a esta dirección.
   • REGION: Es la región en la que deseas reservar esta dirección. Esta región debe ser la misma que la del balanceador de cargas. Todas las direcciones IP regionales son IPv4.

2. Usa el comando compute addresses describe para ver el resultado:

   gcloud compute addresses describe ADDRESS_NAME
   

Terraform

Para reservar la dirección IP, usa el recurso google_compute_address.

resource "google_compute_address" "default" {
  name         = "address-name"
  address_type = "EXTERNAL"
  network_tier = "STANDARD"
  region       = "us-west1"
}

Si deseas obtener más información para aplicar o quitar una configuración de Terraform, consulta los comandos básicos de Terraform.

API

Para crear una dirección IPv4 regional, invoca el método addresses.insert regional:

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

El cuerpo de la solicitud debe contener la siguiente información:

{
  "name": "ADDRESS_NAME"
  "networkTier": "STANDARD"
  "region": "us-west1"
}

Reemplaza lo siguiente:

• ADDRESS_NAME: Es el nombre de la dirección
• REGION: El nombre de la región para esta solicitud.
• PROJECT_ID: Es el ID del proyecto de esta solicitud.

Configura el balanceador de cargas

En este ejemplo, se muestra cómo crear los siguientes recursos del balanceador de cargas de aplicaciones externo regional:

• Verificación de estado de HTTP
• Servicio de backend con un grupo de instancias administrado como backend
• Un mapa de URL
  • Asegúrate de hacer referencia a un mapa de URL regional si se define una región para el proxy de HTTP(S) de destino. Un mapa de URL regional enruta las solicitudes a un servicio de backend regional en función de las reglas que definas para el host y la ruta de acceso de una URL entrante. Solo se puede hacer referencia a un mapa de URL regional mediante una regla regional de proxy de destino en la misma región.
• Certificado SSL (para HTTPS)
• Proxy de destino
• Regla de reenvío

Disponibilidad del proxy

En ocasiones, las regiones de Google Cloud no tienen suficiente capacidad de proxy para un nuevo balanceador de cargas. 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:

• Selecciona una región diferente para el balanceador de cargas. Esta puede ser una opción práctica si tienes backends en otra región.
• Selecciona una red de VPC que ya tenga asignada una subred de solo proxy.

• Espera a que se resuelva el problema de capacidad.

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 Orientado al público (externo) y haz clic en Siguiente.
5. En Implementación global o de una sola región, selecciona Mejor 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 regional-l7-xlb.
2. En Región, selecciona us-west1.
3. En Red, selecciona lb-network.

Reserva una subred de solo proxy

Nota: Si ya configuraste la subred de solo proxy, el botón Reservar una subred no se muestra. Debes omitir esta sección y continuar con los pasos en Configura el servicio de frontend.

Para un balanceador de cargas de aplicaciones externo regional, reserva una subred de solo proxy:

1. Haz clic en Reservar subred.
2. En Nombre, ingresa proxy-only-subnet.
3. En Rango de direcciones IP, ingresa 10.129.0.0/23.
4. Haga clic en Agregar.

Configure el frontend

Para HTTP:

1. Haga clic en Configuración de frontend.
2. Establece el Nombre como l7-xlb-forwarding-rule.
3. Establece el Protocolo en HTTP.
4. Configura el Puerto como 80.
5. Selecciona la dirección IP que creaste en Reserva la dirección IP del balanceador de cargas.
6. Haga clic en Listo.

Para HTTPS:

1. Haz clic en Configuración de frontend.
2. En el campo Nombre, ingresa l7-xlb-forwarding-rule.
3. En el campo Protocolo, selecciona HTTPS (includes HTTP/2).
4. Asegúrate de que el Puerto esté establecido en 443.
5. Selecciona la dirección IP que creaste en Reserva la dirección IP del balanceador de cargas.
6. En la lista Certificado, haz lo siguiente:
   1. Si ya tienes un recurso de certificado SSL autoadministrado de Compute Engine, selecciona el certificado SSL principal.
   2. Haz clic en Crear un certificado nuevo.
      1. En el campo Nombre, ingresa l7-xlb-cert.
      2. En los campos correspondientes, sube los archivos con formato PEM:
         • Certificado
         • Clave privada
      3. Haga clic en Crear.
7. Opcional: Para agregar certificados además del certificado SSL principal, sigue estos pasos:
   1. Haz clic en Agregar certificado.
   2. Si ya tienes un certificado, selecciónalo en la lista Certificados.
   3. Opcional: Haz clic en Crear un certificado nuevo y sigue las instrucciones especificadas en el paso anterior.
8. Selecciona una política de SSL de la lista Política de SSL. Si no creaste ninguna política de SSL, se aplica una política predeterminada de Google Cloud SSL.
9. Haz clic en Listo.

Configura el servicio de 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. Configura el nombre del servicio de backend como l7-xlb-backend-service.
4. En Protocolo, selecciona HTTP.
5. En Puerto con nombre, ingresa http.
6. Configura el Tipo de backend como grupo de instancias.
7. En la sección Nuevo backend, sigue estos pasos:
   1. Establece Grupo de instancias en l7-xlb-backend-example.
   2. Establece Números de puerto en 80.
   3. Establece el campo Modo de balanceo en Uso.
   4. Haga clic en Listo.
8. En la sección Verificación de estado, haz clic en Crea una verificación de estado.
   1. Establece el Nombre como l7-xlb-basic-check.
   2. Establece el Protocolo en HTTP.
   3. Configura el Puerto como 80.
   4. Haz clic en Guardar.
9. Haga clic en Crear.

Configura las reglas de enrutamiento

1. Haga clic en Reglas de enrutamiento.
2. En Modo, selecciona Regla sencilla de host y ruta de acceso.
3. Asegúrate de que l7-xlb-backend-service sea el único servicio de backend para los hosts y rutas de acceso no coincidentes.

Revisa la configuración

1. Haz clic en Revisar y finalizar.
2. Revisa la configuración del balanceador de cargas.
3. Opcional: Haz clic en Código equivalente a fin de ver la solicitud a la API de REST que se usará para crear el balanceador de cargas.
4. 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-xlb-basic-check \
      --region=us-west1 \
      --request-path='/' \
      --use-serving-port
   

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

   gcloud compute backend-services create l7-xlb-backend-service \
     --load-balancing-scheme=EXTERNAL_MANAGED \
     --protocol=HTTP \
     --port-name=http \
     --health-checks=l7-xlb-basic-check \
     --health-checks-region=us-west1 \
     --region=us-west1
   

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

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

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

   gcloud compute url-maps create regional-l7-xlb-map \
     --default-service=l7-xlb-backend-service \
     --region=us-west1
   

5. Crea el proxy de destino.

   Para HTTP:

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

   gcloud compute target-http-proxies create l7-xlb-proxy \
     --url-map=regional-l7-xlb-map \
     --url-map-region=us-west1 \
     --region=us-west1
   

   Para HTTPS:

   Puedes crear certificados de Compute Engine o del Administrador de certificados. Usa cualquiera de los siguientes métodos para crear certificados con el Administrador de certificados:

   • Certificados autoadministrados regionales Para obtener más información sobre cómo crear y usar certificados autoadministrados regionales, consulta Implementa un certificado autoadministrado regional. No se admiten mapas de certificados.

   • Certificados regionales administrados por Google. No se admiten mapas de certificados.

     El Administrador de certificados admite los siguientes tipos de certificados regionales administrados por Google:

     • Certificados regionales administrados por Google con autorización de DNS por proyecto. Para obtener más información, consulta Implementa un certificado regional administrado por Google.
     • Certificados regionales administrados por Google (privados) con Certificate Authority Service. Para obtener más información, consulta Implementa un certificado regional administrado por Google con el servicio de CA.

   Después de crear certificados, adjunta el certificado directamente al proxy de destino.

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

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

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

   3. 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-xlb-proxy \
       --url-map=regional-l7-xlb-map \
       --region=us-west1 \
       --ssl-certificates=l7-xlb-cert
      

   • Crea la regla de reenvío.

     Para HTTP:

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

     gcloud compute forwarding-rules create l7-xlb-forwarding-rule \
       --load-balancing-scheme=EXTERNAL_MANAGED \
       --network-tier=STANDARD \
       --network=lb-network \
       --address=ADDRESS_NAME \
       --ports=80 \
       --region=us-west1 \
       --target-http-proxy=l7-xlb-proxy \
       --target-http-proxy-region=us-west1
     

     Para HTTPS:

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

     gcloud compute forwarding-rules create l7-xlb-forwarding-rule \
       --load-balancing-scheme=EXTERNAL_MANAGED \
       --network-tier=STANDARD \
       --network=lb-network \
       --address=ADDRESS_NAME \
       --ports=443 \
       --region=us-west1 \
       --target-https-proxy=l7-xlb-proxy \
       --target-https-proxy-region=us-west1
     

Terraform

Para crear la verificación de estado, usa el recurso google_compute_region_health_check.

resource "google_compute_region_health_check" "default" {
  name               = "l7-xlb-basic-check"
  check_interval_sec = 5
  healthy_threshold  = 2
  http_health_check {
    port_specification = "USE_SERVING_PORT"
    proxy_header       = "NONE"
    request_path       = "/"
  }
  region              = "us-west1"
  timeout_sec         = 5
  unhealthy_threshold = 2
}

Para crear el servicio de backend, usa el recurso google_compute_region_backend_service.

resource "google_compute_region_backend_service" "default" {
  name                  = "l7-xlb-backend-service"
  region                = "us-west1"
  load_balancing_scheme = "EXTERNAL_MANAGED"
  health_checks         = [google_compute_region_health_check.default.id]
  protocol              = "HTTP"
  session_affinity      = "NONE"
  timeout_sec           = 30
  backend {
    group           = google_compute_instance_group_manager.default.instance_group
    balancing_mode  = "UTILIZATION"
    capacity_scaler = 1.0
  }
}

Para crear el mapa de URL, usa el recurso google_compute_region_url_map.

resource "google_compute_region_url_map" "default" {
  name            = "regional-l7-xlb-map"
  region          = "us-west1"
  default_service = google_compute_region_backend_service.default.id
}

Para crear el proxy HTTP de destino, usa el recurso google_compute_region_target_http_proxy.

resource "google_compute_region_target_http_proxy" "default" {
  name    = "l7-xlb-proxy"
  region  = "us-west1"
  url_map = google_compute_region_url_map.default.id
}

Para crear la regla de reenvío, usa el recurso google_compute_forwarding_rule.

resource "google_compute_forwarding_rule" "default" {
  name       = "l7-xlb-forwarding-rule"
  provider   = google-beta
  depends_on = [google_compute_subnetwork.proxy_only]
  region     = "us-west1"

  ip_protocol           = "TCP"
  load_balancing_scheme = "EXTERNAL_MANAGED"
  port_range            = "80"
  target                = google_compute_region_target_http_proxy.default.id
  network               = google_compute_network.default.id
  ip_address            = google_compute_address.default.id
  network_tier          = "STANDARD"
}

Si deseas obtener más información para aplicar o quitar una configuración de Terraform, consulta los comandos básicos de Terraform.

API

Para crear la verificación de estado, realiza una solicitud POST al método regionHealthChecks.insert y reemplaza PROJECT_ID por el ID del proyecto.

POST https://compute.googleapis.com/compute/v1/projects/<var>PROJECT_ID</var>/regions/{region}/healthChecks
{
  "name": "l7-xlb-basic-check",
  "type": "HTTP",
  "httpHealthCheck": {
    "portSpecification": "USE_SERVING_PORT"
  }
}

Para crear el servicio de backend regional, realiza una solicitud POST al método regionBackendServices.insert y reemplaza PROJECT_ID por el ID del proyecto.

POST https://compute.googleapis.com/compute/v1/projects/<var>PROJECT_ID</var>/regions/us-west1/backendServices
{
  "name": "l7-xlb-backend-service",
  "backends": [
    {
      "group": "projects/<var>PROJECT_ID</var>/zones/us-west1-a/instanceGroups/l7-xlb-backend-example",
      "balancingMode": "UTILIZATION"
    }
  ],
  "healthChecks": [
    "projects/<var>PROJECT_ID</var>/regions/us-west1/healthChecks/l7-xlb-basic-check"
  ],
  "loadBalancingScheme": "EXTERNAL_MANAGED"
}

Para crear el mapa de URL, realiza una solicitud POST al método regionUrlMaps.insert y reemplaza PROJECT_ID por el ID del proyecto.

POST https://compute.googleapis.com/compute/v1/projects/<var>PROJECT_ID</var>/regions/us-west1/urlMaps
{
  "name": "regional-l7-xlb-map",
  "defaultService": "projects/<var>PROJECT_ID</var>/regions/us-west1/backendServices/l7-xlb-backend-service"
}

Para crear el proxy HTTP de destino, realiza una solicitud POST al método regionTargetHttpProxies.insert y reemplaza PROJECT_ID por el ID del proyecto.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/targetHttpProxy
{
  "name": "l7-xlb-proxy",
  "urlMap": "projects/PROJECT_ID/global/urlMaps/regional-l7-xlb-map",
  "region": "us-west1"
}

Para crear la regla de reenvío, realiza una solicitud POST al método forwardingRules.insert y reemplaza PROJECT_ID por el ID del proyecto.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/forwardingRules
{
  "name": "l7-xlb-forwarding-rule",
  "IPAddress": "10.1.2.99",
  "IPProtocol": "TCP",
  "portRange": "80-80",
  "target": "projects/PROJECT_ID/regions/us-west1/targetHttpProxies/l7-xlb-proxy",
  "loadBalancingScheme": "EXTERNAL_MANAGED",
  "network": "projects/PROJECT_ID/global/networks/lb-network",
  "networkTier": "STANDARD",
}

Conecta tu dominio al balanceador de cargas

Después de crear el balanceador de cargas, toma nota de la dirección IP asociada con este: por ejemplo, 30.90.80.100. Para apuntar tu dominio al balanceador de cargas, crea un registro A mediante tu servicio de registro de dominio. Si agregaste varios dominios a tu certificado SSL, debes agregar un registro A para cada uno, que apunte a la dirección IP del balanceador de cargas. Por ejemplo, para crear registros A para www.example.com y example.com, usa lo siguiente:

NAME                  TYPE     DATA
www                   A        30.90.80.100
@                     A        30.90.80.100

Si usas Cloud DNS como proveedor de DNS, consulta Agrega, modifica y borra registros.

Prueba el balanceador de cargas

Ahora que el servicio de balanceo de cargas está en ejecución, puedes enviar tráfico a la regla de reenvío y ver cómo este se dispersa en las diferentes instancias.

Console

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

   Ir a Balanceo de cargas

2. Selecciona el balanceador de cargas que acabas de crear.
3. En la sección Backend, confirma que las VM estén en buen estado. La columna En buen estado debe propagarse, lo que indica que ambas VM están en buen estado (2/2). Si ves lo contrario, primero vuelve a cargar la página. Puede tomar unos minutos que la consola de Google Cloud indique que las VM están en buen estado. Si los backends no se muestran con buen estado después de unos minutos, revisa la configuración del firewall y la etiqueta de red asignada a tus VM de backend.
4. Después de que la consola de Google Cloud muestre que las instancias de backend están en buen estado, puedes probar tu balanceador de cargas con un navegador web en https://IP_ADDRESS (o http://IP_ADDRESS). Reemplaza IP_ADDRESS por la dirección IP del balanceador de cargas.
5. Si usaste un certificado autofirmado para las pruebas de HTTPS, el navegador mostrará una advertencia. Debes indicar de manera explícita a tu navegador que acepte un certificado autofirmado.
6. El navegador debe renderizar una página con contenido que muestre el nombre de la instancia que entregó la página, junto con su zona (por ejemplo, Page served from: lb-backend-example-xxxx). Si el navegador no renderiza esta página, revisa las opciones de configuración que aparecen en esta guía.

gcloud

Toma nota de la dirección IPv4 que se reservó:

gcloud beta compute addresses describe ADDRESS_NAME \
    --format="get(address)" \
    --region="us-west1"

Puedes probar tu balanceador de cargas con un navegador web en https://IP_ADDRESS (o http://IP_ADDRESS). Reemplaza IP_ADDRESS por la dirección IP del balanceador de cargas.

Si usaste un certificado autofirmado para las pruebas de HTTPS, el navegador mostrará una advertencia. Debes indicar de manera explícita a tu navegador que acepte un certificado autofirmado.

Tu navegador debe renderizar una página con información mínima sobre la instancia de backend. Si el navegador no renderiza esta página, revisa las opciones de configuración que aparecen en esta guía.

Opciones de configuración adicionales

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

Habilita la afinidad de sesión

Con estos procedimientos, se muestra cómo actualizar un servicio de backend para el balanceador de cargas de aplicaciones externo regional de ejemplo a fin de que el servicio de backend use afinidad de cookie generada, afinidad de campo de encabezado o afinidad de cookie HTTP.

Cuando se habilita la afinidad de cookie generada, el balanceador de cargas emite una cookie en la primera solicitud. Para cada solicitud posterior con la misma cookie, el balanceador de cargas dirige la solicitud a la misma VM o extremo de backend. Para los balanceadores de cargas de aplicaciones externos regionales, la cookie se llama GCILB.

Cuando se habilita la afinidad de campo de encabezado, el balanceador de cargas enruta solicitudes a VMs o extremos de backend en un NEG según el valor del encabezado de HTTP que se indica en la marca --custom-request-header. La afinidad de campo de encabezado solo es válida si la política de localidad de balanceo de cargas es RING_HASH o MAGLEV y el hash coherente del servicio de backend especifica el nombre del encabezado de HTTP.

Cuando la afinidad de cookie HTTP está habilitada, el balanceador de cargas enruta las solicitudes a VM o extremos de backend en un NEG, según una cookie HTTP a la que se hace referencia en la marca HTTP_COOKIE con la marca opcional --affinity-cookie-ttl. Si el cliente no proporciona la cookie en la solicitud de HTTP, el proxy genera la cookie y la muestra al cliente en un encabezado Set-Cookie. La afinidad de cookie HTTP solo es válida si la política de localidad de balanceo de cargas es RING_HASH o MAGLEV y el hash coherente del servicio de backend especifica la cookie HTTP.

Console

Para habilitar o cambiar la afinidad de sesión de un servicio de backend, sigue estas instrucciones:

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

   Ir a Balanceo de cargas

2. Selecciona el balanceador de cargas que acabas de crear.

3. Haga clic en Backends.

4. Haz clic en l7-xlb-backend-service (el nombre del servicio de backend que creaste para este ejemplo) y haz clic en Editar.

5. En la página Detalles del servicio de backend, haz clic en Configuración avanzada.

6. En Afinidad de sesión, selecciona el tipo de afinidad de sesión que desees del menú.

7. Haga clic en Update.

gcloud

Usa los siguientes comandos de gcloud para actualizar el servicio de backend de l7-xlb-backend-service a diferentes tipos de afinidad de sesión:

gcloud compute backend-services update l7-xlb-backend-service \
    --session-affinity=[GENERATED_COOKIE | HEADER_FIELD | HTTP_COOKIE | CLIENT_IP]
    --region=us-west1

API

Para configurar la afinidad de sesión, realiza una solicitud PATCH al método regionBackendServices/patch.

PATCH https://compute.googleapis.com/compute/v1/projects/[PROJECT_ID]/regions/us-west1/regionBackendServices/l7-xlb-backend-service
{
  "sessionAffinity": ["GENERATED_COOKIE" | "HEADER_FIELD" | "HTTP_COOKIE" | "CLIENT_IP" ]
}

¿Qué sigue?

• Para obtener más información sobre las funciones de administración del tráfico, consulta Descripción general de la administración del tráfico en los balanceadores de cargas de aplicaciones externos regionales.

• Para administrar el recurso de subred de solo proxy que requiere un balanceador de cargas de aplicaciones externo regional, consulta Subredes de solo proxy.

• Si quieres obtener más información sobre cómo actualizar el certificado SSL de tu balanceador de cargas de aplicaciones externo regional, consulta Usa certificados SSL autoadministrados.

• Limpia la configuración del balanceador de cargas.