Configurar um balanceador de carga de aplicativo interno com VPC compartilhada

Neste documento, mostramos dois exemplos de como configurar o balanceador de carga de aplicativo interno em um ambiente de VPC compartilhada:

  • O primeiro exemplo cria todos os componentes e back-ends do balanceador de carga no projeto de serviço.
  • O segundo exemplo cria os componentes de front-end e o mapa de URL do balanceador de carga em um projeto de serviço, enquanto o serviço de back-end e os back-ends do balanceador de carga são criados em um projeto de serviço diferente. Esse tipo de implantação, em que o mapa de URL faz referência a um serviço de back-end em outro projeto, é chamado de Referência de serviço entre projetos.

Os dois exemplos exigem a mesma configuração inicial para conceder permissões e definir a VPC compartilhada antes de começar a criar balanceadores de carga.

Essas não são as únicas configurações de VPC compartilhada compatíveis com balanceadores de carga de aplicativo internos. Para outras arquiteturas de VPC compartilhada válidas, consulte Arquiteturas de VPC compartilhada.

Se você não quiser usar uma rede VPC compartilhada, consulte Configurar um balanceador de carga de aplicativo interno.

Antes de começar

  1. Leia Visão geral da VPC compartilhada.
  2. Leia a Visão geral do balanceador de carga de aplicativo interno, incluindo a seção Arquiteturas de VPC compartilhada.

Permissões necessárias

A configuração de um balanceador de carga em uma rede VPC compartilhada requer algumas configurações e provisionamento iniciais de um administrador. Após a configuração inicial, o proprietário de um projeto de serviço pode realizar uma das seguintes ações:

  • Implantar todos os componentes e os back-ends do balanceador de carga em um projeto de serviço.
  • Implante os componentes do back-end do balanceador de carga (serviço de back-end e back-ends) em projetos de serviço que podem ser referenciados por um mapa de URL em outro serviço ou projeto de host.

Esta seção resume as permissões necessárias para seguir este guia para configurar um balanceador de carga em uma rede VPC compartilhada.

Configurar VPC compartilhada

Os seguintes papéis são necessários para as seguintes tarefas:

  1. Executar tarefas administrativas únicas, como configurar a VPC compartilhada e ativar um projeto host.
  2. Executar tarefas administrativas que precisam ser repetidas sempre que você quiser integrar um novo projeto de serviço. Isso inclui anexar o projeto de serviço, provisionar e configurar recursos de rede e conceder acesso ao administrador do projeto de serviço.

Essas tarefas precisam ser executadas no projeto host da VPC compartilhada. Recomendamos que o administrador da VPC compartilhada também seja o proprietário do projeto host da VPC compartilhada. Isso concede automaticamente os papéis de administrador de rede e administrador de segurança.

Tarefa Papel necessário
Configurar a VPC compartilhada, ativar o projeto host e conceder acesso aos administradores do projeto de serviço Administrador de VPC compartilhada
Criar sub-redes no projeto host da VPC compartilhada e conceder acesso aos administradores do projeto de serviço Administrador de rede
Adicionar e remover regras de firewall Administrador de segurança

Depois que as sub-redes são provisionadas, o proprietário do projeto de host precisa conceder o papel do usuário de rede no projeto de hosta qualquer pessoa (normalmente desenvolvedores, contas de serviço ou administradores do projeto de serviço) que precisa usar esses recursos.

Tarefa Papel necessário
Usar redes e sub-redes VPC pertencentes ao projeto host Usuário de rede

Esse papel pode ser concedido no nível do projeto ou para sub-redes individuais. Recomendamos que você conceda o papel em sub-redes individuais. Conceder o papel no projeto fornece acesso a todas as sub-redes atuais e futuras na VPC do projeto host.

Implantar balanceador de carga e back-ends

Os administradores do projeto de serviço precisam dos seguintes papéis no projeto de serviço para criar recursos e back-ends de balanceamento de carga. Essas permissões são concedidas automaticamente ao proprietário ou editor do projeto de serviço.

Papéis concedidos no projeto de serviço
Tarefa Papel necessário
Criar componentes do balanceador de carga Administrador de rede
Criar instâncias Administrador de instâncias
Criar e modificar certificados SSL Administrador de segurança

Pré-requisitos

Nesta seção, você precisa executar as seguintes etapas:

  1. Como configurar a rede e as sub-redes no projeto host.
  2. Configure a VPC compartilhada no projeto host.

As etapas nesta seção não precisam ser realizadas sempre que você quiser criar um novo balanceador de carga. No entanto, é preciso garantir que você tenha acesso aos recursos descritos aqui antes de continuar criando o balanceador de carga.

Como configurar a rede e as sub-redes no projeto host

Você precisa de uma rede VPC compartilhada com duas sub-redes: uma para o front-end e os back-ends do balanceador de carga e outra para os proxies do balanceador de carga.

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

  • Rede: o nome da rede é lb-network.

  • Sub-rede para o front-end e os back-ends do balanceador de carga. uma sub-rede chamada lb-frontend-and-backend-subnet na região us-west1 usa 10.1.2.0/24 para 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 sub-rede para o front-end e os back-ends do balanceador de carga

Essa etapa não precisa ser realizada sempre que você quiser criar um novo balanceador de carga. Você só precisa garantir que o projeto de serviço tenha acesso a uma sub-rede na rede VPC compartilhada (além da sub-rede somente proxy).

Todas as etapas nesta seção precisam ser realizadas no projeto host.

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:

    1. Defina o Modo de criação da sub-rede como Personalizado.

    2. Na seção Nova sub-rede, insira as seguintes informações:

      • Name: lb-frontend-and-backend-subnet

      • Região: us-west1

      • Intervalo de endereços IP: 10.1.2.0/24

    3. Clique em Concluído.

  5. Clique em Criar.

gcloud

  1. Crie uma rede VPC 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, região us-west1:

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

Terraform

  1. Crie uma rede VPC: 

    # Shared VPC network
resource "google_compute_network" "lb_network" {
  name                    = "lb-network"
  provider                = google-beta
  project                 = "my-host-project-id"
  auto_create_subnetworks = false
}

  2. Crie uma sub-rede na região us-west1: 

    # Shared VPC network - backend subnet
resource "google_compute_subnetwork" "lb_frontend_and_backend_subnet" {
  name          = "lb-frontend-and-backend-subnet"
  provider      = google-beta
  project       = "my-host-project-id"
  region        = "us-west1"
  ip_cidr_range = "10.1.2.0/24"
  role          = "ACTIVE"
  network       = google_compute_network.lb_network.id
}

Configurar a sub-rede somente proxy

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

Não realize esta etapa se já houver uma sub-rede somente proxy reservada na região us-west1 desta rede.

Todas as etapas nesta seção precisam ser realizadas no projeto host.

Console

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

    Acessar redes VPC

  2. Clique no nome da rede VPC compartilhada: 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

Crie a sub-rede somente proxy:

# Shared VPC network - proxy-only subnet
resource "google_compute_subnetwork" "proxy_only_subnet" {
  name          = "proxy-only-subnet"
  provider      = google-beta
  project       = "my-host-project-id"
  region        = "us-west1"
  ip_cidr_range = "10.129.0.0/23"
  role          = "ACTIVE"
  purpose       = "REGIONAL_MANAGED_PROXY"
  network       = google_compute_network.lb_network.id
}

Conceder aos administradores do projeto de serviço acesso à sub-rede de back-end

Os administradores de projetos de serviço exigem acesso à sub-rede lb-frontend-and-backend-subnet para que possam provisionar os back-ends do balanceador de carga.

Um administrador de VPC compartilhada precisa conceder acesso à sub-rede de back-end aos administradores (ou desenvolvedores que implantarão recursos e back-ends que usam a sub-rede) do projeto de serviço. Veja instruções em Administradores de projetos de serviço para algumas sub-redes.

Configurar regras de firewall no projeto host

