Algumas ou todas as informações nesta página podem não se aplicar à Trusted Cloud by S3NS. Consulte o artigo Diferenças em relação ao Google Cloud para mais detalhes.

Esta página foi traduzida pela API Cloud Translation.

Configure o balanceamento de carga ponderado

Este guia fornece instruções para criar uma implementação de balanceador de carga de rede de encaminhamento externo ponderado para cada instância de máquina virtual (VM) através de um serviço de back-end regional.

Neste tutorial, cria um grupo de instâncias com três instâncias de VM e atribui pesos a cada instância. Cria uma verificação de funcionamento de HTTP para comunicar os pesos das instâncias do back-end. O balanceamento de carga ponderado está ativado no serviço de back-end com a política de balanceamento de carga de localidade como WEIGHTED_MAGLEV.

Antes de começar

Leia a vista geral do balanceador de carga de rede de encaminhamento externo baseado em serviços de back-end.
Instale a CLI do Google Cloud. Para uma vista geral completa da ferramenta, consulte a vista geral da CLI gcloud. Pode encontrar comandos relacionados com o equilíbrio de carga na referência da API e da CLI gcloud.

Se não executou o Google Cloud CLI anteriormente, execute primeiro o comando gcloud init para fazer a autenticação.

Ative a API Compute.

gcloud services enable compute.googleapis.com

Crie uma rede VPC, sub-redes e regras de firewall

Crie uma rede VPC, uma sub-rede e regras de firewall de permissão de entrada para permitir ligações às VMs de back-end do seu balanceador de carga.

Crie uma rede de VPC e uma sub-rede.

a. Para criar a rede VPC, execute o comando gcloud compute networks create:
```
gcloud compute networks create NETWORK_NAME --subnet-mode custom
```
b. Neste exemplo, o intervalo de endereços IPv4 principal da sub-rede é 10.10.0.0/24. Para criar a sub-rede, execute o 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
```
Substitua o seguinte:
- NETWORK_NAME: o nome da rede VPC a criar.
- SUBNET_NAME: o nome da sub-rede a criar.
Crie uma regra de firewall de permissão de entrada para permitir que os pacotes enviados para as portas TCP de destino 80 e 443 sejam entregues às VMs de back-end. Neste exemplo, a regra de firewall permite ligações de qualquer endereço IP de origem. A regra de firewall aplica-se a VMs com a etiqueta de rede network-lb-tag.

Para criar a regra de firewall, execute o 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
```
Substitua FIREWALL_RULE_NAME pelo nome da regra de firewall a criar.

Crie instâncias de VM e atribua ponderações

Crie três instâncias de VM e atribua pesos:

Configure três instâncias de VM de back-end para devolver os pesos no cabeçalho X-Load-Balancing-Endpoint-Weight com respostas HTTP. Para este tutorial, vai configurar uma instância de back-end para comunicar um peso de zero, uma segunda instância de back-end para comunicar um peso de 100 e uma terceira instância de back-end para comunicar um peso de 900.

Para criar as instâncias, execute o 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'

Crie um grupo de instâncias

Neste tutorial, fornece instruções para criar um grupo de instâncias não gerido que contenha todas as três instâncias de VM(instance-0, instance-100 e instance-900).

Para criar o grupo de instâncias, execute o 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

Substitua INSTANCE_GROUP pelo nome do grupo de instâncias que quer criar.

Crie uma verificação de funcionamento de HTTP

Neste tutorial, fornece instruções para criar uma verificação de funcionamento de HTTP para ler a resposta HTTP que contém o peso da VM de back-end."

Para criar a verificação de funcionamento de HTTP, execute o comando gcloud compute health-checks create:
```
gcloud compute health-checks create http HTTP_HEALTH_CHECK_NAME \
  --region=us-central1
```
Substitua HTTP_HEALTH_CHECK_NAME pelo nome da verificação de funcionamento de HTTP a criar.

Crie um serviço de back-end

O exemplo seguinte fornece instruções para criar um serviço de back-end externo regional configurado para usar o balanceamento de carga ponderado.

Crie um serviço de back-end com a verificação de funcionamento de HTTP e defina a política do balanceador de carga de localidade como WEIGHTED_MAGLEV.
- Para criar o serviço de back-end, execute o 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
```
  Substitua BACKEND_SERVICE_NAME pelo nome do serviço de back-end a criar.

Adicione o grupo de instâncias ao serviço de back-end.

Para adicionar o grupo de instâncias, execute o 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

Reserve um endereço IP externo regional para o balanceador de carga.
- Para reservar um ou mais endereços IP, execute o comando gcloud compute addresses create:
```
gcloud compute addresses create ADDRESS_NAME \
 --region us-central1
```
  Substitua ADDRESS_NAME pelo nome do endereço IP a criar.
  
  Use o comando compute addresses describe para ver o resultado. Tome nota do endereço IP externo estático reservado (IP_ADDRESS).
```
gcloud compute addresses describe ADDRESS_NAME
```
Crie uma regra de encaminhamento com o endereço IP externo regional reservado IP_ADDRESS. Associe a regra de encaminhamento ao serviço de back-end.
- Para criar a regra de encaminhamento, execute o comando gcloud compute forwarding-rules create:
```
gcloud compute forwarding-rules create FORWARDING_RULE \
  --region=us-central1 \
  --ports=80 \
  --address=IP_ADDRESS \
  --backend-service=BACKEND_SERVICE_NAME
```
  Substitua o seguinte:
  
  FORWARDING_RULE: o nome da regra de encaminhamento a criar.
  
  IP_ADDRESS: o endereço IP a atribuir à instância. Use o endereço IP externo estático reservado e não o nome do endereço.

Valide os pesos do back-end através da API de serviço de back-end

Verifique se os pesos do back-end são comunicados corretamente à verificação do estado HTTP.

Para obter ponderações de back-end (juntamente com os estados de funcionamento) de um serviço de back-end, execute o comando gcloud compute backend-services get-health:
```
gcloud compute backend-services get-health BACKEND_SERVICE_NAME \
  --region=us-central1
```

O resultado é o seguinte:

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