HAProxy Ingress Controller no Kubernetes: Instalação e Configuração

Em Kubernetes, um Ingress controller é utilizado para rotear tráfego externo para os serviços internos do cluster. O Ingress controller traduz as requisições recebidas de fora do cluster para os pods corretos, com base em nomes de hosts, caminhos e outras regras de roteamento. HAProxy se destaca por seu alto desempenho, baixo uso de recursos e extensas opções de configuração, oferecendo balanceamento de carga robusto, confiabilidade e escalabilidade.

O que é HAProxy Ingress?

O HAProxy Ingress controller oferece recursos avançados como roteamento de tráfego (baseado em host e caminho), terminação SSL, opções de limitação de taxa e reconfiguração dinâmica. Ele atualiza automaticamente as rotas e backends quando há mudanças no cluster. Devido a esses recursos, proporciona um tempo de resposta mais rápido, balanceamento de carga eficiente e gerenciamento de conexão confiável, permitindo manter alta disponibilidade mesmo durante horários de pico e picos inesperados.

Instalação do HAProxy Ingress Controller em Kubernetes

Nesta seção, vamos aprender como configurar o HAProxy Ingress Controller no seu cluster Kubernetes. Abordaremos uma lista de verificação rápida de pré-instalação, exploraremos os dois principais métodos de deploy (Helm e YAML manifests) e, por fim, verificaremos se nossa configuração está completa com um teste simples.

Lista de Verificação Pré-Instalação

Antes de iniciar a instalação do HAProxy Ingress, alguns pontos são cruciais. Primeiramente, é necessário ter um cluster Kubernetes em execução. Embora este guia utilize K0s, qualquer cluster Kubernetes pode ser usado. Além disso, o kubectl é essencial para a comunicação com o cluster. Por fim, um entendimento básico de Pods, Services e Ingresses é fundamental.

1. Compatibilidade da Versão do Kubernetes: Antes de instalar o HAProxy, certifique-se de que seu cluster Kubernetes esteja em uma versão suportada. Versões Kubernetes 1.20 geralmente são suportadas, mas você também pode verificar a documentação do HAProxy para garantir.
2. Funções mais recentes do Kubernetes, como definições de recursos personalizados e políticas de rede avançadas, exigirão versões mais atualizadas.

1. Acesso e Permissões

Para interagir com seu cluster, você precisará do Kubectl ou uma ferramenta CLI similar instalada e configurada em seu sistema. O comando kubectl get pods deve funcionar corretamente.

Se você estiver utilizando o Helm para realizar o deploy, certifique-se de ter a versão 3.x ou superior instalada. Ao utilizar plataformas como Rancher, verifique se o usuário ou conta de serviço possui as permissões corretas, como retenção de namespace e regras RBAC.

1. Requisitos de Rede

Certifique-se de que a solução de rede do cluster suporte o tipo de serviço que você planeja usar, como NodePort, LoadBalancer ou ClusterIP.

Para balanceamento de carga externo em uma solução on premise, você pode usar o EdgeLB. Se estiver rodando na nuvem, utilize o load balancer do seu provedor de nuvem. Se você deseja expor os serviços publicamente através do ingress, configure os registros DNS para apontar o IP externo ou nome de domínio associado ao seu cluster.

Etapas de Instalação

Existem duas maneiras principais de instalar o HAProxy Ingress Controller:

• Utilizando o Helm (recomendado para upgrades mais simples e fáceis alterações de configuração via values.yaml).
• Aplicando YAML manifests diretamente (oferece mais controle granular, mas pode ser mais manual para gerenciar as atualizações).

Opção A: Usando Helm

1. Adicione o repositório Helm do HAProxy Ingress:

O comando acima adiciona o repositório Helm oficial do HAProxy Ingress ao seu cliente Helm local e, em seguida, atualiza o cliente local para as versões de gráfico mais recentes.

1. Configure os parâmetros necessários do values.yaml:
2. Certificados SSL: Se você deseja gerenciar o SSL no nível do Ingress, você deve especificar ou montar os certificados usando seus valores Helm.
3. Configurações de Balanceamento de Carga: Você pode configurar seu algoritmo de balanceamento de carga preferido, como round robin ou least connections, ou qualquer outra opção.
4. Tipo de Serviço: Você pode ajustar se o serviço para o controller é um LoadBalancer, NodePort ou um ClusterIP. A escolha que você faz impacta como o tráfego externo é roteado.