Neste exemplo, usamos 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 instâncias às quais ela deve se aplicar.
  • fw-allow-proxies. Uma regra de entrada, aplicável às instâncias submetidas a balanceamento de carga, que permite o tráfego TCP em portas80 ,443 e 8080 dos proxies gerenciados do balanceador de carga. Neste exemplo, usamos a tag de destino load-balanced-backend para identificar as instâncias às quais ela deve se aplicar.
  • fw-allow-ssh: uma regra de entrada, aplicável às instâncias cuja carga está sendo balanceada, que permite a conectividade SSH de entrada na porta TCP 22 proveniente de qualquer endereço. Você pode escolher um intervalo de IP de origem mais restritivo para esta regra. Por exemplo, é possível especificar apenas os intervalos de IP do sistema do qual você inicia sessões SSH. Este exemplo usa a tag de destino allow-ssh para identificar as máquinas virtuais (VMs) às quais 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.

Todas as etapas nesta seção precisam ser realizadas no projeto host.

Console

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

    Acessar as políticas 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 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 as verificações de integridade do Google Cloud:
    • 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 TCP e insira 80, 443, 8080 como os números de porta.
  5. Clique em Criar.
  6. Clique em Criar regra de firewall para criar a regra que permite as verificações de integridade do Google Cloud:
    • Name: fw-allow-ssh
    • Rede: lb-network
    • Direção do tráfego: entrada
    • Ação na correspondência: permitir
    • Destinos: tags de destino especificadas
    • Tags de meta: allow-ssh
    • Filtro de origem: intervalos IPv4
    • Intervalos IPv4 de origem: 0.0.0.0/0
    • Protocolos e portas:
      • Escolha Protocolos e portas especificados.
      • Marque TCP e insira 22 como o número da porta.
  7. Clique em Criar.

gcloud

  1. Crie a regra de firewall fw-allow-health-check para permitir verificações de integridade do Google Cloud. Neste exemplo, todo o tráfego TCP de sondagens de verificação de integridade é permitido. 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 de firewall fw-allow-proxies para permitir que o tráfego da sub-rede somente proxy do Envoy chegue aos seus back-ends.

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

  3. Crie a regra de firewall fw-allow-ssh que permita a conectividade SSH para VMs com a tag de rede allow-ssh. Se você omitir source-ranges, o Google Cloud interpretará que a regra autoriza a conexão proveniente de qualquer origem.

    gcloud compute firewall-rules create fw-allow-ssh \
   --network=lb-network \
   --action=allow \
   --direction=ingress \
   --target-tags=allow-ssh \
   --rules=tcp:22

Terraform

  1. Crie uma regra de firewall para permitir verificações de integridade do Google Cloud. 

    resource "google_compute_firewall" "fw_allow_health_check" {
  name          = "fw-allow-health-check"
  provider      = google-beta
  project       = "my-host-project-id"
  direction     = "INGRESS"
  network       = google_compute_network.lb_network.id
  source_ranges = ["130.211.0.0/22", "35.191.0.0/16"]
  allow {
    protocol = "tcp"
  }
  target_tags = ["load-balanced-backend"]
}

  2. Crie uma regra de firewall para permitir que o tráfego da sub-rede somente proxy do Envoy chegue aos seus back-ends. 

    resource "google_compute_firewall" "fw_allow_proxies" {
  name          = "fw-allow-proxies"
  provider      = google-beta
  project       = "my-host-project-id"
  direction     = "INGRESS"
  network       = google_compute_network.lb_network.id
  source_ranges = ["10.129.0.0/23"]
  allow {
    protocol = "tcp"
    ports    = ["80", "443", "8080"]
  }
  target_tags = ["load-balanced-backend"]
}

  3. Crie uma regra de firewall que permita a conectividade SSH com VMs com a tag de rede allow-ssh. 

    resource "google_compute_firewall" "fw_allow_ssh" {
  name          = "fw-allow-ssh"
  provider      = google-beta
  project       = "my-host-project-id"
  direction     = "INGRESS"
  network       = google_compute_network.lb_network.id
  source_ranges = ["0.0.0.0/0"]
  allow {
    protocol = "tcp"
    ports    = ["22"]
  }
  target_tags = ["allow-ssh"]
}

Configurar a VPC compartilhada no projeto host

Esta etapa envolve ativar um projeto host da VPC compartilhada, compartilhar sub-redes do projeto host e anexar projetos de serviço ao projeto host para que os projetos de serviço possam usar a rede VPC compartilhada. Para configurar a VPC compartilhada no projeto host, consulte as seguintes páginas:

O restante das instruções pressupõe que você já configurou a VPC compartilhada. Isso inclui a configuração de políticas do Cloud IAM para sua organização e a designação dos projetos host e de serviço.

Não continue até configurar a VPC compartilhada e ativar os projetos host e de serviço.

Depois de concluir as etapas definidas nesta seção de pré-requisitos, você poderá seguir uma das seguintes configurações:

Configurar um balanceador de carga no projeto de serviço

Neste exemplo, criamos um balanceador de carga de aplicativo interno em que todos os componentes do balanceamento de carga (regra de encaminhamento, proxy de destino, mapa de URL e serviço de back-end) e back-ends são criados no projeto de serviço.

Os recursos de rede do balanceador de carga de aplicativo interno, como a sub-rede somente proxy e a sub-rede para as instâncias de back-end, são criados no projeto host. As regras de firewall para as instâncias de back-end também são criadas no projeto host.

Figura 1. Balanceador de carga de aplicativo interno na VPC compartilhada
Figura 1. Balanceador de carga de aplicativo interno na VPC compartilhada

Nesta seção, mostramos como configurar o balanceador de carga e os back-ends. Essas etapas devem ser realizadas pelo administrador do projeto de serviço (ou um desenvolvedor que opere nele) e não exigem o envolvimento do administrador do projeto host. As etapas nesta seção são muito semelhantes às etapas padrão para configurar um balanceador de carga de aplicativo interno.

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

Criar o back-end do grupo de instâncias gerenciadas

Nesta seção, você verá como criar um modelo e um grupo de instâncias gerenciadas. O grupo gerenciado de instâncias fornece instâncias de VM que executam os servidores de back-end de um exemplo de balanceador de carga de aplicativo interno. 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-ilb-backend-template.
    3. Verifique se Disco de inicialização está definido como uma imagem Debian, como Debian GNU/Linux 12 (bookworm): Estas instruções usam comandos que estão disponíveis apenas no Debian, como apt-get. Se você precisar alterar o disco de inicialização, clique em Alterar.
      1. Em Sistema operacional, selecione Debian.
      2. Em Versão, selecione uma das imagens Debian disponíveis, como Debian GNU/Linux 12 (bookworm).
      3. Clique em Selecionar.
    4. Clique em Opções avançadas e em Rede.
    5. Insira as seguintes tags de rede: allow-ssh,load-balanced-backend.
    6. Na seção Interfaces de rede, selecione Redes compartilhadas comigo (do projeto host: HOST_PROJECT_ID).
    7. Selecione a sub-rede lb-frontend-and-backend-subnet na rede lb-network.
    8. Clique em Gerenciamento. 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
    9. 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. Escolha Novo grupo gerenciado de instâncias (sem estado). Para mais informações, consulte MIGs sem estado ou com estado.
    3. Em Nome, insira l7-ilb-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-ilb-backend-template.

    8. Especifique o número de instâncias que você quer criar no grupo.

      Neste exemplo, especifique as seguintes opções em Escalonamento automático:

      • Em Modo de escalonamento automático, selecione Off:do not autoscale.
      • Em Número máximo de instâncias, insira 2.

      Se preferir, na seção Escalonamento automático da IU, configure o grupo de instâncias para adicionar ou remover instâncias automaticamente com base no uso de CPU da instância.

    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-ilb-backend-template \
