Configure um Application Load Balancer externo regional com back-ends do grupo de instâncias de VM

Este documento fornece instruções para configurar um balanceador de carga de aplicações externo regional para os seus serviços que são executados em VMs do Compute Engine.

Uma vez que os balanceadores de carga de aplicações externos regionais permitem criar balanceadores de carga em regiões específicas, são frequentemente usados para cargas de trabalho que têm requisitos de conformidade jurisdicional. As cargas de trabalho que requerem acesso à saída do nível de rede padrão são outro exemplo de utilização comum dos balanceadores de carga de aplicações externos regionais, uma vez que estes suportam o nível de serviço de rede Premium e Standard.

Antes de seguir este guia, familiarize-se com o seguinte:

Autorizações

Para seguir este guia, tem de conseguir criar instâncias e modificar uma rede num projeto. Tem de ser proprietário ou editor do projeto, ou ter todas as funções do IAM do Compute Engine seguintes.

Tarefa Função necessária
Crie redes, sub-redes e componentes do balanceador de carga Administrador da rede
Adicione e remova regras de firewall Administrador de segurança
Crie instâncias Administrador da instância

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

Vista geral da configuração

Pode configurar um Application Load Balancer externo regional, conforme descrito no seguinte fluxo de configuração de alto nível. Os passos numerados referem-se aos números no diagrama.

Componentes numerados do balanceador de carga de aplicações externo regional
Componentes numerados do balanceador de carga de aplicações externo regional (clique para ampliar)

Conforme mostrado no diagrama, este exemplo cria um Application Load Balancer externo regional numa rede VPC na região us-west1, com um serviço de back-end e dois grupos de instâncias de back-end.

O diagrama mostra o seguinte:

  1. Uma rede VPC com duas sub-redes:

    1. Uma sub-rede é usada para back-ends (grupos de instâncias). O respetivo intervalo de endereços IP principal é 10.1.2.0/24.

    2. Uma sub-rede é uma sub-rede só de proxy na região us-west1. Tem de criar uma sub-rede apenas de proxy em cada região de uma rede VPC onde usa equilibradores de carga de aplicações externos regionais. A sub-rede apenas de proxy da região é partilhada entre todos os balanceadores de carga regionais na região. Os endereços de origem dos pacotes enviados dos balanceadores de carga para os back-ends do seu serviço são atribuídos a partir da sub-rede apenas de proxy. Neste exemplo, a sub-rede apenas de proxy para a região tem um intervalo de endereços IP principal de 10.129.0.0/23, que é o tamanho da sub-rede recomendado. Para mais informações, consulte Sub-redes apenas de proxy.

  2. Uma regra de firewall que permite fluxos de tráfego de sub-rede só de proxy na sua rede. Isto significa adicionar uma regra que permita o tráfego da porta TCP 80, 443 e 8080 de 10.129.0.0/23 (o intervalo da sub-rede só de proxy neste exemplo). Outra regra de firewall para as sondas de verificação de funcionamento.

  3. Instâncias de back-end.

  4. Grupos de instâncias:

    1. Grupos de instâncias geridas ou não geridas para implementações de VMs do Compute Engine
    2. NEGs para implementações do GKE

    Em cada zona, pode ter uma combinação de tipos de grupos de back-end com base nos requisitos da sua implementação.

  5. Uma verificação de saúde regional que comunica a disponibilidade dos seus back-ends.

  6. Um serviço de back-end regional que monitoriza a utilização e o estado de funcionamento dos back-ends.

  7. Um mapa de URLs regional que analisa o URL de um pedido e encaminha pedidos para serviços de back-end específicos com base no anfitrião e no caminho do URL do pedido.

  8. Um proxy HTTP ou HTTPS de destino regional, que recebe um pedido do utilizador e encaminha-o para o mapa de URLs. Para HTTPS, configure um recurso de certificado SSL regional. O proxy de destino pode usar o certificado SSL ou o certificado do Gestor de Certificados para desencriptar o tráfego SSL se configurar o equilíbrio de carga HTTPS. O proxy de destino pode encaminhar o tráfego para as suas instâncias através de HTTP ou HTTPS.

  9. Uma regra de encaminhamento, que tem o endereço IP externo do seu equilibrador de carga para encaminhar cada pedido recebido para o proxy de destino.

    O endereço IP externo associado à regra de encaminhamento é reservado através do comando gcloud compute addresses create, conforme descrito em Reservar o endereço IP do balanceador de carga.

Configure a rede e as sub-redes

Precisa de uma rede VPC com duas sub-redes: uma para os back-ends do balanceador de carga e outra para os proxies do balanceador de carga. Um balanceador de carga de aplicações externo regional é regional. O tráfego na rede da VPC é encaminhado para o balanceador de carga se a origem do tráfego estiver numa sub-rede na mesma região que o balanceador de carga.

Este exemplo usa a seguinte rede de VPC, região e sub-redes:

  • Rede. A rede é uma rede VPC no modo personalizado denominada lb-network.

  • Sub-rede para back-ends. Uma sub-rede denominada backend-subnet na região us-west1 usa 10.1.2.0/24 para o respetivo intervalo de IP principal.

  • Sub-rede para proxies. Uma sub-rede denominada proxy-only-subnet na região us-west1 usa 10.129.0.0/23 para o respetivo intervalo de IP principal.

Configure a rede e a sub-rede para os back-ends

Consola

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

    Aceda a redes de VPC

  2. Clique em Criar rede de VPC.

  3. Em Nome, introduza lb-network.

  4. Na secção Sub-redes:

    • Defina o Subnet creation mode (Modo de criação de sub-rede) como Custom (Personalizado).
    • Na secção Nova sub-rede, introduza as seguintes informações:
      • Nome: backend-subnet
      • Região: us-west1
      • Intervalo de endereços IP: 10.1.2.0/24
    • Clique em Concluído.

  5. Clique em Criar.

