Configure um Application Load Balancer interno com a VPC partilhada

Consola

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

   Aceda a redes de VPC

2. Clique em Criar rede de VPC.
3. Em Nome, introduza lb-network.

4. Na secção Subnets (Sub-redes):

   1. Defina o Subnet creation mode (Modo de criação de sub-rede) como Custom (Personalizado).

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

      • Nome: 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 na 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 de 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
   }

Consola

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

   Aceda a redes de VPC

2. Clique no nome da rede VPC partilhada: lb-network.
3. Clique em Adicionar sub-rede.
4. Em Nome, introduza proxy-only-subnet.
5. Para Região, selecione us-west1.
6. Defina Purpose como Regional Managed Proxy.
7. Para o Intervalo de endereços IP, introduza 10.129.0.0/23.
8. Clique em Adicionar.

gcloud

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

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

Terraform

Crie a sub-rede só de 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
}

Consola

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

   Aceder a Políticas de firewall

2. Clique em Criar regra de firewall para criar a regra que permite Trusted Cloud verificações de funcionamento:
• Nome: fw-allow-health-check
• Rede: lb-network
• Sentido do tráfego: entrada
• Ação na correspondência: permitir
• Objetivos: etiquetas de objetivo especificadas
• Etiquetas de segmentação: load-balanced-backend
• Filtro de origem: intervalos de IPv4
• Intervalos de IPv4 de origem: 130.211.0.0/22 e 35.191.0.0/16
• Protocolos e portas:
  • Escolha Protocolos e portas especificados.
  • Selecione TCP e introduza 80 para o número da porta.

  Como prática recomendada, limite esta regra apenas aos protocolos e às portas que correspondam aos usados pela sua verificação de funcionamento. Se usar tcp:80 para o protocolo e a porta, Trusted Cloud pode usar HTTP na porta 80 para contactar as suas VMs, mas não pode usar HTTPS na porta 443 para as contactar.

3. Clique em Criar.
4. Clique em Criar regra de firewall para criar a regra que permite Trusted Cloud verificações de funcionamento:
• Nome: fw-allow-proxies
• Rede: lb-network
• Sentido do tráfego: entrada
• Ação na correspondência: permitir
• Objetivos: etiquetas de objetivo especificadas
• Etiquetas de segmentação: load-balanced-backend
• Filtro de origem: intervalos de IPv4
• Intervalos IPv4 de origem: 10.129.0.0/23
• Protocolos e portas:
  • Escolha Protocolos e portas especificados.
  • Selecione TCP e introduza 80, 443, 8080 para os números das portas.
5. Clique em Criar.
6. Clique em Criar regra de firewall para criar a regra que permite Trusted Cloud verificações de funcionamento:
• Nome: fw-allow-ssh
• Rede: lb-network
• Sentido do tráfego: entrada
• Ação na correspondência: permitir
• Objetivos: etiquetas de objetivo especificadas
• Etiquetas de segmentação: allow-ssh
• Filtro de origem: intervalos de IPv4
• Intervalos IPv4 de origem: 0.0.0.0/0
• Protocolos e portas:
  • Escolha Protocolos e portas especificados.
  • Selecione TCP e introduza 22 para 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 funcionamentoTrusted Cloud . Este exemplo permite todo o tráfego TCP de sondas de verificação de estado. No entanto, pode configurar um conjunto mais restrito de portas para satisfazer as suas necessidades.

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

2. Crie a regra de firewall fw-allow-proxies para permitir o tráfego da sub-rede só de proxy do Envoy para alcançar os 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 para permitir a conetividade SSH a VMs com a etiqueta de rede allow-ssh. Quando omite source-ranges, Trusted Cloud interpreta a regra como 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 Trusted Cloud verificações de funcionamento.

   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 só de proxy do Envoy alcance os 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 para permitir a conetividade SSH a VMs com a etiqueta 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"]
   }