1. Instale com o Helm:

Execute o comando abaixo para implantar o HAProxy Ingress Controller em seu cluster:

Este comando instala o gráfico, aplica as configurações do seu values.yaml. Substitua <release-name> e <your-namespace> conforme necessário.

Opção B: Usando YAML Manifests

1. Obtenha manifests oficiais ou da comunidade:
2. Este é o YAML manifest oficial do repositório GitHub do HAProxy.
3. O comando criará um namespace haproxy-controller e implantará os Pods do HAProxy Ingress Controller dentro dele.

Criando a IngressClass

O Kubernetes recomenda criar um recurso IngressClass para identificar qual ingress controller usar. Isso cria um arquivo chamado ingressclass.yaml.

Você pode aplicá-lo com:

Isso declara uma IngressClass com o nome haproxy, que você pode referenciar na definição do Ingress.

Validando a Instalação

1. Confirme Pods, Services e Deployments:
   a. Para confirmar se o HAProxy Ingress Controller está rodando corretamente:
   b. Execute kubectl get pods --namespace haproxy-controller para listar todos os pods do HAProxy Controller.

Você pode ver pelo menos um pod em estado Running para o HAProxy Ingress Controller.

1. Execute kubectl get service --namespace haproxy-controller para verificar os Services associados ao HAProxy Controller.

Se precisar de mais detalhes sobre os pods individuais, execute kubectl describe pods --namespace haproxy-controller. Use kubectl get pods,svc.deploy -n <your-namespace> para garantir que os Pods do HAProxy Ingress Controller estejam rodando sem erros.

Certifique-se de que os Pods estejam em um estado “Running” sem erros. Verifique o tipo de serviço, External-IP e PORTS para ver como o tráfego é roteado.

Na próxima seção, vamos processar algumas configurações avançadas, como SSL offloading, regras de roteamento personalizadas e ajuste de desempenho. Por enquanto, dominamos o básico e, portanto, podemos começar a rotear o tráfego externo para o nosso cluster Kubernetes facilmente.

Verificando os Services

Você pode verificar se o serviço é do tipo NodePort e está expondo as portas para o HTTP (porta 80) e HTTPS (porta 443), além da verificação de saúde e a porta de estatísticas 1024.

Descrevendo os Pods

Para informações mais detalhadas, você também pode descrever os pods do HAProxy Ingress:

Revise a saída para garantir que não haja erros ou avisos. Você deve conseguir ver as entradas indicando o pull bem-sucedido da imagem do HAProxy e que o container está em estado Running.

Exemplo de HAProxy Ingress

Para usar a HAProxy IngressClass em seus serviços, você deve criar um recurso Ingress que referencie a IngressClass. Aqui está um exemplo:

Ao especificar ingressClassName:haproxy, você instrui o Kubernetes a rotear o tráfego para o host/caminho para o HAProxy Ingress Controller.

Configurando o HAProxy Ingress Controller com Exemplo

Nesta seção, vamos aprender como configurar seu HAProxy Ingress Controller. Primeiro, vamos percorrer algumas configurações fundamentais, como:

• criar recursos Ingress
• aplicar certificados SSL
• escolher o algoritmo de balanceamento de carga certo
• Em seguida, vamos avançar para:
• roteamento sofisticado
• Anotações
• Configurações personalizadas
• Estratégias de monitoramento

HAProxy Ingress Controller

Recursos Ingress

Propósito: Os recursos Ingress definem: “como o tráfego externo é roteado para os serviços internos do Kubernetes”.

Você especificará os nomes de host, caminhos e qual serviço de backend cada caminho deve encaminhar o tráfego.

Regras de Host: Uma manifest geral de Ingress inclui spec.rules.host como hello-world.com. As requisições que atingem hello-world.com são então roteadas de acordo com as regras que você define.

Caminhos e Serviços de Backend

Sob as rules, você deve declarar os caminhos específicos como / ou /api e mapeá-los para diferentes serviços e portas no cluster.

