Como configurar o balanceamento de carga TCP/UDP interno

Neste guia, você verá um exemplo dos princípios básicos do balanceamento de carga TCP/UDP interno do Google Cloud. Antes de seguir as instruções deste guia, familiarize-se com os itens abaixo:

Permissões

Para seguir este guia, você precisa criar instâncias e modificar uma rede em um projeto. É necessário ser proprietário ou editor de um projeto ou ter todos 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
Adicionar e remover regras de firewall Administrador de segurança
Criar instâncias Administrador da instância do Compute

Para mais informações, consulte estes guias:

Configuração

Neste guia, mostramos como configurar e testar um balanceador de carga TCP/UDP interno. Nas etapas desta seção, veja como configurar o seguinte:

  1. um exemplo de rede VPC com sub-redes personalizadas
  2. regras de firewall que permitem conexões de entrada para VMs de back-end
  3. quatro VMs de back-end:
    • duas VMs em um grupo de instâncias não gerenciadas na zona us-west1-a
    • Duas VMs em um grupo de instâncias não gerenciadas na zona us-west1-c
  4. Uma VM cliente para testar conexões
  5. os seguintes componentes do balanceador de carga TCP/UDP interno:
    • uma verificação de integridade do serviço de back-end
    • um serviço de back-end interno na região us-west1 para gerenciar a distribuição de conexões para os dois grupos de instâncias zonais
    • Uma regra de encaminhamento interna e um endereço IP interno para o front-end do balanceador de carga

A arquitetura deste exemplo é assim:

Configuração de exemplo de balanceamento de carga TCP/UDP interno (clique para ampliar)
Configuração de exemplo de balanceamento de carga TCP/UDP interno (clique para ampliar)

Como configurar rede, região e sub-rede

O exemplo de balanceador de carga TCP/UDP interno descrito nesta página é criado em uma rede VPC de modo personalizado chamada lb-network.

As VMs de back-end e os componentes do balanceador de carga deste exemplo estão localizados nesta região e sub-rede:

  • Região: us-west1
  • Sub-rede: lb-subnet, com intervalo de endereços IP principal 10.1.2.0/24

Para demonstrar o acesso global, este exemplo cria uma segunda VM de cliente de teste em uma região e uma sub-rede diferentes:

  • Região: europe-west1
  • Sub-rede: europe-subnet, com intervalo de endereços IP principal 10.3.4.0/24

Para criar o exemplo de rede e sub-rede, siga estas etapas.

Console

  1. Acesse a página "Redes VPC" no Console do Google Cloud.
    Acessar a página "Redes VPC"
  2. Clique em Criar rede VPC.
  3. Informe um Nome de lb-network.
  4. Na seção Sub-redes:
    • Defina o Modo de criação de sub-rede como Personalizado.
    • Na seção Nova sub-rede, insira as informações a seguir:
      • Nome: lb-subnet
      • Região: us-west1
      • Intervalo de endereços IP: 10.1.2.0/24
      • Clique em Done.
    • Clique em Adicionar sub-rede e insira as seguintes informações:
      • Name: europe-subnet
      • Região: europe-west1
      • Intervalo de endereços IP: 10.3.4.0/24
      • Clique em Concluído.
  5. Clique em Criar.

gcloud

  1. Crie a rede VPC personalizada:

    gcloud compute networks create lb-network --subnet-mode=custom
    
    1. Na rede lb-network, crie uma sub-rede para back-ends na região us-west1 e outra sub-rede para testar o acesso global na região europe-west1:
    gcloud compute networks subnets create lb-subnet \
        --network=lb-network \
        --range=10.1.2.0/24 \
        --region=us-west1
    
    gcloud compute networks subnets create europe-subnet \
        --network=lb-network \
        --range=10.3.4.0/24 \
        --region=europe-west1
    

api

Faça uma solicitação POST ao método networks.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks

{
  "routingConfig": {
    "routingMode": "REGIONAL"
  },
  "name": "lb-network",
  "autoCreateSubnetworks": false
}

Faça duas solicitações POST para o método subnetworks.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks

{
  "name": "lb-subnet",
  "network": "https://www.googleapis.com/compute/v1/projects/project-id/global/networks/lb-network",
  "ipCidrRange": "10.1.2.0/24",
  "privateIpGoogleAccess": false
}

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/europe-west1/subnetworks

{
  "name": "europe-subnet",
  "network": "https://www.googleapis.com/compute/v1/projects/project-id/global/networks/lb-network",
   "ipCidrRange": "10.3.4.0/24",
   "privateIpGoogleAccess": false
}

Como configurar regras de firewall

Este exemplo usa as seguintes regras de firewall:

  • fw-allow-lb-access: uma regra de entrada, aplicável a todos os destinos na rede VPC, permitindo tráfego de origens nos intervalos 10.1.2.0/24 e 10.3.4.0/24. Essa regra permite o tráfego de entrada de qualquer cliente localizado em uma das duas sub-redes. Posteriormente, é possível configurar e testar o acesso global.

  • fw-allow-ssh: uma regra de entrada, aplicável às instâncias submetidas a balanceamento de carga, que permite a conectividade SSH de entrada na porta TCP 22 proveniente de qualquer endereço. É possível escolher um intervalo de IP de origem mais restritivo para essa regra, por exemplo, especificando apenas os intervalos de IP do sistema que iniciará as sessões SSH. Neste exemplo, usamos a tag allow-ssh de destino para identificar as VMs a que isso se aplicará.

  • fw-allow-health-check: uma regra de entrada, aplicável às instâncias cuja carga está sendo balanceada, que permite o tráfego 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 instâncias às quais ela será aplicada.

Sem essas regras de firewall, a regra padrão de negação de entrada bloqueará o tráfego que chega para as instâncias de back-end.

Console

  1. Acesse a página "Firewall" no Console do Google Cloud.
    Acessar a página "Firewall"
  2. Clique em Criar regra de firewall e insira as seguintes informações para criar a regra que permite o tráfego de sub-rede:
    • Nome: fw-allow-lb-access
    • Rede: lb-network
    • Prioridade: 1000
    • Direção do tráfego: entrada
    • Ação se houver correspondência: permitir
    • Destinos: todas as instâncias na rede
    • Filtro de origem: IP ranges
    • Intervalos de IP de origem: 10.1.2.0/24 e 10.3.4.0/24
    • Protocolos e portas: permitir todos
  3. Clique em Criar
  4. Clique em Criar regra de firewall novamente para criar a regra que permite conexões SSH de entrada:
    • Nome: fw-allow-ssh
    • Rede: lb-network
    • Prioridade: 1000
    • Direção do tráfego: entrada
    • Ação se houver correspondência: permitir
    • Destinos: tags de destino especificadas
    • Tags de destino: allow-ssh
    • Filtro de origem: IP ranges
    • Intervalos de IP de origem: 0.0.0.0/0
    • Protocolos e portas: escolha Protocolos e portas especificados e digite: tcp:22
  5. Clique em Criar
  6. Clique em Criar regra de firewall pela terceira vez para criar uma regra que permita as verificações de integridade do Google Cloud:
    • Name: fw-allow-health-check
    • Rede: lb-network
    • Prioridade: 1000
    • Direção do tráfego: entrada
    • Ação se houver correspondência: permitir
    • Destinos: tags de destino especificadas
    • Tags de destino: allow-health-check
    • Filtro de origem: IP ranges
    • Intervalos de IP de origem: 130.211.0.0/22 e 35.191.0.0/16
    • Protocolos e portas: permitir todos
  7. Clique em Criar.

gcloud

  1. Crie a regra de firewall fw-allow-lb-access para permitir a comunicação a partir da sub-rede:

    gcloud compute firewall-rules create fw-allow-lb-access \
        --network=lb-network \
        --action=allow \
        --direction=ingress \
        --source-ranges=10.1.2.0/24,10.3.4.0/24 \
        --rules=tcp,udp,icmp
    
  2. Crie a regra de firewall fw-allow-ssh que permita a conectividade SSH para VMs com a tag de rede allow-ssh. Se você omitir source-ranges, o Google Cloud interpretará que a regra autoriza a conexão proveniente de qualquer origem.

    gcloud compute firewall-rules create fw-allow-ssh \
        --network=lb-network \
        --action=allow \
        --direction=ingress \
        --target-tags=allow-ssh \
        --rules=tcp:22
    
  3. Crie a regra fw-allow-health-check para permitir verificações de integridade do Google Cloud.

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

api

Crie a regra de firewall fw-allow-lb-access fazendo uma solicitação POST ao método firewalls.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/firewalls

