Configurar um balanceador de carga de aplicativo externo global com back-ends de grupos de instâncias de VM

Neste guia de configuração, mostramos como criar um balanceador de carga de aplicativo global externo com um back-end de grupo gerenciado de instâncias do Compute Engine.

Se esse exemplo não corresponder ao caso de uso em questão, consulte uma destas páginas:

Para o Cloud Run, consulte Como configurar um balanceador de carga com o Cloud Run.
Para um exemplo multirregional que inclui configuração de certificado IPv6 e SSL, consulte Como configurar um balanceador de carga HTTPS externo multirregional.
Para um balanceador de carga de aplicativo externo e regional, consulte Como configurar um balanceador de carga de aplicativo externo regional
Se você estiver usando o GKE, o balanceador de carga normalmente será configurado pelo controlador Ingress do Kubernetes. Para mais informações, consulte Como configurar o Ingress para balanceamento de carga externo.

Para conceitos gerais, consulte a Visão geral do balanceador de carga de aplicativo externo.

Se você já for usuário do balanceador de carga clássico do aplicativo, consulte Planejar a migração para o balanceador de carga de aplicativo externo global ao planejar uma nova implantação. com o balanceador de carga de aplicativo externo global.

Para seguir as instruções passo a passo desta tarefa diretamente no console do Google Cloud, clique em Orientação:

Orientações

Topologias do balanceador de carga

Para um balanceador de carga HTTPS, crie a configuração mostrada no diagrama a seguir.

Balanceador de carga de aplicativo externo com um back-end de grupo gerenciado de instâncias (MIG). — **Figura 1.** Balanceador de carga de aplicativo externo com um back-end de grupo gerenciado de instâncias (MIG) (clique para ampliar).

Para um balanceador de carga HTTP, crie a configuração mostrada no diagrama a seguir.

A sequência de eventos nos diagramas é a seguinte:

Um cliente envia uma solicitação de conteúdo para o endereço IPv4 externo definido na regra de encaminhamento.
Para um balanceador de carga HTTPS, a regra de encaminhamento direciona a solicitação para o proxy HTTPS de destino.

Para um balanceador de carga HTTP, a regra de encaminhamento direciona a solicitação para o proxy HTTP de destino.
O proxy de destino usa a regra no mapa de URLs para determinar que o único serviço de back-end receba todas as solicitações.
O balanceador de carga determina que o serviço de back-end tenha apenas um grupo de instâncias e direciona a solicitação para uma instância de máquina virtual (VM) nesse grupo.
A VM exibe o conteúdo solicitado pelo usuário.

Antes de começar

Conclua as etapas a seguir antes de criar o balanceador de carga.

Configurar um recurso de certificado SSL

Para um balanceador de carga HTTPS, crie um recurso de certificado SSL, conforme descrito a seguir:

Recomendamos o uso de um certificado gerenciado pelo Google.

Este exemplo pressupõe que você já tenha um recurso de certificado SSL chamado www-ssl-cert.

Configurar permissões

Para concluir as etapas neste guia, é preciso ter permissão para criar instâncias do Compute Engine, regras de firewall e endereços IP reservados em um projeto. Você precisa ter um papel de proprietário ou editor do projeto ou os seguintes papéis do IAM do Compute Engine.

Tarefa	Papel necessário
Criar instâncias	Administrador de instâncias
Adicionar e remover regras de firewall	Administrador de segurança
Criar componentes do balanceador de carga	Administrador de rede
Criar um projeto (opcional)	Criador do projeto

Para mais informações, consulte estes guias:

Configurar a rede e as sub-redes

Para criar o exemplo de rede e sub-rede, siga estas etapas.

Console

Para oferecer suporte a tráfego IPv4 e IPv6, siga estas etapas:

No Console do Google Cloud, acesse a página Redes VPC.

Acessar redes VPC
Clique em Criar rede VPC.
Digite um Nome para a rede.
Opcional: se você quiser configurar intervalos de endereços de IPv6 internos em sub-redes nesta rede, siga estas etapas:
1. Em Intervalo de IPv6 interno de ULA da rede VPC, selecione Ativado.
2. Em Alocar intervalo de IPv6 interno, selecione Automático ou Manualmente.
  
  Se você selecionar Manualmente, insira um intervalo /48 no intervalo fd20::/20. Se o intervalo estiver em uso, você precisará fornecer um intervalo diferente.
