Configurar un balanceador de carga de aplicación externo regional 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. En Nombre, escribe lb-network.

4. En la sección Subredes:

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

5. Haz clic en Crear.

gcloud

1. Crea la red 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 de 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. Haz una solicitud POST al método networks.insert y 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": "lb-network",
    "autoCreateSubnetworks": false
   }
   

2. Haz una solicitud POST al método subnetworks.insert y sustituye PROJECT_ID por el ID de tu 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",
   }
   

Consola

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

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

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

Para crear la subred de solo proxy de la 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 sustituye PROJECT_ID por el ID de tu 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"
}

Consola

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

   Ir a reglas de cortafuegos

2. Haz clic en Crear regla de cortafuegos para crear la regla que permita las comprobaciones deGoogle Cloud estado:

   • Nombre: fw-allow-health-check
   • Red: lb-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 de 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.

3. Haz clic en Crear.

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

   • Nombre: fw-allow-proxies
   • Red: lb-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
   • 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.

5. Haz clic en Crear.

gcloud

1. Crea la regla fw-allow-health-check 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-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 carga de aplicaciones externo regional se conecten a tus backends. Asigna a source-ranges los intervalos 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 las reglas de cortafuegos, 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 cortafuegos fw-allow-health-check haciendo una solicitud POST al método firewalls.insert, sustituyendo PROJECT_ID por el ID de tu 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 cortafuegos fw-allow-proxies 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-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"
}

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-xlb-backend-template.
   3. Asegúrate de que 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, introduzca load-balanced-backend.
      2. En Interfaces de red, selecciona lo siguiente:
         • Red: lb-network
         • Subred: backend-subnet

   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://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. Crea un grupo de instancias gestionado. 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 l7-xlb-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-xlb-backend-template.

   8. En Modo de autoescalado, selecciona Activado: añade y quita instancias del grupo.

      Define Número mínimo de instancias como 2 y Número máximo de instancias como 2 o más.

   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 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-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'
   

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

Terraform

Para crear la plantilla de instancia, 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-12"
    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 gestionado, 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 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":"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-12"
          },
          "autoDelete":true
        }
      ]
    }
   }
   

2. Crea un grupo de instancias gestionadas en cada zona con el método instanceGroupManagers.insert, sustituyendo PROJECT_ID por el ID de tu 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
   }
   

Consola

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

   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 Resumen del grupo de instancias, haga clic en Editar edit.

4. Haz clic en Especificar asignación de nombres de puertos.

5. Haz clic en Añadir elemento.

6. En el nombre del puerto, introduce http. En el número de puerto, introduce 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 el ejemplo de grupo de instancias gestionado.

Consola

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

   Ir a Reservar una dirección estática

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

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

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

5. En Type (Tipo), selecciona Regional (Regional).

6. En Region (Región), selecciona us-west1.

7. Deje la opción Adjunto a configurada como Ninguno. Una vez que hayas creado el balanceador de carga, esta dirección IP se adjuntará a la regla de reenvío del balanceador de carga.

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

gcloud

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

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

   Haz los cambios siguientes:

   • ADDRESS_NAME: el nombre que quieras darle a esta dirección.
   • REGION: la región en la que quieres reservar esta dirección. Esta región debe ser la misma que la del balanceador de carga. 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"
}

Para saber cómo aplicar o quitar una configuración de Terraform, consulta Comandos básicos de Terraform.

API

Para crear una dirección IPv4 regional, llama al 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 lo siguiente:

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

Haz los cambios siguientes:

• ADDRESS_NAME: nombre de la dirección
• REGION: el nombre de la región de esta solicitud
• PROJECT_ID: el ID de proyecto de esta solicitud

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 Público (externo) y haz clic en Siguiente.
5. Para la implementación global o en una sola región, 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 el nombre del balanceador de carga, introduce regional-l7-xlb.
2. En Región, selecciona us-west1.
3. En Red, selecciona lb-network.

Reservar una subred de solo proxy

En el caso de un balanceador de carga de aplicación externo regional, reserva una subred de solo proxy:

1. Haz clic en Reservar subred.
2. En Nombre, escribe proxy-only-subnet.
3. En Intervalo de direcciones IP, introduce 10.129.0.0/23.
4. Haz clic en Añadir.

