Grupos de endpoints de rede autônomos

Este produto ou recurso está com disponibilidade geral quando usado com o Traffic Director. Para todos os outros usos, as seguintes condições se aplicam.

Nesta página, você aprende a criar um serviço do Kubernetes respaldado por um grupo de endpoints de rede.

Visão geral

O Google Cloud tem uma variedade de componentes de balanceamento de carga que podem ser combinados de maneiras diferentes para fornecer balanceamento de carga para seus aplicativos. Nas etapas deste tópico, são utilizados os componentes a seguir para fornecer balanceamento de carga em um serviço do Kubernetes:

No diagrama a seguir, você vê as conexões entre os componentes:

Diagrama dos componentes de balanceamento de carga referentes a um grupo de endpoints de rede

A seguir há uma visão geral das etapas deste tópico:

  1. Crie uma implantação que tenha três pods. Cada um deles tem um contêiner que faz detecções na porta TCP 50000.

  2. Crie um serviço. No manifesto do serviço, inclua a anotação cloud.google.com/neg. Assim, um controlador do GKE cria um grupo de endpoints de rede.

  3. Crie uma verificação de integridade.

  4. Crie um serviço de back-end. Depois, conecte-o à verificação de integridade e ao grupo de endpoints de rede.

  5. Crie um proxy TCP. Depois, conecte-o ao serviço de back-end.

  6. Crie uma regra de encaminhamento. Depois, conecte-a ao proxy TCP.

  7. Teste a regra de encaminhamento.

Antes de começar

É preciso um cluster que esteja executando o Google Kubernetes Engine versão 1.10 ou superior.

O cluster precisa ser nativo de VPC. Para saber mais, consulte Como criar clusters nativos de VPC usando IPs de alias.

Seu cluster precisa ter o balanceamento de carga HTTP ativado. Os clusters do GKE têm o balanceamento de carga HTTP ativado por padrão. Não o desative.

Execute as etapas a seguir para se preparar para a tarefa:

  • Verifique se você ativou a API Google Kubernetes Engine.
  • Ativar a API do Google Kubernetes Engine
  • Verifique se o SDK do Cloud está instalado.
  • Defina o ID do projeto padrão:
    gcloud config set project [PROJECT_ID]
  • Se você estiver trabalhando com clusters zonais, defina a zona do Compute padrão:
    gcloud config set compute/zone [COMPUTE_ZONE]
  • Se você estiver trabalhando com clusters regionais, defina a região do Compute padrão:
    gcloud config set compute/region [COMPUTE_REGION]
  • Atualize gcloud para a versão mais recente:
    gcloud components update

Como criar um grupo de endpoints de rede

Veja o manifesto de uma implantação:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-deployment
spec:
  selector:
    matchLabels:
      purpose: demo
      topic: standalone-neg
  replicas: 3
  template:
    metadata:
      labels:
        purpose: demo
        topic: standalone-neg
    spec:
      containers:
      - name: hello
        image: debian
        command: ["/bin/bash"]
        args:
        - "-c"
        - "apt-get update && apt-get install -y netcat && while true; do echo Hello TCP | nc -l -p 50000; done"

A implantação tem três pods, cada um com um contêiner.

Os campos cmd e args no manifesto de implantação usam netcat (nc) para implementar um servidor TCP simples que escute conexões na porta 50000.

Salve o manifesto em um arquivo denominado my-deployment.yaml e crie a implantação:

kubectl apply -f my-deployment.yaml

Veja o manifesto de um serviço:

apiVersion: v1
kind: Service
metadata:
  name: my-service
  annotations:
    cloud.google.com/neg: '{"exposed_ports": {"80":{}}}'
spec:
  type: ClusterIP
  selector:
    purpose: demo
    topic: standalone-neg
  ports:
  - name: my-service-port
    protocol: TCP
    port: 80
    targetPort: 50000

Para o propósito deste exercício, veja pontos importantes que você precisa entender sobre o serviço:

  • Qualquer pod que tenha o rótulo purpose: demo e o rótulo topic: standalone-neg é um membro do serviço.

  • O serviço tem um servicePort estrutura chamada my-service-port. A anotação cloud.google.com/neg diz que my-service-port será associado a um grupo de endpoints da rede.

  • Cada pod membro precisa ter um contêiner que faça detecções na porta TCP 50000.

Salve o manifesto em um arquivo chamado my-service.yaml e crie o Service:

kubectl apply -f my-service.yaml

Depois da criação, um controlador do GKE produz um grupo de endpoints de rede.

Aguarde um momento para que o grupo de endpoints de rede seja criado. Em seguida, é possível inspecionar o grupo de endpoints da rede usando gcloud ou o Console do Google Cloud Platform.

gcloud

Liste os grupos de endpoints de rede:

gcloud compute network-endpoint-groups list

A saída mostra que o grupo tem três endpoints:

NAME                                          LOCATION       ENDPOINT_TYPE   SIZE
k8s1-70aa83a6-default-my-service-80-c9710a6f  us-central1-a  GCE_VM_IP_PORT  3

Veja os endpoints:

gcloud compute network-endpoint-groups list-network-endpoints \
    [NETWORK_ENDPOINT_GROUP_NAME]