{
  "name": "fw-allow-lb-access",
  "network": "https://www.googleapis.com/compute/v1/projects/project-id/global/networks/lb-network",
  "priority": 1000,
  "sourceRanges": [
    "10.1.2.0/24", "10.3.4.0/24"
  ],
  "allowed": [
    {
      "IPProtocol": "tcp"
    },
    {
      "IPProtocol": "udp"
    },
    {
      "IPProtocol": "icmp"
    }
  ],
  "direction": "INGRESS",
  "logConfig": {
    "enable": false
  },
  "disabled": false
}

Crie a regra de firewall fw-allow-ssh fazendo uma solicitação POST ao método firewalls.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/firewalls

{
  "name": "fw-allow-ssh",
       "network": "https://www.googleapis.com/compute/v1/projects/project-id/global/networks/lb-network",
  "priority": 1000,
  "sourceRanges": [
    "0.0.0.0/0"
  ],
  "targetTags": [
    "allow-ssh"
  ],
  "allowed": [
   {
     "IPProtocol": "tcp",
     "ports": [
       "22"
     ]
   }
  ],
 "direction": "INGRESS",
 "logConfig": {
   "enable": false
 },
 "disabled": false
}

Crie a regra de firewall fw-allow-health-check fazendo uma solicitação POST ao método firewalls.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/firewalls

{
  "name": "fw-allow-health-check",
  "network": "https://www.googleapis.com/compute/v1/projects/project-id/global/networks/lb-network",
  "priority": 1000,
  "sourceRanges": [
    "130.211.0.0/22",
    "35.191.0.0/16"
  ],
  "targetTags": [
    "allow-health-check"
  ],
  "allowed": [
    {
      "IPProtocol": "tcp"
    },
    {
      "IPProtocol": "udp"
    },
    {
      "IPProtocol": "icmp"
    }
  ],
  "direction": "INGRESS",
  "logConfig": {
    "enable": false
  },
  "disabled": false
}

Como criar VMs de back-end e grupos de instâncias

Neste exemplo, usamos dois grupos de instâncias não gerenciadas, cada um com duas VMs de back-end (servidor). Para demonstrar a natureza regional do balanceamento de carga TCP/UDP interno, os dois grupos de instâncias são colocados em zonas separadas, us-west1-a e us-west1-c.

  • O grupo de instâncias ig-a contém estas duas VMs:
    • vm-a1
    • vm-a2
  • O grupo de instâncias ig-c contém estas duas VMs:
    • vm-c1
    • vm-c2

O tráfego para as quatro VMs de back-end é submetido a balanceamento de carga.

Para ser compatível com este exemplo e as outras opções de configuração, cada uma das quatro VMs executa um servidor da Web Apache que detecta as portas TCP a seguir: 80, 8008, 8080, 8088, 443 e 8443.

Cada VM recebe um endereço IP interno no lb-subnet e um endereço IP externo (público) temporário. É possível remover os endereços IP externos posteriormente.

Embora não sejam obrigatórios, os endereços IP externos das VMs de back-end são úteis neste exemplo por permitirem que elas façam o download do Apache da internet, além de facilitarem a conexão por SSH.

Por padrão, o Apache é configurado para se vincular a qualquer endereço IP. Os balanceadores de carga TCP/UDP internos enviam pacotes preservando o IP de destino. Verifique se o software servidor executado nas suas VMs de back-end está escutando no endereço IP da regra de firewall interna do balanceador de carga. Se você configurar várias regras de encaminhamento internas, verifique se o software escuta o endereço IP interno associado a cada uma delas. O endereço IP interno da regra de encaminhamento é o endereço IP de destino de um pacote entregue a uma VM de back-end por um balanceador de carga TCP/UDP interno.

Para simplificar as instruções, essas VMs de back-end executam o Debian GNU/Linux 10.

Console

Criar VMs de back-end

  1. Acesse a página "Instâncias de VM" no Console do Google Cloud Platform.
    Acessar a página "Instâncias de VM"
  2. Repita as etapas a seguir para criar quatro VMs. Use estas combinações de nome e zona.
    • Nome: vm-a1, zona: us-west1-a
    • Nome: vm-a2, zona: us-west1-a
    • Nome: vm-c1, zona: us-west1-c
    • Nome: vm-c2, zona: us-west1-c
  3. Clique em Criar instância.
  4. Defina o Nome como indicado na etapa 2.
  5. Em Região, escolha us-west1 e escolha uma Zona, como indicado na etapa 2.
  6. Na seção Disco de inicialização, verifique se o sistema operacional Debian e a versão 10 (buster) estão selecionados para as opções de disco de inicialização. Clique em Escolher para alterar a imagem se necessário.
  7. Clique em Gerenciamento, segurança, discos, rede, locatário único e faça as alterações a seguir:

    • Clique em Rede e adicione as seguintes tags de rede: allow-ssh e allow-health-check.
    • Clique em Editar em Interfaces de rede, faça as seguintes alterações e clique em Concluído:
      • Rede: lb-network
      • Sub-rede: lb-subnet
      • IP interno primário: temporário (automático)
      • IP externo: temporário
    • 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
      if [ -f /etc/startup_script_completed ]; then
      exit 0
      fi
      apt-get update
      apt-get install apache2 -y
      a2ensite default-ssl
      a2enmod ssl
      file_ports="/etc/apache2/ports.conf"
      file_http_site="/etc/apache2/sites-available/000-default.conf"
      file_https_site="/etc/apache2/sites-available/default-ssl.conf"
      http_listen_prts="Listen 80\nListen 8008\nListen 8080\nListen 8088"
      http_vh_prts="*:80 *:8008 *:8080 *:8088"
      https_listen_prts="Listen 443\nListen 8443"
      https_vh_prts="*:443 *:8443"
      vm_hostname="$(curl -H "Metadata-Flavor:Google" \
      http://169.254.169.254/computeMetadata/v1/instance/name)"
      echo "Page served from: $vm_hostname" | \
      tee /var/www/html/index.html
      echo "Page served from: $vm_hostname" | \
      tee /var/www/html/index.html
      prt_conf="$(cat "$file_ports")"
      prt_conf_2="$(echo "$prt_conf" | sed "s|Listen 80|${http_listen_prts}|")"
      prt_conf="$(echo "$prt_conf_2" | sed "s|Listen 443|${https_listen_prts}|")"
      echo "$prt_conf" | tee "$file_ports"
      http_site_conf="$(cat "$file_http_site")"
      http_site_conf_2="$(echo "$http_site_conf" | sed "s|*:80|${http_vh_prts}|")"
      echo "$http_site_conf_2" | tee "$file_http_site"
      https_site_conf="$(cat "$file_https_site")"
      https_site_conf_2="$(echo "$https_site_conf" | sed "s|_default_:443|${https_vh_prts}|")"
      echo "$https_site_conf_2" | tee "$file_https_site"
      systemctl restart apache2
      touch /etc/startup_script_completed
      
  8. Clique em Criar.

Criar grupos de instâncias

  1. Acesse a página "Grupos de instâncias" no Console do Google Cloud.
    Acessar a página "Grupos de instâncias"
  2. Repita as etapas a seguir para criar dois grupos de instâncias não gerenciadas com duas VMs cada. Use estas combinações.
    • Grupo de instâncias: ig-a, zona: us-west1-a, VMs: vm-a1 e vm-a2
    • Grupo de instâncias: ig-c, zona: us-west1-c, VMs: vm-c1 e vm-c2
  3. Clique em Criar grupo de instâncias.
  4. Clique em Novo grupo de instâncias não gerenciadas.
  5. Defina o Nome como indicado na etapa 2.
  6. Na seção Local, escolha us-west1 como Região e escolha uma Zona, conforme indicado na etapa 2.
  7. Em Rede, insira lb-network.
  8. Em Sub-rede, insira lb-subnet.
  9. Na seção Instâncias de VMs, adicione as VMs como indicado na etapa 2.
  10. Clique em Criar.

