Configure um balanceador de carga de aplicações clássico com um back-end de grupo de instâncias geridas

Este guia de configuração mostra como criar um Application Load Balancer clássico com um back-end do grupo de instâncias gerido do Compute Engine.

Para ver conceitos gerais, consulte a vista geral do balanceador de carga de aplicações externo.

Se for um utilizador existente do Application Load Balancer clássico, certifique-se de que revê a vista geral da migração quando planear uma nova implementação com o Application Load Balancer externo global.

Topologias de balanceadores de carga

Para um balanceador de carga HTTPS, cria a configuração apresentada no diagrama seguinte.

Balanceador de carga de aplicações externo com um back-end de grupo de instâncias geridas (MIG).
Figura 1. Balanceador de carga de aplicações externo com um back-end de grupo de instâncias geridas (MIG) (clique para aumentar).

Para um balanceador de carga de HTTP, cria a configuração apresentada no diagrama seguinte.

Balanceador de carga de aplicações externo com um back-end de grupo de instâncias geridas (MIG).
Figura 2. Balanceador de carga de aplicações externo com um back-end de grupo de instâncias geridas (MIG) (clique para aumentar).

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

  1. Um cliente envia um pedido de conteúdo para o endereço IPv4 externo definido na regra de encaminhamento.

  2. Para um balanceador de carga HTTPS, a regra de encaminhamento direciona o pedido para o proxy HTTPS de destino.

    Para um balanceador de carga HTTP, a regra de encaminhamento direciona o pedido para o proxy HTTP de destino.

  3. O proxy de destino usa a regra no mapa de URLs para determinar que o serviço de back-end único recebe todos os pedidos.

  4. O balanceador de carga determina que o serviço de back-end tem apenas um grupo de instâncias e direciona o pedido para uma instância de máquina virtual (VM) nesse grupo.

  5. A MV publica o conteúdo pedido pelo utilizador.

Antes de começar

Conclua os passos seguintes antes de criar o equilibrador de carga.

Configure um recurso de certificado SSL

Para um balanceador de carga HTTPS, crie um recurso de certificado SSL, conforme descrito no seguinte artigo:

Recomendamos a utilização de um certificado gerido pela Google.

Este exemplo pressupõe que já tem um recurso de certificado SSL denominado www-ssl-cert.

Configure as autorizações

Para concluir os passos neste guia, tem de ter autorização para criar instâncias do Compute Engine, regras de firewall e endereços IP reservados num projeto. Tem de ter a função de proprietário ou editor do projeto, ou ter as seguintes funções do IAM do Compute Engine.

Tarefa Função necessária
Crie instâncias Administrador da instância
Adicione e remova regras de firewall Administrador de segurança
Crie componentes do balanceador de carga Administrador da rede
Crie um projeto (opcional) Project Creator

Para mais informações, consulte os seguintes guias:

Configure a rede e as sub-redes

Para criar a rede e a sub-rede de exemplo, siga estes passos.

Consola

  1. Na Google Cloud consola, aceda à página Redes VPC.

    Aceda a redes de VPC

  2. Clique em Criar rede de VPC.

  3. Introduza um Nome para a rede.

  4. Para o Modo de criação de sub-rede, escolha Personalizado.

  5. Na secção Nova sub-rede, configure os seguintes campos:

    1. Indique um Nome para a sub-rede.
    2. Selecione uma região.
    3. Para o Tipo de pilha de IP, selecione IPv4 (pilha única).
    4. Introduza um intervalo de endereços IP. Este é o intervalo IPv4 principal para a sub-rede.

  6. Clique em Concluído.

  7. Para adicionar uma sub-rede numa região diferente, clique em Adicionar sub-rede e repita os passos anteriores.

  8. Clique em Criar.

gcloud

  1. Crie a rede VPC de modo personalizado:

    gcloud compute networks create NETWORK \
    --subnet-mode=custom

  2. Na rede, crie uma sub-rede para os back-ends:

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

    Substitua o seguinte:

    • NETWORK: um nome para a rede da VPC.

    • SUBNET: um nome para a sub-rede.

    • REGION: o nome da região.

Crie um grupo de instâncias geridas

