Como configurar o balanceamento de carga HTTP(S) interno dos pods do GKE

Neste documento, apresentamos instruções para configurar o balanceamento de carga HTTP(S) interno para seus serviços em execução nos pods do Google Kubernetes Engine (GKE).

Beta

Esta é uma versão Beta do balanceamento de carga HTTP(S) interno. Ela não é coberta por SLAs ou políticas de suspensão de uso e está sujeita a alterações incompatíveis com versões anteriores.

Antes de começar

Antes de seguir as instruções deste guia, consulte os seguintes documentos:

• Consulte Como preparar-se para o balanceamento de carga HTTP(S) interno para verificar se você concluiu os pré-requisitos.

• Na Visão geral da configuração, consulte o diagrama que mostra os recursos necessários.

• Nos conceitos de balanceamento de carga HTTP(S) interno, certifique-se de compreender as limitações.

• Ative a API GKE.

Como configurar o balanceamento de carga HTTP(S) interno com um serviço baseado em GKE

Nesta seção, mostramos a configuração necessária para serviços executados em pods do GKE. As VMs cliente se conectam ao endereço IP e à porta que você configura na regra de encaminhamento. Quando seus aplicativos cliente enviam tráfego para esse endereço IP e porta, as solicitações deles são encaminhadas aos pods de back-end do GKE de acordo com o mapa de URL do balanceador de carga HTTP(S) interno.

No exemplo desta página, definimos explicitamente um endereço IP interno reservado para a regra de encaminhamento interno, em vez de permitir que um endereço IP interno temporário seja alocado. Essa é a prática recomendada para regras de encaminhamento.

Como configurar back-ends: cluster do GKE

Nesta seção, criamos um cluster de demonstração do GKE e uma implantação para executar um contêiner simples que executa um servidor da Web simples que exibe o nome do host do nó. Criamos também um serviço ClusterIP, que cria um NEG automaticamente.

Console

Para criar um cluster usando o Console do GCP, siga estas etapas:

1. Vá para o menu do Google Kubernetes Engine no Console do GCP.

   Acessar o menu do Google Kubernetes Engine

2. Clique em Criar cluster.

3. No campo Nome, digite l7-ilb-cluster.

4. Em Tipo de local, selecione Zonal.

5. Em Zona, selecione us-west1-b.

6. Escolha a Versão mestre padrão.

7. Expanda Disponibilidade, rede, segurança e outros recursos:

   1. Verifique se a caixa Ativar cluster nativo de VPC (usando o IP do alias) está selecionada.
   2. Em Rede, selecione lb-network.
   3. Em Sub-rede do nó, selecione backend-subnet.
   4. Verifique se Balanceamento de carga está ativado marcando a caixa ao lado de Enable HTTP load balancing.

8. Para os campos restantes, mantenha os valores padrão ou ajuste-os para atender às suas necessidades.

9. Clique em Criar.

Ao usar o Console do GCP para criar o cluster, é necessário adicionar a tag de rede gerada pelo sistema ao filtro do firewall proxy:

1. Encontre a tag de rede que o GKE adicionou aos nós do cluster. A tag é gerada com base no hash do cluster.

   1. Acesse a página "Instâncias de VMs".

      Acessar a página "Instâncias de VMs"

   2. No menu suspenso Colunas, selecione Tags de rede.

   3. Copie a tag de rede para os nós do GKE. Ela será semelhante a este exemplo:

      gke-l7-ilb-cluster-id-node
      

2. Edite a regra de firewall fw-allow-proxies e adicione a tag.

   1. Acesse a página "Regras de firewall" no Console do Google Cloud Platform.
      Acessar a página "Regras de firewall"
   2. Clique na regra de firewall fw-allow-proxies e, em seguida, clique em Editar.
   3. No campo Palavras-chave, adicione a tag de rede que você copiou na etapa anterior.
   4. Clique em Salvar.

gcloud

1. Crie um cluster do GKE com o comando gcloud container clusters create.

   gcloud container clusters create l7-ilb-cluster \
     --zone=us-west1-b \
     --network=lb-network \
     --subnetwork=backend-subnet \
     --enable-ip-alias \
     --tags=allow-ssh,load-balanced-backend
   

api

Crie um cluster do GKE com o método projects.zones.clusters.create, substituindo [project-id] pelo ID do projeto.

POST https://container.googleapis.com/v1beta1/projects/<var>[project-id]</var>/zones/us-west1-b/clusters
{
  "cluster": {
    "name": "l7-ilb-cluster",
    "network": "projects/<var>[project-id]</var>/global/networks/lb-network1",
    "subnetwork": "projects/<var>[project-id]</var>/regions/us-west1/subnetworks/backend-subnet1",
    "initialClusterVersion": "1.11",
    "location": "us-west1-b",
    "nodePools": [{
      "name": "l7-ilb-node-pool",
      "initialNodeCount": 3
    }],
    "nodeConfig":{
       "tags":["allow-ssh","load-balanced-backend"]
    }
    "defaultMaxPodsConstraint": {
      "maxPodsPerNode": "110"
    },
    "ipAllocationPolicy": {
      "useIpAliases": True
    }
  }
}

