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

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.

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

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.

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

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.

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

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.

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.

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
   }
   

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

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.

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.

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;

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

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.

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

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.

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