Esta página foi traduzida pela API Cloud Translation.

Balanceamento de carga de rede ponderada por instância

1. Introdução

É possível configurar um balanceador de carga de rede para distribuir o tráfego entre as instâncias de back-end do balanceador com base nos pesos informados por uma verificação de integridade HTTP usando o balanceamento de carga ponderado.

O balanceamento de carga ponderado requer que você configure estes dois itens:

Defina a política do balanceador de carga de localidade (localityLbPolicy) do serviço de back-end como WEIGHTED_MAGLEV.
Configure o serviço de back-end com uma verificação de integridade HTTP/HTTP2/HTTPS. As respostas da verificação de integridade HTTP precisam conter um campo de cabeçalho de resposta HTTP personalizado X-Load-Balancing-Endpoint-Weight para especificar os pesos com valores inteiros de 0 a 1.000 em representação decimal para cada instância de back-end.

Se você usar o mesmo grupo de instâncias como back-end para vários balanceadores de carga de rede baseados em serviços de back-end com balanceamento de carga ponderado, recomendamos usar um caminho de solicitação exclusivo para cada verificação de integridade do serviço de back-end. Para mais informações, consulte Critérios de sucesso para verificações de integridade HTTP, HTTPS e HTTP/2.

A verificação de integridade HTTP precisa retornar uma resposta HTTP 200 (OK) para que as verificações sejam aprovadas e a instância de back-end seja considerada íntegra. Em situações em que todas as instâncias de back-end passam nas verificações de integridade e retornam X-Load-Balancing-Endpoint-Weight com peso zero, o balanceador de carga distribui novas conexões entre os back-ends íntegros, tratando-os com o mesmo peso. O balanceador de carga também pode distribuir novas conexões entre back-ends não íntegros. Para mais informações, consulte Distribuição de tráfego.

Para ver exemplos de balanceamento de carga ponderado, consulte Seleção de back-end e rastreamento de conexão.

O balanceamento de carga ponderado pode ser usado nos seguintes cenários:

Se algumas conexões processarem mais dados do que outras ou se algumas conexões ficarem mais tempo do que outras, a distribuição da carga do back-end pode ficar desigual. Ao sinalizar um peso por instância mais baixo, uma instância com alta carga pode reduzir a participação de novas conexões, enquanto continua atendendo as conexões atuais.
Se um back-end estiver sobrecarregado e a atribuição de mais conexões puder interromper as conexões existentes, ele não atribuirá peso zero a si mesmo. Ao sinalizar o peso zero, uma instância de back-end deixa de atender novas conexões, mas continua a atender as atuais.
Se um back-end estiver drenando conexões existentes antes da manutenção, ele atribuirá peso zero a si mesmo. Ao sinalizar o peso zero, a instância de back-end deixa de atender novas conexões, mas continua a atender as atuais.

O que você vai aprender

Como configurar um balanceador de carga de rede para distribuir o tráfego entre as instâncias de back-end do balanceador com base nos pesos informados por uma verificação de integridade HTTP usando o balanceamento de carga ponderado.

Configuração de ambiente autoguiada

Faça login no Console do Google Cloud e crie um novo projeto ou reutilize um existente. Crie uma conta do Gmail ou do Google Workspace, se ainda não tiver uma.

O Nome do projeto é o nome de exibição para os participantes do projeto. É uma string de caracteres não usada pelas APIs do Google É possível atualizar o local a qualquer momento.
O ID do projeto precisa ser exclusivo em todos os projetos do Google Cloud e não pode ser mudado após a definição. O console do Cloud gera automaticamente uma string exclusiva. Em geral, não importa o que seja. Na maioria dos codelabs, é necessário fazer referência ao ID do projeto, normalmente identificado como PROJECT_ID. Se você não gostar do ID gerado, crie outro aleatório. Se preferir, teste o seu e confira se ele está disponível. Ele não pode ser mudado após essa etapa e permanece durante o projeto.
Para sua informação, há um terceiro valor, um Número do projeto, que algumas APIs usam. Saiba mais sobre esses três valores na documentação.

Em seguida, ative o faturamento no console do Cloud para usar os recursos/APIs do Cloud. A execução deste codelab não será muito cara, se tiver algum custo. Para encerrar os recursos e evitar cobranças além deste tutorial, exclua os recursos criados ou o projeto inteiro. Novos usuários do Google Cloud estão qualificados para o programa de US$ 300 de avaliação sem custos.

