Kubernetes – LoadBalancer IP externo

Neste artigo, vou explicar como configurar um endereço IP externo para um cluster Kubernetes local na sua infraestrutura. No meu caso, estou a utilizar a minha rede de teste em casa como exemplo.

Quando criamos serviços do tipo LoadBalancer num cluster, como no Azure Kubernetes Service (AKS), o LoadBalancer recebe um endereço IP externo público fornecido pela infraestrutura do Azure.

No entanto, quando estamos a executar clusters “bare-metal”, como os discutidos neste artigo, essa atribuição de endereço IP externo não acontece automaticamente. Clusters como o GKE e o AKS têm grandes infraestruturas e adquirem grandes blocos de endereços IP públicos para fornecer aos clientes. Isso não é prático para a maioria das pessoas em configurações de teste em casa. No entanto, é possível configurar o LoadBalancer com endereços IP da sua rede de teste, como “192.168.16.0/24”, e usar o NAT (Network Address Translation – Tradução de Endereços de Rede) no seu router para direcionar portas como 80/443 para o endereço IP externo do LoadBalancer, permitindo assim a comunicação da Internet para as suas aplicações.

O projeto MetalLB é a solução que permite atribuir endereços IP externos aos LoadBalancers no seu cluster de teste, e é o projeto que usaremos aqui.

O que é um LoadBalancer?

Um LoadBalancer é um distribuidor de pedidos fundamental num cluster Kubernetes. A ideia por trás de um cluster é garantir alta disponibilidade e escalabilidade horizontal. O LoadBalancer distribui os pedidos entre várias réplicas de um determinado POD. Quando a sua aplicação exige mais recursos, você simplesmente aumenta o número de réplicas. O LoadBalancer considera todas as réplicas e distribui os pedidos entre elas. Se uma delas falhar por algum motivo, as outras podem continuar a atender os pedidos dos clientes. Ele age como um proxy reverso.

Instalação e Configuração do MetalLB

O MetalLB oferece várias formas de anunciar o endereço IP externo atribuído ao LoadBalancer na rede, incluindo protocolos ARP, NDP e BGP. Neste artigo, usaremos ARP, a opção mais simples, uma vez que o nosso cluster está em casa e não exige os recursos avançados dos outros protocolos, que são mais adequados para ambientes de data center.

Instalação

Para instalar o MetalLB com a versão mais recente à data deste artigo, execute o seguinte comando no nó “kube-master”, que é o control plane do seu cluster:

kubectl apply -f https://raw.githubusercontent.com/metallb/metallb/v0.13.11/config/manifests/metallb-native.yaml

Esse comando criará os recursos necessários no seu cluster.

Neste ponto, o MetalLB está instalado no seu cluster.

Configuração

No entanto, a instalação não é suficiente; você precisa configurar o MetalLB de acordo com suas necessidades. Um passo crítico na configuração é determinar quais endereços IP serão distribuídos aos LoadBalancers. Como mencionado anteriormente, estamos a usar a rede “192.168.16.0/24” para nossas configurações de teste, mas o DHCP fornece endereços IP dinâmicos nessa faixa, de “192.168.16.150” a “192.168.16.254”. Portanto, reservaremos endereços IP de “192.168.16.60” a “192.168.16.70” para nossos LoadBalancers. Esta faixa nos permite ter 10 LoadBalancers com endereços IP externos, mais do que suficiente para nossos testes.

Para configurar o MetalLB, criamos dois manifestos que devem ser aplicados ao cluster. Você pode encontrar esses manifestos em anexo a este artigo ou criar os seus próprios.

O primeiro manifesto cria o pool de endereços que queremos distribuir:

apiVersion: metallb.io/v1beta1
kind: IPAddressPool
metadata:
  name: first-pool
  namespace: metallb-system
spec:
  addresses:
  - 192.168.16.60-192.168.16.70

O segundo manifesto configura como esses IPs serão anunciados na rede:

apiVersion: metallb.io/v1beta1
kind: L2Advertisement
metadata:
  name: example
  namespace: metallb-system
spec:
  ipAddressPools:
  - first-pool

Com esses manifestos prontos, execute os seguintes comandos para aplicá-los ao seu cluster:

kubectl apply -f ip-address-pool.yaml
kubectl apply -f l2-advertisement.yaml

Neste momento, o MetalLB está configurado e pronto para fornecer IPs aos seus LoadBalancers no pool que você configurou.

Verificação do Funcionamento

Para confirmar que tudo está a funcionar como esperado, vamos realizar um teste. Vou instalar duas aplicações e expô-las como LoadBalancers. Ambos os LoadBalancers deverão receber um endereço IP externo do pool que configuramos.

