Esta página se ha traducido con Cloud Translation API.

Configurar el balanceo de carga ponderado

En esta guía se explica cómo crear una implementación de balanceador de carga de red de pases externo con pesos para cada instancia de máquina virtual (VM) mediante un servicio de backend regional.

En este tutorial, crearás un grupo de instancias con tres instancias de VM y asignarás pesos a cada instancia. Crea una comprobación del estado de HTTP para registrar los pesos de las instancias de backend. El balanceo de carga ponderado está habilitado en el servicio de backend con la política de balanceo de carga según ubicación como WEIGHTED_MAGLEV.

Antes de empezar

Consulta la descripción general de los balanceadores de carga de red de paso a través externos basados en servicios de backend.
Instala Google Cloud CLI. Para obtener una descripción general completa de la herramienta, consulta la información general sobre la CLI de gcloud. Puedes encontrar comandos relacionados con el balanceo de carga en la referencia de la API y de la CLI de gcloud.

Si no has ejecutado la CLI de Google Cloud anteriormente, ejecuta primero gcloud init para autenticarte.

Habilita la API Compute.

gcloud services enable compute.googleapis.com

Crear una red de VPC, subredes y reglas de cortafuegos

Crea una red de VPC, una subred y reglas de cortafuegos de entrada para permitir las conexiones a las VMs de backend de tu balanceador de carga.

Crea una red de VPC y una subred.

a. Para crear la red de VPC, ejecuta el comando gcloud compute networks create:
```
gcloud compute networks create NETWORK_NAME --subnet-mode custom
```
b. En este ejemplo, el intervalo de direcciones IPv4 principal de la subred es 10.10.0.0/24. Para crear la subred, ejecuta el comando gcloud compute networks subnets create:
```
gcloud compute networks subnets create SUBNET_NAME \
  --network=NETWORK_NAME \
  --range=10.10.0.0/24 \
  --region=us-central1
```
Haz los cambios siguientes:
- NETWORK_NAME: nombre de la red de VPC que se va a crear.
- SUBNET_NAME: el nombre de la subred que se va a crear.
Crea una regla de cortafuegos de entrada para permitir que los paquetes enviados a los puertos TCP 80 y 443 de destino se entreguen a las VMs de backend. En este ejemplo, la regla de cortafuegos permite conexiones desde cualquier dirección IP de origen. La regla de cortafuegos se aplica a las VMs con la etiqueta de red network-lb-tag.

Para crear la regla de cortafuegos, ejecuta el comando gcloud compute firewall-rules create:
```
gcloud compute firewall-rules create FIREWALL_RULE_NAME \
   --direction=INGRESS \
   --priority=1000 \
   --network=NETWORK_NAME \
   --action=ALLOW \
   --rules=tcp:80,tcp:443 \
   --source-ranges=0.0.0.0/0 \
   --target-tags=network-lb-tag
```
Sustituye FIREWALL_RULE_NAME por el nombre de la regla de firewall que quieres crear.

Crear instancias de VM y asignar pesos

Crea tres instancias de VM y asigna pesos:

Configura tres instancias de VM de backend para que devuelvan los pesos en el encabezado X-Load-Balancing-Endpoint-Weight con respuestas HTTP. En este tutorial, configurará una instancia de backend para que registre un peso de cero, una segunda instancia de backend para que registre un peso de 100 y una tercera instancia de backend para que registre un peso de 900.

Para crear las instancias, ejecuta el comando gcloud compute instances create:

gcloud compute instances create instance-0 \
  --zone=us-central1-a \
  --tags=network-lb-tag \
  --image-family=debian-12 \
  --image-project=debian-cloud \
  --subnet=SUBNET_NAME \
  --metadata=load-balancing-weight=0,startup-script='#! /bin/bash
  apt-get update
  apt-get install apache2 -y
  ln -sr /etc/apache2/mods-available/headers.load /etc/apache2/mods-enabled/headers.load
  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
  lb_weight="$(curl -H "Metadata-Flavor:Google" \
  http://169.254.169.254/computeMetadata/v1/instance/attributes/load-balancing-weight)"
  echo "Header set X-Load-Balancing-Endpoint-Weight \"$lb_weight\"" | \
  tee /etc/apache2/conf-enabled/headers.conf
  systemctl restart apache2'

gcloud compute instances create instance-100 \
  --zone=us-central1-a \
  --tags=network-lb-tag \
  --image-family=debian-12 \
  --image-project=debian-cloud \
  --subnet=SUBNET_NAME \
  --metadata=load-balancing-weight=100,startup-script='#! /bin/bash
  apt-get update
  apt-get install apache2 -y
  ln -sr /etc/apache2/mods-available/headers.load /etc/apache2/mods-enabled/headers.load
  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
  lb_weight="$(curl -H "Metadata-Flavor:Google" \
  http://169.254.169.254/computeMetadata/v1/instance/attributes/load-balancing-weight)"
  echo "Header set X-Load-Balancing-Endpoint-Weight \"$lb_weight\"" | \
  tee /etc/apache2/conf-enabled/headers.conf
  systemctl restart apache2'

gcloud compute instances create instance-900 \
  --zone=us-central1-a \
  --tags=network-lb-tag \
  --image-family=debian-12 \
  --image-project=debian-cloud \
  --subnet=SUBNET_NAME \
  --metadata=load-balancing-weight=900,startup-script='#! /bin/bash
    apt-get update
    apt-get install apache2 -y
    ln -sr /etc/apache2/mods-available/headers.load /etc/apache2/mods-enabled/headers.load
    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
    lb_weight="$(curl -H "Metadata-Flavor:Google" \
    http://169.254.169.254/computeMetadata/v1/instance/attributes/load-balancing-weight)"
    echo "Header set X-Load-Balancing-Endpoint-Weight \"$lb_weight\"" | \
    tee /etc/apache2/conf-enabled/headers.conf
    systemctl restart apache2'

