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

Neste documento, você aprenderá a configurar um balanceador de carga de aplicativo regional para seus serviços executados em VMs do Compute Engine.

Como os balanceadores de carga de aplicativo externos regionais permitem criar balanceadores de carga em regiões específicas, eles geralmente são usados para cargas de trabalho com requisitos de conformidade jurisdicional. As cargas de trabalho que exigem acesso à saída do nível de rede padrão são outro caso de uso comum para balanceadores de carga de aplicativo externos regionais, porque eles são compatíveis com o nível de serviço de rede padrão do Google Analytics.

Antes de seguir as instruções deste guia, familiarize-se com os itens abaixo:

• Visão geral do balanceador de carga de aplicativo externo
• Visão geral das regras de firewall da VPC

Permissões

Para seguir as instruções deste guia, você precisa ser capaz de criar instâncias e modificar uma rede em um projeto. É necessário ser um proprietário ou editor de projeto, ou ter todos os seguintes papéis do IAM do Compute Engine:

Tarefa	Papel necessário
Criar redes, sub-redes e componentes do balanceador de carga	Administrador de rede
Adicionar e remover regras de firewall	Administrador de segurança
Criar instâncias	Administrador de instâncias

Para mais informações, consulte estes guias:

• Controle de acesso
• Condições do IAM

Visão geral da configuração

É possível configurar um balanceador de carga de aplicativo externo regional conforme descrito no fluxo de configuração de alto nível a seguir. As etapas numeradas se referem aos números no diagrama.

Componentes numerados do balanceador de carga de aplicativo externo regional (clique para ampliar)

Conforme mostrado no diagrama, este exemplo cria um balanceador de carga HTTP(S) externo regional em uma 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 estes elementos:

1. Uma rede VPC com duas sub-redes:

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

   2. Uma sub-rede é uma sub-rede somente proxy na região us-west1. É necessário criar uma sub-rede somente proxy em cada região de uma rede VPC em que você usa balanceadores de carga HTTP(S) externos regionais. A sub-rede somente proxy da região é compartilhada com 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 alocados da sub-rede somente proxy. Neste exemplo, a sub-rede somente proxy da região tem um intervalo de endereços IP primário de 10.129.0.0/23, que é o tamanho de sub-rede recomendado. Para mais informações, consulte Sub-redes somente proxy.

2. Uma regra de firewall que permite o fluxo de sub-rede somente proxy na rede. Isso significa adicionar uma regra que permita o tráfego das portas TCP 80, 443 e 8080 de 10.129.0.0/23 (o intervalo da sub-rede somente proxy neste exemplo). Outra regra de firewall para as sondagens de verificação de integridade.

3. Instâncias de back-end.

4. Grupos de instâncias:

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

   Em cada zona, é possível ter uma combinação de tipos de grupos de back-end com base nos requisitos da implantação.

5. Uma verificação de integridade regional que informa a prontidão dos back-ends.

6. Um serviço de back-end regional que monitora o uso e a integridade dos back-ends.

7. Um mapa de URL regional que analisa o URL de uma solicitação e encaminha solicitações a serviços de back-end específicos com base no host e no caminho do URL de solicitação.

8. Um proxy HTTP ou HTTPS de destino regional, que recebe uma solicitação do usuário e a encaminha ao mapa de URL. Em HTTPS, configure um recurso de certificado regional de SSL. O proxy de destino pode usar o certificado SSL ou o do Gerenciador de certificados para descriptografar o tráfego SSL se você configurar o balanceamento de carga HTTPS. O proxy de destino pode encaminhar o tráfego para suas instâncias usando HTTP ou HTTPS.

9. Uma regra de encaminhamento, que tem o endereço IP externo do seu balanceador de carga, para encaminhar cada solicitação recebida ao proxy de destino.

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

Configurar a rede e as sub-redes

Você precisa de uma rede VPC com duas sub-redes: uma para os back-ends do balanceador de carga e a outra para os proxies do balanceador de carga. Um balanceador de carga de aplicativo externo regional é regional. O tráfego na rede VPC será direcionado ao balanceador de carga se a origem do tráfego estiver em uma sub-rede na mesma região que o balanceador de carga.

Neste exemplo, usamos a seguinte rede VPC, região e sub-redes:

• Rede: uma rede VPC de modo personalizado chamada lb-network.

• Sub-rede para back-ends: uma sub-rede chamada backend-subnet na região us-west1 usa 10.1.2.0/24 como o intervalo de IP primário.