Configurar el frontend

Para HTTP:

1. Haz clic en Configuración de frontend.
2. Asigna el valor l7-xlb-forwarding-rule a Nombre.
3. Define Protocol (Protocolo) como HTTP.
4. Configure Nivel de servicio de red como Estándar.
5. Define Puerto como 80.
6. Selecciona la dirección IP que has creado en Reservar la dirección IP del balanceador de carga.
7. Haz clic en Listo.

En el caso de HTTPS:

1. Haz clic en Configuración de frontend.
2. En el campo Name (Nombre), introduce l7-xlb-forwarding-rule.
3. En el campo Protocol (Protocolo), selecciona HTTPS (includes HTTP/2).
4. Configure Nivel de servicio de red como Estándar.
5. Asegúrate de que el Puerto esté configurado como 443.
6. Selecciona la dirección IP que has creado en Reservar la dirección IP del balanceador de carga.
7. En la lista Certificado, haz lo siguiente:
   1. Si ya tienes un recurso de certificado SSL autogestionado de Compute Engine, selecciona el certificado SSL principal.
   2. Haz clic en Crear certificado.
      1. En el campo Name (Nombre), introduce l7-xlb-cert.
      2. En los campos correspondientes, sube los archivos con formato PEM:
         • Certificado
         • Clave privada
      3. Haz clic en Crear.
8. Opcional: Para añadir certificados además del certificado SSL principal, sigue estos pasos:
   1. Haz clic en Añadir certificado.
   2. Si ya tienes un certificado, selecciónalo en la lista Certificados.
   3. Opcional: Haz clic en Crear un certificado y sigue las instrucciones del paso anterior.

9. Selecciona una política de SSL de la lista Política de SSL. Si quiere crear una política de SSL, siga estos pasos:

   1. En la lista Política de SSL, selecciona Crear política.
   2. Escribe un nombre para la política de SSL.
   3. Seleccione una versión mínima de TLS. El valor predeterminado es TLS 1.0.
   4. Selecciona uno de los perfiles preconfigurados gestionados por Google o un perfil Personalizado que te permita seleccionar funciones SSL de forma individual. Se muestran las secciones Funciones habilitadas y Funciones inhabilitadas.
   5. Haz clic en Guardar.

   Si no has creado ninguna política de SSL, se aplicará una política de SSL predeterminada Google Cloud .

10. Haz clic en Listo.

Configurar 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. Asigna el nombre l7-xlb-backend-service al servicio de backend.
4. En Protocol (Protocolo), selecciona HTTP.
5. En Puerto con nombre, introduce http.
6. En Tipo de backend, seleccione Grupo de instancias.
7. En la sección Nuevo backend, haz lo siguiente:
   1. Define Grupo de instancias como l7-xlb-backend-example.
   2. Define Port numbers (Transferir números) en 80.
   3. En Modo de balanceo, selecciona Utilización.
   4. Haz clic en Listo.
8. En la lista Comprobación del estado, haga clic en Crear una comprobación del estado.
   1. Asigna el valor l7-xlb-basic-check a Nombre.
   2. Define Protocol (Protocolo) como HTTP.
   3. Define Puerto como 80.
   4. Haz clic en Guardar.
9. Haz clic en Crear.

Configurar las reglas de enrutamiento

1. Haz clic en Reglas de enrutamiento.
2. En Modo, selecciona Regla sencilla de host y ruta.
3. Asegúrate de que l7-xlb-backend-service sea el único servicio de backend para cualquier host o ruta sin coincidencia.

Revisar la configuración