gcloud

  1. Crie a rede VPC personalizada com o comando gcloud compute networks create:

    gcloud compute networks create lb-network --subnet-mode=custom

  2. Crie uma sub-rede na rede lb-network na região us-west1 com o comando gcloud compute networks subnets create:

    gcloud compute networks subnets create backend-subnet \
    --network=lb-network \
    --range=10.1.2.0/24 \
    --region=us-west1

Terraform

Para criar a rede VPC, use o recurso google_compute_network.

resource "google_compute_network" "default" {
  name                    = "lb-network"
  auto_create_subnetworks = false
  routing_mode            = "REGIONAL"
}

Para criar a sub-rede da VPC na rede lb-network, use o recurso google_compute_subnetwork.

resource "google_compute_subnetwork" "default" {
  name                       = "backend-subnet"
  ip_cidr_range              = "10.1.2.0/24"
  network                    = google_compute_network.default.id
  private_ipv6_google_access = "DISABLE_GOOGLE_ACCESS"
  purpose                    = "PRIVATE"
  region                     = "us-west1"
  stack_type                 = "IPV4_ONLY"
}

API

  1. Faça um pedido POST ao método networks.insert, substituindo PROJECT_ID pelo ID do seu projeto.

    POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks
{
 "routingConfig": {
   "routingMode": "REGIONAL"
 },
 "name": "lb-network",
 "autoCreateSubnetworks": false
}

  2. Faça um pedido POST ao método subnetworks.insert, substituindo PROJECT_ID pelo ID do seu projeto.

    POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks
{
 "name": "backend-subnet",
 "network": "projects/PROJECT_ID/global/networks/lb-network",
 "ipCidrRange": "10.1.2.0/24",
 "region": "projects/PROJECT_ID/regions/us-west1",
}

Configure a sub-rede só de proxy

Uma sub-rede apenas de proxy fornece um conjunto de endereços IP que a Google usa para executar proxies do Envoy em seu nome. Os proxies terminam as ligações do cliente e criam novas ligações aos backends.

Esta sub-rede apenas de proxy é usada por todos os equilibradores de carga regionais baseados no Envoy na mesma região da rede VPC lb-network. Só pode existir uma sub-rede só de proxy ativa por região e por rede.

Consola

Se estiver a usar a Google Cloud consola, também pode esperar e criar a sub-rede apenas de proxy mais tarde na página Equilíbrio de carga.

Se quiser criar a sub-rede apenas de proxy agora, siga estes passos:

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

    Aceda a redes de VPC

  2. Clique no nome da rede da VPC: lb-network.

  3. Clique em Adicionar sub-rede.

  4. Em Nome, introduza proxy-only-subnet.

  5. Para Região, selecione us-west1.

  6. Defina Purpose como Regional Managed Proxy.

  7. Para o Intervalo de endereços IP, introduza 10.129.0.0/23.

  8. Clique em Adicionar.

gcloud

Crie a sub-rede só de proxy com o comando gcloud compute networks subnets create.

gcloud compute networks subnets create proxy-only-subnet \
  --purpose=REGIONAL_MANAGED_PROXY \
  --role=ACTIVE \
  --region=us-west1 \
  --network=lb-network \
  --range=10.129.0.0/23

Terraform

Para criar a sub-rede só de proxy da VPC na rede lb-network, use o recurso google_compute_subnetwork.

resource "google_compute_subnetwork" "proxy_only" {
  name          = "proxy-only-subnet"
  ip_cidr_range = "10.129.0.0/23"
  network       = google_compute_network.default.id
  purpose       = "REGIONAL_MANAGED_PROXY"
  region        = "us-west1"
  role          = "ACTIVE"
}

API

Crie a sub-rede apenas de proxy com o método subnetworks.insert, substituindo PROJECT_ID pelo ID do seu projeto.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks
{
  "name": "proxy-only-subnet",
  "ipCidrRange": "10.129.0.0/23",
  "network": "projects/PROJECT_ID/global/networks/lb-network",
  "region": "projects/PROJECT_ID/regions/us-west1",
  "purpose": "REGIONAL_MANAGED_PROXY",
  "role": "ACTIVE"
}

Configure regras de firewall

Este exemplo usa as seguintes regras de firewall:

  • fw-allow-health-check. Uma regra de entrada, aplicável às instâncias com balanceamento de carga, que permite todo o tráfego TCP dos Google Cloud sistemas de verificação de estado (em 130.211.0.0/22 e 35.191.0.0/16). Este exemplo usa a etiqueta de destino load-balanced-backend para identificar as VMs às quais a regra de firewall se aplica.

  • fw-allow-proxies. Uma regra de entrada, aplicável às instâncias com balanceamento de carga, que permite o tráfego TCP nas portas 80, 443 e 8080 dos proxies geridos do balanceador de carga de aplicações externo regional. Este exemplo usa a etiqueta load-balanced-backend de destino para identificar as VMs às quais a regra de firewall se aplica.

Sem estas regras de firewall, a regra de negação predefinida de entrada bloqueia o tráfego de entrada para as instâncias de back-end.

As etiquetas de destino definem as instâncias de back-end. Sem as etiquetas de destino, as regras da firewall aplicam-se a todas as instâncias de back-end na rede VPC. Quando criar as VMs de back-end, certifique-se de que inclui as etiquetas de destino especificadas, conforme mostrado em Criar um grupo de instâncias gerido.