Em Modo de criação da sub-rede, escolha Personalizado.
Na seção Nova sub-rede, configure os seguintes campos:
1. No campo Nome, digite um nome para a sub-rede.
2. No campo Região, selecione uma região.
3. Em Tipo de pilha de IP, selecione IPv4 e IPv6 (pilha dupla).
4. No campo Intervalo de endereços IP, insira um intervalo de endereços IP. Esse é o intervalo IPv4 principal da sub-rede.
  
  É possível configurar um intervalo IPv4 de endereços para a sub-rede, mas não o intervalo de endereços IPv6 para sub-rede. O Google fornece um bloco CIDR IPv6 de tamanho fixo (/64).
5. Em Tipo de acesso IPv6, selecione Externo.
Clique em Concluído.
Clique em Criar.

Para aceitar apenas ao tráfego IPv4, siga estas etapas:

No Console do Google Cloud, acesse a página Redes VPC.

Acessar redes VPC
Clique em Criar rede VPC.
No campo Nome, insira um nome para a rede.
Em Modo de criação da sub-rede, escolha Personalizado.
Na seção Nova sub-rede, configure os seguintes campos:
1. No campo Nome, digite um nome para a sub-rede.
2. No campo Região, selecione uma região.
3. Em Tipo de pilha de IP, selecione IPv4 (pilha única).
4. No campo Intervalo de endereços IP, insira o intervalo IPv4 principal da sub-rede.
Clique em Concluído.
Clique em Criar.

gcloud

Crie a rede VPC de modo personalizado:

gcloud compute networks update NETWORK \
    [ --enable-ula-internal-ipv6 [ --internal-ipv6-range=ULA_IPV6_RANGE ]] \
    --subnet-mode=custom

Na rede, crie uma sub-rede para back-ends.

Para o tráfego IPv4 e IPv6, use o seguinte comando para atualizar uma sub-rede:

gcloud compute networks subnets update SUBNET \
   --stack-type=IPV4_IPv6 \
   --ipv6-access-type=EXTERNAL \
   --network=NETWORK \
   --region=REGION_A

Para somente tráfego IPv4, use o seguinte comando:

gcloud compute networks subnets update SUBNET \
   --network=NETWORK \
   --stack-type=IPV4_ONLY \
   --range=10.1.2.0/24 \
   --region=REGION_A

Substitua:

NETWORK: um nome para a rede VPC
ULA_IPV6_RANGE: um prefixo /48 de dentro do intervalo fd20::/20 usado pelo Google para intervalos de sub-rede IPv6 interno. Se você não usar a flag --internal-ipv6-range, o Google selecionará um prefixo /48 para a rede.
SUBNET: um nome para a sub-rede

REGION_A: o nome da região.

Criar um grupo gerenciado de instâncias

Para configurar um balanceador de carga com um back-end do Compute Engine, suas VMs precisam estar em um grupo de instâncias. Neste guia, descrevemos como criar um grupo de instâncias gerenciadas usando VMs do Linux com o Apache em execução para, em seguida, configurar o balanceamento. Um grupo gerenciado de instâncias cria cada uma das instâncias gerenciadas com base nos modelos de instância que você especifica.

O grupo gerenciado de instâncias fornece VMs que executam os servidores de back-end de um balanceador de carga HTTP(S) externo. Para fins de demonstração, os back-ends exibem os próprios nomes de host.

Antes de criar um grupo gerenciado de instâncias, crie um modelo de instância.

Console

Para oferecer suporte a tráfego IPv4 e IPv6, siga estas etapas:

No Console do Google Cloud, acesse a página Modelos de instância.