1. Haz clic en Revisar y finalizar.
2. Revisa los ajustes de configuración de tu balanceador de carga.
3. Opcional: Haz clic en Código equivalente para ver la solicitud de la API REST que se usará para crear el balanceador de carga.
4. 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-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. Añade 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 URLs 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.

   En HTTP:

   En el caso de un balanceador de carga 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 de Certificate Manager. Utiliza cualquiera de los siguientes métodos para crear certificados con Certificate Manager:

   • Certificados autogestionados regionales. Para obtener información sobre cómo crear y usar certificados regionales autogestionados, consulta Implementar un certificado regional autogestionado. No se admiten mapas de certificados.

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

     Certificate Manager admite los siguientes tipos de certificados regionales gestionados por Google:

     • Certificados regionales gestionados por Google con autorización de DNS por proyecto. Para obtener más información, consulta el artículo sobre cómo desplegar un certificado regional gestionado por Google con autorización de DNS.
     • Certificados privados gestionados por Google regionales con el Servicio de Autoridades de Certificación. Para obtener más información, consulta el artículo sobre cómo implementar un certificado regional gestionado por Google con el Servicio de Autoridades de Certificación.

   Una vez que hayas creado los certificados, adjúntalos directamente al proxy de destino.

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

   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
      

6. Crea 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-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 comprobación del 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 URLs, 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"
}

Para saber cómo aplicar o quitar una configuración de Terraform, consulta Comandos básicos de Terraform.

API

Para crear la comprobación del estado, haz una solicitud POST al método regionHealthChecks.insert, sustituyendo PROJECT_ID por el ID de tu 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"
  }
}

Crea el servicio backend regional haciendo una solicitud POST al método regionBackendServices.insert, sustituyendo PROJECT_ID por el ID de tu 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"
}

Crea el mapa de URLs haciendo una solicitud POST al método regionUrlMaps.insert y sustituyendo PROJECT_ID por el ID de tu 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"
}

Crea el proxy HTTP de destino enviando una solicitud POST al método regionTargetHttpProxies.insert y sustituyendo PROJECT_ID por el ID de tu 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, 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/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",
}

Consola

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

   Ir a Balanceo de carga

2. Selecciona el balanceador de carga que acabas de crear.
3. En la sección Backend, comprueba que las VMs estén en buen estado. La columna Healthy (Saludable) debe estar rellenada, lo que indica que ambas máquinas virtuales están en buen estado (2/2). Si no es así, prueba a volver a cargar la página. La consola Google Cloud puede tardar unos instantes en indicar que las máquinas virtuales están en buen estado. Si los back-ends no están en buen estado al cabo de unos minutos, revisa la configuración del cortafuegos y la etiqueta de red asignada a tus VMs de backend.
4. Una vez que la consola muestre que las instancias de backend están en buen estado, puedes probar el balanceador de carga con un navegador web. Para ello, ve a https://IP_ADDRESS (o http://IP_ADDRESS). Sustituye IP_ADDRESS por la dirección IP del balanceador de carga. Google Cloud
5. Si has usado un certificado autofirmado para probar HTTPS, tu navegador mostrará una advertencia. Debes indicar explícitamente a tu navegador que acepte un certificado autofirmado.
6. Tu navegador debería renderizar una página con contenido que muestre el nombre de la instancia que ha servido la página, junto con su zona (por ejemplo, Page served from: lb-backend-example-xxxx). Si tu navegador no renderiza esta página, revisa los ajustes de configuración de esta guía.

gcloud

Anota la dirección IPv4 que se ha reservado:

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

Puede probar su balanceador de carga con un navegador web. Para ello, vaya a https://IP_ADDRESS (o http://IP_ADDRESS). Sustituya IP_ADDRESS por la dirección IP del balanceador de carga.

Si has usado un certificado autofirmado para probar HTTPS, tu navegador mostrará una advertencia. Debes indicar explícitamente a tu navegador que acepte un certificado autofirmado.

Tu navegador debería renderizar una página con información mínima sobre la instancia de backend. Si tu navegador no renderiza esta página, consulta los ajustes de configuración de esta guía.

Consola

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

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

   Ir a Balanceo de carga

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

3. Haz clic en Back-ends.

4. Haz clic en l7-xlb-backend-service (el nombre del servicio de backend que has creado para este ejemplo) y, a continuación, en Editar.

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

6. En Afinidad de sesión, seleccione el tipo de afinidad de sesión que quiera en el menú.

7. Haz clic en Actualizar.

gcloud

Usa los siguientes comandos para actualizar el servicio de backend 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 definir la afinidad de sesión, haz una solicitud PATCH al método regionBackendServices/patch.

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