Como é implementado o balanceamento de carga no…

O balanceamento de carga no Kubernetes é implementado em vários níveis:

Service (ao nível do Kube-proxy):
- Cada Pod no Service recebe um endereço IP único.
- O Kube-proxy, que funciona em cada nó, monitora as alterações no Service e EndpointSlice.
- Configura regras de redirecionamento de tráfego (iptables, ipvs) para o IP do cluster do Service.
- O tráfego dirigido ao IP do cluster do Service é distribuído entre os Pods desse Service de acordo com o algoritmo selecionado (padrão Round Robin).
- Existem dois modos de operação para o Kube-proxy: iptables (padrão, baseado no Linux netfilter) e ipvs (mais eficiente para grandes clusters, baseado na Virtual Server API).
```
apiVersion: v1
kind: Service
metadata:
  name: my-service
spec:
  selector:
    app: my-app # Seleciona Pods com a etiqueta app: my-app
  ports:
    - protocol: TCP
      port: 80 # Porta no Service
      targetPort: 8080 # Porta nos Pods
```
Ingress (ao nível L7):
- Funciona como um ponto de entrada único para o balanceamento de carga HTTP/S externo.
- Requer um controlador de Ingress (por exemplo, Nginx Ingress Controller) para implementar as regras.
- Redireciona o tráfego para um Service específico dentro do cluster com base no caminho URL, nome do host e outras regras L7.
- Permite implementar várias estratégias de balanceamento, terminação SSL, hospedagem virtual baseada em nomes.
```
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: my-ingress
spec:
  rules:
  - host: myapp.example.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: my-service # Redireciona o tráfego para este Service
            port:
              number: 80
```
Service LoadBalancer (ao nível do provedor de nuvem):
- Ao criar um Service do tipo LoadBalancer, o Kubernetes interage com a API do provedor de nuvem (AWS, GCP, Azure, etc.).
- O provedor cria um balanceador de carga externo que redireciona o tráfego para os nós do cluster.
- Em seguida, o Kube-proxy redireciona o tráfego para os Pods dentro do cluster.
- Este tipo de Service fornece acesso externo e balanceamento de carga ao nível L4 (TCP/UDP) ou L7 (HTTP/S), dependendo do provedor.
```
apiVersion: v1
kind: Service
metadata:
  name: my-external-service
spec:
  selector:
    app: my-app
  ports:
    - protocol: TCP
      port: 80
      targetPort: 8080
  type: LoadBalancer # Cria um balanceador de carga externo
```
Balanceadores de carga personalizados (por exemplo, HAProxy, Nginx como Pods):
- Pode implantar um balanceador de carga dentro do cluster como Deployment e Service (ClusterIP ou NodePort).
- Configurar o tráfego externo para esse Service.
- O balanceador distribuirá o tráfego entre outros Pods.

Assim, o Kubernetes oferece uma abordagem multinível para o balanceamento de carga, combinando mecanismos integrados (Service, Kube-proxy) com soluções externas (Ingress, Balanceadores de carga do provedor de nuvem) e a capacidade de implantar balanceadores personalizados.

Como é implementado o balanceamento de carga no Kubernetes?