• Sub-rede para proxies: uma sub-rede chamada proxy-only-subnet na região us-west1 usa 10.129.0.0/23 como o intervalo de IP primário.

Observação: é possível alterar o nome da rede, a região e os parâmetros das sub-redes. No entanto, nas etapas subsequentes deste guia, são usados os parâmetros de rede, região e sub-rede conforme descrito aqui.

Configurar a rede e a sub-rede para back-ends

Console

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

   Acessar redes VPC

2. Clique em Criar rede VPC.

3. Em Nome, insira lb-network.

4. Na seção Sub-redes:

   • Defina Modo de criação da sub-rede como Personalizado.
   • Na seção Nova sub-rede, insira as informações a seguir:
     • Name: 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.

lb/regional_external_http_load_balancer/main.tf

Acessar no GitHub Feedback

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

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

lb/regional_external_http_load_balancer/main.tf

Acessar no GitHub Feedback

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 uma solicitação POST para o método networks.insert, substituindo PROJECT_ID pelo ID do projeto.

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

2. Faça uma solicitação POST para o método subnetworks.insert, substituindo PROJECT_ID pelo ID do 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",
   }
   

Configurar a sub-rede somente proxy

Uma sub-rede somente proxy fornece um conjunto de endereços IP que o Google usa para executar proxies Envoy em seu nome. Os proxies encerram as conexões do cliente e criam novas conexões com os back-ends.

Essa sub-rede somente proxy é usada por todos os balanceadores de carga regionais baseados no Envoy na mesma região que a rede VPC lb-network. Só pode haver uma sub-rede somente proxy ativa por região, por rede.

Importante: não tente atribuir endereços da sub-rede somente proxy aos back-ends do balanceador de carga. Atribua os endereços IP da instância de back-end de um intervalo (ou intervalos) de sub-redes diferente, não desse. O Google Cloud reserva esse intervalo de sub-redes para proxies gerenciados pelo Google Cloud.

Console

Se você estiver usando o console do Google Cloud, é possível esperar e criar a sub-rede somente proxy depois na página Balanceamento de carga.

Se você quiser criar a sub-rede somente proxy agora, siga estas etapas:

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

   Acessar redes VPC

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

3. Clique em Add subnet.

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

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

6. Defina Finalidade como Proxy gerenciado regional.

7. Em Intervalo de endereços IP, insira 10.129.0.0/23.

8. Clique em Adicionar.

gcloud

Crie a sub-rede somente 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 somente proxy VPC na rede lb-network, use o recurso google_compute_subnetwork.

lb/regional_external_http_load_balancer/main.tf

Acessar no GitHub Feedback

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 somente proxy com o método subnetworks.insert, substituindo PROJECT_ID pelo ID do 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"
}

Configurar regras de firewall

Este exemplo usa as seguintes regras de firewall:

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

• fw-allow-proxies: uma regra de entrada, aplicável às instâncias submetidas a balanceamento de carga, que permite o tráfego TCP nas portas 80, 443 e 8080 dos proxies gerenciados do balanceador de carga de aplicativo externo regional. Neste exemplo, usamos a tag de destino load-balanced-backend para identificar as VMs a que a regra de firewall se aplica.

Sem essas regras de firewall, a regra padrão de negação de entrada bloqueará o tráfego que chega para as instâncias de back-end.

As tags de destino definem as instâncias de back-end. Sem as tags de destino, as regras de firewall se aplicam a todas as instâncias de back-end na rede VPC. Ao criar as VMs de back-end, inclua as tags de destino especificadas, conforme mostrado em Como criar um grupo gerenciado de instâncias.

Console

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

   Acessar as regras de firewall

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

   • Name: fw-allow-health-check
   • Rede: lb-network
   • Direção do tráfego: entrada
   • Ação na correspondência: permitir
   • Destinos: tags de destino especificadas
   • Tags de meta: load-balanced-backend
   • Filtro de origem: intervalos IPv4
   • Intervalos IPv4 de origem: 130.211.0.0/22 e 35.191.0.0/16
   • Protocolos e portas:
     • Escolha Protocolos e portas especificados.
     • Marque a caixa de seleção tcp e insira 80 como o número da porta.
       Como prática recomendada, limite esta regra somente aos protocolos e portas que correspondem aos usados por sua verificação de integridade. Se você usar tcp:80 para o protocolo e a porta, o Google Cloud poderá usar HTTP na porta 80 para entrar em contato com suas VMs, mas não poderá usar HTTPS na porta 443 para entrar em contato com elas.

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 conectem aos back-ends:

   • Name: fw-allow-proxies
   • Rede: lb-network
   • Direção do tráfego: entrada
   • Ação na correspondência: permitir
   • Destinos: tags de destino especificadas
   • Tags de meta: 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.
     • Marque a caixa de seleção tcp e insira 80, 443, 8080 como os números da porta.

