Configurar um grupo gerenciado de instâncias

Console

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

   Acessar redes VPC

2. Clique em Criar rede VPC.

3. Digite um Nome para a rede.

4. Em Modo de criação da sub-rede, escolha Personalizado.

5. Na seção Nova sub-rede, configure os seguintes campos:

   1. Forneça um Nome para a sub-rede.
   2. Selecione uma Região.
   3. Em Tipo de pilha de IP, selecione IPv4 (pilha única).
   4. Digite um Intervalo de endereço IP. Esse é o intervalo IPv4 principal da sub-rede.

6. Clique em Concluído.

7. Para adicionar uma sub-rede em uma região diferente, clique em Adicionar sub-rede e repita as etapas anteriores.

8. Clique em Criar.

gcloud

1. Crie a rede VPC de modo personalizado:

   gcloud compute networks create NETWORK \
       --subnet-mode=custom
   

2. Na rede, crie uma sub-rede para back-ends:

   gcloud compute networks subnets create SUBNET \
       --network=NETWORK \
       --stack-type=IPV4_ONLY \
       --range=10.1.2.0/24 \
       --region=REGION
   

   Substitua:

   • NETWORK: um nome para a rede VPC.

   • SUBNET: um nome para a sub-rede.

   • REGION: o nome da região.

Console

Para oferecer suporte ao tráfego IPv4, siga estas etapas:

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

   Acessar "Modelos de instância"

2. Clique em Criar modelo de instância.

3. Em Nome, insira lb-backend-template.

4. Verifique se o disco de inicialização está definido como uma imagem Debian. Por exemplo, Debian GNU/Linux 10 (buster). Estas instruções usam comandos que estão disponíveis apenas no Debian, como apt-get.

5. Expanda Opções avançadas.

6. Expanda Rede e configure os seguintes campos:

   1. Em Tags de rede, insira allow-health-check.
   2. Na seção Interfaces de rede, clique em editEditar e faça as seguintes alterações:
      • Rede: NETWORK
      • Sub-rede: SUBNET
      • Tráfego IPv4: IPv4 (pilha única)
   3. Clique em Concluído.

7. Expanda Gerenciamento. No campo Script de inicialização, digite o script a seguir:

   #! /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
   

8. Clique em Criar.

gcloud

Para aceitar o tráfego IPv4, execute o seguinte comando:

gcloud compute instance-templates create TEMPLATE_NAME \
  --region=REGION \
  --network=NETWORK \
  --subnet=SUBNET \
  --stack-type=IPV4_ONLY \
  --tags=allow-health-check \
  --image-family=debian-10 \
  --image-project=debian-cloud \
  --metadata=startup-script='#! /bin/bash
    apt-get update
    apt-get install apache2 -y
    a2ensite default-ssl
    a2enmod ssl
    vm_hostname="$(curl -H "Metadata-Flavor:Google" \
    http://metadata.google.internal/computeMetadata/v1/instance/name)"
    echo "Page served from: $vm_hostname" | \
    tee /var/www/html/index.html
    systemctl restart apache2'

Terraform

Para criar o modelo de instância, use o recurso google_compute_instance_template.

resource "google_compute_instance_template" "default" {
  name = "lb-backend-template"
  disk {
    auto_delete  = true
    boot         = true
    device_name  = "persistent-disk-0"
    mode         = "READ_WRITE"
    source_image = "projects/debian-cloud/global/images/family/debian-11"
    type         = "PERSISTENT"
  }
  labels = {
    managed-by-cnrm = "true"
  }
  machine_type = "n1-standard-1"
  metadata = {
    startup-script = "#! /bin/bash\n     sudo apt-get update\n     sudo apt-get install apache2 -y\n     sudo a2ensite default-ssl\n     sudo a2enmod ssl\n     vm_hostname=\"$(curl -H \"Metadata-Flavor:Google\" \\\n   http://169.254.169.254/computeMetadata/v1/instance/name)\"\n   sudo echo \"Page served from: $vm_hostname\" | \\\n   tee /var/www/html/index.html\n   sudo systemctl restart apache2"
  }
  network_interface {
    access_config {
      network_tier = "PREMIUM"
    }
    network    = "global/networks/default"
    subnetwork = "regions/us-east1/subnetworks/default"
  }
  region = "us-east1"
  scheduling {
    automatic_restart   = true
    on_host_maintenance = "MIGRATE"
    provisioning_model  = "STANDARD"
  }
  service_account {
    email  = "default"
    scopes = ["https://www.googleapis.com/auth/devstorage.read_only", "https://www.googleapis.com/auth/logging.write", "https://www.googleapis.com/auth/monitoring.write", "https://www.googleapis.com/auth/pubsub", "https://www.googleapis.com/auth/service.management.readonly", "https://www.googleapis.com/auth/servicecontrol", "https://www.googleapis.com/auth/trace.append"]
  }
  tags = ["allow-health-check"]
}