Consola

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

    Aceda às regras de firewall

  2. Clique em Criar regra de firewall para criar a regra que permite Google Cloud verificações de funcionamento:

    • Nome: fw-allow-health-check
    • Rede: lb-network
    • Direção do tráfego: entrada
    • Ação na correspondência: Permitir
    • Objetivos: etiquetas de destino especificadas
    • Etiquetas de segmentação: load-balanced-backend
    • Filtro de origem: intervalos IPv4
    • Intervalos de IPv4 de origem: 130.211.0.0/22 e 35.191.0.0/16
    • Protocolos e portas:
      • Escolha Protocolos e portas especificados.
      • Selecione a caixa de verificação TCP e, de seguida, introduza 80 para o número da porta.
        Como prática recomendada, limite esta regra apenas aos protocolos e às portas que correspondem aos usados pela sua verificação de estado. Se usar tcp:80 para o protocolo e a porta, Google Cloud pode usar o HTTP na porta 80 para contactar as suas VMs, mas não pode usar o HTTPS na porta 443 para as contactar.

  3. Clique em Criar.

  4. Clique em Criar regra de firewall para criar a regra que permite que os servidores proxy do balanceador de carga se liguem aos back-ends:

    • Nome: fw-allow-proxies
    • Rede: lb-network
    • Direção do tráfego: entrada
    • Ação na correspondência: Permitir
    • Objetivos: etiquetas de destino especificadas
    • Etiquetas de segmentação: load-balanced-backend
    • Filtro de origem: intervalos IPv4
    • Intervalos IPv4 de origem: 10.129.0.0/23
    • Protocolos e portas:
      • Escolha Protocolos e portas especificados.
      • Selecione a caixa de verificação TCP e, de seguida, introduza 80, 443, 8080 para os números de porta.

  5. Clique em Criar.

gcloud

  1. Crie a regra fw-allow-health-check para permitir Google Cloud verificações de funcionamento. Este exemplo permite todo o tráfego TCP de sondas de verificação de estado. No entanto, pode configurar um conjunto mais restrito de portas para satisfazer as suas necessidades.

    gcloud compute firewall-rules create fw-allow-health-check \
    --network=lb-network \
    --action=allow \
    --direction=ingress \
    --source-ranges=130.211.0.0/22,35.191.0.0/16 \
    --target-tags=load-balanced-backend \
    --rules=tcp

  2. Crie a regra fw-allow-proxies para permitir que os proxies do Application Load Balancer externo regional se liguem aos seus back-ends. Defina source-ranges para os intervalos atribuídos da sua sub-rede só de proxy, por exemplo, 10.129.0.0/23.

    gcloud compute firewall-rules create fw-allow-proxies \
  --network=lb-network \
  --action=allow \
  --direction=ingress \
  --source-ranges=source-range \
  --target-tags=load-balanced-backend \
  --rules=tcp:80,tcp:443,tcp:8080

Terraform

Para criar as regras de firewall, use o recurso google_compute_firewall.

resource "google_compute_firewall" "default" {
  name = "fw-allow-health-check"
  allow {
    protocol = "tcp"
  }
  direction     = "INGRESS"
  network       = google_compute_network.default.id
  priority      = 1000
  source_ranges = ["130.211.0.0/22", "35.191.0.0/16"]
  target_tags   = ["load-balanced-backend"]
}
 
resource "google_compute_firewall" "allow_proxy" {
  name = "fw-allow-proxies"
  allow {
    ports    = ["443"]
    protocol = "tcp"
  }
  allow {
    ports    = ["80"]
    protocol = "tcp"
  }
  allow {
    ports    = ["8080"]
    protocol = "tcp"
  }
  direction     = "INGRESS"
  network       = google_compute_network.default.id
  priority      = 1000
  source_ranges = ["10.129.0.0/23"]
  target_tags   = ["load-balanced-backend"]
}

API

Crie a regra de firewall fw-allow-health-check fazendo um pedido POST ao método firewalls.insert, substituindo PROJECT_ID pelo ID do seu projeto.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/firewalls
{
  "name": "fw-allow-health-check",
  "network": "projects/PROJECT-ID/global/networks/lb-network",
  "sourceRanges": [
    "130.211.0.0/22",
    "35.191.0.0/16"
  ],
  "targetTags": [
    "load-balanced-backend"
  ],
  "allowed": [
    {
      "IPProtocol": "tcp"
    }
  ],
  "direction": "INGRESS"
}

Crie a regra de firewall fw-allow-proxies para permitir o tráfego TCP no método firewalls.insert, substituindo PROJECT_ID pelo ID do seu projeto.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/firewalls
{
  "name": "fw-allow-proxies",
  "network": "projects/PROJECT_ID/global/networks/lb-network",
  "sourceRanges": [
    "10.129.0.0/23"
  ],
  "targetTags": [
    "load-balanced-backend"
  ],
  "allowed": [
    {
      "IPProtocol": "tcp",
      "ports": [
        "80"
      ]
    },
    {
      "IPProtocol": "tcp",
      "ports": [
        "443"
      ]
    },
    {
      "IPProtocol": "tcp",
      "ports": [
        "8080"
      ]
    }
  ],
  "direction": "INGRESS"
}

Configure um Application Load Balancer externo regional com um serviço baseado em VMs

Esta secção mostra a configuração necessária para os serviços executados em VMs do Compute Engine. As VMs cliente estabelecem ligação ao endereço IP e à porta que configura na regra de encaminhamento. Quando as aplicações cliente enviam tráfego para este endereço IP e porta, os respetivos pedidos são encaminhados para as máquinas virtuais (VMs) de back-end de acordo com o mapa de URLs do Application Load Balancer externo regional.

O exemplo nesta página cria explicitamente um endereço IP externo reservado para a regra de encaminhamento do Application Load Balancer externo regional, em vez de permitir a atribuição de um endereço IP externo efémero. Como prática recomendada, recomendamos que reserve endereços IP para regras de encaminhamento.

Crie um back-end de grupo de instâncias geridas

Esta secção mostra como criar um modelo e um grupo de instâncias gerido. O grupo de instâncias gerido fornece instâncias de VM que executam os servidores de back-end de um exemplo de balanceador de carga de aplicações externo regional. O tráfego dos clientes é equilibrado em carga para estes servidores de back-end. Para fins de demonstração, os back-ends publicam os seus próprios nomes de anfitrião.