gcloud

  1. Execute o seguinte comando quatro vezes para criar as quatro VMs, usando estas quatro combinações para [VM-NAME] e [ZONE]. O conteúdo do script é o mesmo para as quatro VMs.

    • [VM-NAME] de vm-a1 e [ZONE] de us-west1-a
    • [VM-NAME] de vm-a2 e [ZONE] de us-west1-a
    • [VM-NAME] de vm-c1 e [ZONE] de us-west1-c
    • [VM-NAME] de vm-c2 e [ZONE] de us-west1-c
    gcloud compute instances create [VM-NAME] \
        --zone=[ZONE] \
        --image-family=debian-10 \
        --image-project=debian-cloud \
        --tags=allow-ssh,allow-health-check \
        --subnet=lb-subnet \
        --metadata=startup-script='#! /bin/bash
    if [ -f /etc/startup_script_completed ]; then
    exit 0
    fi
    apt-get update
    apt-get install apache2 -y
    a2ensite default-ssl
    a2enmod ssl
    file_ports="/etc/apache2/ports.conf"
    file_http_site="/etc/apache2/sites-available/000-default.conf"
    file_https_site="/etc/apache2/sites-available/default-ssl.conf"
    http_listen_prts="Listen 80\nListen 8008\nListen 8080\nListen 8088"
    http_vh_prts="*:80 *:8008 *:8080 *:8088"
    https_listen_prts="Listen 443\nListen 8443"
    https_vh_prts="*:443 *:8443"
    vm_hostname="$(curl -H "Metadata-Flavor:Google" \
    http://169.254.169.254/computeMetadata/v1/instance/name)"
    echo "Page served from: $vm_hostname" | \
    tee /var/www/html/index.html
    prt_conf="$(cat "$file_ports")"
    prt_conf_2="$(echo "$prt_conf" | sed "s|Listen 80|${http_listen_prts}|")"
    prt_conf="$(echo "$prt_conf_2" | sed "s|Listen 443|${https_listen_prts}|")"
    echo "$prt_conf" | tee "$file_ports"
    http_site_conf="$(cat "$file_http_site")"
    http_site_conf_2="$(echo "$http_site_conf" | sed "s|*:80|${http_vh_prts}|")"
    echo "$http_site_conf_2" | tee "$file_http_site"
    https_site_conf="$(cat "$file_https_site")"
    https_site_conf_2="$(echo "$https_site_conf" | sed "s|_default_:443|${https_vh_prts}|")"
    echo "$https_site_conf_2" | tee "$file_https_site"
    systemctl restart apache2
    touch /etc/startup_script_completed'
    
  2. Crie os dois grupos de instâncias não gerenciadas em cada zona:

    gcloud compute instance-groups unmanaged create ig-a \
        --zone=us-west1-a
    gcloud compute instance-groups unmanaged create ig-c \
        --zone=us-west1-c
    
  3. Adicione as VMs aos grupos de instâncias apropriados:

    gcloud compute instance-groups unmanaged add-instances ig-a \
        --zone=us-west1-a \
        --instances=vm-a1,vm-a2
    gcloud compute instance-groups unmanaged add-instances ig-c \
        --zone=us-west1-c \
        --instances=vm-c1,vm-c2
    

api

Para as quatro VMs, use os seguintes nomes e zonas de VM:

  • [VM-NAME] de vm-a1 e [ZONE] de us-west1-a
  • [VM-NAME] de vm-a2 e [ZONE] de us-west1-a
  • [VM-NAME] de vm-c1 e [ZONE] de us-west1-c
  • [VM-NAME] de vm-c2 e [ZONE] de us-west1-c

Para ver o DEBIAN_IMAGE_NAME atual, execute o comando gcloud a seguir:

gcloud compute images list \
 --filter="family=debian-10"

Crie quatro VMs de back-end fazendo quatro solicitações POST ao método instances.insert:

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/[ZONE]/instances

{
  "name": "[VM-NAME]",
  "tags": {
    "items": [
      "allow-health-check",
      "allow-ssh"
    ]
  },
  "machineType": "https://www.googleapis.com/compute/v1/projects/project-id/zones/[ZONE]/machineTypes/e2-standard-2",
  "canIpForward": false,
  "networkInterfaces": [
    {
      "network": "https://www.googleapis.com/compute/v1/projects/project-id/global/networks/lb-network",
      "subnetwork": "https://www.googleapis.com/compute/v1/projects/project-id/regions/us-west1/subnetworks/lb-subnet",
      "accessConfigs": [
        {
          "type": "ONE_TO_ONE_NAT",
          "name": "external-nat",
          "networkTier": "PREMIUM"
        }
      ]
    }
  ],
  "disks": [
    {
      "type": "PERSISTENT",
      "boot": true,
      "mode": "READ_WRITE",
      "autoDelete": true,
      "deviceName": "[VM-NAME]",
      "initializeParams": {
        "sourceImage": "projects/debian-cloud/global/images/debian-image-name",
        "diskType": "projects/project-id/zones/zone/diskTypes/pd-standard",
        "diskSizeGb": "10"
      }
    }
  ],
  "metadata": {
    "items": [
      {
        "key": "startup-script",
        "value": "#! /bin/bash\napt-get update\napt-get install apache2 -y\na2ensite default-ssl\na2enmod ssl\nfile_ports=\"/etc/apache2/ports.conf\"\nfile_http_site=\"/etc/apache2/sites-available/000-default.conf\"\nfile_https_site=\"/etc/apache2/sites-available/default-ssl.conf\"\nhttp_listen_prts=\"Listen 80\\nListen 8008\\nListen 8080\\nListen 8088\"\nhttp_vh_prts=\"*:80 *:8008 *:8080 *:8088\"\nhttps_listen_prts=\"Listen 443\\nListen 8443\"\nhttps_vh_prts=\"*:443 *:8443\"\nvm_hostname=\"$(curl -H \"Metadata-Flavor:Google\" \\\nhttp://169.254.169.254/computeMetadata/v1/instance/name)\"\necho \"Page served from: $vm_hostname\" | \\\ntee /var/www/html/index.html\nprt_conf=\"$(cat \"$file_ports\")\"\nprt_conf_2=\"$(echo \"$prt_conf\" | sed \"s|Listen 80|${http_listen_prts}|\")\"\nprt_conf=\"$(echo \"$prt_conf_2\" | sed \"s|Listen 443|${https_listen_prts}|\")\"\necho \"$prt_conf\" | tee \"$file_ports\"\nhttp_site_conf=\"$(cat \"$file_http_site\")\"\nhttp_site_conf_2=\"$(echo \"$http_site_conf\" | sed \"s|*:80|${http_vh_prts}|\")\"\necho \"$http_site_conf_2\" | tee \"$file_http_site\"\nhttps_site_conf=\"$(cat \"$file_https_site\")\"\nhttps_site_conf_2=\"$(echo \"$https_site_conf\" | sed \"s|_default_:443|${https_vh_prts}|\")\"\necho \"$https_site_conf_2\" | tee \"$file_https_site\"\nsystemctl restart apache2"
      }
    ]
  },
  "scheduling": {
    "preemptible": false
  },
  "deletionProtection": false
}

Crie dois grupos de instâncias fazendo uma solicitação POST ao método instanceGroups.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instanceGroups

{
  "name": "ig-a",
  "network": "https://www.googleapis.com/compute/v1/projects/project-id/global/networks/lb-network",
  "subnetwork": "https://www.googleapis.com/compute/v1/projects/project-id/regions/us-west1/subnetworks/lb-subnet"
}

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-c/instanceGroups

{
  "name": "ig-c",
  "network": "https://www.googleapis.com/compute/v1/projects/project-id/global/networks/lb-network",
  "subnetwork": "https://www.googleapis.com/compute/v1/projects/project-id/regions/us-west1/subnetworks/lb-subnet"
}

Adicione instâncias a cada grupo de instâncias fazendo uma solicitação POST para o método instanceGroups.addInstances.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instanceGroups/ig-a/addInstances

{
  "instances": [
    {
      "instance": "https://www.googleapis.com/compute/v1/projects/project-id/zones/us-west1-a/instances/vm-a1",
      "instance": "https://www.googleapis.com/compute/v1/projects/project-id/zones/us-west1-a/instances/vm-a2"
    }
  ]
}

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-c/instanceGroups/ig-c/addInstances

{
  "instances": [
    {
      "instance": "https://www.googleapis.com/compute/v1/projects/project-id/zones/us-west1-c/instances/vm-c1",
      "instance": "https://www.googleapis.com/compute/v1/projects/project-id/zones/us-west1-c/instances/vm-c2"
    }
  ]
}

Como criar uma VM cliente

Neste exemplo, criamos uma VM cliente (vm-client) na mesma região das VMs de back-end (servidor). O cliente é usado para validar a configuração do balanceador de carga e demonstrar o comportamento esperado, conforme descrito na seção de teste.