Acesse "Modelos de instância"
Clique em Criar modelo de instância.
Em Nome, insira lb-backend-template.
Na lista Região, selecione uma região.
Verifique se o disco de inicialização está definido como uma imagem Debian. Por exemplo, Debian GNU/Linux 10 (buster). Estas instruções usam comandos que estão disponíveis apenas no Debian, como apt-get.
Amplie as Opções avançadas.
Expanda Rede e configure os seguintes campos:
1. Em Tags de rede, insira allow-health-check,allow-health-check-ipv6.
2. Na seção Interfaces de rede, clique em edit Editar e configure os seguintes campos:
  - Rede: NETWORK
  - Sub-rede: SUBNET
  - Tipo de pilha de IP: IPv4 e IPv6 (pilha dupla)
3. Clique em Concluir.

Expanda Gerenciamento. No campo Script de inicialização, digite o script a seguir:

#! /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

Clique em Criar.

gcloud

Para oferecer suporte ao tráfego IPv4 e IPv6, execute o seguinte comando:

gcloud compute instance-templates create TEMPLATE_NAME \
  --region=REGION \
  --network=NETWORK \
  --subnet=SUBNET \
  --stack-type=IPv4_IPv6 \
  --tags=allow-health-check,allow-health-check-ipv6 \
  --image-family=debian-10 \
  --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'

Terraform

Para criar o modelo de instância, use o recurso google_compute_instance_template.

resource "google_compute_instance_template" "default" {
  name = "lb-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-11"
    type         = "PERSISTENT"
  }
  labels = {
    managed-by-cnrm = "true"
  }
  machine_type = "n1-standard-1"
  metadata = {
    startup-script = "#! /bin/bash\n     sudo apt-get update\n     sudo apt-get install apache2 -y\n     sudo a2ensite default-ssl\n     sudo a2enmod ssl\n     vm_hostname=\"$(curl -H \"Metadata-Flavor:Google\" \\\n   http://169.254.169.254/computeMetadata/v1/instance/name)\"\n   sudo echo \"Page served from: $vm_hostname\" | \\\n   tee /var/www/html/index.html\n   sudo systemctl restart apache2"
  }
  network_interface {
    access_config {
      network_tier = "PREMIUM"
    }
    network    = "global/networks/default"
    subnetwork = "regions/us-east1/subnetworks/default"
  }
  region = "us-east1"
  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 = ["allow-health-check"]
}

Crie o grupo gerenciado de instâncias e selecione o modelo de instância.

Console

No Console do Google Cloud, acesse a página Grupos de instâncias.

Acesse grupo de instâncias
Clique em Criar grupo de instâncias.
À esquerda, escolha Novo grupo gerenciado de instâncias (sem estado).
Em Nome, insira lb-backend-example.
Em Local, selecione Única zona.
Em Região, selecione a região de sua preferência.
Em Zona, selecione uma zona.
Em Modelo de instância, selecione o modelo de instância lb-backend-template.
Em Modo de escalonamento automático, selecione Ativado: adicionar e remover instâncias para o grupo.

Defina o Número mínimo de instâncias como 2 e o Número máximo de instâncias como 2 ou mais.
Para criar o novo grupo de instâncias, clique em Criar.

gcloud

Crie o grupo gerenciado de instâncias com base no modelo.

gcloud compute instance-groups managed create lb-backend-example \
   --template=TEMPLATE_NAME --size=2 --zone=ZONE_A

Terraform

Para criar o grupo gerenciado de instâncias, use o recurso google_compute_instance_group_manager.

resource "google_compute_instance_group_manager" "default" {
  name = "lb-backend-example"
  zone = "us-east1-b"
  named_port {
    name = "http"
    port = 80
  }
  version {
    instance_template = google_compute_instance_template.default.id
    name              = "primary"
  }
  base_instance_name = "vm"
  target_size        = 2
}

Para saber como aplicar ou remover uma configuração do Terraform, consulte Comandos básicos do Terraform.

Como adicionar uma porta nomeada ao grupo de instâncias

Para o grupo de instâncias, defina um serviço HTTP e associe um nome à porta relevante. O serviço de balanceamento de carga encaminha o tráfego para a porta nomeada. Para mais informações, consulte Portas nomeadas.

Console

No Console do Google Cloud, acesse a página Grupos de instâncias.

Acesse grupo de instâncias
Clique em lb-backend-example.
Na página Visão geral do grupo de instâncias, clique em Editar.
Na seção Mapeamento de porta, clique em Adicionar porta.
1. Para o nome da porta, insira http. Como número de porta, insira 80.
Clique em Salvar.

