Configurar um balanceador de carga de aplicativo externo global com conectividade híbrida

Esta página mostra como implantar um balanceador de carga de aplicativo externo global para balancear a carga do tráfego para endpoints de rede que estão no local ou em outras nuvens públicas e podem ser acessados pela conectividade híbrida.

Depois de concluir essas tarefas, você pode explorar a ativação de serviços adicionais (como Cloud CDN e Google Cloud Armor) e recursos avançados de gerenciamento de tráfego.

Se você ainda não tiver feito isso, leia a Visão geral dos NEGs de conectividade híbridos para entender os requisitos de rede para configurar o balanceamento de carga híbrido.

Visão geral da configuração

O exemplo nesta página configura a seguinte implantação de amostra:

Exemplo de balanceador de carga de aplicativo externo para conectividade híbrida.
Exemplo de balanceador de carga de aplicativo para conectividade híbrida (clique para ampliar).

Você deve configurar a conectividade híbrida antes de tentar configurar uma implantação de balanceamento de carga híbrida. Este documento não inclui a configuração de conectividade híbrida.

Dependendo do produto de conectividade híbrida escolhido (Cloud VPN ou Cloud Interconnect (dedicada ou por parceiro)), use a documentação relevante do produto para fazer essa configuração).

Permissões

Para configurar o balanceamento de carga híbrido, você precisa ter as seguintes permissões:

  • No Google Cloud

  • No local ou em outro ambiente de nuvem que não seja o Google Cloud

    • Permissões para configurar endpoints de rede que autorizam os serviços no local ou em outros ambientes de nuvem a serem acessados pelo Google Cloud com uma combinação de IP:Port. Para mais informações, entre em contato com o administrador de rede do ambiente.
    • Permissões para criar regras de firewall no seu ambiente local ou em outros ambientes de nuvem para que as sondagens de verificação de integridade do Google alcancem os endpoints.

Além disso, para concluir as instruções nesta página, você precisa criar um NEG híbrido de conectividade, um balanceador de carga e NEGs zonais (e os respectivos endpoints) para servir como back-ends baseados no Google Cloud para o balanceador de carga.

É necessário ser proprietário ou editor de um projeto ou ter os seguintes papéis de IAM do Compute Engine.

Tarefa Papel necessário
Criar redes, sub-redes e componentes do balanceador de carga Administrador de rede do Compute (roles/compute.networkAdmin)
Adicionar e remover regras de firewall Administrador de segurança do Compute (roles/compute.securityAdmin)
Criar instâncias Administrador da instância do Compute (roles/compute.instanceAdmin)

Estabelecer conectividade híbrida

O Google Cloud e os ambientes locais ou em nuvem precisam ser conectados por uma conectividade híbrida usando anexos da VLAN do Cloud Interconnect ou túneis do Cloud VPN com o Cloud Router. Recomendamos que você use uma conexão de alta disponibilidade.

Um Cloud Router ativado com roteamento dinâmico global aprende sobre o endpoint específico usando o Border Gateway Protocol (BGP) e o programa na sua rede VPC do Google Cloud. O roteamento dinâmico regional não é compatível. Rotas estáticas também não são compatíveis.

A rede VPC que você usa para configurar o Cloud Interconnect ou o Cloud VPN é a mesma rede usada para configurar a implantação do balanceamento de carga híbrido. Verifique se os intervalos de CIDR da sub-rede da rede VPC não entram em conflito com os intervalos CIDR remotos. Quando os endereços IP se sobrepõem, as rotas de sub-rede são priorizadas em relação à conectividade remota.

Para receber instruções, consulte a seguinte documentação:

Configurar o ambiente fora do Google Cloud

Execute as etapas a seguir para configurar seu ambiente local ou outro ambiente de nuvem para balanceamento de carga híbrido:

  • Configure endpoints da rede para expor serviços locais ao Google Cloud (IP:Port).
  • Configure regras de firewall no seu ambiente local ou em outro ambiente de nuvem
  • Configurar o Cloud Router para divulgar determinadas rotas necessárias para seu ambiente particular.