Por exemplo, o tráfego para /api pode ir para api-service:80, em contraste com /, que pode ir para frontend-service.

Agora, vamos considerar um exemplo de um Pod e um Service que você pode usar junto com seu ingress em um cenário da vida real.

Um Pod: Executa o container nginxdemos/hello na porta 80.

Um Service: Este serviço tem como alvo o Pod usando o app: hello-world label.

Um Ingress: O ingress roteia o tráfego de hello-world.example.com para hello-world-service na porta 80.

Nosso HAProxy ingress então roteará o tráfego para este serviço.

Passos para rodar localmente em uma máquina Debian ou Ubuntu

1. Instale as ferramentas Kubernetes:
   a. Certifique-se de que você tenha um cluster Kubernetes rodando.
   b. Certifique-se de que o kubectl esteja instalado e configurado para que kubectl get pods funcione.
2. Aplique o YAML ao seu Cluster:

Isso criará os recursos Pod, Service e Ingress.

1. Atualize o /etc/hosts: este é um truque de DNS local.
2. Como a regra ingress usa o nome de domínio hello-world.example.com, você pode facilmente mapear este domínio para o endereço IP do seu cluster em sua máquina Debian.
3. Para testes locais, encontre o endereço IP no qual seu cluster está rodando.

Suponha que você descubra que o IP é 192.168.32.54, então edite o arquivo /etc/hosts em sua máquina Debian ou Ubuntu da seguinte forma:

Observe que 192.168.49.2 é o IP do seu cluster Kubernetes.

1. Verificando o Ingress:
   Verifique se o HAProxy Ingress controller está rodando.

Verifique o Ingress criado:

Observe que:

• O nome do ingress é hello-ingress.
• A classe está definida como haproxy.
• O host é hello-world.example.com.

Identificando o NodePort

Como o HAProxy Ingress controller está rodando como um NodePort, você precisa do número da porta para enviar o tráfego externo para o cluster. Execute o comando abaixo:

A partir daqui, você pode ver que a porta 30337 é o nodeport que está mapeado para a porta 80 do Ingress Controller.

1. Enviando uma requisição de teste:

Vamos supor que o endereço IP do seu nó Kubernetes seja 172.16.51.8. Você pode testar se o roteamento ingress está funcionando enviando uma requisição curl que inclua o cabeçalho host da seguinte forma:

Se tudo estiver configurado corretamente, você deverá ver a saída da página de demonstração do Nginx do Pod hello-world.

Abra o browser na sua máquina Debian e vá para ou use o curl:

Você pode ver a resposta vindo do seu cluster Kubernetes.

Configuração SSL/TLS

Proteger o tráfego usando SSL/TLS é uma etapa importante nas implementações de produção.

1. Gerando e importando certificados:

• Você pode gerar o certificado Let’s Encrypt usando um Cert Manager ou um processo standalone.
• Alternativamente, você também pode importar seus certificados existentes de uma Autoridade Certificadora.
• Os certificados são normalmente armazenados como um recurso Secret do Kubernetes.

1. Configurando HTTPS & Redirecionamentos:

• Atualize o Ingress controller para referenciar o secret TLS.
• Force o HTTPS usando anotações, como haproxy.org/ssl-redirect: “true”.
• Isso garante que todo o tráfego HTTP seja automaticamente redirecionado para HTTPS.

Exemplo

Algoritmos de Balanceamento de Carga

Por padrão, o HAProxy usa o algoritmo round-robin, que envia as requisições para cada serviço de backend por sua vez.

Se houver 4 backends (a, b, c, d), o algoritmo round robin primeiro enviará a requisição para a, depois b, depois c e depois d, e então novamente para a, ciclando assim por todos os 4 serviços de backend.

Dependendo do seu ambiente, você pode preferir outros algoritmos, como:

• Least Connections: Envia uma nova requisição para o servidor que tem o menor número de conexões ativas. Esta é uma boa escolha para distribuir a carga uniformemente.
• Source IP Hash/ Sticky Sessions: Útil se você quer que um usuário atinja consistentemente o mesmo servidor de backend.
• Algoritmos Avançados: Weighted round robin, aleatório ou algoritmos especializados de verificação de saúde também estão disponíveis para casos de uso específicos.
• Você pode configurar isso no ConfigMap ou via anotações para o HAProxy Ingress Controller.

