Configurar un balanceador de carga de red de proxy interno multirregional con backends de grupos de instancias de VM

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. Asigne un nombre a la red.

4. En la sección Subredes, selecciona Personalizado en Modo de creación de subredes.

5. Crea una subred para los back-ends del balanceador de carga. En la sección Nueva subred, introduce la siguiente información:

   • Asigna un nombre a la subred.
   • Selecciona una región: REGION_A
   • Introduce un intervalo de direcciones IP: 10.1.2.0/24

6. Haz clic en Listo.

7. Haz clic en Añadir subred.

8. Crea una subred para los back-ends del balanceador de carga. En la sección Nueva subred, introduce la siguiente información:

   • Asigna un nombre a la subred.
   • Selecciona una región: REGION_B
   • Introduce un intervalo de direcciones IP: 10.1.3.0/24

9. Haz clic en Listo.

10. Haz clic en Crear.

gcloud

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

   gcloud compute networks create NETWORK \
       --subnet-mode=custom
   

2. Crea una subred en la red NETWORK de la región REGION_A con el comando gcloud compute networks subnets create:

   gcloud compute networks subnets create SUBNET_A \
       --network=NETWORK \
       --range=10.1.2.0/24 \
       --region=REGION_A
   

3. Crea una subred en la red NETWORK de la región REGION_B con el comando gcloud compute networks subnets create:

   gcloud compute networks subnets create SUBNET_B \
       --network=NETWORK \
       --range=10.1.3.0/24 \
       --region=REGION_B
   

Terraform

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

resource "google_compute_network" "default" {
  auto_create_subnetworks = false
  name                    = "lb-network-crs-reg"
  provider                = google-beta
}

Para crear las subredes de VPC en la red lb-network-crs-reg, usa el recurso google_compute_subnetwork.

resource "google_compute_subnetwork" "subnet_a" {
  provider      = google-beta
  ip_cidr_range = "10.1.2.0/24"
  name          = "lbsubnet-uswest1"
  network       = google_compute_network.default.id
  region        = "us-west1"
}

resource "google_compute_subnetwork" "subnet_b" {
  provider      = google-beta
  ip_cidr_range = "10.1.3.0/24"
  name          = "lbsubnet-useast1"
  network       = google_compute_network.default.id
  region        = "us-east1"
}

API

Realiza una solicitud POST al método networks.insert. Sustituye PROJECT_ID por el ID de tu proyecto.

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

{
 "routingConfig": {
   "routingMode": "regional"
 },
 "name": "NETWORK",
 "autoCreateSubnetworks": false
}

Realiza una solicitud POST al método subnetworks.insert. Sustituye PROJECT_ID por el ID de tu proyecto.

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

{
 "name": "SUBNET_A",
 "network": "projects/PROJECT_ID/global/networks/lb-network-crs-reg",
 "ipCidrRange": "10.1.2.0/24",
 "region": "projects/PROJECT_ID/regions/REGION_A",
}

Realiza una solicitud POST al método subnetworks.insert. Sustituye PROJECT_ID por el ID de tu proyecto.

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

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

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 conexiones SSH entrantes:

   • Nombre: fw-ilb-to-backends
   • Red: NETWORK
   • Sentido del tráfico: entrada
   • Acción tras coincidencia: Permitir
   • Objetivos: 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.
     • Selecciona la casilla TCP y, a continuación, introduce 22 como número de puerto.

3. Haz clic en Crear.

4. Vuelve a hacer clic en Crear regla de cortafuegos para crear la regla que permita las comprobaciones del estado deGoogle Cloud :

   • Nombre: fw-healthcheck
   • Red: NETWORK
   • Sentido del tráfico: entrada
   • Acción tras coincidencia: Permitir
   • Objetivos: 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.
     • Selecciona la casilla TCP y, a continuación, 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 puede usar HTTP en el puerto 80 para ponerse en contacto con tus VMs, pero no puede usar HTTPS en el puerto 443 para hacerlo.

5. Haz clic en Crear.