--region=us-west1 \
--network=projects/HOST_PROJECT_ID/global/networks/lb-network \
--subnet=projects/HOST_PROJECT_ID/regions/us-west1/subnetworks/lb-frontend-and-backend-subnet \
--tags=allow-ssh,load-balanced-backend \
--image-family=debian-12 \
--image-project=debian-cloud \
--metadata=startup-script='#! /bin/bash
apt-get update
apt-get install apache2 -y
a2ensite default-ssl
a2enmod ssl
vm_hostname="$(curl -H "Metadata-Flavor:Google" \
http://metadata.google.internal/computeMetadata/v1/instance/name)"
echo "Page served from: $vm_hostname" | \
tee /var/www/html/index.html
systemctl restart apache2' \
--project=SERVICE_PROJECT_ID

  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-ilb-backend-example \
    --zone=us-west1-a \
    --size=2 \
    --template=l7-ilb-backend-template \
    --project=SERVICE_PROJECT_ID

Terraform

  1. Crie um modelo de instância de VM.

    # Instance template
resource "google_compute_instance_template" "default" {
  name     = "l7-ilb-backend-template"
  provider = google-beta
  project  = "my-service-project-id"
  region   = "us-west1"
  # For machine type, using small. For more options check https://cloud.google.com/compute/docs/machine-types
  machine_type = "e2-small"
  tags         = ["allow-ssh", "load-balanced-backend"]
  network_interface {
    network    = google_compute_network.lb_network.id
    subnetwork = google_compute_subnetwork.lb_frontend_and_backend_subnet.id
    access_config {
      # add external ip to fetch packages like apache2, ssl
    }
  }
  disk {
    source_image = "debian-cloud/debian-12"
    auto_delete  = true
    boot         = true
  }

  # install apache2 and serve a simple web page
  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://metadata.google.internal/computeMetadata/v1/instance/name)"
    sudo echo "Page served from: $vm_hostname" | \
    tee /var/www/html/index.html
    sudo systemctl restart apache2
    EOF
  }
}

  2. criar um grupo gerenciado de instâncias.

    Para HTTP:

    # MIG
resource "google_compute_instance_group_manager" "default" {
  name               = "l7-ilb-backend-example"
  provider           = google-beta
  project            = "my-service-project-id"
  zone               = "us-west1-a"
  base_instance_name = "vm"
  target_size        = 2
  version {
    instance_template = google_compute_instance_template.default.id
    name              = "primary"
  }
  named_port {
    name = "http"
    port = 80
  }
}

    Para HTTPS:

    # MIG
resource "google_compute_instance_group_manager" "default" {
  name               = "l7-ilb-backend-example"
  provider           = google-beta
  project            = "my-service-project-id"
  zone               = "us-west1-a"
  base_instance_name = "vm"
  target_size        = 2
  version {
    instance_template = google_compute_instance_template.default.id
    name              = "primary"
  }
  named_port {
    name = "https"
    port = 443
  }
}

Configurar o balanceador de carga

Nesta seção, mostramos como criar os recursos do balanceador de carga de aplicativo interno:

  • 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
  • Certificado SSL (obrigatório apenas para HTTPS)
  • Proxy de destino
  • Regra de encaminhamento

Disponibilidade de proxy

Dependendo do número de projetos de serviço que usam a mesma rede VPC compartilhada, há a possibilidade de atingir cotas ou limites mais rapidamente do que no modelo de implantação de rede em que cada projeto do Google Cloud hospeda a própria rede.

Por exemplo, às vezes, as regiões do Google Cloud não têm capacidade de proxy suficiente para um novo balanceador de carga de aplicativo interno. 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:

  • Aguarde o problema de capacidade ser resolvido.

  • Entre em contato com sua equipe de vendas do Google Cloud para aumentar esses limites.

Console

Migrar o contexto para o projeto de serviço

  1. No Console do Google Cloud, abra a página Painel.

    Ir para o painel

  2. Clique na lista Selecionar de na parte superior da página. Na janela Selecionar de exibida, selecione o projeto de serviço em que você quer criar o balanceador de carga.

Iniciar a configuração

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

    Acessar o "Balanceamento de carga"

  2. Clique em Criar balanceador de carga.
  3. Em Tipo de balanceador de carga, selecione Balanceador de carga de aplicativo (HTTP/HTTPS) e clique em Próxima.
  4. Em Voltado ao público ou interno, selecione Interno e clique em Próxima.
  5. Em Implantação entre regiões ou região única, selecione Melhor para cargas de trabalho regionais e clique em Próxima.
  6. Clique em Configurar.

Configuração básica

  1. Em Nome do balanceador de carga, digite l7-ilb-shared-vpc.
  2. Em Região, selecione us-west1.

  3. Em Rede, selecione lb-network (do Projeto: HOST_PROJECT_ID).

    Se você vir um aviso Sub-rede exclusiva de proxy necessária na rede VPC compartilhada, confirme se o administrador do projeto de host criou o proxy-only-subnet na região us-west1 na rede VPC compartilhada lb-network. A criação do balanceador de carga será bem-sucedida mesmo que você não tenha permissão para visualizar a sub-rede exclusiva de proxy nesta página.

  4. Mantenha a janela aberta para continuar.

Configure o back-end

  1. Clique em Configuração de back-end.
  2. No menu Criar ou selecionar serviços de back-end, selecione Criar um serviço de back-end.
  3. Defina o Nome do serviço de back-end como l7-ilb-backend-service.
  4. Defina o Tipo de back-end como Grupos de instâncias.
  5. Na seção Novo back-end:
    1. Defina o Grupo de instâncias como l7-ilb-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.
  6. Na seção Verificação de integridade, escolha Criar verificação de integridade com os seguintes parâmetros:
    1. Name: l7-ilb-basic-check
    2. Protocolo: HTTP
    3. Porta: 80
  7. Clique em Salvar e continuar.
  8. Clique em Criar.

Configurar as regras de roteamento

  • Clique em Regras de roteamento. Certifique-se de que l7-ilb-backend-service seja o único serviço de back-end para qualquer host e qualquer caminho sem correspondência.

Saiba mais sobre gerenciamento de tráfego em Como configurar o gerenciamento de tráfego.

Configurar o front-end

Para HTTP:

  1. Clique em Configuração de front-end.
  2. Defina o Nome como l7-ilb-forwarding-rule.
  3. Defina Protocolo como HTTP.
  4. Defina o Sub-rede para lb-frontend-and-backend-subnet. Não selecione a sub-rede exclusiva de proxy para o front-end, mesmo que seja uma opção na lista.
  5. Defina a Porta como 80.
  6. Clique no menu Endereço IP e em Criar endereço IP.
  7. No painel Reservar um endereço IP interno estático, forneça os seguintes detalhes:
    1. Em Nome, insira ip-address-shared-vpc.
    2. Em Endereço IP estático, selecione Let me choose. Em Endereço IP personalizado, insira 10.1.2.99.
    3. (Opcional) Se você quiser compartilhar esse endereço IP com front-ends diferentes, defina Objetivo como Compartilhado.
  8. 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. Atualmente, os certificados gerenciados pelo Google não são compatíveis com balanceadores de carga de aplicativo internos.

  1. Clique em Configuração de front-end.
  2. No campo Nome, use l7-ilb-forwarding-rule.
  3. No campo Protocolo, selecione HTTPS (includes HTTP/2).
  4. Defina o Sub-rede para lb-frontend-and-backend-subnet. Não selecione a sub-rede exclusiva de proxy para o front-end, mesmo que seja uma opção na lista.
  5. Certifique-se de que Porta esteja definida como 443, para permitir tráfego HTTPS.
  6. Clique no menu Endereço IP e em Criar endereço IP.
  7. No painel Reservar um endereço IP interno estático, forneça os seguintes detalhes:
    1. Em Nome, insira ip-address-shared-vpc.
    2. Em Endereço IP estático, selecione Let me choose. Em Endereço IP personalizado, insira 10.1.2.99.
    3. (Opcional) Se você quiser compartilhar esse endereço IP com front-ends diferentes, defina Objetivo como Compartilhado.
  8. Clique na lista Certificate.
    1. Se você já tiver um recurso de certificado SSL autogerenciado que você quer usar como o certificado SSL principal, selecione-o no menu.
    2. Caso contrário, selecione Criar um novo certificado.
      1. Preencha um Nome para l7-ilb-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.
  9. Para adicionar recursos de certificado além do certificado SSL principal, siga estas etapas:
    1. Clique em Adicionar certificado.
    2. Selecione um certificado na lista Certificados ou clique em Criar um novo certificado e siga as instruções anteriores.
  10. Clique em Concluído.

