Como configurar o balanceamento de carga HTTP com a entrada

Neste tutorial, você aprenderá a configurar o recurso de entrada para executar um aplicativo da Web por trás de um balanceador de carga HTTP.

Contexto

O GKE oferece compatibilidade integrada com dois tipos de balanceamento para um aplicativo acessível ao público:

  1. É possível criar balanceadores de carga TCP/UDP especificando type: LoadBalancer em um manifesto de recurso de serviço. Mesmo que um balanceador de carga TCP funcione para servidores HTTP da Web, eles não são projetados para encerrar o tráfego HTTP(S), já que não estão cientes de solicitações HTTP(S) individuais. O GKE não configura qualquer verificação de integridade para balanceadores de carga TCP/UDP. Consulte o tutorial do livro de visitas para ver um exemplo desse tipo de balanceador de carga.

  2. É possível criar balanceadores de carga HTTP(S) usando um recurso de entrada. Balanceadores de carga HTTP(S) são projetados para encerrar solicitações HTTP(S) e são responsáveis pelas melhores decisões de balanceamento de carga contextual. Eles oferecem recursos como mapas URL personalizáveis e encerramento de TLS. O GKE configura automaticamente verificações de integridade para balanceadores de carga HTTP(S).

Se você estiver expondo um serviço HTTP(S) hospedado no GKE, o HTTP(S) é o método recomendado para balanceamento de carga.

Antes de começar

Siga estas etapas para ativar a API Kubernetes Engine:
  1. Acesse a página do Kubernetes Engine no Console do Google Cloud Platform.
  2. Crie ou selecione um projeto.
  3. Aguarde a ativação da API e dos serviços relacionados. Isso pode levar alguns minutos.
  4. Verifique se o faturamento foi ativado no projeto do Google Cloud Platform.

    Saiba como ativar o faturamento

Instale as ferramentas de linha de comando a seguir usadas neste tutorial:

  • gcloud é usado para criar e excluir clusters do Kubernetes Engine. gcloud está incluído no SDK do Google Cloud.
  • kubectl é usado para gerenciar o Kubernetes, o sistema de orquestração de cluster usado pelo Kubernetes Engine. É possível instalar kubectl usando gcloud:
    gcloud components install kubectl

Definir padrões para a ferramenta de linha de comando gcloud

Para poupar tempo, em vez de digitar o ID do projeto e as opções de zona do Compute Engine na ferramenta de linha de comando gcloud, defina os padrões:
gcloud config set project [PROJECT_ID]
gcloud config set compute/zone [COMPUTE_ENGINE_ZONE]

Criar um cluster de contêiner

Crie um cluster de contêiner chamado loadbalancedcluster executando:

gcloud container clusters create loadbalancedcluster

Etapa 1: implantar um aplicativo da Web

Crie uma implantação usando a imagem de amostra do contêiner de aplicativo da Web para detectar em um servidor HTTP na porta 8080:

Para criar a implantação, faça o download do web-deployment.yaml e aplique o recurso ao cluster:

kubectl apply -f web-deployment.yaml

Etapa 2: publicar a implantação internamente como um serviço

Crie um recurso de serviço para tornar a implantação do web acessível dentro do seu cluster de contêiner.

Para criar a implantação, faça o download do web-service.yaml e aplique o recurso ao cluster:

kubectl apply -f web-service.yaml

Quando você cria um serviço do tipo NodePort com esse comando, o GKE o disponibiliza em um número de porta alto selecionado aleatoriamente (por exemplo, 32640) em todos os nós do cluster.

Verifique se o serviço foi criado e se uma porta de nó foi alocada:

kubectl get service web
Saída:
NAME      TYPE       CLUSTER-IP      EXTERNAL-IP   PORT(S)          AGE
web       NodePort   10.35.245.219   <none>        8080:32640/TCP   5m

Na saída de exemplo acima, a porta do nó para o serviço do web é 32640. Além disso, note que não há IP externo alocado para esse serviço. Como os nós do GKE não podem ser acessados externamente por padrão, criar esse serviço não faz com que o aplicativo possa ser acessado pela Internet.

Para que o aplicativo de servidor da Web HTTP(S) possa ser acessado publicamente, crie um recurso Ingress.

Etapa 3: criar um recurso de entrada

