Como configurar a Entrada para balanceamento de carga externo

Nesta página, você aprende a configurar um balanceador de carga HTTP(S) externo criando um objeto de 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:

Verifique se você ativou a API Google Kubernetes Engine.

Ativar a API Google Kubernetes Engine

Verifique se o SDK do Cloud está instalado.

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

Se você receber o erro One of [--zone, --region] must be supplied: Please specify location, conclua esta seção.

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
```
Siga as instruções para autorizar a gcloud a usar sua conta do Google Cloud.
Crie uma nova configuração ou selecione uma atual.
Escolha um projeto do Google Cloud.
Escolha uma zona padrão do Compute Engine para clusters zonais ou uma região para clusters regionais ou de Autopilot.

Observação: para modificar essas configurações padrão nos comandos gcloud, use as sinalizações --project, --zone e --region.

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 de Autopilot ou 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
```

Observação: para modificar as configurações padrão nos comandos gcloud, use as sinalizações --project, --zone e --region.

Você precisa ter um cluster do GKE no seu projeto com o complemento de balanceamento de carga HTTP(S) ativado:

Console

Acesse o menu do Google Kubernetes Engine no Console do Cloud.

Acesse o menu do Google Kubernetes Engine
Clique no nome do cluster que você quer modificar.
Em Rede, no campo Balanceamento de carga HTTP, clique em Editar balanceamento de carga HTTP.
Marque a caixa de seleção Ativar balanceamento de carga HTTP.
Clique em Salvar alterações.

gcloud

gcloud container clusters update cluster-name --update-addons=HttpLoadBalancing=ENABLED

em que cluster-name é o nome do cluster.

Vários serviços de back-end

Um balanceador de carga HTTP(S) externo fornece um endereço IP estável que pode ser usado para encaminhar solicitações a uma variedade de serviços de back-end.

Neste exercício, você configura um balanceador de carga HTTP(S) externo para fazer o encaminhamento de solicitações para diferentes serviços de back-end, dependendo do caminho do 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:

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

Como criar uma implantação

Veja aqui um manifesto de um Deployment:

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

Crie um serviço

Veja aqui um manifesto para um Service que expõe seu primeiro Deployment:

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 este 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 Service:

kubectl apply -f hello-world-service.yaml

Como criar uma segunda implantação

Veja aqui um manifesto para um segundo Deployment:

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

Como criar um segundo serviço

Veja aqui um manifesto para um Service que expõe seu segundo Deployment:

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 este 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

Como criar um Ingress

Veja aqui um manifesto de uma Entrada:

apiVersion: networking.k8s.io/v1beta1
kind: Ingress
metadata:
  name: my-ingress
  annotations:
    # If the class annotation is not specified it defaults to "gce".
    kubernetes.io/ingress.class: "gce"
spec:
  rules:
  - http:
      paths:
      - path: /*
        backend:
          serviceName: hello-world
          servicePort: 60000
      - path: /kube
        backend:
          serviceName: hello-kubernetes
          servicePort: 80

Para os fins deste exercício, estes são os pontos importantes que você precisa entender sobre esse manifesto de entrada:

Há duas classes de Entrada disponíveis para a Entrada do GKE. A classe gce implanta um balanceador de carga externo, e a classe gce-internal implanta um balanceador de carga interno. Recursos de entrada sem uma classe especificada por padrão como gce.
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 *, /foo/bar* 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.
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ê faz isso, o controlador de entrada do GKE cria um balanceador de carga HTTP(S) externo e faz a configuração do balanceador desta forma:

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.

Como testar o balanceador de carga HTTP(S) externo

Para testar o balanceador de carga HTTP(S) externo:

Veja a Entrada:

kubectl get ingress my-ingress --output yaml

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

status:
  loadBalancer:
    ingress:
    - ip: 203.0.113.1

Teste o caminho /:
```
curl load-balancer-ip/
```
Substitua load-balancer-ip pelo 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) externo 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 a identidade dele aos clientes. 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 aplicativo

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, recomendamos usar grupos de endpoints de rede (NEGs, na sigla em inglês). Para clusters do GKE 1.17 e posteriores e em determinadas condições, o balanceamento de carga nativo de contêiner é padrão e não requer uma anotação de serviço cloud.google.com/neg: '{"ingress": true}' explícita.

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 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).
networking.gke.io/v1beta1.FrontendConfig	Use esta anotação para personalizar a configuração do balanceador de carga voltada para o cliente. Para mais informações, consulte Recursos de Entrada.

Anotações de serviço relacionadas à Entrada

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. Para mais informações, consulte Recursos de Entrada.
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

Leia a visão geral do Ingress para balanceamento de carga HTTP(S) no GKE.
Faça o tutorial sobre Como configurar o balanceamento de carga HTTP com a Entrada.
Leia uma visão geral conceitual dos serviços no GKE.