Como conseguir credenciais para operar o cluster

Use o comando gcloud container clusters get-credentials.

gcloud container clusters get-credentials l7-ilb-cluster \
    --zone=us-west1-b

Como definir uma implantação com contêineres de teste que exibem o nome do host

Crie hostname.yaml com a especificação da implantação e do serviço.

cat << EOF > hostname.yaml
apiVersion: v1
kind: Service
metadata:
  name: hostname
  annotations:
    cloud.google.com/neg: '{"exposed_ports":{"80":{}}}'
spec:
  ports:
  - port: 80
    name: host1
    protocol: TCP
    targetPort: 8000
  selector:
    run: hostname
  type: ClusterIP

---

apiVersion: extensions/v1beta1
kind: Deployment
metadata:
  labels:
    run: hostname
  name: hostname
spec:
  replicas: 3
  template:
    metadata:
      labels:
        run: hostname
    spec:
      containers:
      - image: gcr.io/kubernetes-e2e-test-images/serve-hostname-amd64:1.1
        name: host1
        command:
        - /bin/sh
        - -c
        - /serve_hostname -http=true -udp=false -port=8000
        ports:
        - protocol: TCP
          containerPort: 8000
EOF

Como aplicar a configuração

kubectl apply -f hostname.yaml

Como verificar a implantação e a configuração do GKE

Verifique se o novo nome de host do serviço foi criado e se o pod do aplicativo está em execução.

kubectl get svc

O exemplo de saída é o seguinte:

NAME         TYPE        CLUSTER-IP   EXTERNAL-IP   PORT(S)   AGE
hostname     ClusterIP   10.71.9.71           80/TCP    41m
[..skip..]

Observe que o endereço IP do cluster provavelmente é diferente porque o GKE cria automaticamente o intervalo de IP do cluster como um intervalo de IP secundário em backend-subnet.

Se o comando kubectl get svc falhar com problemas de credencial/OAuth, execute o comando gcloud auth application-default login.

kubectl get pods

O exemplo de saída é o seguinte:

NAME                        READY     STATUS    RESTARTS   AGE
hostname-6db459dcb9-896kh   1/1       Running   0          33m
hostname-6db459dcb9-k6ddk   1/1       Running   0          50m
hostname-6db459dcb9-x72kb   1/1       Running   0          33m
[..skip..]

Os nomes dos seus pods são diferentes.

Você verá que o novo nome de host do serviço foi criado e os pods do aplicativo de nome do host estão em execução.

Como conseguir o nome do NEG

1. Procure o nome do NEG usando o comando gcloud compute network-endpoint-groups list, filtrando pela zona do cluster e pelo nome da implantação:

   gcloud compute network-endpoint-groups list \
      --filter="us-west1-b AND hostname" \
      --format="get(name)"
   

Como examinar a configuração do NEG

1. Examine os detalhes e relacione os endpoints no NEG com os comandos gcloud compute network-endpoint-groups list-network-endpoints e gcloud compute network-endpoint-groups describe, substituindo neg-name pelo nome do NEG que você criou.

   gcloud compute network-endpoint-groups describe neg-name \
      --zone=us-west1-b
   

   gcloud compute network-endpoint-groups list-network-endpoints neg-name \
      --zone=us-west1-b
   

Como configurar o balanceador de carga para o GKE

No exemplo, demonstramos as seguintes tarefas internas de configuração do balanceador de carga HTTP(S) interno:

• Criar uma verificação de integridade usando o protocolo HTTP
• Criar um serviço de back-end gerenciado interno e regional
• Adicionar o NEG como um back-end ao serviço de back-end
• Criar um mapa de URL
  • Certifique-se de consultar um mapa regional de URL se uma região for definida para o proxy HTTP(S) de destino. Um mapa regional de URL direciona as solicitações para um serviço de back-end regional com base em regras definidas para o host e caminho de um URL recebido. Esse tipo de mapa pode ser referenciado por uma regra de proxy de destino regional somente na mesma região.
• Criar um proxy de destino

• Criar uma regra de encaminhamento

Console

Selecionar um tipo de balanceador de carga

1. Acesse a página "Balanceamento de carga" no Console do Google Cloud Platform.
   Acessar a página "Balanceamento de carga"
2. Clique em Criar balanceador de carga.
3. Em Balanceamento de carga HTTP(S), clique em Iniciar configuração.
4. Selecione Apenas entre minhas VMs. Essa configuração indica que o balanceador de carga é interno.
5. Clique em Continuar.