A entrada é um recurso do Kubernetes que encapsula um conjunto de regras e configurações para encaminhar tráfego HTTP(S) externo aos serviços internos.

No GKE, a entrada é implementada usando o Cloud Load Balancing. Quando você cria uma entrada no cluster, o GKE cria um balanceador de carga HTTP(S) e o configura para encaminhar tráfego para o aplicativo.

A entrada do Kubernetes é um recurso Beta. Isso significa que a forma como você descreve o objeto dela está sujeita a alterações, mas os balanceadores de carga do Cloud provisionados pelo GKE para implementar a entrada estão prontos para produção.

O arquivo de configuração a seguir define um recurso de entrada que direciona o tráfego para seu serviço web:

apiVersion: extensions/v1beta1
kind: Ingress
metadata:
  name: basic-ingress
spec:
  backend:
    serviceName: web
    servicePort: 8080

Para implantar esse recurso de entrada, faça o download de basic-ingress.yaml e execute:

kubectl apply -f basic-ingress.yaml

Depois que você implanta esse manifesto, o Kubernetes cria um recurso de entrada no cluster. O controlador de entrada em execução no cluster é responsável por criar um balanceador de carga HTTP {S} para rotear todo o tráfego HTTP externo (na porta 80) para o serviço NodePort do web que você expôs.

Etapa 4: acessar o aplicativo

Para descobrir o endereço IP externo do balanceador de carga que disponibiliza o aplicativo, execute:

kubectl get ingress basic-ingress
Saída:
NAME            HOSTS     ADDRESS         PORTS     AGE
basic-ingress   *         203.0.113.12    80        2m

Aponte seu navegador para o endereço IP externo do aplicativo e veja uma resposta HTTP de texto simples como esta:

Hello, world!
Version: 1.0.0
Hostname: web-6498765b79-fq5q5

Acesse Balanceamento de carga no Console do GCP e verifique os recursos de rede criados pelo controlador da entrada.

Etapa 5: configurar um endereço IP estático (opcional)

Quando você publica um servidor da Web em um nome de domínio, precisa que o endereço IP externo de um aplicativo seja um IP estático que não seja alterado.

Por padrão, o GKE aloca endereços IP externos temporários de aplicativos HTTP expostos por meio de uma entrada. Endereços temporários estão sujeitos a alterações. Para um aplicativo da Web que você está planejando há bastante tempo, use um endereço IP externo estático.

Note que, depois de configurar um IP estático para o recurso do Ingress, a exclusão do Ingress não excluirá o endereço IP estático associado a ele. Certifique-se de limpar os endereços IP estáticos configurados se você não planeja usá-los novamente.

Opção 1: converter endereços IP atuais temporários em estáticos

Se você já tem uma entrada implementada, é possível converter o endereço IP atual temporário do aplicativo para estático reservado sem alterar o endereço IP externo. Basta acessar a seção Endereços IP externos no Console do GCP.

Opção 2: reservar um novo endereço IP estático

Reserve um endereço IP externo estático com o nome web-static-ip executando:

gcloud compute addresses create web-static-ip --global

Agora configure o recurso de entrada atual para usar o endereço IP reservado. Substitua o conteúdo do manifesto basic-ingress.yaml pelo manifesto a seguir:

apiVersion: extensions/v1beta1
kind: Ingress
metadata:
  name: basic-ingress
  annotations:
    kubernetes.io/ingress.global-static-ip-name: "web-static-ip"
spec:
  backend:
    serviceName: web
    servicePort: 8080

Essa alteração adiciona uma anotação na entrada para usar o recurso de IP estático chamado web-static-ip. Para aplicar essa modificação à entrada atual, execute o comando a seguir:

kubectl apply -f basic-ingress.yaml

Execute kubectl get ingress basic-ingress e aguarde até que o endereço IP de seu aplicativo seja alterado para usar o endereço IP reservado do recurso web-static-ip.

A atualização do recurso de entrada atual, a reconfiguração do balanceador de carga e a propagação das regras de balanceamento de carga em todo o mundo podem demorar alguns minutos. Após a conclusão da operação, o GKE libera o endereço IP temporário anteriormente alocado ao aplicativo.

Etapa 6: como disponibilizar vários aplicativos em um balanceador de carga (opcional)