em que [NETWORK_ENDPOINT_GROUP_NAME] é o nome do grupo de endpoints de rede.

A saída mostra três endpoints. Cada um deles é um par com porta e endereço IP do pod.

INSTANCE                                           IP_ADDRESS  PORT
gke-standard-cluster-3-default-pool-4cc71a15-qlpf  10.12.1.43  50000
gke-standard-cluster-3-default-pool-4cc71a15-qlpf  10.12.1.44  50000
gke-standard-cluster-3-default-pool-4cc71a15-w9nk  10.12.2.26  50000
````

Console

  1. Visite a lista de grupos de endpoints da rede no Console do Cloud.

    Visite os grupos de endpoints da rede

    Uma lista dos grupos de endpoints da rede do seu projeto é exibida.

  2. Clique no nome do endpoint da rede. Os detalhes do grupo de endpoints da rede serão exibidos, incluindo o número de endpoints, sub-redes, endereços IP e portas.

Como criar uma regra de firewall

Mais adiante neste exercício, você criará uma verificação de integridade e um proxy TCP.

Crie uma regra de firewall para permitir o tráfego do proxy TCP e da verificação de integridade:

gcloud compute firewall-rules create my-fwr --network default \
    --source-ranges 130.211.0.0/22,35.191.0.0/16 --allow tcp

Como criar uma verificação de integridade e um serviço de back-end

Crie uma verificação de integridade:

gcloud compute health-checks create tcp my-hc --use-serving-port --global

Crie um serviço de back-end:

gcloud compute backend-services create my-bes --global \
    --protocol tcp --health-checks my-hc

Adicione o grupo de endpoints de rede ao serviço de back-end.

gcloud compute backend-services add-backend my-bes --global \
   --network-endpoint-group [NETWORK_ENDPOINT_GROUP_NAME] \
   --network-endpoint-group-zone [NETWORK_ENDPOINT_GROUP_ZONE] \
   --balancing-mode CONNECTION --max-connections-per-endpoint 5

em que:

  • [NETWORK_ENDPOINT_GROUP_NAME] é o nome do grupo de endpoints de rede;
  • [NETWORK_ENDPOINT_GROUP_ZONE] é a zona desse grupo.

Descreva o serviço de back-end:

gcloud compute backend-services describe my-bes --global

A saída mostra que o serviço de back-end está associado à verificação de integridade e ao grupo de endpoints de rede.

...
backends:
- balancingMode: CONNECTION
  capacityScaler: 1.0
  group: ... /networkEndpointGroups/k8s1-70aa83a6-default-my-service-80-c9710a6f
...
healthChecks:
- ... /healthChecks/my-hc
...
name: my-bes
...

Aguarde cinco minutos para que o serviço de back-end seja configurado.

Verifique a integridade do serviço de back-end:

gcloud compute backend-services get-health my-bes --global

A saída mostra a integridade de cada endpoint:

...
status:
  healthStatus:
  - healthState: HEALTHY
    instance: ... gke-standard-cluster-3-default-pool-4cc71a15-qlpf
    ipAddress: 10.12.1.43
    port: 50000
  - healthState: HEALTHY
    instance: ... gke-standard-cluster-3-default-pool-4cc71a15-qlpf
    ipAddress: 10.12.1.44
    port: 50000
  - healthState: HEALTHY
    instance: ... gke-standard-cluster-3-default-pool-4cc71a15-w9nk
    ipAddress: 10.12.2.26
    port: 50000

Como criar um proxy TCP e uma regra de encaminhamento

Crie um proxy TCP:

gcloud compute target-tcp-proxies create my-tp --backend-service my-bes

Crie uma regra de encaminhamento:

gcloud compute forwarding-rules create my-for --global \
    --ip-protocol tcp --ports 25 --target-tcp-proxy my-tp

Veja a regra de encaminhamento:

gcloud compute forwarding-rules describe my-for --global

A saída mostra o endereço IP externo da regra de encaminhamento:

IPAddress: 203.0.113.1
IPProtocol: TCP
...
kind: compute#forwardingRule
loadBalancingScheme: EXTERNAL
name: my-for
...
portRange: 25 - 25

Aguarde dez minutos para que a regra de encaminhamento seja configurada.

Use o netcat para testar a regra de encaminhamento:

nc -v [EXTERNAL_IP_ADDRESS] 25

em que [EXTERNAL_IP_ADDRESS] é o endereço IP externo da regra de encaminhamento.

A saída mostra a resposta de um dos contêineres:

Connection to 203.0.113.1 25 port [tcp/smtp] succeeded!
Hello TCP

Como limpar

Depois de concluir as tarefas nesta página, execute os comandos a seguir para remover os recursos e evitar cobranças indesejadas na conta:

gcloud compute forwarding-rules delete my-for --global --quiet
gcloud compute target-tcp-proxies delete my-tp --quiet
gcloud compute backend-services delete my-bes --quiet --global
gcloud compute firewall-rules delete my-fwr --quiet
gcloud compute health-checks delete my-hc --quiet
kubectl delete service my-service
kubectl delete deployment my-deployment

A seguir