Para configurar um balanceador de carga com um back-end do Compute Engine, as VMs têm de estar num grupo de instâncias. Este guia descreve como criar um grupo de instâncias gerido com VMs Linux que têm o Apache em execução e, em seguida, configurar o equilíbrio de carga. Um grupo de instâncias geridas cria cada uma das respetivas instâncias geridas com base nos modelos de instâncias que especificar.

O grupo de instâncias gerido 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 servem os seus próprios nomes de anfitriões.

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

Consola

Para suportar o tráfego IPv4, siga estes passos:

  1. Na Google Cloud consola, aceda à página Modelos de instâncias.

    Aceda a Modelos de instâncias

  2. Clique em Criar modelo de instância.

  3. Em Nome, introduza lb-backend-template.

  4. Certifique-se de que o disco de arranque está definido para uma imagem Debian, como o Debian GNU/Linux 10 (buster). Estas instruções usam comandos que só estão disponíveis no Debian, como apt-get.

  5. Expanda Opções avançadas.

  6. Expanda Rede e configure os seguintes campos:

    1. Para etiquetas de rede, introduza allow-health-check.
    2. Na secção Interfaces de rede, clique em Editar e faça as seguintes alterações:
      • Rede: NETWORK
      • Subnet: SUBNET
      • Tráfego IPv4: IPv4 (single-stack)
    3. Clique em Concluído.

  7. Expanda Gestão. No campo Script de arranque, introduza o seguinte 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

  8. Clique em Criar.

gcloud

Para suportar o tráfego IPv4, execute o seguinte comando:

gcloud compute instance-templates create TEMPLATE_NAME \
  --region=REGION \
  --network=NETWORK \
  --subnet=SUBNET \
  --stack-type=IPV4_ONLY \
  --tags=allow-health-check \
  --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 google_compute_instance_template recurso.

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 de instâncias geridas e selecione o modelo de instância.

Consola

  1. Na Google Cloud consola, aceda à página Grupos de instâncias.

    Aceda a Grupos de instâncias

  2. Clique em Criar grupo de instâncias.

  3. No lado esquerdo, escolha Novo grupo de instâncias gerido (sem estado).

  4. Em Nome, introduza lb-backend-example.

  5. Em Localização, selecione Zona única.

  6. Em Região, selecione a sua região preferida.

  7. Para Zona, selecione uma zona.

  8. Em Modelo de instância, selecione o modelo de instância lb-backend-template.

  9. Para o Modo de dimensionamento automático, selecione Ativado: adicionar e remover instâncias do 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.

  10. Para criar o novo grupo de instâncias, clique em Criar.

gcloud

  1. Crie o grupo de instâncias gerido 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 de instâncias gerido, use o google_compute_instance_group_manager recurso.

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 os comandos básicos do Terraform.

Adicione uma porta com nome ao grupo de instâncias

Para o seu grupo de instâncias, defina um serviço HTTP e mapeie um nome de porta para a porta relevante. O serviço de balanceamento de carga encaminha o tráfego para a porta especificada. Para mais informações, consulte o artigo Portas com nome.

Consola

  1. Na Google Cloud consola, aceda à página Grupos de instâncias.

    Aceda a Grupos de instâncias

  2. Clique em lb-backend-example.

  3. Na página Vista geral do grupo de instâncias, clique em Editar.

  4. Na secção Mapeamento de portas, clique em Adicionar porta.

    1. Para o nome da porta, introduza http. Para o número da porta, introduza 80.

  5. Clique em Guardar.

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 no exemplo de grupo de instâncias gerido.

Configure uma regra de firewall

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

Consola

  1. Na Google Cloud consola, aceda à página Políticas de firewall.

    Aceder a Políticas de firewall

  2. Clique em Criar regra de firewall para criar a regra de firewall.

  3. Em Nome, introduza fw-allow-health-check.

  4. Selecione uma rede.

  5. Em Segmentações, selecione Etiquetas de segmentação especificadas.

  6. Preencha o campo Etiquetas alvo com allow-health-check.

  7. Defina o Filtro de origem como Intervalos IPv4.

  8. Defina os Intervalos IPv4 de origem como 130.211.0.0/22 e 35.191.0.0/16.

  9. Em Protocolos e portas, selecione Protocolos e portas especificados.

  10. Selecione a caixa de verificação TCP e, de seguida, escreva 80 para os números das portas.

  11. 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 os comandos básicos do Terraform.