Consola

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

   Aceda a Modelos de instâncias

   1. Clique em Criar modelo de instância.
   2. Em Nome, introduza l7-ilb-backend-template.
   3. Certifique-se de que o Disco de arranque está definido para uma imagem Debian, como Debian GNU/Linux 12 (bookworm). Estas instruções usam comandos que só estão disponíveis no Debian, como apt-get. Se precisar de alterar o Disco de arranque, clique em Alterar.
      1. Em Sistema operativo, selecione Debian.
      2. Para 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, de seguida, em Redes.
   5. Introduza as seguintes etiquetas de rede: allow-ssh e load-balanced-backend.
   6. Na secção Interfaces de rede, selecione Redes partilhadas comigo (do projeto anfitrião: HOST_PROJECT_ID).
   7. Selecione a sub-rede lb-frontend-and-backend-subnet na rede lb-network.
   8. Clique em Gestão. Para Gestão, insira o seguinte script no campo Script de arranque.

       #! /bin/bash
       apt-get update
       apt-get install apache2 -y
       a2ensite default-ssl
       a2enmod ssl
       vm_hostname="$(curl -H "Metadata-Flavor:Google" 
      
       http://metadata.google.internal/computeMetadata/v1/instance/name)"
       echo "Page served from: $vm_hostname" | 
      
       tee /var/www/html/index.html
       systemctl restart apache2
       

   9. Clique em Criar.

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

   Aceda a Grupos de instâncias

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

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

      Para este exemplo, especifique as seguintes opções para o dimensionamento automático:

      • Para o Modo de ajuste automático de escala, selecione Off:do not autoscale.
      • Para Número máximo de instâncias, introduza 2.

      Opcionalmente, na secção Ajuste de escala automático da IU, pode configurar o grupo de instâncias para adicionar ou remover automaticamente instâncias com base na utilização do CPU das instâncias.

   9. Clique em Criar.

gcloud

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

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

   gcloud compute instance-templates create l7-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 gerido 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. Crie um grupo de instâncias gerido.

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

Consola

Mude o contexto para o projeto de serviço

1. Na Trusted Cloud consola, aceda à página Painel de controlo.

   Aceder ao painel de controlo

2. Clique na lista Selecionar de na parte superior da página. Na janela Selecionar de apresentada, selecione o projeto de serviço onde quer criar o balanceador de carga.

Selecione o tipo de balanceador de carga

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

   Aceda a Balanceamento de carga

2. Clique em Criar equilibrador de carga.
3. Em Tipo de balanceador de carga, selecione Balanceador de carga de aplicações (HTTP/HTTPS) e clique em Seguinte.
4. Para Público ou interno, selecione Interno e clique em Seguinte.
5. Para a Implementação em várias regiões ou numa única região, selecione Melhor para cargas de trabalho regionais e clique em Seguinte.
6. Clique em Configurar.

Configuração básica

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

3. Para a rede, selecione lb-network (de Project: HOST_PROJECT_ID).

   Se vir o aviso É necessária uma sub-rede apenas de proxy na rede VPC partilhada, confirme que o administrador do projeto anfitrião criou a proxy-only-subnet na região us-west1 na lb-network rede VPC partilhada. A criação do equilibrador de carga é bem-sucedida, mesmo que não tenha autorização para ver a sub-rede apenas 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 lista Verificação de funcionamento, selecione Criar uma verificação de funcionamento e, de seguida, introduza as seguintes informações:
   1. Nome: l7-ilb-basic-check
   2. Protocolo: HTTP
   3. Porta: 80
6. Clique em Criar.

7. Na secção Novo back-end:

   1. Defina o Grupo de instâncias como l7-ilb-backend-example.
   2. Defina os Números de portas para 80.
   3. Defina o Modo de equilíbrio como Utilização.
   4. Clique em Concluído.

8. Clique em Criar.

Configure as regras de encaminhamento

• Clique em Regras de encaminhamento. Certifique-se de que l7-ilb-backend-service é o único serviço de back-end para qualquer anfitrião não correspondente e qualquer caminho não correspondente.

Para informações sobre a gestão de tráfego, consulte o artigo Configurar a gestão de tráfego.

Configure a interface

Para HTTP:

1. Clique em Configuração do front-end.
2. Defina o Nome como l7-ilb-forwarding-rule.
3. Defina o Protocolo como HTTP.
4. Defina a Sub-rede como lb-frontend-and-backend-subnet. Não selecione a sub-rede apenas de proxy para o front-end, mesmo que seja uma opção na lista.
5. Defina a Porta para 80.
6. Clique no menu Endereço IP e, de seguida, em Criar endereço IP.
7. No painel Reserve um endereço IP interno estático, indique os seguintes detalhes:
   1. No campo Nome, introduza ip-address-shared-vpc.
   2. Para Endereço IP estático, clique em Eu escolho. Para Endereço IP personalizado, introduza 10.1.2.99.
   3. (Opcional) Se quiser partilhar este endereço IP com diferentes front-ends, defina o Objetivo como Partilhado.