Preparar o balanceador de carga

1. Em Nome do balanceador de carga, digite l7-ilb-gke-map.
2. Verifique se o Protocolo é HTTP.
3. Em Região, selecione us-west1.
4. Em Rede VPC, selecione lb-network.
5. Mantenha a janela aberta para continuar.

Reservar uma sub-rede somente proxy

Observação: se você já reservou uma sub-rede somente proxy, conforme instruído na configuração da preparação, o botão Reservar uma sub-rede não será exibido, portanto, será necessário ignorar esta seção e continuar com as etapas em Configurar o serviço de back-end.

Para o balanceamento de carga de HTTP(S) interno, reserve uma sub-rede proxy:

1. Clique em Reservar uma sub-rede.
2. Em Nome, insira proxy-subnet.
3. Em Rede, selecione lb-network.
4. Em Região, selecione us-west1.
5. Em Intervalo de endereços IP, digite 10.129.0.0/26.
6. Clique em Adicionar.

Configurar o serviço de back-end

1. Clique em Configuração de back-end.
2. No menu Criar ou selecionar serviços de back-end, selecione Criar um serviço de back-end.
3. Defina o Nome do serviço de back-end como l7-ilb-gke-backend-service.
4. Em Tipo de back-end, selecione Grupos de endpoints de rede.
5. No cartão Novo back-end da seção Back-ends, siga estas etapas:
   1. Defina Grupo de endpoints de rede como o NEG criado pelo GKE. Consulte Como conseguir o nome do NEG para saber como determinar o nome dele.
   2. Digite uma taxa máxima de 5 RPS por endpoint. O GCP excederá esse limite máximo, se necessário.
   3. Clique em Concluído.
6. Na seção Verificação de integridade, escolha Criar verificação de integridade com os seguintes parâmetros:
   1. Nome: l7-ilb-gke-basic-check
   2. Protocolo: HTTP
   3. Especificação de portas: porta de exibição
   4. Clique em Salvar e continuar.
7. Clique em Criar.

Configurar o mapa de URL

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

Configurar os componentes do front-end

1. Clique em Configuração de front-end e edite a seção Novo IP e porta de front-end.
2. Defina o Nome como l7-ilb-gke-forwarding-rule.
3. Defina o Protocolo como HTTP.
4. Defina a Sub-rede como sub-rede de back-end.
5. Escolha Reservar um endereço IP interno estático no botão pop-up IP interno.
6. No painel exibido, forneça os seguintes detalhes:
   1. Nome: l7-ilb-gke-ip
   2. Na seção Endereço IP estático, selecione Deixe-me escolher.
   3. Na seção Endereço IP personalizado, insira 10.1.2.199.
   4. Clique em Reservar.
7. Defina a Porta como 80.
8. Clique em Concluído.

Concluir a configuração

1. Clique em Criar.

gcloud

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

   gcloud beta compute health-checks create http l7-ilb-gke-basic-check \
   --region=us-west1 \
   --use-serving-port
   

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

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

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

   gcloud beta compute backend-services add-backend l7-ilb-gke-backend-service \
    --network-endpoint-group=neg-name \
    --network-endpoint-group-zone=us-west1-b \
    --region=us-west1 \
    --balancing-mode=RATE \
    --max-rate-per-endpoint=5
   

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

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

5. Crie o proxy de destino com o comando gcloud compute target-http-proxies create.

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

6. Crie a regra de encaminhamento com o comando gcloud compute forwarding-rules create.

   Para redes personalizadas, referencie a sub-rede na regra de encaminhamento. Observe que esta é a sub-rede da VM, não a do proxy.

   gcloud beta compute forwarding-rules create l7-ilb-gke-forwarding-rule \
   --load-balancing-scheme=INTERNAL_MANAGED \
   --network=lb-network \
   --subnet=backend-subnet \
   --address=10.1.2.199 \
   --ports=80 \
   --region=us-west1 \
   --target-http-proxy=l7-ilb-gke-proxy \
   --target-http-proxy-region=us-west1
   

api

Crie a verificação de integridade fazendo uma solicitação POST para o método healthChecks.insert, substituindo [project-id] pelo ID do projeto.

POST https://www.googleapis.com/compute/beta/projects/[project-id]/global/healthChecks
{
  "name": "l7-ilb-gke-basic-check",
  "type": "HTTP",
  "httpHealthCheck": {
    "portSpecification": "USE_SERVING_PORT"
  }
}

Crie o serviço de back-end regional fazendo uma solicitação POST para o regionBackendServices.insert substituindo [project-id] pelo ID do projeto e [neg-name] pelo nome do NEG que você criou.