Revise e finalize 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-ilb-basic-check \
   --region=us-west1 \
   --use-serving-port \
   --project=SERVICE_PROJECT_ID

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

    gcloud compute backend-services create l7-ilb-backend-service \
  --load-balancing-scheme=INTERNAL_MANAGED \
  --protocol=HTTP \
  --health-checks=l7-ilb-basic-check \
  --health-checks-region=us-west1 \
  --region=us-west1 \
  --project=SERVICE_PROJECT_ID

  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-ilb-backend-service \
  --balancing-mode=UTILIZATION \
  --instance-group=l7-ilb-backend-example \
  --instance-group-zone=us-west1-a \
  --region=us-west1 \
  --project=SERVICE_PROJECT_ID

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

    gcloud compute url-maps create l7-ilb-map \
  --default-service=l7-ilb-backend-service \
  --region=us-west1 \
  --project=SERVICE_PROJECT_ID

  5. Crie o proxy de destino.

    Para HTTP:

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

    gcloud compute target-http-proxies create l7-ilb-proxy \
  --url-map=l7-ilb-map \
  --url-map-region=us-west1 \
  --region=us-west1 \
  --project=SERVICE_PROJECT_ID

    Para HTTPS:

    Saiba mais sobre como criar recursos de certificado SSL em Certificados SSL. Atualmente, os certificados gerenciados pelo Google não são compatíveis com balanceadores de carga de aplicativo internos.

    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

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

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

    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-ilb-proxy \
  --url-map=l7-ilb-map \
  --region=us-west1 \
  --ssl-certificates=l7-ilb-cert \
  --project=SERVICE_PROJECT_ID

  6. Crie a regra de encaminhamento.

    Para redes personalizadas, referencie a sub-rede na regra de encaminhamento.

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

    Para HTTP:

    Use o comando gcloud compute forwarding-rules create com as sinalizações corretas.

    gcloud compute forwarding-rules create l7-ilb-forwarding-rule \
  --load-balancing-scheme=INTERNAL_MANAGED \
  --network=projects/HOST_PROJECT_ID/global/networks/lb-network \
  --subnet=projects/HOST_PROJECT_ID/regions/us-west1/subnetworks/lb-frontend-and-backend-subnet \
  --address=IP_ADDRESS_NAME \
  --ports=80 \
  --region=us-west1 \
  --target-http-proxy=l7-ilb-proxy \
  --target-http-proxy-region=us-west1 \
  --project=SERVICE_PROJECT_ID

    Para HTTPS:

    Use o comando gcloud compute forwarding-rules create com as sinalizações corretas.

    gcloud compute forwarding-rules create l7-ilb-forwarding-rule \
  --load-balancing-scheme=INTERNAL_MANAGED \
  --network=projects/HOST_PROJECT_ID/global/networks/lb-network \
  --subnet=projects/HOST_PROJECT_ID/regions/us-west1/subnetworks/lb-frontend-and-backend-subnet \
  --address=IP_ADDRESS_NAME \
  --ports=443 \
  --region=us-west1 \
  --target-https-proxy=l7-ilb-proxy \
  --target-https-proxy-region=us-west1 \
  --project=SERVICE_PROJECT_ID

Terraform

  1. Defina a verificação de integridade de HTTP.

    Para HTTP: 

    # health check
resource "google_compute_health_check" "default" {
  name               = "l7-ilb-basic-check"
  provider           = google-beta
  project            = "my-service-project-id"
  timeout_sec        = 1
  check_interval_sec = 1
  http_health_check {
    port = "80"
  }
}

    Para HTTPS: 

    # health check
resource "google_compute_health_check" "default" {
  name               = "l7-ilb-basic-check"
  provider           = google-beta
  project            = "my-service-project-id"
  timeout_sec        = 1
  check_interval_sec = 1
  https_health_check {
    port = "443"
  }
}

  2. Defina o serviço de back-end.

    # backend service
resource "google_compute_region_backend_service" "default" {
  name                  = "l7-ilb-backend-service"
  provider              = google-beta
  project               = "my-service-project-id"
  region                = "us-west1"
  protocol              = "HTTP"
  load_balancing_scheme = "INTERNAL_MANAGED"
  timeout_sec           = 10
  health_checks         = [google_compute_health_check.default.id]
  backend {
    group           = google_compute_instance_group_manager.default.instance_group
    balancing_mode  = "UTILIZATION"
    capacity_scaler = 1.0
  }
}

  3. Crie o mapa de URL.

    # URL map
resource "google_compute_region_url_map" "default" {
  name            = "l7-ilb-map"
  provider        = google-beta
  project         = "my-service-project-id"
  region          = "us-west1"
  default_service = google_compute_region_backend_service.default.id
}

  4. Crie o proxy de destino.

    Para HTTP: 

    # HTTP target proxy
resource "google_compute_region_target_http_proxy" "default" {
  name     = "l7-ilb-proxy"
  provider = google-beta
  project  = "my-service-project-id"
  region   = "us-west1"
  url_map  = google_compute_region_url_map.default.id
}

    Para HTTPS: crie um certificado SSL regional

    Saiba mais sobre como criar recursos de certificado SSL em Certificados SSL. Atualmente, os certificados gerenciados pelo Google não são compatíveis com balanceadores de carga de aplicativo internos.

    # Use self-signed SSL certificate
resource "google_compute_region_ssl_certificate" "default" {
  name        = "l7-ilb-cert"
  provider    = google-beta
  project     = "my-service-project-id"
  region      = "us-west1"
  private_key = file("sample-private.key") # path to PEM-formatted file
  certificate = file("sample-server.cert") # path to PEM-formatted file
}

    Como usar o certificado SSL regional para criar um proxy de destino

    # HTTPS target proxy
resource "google_compute_region_target_https_proxy" "default" {
  name             = "l7-ilb-proxy"
  provider         = google-beta
  project          = "my-service-project-id"
  region           = "us-west1"
  url_map          = google_compute_region_url_map.default.id
  ssl_certificates = [google_compute_region_ssl_certificate.default.id]
}

  5. Crie a regra de encaminhamento.

    Para redes personalizadas, referencie a sub-rede na regra de encaminhamento.

    Para HTTP: 

    # Forwarding rule
resource "google_compute_forwarding_rule" "default" {
  name                  = "l7-ilb-forwarding-rule"
  provider              = google-beta
  project               = "my-service-project-id"
  region                = "us-west1"
  ip_protocol           = "TCP"
  port_range            = "80"
  load_balancing_scheme = "INTERNAL_MANAGED"
  target                = google_compute_region_target_http_proxy.default.id
  network               = google_compute_network.lb_network.id
  subnetwork            = google_compute_subnetwork.lb_frontend_and_backend_subnet.id
  network_tier          = "PREMIUM"
  depends_on            = [google_compute_subnetwork.lb_frontend_and_backend_subnet]
}

    Para HTTPS: 

    # Forwarding rule
resource "google_compute_forwarding_rule" "default" {
  name                  = "l7-ilb-forwarding-rule"
  provider              = google-beta
  project               = "my-service-project-id"
  region                = "us-west1"
  ip_protocol           = "TCP"
  port_range            = "443"
  load_balancing_scheme = "INTERNAL_MANAGED"
  target                = google_compute_region_target_https_proxy.default.id
  network               = google_compute_network.lb_network.id
  subnetwork            = google_compute_subnetwork.lb_frontend_and_backend_subnet.id
  network_tier          = "PREMIUM"
  depends_on            = [google_compute_subnetwork.lb_frontend_and_backend_subnet]
}

Testar o balanceador de carga

Para testar o balanceador de carga, primeiro crie uma VM de cliente de amostra. Em seguida, estabeleça uma sessão SSH com a VM e envie o tráfego dessa VM para o balanceador de carga.

Criar uma instância de VM de teste