Configurar endpoints da rede

Depois de configurar a conectividade híbrida, você configura um ou mais endpoints de rede no seu ambiente local ou em outros ambientes de nuvem acessíveis pelo Cloud Interconnect ou pelo Cloud VPN usando uma combinação de IP:port. Essa combinação de IP:port é configurada como um ou mais endpoints para o NEG de conectividade híbrida criado no Google Cloud posteriormente neste processo.

Se houver vários caminhos para o endpoint do IP, o roteamento seguirá o comportamento descrito na Visão geral do Cloud Router.

Configurar regras de firewall

As regras de firewall a seguir precisam ser criadas no ambiente local ou em outro ambiente de nuvem:

  • Crie uma regra de firewall de permissão de entrada a fim de autorizar o tráfego das sondagens de verificação de integridade do Google para os endpoints. Os intervalos de endereços IP de origem a serem permitidos são 35.191.0.0/16 e 130.211.0.0/22. Para mais informações, consulte Regras de firewall e intervalos de IP de sondagem.

Configure o Cloud Router para divulgar os seguintes intervalos de IP personalizados no ambiente local ou em outro ambiente de nuvem:

  • Os intervalos usados pelas sondagens de verificação de integridade do Google: 35.191.0.0/16 e 130.211.0.0/22.

Configurar o ambiente do Google Cloud

Para as etapas a seguir, certifique-se de usar a mesma rede VPC (chamada NETWORK neste procedimento) usada para configurar a conectividade híbrida entre os ambientes.

Criar a sub-rede para os back-ends

Essa sub-rede é usada para criar os back-ends NEG zonais do balanceador de carga, o front-end e o endereço IP interno.

Crie esse sub-rede na rede NETWORK que foi usada para configurar a conectividade híbrida entre os ambientes.

Console

Para oferecer suporte a tráfego IPv4 e IPv6, siga estas etapas:

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

    Acessar redes VPC

  2. Acesse a rede usada para configurar a conectividade híbrida entre os ambientes.

    • Clique em Editar.
    • Em Modo de criação da sub-rede, escolha Personalizado.
    • Clique em Salvar.

  3. Opcional: se você quiser configurar intervalos de endereços de IPv6 internos em sub-redes nesta rede, siga estas etapas:

    1. Em Intervalo de IPv6 interno de ULA da rede VPC, selecione Ativado.

    2. Em Alocar intervalo de IPv6 interno, selecione Automático ou Manualmente.

      Se você selecionar Manualmente, insira um intervalo /48 no intervalo fd20::/20. Se o intervalo estiver em uso, você precisará fornecer um intervalo diferente.

  4. Na guia Sub-redes, clique em vpc-subnet:

  5. No painel Adicionar uma sub-rede, configure os seguintes campos:

    1. No campo Nome, digite um nome para a sub-rede.
    2. No campo Região, selecione uma região.
    3. No campo Intervalo de endereços IP, insira um intervalo de endereços IP.
    4. Em Tipo de pilha de IP, selecione IPv4 e IPv6 (pilha dupla).
    5. No campo Tipo de acesso IPv6, selecione Externo.
    6. Clique em Adicionar.

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

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

    Acessar redes VPC

  2. Acesse a rede usada para configurar a conectividade híbrida entre os ambientes.

    • Clique em Editar.
    • Em Modo de criação da sub-rede, escolha Personalizado.
    • Clique em Salvar.

  3. Na guia Sub-redes, clique em vpc-subnet:

  4. No painel Adicionar uma sub-rede, insira as seguintes informações:

    • No campo Nome, digite um nome para a sub-rede.
    • No campo Região, selecione uma região.
    • No campo Intervalo de endereços IP, insira um intervalo de endereços IP.
    • No campo Tipo de pilha de IP, selecione IPv4 (pilha única).
    • Clique em Adicionar.