Execute vários serviços em um único balanceador de carga e IP público configurando regras de encaminhamento no Ingress. Com a hospedagem de vários serviços na mesma entrada, você evita a criação de mais balanceadores de carga, que são recursos faturáveis, para cada serviço publicado na Internet.

Crie outra implantação de servidor da Web com a versão 2.0 do mesmo aplicativo da Web.

Faça o download do web-deployment-v2.yaml e aplique o recurso ao cluster:

kubectl apply -f web-deployment-v2.yaml

Em seguida, exponha a Implantação do web2 internamente ao cluster em um serviço NodePort chamado .

Faça o download do web-service-v2.yaml e aplique o recurso ao cluster:

kubectl apply -f web-service-v2.yaml

O manifesto a seguir descreve um recurso de entrada que:

  • roteia as solicitações com o caminho começando com /v2/ para o serviço web2
  • encaminha todas as outras solicitações para o serviço web
apiVersion: extensions/v1beta1
kind: Ingress
metadata:
  name: fanout-ingress
spec:
  rules:
  - http:
      paths:
      - path: /*
        backend:
          serviceName: web
          servicePort: 8080
      - path: /v2/*
        backend:
          serviceName: web2
          servicePort: 8080

Para implantar esse manifesto, salve-o em um fanout-ingress.yaml e execute:

kubectl create -f fanout-ingress.yaml

Quando a entrada for implantada, execute kubectl get ingress fanout-ingress para descobrir o endereço IP público do cluster.

Em seguida, acesse o endereço IP para ver se os dois aplicativos podem ser acessados no mesmo balanceador de carga:

  • Acesse http://<IP_ADDRESS>/ e observe que a resposta contém Version: 1.0.0 (já que a solicitação é encaminhada para o serviço web)
  • Acesse http://<IP_ADDRESS>/v2/ e observe que a resposta contém Version: 2.0.0 (já que a solicitação é encaminhada para o serviço web2)

A única correspondência de padrão curinga compatível para o campo path na entrada do GKE é por meio do caractere *. Por exemplo, é possível ter regras com campos path como /* ou /foo/bar/*. Consulte a documentação URL Maps para as limitações path.

Comentários

Por padrão, a entrada executa uma verificação de integridade periódica. Para fazer isso, realiza uma solicitação GET no caminho / para determinar a integridade do aplicativo. A resposta esperada é HTTP 200. Se você quiser verificar um caminho diferente ou esperar um código de resposta diferente, poderá usar um caminho de verificação de integridade personalizado.

A entrada é compatível com casos de uso mais avançados, como os abaixo:

  • Hospedagem virtual baseada em nome: use a entrada para reaproveitar o balanceador de carga em vários nomes de domínio, subdomínios e para expor vários serviços em um único endereço IP e balanceador de carga. Confira os exemplos de fanout simples e hospedagem virtual baseada em nome para saber como configurar a entrada para essas tarefas.

  • Encerramento HTTPS: é possível configurar a entrada para encerrar o tráfego HTTPS usando o Cloud Load Balancer.

Quando uma entrada é excluída, os recursos associados são limpos automaticamente pelo controlador dele, com exceção dos endereços IP estáticos reservados.

Como fazer a limpeza

Para evitar cobranças dos recursos usados neste tutorial na conta do Google Cloud Platform:

  1. Exclua a Entrada: com essa opção, o endereço IP externo temporário e os recursos de balanceamento de carga associados ao aplicativo são desalocados:

    kubectl delete ingress basic-ingress

    Se você seguiu a "Etapa 6", exclua o Ingress. Basta executar:

    kubectl delete ingress fanout-ingress

  2. Exclua o endereço IP estático: execute apenas se tiver seguido a Etapa 5.

    • Se você tiver seguido a "Opção 1" na Etapa 5 para converter um endereço IP temporário atual em IP estático, acesse o Console do GCP para excluir o IP estático.

    • Se você tiver seguido "Opção 2" na Etapa 5, execute o comando a seguir para excluir o endereço IP estático:

      gcloud compute addresses delete web-static-ip --global
  3. Exclua o cluster: assim são excluídos os nós do Compute do cluster de contêiner e outros recursos, como as implantações:

    gcloud container clusters delete loadbalancedcluster

A seguir

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

Enviar comentários sobre…

Tutoriais do Kubernetes Engine