gcloud

Use o comando gcloud compute instance-groups set-named-ports.

gcloud compute instance-groups set-named-ports lb-backend-example \
    --named-ports http:80 \
    --zone ZONE_A

Terraform

O atributo named_port está incluído na amostra de grupo de instâncias gerenciadas.

Configurar uma regra de firewall

Neste exemplo, você criará a regra de firewall fw-allow-health-check. Essa é uma regra de entrada que permite o tráfego dos sistemas de verificação de integridade do Google Cloud (130.211.0.0/22 e 35.191.0.0/16). Este exemplo usa a tag de destino allow-health-check para identificar as VMs.

Console

No Console do Google Cloud, acesse a página políticas de Firewall.

Acessar as políticas de firewall
Clique em Criar regra de firewall para criar a regra.
Em Nome, insira fw-allow-health-check.
Selecione uma rede.
Em Destinos, selecione Tags de destino especificadas.
Preencha o campo Tags de destino com allow-health-check.
Defina Filtro de origem como Intervalos IPv4.
Defina Intervalos IPv4 de origem como 130.211.0.0/22 e 35.191.0.0/16.
Em Protocolos e portas, selecione Portas e protocolos especificados.
Marque a caixa de seleção TCP e digite 80 para os números de porta.
Clique em Criar.

gcloud

gcloud compute firewall-rules create fw-allow-health-check \
    --network=NETWORK \
    --action=allow \
    --direction=ingress \
    --source-ranges=130.211.0.0/22,35.191.0.0/16 \
    --target-tags=allow-health-check \
    --rules=tcp:80

Terraform

Para criar a regra de firewall, use o recurso google_compute_firewall.

resource "google_compute_firewall" "default" {
  name          = "fw-allow-health-check"
  direction     = "INGRESS"
  network       = "global/networks/default"
  priority      = 1000
  source_ranges = ["130.211.0.0/22", "35.191.0.0/16"]
  target_tags   = ["allow-health-check"]
  allow {
    ports    = ["80"]
    protocol = "tcp"
  }
}

Para saber como aplicar ou remover uma configuração do Terraform, consulte Comandos básicos do Terraform.

Crie a regra de firewall de verificação de integridade do IPv6

Verifique se você tem uma regra de entrada, aplicável às instâncias com balanceamento de carga, que permita o tráfego dos sistemas de verificação de integridade do Google Cloud (2600:2d00:1:b029::/64). Neste exemplo, usamos a tag de destino allow-health-check-ipv6 para identificar as instâncias de VM aplicáveis.

Sem essa regra de firewall, a regra de entrada negação implícita bloqueia o tráfego IPv6 de entrada para as instâncias de back-end.

Console

No Console do Google Cloud, acesse a página políticas de Firewall.

Acesse as políticas de firewall
Para permitir o tráfego de sub-rede IPv6, clique novamente em Criar regra de firewall e insira as seguintes informações:
- Nome: fw-allow-lb-access-ipv6
- Rede: NETWORK
- Prioridade: 1000
- Direção do tráfego: entrada
- Destinos: tags de destino especificadas
- No campo Tags de destino, insira allow-health-check-ipv6.
- Filtro de origem: intervalos IPv6
- Intervalos IPv6 de origem: 2600:2d00:1:b029::/64,2600:2d00:1:1::/64
- Protocolos e portas: permitir todos
Clique em Criar.

gcloud

Para permitir a comunicação com a sub-rede, crie a regra de firewall fw-allow-lb-access-ipv6:

gcloud compute firewall-rules create fw-allow-lb-access-ipv6 \
  --network=NETWORK \
  --action=allow \
  --direction=ingress \
  --target-tags=allow-health-check-ipv6 \
  --source-ranges=2600:2d00:1:b029::/64,2600:2d00:1:1::/64 \
  --rules=all

Reservar um endereço IP externo

Agora que suas instâncias estão funcionando, configure um endereço IP externo, estático e global que seus clientes possam usar para alcançar seu balanceador de carga.

Console

No console do Google Cloud, acesse a página Endereços IP externos.