Console

  1. Acesse a página "Instâncias de VM" no Console do Google Cloud Platform.
    Acessar a página "Instâncias de VM"
  2. Clique em Criar instância.
  3. Defina o Nome como vm-client.
  4. Defina a Zona como us-west1-a.
  5. Clique em Gerenciamento, segurança, discos, rede, locatário individual e faça as alterações a seguir:
    • Clique em Rede e adicione allow-ssh a Tags de rede.
    • Clique no botão de editar em Interfaces de rede e faça as alterações a seguir. Depois, clique em Concluído:
      • Rede: lb-network
      • Sub-rede: lb-subnet
      • IP interno primário: temporário (automático)
      • IP externo: temporário
  6. Clique em Criar.

gcloud

A VM cliente pode estar em qualquer zona na mesma região que o balanceador de carga, podendo usar qualquer sub-rede nessa região. Neste exemplo, o cliente está na zona us-west1-a e usa a mesma sub-rede das VMs de back-end.

gcloud compute instances create vm-client \
    --zone=us-west1-a \
    --image-family=debian-10 \
    --image-project=debian-cloud \
    --tags=allow-ssh \
    --subnet=lb-subnet

api

Faça uma solicitação POST ao método instances.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instances

{
  "name": "vm-client",
  "tags": {
    "items": [
      "allow-ssh"
    ]
  },
  "machineType": "https://www.googleapis.com/compute/v1/projects/project-id/zones/us-west1-a/machineTypes/e2-standard-2",
  "canIpForward": false,
  "networkInterfaces": [
    {
      "network": "https://www.googleapis.com/compute/v1/projects/project-id/global/networks/lb-network",
      "subnetwork": "https://www.googleapis.com/compute/v1/projects/project-id/regions/us-west1/subnetworks/lb-subnet",
      "accessConfigs": [
        {
          "type": "ONE_TO_ONE_NAT",
          "name": "external-nat",
          "networkTier": "PREMIUM"
        }
      ]
    }
  ],
  "disks": [
    {
      "type": "PERSISTENT",
      "boot": true,
      "mode": "READ_WRITE",
      "autoDelete": true,
      "deviceName": "vm-client",
      "initializeParams": {
        "sourceImage": "projects/debian-cloud/global/images/debian-image-name",
        "diskType": "projects/project-id/zones/us-west1-a/diskTypes/pd-standard",
        "diskSizeGb": "10"
      }
    }
  ],
  "scheduling": {
    "preemptible": false
  },
  "deletionProtection": false
}

Como configurar componentes do balanceador de carga

Estas etapas configuram todos os componentes do balanceador de carga TCP/UDP interno, começando com verificação de integridade e serviço de back-end e, em seguida, componentes de front-end:

  • Verificação de integridade: neste exemplo, usamos uma verificação de integridade HTTP que apenas verifica se há uma resposta HTTP 200 (OK). Para mais informações, consulte a seção sobre verificações de integridade da visão geral do balanceamento de carga TCP/UDP interno.

  • Serviço de back-end: devido à necessidade de passar tráfego HTTP através do balanceador de carga interno, precisamos usar TCP em vez de UDP.

  • Regra de encaminhamento: neste exemplo, criamos uma única regra de encaminhamento interna.

  • Endereço IP interno: neste exemplo, especificamos um endereço IP interno, 10.1.2.99, ao criarmos a regra de encaminhamento.

Console

Criar o balanceador de carga e configurar um serviço de back-end

  1. Acesse a página "Balanceamento de carga" no Console do Google Cloud.
    Acessar a página "Balanceamento de carga"
  2. Clique em Criar balanceador de carga.
  3. Em Balanceamento de carga TCP, clique em Iniciar configuração.
  4. Em Somente voltado para a Internet ou interno, selecione Apenas entre minhas VMs.
  5. Clique em Continuar.
  6. Defina o Nome como be-ilb.
  7. Clique em Configuração de back-end e faça as alterações a seguir:
    1. Região: us-west1
    2. Rede: lb-network
    3. Em Back-ends, na seção Novo item, selecione o grupo de instâncias ig-a e clique em Concluído.
    4. Clique em Adicionar back-end. Na seção Novo item exibida, selecione o grupo de instâncias ig-c e clique em Concluído novamente.
    5. Em Verificação de integridade, escolha Criar outra verificação de integridade, insira as informações a seguir e clique em Salvar e continuar:
      • Nome: hc-http-80
      • Protocolo: HTTP
      • Porta: 80
      • Protocolo de proxy: NONE
      • Caminho da solicitação: / Ao usar o Console do Cloud para criar o balanceador de carga, a verificação de integridade será global. Se você quiser criar uma verificação de integridade regional, use gcloud ou a API.
    6. Verifique se há uma marca de seleção azul ao lado de Configuração do back-end antes de continuar. Revise esta etapa se não houver marca.
  8. Clique em Configuração de front-end. Na seção Novo IP de front-end e porta, faça as seguintes alterações:
    1. Nome: fr-ilb
    2. Sub-rede: lb-subnet
    3. Em IP interno, escolha Reservar um endereço IP interno estático, insira as informações a seguir e clique em Reservar:
      • Nome: ip-ilb
      • Endereço IP estático: Quero escolher
      • Endereço IP personalizado: 10.1.2.99
    4. Portas: escolha Várias e digite 80,8008,8080,8088 como Número da porta.
    5. Verifique se há uma marca de seleção azul ao lado da Configuração de front-end antes de continuar. Revise esta etapa se não houver marca.
  9. Clique em Analisar e finalizar. Verifique suas configurações.
  10. Clique em Criar.

gcloud

  1. Crie uma nova verificação de integridade HTTP regional para testar a conectividade HTTP com as VMs na porta 80.

    gcloud compute health-checks create http hc-http-80 \
        --region=us-west1 \
        --port=80
    
  2. Crie o serviço de back-end do tráfego HTTP:

    gcloud compute backend-services create be-ilb \
        --load-balancing-scheme=internal \
        --protocol=tcp \
        --region=us-west1 \
        --health-checks=hc-http-80 \
        --health-checks-region=us-west1
    
  3. Adicione os dois grupos de instâncias ao serviço de back-end:

    gcloud compute backend-services add-backend be-ilb \
        --region=us-west1 \
        --instance-group=ig-a \
        --instance-group-zone=us-west1-a
    gcloud compute backend-services add-backend be-ilb \
        --region=us-west1 \
        --instance-group=ig-c \
        --instance-group-zone=us-west1-c
    
  4. Crie uma regra de encaminhamento do serviço de back-end. Ao criar a regra de encaminhamento, especifique 10.1.2.99 para o endereço IP interno na sub-rede.

    gcloud compute forwarding-rules create fr-ilb \
        --region=us-west1 \
        --load-balancing-scheme=internal \
        --network=lb-network \
        --subnet=lb-subnet \
        --address=10.1.2.99 \
        --ip-protocol=TCP \
        --ports=80,8008,8080,8088 \
        --backend-service=be-ilb \
        --backend-service-region=us-west1
    

api

Crie a verificação de integridade fazendo uma solicitação POST ao método regionHealthChecks.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/regionHealthChecks

{
  "name": "hc-http-80",
  "type": "HTTP",
  "httpHealthCheck": {
    "port": 80
  }
}

Crie um serviço de back-end regional fazendo uma solicitação POST ao método regionBackendServices.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/backendServices

{
  "name": "be-ilb",
  "backends": [
    {
      "group": "https://www.googleapis.com/compute/v1/projects/project-id/zones/us-west1-a/instanceGroups/ig-a",
      "balancingMode": "CONNECTION"
    },
    {
      "group": "https://www.googleapis.com/compute/v1/projects/project-id/zones/us-west1-c/instanceGroups/ig-c",
      "balancingMode": "CONNECTION"
    }
  ],
  "healthChecks": [
    "https://www.googleapis.com/compute/v1/projects/project-id/regions/us-west1/healthChecks/hc-http-80"
  ],
  "loadBalancingScheme": "INTERNAL",
  "connectionDraining": {
    "drainingTimeoutSec": 0
   }
}

Crie a regra de firewall fazendo uma solicitação POST ao método forwardingRules.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/forwardingRules

{
  "name": "fr-ilb",
  "IPAddress": "10.1.2.99",
  "IPProtocol": "TCP",
  "ports": [
    "80", "8008", "8080", "8088"
  ],
  "loadBalancingScheme": "INTERNAL",
  "subnetwork": "https://www.googleapis.com/compute/v1/projects/project-id/regions/us-west1/subnetworks/lb-subnet",
  "network": "https://www.googleapis.com/compute/v1/projects/project-id/global/networks/lb-network",
  "backendService": "https://www.googleapis.com/compute/v1/projects/project-id/regions/us-west1/backendServices/be-ilb",
  "networkTier": "PREMIUM"
}