5. Clique em Criar.

gcloud

1. Crie a regra fw-allow-health-check para permitir verificações de integridade do Google Cloud. Neste exemplo, é permitido todo o tráfego TCP de sondagens de verificação de integridade. No entanto, é possível configurar um conjunto mais restrito de portas para atender às 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 balanceador de carga de aplicativo externo regional se conectem aos back-ends. Defina source-ranges para os intervalos alocados da sub-rede somente 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.

lb/regional_external_http_load_balancer/main.tf

Acessar no GitHub Feedback

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

lb/regional_external_http_load_balancer/main.tf

Acessar no GitHub Feedback

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 uma solicitação POST ao método firewalls.insert, substituindo PROJECT_ID pelo ID do 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 na sub-rede proxy para o método firewalls.insert, substituindo PROJECT_ID pelo ID do 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"
}

Configurar um balanceador de carga de aplicativo externo regional com um serviço baseado em VMM

Nesta seção, você verá a configuração necessária para serviços executados em VMs do Compute Engine. As VMs cliente se conectam ao endereço IP e à porta que você configura na regra de encaminhamento. Quando seus aplicativos cliente enviam tráfego para esse endereço IP e porta, as solicitações são encaminhadas para suas máquinas virtuais (VMs, na sigla em inglês) de back-end, de acordo com o mapa de URL do seu balanceador de carga de aplicativo externo regional.

No exemplo desta página, é criado explicitamente um endereço IP externo reservado para a regra de encaminhamento do balanceador de carga de aplicativo regional, em vez de um endereço IP externo temporário ser alocado. Como prática recomendada, reserve endereços IP para regras de encaminhamento.

Criar um back-end de grupo gerenciado de instâncias

Nesta seção, você verá como criar um modelo e um grupo de instâncias gerenciadas. O grupo de instâncias gerenciadas fornece instâncias de VM que executam os servidores de back-end de um exemplo de balanceador de carga de aplicativo externo regional. Para esses servidores de back-end, é feito o balanceamento de carga do tráfego dos clientes. Para fins de demonstração, os back-ends veiculam nomes de host próprios.

Console

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

   Acesse "Modelos de instância"

   1. Clique em Criar modelo de instância.
   2. Em Nome, insira l7-xlb-backend-template.
   3. 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.
   4. Clique em Opções avançadas.
   5. Clique em Rede e configure os seguintes campos:
      1. Em Tags de rede, insira load-balanced-backend.
      2. Em Interfaces de rede, selecione o seguinte:
         • Rede: lb-network
         • Sub-rede: backend-subnet

   6. Clique em Gerenciamento. Insira o script a seguir no campo Script de inicialização.

      #! /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 gerenciadas. No Console do Google Cloud, acesse a página Grupos de instâncias.

   Acesse grupo de instâncias

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

   8. 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.

   9. Clique em Criar.

gcloud

As instruções gcloud deste guia pressupõem que você está usando o Cloud Shell ou outro ambiente com o bash instalado.

1. Crie um modelo de instância de VM com o servidor HTTP usando 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-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'
   

2. Crie um grupo de instâncias gerenciadas 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.

lb/regional_external_http_load_balancer/main.tf

Acessar no GitHub Feedback

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-10"
    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 gerenciado de instâncias, use o recurso google_compute_instance_group_manager.

lb/regional_external_http_load_balancer/main.tf

Acessar no GitHub Feedback

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, substituindo 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-10"
          },
          "autoDelete":true
        }
      ]
    }
   }
   

2. Crie um grupo de instâncias gerenciadas em cada zona com o método instanceGroupManagers.insert, substituindo PROJECT_ID pelo ID do 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
   }
   

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

Console

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

   Acesse grupo de instâncias

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

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

4. Clique em Especificar mapeamento de nomes de porta.

5. Clique em Adicionar item.

6. Para o nome da porta, insira http. Como número de porta, insira 80.