Crear un grupo de instancias

En este tutorial, se proporcionan instrucciones para crear un grupo de instancias no gestionado que contenga las tres instancias de VM(instance-0, instance-100 y instance-900).

Para crear el grupo de instancias, ejecuta el comando gcloud compute instance-groups unmanaged create:

gcloud compute instance-groups unmanaged create INSTANCE_GROUP \     
  --zone=us-central1-a

gcloud compute instance-groups unmanaged add-instances INSTANCE_GROUP \
  --zone=us-central1-a \
  --instances=instance-0,instance-100,instance-900

Sustituye INSTANCE_GROUP por el nombre del grupo de instancias que quieras crear.

Crear una comprobación del estado de HTTP

En este tutorial, se proporcionan instrucciones para crear una comprobación del estado de HTTP que lea la respuesta HTTP que contiene el peso de la VM backend."

Para crear la comprobación del estado de HTTP, ejecuta el comando gcloud compute health-checks create:
```
gcloud compute health-checks create http HTTP_HEALTH_CHECK_NAME \
  --region=us-central1
```
Sustituye HTTP_HEALTH_CHECK_NAME por el nombre de la comprobación del estado de HTTP que quieras crear.

Crear un servicio backend

En el siguiente ejemplo se explica cómo crear un servicio de backend externo regional configurado para usar el balanceo de carga ponderado.

Crea un servicio de backend con la comprobación del estado de HTTP y define la política del balanceador de carga de localidad en WEIGHTED_MAGLEV.
- Para crear el servicio de backend, ejecuta el comando gcloud compute backend-services create:
```
gcloud compute backend-services create BACKEND_SERVICE_NAME \
  --load-balancing-scheme=external \
  --protocol=tcp \
  --region=us-central1 \
  --health-checks=HTTP_HEALTH_CHECK_NAME \
  --health-checks-region=us-central1 \
  --locality-lb-policy=WEIGHTED_MAGLEV
```
  Sustituye BACKEND_SERVICE_NAME por el nombre del servicio de backend que quieras crear.

Añade el grupo de instancias al servicio de backend.

Para añadir el grupo de instancias, ejecuta el comando gcloud compute backend-services add-backend:

gcloud compute backend-services add-backend BACKEND_SERVICE_NAME \
  --instance-group=INSTANCE_GROUP \
  --instance-group-zone=us-central1-a \
  --region=us-central1

Reserva una dirección IP externa regional para el balanceador de carga.
- Para reservar una o varias direcciones IP, ejecuta el comando gcloud compute addresses create:
```
gcloud compute addresses create ADDRESS_NAME \
 --region us-central1
```
  Sustituye ADDRESS_NAME por el nombre de la dirección IP que quieras crear.
  
  Usa el comando compute addresses describe para ver el resultado. Anota la dirección IP externa estática reservada (IP_ADDRESS).
```
gcloud compute addresses describe ADDRESS_NAME
```
Crea una regla de reenvío con la dirección IP externa regional reservada IP_ADDRESS. Conecta la regla de reenvío al servicio de backend.
- Para crear la regla de reenvío, ejecuta el gcloud compute forwarding-rules createcomando:
```
gcloud compute forwarding-rules create FORWARDING_RULE \
  --region=us-central1 \
  --ports=80 \
  --address=IP_ADDRESS \
  --backend-service=BACKEND_SERVICE_NAME
```
  Haz los cambios siguientes:
  
  FORWARDING_RULE: el nombre de la regla de reenvío que se va a crear.
  
  IP_ADDRESS: la dirección IP que se asignará a la instancia. Usa la dirección IP externa estática reservada, no el nombre de la dirección.

Verificar los pesos de backend mediante la API de servicio de backend

Verifica que los pesos del backend se comuniquen correctamente a la comprobación del estado HTTP.

Para obtener los pesos de backend (junto con los estados de salud) de un servicio de backend, ejecuta el comando gcloud compute backend-services get-health:
```
gcloud compute backend-services get-health BACKEND_SERVICE_NAME \
  --region=us-central1
```

El resultado es el siguiente:

backend: https://www.googleapis.com/compute/projects/project-name/{project}/zones/us-central1-a/instanceGroups/{instance-group-name}
status:
  healthStatus:
  - forwardingRule: https://www.googleapis.com/compute/projects/{project}/regions/us-central1/forwardingRules/{firewall-rule-name}
    forwardingRuleIp: 34.135.46.66
    healthState: HEALTHY
    instance: https://www.googleapis.com/compute/projects/{project}/zones/us-central1-a/instances/instance-0
    ipAddress: 10.10.0.5
    port: 80
    weight: '0'
  - forwardingRule: https://www.googleapis.com/compute/projects/{project}/regions/us-central1/forwardingRules/{firewall-rule-name}
    forwardingRuleIp: 34.135.46.66
    healthState: HEALTHY
    instance: https://www.googleapis.com/compute/projects/{project}/zones/us-central1-a/instances/instance-100
    ipAddress: 10.10.0.6
    port: 80
    weight: '100'
  - forwardingRule: https://www.googleapis.com/compute/projects/{project}/regions/us-central1/forwardingRules/{firewall-rule-name}
    forwardingRuleIp: 34.135.46.66
    healthState: HEALTHY
    instance: https://www.googleapis.com/compute/projects/{project}/zones/us-central1-a/instances/instance-900
    ipAddress: 10.10.0.7
    port: 80
    weight: '900'
  kind: compute#backendServiceGroupHealth