Consola

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

    Aceda a Modelos de instâncias

    1. Clique em Criar modelo de instância.
    2. Em Nome, introduza l7-xlb-backend-template.
    3. Certifique-se de que o Disco de arranque está definido para uma imagem do Debian, como Debian GNU/Linux 12 (bookworm). Estas instruções usam comandos que só estão disponíveis no Debian, como apt-get.
    4. Clique em Opções avançadas.
    5. Clique em Rede e configure os seguintes campos:
      1. Para etiquetas de rede, introduza load-balanced-backend.
      2. Para Interfaces de rede, selecione o seguinte:
        • Rede: lb-network
        • Subnet: backend-subnet

    6. Clique em Gestão. Introduza o seguinte script no campo Script de arranque.

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

    7. Clique em Criar.

  2. Crie um grupo de instâncias gerido. Na Google Cloud consola, aceda à página Grupos de instâncias.

    Aceda a Grupos de instâncias

    1. Clique em Criar grupo de instâncias.
    2. Selecione Novo grupo de instâncias gerido (sem estado). Para mais informações, consulte o artigo Grupos de instâncias geridos sem estado ou com estado.
    3. Em Nome, introduza l7-xlb-backend-example.
    4. Para Localização, selecione Zona única.
    5. Para Região, selecione us-west1.
    6. Para Zona, selecione us-west1-a.
    7. Para Modelo de instância, selecione l7-xlb-backend-template.

    8. Para o Modo de escalamento 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.

    9. Clique em Criar.

gcloud

As instruções gcloud neste guia pressupõem que está a usar o Cloud Shell ou outro ambiente com o bash instalado.

  1. Crie um modelo de instância de VM com um servidor HTTP com o comando gcloud compute instance-templates create.

    gcloud compute instance-templates create l7-xlb-backend-template \
--region=us-west1 \
--network=lb-network \
--subnet=backend-subnet \
--tags=load-balanced-backend \
--image-family=debian-12 \
--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'

  2. Crie um grupo de instâncias gerido na zona com o comando gcloud compute instance-groups managed create.

    gcloud compute instance-groups managed create l7-xlb-backend-example \
    --zone=us-west1-a \
    --size=2 \
    --template=l7-xlb-backend-template

Terraform

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

resource "google_compute_instance_template" "default" {
  name = "l7-xlb-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-12"
    type         = "PERSISTENT"
  }
  labels = {
    managed-by-cnrm = "true"
  }
  machine_type = "n1-standard-1"
  metadata = {
    startup-script = <<EOF
    #! /bin/bash
    sudo apt-get update
    sudo apt-get install apache2 -y
    sudo a2ensite default-ssl
    sudo a2enmod ssl
    vm_hostname="$(curl -H "Metadata-Flavor:Google" \
    http://169.254.169.254/computeMetadata/v1/instance/name)"
    sudo echo "Page served from: $vm_hostname" | \
    tee /var/www/html/index.html
    sudo systemctl restart apache2
    EOF
  }
  network_interface {
    access_config {
      network_tier = "PREMIUM"
    }
    network    = google_compute_network.default.id
    subnetwork = google_compute_subnetwork.default.id
  }
  region = "us-west1"
  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 = ["load-balanced-backend"]
}

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

resource "google_compute_instance_group_manager" "default" {
  name = "l7-xlb-backend-example"
  zone = "us-west1-a"
  named_port {
    name = "http"
    port = 80
  }
  version {
    instance_template = google_compute_instance_template.default.id
    name              = "primary"
  }
  base_instance_name = "vm"
  target_size        = 2
}

API

  1. Crie o modelo de instância com o método instanceTemplates.insert e substitua PROJECT_ID pelo ID do projeto.

    POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/instanceTemplates
{
 "name":"l7-xlb-backend-template",
 "properties": {
   "machineType":"e2-standard-2",
   "tags": {
     "items":[
       "load-balanced-backend"
     ]
   },
   "metadata": {
     "kind":"compute#metadata",
     "items":[
       {
         "key":"startup-script",
         "value":"#! /bin/bash\napt-get update\napt-get install apache2 -y\na2ensite default-ssl\na2enmod ssl\nvm_hostname=\"$(curl -H \"Metadata-Flavor:Google\" \\\nhttp://metadata.google.internal/computeMetadata/v1/instance/name)\"\necho \"Page served from: $vm_hostname\" | \\\ntee /var/www/html/index.html\nsystemctl restart apache2"
       }
     ]
   },
   "networkInterfaces":[
     {
       "network":"projects/PROJECT_ID/global/networks/lb-network",
       "subnetwork":"regions/us-west1/subnetworks/backend-subnet",
       "accessConfigs":[
         {
           "type":"ONE_TO_ONE_NAT"
         }
       ]
     }
   ],
   "disks": [
     {
       "index":0,
       "boot":true,
       "initializeParams": {
         "sourceImage":"projects/debian-cloud/global/images/family/debian-12"
       },
       "autoDelete":true
     }
   ]
 }
}

  2. Crie um grupo de instâncias gerido em cada zona com o método instanceGroupManagers.insert, substituindo PROJECT_ID pelo ID do seu projeto.

    POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/{zone}/instanceGroupManagers
{
 "name": "l7-xlb-backend-example",
 "zone": "projects/PROJECT_ID/zones/us-west1-a",
 "instanceTemplate": "projects/PROJECT_ID/global/instanceTemplates/l7-xlb-backend-template",
 "baseInstanceName": "l7-xlb-backend-example",
 "targetSize": 2
}

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 back-end do balanceador de carga encaminha o tráfego para a porta designada.

Consola

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

    Aceda a Grupos de instâncias

  2. Clique no nome do grupo de instâncias (neste exemplo, l7-xlb-backend-example).

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

  4. Clique em Especificar mapeamento do nome da porta.

  5. Clique em Adicionar item.

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

  7. Clique em Guardar.