7. Clique em Save.

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 na amostra de grupo de instâncias gerenciadas.

Reserve o endereço IP do balanceador de carga

Reserve um endereço IP externo para o balanceador de carga. Neste procedimento, você cria o endereço IP do balanceador de carga no nível Standard. Os balanceadores de carga de aplicativo externos regionais dão suporte aos níveis de serviço de rede Premium e Standard. No entanto, a criação desse balanceador de carga no nível Premium não é compatível com o console do Google Cloud. Use a gcloud ou a API REST.

Console

1. No console do Google Cloud, acesse a página Reservar um endereço estático.

   Acessar "Reservar um endereço estático"

2. Escolha um nome para o novo endereço.

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

4. Em Versão IP, selecione IPv4. Os endereços IPv6 só podem ser globais. Também só podem ser usados com balanceadores de carga globais.

5. Em Tipo, selecione Regional.

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

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

8. Clique em Reservar para reservar o IP.

gcloud

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

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

   Substitua:

   • ADDRESS_NAME: o nome que você quer atribuir a esse endereço.
   • REGION: a região em que você quer reservar o endereço. Essa região precisa ser a mesma do 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.

lb/regional_external_http_load_balancer/main.tf

Acessar no GitHub Feedback

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

API

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

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

O corpo da sua solicitação precisa ter:

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

Substitua:

• ADDRESS_NAME: o nome do endereço
• REGION: o nome da região para essa solicitação;
• PROJECT_ID: o ID do projeto desta solicitação;

Configurar o balanceador de carga

Neste exemplo, mostramos como criar os seguintes recursos regionais do balanceador de carga de aplicativo externo:

• Verificação de integridade de HTTP
• Serviço de back-end com um grupo de instâncias gerenciadas como o back-end
• Um mapa de URL
  • Certifique-se de consultar um mapa regional de URL se uma região for definida para o proxy HTTP(S) de destino. Um mapa regional de URL direciona as solicitações para um serviço de back-end regional com base em regras definidas para o host e caminho de um URL recebido. Esse tipo de mapa pode ser referenciado por uma regra de proxy de destino regional somente na mesma região.
• Certificado SSL (para HTTPS)
• Proxy de destino
• Regra de encaminhamento

Disponibilidade de proxy

Às vezes, as regiões do Google Cloud não têm capacidade de proxy suficiente para um novo balanceador de carga. Se isso acontecer, o console do Google Cloud fornecerá uma mensagem de aviso sobre a disponibilidade de proxy quando você criar o balanceador de carga. Para resolver esse problema, siga um destes procedimentos:

• Selecione uma região diferente para seu balanceador de carga. Essa opção pode ser prática se você tiver back-ends em outra região.
• Selecione uma rede VPC que já tenha uma sub-rede somente proxy alocada.
• Aguarde o problema de capacidade ser resolvido.

Console

1. No console do Google Cloud, acesse a página Criar balanceador de carga.

   Acessar "Criar um balanceador de carga"

2. No card Balanceador de carga de aplicativo (HTTP/S), clique em Iniciar configuração.

3. Em Internet ou somente interno, selecione Da internet para VMs ou serviços sem servidor. Essa configuração significa que o balanceador de carga é um balanceador de carga de aplicativo externo.

4. Em Global ou regional, selecione Balanceador de carga HTTP(S) regional.

5. Clique em Continuar.

Criar um balanceador de carga de aplicativo externo regional

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

Reservar uma sub-rede somente proxy

Observação: se você já tiver configurado a sub-rede somente proxy, o botão Reservar uma sub-rede não será exibido. Pule esta seção e continue com as etapas em Configurar o serviço de front-end.

Para um balanceador de carga de aplicativo externo regional, reserve uma sub-rede somente proxy:

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

Configure o front-end

Para HTTP:

1. Clique em Configuração de front-end.
2. Defina o Nome como l7-xlb-forwarding-rule.
3. Defina o Protocolo como HTTP.
4. Defina a Porta como 80.
5. Selecione o Endereço IP criado em Como reservar o endereço IP do balanceador de carga.
6. Clique em Concluído.

Para HTTPS:

É possível criar certificados do Compute Engine ou do Gerenciador de certificados. Use um dos métodos a seguir para criar certificados usando o Gerenciador de certificados:

• Certificados regionais autogerenciados. Para informações sobre como criar e usar certificados autogerenciados regionais, consulte Implantar um certificado autogerenciado regional. Mapas de certificados não são compatíveis.