Acessar Endereços IP externos
Para reservar um endereço IPv4, clique em Reservar endereço IP estático externo.
Em Nome, insira lb-ipv4-1.
Defina o Nível de serviço de rede como Premium.
Defina Versão IP como IPv4.
Configure Tipo como Global.
Clique em Reservar.

gcloud

gcloud compute addresses create lb-ipv4-1 \
    --ip-version=IPV4 \
    --network-tier=PREMIUM \
    --global

Anote o endereço IPv4 que foi reservado:

gcloud compute addresses describe lb-ipv4-1 \
    --format="get(address)" \
    --global

Terraform

Para reservar o endereço IP, use o recurso google_compute_global_address.

resource "google_compute_global_address" "default" {
  name       = "lb-ipv4-1"
  ip_version = "IPV4"
}

Para saber como aplicar ou remover uma configuração do Terraform, consulte Comandos básicos do Terraform.

Configurar o balanceador de carga

Neste exemplo, você está usando HTTPS (front-end) entre o cliente e o balanceador de carga. Para HTTPS, você precisa de um ou mais recursos de certificado SSL para configurar o proxy. Recomendamos o uso de um certificado gerenciado pelo Google.

Mesmo se você estiver usando HTTPS no front-end, poderá usar HTTP no back-end. O Google criptografa automaticamente o tráfego entre os Google Front Ends (GFEs) e seus back-ends que residem em redes VPC do Google Cloud.

Console

Iniciar a configuração

No console do Google Cloud, acesse a página Balanceamento de carga.

Acessar o "Balanceamento de carga"
Clique em Criar balanceador de carga.
Em Tipo de balanceador de carga, selecione Balanceador de carga de aplicativo (HTTP/HTTPS) e clique em Próxima.
Em Voltado ao público ou interno, selecione Voltado ao público (externo) e clique em Próxima.
Em Implantação global ou de região única, selecione Melhor para cargas de trabalho globais e clique em Próxima.
Em Geração do balanceador de carga, selecione Balanceador de carga de aplicativo externo global e clique em Próxima.
Clique em Configurar.

Configuração básica

No campo Nome do balanceador de carga, insira algo como web-map-https ou web-map-http.

Configuração de front-end

Clique em Configuração de front-end.
Defina Protocolo como HTTPS.
Selecione IPv4 para o tráfego IPv4. Defina o endereço IP como lb-ipv4-1, que você criou antes.
Defina a Porta como 443.
Clique em Certificado e selecione seu certificado SSL principal.
Opcional: crie uma política de SSL:
1. Na lista Política de SSL, selecione Criar uma política.
2. Defina o nome da política de SSL como my-ssl-policy.
3. Em Versão mínima de TLS, selecione TLS 1.0.
4. Em Perfil, selecione Moderno. Serão exibidos Recursos ativados e Recursos desativados.
5. Clique em Salvar.
Se você não criou nenhuma política de SSL, uma política padrão de SSL do GCP será aplicada.
Opcional: marque a caixa de seleção Ativar redirecionamento HTTP para HTTPS para ativar redirecionamentos.
Marcar essa caixa de seleção cria um balanceador de carga HTTP parcial extra que usa o mesmo endereço IP que o balanceador de carga HTTPS e redireciona as solicitações HTTP recebidas para o front-end HTTPS do balanceador de carga.

Essa caixa de seleção poderá ser marcada somente quando o protocolo HTTPS estiver selecionado e um endereço IP reservado for utilizado.
Clique em Concluído.

Configuração de back-end

Clique em Configuração de back-end.
Em Criar ou selecionar serviços e buckets de back-end, clique em Serviços de back-end > Criar um serviço de back-end.
Adicione um nome para o serviço de back-end, como web-backend-service.
Na lista Política de seleção de endereço IP, selecione Preferir IPv6.