6. Haz clic en Crear regla de cortafuegos por tercera vez para crear la regla que permita que los servidores proxy del balanceador de carga se conecten a los backends:

   • Nombre: fw-backends
   • Red: NETWORK
   • Sentido del tráfico: entrada
   • Acción tras coincidencia: Permitir
   • Objetivos: 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 y 10.130.0.0/23
   • Protocolos y puertos:
     • Elige Protocolos y puertos especificados.
     • Selecciona la casilla TCP y, a continuación, introduce 80, 443, 8080 en los números de puerto.

7. Haz clic en Crear.

gcloud

1. Crea la regla de cortafuegos fw-ilb-to-backends 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-ilb-to-backends \
       --network=NETWORK \
       --action=allow \
       --direction=ingress \
       --target-tags=allow-ssh \
       --rules=tcp:22
   

2. Crea la regla fw-healthcheck para permitir Google Cloud las comprobaciones del estado. En este ejemplo, se permite todo el tráfico TCP de los verificadores de comprobación del estado. Sin embargo, puede configurar un conjunto de puertos más reducido para satisfacer sus necesidades.

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

3. Crea la regla fw-backends para permitir que los proxies del balanceador de carga de red de proxy interno se conecten a tus backends. Define source-ranges en los intervalos asignados de tu subred de solo proxy, por ejemplo, 10.129.0.0/23 y 10.130.0.0/23.

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

API

Crea la regla de cortafuegos fw-ilb-to-backends haciendo una solicitud POST al método firewalls.insert y sustituyendo PROJECT_ID por el ID de tu proyecto.

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

{
 "name": "fw-ilb-to-backends",
 "network": "projects/PROJECT_ID/global/networks/NETWORK",
 "sourceRanges": [
   "0.0.0.0/0"
 ],
 "targetTags": [
   "allow-ssh"
 ],
 "allowed": [
  {
    "IPProtocol": "tcp",
    "ports": [
      "22"
    ]
  }
 ],
"direction": "INGRESS"
}

Crea la regla de cortafuegos fw-healthcheck haciendo una solicitud POST al método firewalls.insert y sustituyendo PROJECT_ID por el ID de tu proyecto.

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