• Certificados regionais gerenciados pelo Google. Mapas de certificados não são compatíveis.

  Os seguintes tipos de certificados regionais gerenciados pelo Google são aceitos pelo Gerenciador de certificados:

  • Certificados regionais gerenciados pelo Google com autorização de DNS por projeto. Para mais informações, consulte Implantar um certificado regional gerenciado pelo Google.
  • Certificados (particulares) regionais gerenciados pelo Google com o Certificate Authority Service. Para mais informações, consulte Implantar um certificado regional gerenciado pelo Google com o serviço de AC.

Depois de criar certificados, anexe o certificado diretamente ao proxy de destino.

1. Clique em Configuração de front-end.
2. No campo Nome, use l7-xlb-forwarding-rule.
3. No campo Protocolo, selecione HTTPS (includes HTTP/2).
4. Verifique se a Porta está definida como 443.
5. Selecione o Endereço IP criado em Como reservar o endereço IP do balanceador de carga.
6. Na lista Certificado, faça o seguinte:
   1. Se você já tiver um recurso de certificado SSL autogerenciado do Compute Engine, selecione o certificado SSL principal.
   2. Clique em Criar um novo certificado.
      1. No campo Nome, use l7-xlb-cert.
      2. Nos campos apropriados, faça o upload dos arquivos formatados em PEM:
         • Certificado
         • Chave privada
      3. Clique em Criar.
7. Opcional: para adicionar certificados além do certificado SSL principal:
   1. Clique em Adicionar certificado.
   2. Se você já tiver um certificado, selecione-o na lista Certificados.
   3. Opcional: clique em Criar um novo certificado e siga as instruções especificadas na etapa anterior.
8. Selecione uma política de SSL na lista Política de SSL. Se você não tiver criado políticas SSL, uma política padrão do Google Cloud SSL será aplicada.
9. Clique em Concluído.

Configurar o serviço de back-end

1. Clique em Configuração do 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. Em Protocolo, selecione HTTP.
5. Em Porta nomeada, insira http.
6. Defina o Tipo de back-end como Grupo de instâncias.
7. Na seção Novo back-end:
   1. Defina Grupo de instâncias como l7-xlb-backend-example.
   2. Defina Números de portas como 80.
   3. Defina Modo de balanceamento como Utilização.
   4. Clique em Concluído.
8. Na seção Verificação de integridade, clique em Criar verificação de integridade.
   1. Defina o Nome como l7-xlb-basic-check.
   2. Defina o Protocolo como HTTP.
   3. Defina a Porta como 80.
   4. Clique em Save.
9. Clique em Criar.

Configurar as regras de roteamento

1. Clique em Regras de roteamento.
2. Em Modo, selecione Regra de host e caminho simples.
3. Certifique-se de que l7-xlb-backend-service seja o único serviço de back-end para qualquer host e qualquer caminho sem correspondência.

Analise a configuração

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

gcloud

1. Defina a verificação de integridade 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 URL 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:

   É possível criar certificados do Compute Engine ou do Gerenciador de certificados. Use um dos métodos a seguir para criar certificados usando o Gerenciador de certificados:

   • Certificados regionais autogerenciados. Para informações sobre como criar e usar certificados autogerenciados regionais, consulte Implantar um certificado autogerenciado regional. Mapas de certificados não são compatíveis.

   • Certificados regionais gerenciados pelo Google. Mapas de certificados não são compatíveis.

     Os seguintes tipos de certificados regionais gerenciados pelo Google são aceitos pelo Gerenciador de certificados:

     • Certificados regionais gerenciados pelo Google com autorização de DNS por projeto. Para mais informações, consulte Implantar um certificado regional gerenciado pelo Google.
     • Certificados (particulares) regionais gerenciados pelo Google com o Certificate Authority Service. Para mais informações, consulte Implantar um certificado regional gerenciado pelo Google com o serviço de AC.

   Depois de criar certificados, anexe o certificado diretamente ao proxy de destino.

   1. Atribua os caminhos de arquivo aos 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 usando 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
      

   • Crie a regra de encaminhamento.

     Para HTTP:

     Use o comando gcloud compute forwarding-rules create com as sinalizações 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 usando o comando gcloud compute forwarding-rules create com as sinalizações 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 integridade, use o recurso google_compute_region_health_check.

lb/regional_external_http_load_balancer/main.tf