Em Protocolo, selecione HTTP.
Em Porta nomeada, insira http.
Em Back-ends > Novo back-end > Grupo de instâncias, selecione o grupo de instâncias, lb-backend-example.
Em Número da porta, insira 80.
Mantenha as outras configurações padrão.
Em Verificação de integridade, selecione Criar uma verificação de integridade e adicione um nome para ela, como http-basic-check.
Defina o protocolo como HTTP e clique em HTTP.
Opcional: configure uma política de segurança de back-end padrão. A política de segurança padrão limita o tráfego acima de um limite configurado pelo usuário. Para mais informações sobre as políticas de segurança padrão, consulte a Visão geral de limitação de taxa.
1. Para desativar a política de segurança padrão do Google Cloud Armor, selecione None no menu da lista de políticas de segurança do back-end.
2. Na seção Segurança, selecione Política de segurança padrão.
3. No campo Nome da política, aceite o nome gerado automaticamente ou insira um nome para a política de segurança.
4. No campo Contagem de solicitações, aceite a contagem de solicitações padrão ou insira um número inteiro entre 1 e 10,000.
5. No campo Intervalo, selecione um intervalo.
6. No campo Aplicar na chave, escolha um dos seguintes valores: Todos, Endereço IP ou Endereço IP X-Forwarded-For. Para mais informações sobre essas opções, consulte Identificar clientes para a limitação de taxa.
Mantenha as outras configurações padrão.
Clique em Criar.

Regras de roteamento

Em Regras de roteamento, mantenha as configurações padrão.

Revisar e finalizar

Clique em Analisar e finalizar.
Revise suas configurações do balanceador de carga.
Opcional: clique em Código equivalente para conferir a solicitação da API REST que será usada para criar o balanceador de carga.
Clique em Criar.

Aguarde o balanceador de carga ser criado.

Se você tiver criado um balanceador de carga HTTPS e marcado a caixa de seleção Ativar redirecionamento HTTP para HTTPS, você também verá um balanceador de carga HTTP criado com um sufixo -redirect.

Clique no nome do balanceador de carga.
Na tela Detalhes do balanceador de carga, anote o IP:Porta do balanceador de carga.

gcloud

Crie uma verificação de integridade.

 gcloud compute health-checks create http http-basic-check \
     --port 80

Crie um serviço de back-end.

gcloud beta compute backend-services create web-backend-service \
    --load-balancing-scheme=EXTERNAL_MANAGED \
    --protocol=HTTP \
    --port-name=http \
    --ip-address-selection-policy=PREFER_IPV6 \
    --health-checks=http-basic-check \
    --global

Adicione seu grupo de instâncias como back-end do serviço de back-end.

gcloud beta compute backend-services add-backend web-backend-service \
  --instance-group=lb-backend-example \
  --instance-group-zone=ZONE_A \
  --global

No caso de HTTP, crie um mapa de URL a fim de encaminhar as solicitações recebidas para o serviço de back-end padrão.
```
gcloud beta compute url-maps create web-map-http \
  --default-service web-backend-service
```
Para HTTPS, crie um mapa de URLs para encaminhar as solicitações recebidas para o serviço de back-end padrão.
```
gcloud beta compute url-maps create web-map-https \
  --default-service web-backend-service
```

Configurar um front-end HTTPS

Pule esta seção para balanceadores de carga HTTP.

Para HTTPS, crie o recurso de certificado SSL global, conforme mostrado nas seções a seguir:

No caso de HTTPS, crie um proxy HTTPS de destino a fim de encaminhar solicitações ao mapa de URL. O proxy é a parte do balanceador de carga HTTPS que armazena o certificado SSL associado a ele. Portanto, nesta etapa, também é possível carregar o certificado.
```
gcloud beta compute target-https-proxies create http-lb-proxy \
  --http-keep-alive-timeout-sec=HTTP_KEEP_ALIVE_TIMEOUT_SEC \
  --url-map=web-map-https \
  --ssl-certificates=www-ssl-cert
```
Substitua HTTP_KEEP_ALIVE_TIMEOUT_SEC pelo valor do tempo limite do sinal de atividade HTTP do cliente de 5 a 1.200 segundos. O valor padrão é de 610 segundos. Este campo é opcional.

No caso de HTTPS, crie uma regra de encaminhamento global a fim de encaminhar as solicitações recebidas ao o proxy.

gcloud beta compute forwarding-rules create https-content-rule \
  --load-balancing-scheme=EXTERNAL_MANAGED \
  --network-tier=PREMIUM \
  --address=lb-ipv4-1 \
  --global \
  --target-https-proxy=https-lb-proxy \
  --ports=443