gcloud

Crie uma sub-rede na rede NETWORK que foi usada para configurar a conectividade híbrida entre os ambientes.

Para tráfego IPv4 e IPv6, use o seguinte comando:

gcloud compute networks update NETWORK \
    [ --enable-ula-internal-ipv6 [ --internal-ipv6-range=ULA_IPV6_RANGE ]] \
    --switch-to-custom-subnet-mode

gcloud compute networks subnets create LB_SUBNET_NAME \
    --network=NETWORK \
    --range=LB_SUBNET_RANGE \
    --region=REGION \
    --stack-type=IPV4_IPV6 \
    --ipv6-access-type=EXTERNAL

Para o tráfego IPv4, use o seguinte comando:

gcloud compute networks subnets create LB_SUBNET_NAME \
    --network=NETWORK \
    --range=LB_SUBNET_RANGE \
    --region=REGION

Substitua:

  • NETWORK: um nome para a rede VPC.

  • LB_SUBNET_NAME: um nome para a sub-rede.

  • REGION: o nome da região.

  • ULA_IPV6_RANGE: um prefixo /48 de dentro do intervalo fd20::/20 usado pelo Google para intervalos de sub-rede IPv6 interno. Se você não usar a sinalização --internal-ipv6-range, o Google selecionará um prefixo /48 para a rede.

Criar regra de firewall

Neste exemplo, você criará a regra de firewall:

  • fw-allow-health-check: uma regra de entrada, aplicável às instâncias do Google Cloud submetidas a balanceamento de carga, que permite o tráfego do balanceador de carga e dos sistemas de verificação de integridade do Google Cloud (130.211.0.0/22 e 35.191.0.0/16). Este exemplo usa a tag de destino allow-health-check para identificar as VMs de back-end às quais ela deve ser aplicada.

Console

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

    Acesse as políticas de firewall

  2. Clique em Criar regra de firewall.

    1. Informe um Nome de fw-allow-health-check.
    2. Na seção Rede, selecione NETWORK.
    3. Em Destinos, selecione Tags de destino especificadas.
    4. Preencha o campo Tags de destino com allow-health-check.
    5. Defina Filtro de origem como Intervalos IPv4.
    6. Defina Intervalos IPv4 de origem como 130.211.0.0/22 e 35.191.0.0/16.
    7. Em Protocolos e portas, selecione Portas e protocolos especificados.
    8. Marque a caixa de seleção ao lado de TCP e digite os números da porta, 80.

  3. Clique em Criar.

  4. Para permitir o tráfego de sub-rede IPv6, clique novamente em Criar regra de firewall e insira as seguintes informações:

    1. Nome: fw-allow-lb-access-ipv6
    2. Rede: NETWORK
    3. Prioridade: 1000
    4. Direção do tráfego: entrada
    5. Destinos: tags de destino especificadas
    6. No campo Tags de destino, insira allow-health-check-ipv6.
    7. Filtro de origem: intervalos IPv6
    8. Intervalos IPv6 de origem: 2600:2d00:1:b029::/64,2600:2d00:1:1::/64
    9. Protocolos e portas: permitir todos

  5. Clique em Criar.

gcloud

  1. Crie a regra fw-allow-health-check-and-proxy para permitir que o balanceador de carga e as verificações de integridade do Google Cloud se comuniquem com instâncias de back-end na porta TCP 80.

    Substitua NETWORK pelo nome da rede VPC usada para configurar a conectividade híbrida.

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

  2. Crie a regra fw-allow-health-check-ipv6 para permitir verificações de integridade do IPv6 do Google Cloud.

    gcloud compute firewall-rules create fw-allow-health-check-ipv6 \
   --network=NETWORK \
   --action=allow \
   --direction=ingress \
   --target-tags=allow-health-check-ipv6 \
   --source-ranges=2600:2d00:1:b029::/64,2600:2d00:1:1::/64 \
   --rules=tcp,udp,icmp