{
 "name": "fw-healthcheck",
 "network": "projects/PROJECT_ID/global/networks/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 cortafuegos fw-backends para permitir el tráfico TCP en la subred de proxy del método firewalls.insert. Sustituye PROJECT_ID por el ID de tu proyecto.

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

{
 "name": "fw-backends",
 "network": "projects/PROJECT_ID/global/networks/NETWORK",
 "sourceRanges": [
   "10.129.0.0/23",
   "10.130.0.0/23"
 ],
 "targetTags": [
   "load-balanced-backend"
 ],
 "allowed": [
   {
     "IPProtocol": "tcp",
     "ports": [
       "80"
     ]
   },
 {
     "IPProtocol": "tcp",
     "ports": [
       "443"
     ]
   },
   {
     "IPProtocol": "tcp",
     "ports": [
       "8080"
     ]
   }
 ],
 "direction": "INGRESS"
}

Consola

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

   Ir a Plantillas de instancia

   1. Haz clic en Crear plantilla de instancia.
   2. En Nombre, escribe gil4-backendeast1-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.
   4. Haz clic en Advanced options (Opciones avanzadas).
   5. Haga clic en Redes y configure los siguientes campos:
      1. En Etiquetas de red, introduce allow-ssh y load-balanced-backend.
      2. En Interfaces de red, selecciona lo siguiente:
         • Red: NETWORK
         • Subred: SUBNET_B

   6. Haz clic en Gestión. Introduce 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://169.254.169.254/computeMetadata/v1/instance/name)"
      echo "Page served from: $vm_hostname" | \
      tee /var/www/html/index.html
      systemctl restart apache2
      

   7. Haz clic en Crear.

   8. Haz clic en Crear plantilla de instancia.

   9. En Nombre, escribe gil4-backendwest1-template.

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

   11. Haz clic en Advanced options (Opciones avanzadas).

   12. Haga clic en Redes y configure los siguientes campos:

       1. En Etiquetas de red, introduce allow-ssh y load-balanced-backend.
       2. En Interfaces de red, selecciona lo siguiente:
          • Red: NETWORK
          • Subred: SUBNET_A

   13. Haz clic en Gestión. Introduce 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://169.254.169.254/computeMetadata/v1/instance/name)"
       echo "Page served from: $vm_hostname" | \
       tee /var/www/html/index.html
       systemctl restart apache2
       

   14. Haz clic en Crear.

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

   Ir a Grupos de instancias

   1. Haz clic en Crear grupo de instancias.
   2. Selecciona 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 gl4-ilb-miga.
   4. En Ubicación, selecciona Una sola zona.
   5. En Región, selecciona REGION_A.
   6. En Zona, selecciona ZONE_A.
   7. En Plantilla de instancia, selecciona gil4-backendwest1-template.

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

      En este ejemplo, especifica las siguientes opciones en 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 Autoescalado 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.

   10. Haz clic en Crear grupo de instancias.

   11. Selecciona 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.

   12. En Nombre, escribe gl4-ilb-migb.

   13. En Ubicación, selecciona Una sola zona.

   14. En Región, selecciona REGION_B.

   15. En Zona, selecciona ZONE_B.

   16. En Plantilla de instancia, selecciona gil4-backendeast1-template.

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

       En este ejemplo, especifica las siguientes opciones en 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.

   18. Haz clic en Crear.

gcloud

Las instrucciones de la CLI de gcloud de esta guía presuponen que usas Cloud Shell u otro entorno con bash instalado.

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

   gcloud compute instance-templates create gil4-backendwest1-template \
      --region=REGION_A \
      --network=NETWORK \
      --subnet=SUBNET_A \
      --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://169.254.169.254/computeMetadata/v1/instance/name)"
        echo "Page served from: $vm_hostname" | \
        tee /var/www/html/index.html
        systemctl restart apache2'
   

   gcloud compute instance-templates create gil4-backendeast1-template \
       --region=REGION_B \
       --network=NETWORK \
       --subnet=SUBNET_B \
       --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://169.254.169.254/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 gestionado en la zona con el comando gcloud compute instance-groups managed create.

   gcloud compute instance-groups managed create gl4-ilb-miga \
       --zone=ZONE_A \
       --size=2 \
       --template=gil4-backendwest1-template
   

   gcloud compute instance-groups managed create gl4-ilb-migb \
       --zone=ZONE_B \
       --size=2 \
       --template=gil4-backendeast1-template
   

API

Crea la plantilla de instancia con el método instanceTemplates.insert y sustituye PROJECT_ID por el ID de tu proyecto.

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

{
  "name":"gil4-backendwest1-template",
  "properties":{
     "machineType":"e2-standard-2",
     "tags":{
       "items":[
         "allow-ssh",
         "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\n
            vm_hostname=\"$(curl -H \"Metadata-Flavor:Google\"
            \\\nhttp://169.254.169.254/computeMetadata/v1/instance/name)\"\n
            echo \"Page served from: $vm_hostname\" | \\\ntee
            /var/www/html/index.html\nsystemctl restart apache2"
          }
        ]
     },
     "networkInterfaces":[
       {
         "network":"projects/PROJECT_ID/global/networks/NETWORK",
         "subnetwork":"regions/REGION_A/subnetworks/SUBNET_A",
         "accessConfigs":[
           {
             "type":"ONE_TO_ONE_NAT"
           }
         ]
       }
     ],
     "disks":[
       {
         "index":0,
         "boot":true,
         "initializeParams":{
           "sourceImage":"projects/debian-cloud/global/images/family/debian-12"
         },
         "autoDelete":true
       }
     ]
  }
}

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

