Si vous gérez un cluster Kubernetes de grande taille, vous connaissez le problème : scaler horizontalement un controller custom ne fonctionne pas vraiment. Chaque réplica reçoit le flux complet d'événements de l'API server, désérialise chaque Pod, chaque ConfigMap, chaque Secret. À l'échelle d'un cluster de 5000 noeuds, c'est du gaspillage de ressources massif.
Kubernetes v1.36, sorti en mai 2026, apporte enfin une solution native à ce problème avec le Coordinated Leader Election. Ce guide vous explique comment ça fonctionne et comment l'implémenter dans vos workloads de production.
Le problème : pourquoi le scaling horizontal des controllers est cassé
Avant de comprendre la solution, il faut comprendre le problème. Prenons un exemple concret.
Le coût réel de tout surveiller
Imaginez un controller qui gère une Custom Resource dans un cluster de 5000 noeuds. Vous lancez 3 réplicas pour la haute disponibilité. Voici ce qui se passe :
Chaque réplica reçoit tout le flux d'événements
L'API server envoie les mêmes événements (Pod créé, ConfigMap modifié, Node ajouté) à chaque réplica. Si vous avez 10 000 Pods dans le cluster, chaque réplica reçoit et traite les 10 000 événements.
Désérialisation redondante
Chaque réplica désérialise les mêmes objets JSON en structures Go. C'est du CPU gaspillé, multiplié par le nombre de réplicas.
Mémoire dupliquée
Chaque réplica maintient son propre cache des objets du cluster. 3 réplicas signifient 3 copies de l'état complet en mémoire.
L'illusion du leader election
Le pattern classique de leader election dans Kubernetes ne résout pas ce problème. Oui, un seul réplica est le "leader" qui effectue les actions. Mais tous les réplicas continuent à recevoir et traiter les événements pour être prêts à prendre le relai.
Selon les benchmarks présentés lors du KubeCon 2026, un controller custom typique sur un cluster de 5000 noeuds consomme environ 3x plus de ressources avec 3 réplicas qu'avec 1 seul, sans aucun gain de throughput.
La solution : Coordinated Leader Election (CLE)
Kubernetes v1.36 introduit le Coordinated Leader Election, un mécanisme qui permet aux réplicas de se partager réellement le travail au lieu de le dupliquer.
Comment ça fonctionne
Le CLE divise le flux d'événements en "shards" basés sur un hash des objets. Chaque réplica ne traite que les shards qui lui sont assignés :
-
Partitionnement dynamique : Les shards sont répartis entre les réplicas actifs. Si un réplica tombe, ses shards sont redistribués aux autres.
-
Watch ciblé : Chaque réplica n'établit un watch que sur ses shards assignés. L'API server ne lui envoie que les événements pertinents.
-
État partagé minimal : Les réplicas communiquent leur état via des Leases, sans avoir besoin de synchroniser l'état complet du cluster.
Les gains mesurés
Les tests sur des clusters de production montrent des résultats significatifs :
| Métrique | Avant CLE (3 réplicas) | Après CLE (3 réplicas) | |----------|------------------------|------------------------| | CPU total | 300% baseline | 110% baseline | | Mémoire totale | 300% baseline | 105% baseline | | Latence p99 | 2.4s | 0.8s | | Throughput | 1x | 2.8x |
Le throughput triple presque car les réplicas travaillent en parallèle sur des objets différents au lieu de tous traiter les mêmes événements.
Implémenter le CLE dans vos controllers
Voici comment activer le Coordinated Leader Election dans vos propres controllers.
Prérequis
- Kubernetes cluster v1.36+
- Controller-runtime v0.19+ (pour les controllers basés sur Kubebuilder/Operator SDK)
- Feature gate
CoordinatedLeaderElection=trueactivé sur l'API server
Configuration du controller
Pour un controller basé sur controller-runtime, la configuration se fait dans le Manager :
import (
"sigs.k8s.io/controller-runtime/pkg/leaderelection"
ctrl "sigs.k8s.io/controller-runtime"
)
func main() {
mgr, err := ctrl.NewManager(ctrl.GetConfigOrDie(), ctrl.Options{
LeaderElection: true,
LeaderElectionID: "my-controller-leader",
LeaderElectionNamespace: "my-namespace",
// Activer le CLE
LeaderElectionConfig: leaderelection.Config{
CoordinatedEnabled: true,
ShardCount: 12, // Nombre de shards
Identity: os.Getenv("POD_NAME"),
},
})
if err != nil {
log.Fatal(err)
}
// ... reste de la config
}
Choisir le nombre de shards
Le nombre de shards détermine la granularité du partitionnement :
- Trop peu de shards : Les réplicas ne peuvent pas se répartir le travail équitablement. 4 shards pour 5 réplicas signifie qu'un réplica reste inactif.
- Trop de shards : Overhead de coordination. Chaque shard nécessite un Lease, et les réassignations deviennent plus fréquentes.
Règle générale : utilisez 3x le nombre maximum de réplicas prévu. Pour un controller qui peut scaler jusqu'à 5 réplicas, 15 shards est un bon point de départ.
Gestion du failover
Le CLE gère automatiquement les pannes :
-
Détection : Un réplica qui ne renouvelle pas son Lease est considéré comme défaillant après le
LeaseDuration(défaut : 15 secondes). -
Réassignation : Les shards du réplica défaillant sont réassignés aux réplicas restants.
-
Réconciliation : Les nouveaux propriétaires de shards déclenchent une réconciliation complète des objets concernés.
Le temps total de failover est généralement inférieur à 20 secondes, ce qui est comparable au leader election classique.
Cas d'usage avancés
Multi-cluster avec Coordinated Leader Election
Pour les déploiements multi-cluster, le CLE peut être combiné avec des topologies de sharding personnalisées :
LeaderElectionConfig: leaderelection.Config{
CoordinatedEnabled: true,
ShardCount: 24,
ShardingStrategy: leaderelection.TopologyAwareSharding{
TopologyKey: "topology.kubernetes.io/zone",
},
}
Cette configuration répartit les shards par zone, réduisant la latence réseau entre le controller et les objets qu'il gère.
Monitoring et observabilité
Les métriques du CLE sont exposées via le endpoint /metrics standard :
controller_leader_election_shard_count: Nombre de shards assignés à ce réplicacontroller_leader_election_shard_transitions_total: Nombre de réassignations de shardscontroller_leader_election_shard_reconcile_latency_seconds: Latence de réconciliation post-failover
Intégrez ces métriques dans vos dashboards Prometheus/Grafana pour suivre la santé du sharding.
Migration depuis le leader election classique
Si vous avez des controllers existants utilisant le leader election standard, voici comment migrer vers le CLE.
Étape 1 : Vérifier la compatibilité
Le CLE nécessite que votre controller soit idempotent et sans état partagé entre les réconciliations. Si votre controller maintient un cache in-memory qui ne se reconstruit pas à partir des watches, le CLE ne fonctionnera pas correctement.
Étape 2 : Tester en environnement de staging
Déployez votre controller avec CLE activé dans un cluster de test. Simulez des pannes de réplicas et vérifiez que les objets sont réconciliés correctement après réassignation.
Étape 3 : Déploiement progressif
En production, utilisez un déploiement Canary :
- Déployez un nouveau ReplicaSet avec CLE activé
- Routez une fraction du trafic vers ce ReplicaSet
- Surveillez les métriques pendant 24-48h
- Si tout est stable, migrez complètement
Points d'attention
- Ordre des événements : Avec le CLE, l'ordre des événements n'est garanti que par shard. Si votre logique dépend d'un ordre global, elle doit être adaptée.
- Ressources Lease : Le CLE crée des objets Lease supplémentaires. Assurez-vous que votre RBAC autorise la création de Leases.
Bonnes pratiques pour les clusters de grande taille
Le CLE est particulièrement utile pour les clusters de grande taille (plus de 1000 noeuds). Voici quelques recommandations :
Dimensionner les réplicas
La formule recommandée est :
Nombre de réplicas = ceil(Objets gérés / 2000)
Un controller gérant 10 000 Custom Resources devrait avoir 5 réplicas avec CLE activé.
Configurer les ressources
Avec le CLE, chaque réplica consomme environ 1/N des ressources d'un réplica sans CLE (où N est le nombre de réplicas). Ajustez vos requests/limits en conséquence.
Éviter le thundering herd
Après un failover massif (tous les réplicas redémarrent), tous les shards sont réconciliés simultanément. Configurez un RateLimiter pour éviter de surcharger l'API server :
RateLimiter: workqueue.NewItemExponentialFailureRateLimiter(
100*time.Millisecond, // base delay
30*time.Second, // max delay
),
Impact sur les coûts cloud
Le scaling horizontal efficace des controllers a un impact direct sur vos coûts d'infrastructure.
Avant le CLE : Scaler un controller de 1 à 3 réplicas triple vos coûts de compute pour ce controller, sans améliorer les performances.
Avec le CLE : Scaler de 1 à 3 réplicas augmente les coûts d'environ 10-15% tout en triplant le throughput.
Pour une entreprise gérant plusieurs clusters Kubernetes, les économies peuvent représenter plusieurs dizaines de milliers de MAD par mois.
Chez Claro Digital, nous accompagnons les entreprises dans l'optimisation de leur infrastructure cloud. L'adoption de Kubernetes v1.36 et du CLE fait partie des recommandations que nous intégrons dans nos audits d'infrastructure.
Conclusion
Kubernetes v1.36 apporte enfin une solution native au problème du scaling horizontal des controllers. Le Coordinated Leader Election permet de distribuer réellement le travail entre les réplicas, réduisant les coûts et améliorant les performances.
Si vous gérez des clusters de grande taille ou des controllers custom à fort volume, la migration vers le CLE devrait être une priorité. Les gains en ressources et en latence justifient largement l'effort de migration.
FAQ
Le Coordinated Leader Election est-il rétrocompatible ?
Oui. Si vous n'activez pas le feature flag CoordinatedLeaderElection, vos controllers continueront à utiliser le leader election classique. La migration est opt-in.
Puis-je utiliser le CLE avec des controllers existants sans modification de code ?
Non. Le code du controller doit être mis à jour pour configurer le CLE dans le Manager. Cependant, si vous utilisez controller-runtime, les modifications sont minimes (quelques lignes de configuration).
Combien de shards dois-je configurer ?
Règle générale : 3x le nombre maximum de réplicas prévu. Pour 5 réplicas max, utilisez 15 shards. Trop de shards crée de l'overhead, trop peu limite la distribution du travail.
Le CLE fonctionne-t-il avec des clusters multi-régions ?
Oui, mais avec précautions. Le CLE utilise des Leases stockés dans l'API server. Si vos réplicas sont distribués géographiquement, la latence de renouvellement des Leases peut causer des faux positifs de failover. Utilisez le TopologyAwareSharding pour optimiser.
Quels sont les prérequis pour activer le CLE ?
Kubernetes cluster v1.36+, controller-runtime v0.19+, feature gate CoordinatedLeaderElection=true sur l'API server, et un controller idempotent sans état partagé entre réconciliations.