Console

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

   Acesse grupo de instâncias

2. Clique em Criar grupo de instâncias.

3. À esquerda, escolha Novo grupo gerenciado de instâncias (sem estado).

4. Em Nome, insira lb-backend-example.

5. Em Local, selecione Única zona.

6. Em Região, selecione a região de sua preferência.

7. Em Zona, selecione uma zona.

8. Em Modelo de instância, selecione o modelo de instância lb-backend-template.

9. Em Modo de escalonamento automático, selecione Ativado: adicionar e remover instâncias para o grupo.

   Defina o Número mínimo de instâncias como 2 e o Número máximo de instâncias como 2 ou mais.

10. Para criar o novo grupo de instâncias, clique em Criar.

gcloud

1. Crie o grupo gerenciado de instâncias com base no modelo.

   gcloud compute instance-groups managed create lb-backend-example \
      --template=TEMPLATE_NAME --size=2 --zone=ZONE_A
   

Terraform

Para criar o grupo gerenciado de instâncias, use o recurso google_compute_instance_group_manager.

resource "google_compute_instance_group_manager" "default" {
  name = "lb-backend-example"
  zone = "us-east1-b"
  named_port {
    name = "http"
    port = 80
  }
  version {
    instance_template = google_compute_instance_template.default.id
    name              = "primary"
  }
  base_instance_name = "vm"
  target_size        = 2
}

Para saber como aplicar ou remover uma configuração do Terraform, consulte Comandos básicos do Terraform.

Console

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

   Acesse grupo de instâncias

2. Clique em lb-backend-example.

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

4. Na seção Mapeamento de porta, clique em Adicionar porta.

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

5. Clique em Salvar.

gcloud

Use o comando gcloud compute instance-groups set-named-ports.

gcloud compute instance-groups set-named-ports lb-backend-example \
    --named-ports http:80 \
    --zone ZONE_A

Terraform

O atributo named_port está incluído na amostra de grupo de instâncias gerenciadas.

Console

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

   Acessar as políticas de firewall

2. Clique em Criar regra de firewall para criar a regra.

3. Em Nome, insira fw-allow-health-check.

4. Selecione uma rede.

5. Em Destinos, selecione Tags de destino especificadas.

6. Preencha o campo Tags de destino com allow-health-check.

7. Defina Filtro de origem como Intervalos IPv4.

8. Defina Intervalos IPv4 de origem como 130.211.0.0/22 e 35.191.0.0/16.

9. Em Protocolos e portas, selecione Portas e protocolos especificados.

10. Marque a caixa de seleção TCP e digite 80 para os números de porta.

11. Clique em Criar.

gcloud

gcloud compute firewall-rules create fw-allow-health-check \
    --network=NETWORK \
    --action=allow \
    --direction=ingress \
    --source-ranges=130.211.0.0/22,35.191.0.0/16 \
    --target-tags=allow-health-check \
    --rules=tcp:80

Terraform

Para criar a regra de firewall, use o recurso google_compute_firewall.

resource "google_compute_firewall" "default" {
  name          = "fw-allow-health-check"
  direction     = "INGRESS"
  network       = "global/networks/default"
  priority      = 1000
  source_ranges = ["130.211.0.0/22", "35.191.0.0/16"]
  target_tags   = ["allow-health-check"]
  allow {
    ports    = ["80"]
    protocol = "tcp"
  }
}

Para saber como aplicar ou remover uma configuração do Terraform, consulte Comandos básicos do Terraform.

Console

1. No console do Google Cloud, acesse a página Endereços IP externos.

   Acessar Endereços IP externos

2. Para reservar um endereço IPv4, clique em Reservar endereço IP estático externo.

3. Em Nome, insira lb-ipv4-1.

4. Defina o Nível de serviço de rede como Premium.

5. Defina Versão IP como IPv4.