Os clientes podem estar localizados no projeto host ou em qualquer projeto de serviço conectado. Neste exemplo, você testará se o balanceador de carga está funcionando ao implantar uma VM cliente em um projeto de serviço. O cliente precisa usar a mesma rede VPC compartilhada e estar na mesma região do balanceador de carga.

Console

  1. No console do Google Cloud, acesse a página Instâncias de VMs.

    Acessar instâncias de VM

  2. Clique em Criar instância.

  3. Defina o Nome como client-vm.

  4. Defina a Zona como us-west1-a.

  5. Clique em Opções avançadas e em Rede.

  6. Insira as seguintes tags de rede: allow-ssh,load-balanced-backend.

  7. Na seção Interfaces de rede, selecione Redes compartilhadas comigo (do projeto host: HOST_PROJECT_ID).

  8. Selecione a sub-rede lb-frontend-and-backend-subnet na rede lb-network.

  9. Clique em Criar.

gcloud

Crie uma instância de VM de teste.

gcloud compute instances create client-vm \
    --image-family=debian-12 \
    --image-project=debian-cloud \
    --subnet=projects/HOST_PROJECT_ID/regions/us-west1/subnetworks/lb-frontend-and-backend-subnet \
    --zone=us-west1-a \
    --tags=allow-ssh \
    --project=SERVICE_PROJECT_ID

Terraform

Crie uma instância de VM de teste.

resource "google_compute_instance" "vm_test" {
  name         = "client-vm"
  provider     = google-beta
  project      = "my-service-project-id"
  zone         = "us-west1-a"
  machine_type = "e2-small"
  tags         = ["allow-ssh"]
  network_interface {
    network    = google_compute_network.lb_network.id
    subnetwork = google_compute_subnetwork.lb_frontend_and_backend_subnet.id
  }
  boot_disk {
    initialize_params {
      image = "debian-cloud/debian-12"
    }
  }
  lifecycle {
    ignore_changes = [
      metadata["ssh-keys"]
    ]
  }
}

Enviar tráfego ao balanceador de carga

Use o SSH para se conectar à instância que você acabou de criar e teste se os serviços HTTP(S) nos back-ends podem ser acessados pelo endereço IP da regra de encaminhamento do balanceador de carga de aplicativo interno e se o tráfego está com balanceamento de carga entre as instâncias de back-end.

  1. Conecte-se à instância do cliente com SSH.

    gcloud compute ssh client-vm \
   --zone=us-west1-a

  2. Verifique se o endereço IP está exibindo o nome do host. Substitua LB_IP_ADDRESS pelo endereço IP do balanceador de carga.

    curl LB_IP_ADDRESS

    Para fazer teste em HTTPS, substitua curl pelo seguinte:

    curl -k -s 'https://LB_IP_ADDRESS:443'

    A sinalização -k faz com que o curl ignore a validação do certificado.

Configurar um balanceador de carga com um serviço de back-end entre projetos

O exemplo anterior nesta página mostra como configurar uma implantação de VPC compartilhada em que todos os componentes do balanceador de carga e os back-ends dele são criados no projeto de serviço.

Os balanceadores de carga de aplicativo internos também permitem configurar implantações de VPC compartilhada em que um mapa de URL em um projeto host ou de serviço pode referenciar serviços de back-end (e back-ends) localizados em vários projetos de serviço em ambientes de VPC compartilhada. Isso é chamado de referência de serviço entre projetos.

Use as etapas desta seção como referência para configurar qualquer uma das combinações compatíveis listadas aqui:

  • Regra de encaminhamento, proxy de destino e mapa de URL no projeto host, com serviço de back-end em um projeto de serviço.
  • Regra de encaminhamento, proxy de destino e mapa de URL em um projeto de serviço, com serviço de back-end em outro projeto de serviço.

A referência de serviços entre projetos pode ser usada com grupos de instâncias, NEGs sem servidor ou qualquer outro tipo de back-end com suporte. Se estiver usando NEGs sem servidor, crie uma VM na rede VPC em que você pretende criar o front-end do balanceador de carga. Por exemplo, consulte Criar uma instância de VM em uma sub-rede específica em Configurar um balanceador de carga de aplicativo interno com o Cloud Run.

Requisitos para criação

Este exemplo configura um balanceador de carga de amostra com o front-end e o back-end em dois projetos de serviço diferentes.

Se você ainda não tiver feito isso, conclua todas as etapas de pré-requisito para configurar a VPC compartilhada e configurar a rede, as sub-redes e as regras de firewall necessárias para este exemplo. Para ver instruções, consulte os links a seguir:

Figura 2. Front-end e back-end do balanceador de carga em projetos de serviço diferentes
Figura 2. Front-end e back-end do balanceador de carga em projetos de serviço diferentes.

Crie os back-ends e o serviço de back-end no projeto de serviço B

Todas as etapas nesta seção precisam ser realizadas no projeto de serviço B.

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. Digite um Nome para o modelo de instância: cross-ref-backend-template.
    3. Verifique se Disco de inicialização está definido como uma imagem Debian, como Debian GNU/Linux 12 (bookworm): Estas instruções usam comandos que estão disponíveis apenas no Debian, como apt-get. Se você precisar alterar o disco de inicialização, clique em Alterar.
      1. Em Sistema operacional, selecione Debian.
      2. Em Versão, selecione uma das imagens Debian disponíveis, como Debian GNU/Linux 12 (bookworm).
      3. Clique em Selecionar.
    4. Clique em Opções avançadas e em Rede.
    5. Insira as seguintes tags de rede: allow-ssh,load-balanced-backend.
    6. Na seção Interfaces de rede, selecione Redes compartilhadas comigo (do projeto host: HOST_PROJECT_ID).
    7. Selecione a sub-rede lb-frontend-and-backend-subnet na rede lb-network.
    8. Clique em Gerenciamento. 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
    9. 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. Escolha Novo grupo gerenciado de instâncias (sem estado). Para mais informações, consulte MIGs sem estado ou com estado.
    3. Digite um Nome para o grupo de instâncias: cross-ref-ig-backend.
    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 cross-ref-backend-template.

    8. Especifique o número de instâncias que você quer criar no grupo.

      Neste exemplo, especifique as seguintes opções em Escalonamento automático:

      • Em Modo de escalonamento automático, selecione Off:do not autoscale.
      • Em Número máximo de instâncias, insira 2.

      Se preferir, na seção Escalonamento automático da IU, configure o grupo de instâncias para adicionar ou remover instâncias automaticamente com base no uso de CPU da instância.

    9. Clique em Criar.

  3. Criar um serviço de back-end regional Como parte desta etapa, também criamos a verificação de integridade e adicionamos back-ends ao serviço de back-end. No console do Google Cloud, abra a página Back-ends.

    Acessar back-ends

    1. Clique em Criar serviço de back-end regional.
    2. Digite um Nome para o serviço de back-end: cross-ref-backend-service.
    3. Em Região, selecione us-west1.
    4. Em Tipo de balanceador de carga, selecione Balanceador de carga de aplicativo interno regional (INTERNAL_MANAGED).
    5. Defina o Tipo de back-end como Grupos de instâncias.
    6. Na seção Back-ends, defina Rede como lb-network.
    7. Clique em Adicionar back-end e defina os seguintes campos:
      1. Defina o Grupo de instâncias como cross-ref-ig-backend.
      2. Digite os Números de porta: 80.
      3. Defina Modo de balanceamento como Utilização.
      4. Clique em Concluído.
    8. Na seção Verificação de integridade, escolha Criar verificação de integridade com os seguintes parâmetros:
      1. Name: cross-ref-http-health-check
      2. Protocolo: HTTP
      3. Porta: 80
      4. Clique em Salvar.
    9. Clique em Continuar.

    10. Opcional: na seção Adicionar permissões, insira os principais do IAM (geralmente um endereço de e-mail) de administradores do balanceador de carga de outros projetos para que eles possam usar esse serviço de back-end balanceadores de carga nos próprios projetos. Sem essa permissão, não é possível usar a referência de serviços entre projetos.

      Se você não tiver permissão para definir políticas de controle de acesso para serviços de back-end neste projeto, ainda será possível criar o serviço de back-end agora, e um usuário autorizado poderá executar essa etapa mais tarde, conforme descrito na seção Conceda permissões ao administrador do balanceador de carga para usar o serviço de back-end. Essa seção também descreve como conceder acesso a todos os serviços de back-end neste projeto para que você não precise conceder acesso sempre que criar um novo serviço de back-end.

    11. Clique em Criar.

