Cum se implementează echilibrarea încărcării în…

Împărțirea sarcinii în Kubernetes se realizează pe mai multe niveluri:

Serviciu (la nivelul Kube-proxy):
- Fiecare Pod din serviciu primește o adresă IP unică.
- Kube-proxy, care rulează pe fiecare nod, monitorizează modificările în Service și EndpointSlice.
- Configurează reguli de redirecționare a traficului (iptables, ipvs) către adresa IP a clusterului pentru serviciu.
- Traficul direcționat către IP-ul clusterului pentru serviciu este distribuit între Pod-urile acestui serviciu conform algoritmului ales (implicit Round Robin).
- Există două moduri de funcționare pentru Kube-proxy: iptables (standard, bazat pe Linux netfilter) și ipvs (mai performant pentru clustere mari, bazat pe Virtual Server API).
```
apiVersion: v1
kind: Service
metadata:
  name: my-service
spec:
  selector:
    app: my-app # Selectează Pod-urile cu eticheta app: my-app
  ports:
    - protocol: TCP
      port: 80 # Portul serviciului
      targetPort: 8080 # Portul pe Pod-uri
```
Ingress (la nivelul L7):
- Funcționează ca un punct de intrare unificat pentru echilibrarea încărcării HTTP/S externe.
- Este necesar un controler Ingress (de exemplu, Nginx Ingress Controller) pentru implementarea regulilor.
- Redirecționează traficul către un serviciu specific din interiorul clusterului pe baza căii URL, numelui gazdei și altor reguli L7.
- Permite implementarea diverselor strategii de echilibrare a încărcării, terminarea SSL, hosting virtual bazat pe nume.
```
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 # Redirecționează traficul către acest serviciu
            port:
              number: 80
```
Serviciu LoadBalancer (la nivelul furnizorului de cloud):
- Când se creează un serviciu de tip LoadBalancer, Kubernetes interacționează cu API-ul furnizorului de cloud (AWS, GCP, Azure etc.).
- Furnizorul creează un echilibru de sarcină extern care redirecționează traficul către nodurile clusterului.
- Apoi, Kube-proxy redirecționează traficul către Pod-urile din interiorul clusterului.
- Acest tip de serviciu asigură acces extern și echilibrare a sarcinii la nivel L4 (TCP/UDP) sau L7 (HTTP/S), în funcție de furnizor.
```
apiVersion: v1
kind: Service
metadata:
  name: my-external-service
spec:
  selector:
    app: my-app
  ports:
    - protocol: TCP
      port: 80
      targetPort: 8080
  type: LoadBalancer # Creează un echilibru de sarcină extern
```
Echilibrarea de sarcină personalizată (de exemplu, HAProxy, Nginx ca Pod):
- Se poate implementa un echilibru de sarcină în interiorul clusterului ca Deployment și Service (ClusterIP sau NodePort).
- Configurați traficul extern către acest Service.
- Echilibratorul de sarcină va distribui traficul între celelalte Pod-uri.

Astfel, Kubernetes oferă o abordare multi-nivel pentru echilibrarea încărcării, combinând mecanisme încorporate (Service, Kube-proxy) cu soluții externe (Ingress, Load Balancer de la furnizorul de cloud) și posibilitatea de a implementa echilibrare de sarcină personalizată.

Cum se implementează echilibrarea încărcării în Kubernetes?