Come viene implementato il bilanciamento del carico…

Il bilanciamento del carico in Kubernetes viene implementato su più livelli:

Servizio (a livello di Kube-proxy):
- Ogni Pod nel Service riceve un indirizzo IP univoco.
- Kube-proxy, che funziona su ogni nodo, monitora le modifiche in Service e EndpointSlice.
- Configura regole di reindirizzamento del traffico (iptables, ipvs) verso l'indirizzo IP del cluster del Service.
- Il traffico diretto all'indirizzo IP del cluster del Service viene distribuito tra i Pod di quel Service secondo l'algoritmo scelto (predefinito Round Robin).
- Ci sono due modalità operative per Kube-proxy: iptables (standard, basato su Linux netfilter) e ipvs (più performante per grandi cluster, basato su Virtual Server API).
```
apiVersion: v1
kind: Service
metadata:
  name: my-service
spec:
  selector:
    app: my-app # Seleziona Pod con l'etichetta app: my-app
  ports:
    - protocol: TCP
      port: 80 # Porta del Service
      targetPort: 8080 # Porta sui Pod
```
Ingress (a livello L7):
- Funziona come un punto di ingresso unico per il bilanciamento del carico HTTP/S esterno.
- È necessario un controller Ingress (ad esempio, Nginx Ingress Controller) per implementare le regole.
- Reindirizza il traffico a un Service specifico all'interno del cluster in base al percorso URL, al nome host e ad altre regole L7.
- Permette di implementare diverse strategie di bilanciamento, terminazione SSL, hosting virtuale basato sul nome.
```
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 # Reindirizza il traffico a questo Service
            port:
              number: 80
```
Service LoadBalancer (a livello del provider cloud):
- Quando si crea un Service di tipo LoadBalancer, Kubernetes interagisce con l'API del provider cloud (AWS, GCP, Azure, ecc.).
- Il provider crea un bilanciatore di carico esterno che reindirizza il traffico ai nodi del cluster.
- Successivamente, Kube-proxy reindirizza il traffico ai Pod all'interno del cluster.
- Questo tipo di Service fornisce accesso esterno e bilanciamento del carico a livello L4 (TCP/UDP) o L7 (HTTP/S) a seconda del provider.
```
apiVersion: v1
kind: Service
metadata:
  name: my-external-service
spec:
  selector:
    app: my-app
  ports:
    - protocol: TCP
      port: 80
      targetPort: 8080
  type: LoadBalancer # Crea un bilanciatore di carico esterno
```
Bilanciatori di carico personalizzati (ad esempio, HAProxy, Nginx come Pod):
- È possibile distribuire un bilanciatore di carico all'interno del cluster come Deployment e Service (ClusterIP o NodePort).
- Configurare il traffico esterno a questo Service.
- Il bilanciatore di carico distribuirà il traffico tra gli altri Pod.

In questo modo, Kubernetes offre un approccio multilivello al bilanciamento del carico, combinando meccanismi integrati (Service, Kube-proxy) con soluzioni esterne (Ingress, Load Balancer del provider cloud) e la possibilità di distribuire bilanciatori di carico personalizzati.

Come viene implementato il bilanciamento del carico in Kubernetes?