Para instalar as aplicações de teste e expô-las, execute os seguintes comandos:

kubectl create deployment hello-app1 --image=gcr.io/google-samples/hello-app:1.0
kubectl create deployment hello-app2 --image=gcr.io/google-samples/hello-app:1.0
kubectl expose deployment hello-app1 --type LoadBalancer --port 80 --target-port 8080
kubectl expose deployment hello-app2 --type LoadBalancer --port 80 --target-port 8080

Após a execução desses comandos, as aplicações estão instaladas e expostas como LoadBalancers. Você pode usar o seguinte comando para verificar o endereço IP externo atribuído a cada LoadBalancer:

kubectl get services

Isso retornará algo semelhante ao seguinte:

NAME         TYPE           CLUSTER-IP       EXTERNAL-IP     PORT(S)        AGE
hello-app1   LoadBalancer   10.104.215.113   192.168.16.60   80:31296/TCP   93s
hello-app2   LoadBalancer   10.104.150.14    192.168.16.61   80:32442/TCP   93s
kubernetes   ClusterIP      10.96.0.1        <none>          443/TCP        19h

Você pode aceder às aplicações usando o comando curl de qualquer máquina na rede “192.168.16.0/24” ou diretamente de um navegador da web:

curl http://192.168.16.60
curl http://192.168.16.61

Isso deverá retornar algo semelhante a:

Hello, world!
Version: 1.0.0
Hostname: hello-app1-6bfdbf486-x2nsl

Hello, world!
Version: 1.0.0
Hostname: hello-app2-7588bfd9-zp669

Para testar a distribuição de carga, aumente o número de réplicas para cada aplicação com os seguintes comandos:

kubectl scale --replicas=5 deployment hello-app1
kubectl scale --replicas=5 deployment hello-app2

Agora você tem cinco réplicas de cada aplicação, que serão distribuídas entre os nós do cluster. Para verificar o funcionamento, execute os seguintes comandos:

for i in {1..5}; do curl http://192.168.16.60; done
for i in {1..5}; do curl http://192.168.16.61; done

Isso mostrará que as solicitações estão a ser distribuídas entre as várias réplicas das aplicações.

Hello, world!
Version: 1.0.0
Hostname: hello-app1-6bfdbf486-dskmm
Hello, world!
Version: 1.0.0
Hostname: hello-app1-6bfdbf486-vtx7h
Hello, world!
Version: 1.0.0
Hostname: hello-app1-6bfdbf486-dpgbd
Hello, world!
Version: 1.0.0
Hostname: hello-app1-6bfdbf486-vtx7h
Hello, world!
Version: 1.0.0
Hostname: hello-app1-6bfdbf486-dskmm

Hello, world!
Version: 1.0.0
Hostname: hello-app2-7588bfd9-lp749
Hello, world!
Version: 1.0.0
Hostname: hello-app2-7588bfd9-j8xn2
Hello, world!
Version: 1.0.0
Hostname: hello-app2-7588bfd9-cwncj
Hello, world!
Version: 1.0.0
Hostname: hello-app2-7588bfd9-fgz5j
Hello, world!
Version: 1.0.0
Hostname: hello-app2-7588bfd9-fgz5j

Como podemos observar nos resultados, as solicitações estão sendo direcionadas para as várias réplicas das aplicações. É importante notar que, neste cluster específico, temos apenas dois nós (nodes), enquanto as aplicações foram dimensionadas para cinco réplicas. Isso significa que algumas réplicas podem estar no mesmo nó, o que explica a duplicação de solicitações para esses nós específicos. No entanto, quando o cluster possui um maior número de nós, as solicitações são distribuídas de forma mais uniforme entre todas as réplicas, garantindo uma melhor utilização dos recursos do cluster. Essa distribuição eficiente de solicitações é uma das vantagens do Kubernetes, especialmente em ambientes de grande escala.

A única etapa restante é configurar o seu router para redirecionar a porta 80 para o LoadBalancer, por exemplo, o “192.168.16.60”. Com essa configuração, você terá acesso à sua aplicação pela Internet. Embora em um data center, essa atribuição de endereços IP públicos ao LoadBalancer seja transparente, em configurações como a nossa, essa solução funciona bem, mesmo para muitas empresas.

Conclusão

Neste artigo, exploramos uma maneira de atribuir endereços IP aos LoadBalancers no seu cluster Kubernetes. É uma abordagem simples, adequada às necessidades específicas e à falta de um ambiente de data center para testes. No entanto, ela permite que você tenha um cluster com serviços LoadBalancer que podem ser acessados pela Internet. Isso possibilita a criação de aplicativos e serviços e a sua exposição à Internet, com a capacidade de dimensioná-los conforme necessário.