8. Clique em Concluído.

Para HTTPS:

Se estiver a usar o protocolo HTTPS entre o cliente e o balanceador de carga, precisa de um ou mais recursos de certificado SSL para configurar o proxy. Para obter informações sobre como criar recursos de certificados SSL, consulte o artigo Certificados SSL. Atualmente, os certificados geridos pela Google não são suportados com equilibradores de carga de aplicações internos.

1. Clique em Configuração do front-end.
2. No campo Nome, introduza l7-ilb-forwarding-rule.
3. No campo Protocolo, selecione HTTPS (includes HTTP/2).
4. Defina a Sub-rede como lb-frontend-and-backend-subnet. Não selecione a sub-rede apenas de proxy para o front-end, mesmo que seja uma opção na lista.
5. Certifique-se de que a Porta está definida como 443 para permitir o tráfego HTTPS.
6. Clique no menu Endereço IP e, de seguida, em Criar endereço IP.
7. No painel Reserve um endereço IP interno estático, indique os seguintes detalhes:
   1. No campo Nome, introduza ip-address-shared-vpc.
   2. Para Endereço IP estático, clique em Eu escolho. Para Endereço IP personalizado, introduza 10.1.2.99.
   3. (Opcional) Se quiser partilhar este endereço IP com diferentes front-ends, defina o Objetivo como Partilhado.
8. Clique na lista Certificado.
   1. Se já tiver um recurso de certificado SSL autogerido que queira usar como certificado SSL principal, selecione-o no menu.
   2. Caso contrário, selecione Criar um novo certificado.
      1. Preencha um Nome de l7-ilb-cert.
      2. Nos campos adequados, carregue os seus ficheiros formatados em PEM:
         • Certificado de chave pública
         • Cadeia de certificados
         • Chave privada
      3. Clique em Criar.
9. Para adicionar recursos de certificados além do recurso de certificado SSL principal:
   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.

Reveja e finalize a configuração

• Clique em Criar.

gcloud

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

   gcloud compute health-checks create http l7-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 URLs 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:

   Para obter informações sobre como criar recursos de certificados SSL, consulte o artigo Certificados SSL. Atualmente, os certificados geridos pela Google não são suportados com equilibradores de carga de aplicações internos.

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

   export LB_CERT=path to PEM-formatted file
   

   export LB_PRIVATE_KEY=path to PEM-formatted file
   

   Crie um certificado SSL regional com 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, tem de fazer referência à sub-rede na regra de encaminhamento.

   Para o endereço IP da regra de encaminhamento, use lb-frontend-and-backend-subnet. Se tentar usar a sub-rede apenas de proxy, a criação da regra de encaminhamento falha.

   Para HTTP:

   Use o comando gcloud compute forwarding-rules create com as flags 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 flags 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 funcionamento 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 URLs.

   # 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

   Para obter informações sobre como criar recursos de certificados SSL, consulte o artigo Certificados SSL. Atualmente, os certificados geridos pela Google não são suportados com equilibradores de carga de aplicações 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
   }

   Use 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, tem de fazer referência à 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]
   }

Consola

1. Na Trusted Cloud consola, aceda à página Instâncias de VM.

   Aceder às 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, de seguida, em Redes.

6. Introduza as seguintes etiquetas de rede: allow-ssh e load-balanced-backend.

7. Na secção Interfaces de rede, selecione Redes partilhadas comigo (do projeto anfitrião: 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"]
    ]
  }
}