Configurar o NEG zonal

Para back-ends baseados no Google Cloud, recomendamos que você configure vários NEGs zonais na mesma região em que configurou a conectividade híbrida.

Os NEGs zonais com um ou mais endpoints do tipo GCE_VM_IP_PORT são compatíveis com a pilha dupla.

Neste exemplo, configuramos um NEG zonal (com endpoints do tipo GCE_VM_IP_PORT) na região REGION. Primeiro, crie as VMs na zona GCP_NEG_ZONE. Em seguida, crie um NEG zonal no mesmo GCP_NEG_ZONE e adicione os endpoints de rede das VMs ao NEG.

Criar VMs

Console

  1. Acesse a página "Instâncias de VMs" no Console do Google Cloud.
    Acessar instâncias de VM

  2. Clique em Criar instância.

  3. Defina o Nome como vm-a1.

  4. Em Região, escolha REGION.

  5. Em Zona, escolha GCP_NEG_ZONE.

  6. Na seção Disco de inicialização, verifique se Debian GNU/Linux 12 (bookworm) está selecionado para as opções de disco de inicialização. Clique em Escolher para alterar a imagem se necessário.

  7. Clique em Opções avançadas e faça as seguintes alterações:

    • Clique em Rede e adicione as seguintes tags de rede: allow-health-check.
    • Clique em Editar em Interfaces de rede, faça as seguintes alterações e clique em Concluído:
      • Rede: NETWORK
      • Sub-rede: LB_SUBNET_NAME
      • Tipo de pilha de IP: IPv4 e IPv6 (pilha dupla)

    • Clique em Gerenciamento. No campo Script de inicialização, copie e cole o conteúdo do script a seguir, que é o mesmo para as quatro VMs:

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

  9. Repita as etapas a seguir para criar uma segunda VM usando a combinação de nome e zona a seguir:

    • Nome: vm-a2, zona: GCP_NEG_ZONE

gcloud

Crie as VMs executando o comando a seguir duas vezes, usando essas combinações para o nome da VM e a zona dela. O conteúdo do script é idêntico para as duas VMs.

  • VM_NAME de vm-a1 e qualquer zona GCP_NEG_ZONE que você preferir.

  • VM_NAME de vm-a2 e a mesma zona GCP_NEG_ZONE

    Para oferecer suporte ao tráfego IPv4 e IPv6, execute o seguinte comando:

    gcloud compute instances create VM_NAME \
    --zone=GCP_NEG_ZONE \
    --image-family=debian-10 \
    --image-project=debian-cloud \
    --tags=allow-health-check,allow-health-check-ipv6 \
    --ipv6-network-tier=PREMIUM \
    --stack-type=IPv4_IPv6 \
    --subnet=LB_SUBNET_NAME \
    --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'

Criar o NEG zonal

Console

Para criar um grupo de endpoints de rede zonal:

  1. Acesse a página "Grupos de endpoints da rede" no Google Cloud Console.
    Acessar a página "Grupos de endpoints de rede"
  2. Clique em Criar grupo de endpoints de rede.
  3. Insira um Nome para o NEG zonal. Chamado de GCP_NEG_NAME neste procedimento.
  4. Selecione o Tipo de grupo de endpoints da rede: Grupo de endpoints da rede (Zonal).
  5. Selecione a Rede: NETWORK
  6. Selecione a Sub-rede: LB_SUBNET_NAME
  7. Selecione a Zona: GCP_NEG_ZONE
  8. Insira a Porta padrão: 80.
  9. Clique em Criar.