Opcional: para HTTPS, crie uma política de SSL global e anexe-a ao proxy HTTPS.
Para criar uma política de SSL global:

gcloud compute ssl-policies create my-ssl-policy \
  --profile MODERN \
  --min-tls-version 1.0

Para anexar a política de SSL ao proxy HTTPS de destino global:

gcloud compute target-https-proxies update https-lb-proxy \
  --ssl-policy my-ssl-policy

Configurar um front-end HTTP

Pule esta seção para balanceadores de carga HTTPS.

Para HTTP, crie um proxy HTTP de destino para encaminhar solicitações ao mapa de URLs.
```
gcloud beta compute target-http-proxies create http-lb-proxy \
  --http-keep-alive-timeout-sec=HTTP_KEEP_ALIVE_TIMEOUT_SEC \
  --url-map=web-map-http
```
Substitua HTTP_KEEP_ALIVE_TIMEOUT_SEC pelo valor do tempo limite do sinal de atividade HTTP do cliente de 5 a 1.200 segundos. O valor padrão é de 610 segundos. Este campo é opcional.

No caso de HTTP, crie uma regra de encaminhamento global a fim de encaminhar as solicitações recebidas ao proxy.

gcloud beta compute forwarding-rules create http-content-rule \
  --load-balancing-scheme=EXTERNAL_MANAGED \
  --address=lb-ipv4-1 \
  --global \
  --target-http-proxy=http-lb-proxy \
  --ports=80

Terraform

Para criar a verificação de integridade, use o recurso google_compute_health_check.

resource "google_compute_health_check" "default" {
  name               = "http-basic-check"
  check_interval_sec = 5
  healthy_threshold  = 2
  http_health_check {
    port               = 80
    port_specification = "USE_FIXED_PORT"
    proxy_header       = "NONE"
    request_path       = "/"
  }
  timeout_sec         = 5
  unhealthy_threshold = 2
}

Para criar o serviço de back-end, use o recurso google_compute_backend_service.