Reserve um endereço IP externo

Agora que as suas instâncias estão em funcionamento, configure um endereço IP externo estático global que os seus clientes usam para aceder ao balanceador de carga.

Consola

  1. Na Google Cloud consola, aceda à página Endereços IP externos.

    Aceda a Endereços IP externos

  2. Para reservar um endereço IPv4, clique em Reservar endereço IP estático externo.

  3. Em Nome, introduza lb-ipv4-1.

  4. Defina o Nível de serviço de rede como Premium.

  5. Defina a versão do IP como IPv4.

  6. Defina o Tipo como Global.

  7. Clique em Reservar.

gcloud 

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

Tome nota do 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 os comandos básicos do Terraform.

Configure o balanceador de carga

Neste exemplo, está a usar HTTPS (frontend) entre o cliente e o balanceador de carga. Para o HTTPS, precisa de um ou mais recursos de certificado SSL para configurar o proxy. Recomendamos a utilização de um certificado gerido pela Google.

Mesmo que esteja a usar HTTPS no frontend, pode usar HTTP no backend. A Google encripta automaticamente o tráfego entre os front-ends da Google (GFEs) e os seus back-ends que residem em Google Cloud redes VPC.

Consola

Selecione o tipo de balanceador de carga

  1. Na Google Cloud consola, aceda à página Equilíbrio de carga.

    Aceda a Balanceamento de carga

  2. Clique em Criar equilibrador de carga.
  3. Em Tipo de balanceador de carga, selecione Balanceador de carga de aplicações (HTTP/HTTPS) e clique em Seguinte.
  4. Para Público ou interno, selecione Público (externo) e clique em Seguinte.
  5. Para a Implementação global ou de região única, selecione Melhor para cargas de trabalho globais e clique em Seguinte.
  6. Para Geração do balanceador de carga, selecione Classic Application Load Balancer e clique em Seguinte.
  7. Clique em Configurar.

Configuração básica

Para o Nome do balanceador de carga, introduza algo como web-map-https ou web-map-http.

Configuração do frontend

  1. Clique em Configuração do front-end.
  2. Defina o Protocolo como HTTPS.
  3. Selecione IPv4 para tráfego IPv4. Defina o endereço IP para lb-ipv4-1, que criou anteriormente.
  4. Defina a Porta como 443.
  5. Clique em Certificado e selecione o seu certificado SSL principal.
  6. Opcional: crie uma política SSL:
    1. Na lista Política de SSL, selecione Criar uma política.
    2. Defina o nome da política SSL como my-ssl-policy.
    3. Para Versão mínima de TLS, selecione TLS 1.0.
    4. Para Perfil, selecione Moderno. São apresentadas as Funcionalidades ativadas e as Funcionalidades desativadas.
    5. Clique em Guardar.
    Se não tiver criado políticas de SSL, é aplicada uma política de SSL predefinida.
  7. Opcional: selecione a caixa de verificação Ativar redirecionamento de HTTP para HTTPS para ativar os redirecionamentos.

    Selecione esta caixa de verificação para criar um balanceador de carga HTTP parcial adicional que usa o mesmo endereço IP que o seu balanceador de carga HTTPS e redireciona os pedidos HTTP recebidos para o frontend HTTPS do seu balanceador de carga.

    Esta caixa de verificação só pode ser selecionada quando o protocolo HTTPS estiver selecionado e for usado um endereço IP reservado.

  8. Clique em Concluído.