Teste

Nos testes a seguir, veja como validar a configuração do balanceador de carga e conheça o comportamento esperado dele.

Como testar o balanceamento de carga

Neste teste, o balanceador de carga é contatado por uma VM cliente separada, e não por uma VM de back-end do balanceador de carga. O comportamento esperado é que o tráfego seja distribuído entre as quatro VMs de back-end porque nenhuma afinidade de sessão foi configurada.

  1. Conecte-se à instância da VM cliente.

    gcloud compute ssh vm-client --zone=us-west1-a
    
  2. Faça uma solicitação da Web para o balanceador de carga usando curl para contatar o endereço IP dele. Repita a solicitação para ver que as respostas provêm de diferentes VMs de back-end. O nome da VM que gera a resposta é exibido no texto na resposta HTML, em virtude do conteúdo de /var/www/html/index.html em cada VM de back-end. As respostas esperadas são assim: Page served from: vm-a1, Page served from: vm-a2 e assim por diante.

    curl http://10.1.2.99
    

    A regra de encaminhamento está configurada para exibir as portas 80, 8008, 8080 e 8088. Para enviar tráfego para essas outras portas, anexe dois pontos (:) e o número da porta após o endereço IP, desta maneira:

    curl http://10.1.2.99:8008
    
    • Se você adicionar um rótulo de serviço à regra de encaminhamento interno, poderá usar DNS interno para contatar o balanceador de carga usando o nome de serviço.

      curl http://web-test.fr-ilb.il4.us-west1.lb.project-id.internal
      

Como dar um ping no endereço IP do balanceador de carga

Neste teste, demonstramos um comportamento esperado: não é possível dar um ping no endereço IP do balanceador de carga. Isso ocorre porque os balanceadores de carga TCP/UDP internos são implementados na programação de rede virtual, eles não são dispositivos separados.

  1. Conecte-se à instância da VM cliente.

    gcloud compute ssh vm-client --zone=us-west1-a
    
  2. Tente fazer o ping do endereço IP do balanceador de carga. Observe que você não recebe uma resposta e o comando ping expira após 10 segundos neste exemplo.

    timeout 10 ping 10.1.2.99
    

Como enviar solicitações a partir de VMs submetidas a balanceamento de carga

Neste teste, demonstramos que as solicitações ao balanceador de carga originadas de qualquer VM de back-end (as VMs de servidor submetidas a balanceamento de carga) são sempre respondidas pela mesma VM que faz a solicitação.

O balanceamento de carga TCP/UDP interno é implementado por meio de programação de rede virtual e configuração de VM no SO convidado. Em VMs do Linux, o ambiente de convidado Linux realiza a configuração local instalando uma rota na tabela de roteamento do SO convidado. Por causa dessa rota local, o tráfego para o endereço IP do balanceador de carga permanece na VM submetida a balanceamento de carga. Esta rota local é diferente das rotas na rede VPC.

  1. Conecte-se a uma VM de back-end, como vm-a1:

    gcloud compute ssh vm-a1 --zone=us-west1-a
    
  2. Faça uma solicitação da Web para o balanceador de carga (por endereço IP ou nome de serviço) usando curl. Repita a solicitação e observe que a resposta é enviada pela VM de back-end que faz a solicitação. A resposta esperada quando se faz o teste a partir de vm-a1 é sempre: Page served from: vm-a1.

    curl http://10.1.2.99
    
  3. Inspecione a tabela de roteamento local, procurando um destino que corresponda ao endereço IP do próprio balanceador de carga, 10.1.2.99. Essa rota é uma parte necessária do balanceamento de carga TCP/UDP interno, mas também demonstra porque uma solicitação de uma VM por trás do balanceador de carga sempre é respondida pela mesma VM.

    ip route show table local | grep 10.1.2.99
    

Outras opções de configuração

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

Como ativar o acesso global

Ative o acesso global do seu balanceador de carga TCP/UDP interno de exemplo a fim de torná-lo acessível aos clientes em todas as regiões. Os back-ends do seu balanceador de carga de exemplo ainda precisam estar localizados em uma região (us-west1).

Balanceamento de carga TCP/UDP interno com acesso global (clique para ampliar)
Balanceamento de carga TCP/UDP interno com acesso global (clique para ampliar)

Para configurar o acesso global, faça as seguintes alterações de configuração.

Console

Editar a regra de encaminhamento do balanceador de carga

  1. Acesse a página "Balanceamento de carga" no Console do Google Cloud.
    Acessar a página "Balanceamento de carga"
  2. Na coluna Nome, clique no balanceador de carga TCP/UDP interno. O balanceador de carga de exemplo é chamado de be-ilb.

  3. Clique em Configuração de front-end.

  4. Clique em Editar .

  5. Em Acesso global, selecione Ativar.

  6. Clique em Concluído.

  7. Clique em Update.

Na página Detalhes do balanceador de carga, verifique se a configuração de front-end diz Regional (REGION) com acesso global.

gcloud

  1. Atualize a regra de encaminhamento do balanceador de carga de exemplo, fr-ilb, para incluir a sinalização --allow-global-access.

    gcloud compute forwarding-rules update fr-ilb \
       --region=us-west1 \
       --allow-global-access
    
  2. Verifique se a regra de encaminhamento permite acesso global.

    gcloud compute forwarding-rules describe fr-ilb \
       --region=us-west1 \
       --format="get(name,region,allowGlobalAccess)"
    

    A palavra True aparece na saída, após o nome e a região da regra de encaminhamento, quando o acesso global está ativado.

api

Faça uma solicitação PATCH ao método forwardingRules/patch.

PATCH https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/forwardingRules/fr-ilb

{
  "allowGlobalAccess": true
}

Criar um cliente de VM para testar o acesso global

Console

  1. Acesse a página "Instâncias de VM" no Console do Google Cloud Platform.
    Acessar a página "Instâncias de VM"
  2. Clique em Criar instância.
  3. Defina o Nome como vm-client2.
  4. Defina a Zona como europe-west1-b.
  5. Clique em Gerenciamento, segurança, discos, rede, locatário individual e faça as alterações a seguir:
    • Clique em Rede e adicione allow-ssh a Tags de rede.
    • Clique no botão de editar em Interfaces de rede e faça as alterações a seguir. Depois, clique em Concluído:
      • Rede: lb-network
      • Sub-rede: europe-subnet
      • IP interno primário: temporário (automático)
      • IP externo: temporário
  6. Clique em Criar.

gcloud

A VM cliente pode estar em qualquer zona na mesma região que o balanceador de carga, podendo usar qualquer sub-rede nessa região. Neste exemplo, o cliente está na zona europe-west1-b e usa a mesma sub-rede das VMs de back-end.

gcloud compute instances create vm-client2 \
    --zone=europe-west1-b \
    --image-family=debian-10 \
    --image-project=debian-cloud \
    --tags=allow-ssh \
    --subnet=europe-subnet

api

Faça uma solicitação POST ao método instances.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/europe-west1-b/instances

{
  "name": "vm-client2",
  "tags": {
    "items": [
      "allow-ssh"
    ]
  },
  "machineType": "https://www.googleapis.com/compute/v1/projects/project-id/zones/europe-west1-b/machineTypes/e2-standard-2",
  "canIpForward": false,
  "networkInterfaces": [
    {
      "network": "https://www.googleapis.com/compute/v1/projects/project-id/global/networks/lb-network",
      "subnetwork": "https://www.googleapis.com/compute/v1/projects/project-id/regions/europe-west1/subnetworks/europe-subnet",
      "accessConfigs": [
        {
          "type": "ONE_TO_ONE_NAT",
          "name": "external-nat",
          "networkTier": "PREMIUM"
        }
      ]
    }
  ],
  "disks": [
    {
      "type": "PERSISTENT",
      "boot": true,
      "mode": "READ_WRITE",
      "autoDelete": true,
      "deviceName": "vm-client2",
      "initializeParams": {
        "sourceImage": "projects/debian-cloud/global/images/debian-image-name",
        "diskType": "projects/project-id/zones/europe-west1-b/diskTypes/pd-standard",
        "diskSizeGb": "10"
      }
    }
  ],
  "scheduling": {
    "preemptible": false
  },
  "deletionProtection": false
}

Conectar-se ao cliente da VM e testar a conectividade

gcloud compute ssh vm-client2 --zone=europe-west1-b

Teste a conexão com o balanceador de carga em todas as portas configuradas, como você fez no vm-client na região us-west1. Teste a conectividade HTTP nas quatro portas configuradas na regra de encaminhamento:

curl http://10.1.2.99
curl http://10.1.2.99:8008
curl http://10.1.2.99:8080
curl http://10.1.2.99:8088

Como configurar grupos de instâncias gerenciadas

Com a configuração de exemplo, foram criados dois grupos de instâncias não gerenciadas. Porém, é possível usar grupos de instâncias gerenciadas, incluindo grupos de instâncias gerenciadas zonais e regionais, como back-ends para balanceamento de carga TCP/UDP interno.

Os grupos de instâncias gerenciadas exigem que você crie um modelo de instância. Neste procedimento, demonstramos como substituir os dois grupos de instâncias não gerenciadas zonais do exemplo por um único grupo de instâncias gerenciadas regionais. Um grupo de instâncias gerenciadas regionais cria automaticamente VMs em várias zonas da região, simplificando a distribuição do tráfego de produção entre as zonas.

Os grupos de instâncias gerenciadas também são compatíveis com autoescalonamento e recuperação automática. Se você usar autoescalonamento com balanceamento de carga TCP/UDP interno, não poderá escalonar de acordo com o balanceamento de carga.

Neste procedimento, mostramos como modificar o serviço de back-end do balanceador de carga TCP/UDP interno de exemplo para que ele use um grupo de instâncias gerenciadas regionais.

Console

Modelo de instância

  1. Acesse a página de modelos de instância de VM no Console do Google Cloud.
    Acessar a página "Modelos de instância" de VM
  2. Clique em Criar modelo de instância.
  3. Defina o Nome como template-vm-ilb.
  4. Escolha um tipo de máquina.
  5. Em Disco de inicialização, clique em Alterar, escolha o sistema operacional Debian e a versão 10 (buster).
  6. Clique em Salvar para confirmar as opções deste disco de inicialização.
  7. Clique em Gerenciamento, segurança, discos, rede, locatário único.

    • Clique em Rede e faça as seguintes alterações:
      • Rede: lb-network
      • Sub-rede: lb-subnet
      • Tags de rede: allow-ssh e allow-health-check
    • Clique em Gerenciamento. No campo Script de inicialização, copie e cole o conteúdo do script a seguir:
    #! /bin/bash
    if [ -f /etc/startup_script_completed ]; then
    exit 0
    fi
    apt-get update
    apt-get install apache2 -y
    a2ensite default-ssl
    a2enmod ssl
    file_ports="/etc/apache2/ports.conf"
    file_http_site="/etc/apache2/sites-available/000-default.conf"
    file_https_site="/etc/apache2/sites-available/default-ssl.conf"
    http_listen_prts="Listen 80\nListen 8008\nListen 8080\nListen 8088"
    http_vh_prts="*:80 *:8008 *:8080 *:8088"
    https_listen_prts="Listen 443\nListen 8443"
    https_vh_prts="*:443 *:8443"
    vm_hostname="$(curl -H "Metadata-Flavor:Google" \
    http://169.254.169.254/computeMetadata/v1/instance/name)"
    echo "Page served from: $vm_hostname" | \
    tee /var/www/html/index.html
    echo "Page served from: $vm_hostname" | \
    tee /var/www/html/index.html
    prt_conf="$(cat "$file_ports")"
    prt_conf_2="$(echo "$prt_conf" | sed "s|Listen 80|${http_listen_prts}|")"
    prt_conf="$(echo "$prt_conf_2" | sed "s|Listen 443|${https_listen_prts}|")"
    echo "$prt_conf" | tee "$file_ports"
    http_site_conf="$(cat "$file_http_site")"
    http_site_conf_2="$(echo "$http_site_conf" | sed "s|*:80|${http_vh_prts}|")"
    echo "$http_site_conf_2" | tee "$file_http_site"
    https_site_conf="$(cat "$file_https_site")"
    https_site_conf_2="$(echo "$https_site_conf" | sed "s|_default_:443|${https_vh_prts}|")"
    echo "$https_site_conf_2" | tee "$file_https_site"
    systemctl restart apache2
    touch /etc/startup_script_completed
    
  8. Clique em Criar

Grupo de instâncias gerenciadas

  1. Acesse a página de grupos de instâncias de VMs no Console do Google Cloud.
    Acessar a página "Grupos de instâncias" de VM
  2. Clique em Criar grupo de instâncias.
  3. Defina o Nome como ig-ilb.
  4. Em Local, escolha Várias zonas e defina a Região como us-west1.
  5. Defina o Modelo de instância como template-vm-ilb.
  6. (Opcional) Configure escalonamento automático. Não é possível fazer escalonamento automático no grupo de instâncias com base no uso do balanceamento de carga HTTP porque o grupo de instâncias é um back-end de balanceamento de carga TCP/UDP interno.
  7. Defina o Número mínimo de instâncias como 1 e o Número máximo de instâncias como 6.
  8. (Opcional) Configure a recuperação automática. Se você configurar a recuperação automática, use a mesma verificação de integridade usada pelo serviço de back-end para o balanceador de carga TCP/UDP interno. Neste exemplo, use hc-http-80.
  9. Clique em Criar

gcloud

  1. Crie o modelo da instância. Opcionalmente, defina outros parâmetros, como tipo de máquina, para o modelo de imagem a usar.

    gcloud compute instance-templates create template-vm-ilb \
        --image-family=debian-10 \
        --image-project=debian-cloud \
        --tags=allow-ssh,allow-health-check \
        --subnet=lb-subnet \
        --region=us-west1 \
        --network=lb-network \
           --metadata=startup-script='#! /bin/bash
             if [ -f /etc/startup_script_completed ]; then
             exit 0
             fi
             apt-get update
             apt-get install apache2 -y
             a2ensite default-ssl
             a2enmod ssl
             file_ports="/etc/apache2/ports.conf"
             file_http_site="/etc/apache2/sites-available/000-default.conf"
             file_https_site="/etc/apache2/sites-available/default-ssl.conf"
             http_listen_prts="Listen 80\nListen 8008\nListen 8080\nListen 8088"
             http_vh_prts="*:80 *:8008 *:8080 *:8088"
             https_listen_prts="Listen 443\nListen 8443"
             https_vh_prts="*:443 *:8443"
             vm_hostname="$(curl -H "Metadata-Flavor:Google" \
             http://169.254.169.254/computeMetadata/v1/instance/name)"
             echo "Page served from: $vm_hostname" | \
             tee /var/www/html/index.html
             prt_conf="$(cat "$file_ports")"
             prt_conf_2="$(echo "$prt_conf" | sed "s|Listen 80|${http_listen_prts}|")"
             prt_conf="$(echo "$prt_conf_2" | sed "s|Listen 443|${https_listen_prts}|")"
             echo "$prt_conf" | tee "$file_ports"
             http_site_conf="$(cat "$file_http_site")"
             http_site_conf_2="$(echo "$http_site_conf" | sed "s|*:80|${http_vh_prts}|")"
             echo "$http_site_conf_2" | tee "$file_http_site"
             https_site_conf="$(cat "$file_https_site")"
             https_site_conf_2="$(echo "$https_site_conf" | sed "s|_default_:443|${https_vh_prts}|")"
             echo "$https_site_conf_2" | tee "$file_https_site"
             systemctl restart apache2
             touch /etc/startup_script_completed'
    
  2. Crie um grupo de instânciasgerenciadas regionais usando o modelo:

    gcloud compute instance-groups managed create ig-ilb \
        --template=template-vm-ilb \
        --region=us-west1 \
        --size=6
    
  3. Adicione o grupo de instânciasgerenciadas regionais como back-end para o serviço de back-end que você já criou:

    gcloud compute backend-services add-backend be-ilb \
        --region=us-west1 \
        --instance-group=ig-ilb \
        --instance-group-region=us-west1
    
  4. Desconecte os dois grupos de instâncias não gerenciadas (zonais) do serviço de back-end:

    gcloud compute backend-services remove-backend be-ilb \
        --region=us-west1 \
        --instance-group=ig-a \
        --instance-group-zone=us-west1-a
    gcloud compute backend-services remove-backend be-ilb \
        --region=us-west1 \
        --instance-group=ig-c \
        --instance-group-zone=us-west1-c
    

Como remover endereços IP externos de VMs de back-end

Quando você criou as VMs de back-end, a cada uma foi atribuído um endereço IP externo temporário para possibilitar o download do Apache por meio de um script de inicialização. Como as VMs de back-end só são usadas por um balanceador de carga interno, é possível remover os endereços IP externos. A remoção de endereços IP externos impede que as VMs de back-end acessem a Internet diretamente.

