Como configurar o balanceamento de carga por meio da Entrada

Nesta página, você aprende a configurar um balanceador de carga HTTP(S) criando um objeto de entrada do Kubernetes. O objeto de entrada precisa estar associado a um ou mais objetos de serviço, e cada um deles associado a um conjunto de Pods.

Um objeto de serviço tem uma ou mais estruturas servicePort. Cada servicePort segmentado por uma entrada está associado a um recurso do serviço de back-end do Google Cloud Platform.

Antes de começar

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

Vários serviços de back-end

Um balanceador de carga HTTP(S) fornece um endereço IP estável que você pode usar para rotear solicitações para diversos serviços de back-end.

Neste exercício, você configura o balanceador de carga para rotear solicitações para diferentes serviços de back-end, dependendo do caminho da URL. Solicitações que têm o caminho / são roteadas para um serviço de back-end e as solicitações que têm o caminho /kube são encaminhadas para um serviço de back-end diferente.

Veja a ideia geral dos passos deste exercício:

  1. Crie uma implantação e a exponha a um serviço chamado hello-world.
  2. Crie uma segunda implantação e a exponha a um serviço chamado hello-kubernetes.
  3. Crie uma entrada que especifique regras para rotear solicitações de um serviço a outro, dependendo do caminho da URL na solicitação. Quando você cria a entrada, o controlador de entrada GKE cria e configura um balanceador de carga HTTP(S).
  4. Teste o balanceador de carga HTTP(S).

Veja aqui um manifesto da primeira implantação:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: hello-world-deployment
spec:
  selector:
    matchLabels:
      greeting: hello
      department: world
  replicas: 3
  template:
    metadata:
      labels:
        greeting: hello
        department: world
    spec:
      containers:
      - name: hello
        image: "gcr.io/google-samples/hello-app:2.0"
        env:
        - name: "PORT"
          value: "50000"

Copie o manifesto em um arquivo denominado hello-world-deployment.yaml e crie a implantação:

kubectl apply -f hello-world-deployment.yaml

Veja aqui um manifesto para um serviço que expõe sua primeira implantação:

apiVersion: v1
kind: Service
metadata:
  name: hello-world
spec:
  type: NodePort
  selector:
    greeting: hello
    department: world
  ports:
  - protocol: TCP
    port: 60000
    targetPort: 50000

Para os fins deste exercício, estes são os pontos importantes que você precisa entender sobre o serviço:

  • Qualquer pod que tenha o rótulo greeting: hello e o rótulo department: world é membro do serviço.

  • Quando uma solicitação é enviada ao serviço na porta TCP 60000, ela é encaminhada para um dos pods membros na porta TCP 50000.

Copie o manifesto para um arquivo chamado hello-world-service.yaml e crie o serviço:

kubectl apply -f hello-world-service.yaml

Veja aqui um manifesto para uma segunda implantação:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: hello-kubernetes-deployment
spec:
  selector:
    matchLabels:
      greeting: hello
      department: kubernetes
  replicas: 3
  template:
    metadata:
      labels:
        greeting: hello
        department: kubernetes
    spec:
      containers:
      - name: hello-again
        image: "gcr.io/google-samples/node-hello:1.0"
        env:
        - name: "PORT"
          value: "8080"

Copie o manifesto em um arquivo denominado hello-kubernetes-deployment e crie a implantação:

kubectl apply -f hello-kubernetes-deployment.yaml

Veja aqui um manifesto para um serviço que expõe sua segunda implantação:

apiVersion: v1
kind: Service
metadata:
  name: hello-kubernetes
spec:
  type: NodePort
  selector:
    greeting: hello
    department: kubernetes
  ports:
  - protocol: TCP
    port: 80
    targetPort: 8080

Para os fins deste exercício, estes são os pontos importantes que você precisa entender sobre o serviço:

  • Qualquer pod que tenha o rótulo greeting: hello e o rótulo department: kubernetes é membro do serviço.

  • Quando uma solicitação é enviada ao serviço na porta TCP 80, ela é encaminhada para um dos pods membros na porta TCP 8080.

Copie o manifesto para um arquivo chamado hello-kubernetes-service.yaml e crie o serviço:

kubectl apply -f hello-kubernetes-service.yaml

Veja aqui um manifesto de uma entrada:

apiVersion: extensions/v1beta1
kind: Ingress
metadata:
  name: my-ingress