Adicione endpoints ao NEG zonal:

  1. Acesse a página "Grupos de endpoints da rede" no Google Cloud Console.
    Acessar os grupos de endpoints de rede
  2. Clique no Nome do grupo de endpoints da rede criado na etapa anterior (GCP_NEG_NAME). Você verá a página Detalhes do grupo de endpoints da rede.
  3. Na seção Endpoints da rede neste grupo, clique em Adicionar endpoint da rede. Você verá a página Adicionar endpoint de rede.
  4. Selecione uma instância de VM para adicionar endereços IP internos como endpoints da rede. Na seção Interface de rede, são exibidos o nome, a zona e a sub-rede da VM.
  5. No campo Endereço IPv4, insira o endereço IPv4 do novo endpoint da rede.
  6. No campo Endereço IPv6, insira o endereço IPv6 do novo endpoint da rede.
  7. Selecione o Tipo de porta.
    1. Se você selecionar Padrão, o endpoint usará a porta padrão 80 para todos os endpoints no grupo de endpoints da rede. Isso é suficiente para nosso exemplo, porque o servidor Apache está atendendo solicitações na porta 80.
    2. Se você selecionar Personalizado, insira o Número da porta do endpoint que será usado.
  8. Para adicionar mais endpoints, clique em Adicionar endpoint da rede e repita as etapas anteriores.
  9. Depois de adicionar todos os endpoints, clique em Criar.

gcloud

  1. Crie um NEG zonal (com endpoints GCE_VM_IP_PORT) usando o comando gcloud compute network-endpoint-groups create:

    gcloud compute network-endpoint-groups create GCP_NEG_NAME \
    --network-endpoint-type=GCE_VM_IP_PORT \
    --zone=GCP_NEG_ZONE \
    --network=NETWORK \
    --subnet=LB_SUBNET_NAME

    É possível especificar um --default-port ao criar o NEG ou especificar um número de porta para cada endpoint. conforme mostrado na próxima etapa.

  2. Adicione endpoints de pilha dupla a GCP_NEG_NAME. 

    gcloud compute network-endpoint-groups update GCP_NEG_NAME \
   --zone=GCP_NEG_ZONE \
   --add-endpoint='instance=vm-a1,ip=IPv4_ADDRESS, \
                   ipv6=IPv6_ADDRESS,port=80' \
   --add-endpoint='instance=vm-a2,ip=IPv4_ADDRESS, \
                   ipv6=IPv6_ADDRESS,port=80'

Configurar o NEG de conectividade híbrida

Ao criar o NEG, use uma ZONE que minimize a distância geográfica entre o Google Cloud e o ambiente local ou de outra nuvem. Por exemplo, se você estiver hospedando um serviço em um ambiente local em Frankfurt, na Alemanha, será possível especificar a zona europe-west3-a do Google Cloud ao criar o NEG.

Além disso, se você estiver usando o Cloud Interconnect, a ZONE usada para criar o NEG precisa estar na mesma região em que o anexo da VLAN do Cloud Interconnect de conectividade híbrida foi configurado.

Para ver as regiões e zonas disponíveis, consulte a documentação do Compute Engine: regiões e zonas disponíveis.

Console

Para criar um grupo de endpoints de rede de conectividade híbrida:

  1. Acesse a página "Grupos de endpoints da rede" no Google Cloud Console.
    Acessar grupos de endpoints da rede
  2. Clique em Criar grupo de endpoints de rede.
  3. Insira um Nome para o NEG híbrido. Chamado de ON_PREM_NEG_NAME neste procedimento.
  4. Selecione o Tipo de grupo de endpoints da rede: grupo de endpoints da rede de conectividade híbrida (zonal).
  5. Selecione a Rede: NETWORK
  6. Selecione a Sub-rede: LB_SUBNET_NAME
  7. Selecione a Zona: ON_PREM_NEG_ZONE
  8. Insira a Porta padrão.
  9. Clique em Criar.