gcloud

  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 BACKEND_IG_TEMPLATE \
    --region=us-west1 \
    --network=projects/HOST_PROJECT_ID/global/networks/lb-network \
    --subnet=projects/HOST_PROJECT_ID/regions/us-west1/subnetworks/lb-frontend-and-backend-subnet \
    --tags=allow-ssh,load-balanced-backend \
    --image-family=debian-12 \
    --image-project=debian-cloud \
    --metadata=startup-script='#! /bin/bash
    apt-get update
    apt-get install apache2 -y
    a2ensite default-ssl
    a2enmod ssl
    vm_hostname="$(curl -H "Metadata-Flavor:Google" \
    http://metadata.google.internal/computeMetadata/v1/instance/name)"
    echo "Page served from: $vm_hostname" | \
    tee /var/www/html/index.html
    systemctl restart apache2' \
    --project=SERVICE_PROJECT_B_ID

    Substitua:

    • BACKEND_IG_TEMPLATE: o nome do modelo do grupo de instâncias.
    • SERVICE_PROJECT_B_ID: o ID do projeto de serviço B, em que os back-ends do balanceador de carga e o serviço de back-end estão sendo criados.
    • HOST_PROJECT_ID: o ID do projeto host da VPC compartilhada.

  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 BACKEND_MIG \
    --zone=us-west1-a \
    --size=2 \
    --template=BACKEND_IG_TEMPLATE \
    --project=SERVICE_PROJECT_B_ID

    Substitua:

    • BACKEND_MIG: o nome do grupo de instâncias de back-end.

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

    gcloud compute health-checks create http HTTP_HEALTH_CHECK_NAME \
  --region=us-west1 \
  --use-serving-port \
  --project=SERVICE_PROJECT_B_ID

    Substitua:

    • HTTP_HEALTH_CHECK_NAME: o nome da verificação de integridade HTTP.

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

    gcloud compute backend-services create BACKEND_SERVICE_NAME \
  --load-balancing-scheme=INTERNAL_MANAGED \
  --protocol=HTTP \
  --health-checks=HTTP_HEALTH_CHECK_NAME \
  --health-checks-region=us-west1 \
  --region=us-west1 \
  --project=SERVICE_PROJECT_B_ID

    Substitua:

    • BACKEND_SERVICE_NAME: o nome do serviço de back-end criado no projeto de serviço B.

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

    gcloud compute backend-services add-backend BACKEND_SERVICE_NAME \
  --balancing-mode=UTILIZATION \
  --instance-group=BACKEND_MIG \
  --instance-group-zone=us-west1-a \
  --region=us-west1 \
  --project=SERVICE_PROJECT_B_ID

Terraform

  1. Criar um modelo de instância.

    # Instance template
resource "google_compute_instance_template" "default" {
  name     = "l7-ilb-backend-template"
  provider = google-beta
  project  = "my-service-project-b-id"
  region   = "us-west1"
  # For machine type, using small. For more options check https://cloud.google.com/compute/docs/machine-types
  machine_type = "e2-small"
  tags         = ["allow-ssh", "load-balanced-backend"]
  network_interface {
    network    = google_compute_network.lb_network.id
    subnetwork = google_compute_subnetwork.lb_frontend_and_backend_subnet.id
    access_config {
      # add external ip to fetch packages like apache2, ssl
    }
  }
  disk {
    source_image = "debian-cloud/debian-12"
    auto_delete  = true
    boot         = true
  }

  # install apache2 and serve a simple web page
  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://metadata.google.internal/computeMetadata/v1/instance/name)"
    sudo echo "Page served from: $vm_hostname" | \
    tee /var/www/html/index.html
    sudo systemctl restart apache2
    EOF
  }
}

  2. criar um grupo gerenciado de instâncias.

    Para HTTP

    # MIG
resource "google_compute_instance_group_manager" "default" {
  name               = "l7-ilb-backend-example"
  provider           = google-beta
  project            = "my-service-project-b-id"
  zone               = "us-west1-a"
  base_instance_name = "vm"
  target_size        = 2
  version {
    instance_template = google_compute_instance_template.default.id
    name              = "primary"
  }
  named_port {
    name = "http"
    port = 80
  }
}

    Para HTTPS

    # MIG
resource "google_compute_instance_group_manager" "default" {
  name               = "l7-ilb-backend-example"
  provider           = google-beta
  project            = "my-service-project-b-id"
  zone               = "us-west1-a"
  base_instance_name = "vm"
  target_size        = 2
  version {
    instance_template = google_compute_instance_template.default.id
    name              = "primary"
  }
  named_port {
    name = "https"
    port = 443
  }
}

  3. Crie uma verificação de integridade para back-end.

    Para HTTP

    # health check
resource "google_compute_health_check" "default" {
  name               = "l7-ilb-basic-check"
  provider           = google-beta
  project            = "my-service-project-b-id"
  timeout_sec        = 1
  check_interval_sec = 1
  http_health_check {
    port = "80"
  }
}

    Para HTTPS

    # health check
resource "google_compute_health_check" "default" {
  name               = "l7-ilb-basic-check"
  provider           = google-beta
  project            = "my-service-project-b-id"
  timeout_sec        = 1
  check_interval_sec = 1
  https_health_check {
    port = "443"
  }
}

  4. Criar um serviço de back-end regional

    # backend service
resource "google_compute_region_backend_service" "default" {
  name                  = "l7-ilb-backend-service"
  provider              = google-beta
  project               = "my-service-project-b-id"
  region                = "us-west1"
  protocol              = "HTTP"
  load_balancing_scheme = "INTERNAL_MANAGED"
  timeout_sec           = 10
  health_checks         = [google_compute_health_check.default.id]
  backend {
    group           = google_compute_instance_group_manager.default.instance_group
    balancing_mode  = "UTILIZATION"
    capacity_scaler = 1.0
  }
}

Crie o front-end do balanceador de carga e o mapa de URL no projeto de serviço A

Todas as etapas nesta seção precisam ser realizadas no projeto de serviço A.

Console

Iniciar a configuração

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

    Acessar o "Balanceamento de carga"

  2. Clique em Criar balanceador de carga.
  3. Em Tipo de balanceador de carga, selecione Balanceador de carga de aplicativo (HTTP/HTTPS) e clique em Próxima.
  4. Em Voltado ao público ou interno, selecione Interno e clique em Próxima.
  5. Em Implantação entre regiões ou região única, selecione Melhor para cargas de trabalho regionais e clique em Próxima.
  6. Clique em Configurar.

Configuração básica

  1. Digite um Nome para o balanceador de carga.
  2. Em Região, selecione us-west1.

  3. Em Rede, selecione lb-network (do Projeto: HOST_PROJECT_NAME).

    Se você vir um aviso Sub-rede exclusiva de proxy necessária na rede VPC compartilhada, confirme se o administrador do projeto de host criou o proxy-only-subnet na região us-west1 na rede VPC compartilhada lb-network. A criação do balanceador de carga será bem-sucedida mesmo que você não tenha permissão para visualizar a sub-rede exclusiva de proxy nesta página.

  4. Mantenha a janela aberta para continuar.

Configure o back-end

  1. Clique em Configuração de back-end.
  2. Clique em Serviços de back-end entre projetos.
  3. Em ID do projeto, insira o ID do projeto para o projeto de serviço B.
  4. Na lista Selecionar serviços de back-end, selecione os serviços de back-end do projeto de serviço B que você quer usar. Para este exemplo, digite cross-ref-backend-service.
  5. Clique em OK.