spec:
  rules:
  - http:
      paths:
      - path: /*
        backend:
          serviceName: hello-world
          servicePort: 60000
      - path: /kube
        backend:
          serviceName: hello-kubernetes
          servicePort: 80

Observe que o manifesto de entrada tem dois pares serviceName, servicePort. Cada um deles (serviceName, servicePort) está associado a um serviço de back-end do GCP.

Copie o manifesto em um arquivo chamado my-ingress.yaml e crie a entrada:

kubectl apply -f my-ingress.yaml

Quando você cria uma entrada, o controlador de entrada do GKE cria um balanceador de carga HTTP(S) e o configura da maneira a seguir:

  • Quando um cliente envia uma solicitação ao balanceador de carga com o caminho de URL /, a solicitação é encaminhada para o serviço hello-world na porta 60000.

  • Quando um cliente envia uma solicitação ao balanceador de carga usando o caminho de URL /kube, a solicitação é encaminhada para o serviço hello-kubernetes na porta 80.

Aguarde cerca de cinco minutos até que o balanceador de carga seja configurado.

Veja a Entrada:

kubectl get ingress my-ingress --output yaml

A saída mostra o endereço IP externo do balanceador de carga HTTP(S).

status:
  loadBalancer:
    ingress:
    - ip: 203.0.113.1

Teste o caminho /:

curl [LOAD_BALANCER_IP]/

em que [LOAD_BALANCER_IP] é o endereço IP externo do balanceador de carga.

A saída mostra uma mensagem Hello, world!:

Hello, world!
Version: 2.0.0
Hostname: ...

Teste o caminho /kube:

curl [LOAD_BALANCER_IP]/kube

A saída mostra uma mensagem Hello Kubernetes:

Hello Kubernetes!

HTTPS entre o cliente e o balanceador de carga

Um balanceador de carga HTTP(S) atua como um proxy entre seus clientes e o aplicativo. Se você quiser aceitar solicitações HTTPS dos seus clientes, o balanceador de carga precisará ter um certificado para provar sua identidade a eles. Além disso, ele precisa ter uma chave privada para concluir o handshake HTTPS. Veja mais informações em:

Como desativar o HTTP

Se você quiser que todo o tráfego entre o cliente e o balanceador de carga use HTTPS, é possível desativar o HTTP. Para mais informações, consulte Como desativar o HTTP.

HTTPS entre o balanceador de carga e o cliente

Se o aplicativo em execução em um pod do GKE for capaz de receber solicitações HTTPS, configure o balanceador de carga para usar HTTPS quando encaminhar solicitações para o aplicativo. Para mais informações, consulte HTTPS (TLS) entre o balanceador de carga e o aplicativo.

HTTP/2 entre o cliente e o balanceador de carga

Os clientes podem usar HTTP/2 para enviar solicitações ao balanceador de carga. Nenhuma configuração é necessária.

HTTP/2 entre o balanceador de carga e o aplicativo

Se seu aplicativo em execução em um pod do GKE for capaz de receber solicitações HTTP/2, é possível configurar o balanceador de carga para usar HTTP/2 ao encaminhar solicitações para o aplicativo. Para mais informações, consulte HTTP/2 para balanceamento de carga com Entrada.

Grupos de endpoints da rede

Se o cluster for compatível com balanceamento de carga nativo de contêiner, é possível configurar o balanceador de carga para usar grupos de endpoints de rede. Para mais informações, consulte Como usar balanceamento de carga nativo de contêiner.

Resumo das anotações de entrada

kubernetes.io/ingress.allow-http
Especifica se o tráfego HTTP será permitido entre o cliente e o balanceador de carga HTTP(S). Os valores possíveis são "verdadeiro" e "falso". O padrão é "verdadeiro". Consulte Como desativar o HTTP .
ingress.gcp.kubernetes.io/pre-shared-cert
É possível fazer upload de certificados e chaves para o projeto do GCP. Use essa anotação para fazer referência aos certificados e às chaves. Consulte Como usar vários certificados SSL no balanceamento de carga HTTP(S).
kubernetes.io/ingress.global-static-ip-name
Use essa anotação para especificar que o balanceador de carga usará um endereço IP externo estático que você criou anteriormente. Consulte Endereços IP estáticos para balanceadores de carga HTTP(S).
service.alpha.kubernetes.io/app-protocols
Use essa anotação para definir o protocolo de comunicação entre o balanceador de carga e o aplicativo. Os protocolos possíveis são HTTP, HTTPS e HTTP/2. Consulte HTTPS entre o balanceador de carga e o aplicativo e HTTP/2 para balanceamento de carga com entrada.
beta.cloud.google.com/backend-config
Use esta anotação para configurar o serviço de back-end associado a servicePort. Consulte Recurso personalizado BackendConfig.
cloud.google.com/neg
Use essa anotação para especificar que o balanceador de carga usará grupos de endpoints de rede. Consulte Como usar o balanceamento de carga nativo de contêiner.

A seguir

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

Enviar comentários sobre…

Documentação do Kubernetes Engine