{
  "name":"gil4-backendeast1-template",
  "properties":{
     "machineType":"e2-standard-2",
     "tags":{
       "items":[
         "allow-ssh",
         "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\n
            vm_hostname=\"$(curl -H \"Metadata-Flavor:Google\"
            \\\nhttp://169.254.169.254/computeMetadata/v1/instance/name)\"\n
            echo \"Page served from: $vm_hostname\" | \\\ntee
            /var/www/html/index.html\nsystemctl restart apache2"
          }
        ]
     },
     "networkInterfaces":[
       {
         "network":"projects/PROJECT_ID/global/networks/NETWORK",
         "subnetwork":"regions/REGION_B/subnetworks/SUBNET_B",
         "accessConfigs":[
           {
             "type":"ONE_TO_ONE_NAT"
           }
         ]
       }
     ],
     "disks":[
       {
         "index":0,
         "boot":true,
         "initializeParams":{
           "sourceImage":"projects/debian-cloud/global/images/family/debian-12"
         },
         "autoDelete":true
       }
     ]
  }
}

Crea un grupo de instancias gestionadas en cada zona con el método instanceGroupManagers.insert. Sustituye PROJECT_ID por el ID de tu proyecto.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/{zone}/instanceGroupManagers

{
  "name": "gl4-ilb-miga",
  "zone": "projects/PROJECT_ID/zones/ZONE_A",
  "instanceTemplate": "projects/PROJECT_ID/global/instanceTemplates/gil4-backendwest1-template",
  "baseInstanceName": "gl4-ilb-miga",
  "targetSize": 2
}

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/{zone}/instanceGroupManagers

{
  "name": "gl4-ilb-migb",
  "zone": "projects/PROJECT_ID/zones/ZONE_A",
  "instanceTemplate": "projects/PROJECT_ID/global/instanceTemplates/gil4-backendwest1-template",
  "baseInstanceName": "gl4-ilb-migb",
  "targetSize": 2
}

Consola

Iniciar la configuración

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 red (TCP/UDP/SSL) y haz clic en Siguiente.
4. En Proxy o pasarela, selecciona Balanceador de carga de proxy y haz clic en Siguiente.
5. En Público o interno, selecciona Interno y haz clic en Siguiente.
6. En Implementación en una sola región o en varias regiones, selecciona La mejor opción para cargas de trabajo entre regiones y haz clic en Siguiente.
7. Haz clic en Configurar.

Configuración básica

1. Asigna un nombre al balanceador de carga.
2. En Red, selecciona NETWORK.

Configurar el frontend con dos reglas de reenvío

1. Haz clic en Configuración de frontend.
1. Asigne un nombre a la regla de reenvío.
2. En la lista Región de la subred, selecciona REGION_A.
   

   Reservar una subred de solo proxy

3. En la lista Subred, selecciona SUBNET_A.
4. En la lista Dirección IP, haz clic en Crear dirección IP. Se abrirá la página Reservar una dirección IP interna estática.
• Asigna un nombre a la dirección IP estática.
• En la lista Dirección IP estática, selecciona Permitirme elegir.
• En el campo Dirección IP personalizada, introduce 10.1.2.99.
• Selecciona Reservar.
2. Haz clic en Listo.
3. Para añadir la segunda regla de reenvío, haz clic en Añadir IP y puerto de frontend.
1. Asigne un nombre a la regla de reenvío.
2. En la lista Región de la subred, selecciona REGION_B.
   

   Reservar una subred de solo proxy

3. En la lista Subred, selecciona SUBNET_B.
4. En la lista Dirección IP, haz clic en Crear dirección IP. Se abrirá la página Reservar una dirección IP interna estática.
• Asigna un nombre a la dirección IP estática.
• En la lista Dirección IP estática, selecciona Permitirme elegir.
• En el campo Dirección IP personalizada, introduce 10.1.3.99.
• Selecciona Reservar.
4. Haz clic en Listo.

1. Haz clic en Configuración de backend.
2. En la lista Crear o seleccionar servicios de backend, haz clic en Crear un servicio de backend.
3. Asigna un Nombre al servicio de backend.
4. En Protocolo, selecciona TCP.
5. En Puerto con nombre, introduce http.
6. En la lista Tipo de backend, selecciona Grupo de instancias.
7. En la sección Nuevo backend:
• En la lista Grupo de instancias, selecciona gl4-ilb-miga en REGION_A.
• Define Port numbers (Transferir números) en 80.
• Haz clic en Listo.
• Para añadir otro backend, haz clic en Añadir backend.
• En la lista Grupo de instancias, selecciona gl4-ilb-migb en REGION_B.
• Define Port numbers (Transferir números) en 80.
• Haz clic en Listo.
8. En la lista Comprobación del estado, haga clic en Crear una comprobación del estado.
• En el campo Name (Nombre), introduce global-http-health-check.
• Define Protocol (Protocolo) como HTTP.
• Define Puerto como 80.
• Haz clic en Guardar.