Configuração do back-end

  1. Clique em Configuração de back-end.
  2. Em Serviços de back-end e contentores de back-end, selecione Criar um serviço de back-end.
  3. Adicione um nome para o seu serviço de back-end, como web-backend-service.
  4. Aceda à secção Segurança e, de seguida, selecione Ativar IAP para proteger o acesso às suas aplicações.

    O Cloud CDN e o IAP não são compatíveis. Se tiver o Cloud CDN ativado e selecionar a ativação do IAP, o Cloud CDN é desativado automaticamente.

  5. Opcional: configure uma política de segurança do back-end predefinida. A política de segurança predefinida limita o tráfego acima de um limite configurado pelo utilizador. Para mais informações sobre as políticas de segurança predefinidas, consulte a vista geral da limitação de taxa.

    1. Para desativar a política de segurança predefinida do Cloud Armor, selecione None na lista Política de segurança de back-end do Cloud Armor.
    2. Para configurar a política de segurança predefinida do Cloud Armor, selecione Política de segurança predefinida na lista Política de segurança de back-end do Cloud Armor.
    3. No campo Nome da política, aceite o nome gerado automaticamente ou introduza um nome para a sua política de segurança.
    4. No campo Contagem de pedidos, aceite a contagem de pedidos predefinida ou introduza um número inteiro entre 1 e 10,000.
    5. No campo Intervalo, selecione um intervalo.
    6. No campo Aplicar à chave, escolha um dos seguintes valores: Tudo, Endereço IP ou Endereço IP X-Forwarded-For. Para mais informações acerca destas opções, consulte o artigo Identificar clientes para a limitação de taxa.
  6. Manter as outras predefinições.
  7. Clique em Criar.

Regras de anfitrião e caminho

Para Regras de caminhos e anfitriões, mantenha as predefinições.

Reveja e finalize

  1. Clique em Rever e finalizar.
  2. Reveja as definições de configuração do equilibrador de carga.
  3. Opcional: clique em Código equivalente para ver o pedido da API REST que vai ser usado para criar o balanceador de carga.
  4. Clique em Criar.

Aguarde a criação do balanceador de carga.

Se criou um balanceador de carga HTTPS e selecionou a caixa de verificação Ativar redirecionamento de HTTP para HTTPS, também vê um balanceador de carga HTTP criado com o sufixo -redirect.

  1. Clique no nome do balanceador de carga.
  2. No ecrã Detalhes do balanceador de carga, tome nota do IP:Porta do seu balanceador de carga.

gcloud

  1. Crie uma verificação de funcionamento. 
     gcloud compute health-checks create http http-basic-check \
     --port 80
  2. Crie um serviço de back-end. 
    gcloud compute backend-services create web-backend-service \
    --load-balancing-scheme=EXTERNAL \
    --protocol=HTTP \
    --port-name=http \
    --health-checks=http-basic-check \
    --global
  3. Adicione o seu grupo de instâncias como back-end ao 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
  4. Para HTTP, crie um mapa de URLs para encaminhar os pedidos recebidos para o serviço de back-end predefinido. 
    gcloud beta compute url-maps create web-map-http \
  --default-service web-backend-service
  5. Para HTTPS, crie um mapa de URLs para encaminhar os pedidos recebidos para o serviço de back-end predefinido. 
    gcloud beta compute url-maps create web-map-https \
  --default-service web-backend-service

Configure um frontend HTTPS

Ignore esta secção para balanceadores de carga de HTTP.

  1. Para HTTPS, se ainda não o fez, crie o recurso de certificado SSL global, conforme mostrado nas secções seguintes:

  2. Para HTTPS, crie um proxy HTTPS de destino para encaminhar pedidos para o seu mapa de URLs. O proxy é a parte do balanceador de carga que contém o certificado SSL para um balanceador de carga HTTPS, pelo que também carrega o certificado neste passo.

    gcloud compute target-https-proxies create https-lb-proxy \
  --url-map=web-map-https \
  --ssl-certificates=www-ssl-cert
  3. Para HTTPS, crie uma regra de encaminhamento global para encaminhar pedidos recebidos para o proxy. 
    gcloud compute forwarding-rules create https-content-rule \
  --load-balancing-scheme=EXTERNAL \
  --network-tier=PREMIUM \
  --address=lb-ipv4-1 \
  --global \
  --target-https-proxy=https-lb-proxy \
  --ports=443
  4. Opcional: para HTTPS, crie uma política SSL global e anexe-a ao proxy HTTPS.
    Para criar uma política SSL global: 
    gcloud compute ssl-policies create my-ssl-policy \
  --profile MODERN \
  --min-tls-version 1.0
    Para anexar a política SSL ao proxy HTTPS de destino global: 
    gcloud compute target-https-proxies update https-lb-proxy \
  --ssl-policy my-ssl-policy