Adicione endpoints ao NEG de conectividade híbrida:

  1. Acesse a página "Grupos de endpoints da rede" no Google Cloud Console.
    Acessar a página "Grupos de endpoints de rede"
  2. Clique no Nome do grupo de endpoints da rede criado na etapa anterior (ON_PREM_NEG_NAME). Você verá a página Detalhes do grupo de endpoints da rede.
  3. Na seção Endpoints da rede neste grupo, clique em Adicionar endpoint da rede. Você verá a página Adicionar endpoint de rede.
  4. Insira o endereço IP do novo endpoint da rede.
  5. Selecione o Tipo de porta.
    1. Se você selecionar Padrão, o endpoint usará a porta padrão para todos os endpoints no grupo de endpoints da rede.
    2. Se você selecionar Personalizado, insira um Número de porta diferente para ser usado pelo endpoint.
  6. Para adicionar mais endpoints, clique em Adicionar endpoint da rede e repita as etapas anteriores.
  7. Depois de adicionar todos os endpoints que não são do Google Cloud, clique em Criar.

gcloud

  1. Crie um NEG de conectividade híbrida usando o comando gcloud compute network-endpoint-groups create.

    gcloud compute network-endpoint-groups create ON_PREM_NEG_NAME \
    --network-endpoint-type=NON_GCP_PRIVATE_IP_PORT \
    --zone=ON_PREM_NEG_ZONE \
    --network=NETWORK

  2. Adicione o endpoint a on-prem-neg:

    gcloud compute network-endpoint-groups update ON_PREM_NEG_NAME \
    --zone=ON_PREM_NEG_ZONE \
    --add-endpoint="ip=ON_PREM_IP_ADDRESS_1,port=PORT_1" \
    --add-endpoint="ip=ON_PREM_IP_ADDRESS_2,port=PORT_2"

Use esse comando para adicionar os endpoints de rede que você configurou anteriormente no local ou no seu ambiente de nuvem. Repita --add-endpoint quantas vezes forem necessárias.

Repita essas etapas para criar vários NEGs híbridos se necessário.

Configurar o balanceador de carga

Console

