Grupos de endpoints de rede autônomos

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 Platform conta com vários componentes que podem ser combinados de diferentes maneiras para fornecer balanceamento de carga nos 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

Veja abaixo 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 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 padrão do Compute:
    gcloud config set compute/zone [COMPUTE_ZONE]
  • Se você estiver trabalhando com clusters regionais, defina a região padrão do Compute:
    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.googe.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 serviço:

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 GCP.

    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

Esta página foi útil? Conte sua opinião sobre:

Enviar comentários sobre…

Documentação do Kubernetes Engine