Console

  1. Acesse a página "Instâncias de VM" no Console do Google Cloud Platform.
    Acessar a página "Instâncias de VM"
  2. Repita as etapas a seguir para cada VM de back-end.
  3. Clique no nome da VM de back-end (por exemplo, vm-a1) para visualizar a página Detalhes da instância de VM.
  4. Clique em Editar .
  5. Na seção Interfaces de rede, clique no botão Editar.
  6. No pop-up IP externo, escolha Nenhum e clique em Concluído.
  7. Clique em Salvar.

gcloud

  1. Para procurar a zona de uma instância, por exemplo, se estiver usando um grupo de instâncias gerenciadas regionais, execute o seguinte comando para cada instância determinar sua zona. Substitua [SERVER-VM] pelo nome da VM a ser pesquisada.

    gcloud compute instances list --filter="name=[SERVER-VM]"
    
  2. Repita a etapa a seguir para cada VM de back-end. Substitua [SERVER-VM] pelo nome da VM e [ZONE] pela zona da VM.

    gcloud compute instances delete-access-config [SERVER-VM] \
        --zone=[ZONE] \
        --access-config-name=external-nat
    

api

Faça uma solicitação POST ao método instances.deleteAccessConfig para cada VM de back-end, substituindo vm-a1 pelo nome da VM e us-west1-a pela zona da VM.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instances/vm-a1/deleteAccessConfig?accessConfig=external-nat&networkInterface=None

Como aceitar o tráfego em todas as portas

A regra de encaminhamento do balanceador de carga, não o serviço de back-end, determina a porta ou as portas em que o balanceador de carga aceita tráfego. Para mais informações sobre a finalidade de cada componente, consulte Componentes.

Ao criar a regra de encaminhamento do balanceador de carga de exemplo, você configurou as portas 80, 8008, 8080 e 8088. O script de inicialização que instala o Apache também o configura para aceitar conexões HTTPS nas portas 443 e 8443.

Para que essas seis portas tenham suporte, configure a regra de encaminhamento para aceitar o tráfego em todas as portas. Com essa estratégia, também é possível configurar a regra de firewall ou regras que permitem conexões de entrada para VMs de back-end, para que elas permitam apenas determinadas portas.

Neste procedimento, mostramos como substituir a regra de encaminhamento do balanceador de carga de exemplo por uma que aceite tráfego em todas as portas.

Para mais informações sobre quando usar essa configuração, consulte Balanceamento de carga TCP/UDP interno e regras de encaminhamento com um endereço IP comum.

Console

Excluir sua regra de encaminhamento e criar uma nova

  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 be-ilb e em Editar.
  3. Clique em Configuração de front-end.
  4. Passe o cursor sobre sua regra de encaminhamento 10.1.2.9 e clique no ícone da lixeira para excluí-la.
  5. Clique em Adicionar IP e porta de front-end.
  6. Na seção Novo IP de front-end e porta, faça as seguintes alterações:
    1. Nome: fr-ilb
    2. Sub-rede: lb-subnet
    3. Em IP interno, selecione ip-ilb
    4. Portas: Todas.
    5. Clique em Done.
    6. Verifique se há uma marca de seleção azul ao lado da Configuração de front-end antes de continuar. Revise esta etapa se não houver marca.
  7. Clique em Analisar e finalizar. Verifique suas configurações.
  8. Clique em Criar.

gcloud

  1. Exclua a regra de encaminhamento atual, fr-ilb.

    gcloud compute forwarding-rules delete fr-ilb \
        --region=us-west1
    
  2. Crie uma regra de encaminhamento de substituição com o mesmo nome, com uma configuração de porta que use a palavra-chave ALL. Os outros parâmetros da regra de encaminhamento permanecem os mesmos.

    gcloud compute forwarding-rules create fr-ilb \
        --region=us-west1 \
        --load-balancing-scheme=internal \
        --network=lb-network \
        --subnet=lb-subnet \
        --address=10.1.2.99 \
        --ip-protocol=TCP \
        --ports=ALL \
        --backend-service=be-ilb \
        --backend-service-region=us-west1
    

api

Exclua a regra de encaminhamento fazendo uma solicitação DELETE ao método forwardingRules.delete.

DELETE https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/forwardingRules/fr-ilb

Crie a regra de firewall fazendo uma solicitação POST ao método forwardingRules.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/forwardingRules

{
  "name": "fr-ilb",
  "IPAddress": "10.1.2.99",
  "IPProtocol": "TCP",
  "allPorts": true,
  "loadBalancingScheme": "INTERNAL",
  "subnetwork": "https://www.googleapis.com/compute/v1/projects/project-id/regions/us-west1/subnetworks/lb-subnet",
  "network": "https://www.googleapis.com/compute/v1/projects/project-id/global/networks/lb-network",
  "backendService": "https://www.googleapis.com/compute/v1/projects/project-id/regions/us-west1/backendServices/be-ilb",
  "networkTier": "PREMIUM"
}

Como testar o tráfego em todas as portas

Conecte-se à instância de VM de cliente e teste as conexões HTTP e HTTPS.

  • Conecte-se à VM do cliente:

    gcloud compute ssh vm-client --zone=us-west1-a
    
  • Teste a conectividade HTTP nas quatro portas:

    curl http://10.1.2.99
    curl http://10.1.2.99:8008
    curl http://10.1.2.99:8080
    curl http://10.1.2.99:8088
    
  • Teste a conectividade HTTPS nas portas 443 e 8443. A sinalização --insecure é obrigatória porque cada servidor Apache na configuração de exemplo usa um certificado autoassinado.

    curl https://10.1.2.99 --insecure
     curl https://10.1.2.99:8443 --insecure
    
  • Observe que as solicitações HTTP (em todas as quatro portas) e HTTPS (em ambas as portas) são distribuídas entre todas as VMs de back-end.

Como aceitar tráfego em várias portas usando duas regras de encaminhamento

Ao criar a regra de encaminhamento do balanceador de carga de exemplo, você configurou as portas 80, 8008, 8080 e 8088. O script de inicialização que instala o Apache também o configura para aceitar conexões HTTPS nas portas 443 e 8443.

Uma estratégia alternativa para configurar uma única regra de encaminhamento para aceitar o tráfego em todas as portas é criar várias regras de encaminhamento, cada uma com suporte para cinco ou menos portas.

Neste procedimento, veja como substituir a regra de encaminhamento do balanceador de carga de exemplo por duas regras de encaminhamento, uma para lidar com o tráfego nas portas 80, 8008, 8080 e 8088 e outra, nas portas 443 e 8443.

Para mais informações sobre quando usar essa configuração, consulte Balanceamento de carga TCP/UDP interno e regras de encaminhamento com um endereço IP comum.

gcloud

  1. Exclua a regra de encaminhamento atual, fr-ilb.

    gcloud compute forwarding-rules delete fr-ilb \
        --region=us-west1
    
  2. Crie um endereço IP interno estático (reservado) para 10.1.2.99 e defina a sinalização --purpose como SHARED_LOADBALANCER_VIP. A sinalização --purpose é necessária para que duas regras de encaminhamento interno possam usar o mesmo endereço IP interno.

    gcloud beta compute addresses create internal-10-1-2-99 \
        --region=us-west1 \
        --subnet=lb-subnet \
        --addresses=10.1.2.99 \
        --purpose=SHARED_LOADBALANCER_VIP
    
    1. Crie duas regras de encaminhamento de substituição com os seguintes parâmetros:
    gcloud compute forwarding-rules create fr-ilb-http \
        --region=us-west1 \
        --load-balancing-scheme=internal \
        --network=lb-network \
        --subnet=lb-subnet \
        --address=10.1.2.99 \
        --ip-protocol=TCP \
        --ports=80,8008,8080,8088 \
        --backend-service=be-ilb \
        --backend-service-region=us-west1
    
    gcloud compute forwarding-rules create fr-ilb-https \
        --region=us-west1 \
        --load-balancing-scheme=internal \
        --network=lb-network \
        --subnet=lb-subnet \
        --address=10.1.2.99 \
        --ip-protocol=TCP \
        --ports=443,8443 \
        --backend-service=be-ilb \
        --backend-service-region=us-west1
    

api

Exclua a regra de encaminhamento fazendo uma solicitação DELETE ao método forwardingRules.delete.

DELETE https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/forwardingRules/fr-ilb

Crie um endereço IP interno estático (reservado) para 10.1.2.99 e defina a finalidade como SHARED_LOADBALANCER_VIP, fazendo uma solicitação POST para o método addresses.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/addresses