gcloud

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

gcloud compute instance-groups set-named-ports l7-xlb-backend-example \
    --named-ports http:80 \
    --zone us-west1-a

Terraform

O atributo named_port está incluído no exemplo de grupo de instâncias gerido.

Reserve o endereço IP do balanceador de carga

Reserve um endereço IP estático para o balanceador de carga.

Consola

  1. Na Google Cloud consola, aceda à página Reserve um endereço estático.

    Aceda a Reservar um endereço estático

  2. Escolha um Nome para a nova morada.

  3. Para Nível de serviço de rede, selecione Padrão.

  4. Para Versão de IP, selecione IPv4. Os endereços IPv6 só podem ser globais e só podem ser usados com equilibradores de carga globais.

  5. Para Tipo, selecione Regional.

  6. Para Região, selecione us-west1.

  7. Deixe a opção Anexado a definida como Nenhum. Depois de criar o balanceador de carga, este endereço IP é anexado à regra de encaminhamento do balanceador de carga.

  8. Clique em Reservar para reservar o endereço IP.

gcloud

  1. Para reservar um endereço IP externo estático através do gcloud compute, use o comando compute addresses create.

    gcloud compute addresses create ADDRESS_NAME  \
   --region=us-west1 \
   --network-tier=STANDARD

    Substitua o seguinte:

    • ADDRESS_NAME: o nome que quer dar a esta morada.
    • REGION: a região onde quer reservar esta morada. Esta região deve ser a mesma região que o balanceador de carga. Todos os endereços IP regionais são IPv4.

  2. Use o comando compute addresses describe para ver o resultado:

    gcloud compute addresses describe ADDRESS_NAME

Terraform

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

resource "google_compute_address" "default" {
  name         = "address-name"
  address_type = "EXTERNAL"
  network_tier = "STANDARD"
  region       = "us-west1"
}

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

API

Para criar um endereço IPv4 regional, chame o método regional addresses.insert:

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION/addresses

O corpo do pedido deve conter o seguinte:

{
  "name": "ADDRESS_NAME"
  "networkTier": "STANDARD"
  "region": "us-west1"
}

Substitua o seguinte:

  • ADDRESS_NAME: o nome do endereço
  • REGION: o nome da região para este pedido
  • PROJECT_ID: o ID do projeto para este pedido

Configure o balanceador de carga

Este exemplo mostra como criar os seguintes recursos do Application Load Balancer externo regional:

  • Verificação de funcionamento de HTTP
  • Serviço de back-end com um grupo de instâncias geridas como back-end
  • Um mapa de URLs
    • Certifique-se de que faz referência a um mapa de URLs regional se for definida uma região para o proxy HTTP(S) de destino. Um mapa de URLs regional encaminha pedidos para um serviço de back-end regional com base em regras que define para o anfitrião e o caminho de um URL recebido. Um mapa de URLs regional só pode ser referenciado por uma regra de proxy de destino regional na mesma região.
  • Certificado SSL (para HTTPS)
  • Proxy de destino
  • Regra de encaminhamento

Disponibilidade do proxy

Por vezes, Google Cloud as regiões não têm capacidade de proxy suficiente para um novo balanceador de carga. Se isto acontecer, a Google Cloud consola apresenta uma mensagem de aviso de disponibilidade de proxy quando estiver a criar o equilibrador de carga. Para resolver este problema, pode fazer uma das seguintes ações:

  • Selecione uma região diferente para o balanceador de carga. Esta pode ser uma opção prática se tiver back-ends noutra região.
  • Selecione uma rede de VPC que já tenha uma sub-rede apenas de proxy atribuída.

  • Aguarde pela resolução do problema de capacidade.

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 regionais e clique em Seguinte.
  6. Clique em Configurar.

Configuração básica

  1. Para o nome do balanceador de carga, introduza regional-l7-xlb.
  2. Para Região, selecione us-west1.
  3. Para Rede, selecione lb-network.

Reserve uma sub-rede só de proxy

Para um Application Load Balancer externo regional, reserve uma sub-rede apenas de proxy:

  1. Clique em Reservar sub-rede.
  2. Em Nome, introduza proxy-only-subnet.
  3. Para o Intervalo de endereços IP, introduza 10.129.0.0/23.
  4. Clique em Adicionar.

Configure o front-end

Para HTTP:

  1. Clique em Configuração do front-end.
  2. Defina Nome como l7-xlb-forwarding-rule.
  3. Defina Protocol como HTTP.
  4. Defina o Nível do serviço de rede como Padrão.
  5. Defina Porta como 80.
  6. Selecione o endereço IP que criou em Reservar o endereço IP do balanceador de carga.
  7. Clique em Concluído.