Revisar la configuración

1. Haz clic en Revisar y finalizar.
2. Revisa los ajustes de configuración de tu balanceador de carga.
3. Haz clic en Crear.

gcloud

1. Define la comprobación del estado TCP con el comando gcloud compute health-checks create tcp.

   gcloud compute health-checks create tcp global-health-check \
      --use-serving-port \
      --global
   

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

   gcloud compute backend-services create gl4-gilb-backend-service \
     --load-balancing-scheme=INTERNAL_MANAGED \
     --protocol=TCP \
     --enable-logging \
     --logging-sample-rate=1.0 \
     --health-checks=global-health-check \
     --global-health-checks \
     --global
   

3. Añade backends al servicio de backend con el comando gcloud compute backend-services add-backend.

   gcloud compute backend-services add-backend gl4-gilb-backend-service \
     --balancing-mode=CONNECTION \
     --max-connections=50 \
     --instance-group=gl4-ilb-miga \
     --instance-group-zone=ZONE_A \
     --global
   

   gcloud compute backend-services add-backend gl4-gilb-backend-service \
     --balancing-mode=CONNECTION \
     --max-connections=50 \
     --instance-group=gl4-ilb-migb \
     --instance-group-zone=ZONE_B \
     --global
   

4. Crea el proxy de destino.

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

   gcloud compute target-tcp-proxies create gilb-tcp-proxy \
     --backend-service=gl4-gilb-backend-service \
     --global
   

5. Crea dos reglas de reenvío: una con una IP virtual (10.1.2.99) en REGION_B y otra con una IP virtual (10.1.3.99) en REGION_A. Para obtener más información, consulta Reservar una dirección IPv4 interna estática.

   En el caso de las redes personalizadas, debes hacer referencia a la subred en la regla de reenvío. Ten en cuenta que se trata de la subred de la VM, no de la subred del proxy.

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

   gcloud compute forwarding-rules create gil4forwarding-rule-a \
     --load-balancing-scheme=INTERNAL_MANAGED \
     --network=NETWORK \
     --subnet=SUBNET_A \
     --subnet-region=REGION_A \
     --address=10.1.2.99 \
     --ports=80 \
     --target-tcp-proxy=gilb-tcp-proxy \
     --global
   

   gcloud compute forwarding-rules create gil4forwarding-rule-b \
     --load-balancing-scheme=INTERNAL_MANAGED \
     --network=NETWORK \
     --subnet=SUBNET_B \
     --subnet-region=REGION_B \
     --address=10.1.3.99 \
     --ports=80 \
     --target-tcp-proxy=gilb-tcp-proxy \
     --global
   

API

Para crear la comprobación del estado, haz una solicitud POST al método healthChecks.insert y sustituye PROJECT_ID por el ID de tu proyecto.

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

{
"name": "global-health-check",
"type": "TCP",
"httpHealthCheck": {
  "portSpecification": "USE_SERVING_PORT"
}
}

Crea el servicio de backend global haciendo una solicitud POST al método backendServices.insert y sustituyendo PROJECT_ID por el ID de tu proyecto.

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

{
"name": "gl4-gilb-backend-service",
"backends": [
  {
    "group": "projects/PROJECT_ID/zones/ZONE_A/instanceGroups/gl4-ilb-miga",
    "balancingMode": "CONNECTION"
  },
  {
    "group": "projects/PROJECT_ID/zones/ZONE_B/instanceGroups/gl4-ilb-migb",
    "balancingMode": "CONNECTION"
  }
],
"healthChecks": [
  "projects/PROJECT_ID/regions/global/healthChecks/global-health-check"
],
"loadBalancingScheme": "INTERNAL_MANAGED"
}