6. Configure Tipo como Global.

7. Clique em Reservar.

gcloud

gcloud compute addresses create lb-ipv4-1 \
    --ip-version=IPV4 \
    --network-tier=PREMIUM \
    --global

Anote o endereço IPv4 que foi reservado:

gcloud compute addresses describe lb-ipv4-1 \
    --format="get(address)" \
    --global

Terraform

Para reservar o endereço IP, use o recurso google_compute_global_address.

resource "google_compute_global_address" "default" {
  name       = "lb-ipv4-1"
  ip_version = "IPV4"
}

Para saber como aplicar ou remover uma configuração do Terraform, consulte Comandos básicos do Terraform.

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 Voltado ao público (externo) e clique em Próxima.
5. Em Implantação global ou de região única, selecione Melhor para cargas de trabalho globais e clique em Próxima.
6. Em Geração do balanceador de carga, selecione Balanceador de carga de aplicativo clássico e clique em Próxima.
7. Clique em Configurar.

Configuração básica

No campo Nome do balanceador de carga, insira algo como web-map-https ou web-map-http.

Configuração de front-end

1. Clique em Configuração de front-end.
2. Defina Protocolo como HTTPS.
3. Selecione IPv4 para o tráfego IPv4. Defina o endereço IP como lb-ipv4-1, que você criou antes.
4. Defina a Porta como 443.
5. Clique em Certificado e selecione seu certificado SSL principal.
6. Opcional: crie uma política de SSL:
   1. Na lista Política de SSL, selecione Criar uma política.
   2. Defina o nome da política de SSL como my-ssl-policy.
   3. Em Versão mínima de TLS, selecione TLS 1.0.
   4. Em Perfil, selecione Moderno. Serão exibidos Recursos ativados e Recursos desativados.
   5. Clique em Salvar.
   Se você não criou nenhuma política de SSL, uma política padrão de SSL do GCP será aplicada.
7. Opcional: marque a caixa de seleção Ativar redirecionamento HTTP para HTTPS para ativar redirecionamentos.

   Marcar essa caixa de seleção cria um balanceador de carga HTTP parcial extra que usa o mesmo endereço IP que o balanceador de carga HTTPS e redireciona as solicitações HTTP recebidas para o front-end HTTPS do balanceador de carga.

   Essa caixa de seleção poderá ser marcada somente quando o protocolo HTTPS estiver selecionado e um endereço IP reservado for utilizado.

8. Clique em Concluído.

Configuração de back-end

1. Clique em Configuração de back-end.
2. Em Criar ou selecionar serviços e buckets de back-end, clique em Serviços de back-end > Criar um serviço de back-end.
3. Adicione um nome para o serviço de back-end, como web-backend-service.
4. Em Protocolo, selecione HTTP.
5. Em Porta nomeada, insira http.
6. Em Back-ends > Novo back-end > Grupo de instâncias, selecione o grupo de instâncias, lb-backend-example.
7. Em Número da porta, insira 80.
8. Mantenha as outras configurações padrão.
9. Em Verificação de integridade, selecione Criar uma verificação de integridade e adicione um nome para ela, como http-basic-check.
10. Defina o protocolo como HTTP e clique em Salvar.

11. Opcional: configure uma política de segurança de back-end padrão. A política de segurança padrão limita o tráfego acima de um limite configurado pelo usuário. Para mais informações sobre as políticas de segurança padrão, consulte a Visão geral de limitação de taxa.

    1. Para desativar a política de segurança padrão do Google Cloud Armor, selecione None no menu da lista de políticas de segurança do back-end.
    2. Na seção Segurança, selecione Política de segurança padrão.
    3. No campo Nome da política, aceite o nome gerado automaticamente ou insira um nome para a política de segurança.
    4. No campo Contagem de solicitações, aceite a contagem de solicitações padrão ou insira um número inteiro entre 1 e 10,000.
    5. No campo Intervalo, selecione um intervalo.
    6. No campo Aplicar na chave, escolha um dos seguintes valores: Todos, Endereço IP ou Endereço IP X-Forwarded-For. Para mais informações sobre essas opções, consulte Identificar clientes para a limitação de taxa.
12. Selecione Ativar Cloud CDN.
13. Opcional: modifique as configurações do modo de cache e TTL.
14. Mantenha as outras configurações padrão.
15. Clique em Criar.