Configurar as regras de roteamento

  • Clique em Regras de roteamento. Certifique-se de que cross-ref-backend-service seja o único serviço de back-end para qualquer host e qualquer caminho sem correspondência.

Saiba mais sobre gerenciamento de tráfego em Como configurar o gerenciamento de tráfego.

Configure o front-end

Para que o serviço de projetos cruzados faça referência, o front-end precisa usar a mesma rede (lb-network) do projeto host da VPC compartilhada que foi usada para criar o serviço de back-end.

Para HTTP:

  1. Clique em Configuração de front-end.
  2. Insira um nome para a regra de encaminhamento: cross-ref-http-forwarding-rule.
  3. Defina Protocolo como HTTP.
  4. Defina o Sub-rede para lb-frontend-and-backend-subnet. Não selecione a sub-rede exclusiva de proxy para o front-end, mesmo que seja uma opção na lista.
  5. Defina a Porta como 80.
  6. Clique no menu Endereço IP e em Criar endereço IP.
  7. No painel Reservar um endereço IP interno estático, forneça os seguintes detalhes:
    1. Em Nome, insira cross-ref-ip-address.
    2. Em Endereço IP estático, selecione Let me choose. Em Endereço IP personalizado, insira 10.1.2.98.
    3. (Opcional) Se você quiser compartilhar esse endereço IP com front-ends diferentes, defina Objetivo como Compartilhado.
  8. 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. Atualmente, os certificados gerenciados pelo Google não são compatíveis com balanceadores de carga de aplicativo internos.

  1. Clique em Configuração de front-end.
  2. Insira um nome para a regra de encaminhamento: cross-ref-https-forwarding-rule.
  3. No campo Protocolo, selecione HTTPS (includes HTTP/2).
  4. Defina o Sub-rede para lb-frontend-and-backend-subnet. Não selecione a sub-rede exclusiva de proxy para o front-end, mesmo que seja uma opção na lista.
  5. Certifique-se de que Porta esteja definida como 443, para permitir tráfego HTTPS.
  6. Clique no menu Endereço IP e em Criar endereço IP.
  7. No painel Reservar um endereço IP interno estático, forneça os seguintes detalhes:
    1. Em Nome, insira cross-ref-ip-address.
    2. Em Endereço IP estático, selecione Let me choose. Em Endereço IP personalizado, insira 10.1.2.98.
    3. (Opcional) Se você quiser compartilhar esse endereço IP com front-ends diferentes, defina Objetivo como Compartilhado.
  8. Clique na lista Certificate.
    1. Se você já tiver um recurso de certificado SSL autogerenciado que você quer usar como o certificado SSL principal, selecione-o no menu.
    2. Caso contrário, selecione Criar um novo certificado.
      1. Digite um Nome para o certificado SSL.
      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.
  9. Para adicionar recursos de certificado além do certificado SSL principal, siga estas etapas:
    1. Clique em Adicionar certificado.
    2. Selecione um certificado na lista Certificados ou clique em Criar um novo certificado e siga as instruções anteriores.
  10. Clique em Concluído.

Revise e finalize a configuração

  • Clique em Criar.

Testar o balanceador de carga

Após a criação do balanceador de carga, teste o balanceador usando as etapas descritas em Testar o balanceador de carga.

gcloud

  1. Opcional: antes de criar um balanceador de carga com serviços de back-end de referência cruzada, descubra se eles podem ser referenciados usando um mapa de URL:

    gcloud compute backend-services list-usable \
    --region=us-west1 \
    --project=SERVICE_PROJECT_B_ID

  2. Crie o mapa de URL e defina o serviço padrão como o serviço de back-end criado no projeto de serviço B.

    gcloud compute url-maps create URL_MAP_NAME \
    --default-service=projects/SERVICE_PROJECT_B_ID/regions/us-west1/backendServices/BACKEND_SERVICE_NAME \
    --region=us-west1 \
    --project=SERVICE_PROJECT_A_ID

    Substitua:

    • URL_MAP_NAME: o nome do mapa de URL.
    • BACKEND_SERVICE_NAME: o nome do serviço de back-end criado no projeto de serviço B.
    • SERVICE_PROJECT_B_ID: o ID do projeto de serviço B, em que os back-ends do balanceador de carga e o serviço de back-end são criados.
    • SERVICE_PROJECT_A_ID: o ID do projeto de serviço A em que o front-end do balanceador de carga está sendo criado.

    A criação de mapas de URL falhará se você não tiver a permissão compute.backendServices.use para o serviço de back-end no projeto de serviço B.

  3. Crie o proxy de destino.

    Para HTTP:

    gcloud compute target-http-proxies create HTTP_TARGET_PROXY_NAME \
  --url-map=URL_MAP_NAME \
  --url-map-region=us-west1 \
  --region=us-west1 \
  --project=SERVICE_PROJECT_A_ID

    Substitua:

    • HTTP_TARGET_PROXY_NAME: o nome do proxy HTTP de destino.

    Para HTTPS:

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

    gcloud compute ssl-certificates create SSL_CERTIFICATE_NAME \
  --certificate=PATH_TO_CERTIFICATE \
  --private-key=PATH_TO_PRIVATE_KEY \
  --region=us-west1 \
  --project=SERVICE_PROJECT_A_ID

    Substitua:

    • SSL_CERTIFICATE_NAME: o nome do recurso de certificado SSL.
    • PATH_TO_CERTIFICATE: o caminho para o arquivo de certificado SSL local no formato PEM.
    • PATH_TO_PRIVATE_KEY: o caminho para a chave privada do certificado SSL local no formato PEM.

    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 HTTPS_TARGET_PROXY_NAME \
  --url-map=URL_MAP_NAME \
  --region=us-west1 \
  --ssl-certificates=SSL_CERTIFICATE_NAME \
  --project=SERVICE_PROJECT_A_ID

    Substitua:

    • HTTPS_TARGET_PROXY_NAME: um nome para o proxy HTTPS de destino.

  4. Crie a regra de encaminhamento. Para que o serviço de projetos cruzados faça referência, a regra de encaminhamento precisa usar a mesma rede (lb-network) do projeto host da VPC compartilhada que foi usada para criar o serviço de back-end.

    Para HTTP:

    gcloud compute forwarding-rules create HTTP_FORWARDING_RULE_NAME \
  --load-balancing-scheme=INTERNAL_MANAGED \
  --network=projects/HOST_PROJECT_ID/global/networks/lb-network \
  --subnet=projects/HOST_PROJECT_ID/regions/us-west1/subnetworks/lb-frontend-and-backend-subnet \
  --address=IP_ADDRESS_CROSS_REF \
  --ports=80 \
  --region=us-west1 \
  --target-http-proxy=HTTP_TARGET_PROXY_NAME \
  --target-http-proxy-region=us-west1 \
  --project=SERVICE_PROJECT_A_ID

    Substitua:

    • HTTP_FORWARDING_RULE_NAME: o nome da regra de encaminhamento usada para processar o tráfego HTTP.

    Para HTTPS:

    gcloud compute forwarding-rules create HTTPS_FORWARDING_RULE_NAME \
  --load-balancing-scheme=INTERNAL_MANAGED \
  --network=projects/HOST_PROJECT_ID/global/networks/lb-network \
  --subnet=projects/HOST_PROJECT_ID/regions/us-west1/subnetworks/lb-frontend-and-backend-subnet \
  --address=IP_ADDRESS_CROSS_REF \
  --ports=443 \
  --region=us-west1 \
  --target-https-proxy=HTTPS_TARGET_PROXY_NAME \
  --target-https-proxy-region=us-west1 \
  --project=SERVICE_PROJECT_A_ID

    Substitua:

    • HTTPS_FORWARDING_RULE_NAME: o nome da regra de encaminhamento usada para processar o tráfego HTTPS.

  5. Para testar o balanceador de carga, use as etapas descritas em Testar o balanceador de carga.

Terraform

  1. Crie o mapa de URL.

    # URL map