O trecho acima instrui o HAProxy a usar o algoritmo leastconn em todos os backends onde for aplicável.

Recursos Avançados de Roteamento

Roteamento Baseado em Caminho

Em um ambiente de microsserviços, você frequentemente divide sua aplicação em múltiplos componentes, por exemplo: /api, /admin, /auth.

Com HAProxy Ingress

Mapeamento de Múltiplos Contextos: Cada Caminho em um único recurso Ingress pode apontar para um serviço interno diferente.

Caso de Uso Comum: Um front-end que é servido por um react ou angular SPA (/), uma API backend em (/api) e um painel de administração (/admin).

Roteamento Baseado em Host

Às vezes, você tem múltiplos domínios que estão compartilhando um único cluster Kubernetes, por exemplo: app1.example.com e app2.example.com.

As regras baseadas em host permitem dividir o tráfego com base no nome de domínio.

Cada domínio tem sua própria regra que está apontando para seu próprio serviço de backend distinto.

TCP VS HTTP Roteamento

• Roteamento HTTP/HTTPS: O cenário mais comum é usar os recursos L7 (ou seja, a camada de aplicação), como roteamento baseado em caminho, cabeçalhos e cookies.
• Roteamento TCP: Aplicações como databases, protocolos TCP customizados e outros podem ser roteados na camada 4.
• O HAproxy é configurado para encaminhar o tráfego TCP sem inspecionar a camada HTTP.
• Se você quiser expor um serviço de database externamente ou fornecer portas personalizadas, você pode configurar um recurso ingress TCP.
• Isso geralmente é feito usando CRDs especializados ou configuração no gráfico HAProxy Ingress.

Anotações e Configuração Personalizada

O HAProxy suporta uma variedade de anotações que ajustam o comportamento no nível da rota ou no nível do controller.

Ajuste Fino de Timeouts, Tamanhos de Buffer e Limites de Conexão

• Timeouts: Você pode definir por quanto tempo o HAProxy esperará por uma resposta HTTP antes de fechar a conexão ou retornar um erro. Por exemplo: haproxy.org/backend-timeout: “30000” em milissegundos.
• Zonas de Buffer: Isso é útil para cabeçalhos grandes e payloads grandes.
• Limites de Conexão: Protege seus serviços de backend limitando o número total de conexões que ele pode lidar.

Usando um ConfigMap para Configurações Globais

Você pode definir algumas configurações globais do HAProxy via ConfigMap:

Cada chave no ConfigMap pode sobrescrever os padrões para coisas como timeouts, SSL ciphers e formatos de log.

Mesclando Seções de Configuração HAProxy Personalizadas

Se você precisa de customização avançada como Lua scripts, logging especializado ou reescrever as regras.

Usando HAProxy Ingress você pode adicionar ou mesclar trechos de configuração como este:

As seções mescladas são anexadas à configuração final do HAProxy, o que lhe dá flexibilidade sem reescrever o arquivo inteiro.

Monitoramento e Observabilidade

Uma pilha de observabilidade sólida significa que você pode detectar e solucionar os erros precocemente e manter alta disponibilidade.

Integrando com Prometheus e Grafana

Prometheus pode extrair as métricas que são expostas pelo HAProxy Ingress Controller. Você pode configurar o Ingress controller para exportar as métricas para um endpoint como 8080/metrics.

Grafana dashboards permite visualizar os dados como taxas de requisição, tempos de resposta e outros dados.

Métricas chave para Monitorar:

• request_rate
• http_response_status
• backend_up
• latency

Para garantir a segurança do seu cluster Kubernetes, é crucial estar atento às atualizações de segurança, como as oferecidas pela série Xiaomi 15, que garante atualizações por 6 anos. Além disso, otimizar o desempenho da sua rede pode ser alcançado com um roteador NETGEAR Nighthawk Tri-Band Wi-Fi 7, que está disponível com desconto. Para complementar a segurança, considere utilizar um gerenciador de senhas do Google para facilitar a exclusão de credenciais salvas e proteger suas informações.

Este conteúdo foi auxiliado por Inteligência Artificial, mas escrito e revisado por um humano.

Via dev.to