Para HTTPS:

  1. Clique em Configuração do front-end.
  2. No campo Nome, introduza l7-xlb-forwarding-rule.
  3. No campo Protocolo, selecione HTTPS (includes HTTP/2).
  4. Defina o Nível do serviço de rede como Padrão.
  5. Certifique-se de que a Porta está definida como 443.
  6. Selecione o endereço IP que criou em Reservar o endereço IP do balanceador de carga.

  7. Para atribuir um certificado SSL ao proxy HTTPS de destino do equilibrador de carga, pode usar um certificado SSL do Compute Engine ou um certificado do Gestor de certificados.

    1. Para anexar um certificado do Gestor de certificados ao proxy HTTPS de destino do equilibrador de carga, na secção Escolher repositório de certificados, selecione Certificados.

      Se já tiver um certificado do Gestor de certificados para selecionar, faça o seguinte:

      1. Clique em Adicionar certificado.
      2. Clique em Selecionar um certificado existente e selecione o certificado na lista de certificados.
      3. Clique em Selecionar.

      Depois de selecionar o novo certificado do Gestor de certificados, este aparece na lista de certificados.

      Para criar um novo certificado do Gestor de certificados, faça o seguinte:

      1. Clique em Adicionar certificado.
      2. Clique em Criar um novo certificado.

      3. Para criar um novo certificado, siga os passos a partir do passo 3, conforme descrito num dos seguintes métodos de configuração na documentação do Gestor de certificados:

      Depois de criar o novo certificado do Gestor de certificados, este aparece na lista de certificados.

    2. Para anexar um certificado SSL do Compute Engine ao proxy HTTPS de destino do balanceador de carga, na secção Escolher repositório de certificados, selecione Certificados clássicos.

      1. Na lista Certificado, faça o seguinte:
        1. Se já tiver um recurso de certificado SSL autogerido do Compute Engine, selecione o certificado SSL principal.
        2. Clique em Criar um novo certificado.
          1. No campo Nome, introduza l7-xlb-cert.
          2. Nos campos adequados, carregue os seus ficheiros formatados em PEM:
            • Certificado
            • Chave privada
          3. Clique em Criar.
        3. Opcional: para adicionar certificados além do certificado SSL principal:
          1. Clique em Adicionar certificado.
          2. Se já tiver um certificado, selecione-o na lista Certificados.
          3. Opcional: clique em Criar um novo certificado e siga as instruções especificadas no passo anterior.

  8. Selecione uma política SSL na lista Política SSL. Opcionalmente, para criar uma política de SSL, faça o seguinte:

    1. Na lista Política de SSL, selecione Criar uma política.
    2. Introduza um nome para a política SSL.
    3. Selecione uma versão de TLS mínima. O valor predefinido é TLS 1.0.
    4. Selecione um dos perfis pré-configurados geridos pela Google ou selecione um perfil Personalizado que lhe permite selecionar funcionalidades SSL individualmente. 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 Google Cloud predefinida Google Cloud .

  9. Clique em Concluído.

Configure o serviço de back-end

  1. Clique em Configuração de back-end.
  2. No menu Criar ou selecionar serviços de back-end, selecione Criar um serviço de back-end.
  3. Defina o nome do serviço de back-end como l7-xlb-backend-service.
  4. Para Protocolo, selecione HTTP.
  5. Em Porta com nome, introduza http.
  6. Defina o Tipo de back-end como Grupo de instâncias.
  7. Na lista Verificação de funcionamento, clique em Criar uma verificação de funcionamento e, de seguida, introduza as seguintes informações:
    • No campo Nome, introduza l7-xlb-basic-check.
    • Na lista Protocolo, selecione HTTP.
    • No campo Porta, introduza 80.
  8. Clique em Criar.
  9. Na secção Novo back-end:
    1. Defina Grupo de instâncias como l7-xlb-backend-example.
    2. Defina Transferir números como 80.
    3. Defina o Modo de equilíbrio como Utilização.
    4. Clique em Concluído.
  10. Clique em Criar.

Configure as regras de encaminhamento

  1. Clique em Regras de encaminhamento.
  2. Para Modo, selecione Regra de anfitrião e caminho simples.
  3. Certifique-se de que o l7-xlb-backend-service é o único serviço de back-end para qualquer anfitrião não correspondente e qualquer caminho não correspondente.

Reveja a configuração

  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 equilibrador de carga.
  4. Clique em Criar.

gcloud

  1. Defina a verificação de funcionamento de HTTP com o comando gcloud compute health-checks create http.

    gcloud compute health-checks create http l7-xlb-basic-check \
   --region=us-west1 \
   --request-path='/' \
   --use-serving-port

  2. Defina o serviço de back-end com o comando gcloud compute backend-services create.

    gcloud compute backend-services create l7-xlb-backend-service \
  --load-balancing-scheme=EXTERNAL_MANAGED \
  --protocol=HTTP \
  --port-name=http \
  --health-checks=l7-xlb-basic-check \
  --health-checks-region=us-west1 \
  --region=us-west1

  3. Adicione back-ends ao serviço de back-end com o comando gcloud compute backend-services add-backend.

    gcloud compute backend-services add-backend l7-xlb-backend-service \
  --balancing-mode=UTILIZATION \
  --instance-group=l7-xlb-backend-example \
  --instance-group-zone=us-west1-a \
  --region=us-west1

  4. Crie o mapa de URLs com o comando gcloud compute url-maps create.

    gcloud compute url-maps create regional-l7-xlb-map \
  --default-service=l7-xlb-backend-service \
  --region=us-west1

  5. Crie o proxy de destino.

    Para HTTP:

    Para um balanceador de carga HTTP, crie o proxy de destino com o comando gcloud compute target-http-proxies create.

    gcloud compute target-http-proxies create l7-xlb-proxy \
  --url-map=regional-l7-xlb-map \
  --url-map-region=us-west1 \
  --region=us-west1

    Para HTTPS:

    Pode criar certificados do Compute Engine ou do Certificate Manager. Use qualquer um dos seguintes métodos para criar certificados através do gestor de certificados:

    Depois de criar os certificados, anexe-os diretamente ao proxy de destino.

    1. Atribua os caminhos de ficheiros a nomes de variáveis.

      export LB_CERT=path to PEM-formatted file

      export LB_PRIVATE_KEY=path to PEM-formatted file

    2. Crie um certificado SSL regional com o comando gcloud compute ssl-certificates create.

      gcloud compute ssl-certificates create l7-xlb-cert \
 --certificate=$LB_CERT \
 --private-key=$LB_PRIVATE_KEY \
 --region=us-west1

    3. Use o certificado SSL regional para criar um proxy de destino com o comando gcloud compute target-https-proxies create.

      gcloud compute target-https-proxies create l7-xlb-proxy \
 --url-map=regional-l7-xlb-map \
 --region=us-west1 \
 --ssl-certificates=l7-xlb-cert

  6. Crie a regra de encaminhamento.

    Para HTTP:

    Use o comando gcloud compute forwarding-rules create com as flags corretas.

    gcloud compute forwarding-rules create l7-xlb-forwarding-rule \
  --load-balancing-scheme=EXTERNAL_MANAGED \
  --network-tier=STANDARD \
  --network=lb-network \
  --address=ADDRESS_NAME \
  --ports=80 \
  --region=us-west1 \
  --target-http-proxy=l7-xlb-proxy \
  --target-http-proxy-region=us-west1

    Para HTTPS:

    Crie a regra de encaminhamento com o comando gcloud compute forwarding-rules create com as flags corretas.

    gcloud compute forwarding-rules create l7-xlb-forwarding-rule \
  --load-balancing-scheme=EXTERNAL_MANAGED \
  --network-tier=STANDARD \
  --network=lb-network \
  --address=ADDRESS_NAME \
  --ports=443 \
  --region=us-west1 \
  --target-https-proxy=l7-xlb-proxy \
  --target-https-proxy-region=us-west1