resource "google_compute_backend_service" "default" {
  name                            = "web-backend-service"
  connection_draining_timeout_sec = 0
  health_checks                   = [google_compute_health_check.default.id]
  load_balancing_scheme           = "EXTERNAL_MANAGED"
  port_name                       = "http"
  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 criar o mapa de URL, use o recurso google_compute_url_map.

resource "google_compute_url_map" "default" {
  name            = "web-map-http"
  default_service = google_compute_backend_service.default.id
}

Para criar o proxy HTTP de destino, use o recurso google_compute_target_http_proxy.

resource "google_compute_target_http_proxy" "default" {
  name    = "http-lb-proxy"
  url_map = google_compute_url_map.default.id
}

Para criar a regra de encaminhamento, use o recurso google_compute_global_forwarding_rule.

resource "google_compute_global_forwarding_rule" "default" {
  name                  = "http-content-rule"
  ip_protocol           = "TCP"
  load_balancing_scheme = "EXTERNAL_MANAGED"
  port_range            = "80-80"
  target                = google_compute_target_http_proxy.default.id
  ip_address            = google_compute_global_address.default.id
}

Para saber como aplicar ou remover uma configuração do Terraform, consulte Comandos básicos do Terraform.

Como conectar seu domínio ao balanceador de carga

Após a criação do balanceador de carga, anote o endereço IP associado a ele, por exemplo, 30.90.80.100. Para apontar seu domínio para o balanceador de carga, crie um registro A usando o serviço de registro de domínio. Se você adicionou vários domínios ao certificado SSL, adicione um registro A para cada um deles, todos apontando para o endereço IP do balanceador de carga. Por exemplo, para criar registros A para www.example.com e example.com, use o seguinte:

NAME                  TYPE     DATA
www                   A        30.90.80.100
@                     A        30.90.80.100

Se você usa o Cloud DNS como provedor de DNS, consulte Adicionar, modificar e excluir registros.

Testar o tráfego enviado às suas instâncias

Agora que o serviço de balanceamento de carga está em execução, é possível enviar o tráfego para a regra de encaminhamento e observar como ele será distribuído em várias instâncias.

Console

No Console do Google Cloud, acesse a página Balanceamento de carga.

Acessar o "Balanceamento de carga"
Clique no balanceador de carga que você acabou de criar.
Na seção Back-end, confirme se as VMs estão íntegras. A coluna Integridade deve estar preenchida, indicando que ambas as VMs estão íntegras (2/2). Caso contrário, primeiro tente recarregar a página. Pode levar alguns instantes para o Console do Google Cloud indicar que as VMs estão íntegras. Se os back-ends não aparecerem íntegros depois de alguns minutos, revise a configuração do firewall e a tag de rede atribuída às suas VMs de back-end.

Observação: um serviço de back-end com vários endpoints precisa ter endereços IPv6 exclusivos. Os endpoints podem estar em sub-redes diferentes, mas o mesmo endereço IPv6 não pode ser usado para vários endpoints.
No caso de HTTPS, se você usa um certificado gerenciado pelo Google, confirme se o status do recurso do certificado é "ATIVO". Para mais informações, consulte Status do recurso de certificado SSL gerenciado pelo Google.
Depois que o Console do Google Cloud mostrar que as instâncias de back-end estão íntegras, teste o balanceador de carga com um navegador da Web acessando https://IP_ADDRESS (ou http://IP_ADDRESS). Substitua IP_ADDRESS pelo endereço IP do balanceador de carga.
Caso você tenha usado um certificado autoassinado durante o teste de HTTPS, o navegador exibirá um aviso. É preciso conceder permissão explícita para que seu navegador aceite um certificado autoassinado.
Seu navegador deve renderizar uma página que mostre o nome da instância que a exibiu e a zona (por exemplo, Page served from: lb-backend-example-xxxx). Caso seu navegador não renderize essa página, revise as configuração mostradas neste guia.

gcloud

gcloud compute addresses describe lb-ipv4-1 \
   --format="get(address)" \
   --global

Após alguns minutos, é possível testar a configuração executando o seguinte comando curl.

curl http://IP_ADDRESS

-OU-

curl https://HOSTNAME

Configurações avançadas

Nesta seção, o exemplo é detalhado para fornecer outras opções de configuração. Todas as tarefas são opcionais. É possível realizá-las em qualquer ordem.

Atualizar tempo limite do sinal de atividade HTTP do cliente

O balanceador de carga criado nas etapas anteriores foi configurado com um valor padrão para o tempo limite do sinal de atividade HTTP do cliente. Para atualizar o tempo limite do sinal de atividade HTTP do cliente, use as instruções a seguir.

Console

No Console do Google Cloud, acesse a página Balanceamento de carga.

Acessar o "Balanceamento de carga"
Clique no nome do balanceador de carga que você quer modificar.
Clique em Editar.
Clique em Configuração de front-end.
Expanda Recursos avançados. Em Tempo limite de sinal de atividade HTTP, insira um valor de tempo limite entre 5 e 1.200 segundos.
Clique em Atualizar.
Para revisar as alterações, clique em Analisar e finalizar e depois em Atualizar.

gcloud

Para um balanceador de carga HTTP, atualize o proxy HTTP de destino usando o comando gcloud compute target-http-proxies update:

    gcloud compute target-http-proxies update TARGET_HTTP_PROXY_NAME \
        --http-keep-alive-timeout-sec=HTTP_KEEP_ALIVE_TIMEOUT_SEC \
        --global

Para um balanceador de carga HTTPS, atualize o proxy HTTPS de destino usando o comando gcloud compute target-https-proxies update:

    gcloud compute target-https-proxies update TARGET_HTTPS_PROXY_NAME \
        --http-keep-alive-timeout-sec=HTTP_KEEP_ALIVE_TIMEOUT_SEC \
        --global

Substitua:

TARGET_HTTP_PROXY_NAME: o nome do proxy HTTP de destino.
TARGET_HTTPS_PROXY_NAME: o nome do proxy HTTPS de destino.
HTTP_KEEP_ALIVE_TIMEOUT_SEC: o tempo limite do sinal de atividade HTTP de 5 a 1.200 segundos.

A seguir

Para documentação relacionada:

Para vídeos relacionados:

Como configurar serviços de back-end para o balanceador de carga de aplicativo externo global