Inicie o Cloud Shell

Embora o Google Cloud e o Spanner possam ser operados remotamente do seu laptop, neste codelab usaremos o Google Cloud Shell, um ambiente de linha de comando executado no Cloud.

No Console do Google Cloud, clique no ícone do Cloud Shell na barra de ferramentas superior à direita:

O provisionamento e a conexão com o ambiente levarão apenas alguns instantes para serem concluídos: Quando o processamento for concluído, você verá algo como:

Essa máquina virtual contém todas as ferramentas de desenvolvimento necessárias. Ela oferece um diretório principal persistente de 5 GB, além de ser executada no Google Cloud. Isso aprimora o desempenho e a autenticação da rede. Neste codelab, todo o trabalho pode ser feito com um navegador. Você não precisa instalar nada.

2. Iniciar configuração

O codelab exige um único projeto.

Neste tutorial, você cria um grupo de instâncias com três instâncias de VM e atribui pesos a cada uma delas. Crie uma verificação de integridade HTTP para informar os pesos das instâncias de back-end. O balanceador de carga de rede ponderado é ativado no serviço de back-end com a política de balanceador de carga de localidade como WEIGHTED_MAGLEV.

Antes de começar

Leia a Visão geral do balanceamento de carga de rede externa baseado em serviço de back-end.
Instale a Google Cloud CLI. Para uma visão geral completa da ferramenta, consulte a visão geral da CLI gcloud. Encontre os comandos relacionados ao balanceamento de carga na referência da API e da CLI gcloud. Se você ainda não executou a CLI do Google Cloud, primeiro execute gcloud init para autenticar.
Ativar a API Compute.

gcloud services enable compute.googleapis.com

Observação:não é possível usar o console do Google Cloud para configurar a política do balanceador de carga de localidade e atribuir pesos a instâncias de VM. Use a Google Cloud CLI.

Criar regras de firewall, rede e sub-redes VPC

Crie uma rede VPC, uma sub-rede e regras de firewall de entrada para permitir conexões com as VMs de back-end do balanceador de carga.

Crie uma rede e uma sub-rede VPC. 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:

NETWORK_NAME: o nome da rede VPC a ser criada.
SUBNET_NAME: o nome da sub-rede a ser criada.

Crie uma regra de firewall de entrada permitida para permitir que os pacotes enviados para as portas TCP 80 e 443 de destino sejam entregues às VMs de back-end. Neste exemplo, a regra de firewall permite conexões de qualquer endereço IP de origem. A regra de firewall se aplica a VMs com a tag 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 ser criada.

Criar instâncias de VM e atribuir pesos

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

Configure três instâncias de VM de back-end para retornar os pesos no cabeçalho X-Load-Balancing-Endpoint-Weight com respostas HTTP. Para este tutorial, configure uma instância de back-end para informar um peso de zero, uma segunda instância de back-end para informar um peso de 100 e uma terceira instância de back-end para informar 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-10 \
  --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-10 \
  --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-10 \
  --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'

Criar um grupo de instâncias

Neste tutorial, você fornece instruções para criar um grupo de instâncias não gerenciadas contendo todas as três instâncias de VM(instance-0, instance-100, and 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 a ser criado.

Criar uma verificação de integridade HTTP

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

Para criar a verificação de integridade 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 integridade HTTP a ser criada.

Criar serviço de back-end

Confira no exemplo a seguir como 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 integridade 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 ser criado.

Adicione o grupo de instâncias principal 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

Reservar 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 ser criado. Use o comando compute addresses describe para ver o resultado. Anote o endereço IP externo estático reservado (IP_ADDRESS').

gcloud compute addresses describe ADDRESS_NAME

Crie uma regra de encaminhamento usando o endereço IP externo regional reservado "IP_ADDRESS". Conecte 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 ser criada. IP_ADDRESS: o endereço IP a ser atribuído à instância. Use o endereço IP externo estático reservado, não o nome do endereço.

Verificar pesos de back-end usando a API de serviço de back-end

Verifique se os pesos do back-end são informados corretamente à verificação de integridade de HTTP.

Para receber pesos de back-end (junto com os status de integridade) de um serviço de back-end, execute o comando gcloud compute backend-services get-health :

gcloud compute backend-services get-health HTTP_HEALTH_CHECK_NAME \
  --region=us-central1

A saída será semelhante a esta:

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