Terraform

Para criar a verificação de funcionamento, use o recurso google_compute_region_health_check.

resource "google_compute_region_health_check" "default" {
  name               = "l7-xlb-basic-check"
  check_interval_sec = 5
  healthy_threshold  = 2
  http_health_check {
    port_specification = "USE_SERVING_PORT"
    proxy_header       = "NONE"
    request_path       = "/"
  }
  region              = "us-west1"
  timeout_sec         = 5
  unhealthy_threshold = 2
}

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

resource "google_compute_region_backend_service" "default" {
  name                  = "l7-xlb-backend-service"
  region                = "us-west1"
  load_balancing_scheme = "EXTERNAL_MANAGED"
  health_checks         = [google_compute_region_health_check.default.id]
  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 URLs, use o recurso google_compute_region_url_map.

resource "google_compute_region_url_map" "default" {
  name            = "regional-l7-xlb-map"
  region          = "us-west1"
  default_service = google_compute_region_backend_service.default.id
}

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

resource "google_compute_region_target_http_proxy" "default" {
  name    = "l7-xlb-proxy"
  region  = "us-west1"
  url_map = google_compute_region_url_map.default.id
}

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

resource "google_compute_forwarding_rule" "default" {
  name       = "l7-xlb-forwarding-rule"
  provider   = google-beta
  depends_on = [google_compute_subnetwork.proxy_only]
  region     = "us-west1"

  ip_protocol           = "TCP"
  load_balancing_scheme = "EXTERNAL_MANAGED"
  port_range            = "80"
  target                = google_compute_region_target_http_proxy.default.id
  network               = google_compute_network.default.id
  ip_address            = google_compute_address.default.id
  network_tier          = "STANDARD"
}

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

API

Crie a verificação de funcionamento fazendo um pedido POST ao método regionHealthChecks.insert, substituindo PROJECT_ID pelo ID do seu projeto.

POST https://compute.googleapis.com/compute/v1/projects/<var>PROJECT_ID</var>/regions/{region}/healthChecks
{
  "name": "l7-xlb-basic-check",
  "type": "HTTP",
  "httpHealthCheck": {
    "portSpecification": "USE_SERVING_PORT"
  }
}

Crie o serviço de back-end regional fazendo um pedido POST ao método regionBackendServices.insert, substituindo PROJECT_ID pelo ID do seu projeto.

POST https://compute.googleapis.com/compute/v1/projects/<var>PROJECT_ID</var>/regions/us-west1/backendServices
{
  "name": "l7-xlb-backend-service",
  "backends": [
    {
      "group": "projects/<var>PROJECT_ID</var>/zones/us-west1-a/instanceGroups/l7-xlb-backend-example",
      "balancingMode": "UTILIZATION"
    }
  ],
  "healthChecks": [
    "projects/<var>PROJECT_ID</var>/regions/us-west1/healthChecks/l7-xlb-basic-check"
  ],
  "loadBalancingScheme": "EXTERNAL_MANAGED"
}

Crie o mapa de URLs fazendo um pedido POST ao método regionUrlMaps.insert, substituindo PROJECT_ID pelo ID do seu projeto.

POST https://compute.googleapis.com/compute/v1/projects/<var>PROJECT_ID</var>/regions/us-west1/urlMaps
{
  "name": "regional-l7-xlb-map",
  "defaultService": "projects/<var>PROJECT_ID</var>/regions/us-west1/backendServices/l7-xlb-backend-service"
}

Crie o proxy HTTP de destino fazendo um pedido POST ao método regionTargetHttpProxies.insert, substituindo PROJECT_ID pelo ID do seu projeto.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/targetHttpProxy
{
  "name": "l7-xlb-proxy",
  "urlMap": "projects/PROJECT_ID/global/urlMaps/regional-l7-xlb-map",
  "region": "us-west1"
}

Crie a regra de encaminhamento fazendo um pedido POST ao método forwardingRules.insert, substituindo PROJECT_ID pelo ID do seu projeto.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/forwardingRules
{
  "name": "l7-xlb-forwarding-rule",
  "IPAddress": "10.1.2.99",
  "IPProtocol": "TCP",
  "portRange": "80-80",
  "target": "projects/PROJECT_ID/regions/us-west1/targetHttpProxies/l7-xlb-proxy",
  "loadBalancingScheme": "EXTERNAL_MANAGED",
  "network": "projects/PROJECT_ID/global/networks/lb-network",
  "networkTier": "STANDARD",
}

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 balanceador de carga

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. Selecione o equilibrador de carga que acabou de criar.
  3. Na secção Backend, confirme que as VMs estão em bom estado. A coluna Em bom estado deve estar preenchida, o que indica que ambas as VMs estão em bom estado (2/2). Caso contrário, experimente primeiro recarregar a página. A Google Cloud consola pode demorar alguns momentos 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. Depois de a Google Cloud consola mostrar que as instâncias de back-end estão em bom estado, pode testar o equilibrador 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 equilibrador de carga.
  5. Se usou um certificado autoassinado para testar o HTTPS, o seu navegador apresenta um aviso. Tem de instruir explicitamente o navegador para aceitar um certificado autoassinado.
  6. 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

Tome nota do endereço IPv4 que foi reservado:

gcloud beta compute addresses describe ADDRESS_NAME \
    --format="get(address)" \
    --region="us-west1"

Pode testar o equilibrador 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 equilibrador de carga.

Se usou um certificado autoassinado para testar o HTTPS, o navegador apresenta um aviso. Tem de instruir explicitamente o navegador para aceitar um certificado autossinado.

O navegador deve renderizar uma página com informações mínimas sobre a instância de back-end. Se o navegador não renderizar esta página, reveja as definições de configuração neste guia.

Opções de configuração adicionais

Esta secção expande o exemplo de configuração para oferecer opções de configuração alternativas e adicionais. Todas as tarefas são opcionais. Pode realizá-las por qualquer ordem.

Ative a afinidade de sessão

Estes procedimentos mostram como atualizar um serviço de back-end para o exemplo de Application Load Balancer externo regional, de modo que o serviço de back-end use a afinidade de cookies gerada, a afinidade de campos de cabeçalho ou a afinidade de cookies HTTP.

Quando a afinidade de cookie gerado está ativada, o equilibrador de carga emite um cookie no primeiro pedido. Para cada pedido subsequente com o mesmo cookie, o balanceador de carga direciona o pedido para a mesma VM ou ponto final de back-end. Para balanceadores de carga de aplicações externos regionais, o cookie chama-se GCILB.

Quando a afinidade do campo de cabeçalho está ativada, o balanceador de carga encaminha os pedidos para VMs ou pontos finais de back-end num NEG com base no valor do cabeçalho HTTP denominado no parâmetro --custom-request-header. A afinidade do campo de cabeçalho só é válida se a política de localidade de equilíbrio de carga for RING_HASH ou MAGLEV e o hash consistente do serviço de back-end especificar o nome do cabeçalho HTTP.

Quando a afinidade de cookies HTTP está ativada, o balanceador de carga encaminha pedidos para VMs ou pontos finais de back-end num NEG, com base num cookie HTTP denominado no parâmetro HTTP_COOKIE com o parâmetro --affinity-cookie-ttl opcional. Se o cliente não fornecer o cookie no respetivo pedido HTTP, o proxy gera o cookie e devolve-o ao cliente num cabeçalho Set-Cookie. A afinidade de cookies HTTP só é válida se a política de localidade de equilíbrio de carga for RING_HASH ou MAGLEV e o hash consistente do serviço de back-end especificar o cookie HTTP.

Consola

Para ativar ou alterar a afinidade de sessão para um serviço de back-end:

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

    Aceda a Balanceamento de carga

  2. Selecione o equilibrador de carga que acabou de criar.

  3. Clique em Back-ends.

  4. Clique em l7-xlb-backend-service (o nome do serviço de back-end que criou para este exemplo) e clique em Editar.

  5. Na página Detalhes do serviço de back-end, clique em Configuração avançada.

  6. Para Afinidade de sessão, selecione o tipo de afinidade de sessão que quer no menu.

  7. Clique em Atualizar.

gcloud

Use os seguintes comandos para atualizar o l7-xlb-backend-serviceserviço de back-end para diferentes tipos de afinidade de sessão:

gcloud compute backend-services update l7-xlb-backend-service \
    --session-affinity=GENERATED_COOKIE | HEADER_FIELD | HTTP_COOKIE | CLIENT_IP
    --region=us-west1

API

Para definir a afinidade de sessão, faça um pedido PATCH ao regionBackendServices/patch método.

PATCH https://compute.googleapis.com/compute/v1/projects/<var>PROJECT_ID</var>/regions/us-west1/regionBackendServices/l7-xlb-backend-service
{
  "sessionAffinity": <var>"GENERATED_COOKIE" | "HEADER_FIELD" | "HTTP_COOKIE" | "CLIENT_IP"</var>
}

Atualize o tempo limite de manutenção ativa de HTTP do cliente

O balanceador de carga criado nos passos anteriores foi configurado com um valor predefinido para o tempo limite de manutenção ativa do HTTP do cliente.

Para atualizar o limite de tempo limite de manutenção ativa HTTP do cliente, siga as instruções abaixo.

Consola

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

    Aceda a Balanceamento de carga.

  2. Clique no nome do equilibrador de carga que quer modificar.
  3. Clique em Editar.
  4. Clique em Configuração do front-end.
  5. Expanda Funcionalidades avançadas. Para Limite de tempo de manutenção ativa de HTTP, introduza um valor de limite de tempo.
  6. Clique em Atualizar.
  7. Para rever as alterações, clique em Rever e finalizar e, de seguida, clique em Atualizar.

gcloud

Para um balanceador de carga HTTP, atualize o proxy HTTP de destino através do 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 \
          --region=REGION

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

      gcloud compute target-https-proxies update TARGET_HTTP_PROXY_NAME \
          --http-keep-alive-timeout-sec=HTTP_KEEP_ALIVE_TIMEOUT_SEC \
          --region REGION

Substitua o seguinte:

  • 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 valor de tempo limite de manutenção ativa de HTTP de 5 a 600 segundos.

Ative a IAP no Application Load Balancer externo

Pode configurar as CAs para estarem ativadas ou desativadas (predefinição). Se a opção estiver ativada, tem de fornecer valores para oauth2-client-id e oauth2-client-secret.

Para ativar as CAs, atualize o serviço de back-end para incluir a flag --iap=enabled com oauth2-client-id e oauth2-client-secret.

Opcionalmente, pode ativar a IAP para um recurso do Compute Engine através da Google Cloud consola, da CLI gcloud ou da API.

O que se segue?