gcloud

  1. Crie um endereço IP externo estático global para o qual os clientes externos enviarão tráfego. 
      gcloud compute addresses create LB_IP_ADDRESS_NAME \
      --network-tier=PREMIUM \
      --global
  2. Crie uma verificação de integridade para os back-ends. 
      gcloud compute health-checks create http HTTP_HEALTH_CHECK_NAME \
      --use-serving-port
  3. Crie um serviço de back-end. Adicione o NEG zonal e o NEG de conectividade híbrida como back-ends a esse serviço de back-end.
    4.   gcloud beta compute backend-services create BACKEND_SERVICE \
      --health-checks=HTTP_HEALTH_CHECK_NAME \
      --load-balancing-scheme=EXTERNAL_MANAGED \
      --ip-address-selection-policy=PREFER_IPV6 \
      --global
  4. Adicione o NEG zonal como back-end ao serviço de back-end: 
      gcloud beta compute backend-services add-backend BACKEND_SERVICE \
      --global \
      --balancing-mode=RATE \
      --max-rate-per-endpoint=MAX_REQUEST_RATE_PER_ENDPOINT \
      --network-endpoint-group=GCP_NEG_NAME \
      --network-endpoint-group-zone=GCP_NEG_ZONE
    Para ver detalhes de como configurar o modo de balanceamento, consulte a documentação da gcloud CLI sobre o parâmetro --max-rate-per-endpoint.
  5. Adicione o NEG híbrido como um back-end ao serviço de back-end: 
      gcloud compute backend-services add-backend BACKEND_SERVICE \
      --global \
      --balancing-mode=RATE \
      --max-rate-per-endpoint=MAX_REQUEST_RATE_PER_ENDPOINT \
      --network-endpoint-group=ON_PREM_NEG_NAME \
      --network-endpoint-group-zone=ON_PREM_NEG_ZONE
  6. Crie um mapa de URL para rotear solicitações recebidas para o serviço de back-end. 
      gcloud beta compute url-maps create URL_MAP_NAME \
      --default-service BACKEND_SERVICE
  7. Execute essa etapa somente se você quiser criar um balanceador de carga HTTPS. Ele não é necessário para balanceadores de carga HTTP.
    Para criar um balanceador de carga HTTPS, você precisa ter um recurso de certificado SSL para usar no proxy HTTPS. É possível criar um recurso de certificado SSL usando um certificado SSL gerenciado pelo Google ou um certificado SSL autogerenciado. O uso de certificados gerenciados pelo Google é recomendado porque o Google Cloud recebe, gerencia e renova esses certificados automaticamente.

    Para criar um certificado gerenciado pelo Google, você precisa ter um domínio. Se você não tiver um domínio, use um certificado SSL autoassinado para teste.

    Para criar um recurso de certificado SSL gerenciado pelo Google: 
    gcloud compute ssl-certificates create SSL_CERTIFICATE_NAME \
    --domains DOMAIN
    Para criar um recurso de certificado SSL autogerenciado: 
    gcloud compute ssl-certificates create SSL_CERTIFICATE_NAME \
    --certificate CRT_FILE_PATH \
    --private-key KEY_FILE_PATH
  8. Crie um proxy de destino HTTP(S) para encaminhar solicitações ao mapa de URLs.

    Para um balanceador de carga HTTP, crie um proxy de destino HTTP: 
    gcloud beta compute target-http-proxies create TARGET_HTTP_PROXY_NAME \
    --http-keep-alive-timeout-sec=HTTP_KEEP_ALIVE_TIMEOUT_SEC \
    --url-map=URL_MAP_NAME
    Para um balanceador de carga HTTPS, crie um proxy de destino HTTPS. O proxy é a parte do balanceador de carga onde é armazenado o certificado SSL para balanceamento de carga HTTPS. Portanto, nesta etapa, também é possível carregar o certificado. 
    gcloud beta compute target-https-proxies create TARGET_HTTPS_PROXY_NAME \
    --http-keep-alive-timeout-sec=HTTP_KEEP_ALIVE_TIMEOUT_SEC \
    --ssl-certificates=SSL_CERTIFICATE_NAME \
    --url-map=URL_MAP_NAME

    Substitua:

    • TARGET_HTTP_PROXY_NAME: o nome do proxy HTTP de destino.
    • TARGET_HTTPS_PROXY_NAME: o nome do proxy HTTPS de destino.
    • HTTP_KEEP_ALIVE_TIMEOUT_SEC: um campo opcional usado para especificar o tempo limite do sinal de atividade HTTP do cliente. O valor de tempo limite precisa ser de 5 a 1.200 segundos. O valor padrão é de 610 segundos.
    • SSL_CERTIFICATE_NAME: o nome do certificado SSL.
    • URL_MAP_NAME: o nome do mapa de URL.
  9. Crie uma regra de encaminhamento para encaminhar as solicitações recebidas para o proxy.

    Para um balanceador de carga HTTP: 
    gcloud beta compute forwarding-rules create HTTP_FORWARDING_RULE_NAME \
    --load-balancing-scheme=EXTERNAL_MANAGED \
    --network-tier=PREMIUM \
    --address=LB_IP_ADDRESS_NAME \
    --target-http-proxy=TARGET_HTTP_PROXY_NAME \
    --global \
    --ports=80
    Para um balanceador de carga HTTPS: 
    gcloud beta compute forwarding-rules create HTTPS_FORWARDING_RULE_NAME \
    --load-balancing-scheme=EXTERNAL_MANAGED \
    --network-tier=PREMIUM \
    --address=LB_IP_ADDRESS_NAME \
    --target-https-proxy=TARGET_HTTPS_PROXY_NAME \
    --global \
    --ports=443

Como conectar seu domínio ao balanceador de carga