Consola

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

   Aceda a Modelos de instâncias

   1. Clique em Criar modelo de instância.
   2. Introduza um Nome para o modelo de instância: cross-ref-backend-template.
   3. Certifique-se de que o Disco de arranque está definido para uma imagem Debian, como Debian GNU/Linux 12 (bookworm). Estas instruções usam comandos que só estão disponíveis no Debian, como apt-get. Se precisar de alterar o Disco de arranque, clique em Alterar.
      1. Em Sistema operativo, selecione Debian.
      2. Para 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, de seguida, em Redes.
   5. Introduza as seguintes etiquetas de rede: allow-ssh e load-balanced-backend.
   6. Na secção Interfaces de rede, selecione Redes partilhadas comigo (do projeto anfitrião: HOST_PROJECT_ID).
   7. Selecione a sub-rede lb-frontend-and-backend-subnet na rede lb-network.
   8. Clique em Gestão. Para Gestão, insira o seguinte script no campo Script de arranque.

      #! /bin/bash
      apt-get update
      apt-get install apache2 -y
      a2ensite default-ssl
      a2enmod ssl
      vm_hostname="$(curl -H "Metadata-Flavor:Google" 
      
      http://metadata.google.internal/computeMetadata/v1/instance/name)"
      echo "Page served from: $vm_hostname" | 
      
      tee /var/www/html/index.html
      systemctl restart apache2
      

   9. Clique em Criar.

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

   Aceda a Grupos de instâncias

   1. Clique em Criar grupo de instâncias.
   2. Escolha Novo grupo de instâncias gerido (sem estado). Para mais informações, consulte o artigo Grupos de instâncias geridos sem estado ou com estado.
   3. Introduza um Nome para o grupo de instâncias: cross-ref-ig-backend.
   4. Para Localização, selecione Zona única.
   5. Para Região, selecione us-west1.
   6. Para Zona, selecione us-west1-a.
   7. Para Modelo de instância, selecione cross-ref-backend-template.

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

      Para este exemplo, especifique as seguintes opções para o dimensionamento automático:

      • Para o Modo de ajuste automático de escala, selecione Off:do not autoscale.
      • Para Número máximo de instâncias, introduza 2.

      Opcionalmente, na secção Ajuste de escala automático da IU, pode configurar o grupo de instâncias para adicionar ou remover automaticamente instâncias com base na utilização do CPU das instâncias.

   9. Clique em Criar.

3. Crie um serviço de back-end regional. Como parte deste passo, também vamos criar a verificação de funcionamento e adicionar back-ends ao serviço de back-end. Na Trusted Cloud consola, aceda à página Back-ends.

   Aceda a Back-ends

   1. Clique em Criar serviço de back-end regional.
   2. Introduza um Nome para o serviço de back-end: cross-ref-backend-service.
   3. Para Região, selecione us-west1.
   4. Para Tipo de balanceador de carga, selecione Balanceador de carga de aplicações interno regional (INTERNAL_MANAGED).
   5. Defina o Tipo de back-end como Grupos de instâncias.
   6. Na lista Verificação de funcionamento, clique em Criar uma verificação de funcionamento e, em seguida, introduza as seguintes informações:
      1. Nome: cross-ref-http-health-check
      2. Protocolo: HTTP
      3. Porta: 80
   7. Clique em Criar.
   8. Na secção Back-ends, defina Rede como lb-network.
   9. Clique em Adicionar back-end e defina os seguintes campos:
      1. Defina Grupo de instâncias como cross-ref-ig-backend.
      2. Introduza os números de porta: 80.
      3. Defina o Modo de equilíbrio como Utilização.
      4. Clique em Concluído.
   10. Clique em Continuar.

   11. Opcional: na secção Adicionar autorizações, introduza os principais da IAM (normalmente, um endereço de email) dos administradores do Load Balancer de outros projetos para que possam usar este serviço de backend para equilibradores de carga nos respetivos projetos. Sem esta autorização, não pode usar referências de serviços entre projetos.

       Se não tiver autorização para definir políticas de controlo de acesso para serviços de back-end neste projeto, pode criar o serviço de back-end agora, e um utilizador autorizado pode realizar este passo mais tarde, conforme descrito na secção Conceda autorizações ao administrador do equilibrador de carga para usar o serviço de back-end. Essa secção também descreve como conceder acesso a todos os serviços de back-end neste projeto, para que não tenha de conceder acesso sempre que criar um novo serviço de back-end.

   12. Clique em Criar.

gcloud

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

   gcloud compute instance-templates create 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 o seguinte:

   • BACKEND_IG_TEMPLATE: o nome do modelo de grupo de instâncias.
   • SERVICE_PROJECT_B_ID: o ID do projeto para o projeto de serviço B, onde os back-ends do balanceador de carga e o serviço de back-end estão a ser criados.
   • HOST_PROJECT_ID: o ID do projeto do projeto anfitrião da VPC partilhada.

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

   gcloud compute instance-groups managed create BACKEND_MIG \
       --zone=us-west1-a \
       --size=2 \
       --template=BACKEND_IG_TEMPLATE \
       --project=SERVICE_PROJECT_B_ID
   

   Substitua o seguinte:

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

3. Defina a verificação de funcionamento de 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 o seguinte:

   • HTTP_HEALTH_CHECK_NAME: o nome da verificação de funcionamento 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 o seguinte:

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

   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 funcionamento para o 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. Crie 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
     }
   }