POST https://www.googleapis.com/compute/beta/projects/[project-id]/regions/us-west1/backendServices
{
  "name": "l7-ilb-gke-backend-service",
  "backends": [
    {
      "group": "https://www.googleapis.com/compute/v1/projects/[project-id]/zones/us-west1-b/networkEndpointGroups/[neg-name]",
      "balancingMode": "RATE"
      "maxRatePerEndpoint": 5
    }
  ],
  "healthChecks": [
    "projects/[project-id]/global/healthChecks/l7-ilb-gke-basic-check"
  ],
  "loadBalancingScheme": "INTERNAL_MANAGED"
}

Crie o mapa de URL fazendo uma solicitação POST ao método urlMap.insert, substituindo [project-id] pelo ID do projeto.

POST https://www.googleapis.com/compute/beta/projects/[project-id]/global/urlMaps
{
  "name": "l7-ilb-gke-map",
  "defaultService": "projects/[project-id]/regions/us-west1/backendServices/l7-ilb-gke-backend-service"
}

Crie o proxy HTTP de destino fazendo uma solicitação POST para o método targetHttpProxies.insert, substituindo [project-id] pelo ID do projeto.

POST https://www.googleapis.com/compute/beta/projects/[project-id]/regions/us-west1/targetHttpProxy
{
  "name": "l7-ilb-gke-proxy",
  "urlMap": "projects/[project-id]/global/urlMaps/l7-ilb-gke-map",
  "region": "us-west1"
}

Crie a regra de encaminhamento fazendo uma solicitação POST ao método forwardingRules.insert, substituindo [project-id] pelo ID do projeto.

POST https://www.googleapis.com/compute/beta/projects/[project-id]/regions/us-west1/forwardingRules
{
  "name": "l7-ilb-gke-forwarding-rule",
  "IPAddress": "10.1.2.199",
  "IPProtocol": "TCP",
  "portRange": "80-80",
  "target": "projects/[project-id]/regions/us-west1/targetHttpProxies/l7-ilb-gke-proxy",
  "loadBalancingScheme": "INTERNAL_MANAGED",
  "subnetwork": "projects/[project-id]/regions/us-west1/subnetworks/backend-subnet",
  "network": "projects/[project-id]/global/networks/lb-network",
  "networkTier": "PREMIUM",
}

Teste

Como criar uma instância de VM na zona para testar a conectividade

gcloud compute instances create l7-ilb-client-us-west1-b \
    --image-family=debian-9 \
    --image-project=debian-cloud \
    --zone=us-west1-b \
    --network=lb-network \
    --subnet=backend-subnet \
    --tags=l7-ilb-client

Como permitir acesso SSH à instância

gcloud compute firewall-rules create allow-ssh-to-l7-ilb-client \
    --network=lb-network \
    --target-tags=l7-ilb-client \
    --allow=tcp:22

Como testar o balanceador de carga

Faça login na instância do cliente para que os serviços HTTP(S) nos back-ends sejam acessados pelo endereço IP da regra de encaminhamento do balanceador de carga HTTP(S) interno e o balanceamento de carga do tráfego seja feito entre os endpoints no NEG.

Como conectar via SSH a cada instância do cliente

gcloud compute ssh l7-ilb-client-us-west1-b \
    --zone=us-west1-b

Como verificar se o IP está exibindo o nome de host dele

curl 10.1.2.199

Como executar 100 solicitações e confirmar o balanceamento de carga delas

{
RESULTS=
for i in {1..100}
do
    RESULTS="$RESULTS:$(curl --silent 10.1.2.199)"
done
echo "***"
echo "*** Results of load-balancing to 10.1.2.199: "
echo "***"
echo "$RESULTS" | tr ':' '\n' | grep -Ev "^$" | sort | uniq -c
echo
}

Observe que vários proxies executam o balanceamento de carga, um para cada comando curl, e eles não coordenam a seleção de back-ends deles. Portanto, neste teste, os back-ends não recebem o mesmo número de solicitações. No entanto, a longo prazo (em outras palavras, de milhares a milhões de solicitações), a fração de solicitações recebidas por cada back-end se aproxima de uma distribuição igual.

A seguir

• Consulte Conceitos de balanceamento de carga HTTP(S) interno para informações sobre como funciona esse tipo de balanceamento de carga.
• Consulte Como configurar o balanceamento de carga HTTP(S) interno para VMs do Compute Engine se você quiser que os serviços de back-end sejam executados nas VMs do Compute Engine.
• Consulte Sub-rede somente proxy para balanceadores de carga HTTP(S) internos para informações sobre como gerenciar o recurso de sub-rede somente proxy exigido pelo balanceamento de carga HTTP(S) interno.
• Consulte Solução de problemas de balanceamento de carga de HTTP(S) interno para instruções sobre como resolver problemas de configuração.