Acessar no GitHub Feedback

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.

lb/regional_external_http_load_balancer/main.tf

Acessar no GitHub Feedback

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 URL, use o recurso google_compute_region_url_map.

lb/regional_external_http_load_balancer/main.tf

Acessar no GitHub Feedback

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.

lb/regional_external_http_load_balancer/main.tf

Acessar no GitHub Feedback

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.

lb/regional_external_http_load_balancer/main.tf

Acessar no GitHub Feedback

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

API

Crie a verificação de integridade fazendo uma solicitação POST ao método regionHealthChecks.insert, substituindo PROJECT_ID pelo ID do 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 uma solicitação POST para o método regionBackendServices.insert, substituindo PROJECT_ID pelo ID do 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 URL fazendo uma solicitação POST ao método regionUrlMaps.insert, substituindo PROJECT_ID pelo ID do 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 uma solicitação POST ao método regionTargetHttpProxies.insert, substituindo PROJECT_ID pelo ID do 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 uma solicitação POST para o método forwardingRules.insert, substituindo PROJECT_ID pelo ID do 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",
}

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

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

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

   Acessar o "Balanceamento de carga"

2. Selecione o balanceador de carga que você acabou de criar.
3. 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 forem exibidos depois de alguns minutos, analise a configuração do firewall e a tag de rede atribuída às suas VMs de back-end.
4. 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.
5. Caso você tenha usado um certificado autoassinado durante o teste, o navegador exibirá um aviso. Você precisa permitir que o navegador aceite um certificado autoassinado.
6. 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ções mostradas neste guia.

gcloud

Anote o endereço IPv4 que foi reservado:

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

É possível testar o balanceador de carga usando 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. Você precisa permitir que o navegador aceite um certificado autoassinado.

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

Outras opções de configuração

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.

Ativar a afinidade de sessão

Estes procedimentos mostram como atualizar um serviço de back-end para o balanceador de carga de aplicativo externo regional de exemplo para que o serviço use a afinidade de cookie gerado, a afinidade de campo de cabeçalho ou a afinidade de cookie HTTP.

Quando a afinidade de cookie gerado é ativada, o balanceador de carga emite um cookie na primeira solicitação. Em cada solicitação subsequente com o mesmo cookie, o balanceador de carga direciona a solicitação para a mesma VM ou o mesmo endpoint de back-end. Em balanceadores de carga de aplicativo externos regionais, o cookie é chamado de GCILB.

Quando a afinidade de campo de cabeçalho é ativada, o balanceador de carga encaminha solicitações para VMs ou endpoints de back-end em um NEG com base no valor do cabeçalho HTTP nomeado na sinalização --custom-request-header. A afinidade de campo de cabeçalho só será válida se a política de localidade de balanceamento 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 cookie HTTP é ativada, o balanceador de carga encaminha solicitações para VMs ou endpoints de back-end em um NEG, com base em um cookie HTTP nomeado na sinalização HTTP_COOKIE com a sinalização opcional --affinity-cookie-ttl. Se o cliente não fornecer o cookie na solicitação HTTP, o proxy gerará o cookie e o retornará ao cliente em um cabeçalho Set-Cookie. A afinidade de cookie HTTP só será válida se a política de localidade de balanceamento de carga for RING_HASH ou MAGLEV e o hash consistente do serviço de back-end especificar o cookie HTTP.

Console

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

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

   Acessar o "Balanceamento de carga"

2. Selecione o balanceador de carga que você acabou de criar.

3. Clique em Back-ends.

4. Clique em l7-xlb-backend-service (o nome do serviço de back-end criado 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. Em Afinidade de sessão, selecione no menu o tipo de afinidade de sessão que você quer.

7. Clique em Atualizar.

gcloud

Use os seguintes comandos gcloud para atualizar o serviço de back-end l7-xlb-backend-service 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 uma solicitação PATCH para o método regionBackendServices/patch.

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

A seguir

• Para saber mais sobre os recursos de gerenciamento de tráfego, consulte Visão geral do gerenciamento de tráfego para balanceadores de carga regionais de aplicativos.

• Para gerenciar o recurso de sub-rede somente proxy exigido por um balanceador de carga de aplicativo regional, consulte Sub-redes somente proxy.

• Para saber como atualizar o certificado SSL do balanceador de carga de aplicativo externo regional, consulte Como usar certificados SSL autogerenciados.

• Limpe a configuração do balanceador de carga.