O que é um controlador de ingresso?
Um controlador de entrada é um componente que permite aos usuários gerenciar e controlar o acesso de serviços dentro de seu cluster Kubernetes. O controlador de ingresso possui dois elementos principais:
- O recurso de entrada – É um objeto da API Kubernetes que define as regras para rotear o tráfego dos serviços no cluster com base no nome do host e nos caminhos especificados.
- O controlador de entrada – É um componente de software como HAProxy, Traefik ou NGINX que implementa as regras especificadas no recurso de entrada. Ele configura o balanceador de carga para lidar com o tráfego com base nas alterações feitas nos objetos de entrada.
Como usar o HAProxy como controlador de entrada no ambiente Kubernetes
Tendo entendido o que é um controlador de ingresso e por que você precisa dele, a próxima tarefa é abordar as etapas para usá-lo. Para o nosso caso, configuramos o HAProxy como nosso controlador de entrada seguindo as etapas fornecidas.
N/B: Certifique-se de ter seu cluster Kubernetes instalado e funcionando. Em seguida, proceda da seguinte forma.
Etapa 1: inicie seu cluster Kubernetes
Existem diferentes maneiras de configurar e iniciar um cluster Kubernetes. Para este guia, usamos Minikube. É uma ferramenta que oferece uma maneira simplista de implantar o Kubernetes dentro de uma máquina virtual ou Docker, especialmente se você tiver o Kubernetes localmente em sua máquina.
Consulte o Documentação do Minikube nos comandos de instalação a serem usados em sua plataforma. Para este caso, executamos uma arquitetura Linux “x64” estável e executamos os seguintes comandos:
$ enrolar -ISTO https: // storage.googleapis.com / minikubo / lançamentos / mais recente / minikube-linux-amd64
$ sudo instalar minikube-linux-amd64 / usr / local / caixa / minikubo
O primeiro comando captura o binário Minikube estável mais recente, enquanto o segundo comando instala e move o binário para o caminho especificado.
Depois de instalar o Minikube, inicie-o para abrir o cluster.
$ início do minikube
Você deve então ter o kubectl instalado para acessar o cluster. No entanto, você pode usar a versão kubectl disponível no Minikube. Por exemplo, para verificar os detalhes dos pods em execução, você executa o comando “kubectl” da seguinte forma:
$ minikube kubectl -- obter vagens -ADessa forma, você não precisa ter o kubectl instalado. O (-) sinaliza que os comandos são para kubectl, não para Minikube.
Etapa 2: crie um namespace
A segunda etapa envolve a criação de um namespace dedicado para o controlador de entrada. Chamamos o namespace de “haproxy-controller”.
Etapa 3: criar e implantar o controlador de entrada HAProxy
A forma como você cria o controlador de entrada depende do que você deseja alcançar. Por exemplo, você pode criar um controlador de entrada HAProxy para rotear um tráfego HTTP dependendo do nome do host solicitado. Nesse caso, comece acessando seu servidor DNS e criando um registro “A” para mapear o nome do host de destino para o seu cluster.
Depois de ter o registro “A” correto, crie o arquivo YAML do controlador de entrada conforme mostrado na imagem a seguir. Na primeira seção, criamos um recurso de implantação que usa a imagem de contêiner Docker “jmalloc/echo-server” como nosso exemplo.
Na segunda seção do arquivo YAML, criamos o recurso Service que é mapeado com base no nome do host solicitado no controlador de ingresso criado na etapa 4.
Salve o arquivo e implante-o em seu cluster usando kubectl. Fazemos referência ao Minikube kubectl executando o seguinte comando para o nosso caso. Nosso controlador de entrada HAProxy é “linuxhint-jmaildeployment.yaml”.
$ minikube kubectl -- aplicar -f < nome do arquivo > 
Depois de obter uma saída mostrando que o serviço foi criado, você poderá verificar ainda mais se ele foi implantado usando o seguinte comando:
$ minikube kubectl -- obter vagens --namespace controlador haproxy 
Certifique-se de usar o namespace correto criado na etapa 1. Você obterá uma saída que confirma que o serviço está disponível, o que significa que a implantação foi bem-sucedida.
Etapa 4: criar e implantar um recurso do Ingress
Crie outro arquivo YAML que atue como recurso de entrada que contém as regras de como o HAProxy deve rotear seu tráfego. Certifique-se de usar o nome de domínio (host) correto que você está direcionando e ajuste a nomenclatura e a porta desejada para aceitar o tráfego de entrada.
Salve o arquivo de recurso de entrada HAProxy e implante-o como fizemos com o controlador.
$ minikube kubectl -- aplicar -f < nome do arquivo >Nomeamos nosso recurso de entrada como “linuxhint-ingresscontroller.yaml”.
É isso! Com o comando a seguir, você pode verificar se o controlador de entrada HAProxy está funcionando verificando a porta atribuída ao NodePort.
$ minikube kubectl -- obter serviço haproxy-kubernetes-ingress --namespace controlador haproxyPara este caso, é atribuída a porta 32448. Você pode acessar o serviço criado através da porta e verificar seu status.
Com isso, você conseguiu usar o HAProxy como controlador de ingresso em um ambiente Kubernetes.
Conclusão
Um controlador de entrada permite definir como lidar com o tráfego para seu cluster com base nas regras definidas em seu arquivo de recursos de entrada. HAProxy é um controlador de entrada confiável que você pode usar em um cluster Kubernetes, e esta postagem abordou quais etapas você deve seguir para usá-lo. Experimente e aproveite o uso do HAProxy como seu controlador de entrada.