Regras de host e caminho

Em Regras de host e caminho, mantenha as configurações padrão.

Revisar e finalizar

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

gcloud

1. Crie uma verificação de integridade.

    gcloud compute health-checks create http http-basic-check \
        --port 80
    

2. Crie um serviço de back-end.

   gcloud compute backend-services create web-backend-service \
       --load-balancing-scheme=EXTERNAL \
       --protocol=HTTP \
       --port-name=http \
       --health-checks=http-basic-check \
       --global
   

3. Adicione seu grupo de instâncias como back-end do serviço de back-end.

   gcloud beta compute backend-services add-backend web-backend-service \
     --instance-group=lb-backend-example \
     --instance-group-zone=ZONE_A \
     --global
   

4. No caso de HTTP, crie um mapa de URL a fim de encaminhar as solicitações recebidas para o serviço de back-end padrão.

   gcloud beta compute url-maps create web-map-http \
     --default-service web-backend-service
   

5. Para HTTPS, crie um mapa de URLs para encaminhar as solicitações recebidas para o serviço de back-end padrão.

   gcloud beta compute url-maps create web-map-https \
     --default-service web-backend-service
   

Configurar um front-end HTTPS

Pule esta seção para balanceadores de carga HTTP.

1. Para HTTPS, crie o recurso de certificado SSL global, conforme mostrado nas seções a seguir:
• Como criar um recurso de certificado SSL gerenciado pelo Google
• Como criar um recurso de certificado SSL autogerenciado

2. No caso de HTTPS, crie um proxy HTTPS de destino a fim de encaminhar solicitações ao mapa de URL. O proxy é a parte do balanceador de carga HTTPS que armazena o certificado SSL associado a ele. Portanto, nesta etapa, também é possível carregar o certificado.

   gcloud compute target-https-proxies create https-lb-proxy \
     --url-map=web-map-https \
     --ssl-certificates=www-ssl-cert
   

3. No caso de HTTPS, crie uma regra de encaminhamento global a fim de encaminhar as solicitações recebidas ao o proxy.

   gcloud compute forwarding-rules create https-content-rule \
     --load-balancing-scheme=EXTERNAL \
     --network-tier=PREMIUM \
     --address=lb-ipv4-1 \
     --global \
     --target-https-proxy=https-lb-proxy \
     --ports=443
   

4. Opcional: para HTTPS, crie uma política de SSL global e anexe-a ao proxy HTTPS.
   Para criar uma política de SSL global:

   gcloud compute ssl-policies create my-ssl-policy \
     --profile MODERN \
     --min-tls-version 1.0
   

   Para anexar a política de SSL ao proxy HTTPS de destino global:

   gcloud compute target-https-proxies update https-lb-proxy \
     --ssl-policy my-ssl-policy
   

Configurar um front-end HTTP

Pule esta seção para balanceadores de carga HTTPS.

1. Para HTTP, crie um proxy HTTP de destino para encaminhar solicitações ao mapa de URLs.

   gcloud compute target-http-proxies create http-lb-proxy \
     --url-map=web-map-http
   

2. No caso de HTTP, crie uma regra de encaminhamento global a fim de encaminhar as solicitações recebidas ao proxy.

   gcloud compute forwarding-rules create http-content-rule \
     --load-balancing-scheme=EXTERNAL \
     --address=lb-ipv4-1 \
     --global \
     --target-http-proxy=http-lb-proxy \
     --ports=80
   

Terraform

1. Para criar a verificação de integridade, use o recurso google_compute_health_check.

   resource "google_compute_health_check" "default" {
     name               = "http-basic-check"
     check_interval_sec = 5
     healthy_threshold  = 2
     http_health_check {
       port               = 80
       port_specification = "USE_FIXED_PORT"
       proxy_header       = "NONE"
       request_path       = "/"
     }
     timeout_sec         = 5
     unhealthy_threshold = 2
   }

2. Para criar o serviço de back-end, use o recurso google_compute_backend_service.

   Este exemplo usa load_balancing_scheme="EXTERNAL_MANAGED", que configura um balanceador de carga de aplicativo externo global com o recurso de gerenciamento de tráfego avançado. Para criar um balanceador de carga de aplicativo clássico, altere load_balancing_scheme para EXTERNAL antes de executar o script.

   resource "google_compute_backend_service" "default" {
     name                            = "web-backend-service"
     connection_draining_timeout_sec = 0
     health_checks                   = [google_compute_health_check.default.id]
     load_balancing_scheme           = "EXTERNAL_MANAGED"
     port_name                       = "http"
     protocol                        = "HTTP"
     session_affinity                = "NONE"
     timeout_sec                     = 30
     backend {
       group           = google_compute_instance_group_manager.default.instance_group
       balancing_mode  = "UTILIZATION"
       capacity_scaler = 1.0
     }
   }