{
  "name": "internal-10-1-2-99",
  "address": "10.1.2.99",
  "prefixLength": 32,
  "addressType": INTERNAL,
  "purpose": SHARED_LOADBALANCER_VIP,
  "subnetwork": "https://www.googleapis.com/compute/v1/projects/project-id/regions/us-west1/subnetworks/lb-subnet"
}

Crie duas regras de encaminhamento fazendo duas solicitações POST para o método forwardingRules.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/forwardingRules

{
  "name": "fr-ilb-http",
  "IPAddress": "10.1.2.99",
  "IPProtocol": "TCP",
  "ports": [
    "80", "8008", "8080",  "8088"
  ],
  "loadBalancingScheme": "INTERNAL",
  "subnetwork": "https://www.googleapis.com/compute/v1/projects/project-id/regions/us-west1/subnetworks/lb-subnet",
  "network": "https://www.googleapis.com/compute/v1/projects/project-id/global/networks/lb-network",
  "backendService": "https://www.googleapis.com/compute/v1/projects/project-id/regions/us-west1/backendServices/be-ilb",
  "networkTier": "PREMIUM"
}
{
  "name": "fr-ilb-https",
  "IPAddress": "10.1.2.99",
  "IPProtocol": "TCP",
  "ports": [
    "443", "8443"
  ],
  "loadBalancingScheme": "INTERNAL",
  "subnetwork": "https://www.googleapis.com/compute/v1/projects/project-id/regions/us-west1/subnetworks/lb-subnet",
  "network": "https://www.googleapis.com/compute/v1/projects/project-id/global/networks/lb-network",
  "backendService": "https://www.googleapis.com/compute/v1/projects/project-id/regions/us-west1/backendServices/be-ilb",
  "networkTier": "PREMIUM"
}

Como testar o tráfego em várias portas

Conecte-se à instância de VM de cliente e teste as conexões HTTP e HTTPS.

  • Conecte-se à VM do cliente:

    gcloud compute ssh vm-client --zone=us-west1-a
    
  • Teste a conectividade HTTP nas quatro portas:

    curl http://10.1.2.99
    curl http://10.1.2.99:8008
    curl http://10.1.2.99:8080
    curl http://10.1.2.99:8088
    
  • Teste a conectividade HTTPS nas portas 443 e 8443. A sinalização --insecure é obrigatória porque cada servidor Apache na configuração de exemplo usa um certificado autoassinado.

    curl https://10.1.2.99 --insecure
    curl https://10.1.2.99:8443 --insecure
    
  • Observe que as solicitações HTTP (em todas as quatro portas) e HTTPS (em ambas as portas) são distribuídas entre todas as VMs de back-end.

Como usar a afinidade de sessão

A configuração de exemplo cria um serviço de back-end sem afinidade de sessão.

Neste procedimento, mostramos como atualizar o serviço de back-end do balanceador de carga TCP/UDP interno de exemplo para que ele use a afinidade da sessão com base em um hash criado a partir dos endereços IP do cliente e do endereço IP da regra de encaminhamento interna do balanceador de carga. No momento, não é possível definir a afinidade da sessão de um balanceador de carga UDP interno.

Console

  1. Acesse a página "Balanceamento de carga" no Console do Google Cloud.
    Acessar a página "Balanceamento de carga"
  2. Clique em be-ilb (nome do serviço de back-end que você criou para este exemplo) e clique em Editar.
  3. Na página Editar balanceador de carga interno, clique em Configuração de back-end.
  4. Selecione IP do cliente no menu pop-up Sessão de afinidade.
  5. Clique em Atualizar.

gcloud

Use o comando gcloud a seguir para atualizar o serviço de back-end be-ilb, especificando a afinidade da sessão de IP do cliente:

gcloud compute backend-services update be-ilb \
    --region=us-west1 \
    --session-affinity CLIENT_IP

api

Faça uma solicitação PATCH ao método regionBackendServices/patch.

PATCH https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/backendServices/be-ilb

{
  "sessionAffinity": "CLIENT_IP"
}

Para mais informações sobre o uso da afinidade da sessão para influenciar a distribuição de tráfego e uma descrição de cada opção, consulte Distribuição de tráfego.

Como criar uma regra de encaminhamento em outra sub-rede

Neste procedimento, criamos um segundo endereço IP e regra de encaminhamento em outra sub-rede para demonstrar que é possível criar várias regras de encaminhamento para um balanceador de carga TCP/UDP interno. A região da regra de encaminhamento precisa corresponder à região do serviço de back-end.

Sujeito a regras de firewall, os clientes em qualquer sub-rede da região podem contatar o endereço IP do balanceador de carga TCP/UDP interno.

Console

Adicione a segunda sub-rede

  1. Acesse a página "Redes VPC" no Console do Google Cloud.
    Acessar a página "Redes VPC"
  2. Clique em Criar rede VPC.
  3. Clique em lb-network.
  4. Na seção Sub-redes:
    • Clique em Add subnet.
    • Na seção Nova sub-rede, insira as informações a seguir:
      • Nome: second-subnet
      • Região: us-west1
      • Intervalo de endereços IP: 10.5.6.0/24
      • Clique em Add.

Adicione a segunda regra de encaminhamento

  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 be-ilb e em Editar.
  3. Clique em Configuração de front-end.
  4. Clique em Adicionar IP e porta de front-end.
  5. Na seção Novo IP de front-end e porta, faça as seguintes alterações:
    1. Nome: fr-ilb-2
    2. Sub-rede: second-subnet
    3. Em IP interno, selecione ip-ilb
    4. Portas: 80, 443.
    5. Clique em Done.
    6. Verifique se há uma marca de seleção azul ao lado da Configuração de front-end antes de continuar. Revise esta etapa se não houver marca.
  6. Clique em Analisar e finalizar. Verifique suas configurações.
  7. Clique em Criar.

gcloud

  1. Crie uma segunda sub-rede na rede lb-network, região us-west1:

    gcloud compute networks subnets create second-subnet \
       --network=lb-network \
       --range=10.5.6.0/24 \
       --region=us-west1
    
  2. Crie uma segunda regra de encaminhamento para as portas 80 e 443. Os outros parâmetros desta regra, incluindo endereço IP e serviço de back-end, são iguais aos da regra de encaminhamento principal, fr-ilb.

    gcloud compute forwarding-rules create fr-ilb-2 \
       --region=us-west1 \
       --load-balancing-scheme=internal \
       --network=lb-network \
       --subnet=second-subnet \
       --address=10.5.6.99 \
       --ip-protocol=TCP \
       --ports=80,443 \
       --backend-service=be-ilb \
       --backend-service-region=us-west1
    

api

Faça uma solicitação POST ao método subnetworks.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks

{
  "name": "second-subnet",
  "network": "https://www.googleapis.com/compute/v1/projects/project-id/global/networks/lb-network",
  "ipCidrRange": "10.5.6.0/24",
  "privateIpGoogleAccess": false
}

Crie a regra de firewall fazendo uma solicitação POST ao método forwardingRules.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/forwardingRules

{
 "name": "fr-ilb-2",
 "IPAddress": "10.5.6.99",
 "IPProtocol": "TCP",
 "ports": [
   "80", "443"
 ],
 "loadBalancingScheme": "INTERNAL",
 "subnetwork": "https://www.googleapis.com/compute/v1/projects/project-id/regions/us-west1/subnetworks/lb-subnet",
 "network": "https://www.googleapis.com/compute/v1/projects/project-id/global/networks/lb-network",
 "backendService": "https://www.googleapis.com/compute/v1/projects/project-id/regions/us-west1/backendServices/be-ilb",
 "networkTier": "PREMIUM"
}

Como testar a nova regra de encaminhamento

  1. Conecte-se à instância de VM de cliente e teste as conexões HTTP e HTTPS com os endereços IP.

    • Conecte-se à VM do cliente:
    gcloud compute ssh vm-client --zone=us-west1-a
    
    • Teste a conectividade HTTP com os endereços IP:
    curl http://10.1.2.99
    curl http://10.5.6.99
    
    • Teste a conectividade HTTPS. O uso de --insecure é obrigatório porque a configuração do servidor Apache na configuração de exemplo usa certificados autoassinados.
    curl https://10.1.2.99 --insecure
    curl https://10.5.6.99 --insecure
    
    • Observe que as solicitações são manipuladas por todas as VMs de back-end, independentemente do protocolo (HTTP ou HTTPS) ou do endereço IP usado.

A seguir