Comment la répartition de charge est-elle implémentée…

L'équilibrage de charge dans Kubernetes est mis en œuvre à plusieurs niveaux:

Service (au niveau de Kube-proxy):
- Chaque Pod dans le Service reçoit une adresse IP unique.
- Kube-proxy, fonctionnant sur chaque nœud, surveille les changements dans le Service et EndpointSlice.
- Configure des règles de redirection du trafic (iptables, ipvs) vers l'adresse IP du cluster du Service.
- Le trafic destiné à l'adresse IP du cluster du Service est réparti entre les Pods de ce Service selon l'algorithme choisi (par défaut Round Robin).
- Deux modes de fonctionnement pour Kube-proxy: iptables (standard, basé sur Linux netfilter) et ipvs (plus performant pour les grands clusters, basé sur Virtual Server API).
```
apiVersion: v1
kind: Service
metadata:
  name: my-service
spec:
  selector:
    app: my-app # Sélectionne les Pods avec l'étiquette app: my-app
  ports:
    - protocol: TCP
      port: 80 # Port du Service
      targetPort: 8080 # Port des Pods
```
Ingress (au niveau L7):
- Fonctionne comme un point d'entrée unique pour le load balancing HTTP/S externe.
- Nécessite un contrôleur Ingress (par exemple, Nginx Ingress Controller) pour implémenter les règles.
- Redirige le trafic vers un Service spécifique dans le cluster basé sur le chemin URL, le nom d'hôte et d'autres règles L7.
- Permet de mettre en œuvre diverses stratégies de load balancing, terminaison SSL, hébergement virtuel basé sur le nom.
```
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 # Redirige le trafic vers ce Service
            port:
              number: 80
```
Service LoadBalancer (au niveau du fournisseur cloud):
- Lors de la création d'un Service de type LoadBalancer, Kubernetes interagit avec l'API du fournisseur cloud (AWS, GCP, Azure, etc.).
- Le fournisseur crée un équilibreur de charge externe qui redirige le trafic vers les nœuds du cluster.
- Ensuite, Kube-proxy redirige le trafic vers les Pods à l'intérieur du cluster.
- Ce type de Service fournit un accès externe et un équilibrage de charge au niveau L4 (TCP/UDP) ou L7 (HTTP/S) selon le fournisseur.
```
apiVersion: v1
kind: Service
metadata:
  name: my-external-service
spec:
  selector:
    app: my-app
  ports:
    - protocol: TCP
      port: 80
      targetPort: 8080
  type: LoadBalancer # Crée un équilibreur de charge externe
```
Équilibreurs de charge personnalisés (par exemple, HAProxy, Nginx en tant que Pods):
- Peut déployer un équilibrage de charge à l'intérieur du cluster en tant que Deployment et Service (ClusterIP ou NodePort).
- Configurer le trafic externe vers ce Service.
- L'équilibreur de charge répartira le trafic entre d'autres Pods.

Ainsi, Kubernetes propose une approche multiniveau pour l'équilibrage de charge, combinant des mécanismes intégrés (Service, Kube-proxy) avec des solutions externes (Ingress, Load Balancers du fournisseur cloud) et la possibilité de déployer des équilibrages de charge personnalisés.

Comment la répartition de charge est-elle implémentée dans Kubernetes?