Consola

Selecione o tipo de balanceador de carga

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

   Aceda a Balanceamento de carga

2. Clique em Criar equilibrador de carga.
3. Em Tipo de balanceador de carga, selecione Balanceador de carga de aplicações (HTTP/HTTPS) e clique em Seguinte.
4. Para Público ou interno, selecione Interno e clique em Seguinte.
5. Para a Implementação em várias regiões ou numa única região, selecione Melhor para cargas de trabalho regionais e clique em Seguinte.
6. Clique em Configurar.

Configuração básica

1. Introduza um nome para o equilibrador de carga.
2. Para a Região, selecione us-west1.

3. Para a rede, selecione lb-network (de Project: HOST_PROJECT_NAME).

   Se vir o aviso É necessária uma sub-rede apenas de proxy na rede VPC partilhada, confirme que o administrador do projeto anfitrião criou a proxy-only-subnet na região us-west1 na lb-network rede VPC partilhada. A criação do equilibrador de carga é bem-sucedida, mesmo que não tenha autorização para ver a sub-rede apenas 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. Para o ID do projeto, introduza 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 quer usar. Para este exemplo, introduza cross-ref-backend-service.
5. Clique em OK.

Configure as regras de encaminhamento

• Clique em Regras de encaminhamento. Certifique-se de que o cross-ref-backend-service é o único serviço de back-end para qualquer anfitrião não correspondente e qualquer caminho não correspondente.

Para informações sobre a gestão de tráfego, consulte o artigo Configurar a gestão de tráfego.

Configure a interface

Para que a referência de serviços entre projetos funcione, o front-end tem de usar a mesma rede (lb-network) do projeto anfitrião de VPC partilhada que foi usada para criar o serviço de back-end.

Para HTTP:

1. Clique em Configuração do front-end.
2. Introduza um Nome para a regra de encaminhamento: cross-ref-http-forwarding-rule.
3. Defina o Protocolo como HTTP.
4. Defina a Sub-rede como lb-frontend-and-backend-subnet. Não selecione a sub-rede apenas de proxy para o front-end, mesmo que seja uma opção na lista.
5. Defina a Porta para 80.
6. Clique no menu Endereço IP e, de seguida, em Criar endereço IP.
7. No painel Reserve um endereço IP interno estático, indique os seguintes detalhes:
   1. No campo Nome, introduza cross-ref-ip-address.
   2. Para Endereço IP estático, clique em Eu escolho. Para Endereço IP personalizado, introduza 10.1.2.98.
   3. (Opcional) Se quiser partilhar este endereço IP com diferentes front-ends, defina o Objetivo como Partilhado.
8. Clique em Concluído.

Para HTTPS:

Se estiver a usar o protocolo HTTPS entre o cliente e o balanceador de carga, precisa de um ou mais recursos de certificado SSL para configurar o proxy. Para obter informações sobre como criar recursos de certificados SSL, consulte o artigo Certificados SSL. Atualmente, os certificados geridos pela Google não são suportados com equilibradores de carga de aplicações internos.

1. Clique em Configuração do front-end.
2. Introduza um Nome para a regra de encaminhamento: cross-ref-https-forwarding-rule.
3. No campo Protocolo, selecione HTTPS (includes HTTP/2).
4. Defina a Sub-rede como lb-frontend-and-backend-subnet. Não selecione a sub-rede apenas de proxy para o front-end, mesmo que seja uma opção na lista.
5. Certifique-se de que a Porta está definida como 443 para permitir o tráfego HTTPS.
6. Clique no menu Endereço IP e, de seguida, em Criar endereço IP.
7. No painel Reserve um endereço IP interno estático, indique os seguintes detalhes:
   1. No campo Nome, introduza cross-ref-ip-address.
   2. Para Endereço IP estático, clique em Eu escolho. Para Endereço IP personalizado, introduza 10.1.2.98.
   3. (Opcional) Se quiser partilhar este endereço IP com diferentes front-ends, defina o Objetivo como Partilhado.
8. Clique na lista Certificado.
   1. Se já tiver um recurso de certificado SSL autogerido que quer usar como certificado SSL principal, selecione-o no menu.
   2. Caso contrário, selecione Criar um novo certificado.
      1. Introduza um Nome para o certificado SSL.
      2. Nos campos adequados, carregue os seus ficheiros formatados em PEM:
         • Certificado de chave pública
         • Cadeia de certificados
         • Chave privada
      3. Clique em Criar.