Após a criação do balanceador de carga, anote o endereço IP associado a ele, por exemplo, 30.90.80.100. Para apontar seu domínio para o balanceador de carga, crie um registro A usando o serviço de registro de domínio. Se você adicionou vários domínios ao certificado SSL, adicione um registro A para cada um deles, todos apontando para o endereço IP do balanceador de carga. Por exemplo, para criar registros A para www.example.com e example.com, use o seguinte:

NAME                  TYPE     DATA
www                   A        30.90.80.100
@                     A        30.90.80.100

Se você usa o Cloud DNS como provedor de DNS, consulte Adicionar, modificar e excluir registros.

Como testar o balanceador de carga

Agora que você configurou o balanceador de carga, é possível começar a enviar tráfego para o endereço IP dele.

  1. Acesse a página Balanceamento de carga no Console do Google Cloud.
    Acessar a página "Balanceamento de carga"

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

  3. Anote o Endereço IP do balanceador de carga.

  4. Enviar tráfego ao balanceador de carga

    • Se você tiver criado um balanceador de carga HTTP, será possível testar seu balanceador de carga usando um navegador da Web acessando http://IP_ADDRESS. Substitua IP_ADDRESS pelo endereço IP do balanceador de carga. Você será direcionado para o serviço que expôs pelo endpoint.

    • Se você criou um balanceador de carga HTTPS, poderá testar o balanceador de carga usando curl da seguinte maneira. Substitua IP_ADDRESS pelo endereço IP do balanceador de carga. Você será direcionado para o serviço que expôs pelo endpoint.

      curl -k https://IP_ADDRESS

      Se isso não funcionar e você estiver usando 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. Em seguida, teste o domínio que aponta para o endereço IP do balanceador de carga. Exemplo:

      curl -s https://test.example.com

  5. O teste dos endpoints que não são do Google Cloud depende do serviço que você expôs pelo endpoint NEG híbrido.

Configurações avançadas

Nesta seção, o exemplo é detalhado para fornecer outras opções de configuração. Todas as tarefas são opcionais. É possível realizá-las em qualquer ordem.

Atualizar tempo limite do sinal de atividade HTTP do cliente

O balanceador de carga criado nas etapas anteriores foi configurado com um valor padrão para o tempo limite do sinal de atividade HTTP do cliente. Para atualizar o tempo limite do sinal de atividade HTTP do cliente, use as instruções a seguir.

Console

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

    Acessar o "Balanceamento de carga"

  2. Clique no nome do balanceador de carga que você quer modificar.
  3. Clique em Editar.
  4. Clique em Configuração de front-end.
  5. Expanda Recursos avançados. Em Tempo limite de sinal de atividade HTTP, insira um valor de tempo limite entre 5 e 1.200 segundos.
  6. Clique em Atualizar.
  7. Para revisar as alterações, clique em Analisar e finalizar e depois em Atualizar.

gcloud

Para um balanceador de carga HTTP, atualize o proxy HTTP de destino usando o comando gcloud compute target-http-proxies update:

    gcloud compute target-http-proxies update TARGET_HTTP_PROXY_NAME \
        --http-keep-alive-timeout-sec=HTTP_KEEP_ALIVE_TIMEOUT_SEC \
        --global

Para um balanceador de carga HTTPS, atualize o proxy HTTPS de destino usando o comando gcloud compute target-https-proxies update:

    gcloud compute target-https-proxies update TARGET_HTTPS_PROXY_NAME \
        --http-keep-alive-timeout-sec=HTTP_KEEP_ALIVE_TIMEOUT_SEC \
        --global

Substitua:

  • TARGET_HTTP_PROXY_NAME: o nome do proxy HTTP de destino.
  • TARGET_HTTPS_PROXY_NAME: o nome do proxy HTTPS de destino.
  • HTTP_KEEP_ALIVE_TIMEOUT_SEC: o tempo limite do sinal de atividade HTTP de 5 a 1.200 segundos.

A seguir