Como configurar o Ingress para balanceamento de carga externo

Nesta página, você verá como configurar um balanceador de carga HTTP(S) externo criando um objeto "Entrada" do Kubernetes. O objeto 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.

Antes de começar

Antes de começar, verifique se você realizou as tarefas a seguir:

Defina as configurações padrão da gcloud usando um dos métodos a seguir:

  • Use gcloud init se quiser orientações para definir os padrões.
  • Use gcloud config para definir individualmente a região, a zona e o ID do projeto.

Como usar o gcloud init

  1. Execute gcloud init e siga as instruções:

    gcloud init

    Se você estiver usando SSH em um servidor remoto, utilize a sinalização --console-only para impedir que o comando inicie um navegador:

    gcloud init --console-only
  2. Siga as instruções para autorizar a gcloud a usar sua conta do Google Cloud.
  3. Crie uma nova configuração ou selecione uma atual.
  4. Escolha um projeto do Google Cloud.
  5. Escolha uma zona padrão do Compute Engine.

Como usar o gcloud config

  • 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

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.

O único caractere curinga aceito no campo path de uma entrada é *. O caractere * precisa vir depois de uma barra (/) e ser o último caractere no padrão. Por exemplo, /*, /foo/* e /foo/bar/* são padrões válidos, ao contrário de * e /foo/*/bar.

Um padrão mais específico tem precedência sobre um menos específico. Se você tiver os padrões /foo/* e /foo/bar/*, /foo/bar/bat será usado na correspondência com /foo/bar/*.

Para mais informações sobre limitações de caminho e correspondência de padrões, consulte a documentação dos mapas de URL.

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

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.yaml 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 em um arquivo denominado hello-kubernetes-service.yaml e crie o serviço:

kubectl apply -f hello-kubernetes-service.yaml

Veja aqui um manifesto de um Ingress:

apiVersion: networking.k8s.io/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 Google Cloud.

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 o Ingress:

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, desative 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 endpoint de rede

Se o cluster for compatível com o balanceamento de carga nativo de contêiner, configure o balanceador de carga para usar grupos de endpoints de rede (NEGs, na sigla em inglês). Para mais informações, consulte Como usar balanceamento de carga nativo de contêiner.

Resumo das anotações de Entrada externa

Anotações do Ingress

Anotação Descrição
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 seu projeto do Google Cloud. 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 e estático que você criou anteriormente. Consulte Endereços IP estáticos para balanceadores de carga HTTP(S).
Anotação Descrição
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 essa anotação para configurar o serviço de back-end associado a um servicePort. Consulte Recurso personalizado BackendConfig.
cloud.google.com/neg Use essa anotação para especificar que o balanceador de carga usará grupos de endpoint de rede. Consulte Como usar o balanceamento de carga nativo de contêiner.

A seguir