9. Para adicionar recursos de certificados além do recurso de certificado SSL principal:
   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.

Reveja e finalize a configuração

• Clique em Criar.

Teste o balanceador de carga

Depois de criar o balanceador de carga, teste-o seguindo os passos descritos em Teste o balanceador de carga.

gcloud

1. Opcional: antes de criar um balanceador de carga com serviços de back-end de referências cruzadas, descubra se os serviços de back-end aos quais quer fazer referência podem ser referenciados através de um mapa de URLs:

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

2. Crie o mapa de URLs e defina o serviço predefinido para 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 o seguinte:

   • URL_MAP_NAME: o nome do mapa de URLs.
   • 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 do projeto de serviço B, onde 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 do projeto de serviço A, onde está a ser criado o front-end do balanceador de carga.

   A criação do mapa de URLs falha se não tiver a autorizaçã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 o seguinte:

   • HTTP_TARGET_PROXY_NAME: o nome do proxy HTTP de destino.

   Para HTTPS:

   Crie um certificado SSL regional com 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 o seguinte:

   • SSL_CERTIFICATE_NAME: o nome do recurso de certificado SSL.
   • PATH_TO_CERTIFICATE: o caminho para o ficheiro 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 o seguinte:

   • HTTPS_TARGET_PROXY_NAME: o nome do proxy HTTPS de destino.

4. Crie a regra de encaminhamento. Para que a referência de serviço entre projetos funcione, a regra de encaminhamento tem de usar a mesma rede (lb-network) do projeto anfitrião de VPC partilhada 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 o seguinte:

   • 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 o seguinte:

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

5. Para testar o equilibrador de carga, siga os passos descritos em Teste o equilibrador de carga.

Terraform

1. Crie o mapa de URLs.

   # 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

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

   Use 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 equilibrador de carga, siga os passos descritos em Teste o equilibrador de carga.

Consola

Autorizações ao nível do projeto

Siga os passos abaixo para conceder autorizações a todos os serviços de back-end no seu projeto.

Precisa das autorizações compute.regionBackendServices.setIamPolicy e resourcemanager.projects.setIamPolicy para concluir este passo.

1. Na Trusted Cloud consola, aceda à página IAM.

   Aceda ao IAM

2. Selecione o seu projeto.

3. Clique em person_addConceder acesso.

4. No campo Novos membros, introduza o endereço de email do membro ou outro identificador.

5. Na lista Selecionar uma função, selecione Utilizador dos serviços do Compute Load Balancer.

6. Opcional: adicione uma condição à função.

7. Clique em Guardar.

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

Siga os passos abaixo para conceder autorizações a serviços de back-end individuais no seu projeto.

Precisa da autorização compute.regionBackendServices.setIamPolicy para concluir este passo.

1. Na Trusted Cloud consola, aceda à página Back-ends.

   Aceda a Back-ends

2. Na lista de back-ends, selecione o serviço de back-end ao qual quer conceder acesso e clique em person_addAutorizações.

3. Clique em person_addAdicionar principal.

4. No campo Novos membros, introduza o endereço de email do membro ou outro identificador.

5. Na lista Selecionar uma função, selecione Utilizador dos serviços do Compute Load Balancer.

6. Clique em Guardar.

gcloud

Autorizações ao nível do projeto

Siga os passos abaixo para conceder autorizações a todos os serviços de back-end no seu projeto.

Precisa das autorizações compute.regionBackendServices.setIamPolicy e resourcemanager.projects.setIamPolicy para concluir este passo.

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

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

Ao nível do serviço de back-end, os administradores do projeto de serviço podem usar qualquer um dos seguintes comandos para conceder a função de utilizador dos serviços de equilibrador de carga do Compute (roles/compute.loadBalancerServiceUser).

Precisa da autorização compute.regionBackendServices.setIamPolicy para concluir este passo.

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 estes comandos, substitua LOAD_BALANCER_ADMIN pelo principal do utilizador. Por exemplo, test-user@gmail.com.

Também pode configurar autorizações da IAM para que se apliquem apenas a um subconjunto de serviços de back-end regionais através de condições e da especificação de atributos de condições.

gcloud

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

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

Substitua o seguinte:

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

No resultado do comando, reveja o campo usedBy, que apresenta os recursos que referenciam o serviço de back-end, conforme mostrado no exemplo seguinte:

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