Configure um front-end HTTP

Ignore esta secção para balanceadores de carga HTTPS.

  1. Para HTTP, crie um proxy HTTP de destino para encaminhar pedidos para o seu mapa de URLs. 
    gcloud compute target-http-proxies create http-lb-proxy \
  --url-map=web-map-http
  2. Para HTTP, crie uma regra de encaminhamento global para encaminhar pedidos recebidos para o proxy. 
    gcloud compute forwarding-rules create http-content-rule \
  --load-balancing-scheme=EXTERNAL \
  --address=lb-ipv4-1 \
  --global \
  --target-http-proxy=http-lb-proxy \
  --ports=80

Terraform

  1. Para criar a verificação de funcionamento, 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
}

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

    Este exemplo usa load_balancing_scheme="EXTERNAL_MANAGED", que configura um Application Load Balancer externo global com a capacidade de gestão de tráfego avançada. Para criar um Application Load Balancer clássico, certifique-se de que altera o valor de load_balancing_scheme para EXTERNAL antes de executar o script.

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

  3. Para criar o mapa de URLs, 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
}

  4. 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
}

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

    Este exemplo usa load_balancing_scheme="EXTERNAL_MANAGED", que configura um Application Load Balancer externo global com a capacidade de gestão de tráfego avançada. Para criar um Application Load Balancer clássico, certifique-se de que altera o valor de load_balancing_scheme para EXTERNAL antes de executar o script.

    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 os comandos básicos do Terraform.

Associe o seu domínio ao balanceador de carga

Após a criação do balanceador de carga, tome nota do endereço IP associado ao balanceador de carga, por exemplo, 30.90.80.100. Para direcionar o seu domínio para o equilibrador de carga, crie um registo A através do serviço de registo de domínios. Se adicionou vários domínios ao seu certificado SSL, tem de adicionar um registo A para cada um, todos a apontar para o endereço IP do equilibrador de carga. Por exemplo, para criar registos 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 usar o Cloud DNS como fornecedor de DNS, consulte o artigo Adicione, modifique e elimine registos.

Teste o tráfego enviado para as suas instâncias

Agora que o serviço de balanceamento de carga está em execução, pode enviar tráfego para a regra de encaminhamento e ver o tráfego disperso por diferentes instâncias.

Consola

  1. Na Google Cloud consola, aceda à página Equilíbrio de carga.

    Aceda a Balanceamento de carga

  2. Clique no balanceador de carga que acabou de criar.

  3. Na secção Backend, confirme que as VMs estão em bom estado. A coluna Healthy deve estar preenchida, o que indica que ambas as VMs estão em bom estado (2/2). Se vir o contrário, experimente primeiro atualizar a página. A Google Cloud consola pode demorar alguns instantes a indicar que as VMs estão em bom estado. Se os back-ends não parecerem em bom estado após alguns minutos, reveja a configuração da firewall e a etiqueta de rede atribuída às VMs de back-end.

  4. Para HTTPS, se estiver a usar um certificado gerido pela Google, confirme se o estado do recurso de certificado é ATIVO. Para mais informações, consulte o artigo Estado do recurso de certificado SSL gerido pela Google.
  5. Depois de a Google Cloud consola mostrar que as instâncias de back-end estão em bom estado, pode testar o balanceador de carga através de um navegador de Internet acedendo a https://IP_ADDRESS (ou http://IP_ADDRESS). Substitua IP_ADDRESS pelo endereço IP do balanceador de carga.
  6. Se usou um certificado autoassinado para testar o HTTPS, o navegador apresenta um aviso. Tem de instruir explicitamente o navegador para aceitar um certificado autoassinado.
  7. O navegador deve renderizar uma página com conteúdo que mostre o nome da instância que publicou a página, juntamente com a respetiva zona (por exemplo, Page served from: lb-backend-example-xxxx). Se o navegador não renderizar esta página, reveja as definições de configuração neste guia.

gcloud 

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

Após alguns minutos, pode testar a configuração executando o seguinte comando curl.

curl http://IP_ADDRESS

-OU-

curl https://HOSTNAME

O que se segue?