resource "google_compute_region_url_map" "default" {
  name            = "l7-ilb-map"
  provider        = google-beta
  project         = "my-service-project-a-id"
  region          = "us-west1"
  default_service = google_compute_region_backend_service.default.id
}

  2. Crie o proxy de destino.

    Para HTTP

    # HTTP target proxy
resource "google_compute_region_target_http_proxy" "default" {
  name     = "l7-ilb-proxy"
  provider = google-beta
  project  = "my-service-project-a-id"
  region   = "us-west1"
  url_map  = google_compute_region_url_map.default.id
}

    Para HTTPS

    Criar um certificado SSL regional

    # Use self-signed SSL certificate
resource "google_compute_region_ssl_certificate" "default" {
  name        = "l7-ilb-cert"
  provider    = google-beta
  project     = "my-service-project-a-id"
  region      = "us-west1"
  private_key = file("sample-private.key") # path to PEM-formatted file
  certificate = file("sample-server.cert") # path to PEM-formatted file
}

    Como usar o certificado SSL regional para criar um proxy de destino

    # HTTPS target proxy
resource "google_compute_region_target_https_proxy" "default" {
  name             = "l7-ilb-proxy"
  provider         = google-beta
  project          = "my-service-project-a-id"
  region           = "us-west1"
  url_map          = google_compute_region_url_map.default.id
  ssl_certificates = [google_compute_region_ssl_certificate.default.id]
}

  3. Crie a regra de encaminhamento.

    Para HTTP

    # Forwarding rule
resource "google_compute_forwarding_rule" "default" {
  name                  = "l7-ilb-forwarding-rule"
  provider              = google-beta
  project               = "my-service-project-a-id"
  region                = "us-west1"
  ip_protocol           = "TCP"
  port_range            = "80"
  load_balancing_scheme = "INTERNAL_MANAGED"
  target                = google_compute_region_target_http_proxy.default.id
  network               = google_compute_network.lb_network.id
  subnetwork            = google_compute_subnetwork.lb_frontend_and_backend_subnet.id
  network_tier          = "PREMIUM"
  depends_on            = [google_compute_subnetwork.lb_frontend_and_backend_subnet]
}

    Para HTTPS

    # Forwarding rule
resource "google_compute_forwarding_rule" "default" {
  name                  = "l7-ilb-forwarding-rule"
  provider              = google-beta
  project               = "my-service-project-a-id"
  region                = "us-west1"
  ip_protocol           = "TCP"
  port_range            = "443"
  load_balancing_scheme = "INTERNAL_MANAGED"
  target                = google_compute_region_target_https_proxy.default.id
  network               = google_compute_network.lb_network.id
  subnetwork            = google_compute_subnetwork.lb_frontend_and_backend_subnet.id
  network_tier          = "PREMIUM"
  depends_on            = [google_compute_subnetwork.lb_frontend_and_backend_subnet]
}

  4. Para testar o balanceador de carga, use as etapas descritas em Testar o balanceador de carga.

Conceder permissões ao administrador do balanceador de carga para usar o serviço de back-end

Se você quiser que os balanceadores de carga façam referência a serviços de back-end em outros projetos de serviço, o administrador do balanceador de carga precisará ter a permissão compute.backendServices.use. Para conceder essa permissão, use o papel predefinido do IAM chamado Usuário de serviços do balanceador de carga do Compute (roles/compute.loadBalancerServiceUser). Esse papel precisa ser concedido pelo Administrador do projeto de serviço e pode ser aplicado no nível do projeto ou no nível do serviço de back-end individual.

Esta etapa não será necessária se você já tiver concedido as permissões necessárias no nível do serviço de back-end ao criá-lo. Você pode pular esta seção ou continuar a ler para saber como conceder acesso a todos os serviços de back-end neste projeto para que não precise conceder acesso sempre que criar um novo back-end serviço.

Neste exemplo, um administrador de projeto de serviço do projeto B precisa executar um dos comandos a seguir para conceder a permissão compute.backendServices.use a um administrador do balanceador de carga do projeto de serviço A. Isso pode ser feito no nível do projeto (para todos os serviços de back-end no projeto) ou por serviço de back-end.

Console

Permissões de nível de projeto

Use as etapas a seguir para conceder permissões a todos os serviços de back-end no projeto.

Você precisa das permissões compute.regionBackendServices.setIamPolicy e resourcemanager.projects.setIamPolicy para concluir esta etapa.

  1. No console do Google Cloud, abra a página IAM.

    Acessar IAM

  2. Selecione o projeto.

  3. Clique em Conceder acesso.

  4. No campo Novos principais, insira o endereço de e-mail do principal ou outro identificador.

  5. Na lista Selecionar um papel, selecione Usuário de serviços do balanceador de carga do Compute.

  6. Opcional: adicione uma condição ao papel.

  7. Clique em Salvar.

Permissões no nível do recurso para serviços de back-end individuais

Use as etapas a seguir para conceder permissões a serviços de back-end individuais no projeto.

A permissão compute.regionBackendServices.setIamPolicy é necessária para concluir esta etapa.

  1. No console do Google Cloud, abra a página Back-ends.

    Acessar back-ends

  2. Na lista de back-ends, selecione o serviço de back-end a que você quer conceder acesso e clique em Permissões.

  3. Clique em Adicionar principal.

  4. No campo Novos principais, insira o endereço de e-mail do principal ou outro identificador.

  5. Na lista Selecionar um papel, selecione Usuário de serviços do balanceador de carga do Compute.

  6. Clique em Salvar.

gcloud

Permissões de nível de projeto

Use as etapas a seguir para conceder permissões a todos os serviços de back-end no projeto.

Você precisa das permissões compute.regionBackendServices.setIamPolicy e resourcemanager.projects.setIamPolicy para concluir esta etapa. 

gcloud projects add-iam-policy-binding SERVICE_PROJECT_B_ID \
    --member="user:LOAD_BALANCER_ADMIN" \
    --role="roles/compute.loadBalancerServiceUser"

Permissões no nível do recurso para serviços de back-end individuais

No nível de serviço de back-end, os administradores do projeto de serviço podem usar um dos comandos a seguir para conceder o papel de usuário de serviços do balanceador de carga do Compute (roles/compute.loadBalancerServiceUser).

A permissão compute.regionBackendServices.setIamPolicy é necessária para concluir esta etapa. 

gcloud projects add-iam-policy-binding SERVICE_PROJECT_B_ID \
    --member="user:LOAD_BALANCER_ADMIN" \
    --role="roles/compute.loadBalancerServiceUser" \
    --condition='expression=resource.name=="projects/SERVICE_PROJECT_B_ID/regions/us-west1/backend-services/BACKEND_SERVICE_NAME",title=Shared VPC condition'

ou

gcloud compute backend-services add-iam-policy-binding BACKEND_SERVICE_NAME \
    --member="user:LOAD_BALANCER_ADMIN" \
    --role="roles/compute.loadBalancerServiceUser" \
    --project=SERVICE_PROJECT_B_ID \
    --region=us-west1

Para usar esses comandos, substitua LOAD_BALANCER_ADMIN pelo principal do usuário, por exemplo, test-user@gmail.com.

Também é possível configurar permissões do IAM para que elas se apliquem apenas a um subconjunto de serviços de back-end regionais usando condições e especificando atributos de condição.

Para acessar mapas de URL que fazem referência a um determinado serviço de back-end de VPC compartilhada, siga estas etapas:

gcloud

Para conferir os recursos que fazem referência a um serviço de back-end regional de VPC compartilhada, execute o seguinte comando:

gcloud compute backend-services describe BACKEND_SERVICE_NAME \
    --region REGION

Substitua:

  • BACKEND_SERVICE_NAME: o nome do carregamento serviço de back-end de balanceador
  • REGION: a região do balanceador de carga

Na resposta ao comando, revise o campo usedBy, que mostra o que fazem referência ao serviço de back-end, como mostrado a seguir: exemplo:

id: '123456789'
kind: compute#backendService
loadBalancingScheme: INTERNAL_MANAGED
...
usedBy:
-   reference: https://www.googleapis.com/compute/v1/projects/my-project/region/us-central1/urlMaps/my-url-map

A seguir