Configurar um balanceador de carga HTTP(S) externo regional com back-ends de grupo de instâncias de VM

Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

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

Como os balanceadores de carga HTTP(S) 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. cargas de trabalho que exigem acesso.Saída de nível de rede padrão são outro caso de uso comum para balanceadores de carga HTTP(S) externos regionais, porque os balanceadores de carga HTTP(S) externos regionais são compatíveis com o nível de serviço de rede padrão.

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

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:

Visão geral da configuração

É possível configurar um balanceador de carga HTTP(S) 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 HTTP(S) externo regional (clique para ampliar)
Componentes numerados do balanceador de carga HTTP(S) 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 usa o certificado SSL 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 HTTP(S) 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.

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

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 REGION.
  6. Defina Finalidade como Proxy gerenciado regional.
  7. Em Intervalo de endereços IP, digite 10.129.0.0/23.
  8. Clique em Add.

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.

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 submetidas ao balanceamento de carga, 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.

  • 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 HTTP(S) externo regional. Neste exemplo, usamos a tag de destino load-balanced-backend.

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 Google Cloud Console, acesse a página Regras de firewall.
    Acesse Regras de firewall
  2. Clique em Criar regra de firewall pela segunda vez para criar uma regra que autorize as verificações de integridade do Google Cloud:
    • Nome: 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 uma terceira vez para criar a regra que permite que os servidores proxy do balanceador de carga se conectem aos back-ends:
    • Nome: 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 HTTP(S) 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.

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 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 HTTP(S) externo regional com um serviço baseado em VM

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 HTTP(S) externo regional.

No exemplo desta página, é definido explicitamente um endereço IP externo reservado para a regra de encaminhamento do balanceador de carga HTTP(S) 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.

Como endereço IP da regra de encaminhamento, use o backend-subnet. Se você tentar usar a sub-rede somente proxy, a criação da regra de encaminhamento falhará.

Criar um 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 HTTP(S) 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.

    Acessar "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. Na guia Gerenciamento, insira o seguinte script no campo Script de inicialização em Gerenciamento, segurança, discos, rede, locatário único.

      #! /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
      
    5. Em Rede, selecione lb-network como a Rede e, para a Sub-rede, selecione backend-subnet.

    6. Adicione a tag de rede a seguir: load-balanced-backend.

    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 Única zona.
    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. Controle o número de instâncias criadas no grupo selecionando uma das seguintes opções em Escalonamento automático:

      • On: add and remove instances to the group
      • Scale up: only add instances to the group
      • Off: do not autoscale

      Defina o Número mínimo de instâncias como 2 e defina 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
    sudo apt-get update
    sudo apt-get install apache2 -y
    sudo a2ensite default-ssl
    sudo a2enmod ssl
    sudo 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'
    
  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.

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 = "#! /bin/bash\nsudo apt-get update\nsudo apt-get install apache2 -y\nsudo a2ensite default-ssl\nsudo a2enmod ssl\nsudo vm_hostname=\"$(curl -H \"Metadata-Flavor:Google\" \\\nhttp://169.254.169.254/computeMetadata/v1/instance/name)\"\nsudo echo \"Page served from: $vm_hostname\" | \\\ntee /var/www/html/index.html\nsudo systemctl restart apache2"
  }
  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.

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\nsudo apt-get update\nsudo apt-get install apache2 -y\nsudo a2ensite default-ssl\nsudo a2enmod ssl\nsudo vm_hostname=\"$(curl -H \"Metadata-Flavor:Google\" \\\nhttp://169.254.169.254/computeMetadata/v1/instance/name)\"\nsudo echo \"Page served from: $vm_hostname\" | \\\ntee /var/www/html/index.html\nsudo systemctl 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 balanceamento 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

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. Selecione IPv4. Os endereços IPv6 só podem ser globais. Também só podem ser usados com balanceadores de carga globais.

  5. Selecione Regional.

  6. Selecione a região em que o endereço será criado.

  7. Deixe a opção Anexar 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.

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 Trabalhar com uma configuração 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, você verá como criar os seguintes recursos externos do balanceador de carga HTTP(S) regional:

  • 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

Como endereço IP da regra de encaminhamento, use o backend-subnet. Se você tentar usar a sub-rede somente proxy, a criação da regra de encaminhamento falhará.

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.
    Acesse Criar um balanceador de carga
  2. Em Balanceamento de carga HTTP(S), clique em Iniciar configuração.
  3. Na seção Somente voltado para a Internet ou interno, selecione Da Internet para minhas VMs ou serviços sem servidor. Essa configuração significa que o balanceador de carga é um balanceador de carga HTTP(S) externo.
  4. Na seção Gerenciamento avançado de tráfego:
    1. Selecione Balanceador de carga HTTP(S) com Gerenciamento avançado de tráfego.
    2. Selecione Balanceador de carga HTTP(S) regional.
  5. Clique em Continuar.

Criar um balanceador de carga HTTP(S) externo regional

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

Reservar uma sub-rede somente proxy

Para um balanceador de carga HTTP(S) externo regional, reserve uma sub-rede somente proxy:

  1. Clique em Reservar uma sub-rede.
  2. Em Nome, insira proxy-only-subnet.

  3. Em Intervalo de endereços IP, digite 10.129.0.0/23.

  4. Clique em Add.

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

Se você usa o HTTPS entre o cliente e o balanceador de carga, um ou mais recursos de certificado SSL serão necessários para configurar o proxy. Saiba mais sobre como criar recursos de certificado SSL em Certificados SSL. Os certificados gerenciados pelo Google não são suportados com balanceadores de carga HTTP(S) externos regionais.

  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, 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 de chave pública
        • Cadeia de certificados
        • 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 conforme especificado acima.
  8. Clique em Concluído.
  9. 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 Protocolo como HTTP.
    3. Defina a Porta como 80.
    4. Clique em Save.
  10. 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.

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. Para 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 o Grupo de instâncias como l7-xlb-backend-example.
    2. Defina os Números de portas como 80.
    3. Defina o Modo de balanceamento como Utilização.
    4. Clique em Concluído.

Concluir a configuração

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:

    Saiba mais sobre como criar recursos de certificado SSL em Certificados SSL. Os certificados gerenciados pelo Google não são compatíveis com balanceadores de carga HTTP(S) externos regionais.

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

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 URL, 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 Trabalhar com uma configuração 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:

NAME                  TYPE     DATA
www                   A        30.90.80.100
@                     A        30.90.80.100

Se você estiver usando o Google Domains, consulte a página de Ajuda do Google Domains para ver mais informações.

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 HTTP(S) 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 endpoint de back-end. Em balanceadores de carga HTTP(S) 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 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 Update.

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