Crea el proxy TCP de destino haciendo una solicitud POST al método targetTcpProxies.insert y sustituyendo PROJECT_ID por el ID de tu proyecto.

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

{
"name": "l4-ilb-proxy",
}

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

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

{
"name": "gil4forwarding-rule-a",
"IPAddress": "10.1.2.99",
"IPProtocol": "TCP",
"portRange": "80-80",
"target": "projects/PROJECT_ID/global/targetTcpProxies/l4-ilb-proxy",
"loadBalancingScheme": "INTERNAL_MANAGED",
"subnetwork": "projects/PROJECT_ID/regions/REGION_A/subnetworks/SUBNET_A",
"network": "projects/PROJECT_ID/global/networks/NETWORK",
"networkTier": "PREMIUM"
}

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

{
"name": "gil4forwarding-rule-b",
"IPAddress": "10.1.3.99",
"IPProtocol": "TCP",
"portRange": "80-80",
"target": "projects/PROJECT_ID/global/targetTcpProxies/l4-ilb-proxy",
"loadBalancingScheme": "INTERNAL_MANAGED",
"subnetwork": "projects/PROJECT_ID/regions/REGION_B/subnetworks/SUBNET_B",
"network": "projects/PROJECT_ID/global/networks/NETWORK",
"networkTier": "PREMIUM"
}

Para crear la regla de reenvío, haz una solicitud POST al método globalForwardingRules.insert y sustituye PROJECT_ID por el ID de tu proyecto.

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

{
"name": "gil4forwarding-rule-a",
"IPAddress": "10.1.2.99",
"IPProtocol": "TCP",
"portRange": "80-80",
"target": "projects/PROJECT_ID/global/targetTcpProxies/l4-ilb-proxy",
"loadBalancingScheme": "INTERNAL_MANAGED",
"subnetwork": "projects/PROJECT_ID/regions/REGION_A/subnetworks/SUBNET_A",
"network": "projects/PROJECT_ID/global/networks/NETWORK",
"networkTier": "PREMIUM"
}

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

{
"name": "gil4forwarding-rule-b",
"IPAddress": "10.1.3.99",
"IPProtocol": "TCP",
"portRange": "80-80",
"target": "projects/PROJECT_ID/global/targetTcpProxies/l4-ilb-proxy",
"loadBalancingScheme": "INTERNAL_MANAGED",
"subnetwork": "projects/PROJECT_ID/regions/REGION_B/subnetworks/SUBNET_B",
"network": "projects/PROJECT_ID/global/networks/NETWORK",
"networkTier": "PREMIUM"
}

Consola

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

   Ir a Balanceo de carga

2. Haz clic en editEditar en el balanceador de carga.

3. Haz clic en Configuración de frontend.

4. Cambia el valor del campo Protocolo de proxy a Activado.

5. Haz clic en Update (Actualizar) para guardar los cambios.

gcloud

En el siguiente comando, edita el campo --proxy-header y asigna el valor NONE o PROXY_V1, según lo que necesites.

gcloud compute target-ssl-proxies update int-tcp-target-proxy \
    --proxy-header=[NONE | PROXY_V1]

gcloud

gcloud compute addresses create SHARED_IP_ADDRESS_NAME \
    --region=REGION \
    --subnet=SUBNET_NAME \
    --purpose=SHARED_LOADBALANCER_VIP

Consola

Para habilitar la afinidad de sesión de IP de cliente, sigue estos pasos:

1. En la Google Cloud consola, ve a la página Balanceo de carga.
   Ve a Balanceo de carga.
2. Haz clic en Back-ends.
3. Haz clic en el nombre del servicio de backend que has creado para este ejemplo y, a continuación, en Editar.
4. En la página Detalles del servicio backend, haz clic en Configuración avanzada.
5. En Afinidad de sesión, seleccione IP de cliente en el menú.
6. Haz clic en Actualizar.

gcloud

Usa el siguiente comando de gcloud para actualizar el servicio de backend BACKEND_SERVICE y especificar la afinidad de sesión de la IP del cliente:

gcloud compute backend-services update BACKEND_SERVICE \
    --global \
    --session-affinity=CLIENT_IP