3. Para criar o mapa de URL, use o recurso google_compute_url_map.

   resource "google_compute_url_map" "default" {
     name            = "web-map-http"
     default_service = google_compute_backend_service.default.id
   }

4. Para criar o proxy HTTP de destino, use o recurso google_compute_target_http_proxy.

   resource "google_compute_target_http_proxy" "default" {
     name    = "http-lb-proxy"
     url_map = google_compute_url_map.default.id
   }

5. Para criar a regra de encaminhamento, use o recurso google_compute_global_forwarding_rule.

   Este exemplo usa load_balancing_scheme="EXTERNAL_MANAGED", que configura um balanceador de carga de aplicativo externo global com o recurso de gerenciamento de tráfego avançado. Para criar um balanceador de carga de aplicativo clássico, altere load_balancing_scheme para EXTERNAL antes de executar o script.

   resource "google_compute_global_forwarding_rule" "default" {
     name                  = "http-content-rule"
     ip_protocol           = "TCP"
     load_balancing_scheme = "EXTERNAL_MANAGED"
     port_range            = "80-80"
     target                = google_compute_target_http_proxy.default.id
     ip_address            = google_compute_global_address.default.id
   }

Para saber como aplicar ou remover uma configuração do Terraform, consulte Comandos básicos do Terraform.

Console

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

   Acessar o "Balanceamento de carga"

2. Clique no balanceador de carga que você acabou de criar.

3. Na seção Back-end, confirme se as VMs estão íntegras. A coluna Integridade deve estar preenchida, indicando que ambas as VMs estão íntegras (2/2). Caso contrário, primeiro tente recarregar a página. Pode levar alguns instantes para o Console do Google Cloud indicar que as VMs estão íntegras. Se os back-ends não aparecerem íntegros depois de alguns minutos, revise a configuração do firewall e a tag de rede atribuída às suas VMs de back-end.

4. No caso de HTTPS, se você usa um certificado gerenciado pelo Google, confirme se o status do recurso do certificado é "ATIVO". Para mais informações, consulte Status do recurso de certificado SSL gerenciado pelo Google.
5. Depois que o Console do Google Cloud mostrar que as instâncias de back-end estão íntegras, teste o balanceador de carga com um navegador da Web acessando https://IP_ADDRESS (ou http://IP_ADDRESS). Substitua IP_ADDRESS pelo endereço IP do balanceador de carga.
6. Caso você tenha usado um certificado autoassinado durante o teste de HTTPS, o navegador exibirá um aviso. É preciso conceder permissão explícita para que seu navegador aceite um certificado autoassinado.
7. Seu navegador deve renderizar uma página que mostre o nome da instância que a exibiu e a zona (por exemplo, Page served from: lb-backend-example-xxxx). Caso seu navegador não renderize essa página, revise as configuração mostradas neste guia.

gcloud

gcloud compute addresses describe lb-ipv4-1 \
   --format="get(address)" \
   --global

Após alguns minutos, é possível testar a configuração executando o seguinte comando curl.

curl http://IP_ADDRESS

-OU-

curl https://HOSTNAME

Console

Desative o Cloud CDN para um único serviço de back-end

1. No console do Google Cloud, acesse a página do Cloud CDN.

   Acessar o Cloud CDN

2. No lado direito da linha de origem, clique em Menu more_vert e selecione editEditar.

3. Desmarque as caixas de seleção dos serviços de back-end que você não quer mais que usem o Cloud CDN.

4. Clique em Atualizar.

Remova o Cloud CDN de todos os serviços de back-end de uma origem

1. No console do Google Cloud, acesse a página do Cloud CDN.

   Acessar o Cloud CDN

2. No lado direito da linha de origem, clique em Menu more_vert e selecione Remover.

3. Para confirmar, clique em Remover.

gcloud

gcloud compute backend-services update BACKEND_SERVICE_NAME \
    --no-enable-cdn