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 seguintes componentes 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

Confira 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 dele, 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.

Prepare-se para esta tarefa seguindo as etapas a seguir:

  • 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 código padrão do projeto:
    gcloud config set project [PROJECT_ID]
  • Se você estiver trabalhando com clusters zonais, defina a zona de computação padrão:
    gcloud config set compute/zone [COMPUTE_ZONE]
  • Se você estiver trabalhando com clusters regionais, defina a região de computação padrão:
    gcloud config set compute/region [COMPUTE_REGION]
  • Atualize o 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 da implantação usam o netcat (nc) para implementar um servidor TCP simples que detecta 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 os rótulos purpose: demo e topic: standalone-neg é um membro do serviço.

  • O serviço tem uma estrutura servicePort denominada my-service-port. A anotação cloud.googe.com/neg informa que my-service-port será associado a um grupo de endpoints de rede.

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

Salve o manifesto em um arquivo denominado 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. Depois, será possível inspecioná-lo usando a gcloud ou o Console do Google Cloud Platform.

gcloud

Liste os grupos de endpoints de rede:

gcloud beta 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 beta 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. Acesse o menu "TODO" do Google Kubernetes Engine no Console do GCP.

    Acessar o menu "Cargas de trabalho"

  2. Clique em Implantar.

  3. Preencha o campo Imagem de contêiner com a devida imagem e a respectiva versão, como nginx:latest. Se preferir, clique em Selecionar a imagem atual do Google Container Registry e escolha a imagem.

  4. Configure o contêiner como quiser: adicione variáveis de ambiente, comandos iniciais, nome do aplicativo, namespace e rótulos.

  5. No menu suspenso Cluster, escolha o cluster que quiser.

  6. Clique em Implantar.

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 beta compute health-checks create tcp my-hc --use-serving-port

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 beta 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 beta 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.16
    port: 8080
  - healthState: HEALTHY
    instance: ... gke-standard-cluster-3-default-pool-4cc71a15-qlpf
    ipAddress: 10.12.1.17
    port: 8080
  - healthState: HEALTHY
    instance: ... gke-standard-cluster-3-default-pool-4cc71a15-w9nk
    ipAddress: 10.12.2.10
    port: 8080

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