Le trafic double à 9 h 00. En une trentaine de secondes, le HorizontalPodAutoscaler demande six réplicas d'API de plus. Quatre démarrent ; deux restent Pending, car aucun nœud n'a la place pour leurs requests CPU. L'autoscaler de nœuds demande une machine au cloud, et les deux derniers démarrent une fois qu'elle a booté et rejoint le cluster.
Cette matinée a reposé sur plusieurs boucles de contrôle, chacune avec sa propre entrée et sa propre horloge. Bien réglées, personne ne les remarque. Avec de mauvaises requests, ou deux autoscalers en désaccord, vous obtenez des pods évincés en boucle ou des nœuds qui ne se réduisent jamais.
Cet article passe en revue chaque boucle avec ses valeurs par défaut actuelles (Kubernetes 1.37), les endroits où les boucles se contredisent, et un diagramme qui les montre toutes.
Les boucles d'autoscaling en un coup d'œil
| Boucle | Modifie | Surveille | Période par défaut |
|---|---|---|---|
| HorizontalPodAutoscaler (HPA) | Nombre de réplicas | Métriques resource, custom et external | 15 s |
| VerticalPodAutoscaler (VPA) | Requests CPU et mémoire | Historique d'utilisation | 1 min |
| KEDA | Nombre de réplicas, jusqu'à zéro | Sources d'événements comme la longueur d'une file | Interrogation toutes les 30 s |
| Cluster Autoscaler | Taille du groupe de nœuds | Pods non planifiables | Analyse toutes les 10 s |
| Karpenter | Nœuds individuels | Pods non planifiables, coût des nœuds | Lots de 1 à 10 s |
Les pods relient les couches, et les requests sont la monnaie : le scheduler et les deux autoscalers de nœuds décident d'après le CPU et la mémoire demandés, pas d'après l'usage réel, comme le souligne la documentation Kubernetes sur l'autoscaling des nœuds.
HPA : des réplicas à partir de métriques
Le contrôleur HPA s'exécute dans kube-controller-manager et recalcule toutes les 15 secondes. Le CPU et la mémoire viennent de metrics.k8s.io, servi par metrics-server, qui interroge chaque kubelet toutes les 15 secondes. Cette API est devenue stable en v1 dans Kubernetes 1.37, mais le HPA lit toujours v1beta1. Les autres métriques arrivent par des adaptateurs pour votre pipeline de métriques : custom.metrics.k8s.io pour des valeurs comme les requêtes par seconde, external.metrics.k8s.io pour des valeurs extérieures au cluster comme une file cloud. La référence du HPA documente la formule :
desiredReplicas = ceil(currentReplicas × currentMetricValue / desiredMetricValue)
Avec 4 réplicas à 90 % de CPU et une cible de 60 %, le HPA demande ceil(4 × 90 / 60) = 6. À 64 %, il ne fait rien : le ratio de 1,07 est dans la tolérance par défaut de 10 %. L'utilisation est relative aux requests ; un conteneur sans request CPU empêche donc le HPA d'agir sur le CPU. Avec plusieurs métriques, le plus grand résultat l'emporte.
| Paramètre | Valeur par défaut |
|---|---|
| Période de synchronisation | 15 s |
| Tolérance | 10 % ; un champ par HPA est stable depuis 1.37 |
| Stabilisation du scale-down | 300 s, avec la recommandation la plus haute de cette fenêtre |
| Limite de scale-up | 100 % ou 4 pods par 15 s, selon la valeur la plus grande |
| Période d'initialisation du CPU | 5 min ; le CPU des pods pas encore prêts est ignoré |
Le scale-to-zero est en bêta et activé par défaut dans 1.37 : avec une métrique object ou external, vous pouvez définir minReplicas: 0, comme l'explique l'annonce de la version. Le CPU et la mémoire ne peuvent pas réveiller une charge de travail à zéro, car ils sont mesurés sur des pods en cours d'exécution.
spec:
minReplicas: 3
maxReplicas: 30
metrics:
- type: Resource
resource:
name: cpu
target: {type: Utilization, averageUtilization: 60}
behavior:
scaleUp:
tolerance: 0.05
scaleDown:
stabilizationWindowSeconds: 300
VPA : des requests à partir de l'historique d'utilisation
Le VPA est un module complémentaire du projet Kubernetes autoscaler, dont la ligne de versions actuelle est la 1.8. Il comporte trois composants :
- Le recommender calcule une cible, une borne basse et une borne haute par conteneur chaque minute. La mémoire suit les pics sur 8 jours ; l'historique CPU perd la moitié de son poids toutes les 24 heures.
- L'updater vérifie les pods chaque minute et évince ou redimensionne ceux qui sont hors des bornes, en respectant les PodDisruptionBudgets.
- L'admission controller, un mutating webhook, écrit les requests recommandées dans les nouveaux pods.
| Mode de mise à jour | Effet |
|---|---|
Off |
Recommandations uniquement |
Initial |
Requests définies uniquement à la création du pod |
Recreate |
Pods évincés et recréés |
InPlaceOrRecreate |
Redimensionnés sur place, évincés en cas d'échec |
InPlace |
Redimensionnés sur place uniquement ; alpha dans VPA 1.7 |
Auto |
Alias obsolète de Recreate |
Le redimensionnement de pod sur place est stable depuis Kubernetes 1.35, et InPlaceOrRecreate est en disponibilité générale depuis VPA 1.6. L'updater évince tout de même quand un redimensionnement est impossible ou reste différé plus de cinq minutes. Exécutez Off pendant une semaine et comparez les recommandations avec vos requests avant d'activer les mises à jour. Le VPA ne gère pas encore les charges de travail avec resources au niveau du pod ; la référence du VPA couvre le reste.
Cluster Autoscaler contre Karpenter
Tous deux réagissent aux pods que le scheduler a marqués comme non planifiables, et tous deux simulent la planification avec les requests, pas avec l'utilisation des nœuds.
Cluster Autoscaler agrandit des groupes de nœuds que vous définissez à l'avance, comme les Auto Scaling groups d'AWS. Toutes les 10 secondes, il essaie les pods non planifiables sur un nœud modèle de chaque groupe, choisit un groupe avec un expander (least-waste par défaut) et demande au cloud de l'agrandir ; sa FAQ vise moins de 30 secondes pour cela sur des clusters de moins de 100 nœuds. Un nœud dont les pods demandent moins de 50 % du CPU et de la mémoire allouables, et qui pourraient aller ailleurs, est supprimé au bout de 10 minutes. Des PodDisruptionBudgets restrictifs, le stockage local et les pods annotés safe-to-evict: "false" l'empêchent.
Karpenter n'a pas de groupes de nœuds. Un NodePool définit des contraintes comme les familles d'instances, les zones et les limites ; un NodeClass contient les paramètres du cloud. Karpenter regroupe les pods en attente pendant 1 à 10 secondes, les place par bin-packing et lance directement des instances, sur AWS en proposant à EC2 Fleet jusqu'à 60 types d'instances. Ses docs sur la disruption couvrent la suppression : la consolidation supprime ou remplace les nœuds sous-utilisés (WhenEmptyOrUnderutilized par défaut), les nœuds en drift sont remplacés, et des budgets plafonnent les deux à 10 % des nœuds d'un NodePool par défaut. Les nœuds expirent aussi après 720 heures.
| Cluster Autoscaler | Karpenter | |
|---|---|---|
| Unité de mise à l'échelle | Groupes de nœuds prédéfinis | Nœuds individuels, choisis par lot |
| Types d'instances | Fixes par groupe | Tout type autorisé par le NodePool |
| Suppression de nœuds | Moins de 50 % demandé pendant 10 minutes | Consolidation et drift dans les budgets, plus expiration |
| Fournisseurs cloud | Nombreux | Moins nombreux, dont AWS et Azure |
Au moment de la rédaction (novembre 2026), EKS Auto Mode s'appuie sur Karpenter, AKS node auto-provisioning exécute Karpenter pour vous, et GKE gère son propre cluster autoscaler. Exécutez un seul autoscaler de nœuds par ensemble de nœuds ; le guide de migration de Karpenter met Cluster Autoscaler à zéro réplica.
KEDA : files d'attente et scale-to-zero
KEDA, un projet CNCF graduated, ajoute une mise à l'échelle pilotée par les événements avec plus de 70 scalers : lag des consumers sur les partitions Kafka, longueur de file RabbitMQ ou SQS, requêtes Prometheus, cron. Un ScaledObject pointe vers un Deployment. L'opérateur KEDA gère lui-même le passage de 0 à 1 et le retour, en interrogeant toutes les 30 secondes et en passant à zéro après un cooldown de 300 secondes. De 1 à N, il gère un HPA et l'alimente via l'API external metrics, comme le décrit la référence ScaledObject.
apiVersion: keda.sh/v1alpha1
kind: ScaledObject
metadata:
name: worker
spec:
scaleTargetRef:
name: worker
minReplicaCount: 0
maxReplicaCount: 50
triggers:
- type: rabbitmq
metadata:
queueName: orders
mode: QueueLength
value: "20"
hostFromEnv: RABBITMQ_HOST
Le scale-to-zero coûte un démarrage à froid, ce qui convient à une file durable. Pour HTTP, il faut une couche de mise en tampon, car les Services ne retiennent pas les requêtes tant qu'aucun pod n'est prêt. Avec le scale-to-zero du HPA en bêta, un HPA sur une métrique external peut désormais atteindre zéro seul, mais KEDA apporte toujours les scalers, l'authentification des triggers et les ScaledJobs pour les traitements par lots. Le diagramme d'architecture événementielle montre les files autour de tels workers.
Comment les boucles interagissent, et où elles se contredisent
- HPA et VPA sur une même métrique. Le VPA augmente les requests CPU, l'utilisation baisse, le HPA retire des réplicas, les pods restants chauffent davantage, et le VPA augmente de nouveau les requests. Associez un HPA sur le CPU à un VPA limité à la mémoire (
controlledResources: ["memory"]), ou mettez à l'échelle sur des métriques custom. - KEDA plus votre propre HPA. Deux contrôleurs écriraient le même nombre de réplicas. Transférez un HPA existant avec l'annotation
transfer-hpa-ownershipde KEDA. - VPA sur des DaemonSets. Il fausse la prédiction des autoscalers de nœuds sur ce qu'un nouveau nœud exécutera ; la documentation Kubernetes le déconseille.
- Mauvaises requests. Trop basses, et les nouveaux nœuds n'aident pas ; trop hautes, et les nœuds ne paraissent jamais sous-utilisés.
Le timing compte aussi. Un pic de CPU aboutit à une décision après jusqu'à 15 secondes pour la prochaine collecte, plus 15 pour la prochaine synchronisation du HPA. Les pods qui ne tiennent pas attendent jusqu'à 10 secondes de plus une analyse de Cluster Autoscaler, ou 1 à 10 pour le lot de Karpenter. Ensuite la VM démarre : AWS affirme que Karpenter lance de la capacité en moins d'une minute ; la FAQ de Cluster Autoscaler cite trois à quatre minutes sur Google Compute Engine. Pour disposer d'une marge plus vite, exécutez des pods de réserve à basse priorité que les vrais pods préemptent, comme le décrit cette FAQ.
Le diagramme d'autoscaling Kubernetes
Contenu du diagramme
- orders queue
- KEDA
- worker
- new pod
- metrics-server
- HPA: api
- api
- VPA: api memory
- Cluster Autoscaler
- Karpenter
- Cloud provider API
- New node
- queue length
- replicas 0–N
- CPU usage
- replicas
- memory usage
- memory requests
- new replica
- Unschedulable
- resize node group
- launch instances
- VM joins
Comment le lire :
- Rangée du haut, turquoise : KEDA lit la file orders et met à l'échelle le Deployment worker entre zéro et N réplicas.
- Rangée du milieu, bleu : le HPA met à l'échelle le Deployment api d'après l'utilisation du CPU toutes les 15 secondes.
- En bas, violet : le VPA ne fixe que les requests mémoire sur api, il n'entre donc jamais en concurrence avec le HPA.
- Centre : un réplica qui ne tient sur aucun nœud reste Pending. La couche nœuds réagit à ce pod, pas au CPU.
- À droite, ambre : Cluster Autoscaler redimensionne un groupe de nœuds, ou Karpenter lance des instances, via l'API du cloud, et la nouvelle VM rejoint le cluster. Le bloc Markdown liste les valeurs par défaut.
Dessiner clairement des diagrammes d'autoscaling
- Une boucle, une ligne. Le signal entre dans le contrôleur ; ce qu'il modifie en sort.
- Écrivez la période à côté de chaque contrôleur. Elle répond à la plupart des questions « pourquoi n'a-t-il pas scalé ».
- Nommez la ressource que possède chaque autoscaler, pour qu'un HPA et un VPA sur une même charge de travail ne se chevauchent visiblement pas.
- Dessinez le pod Pending. C'est le passage de relais entre la couche pods et la couche nœuds.
- Omettez : les réplicas individuels, les kubelets et les scalers supplémentaires.
Les erreurs courantes sont une flèche du HPA directement vers les nœuds, les deux autoscalers de nœuds dessinés comme s'ils fonctionnaient ensemble, et aucune mention des requests. Pour le cluster autour des boucles, voir comment dessiner un diagramme d'architecture Kubernetes.
Le construire dans Archboard
- Connectez-vous avec Google ou GitHub et créez un diagramme.
- Depuis le pack Kubernetes, ajoutez deux nœuds Deployment, worker et api, ainsi qu'un HPA et un VPA pour api. Réglez le mode de mise à jour du VPA sur InPlaceOrRecreate.
- Ajoutez un nœud Métriques du pack DevOps pour metrics-server et une File d'attente du pack Données.
- Ajoutez une Ressource personnalisée du pack Kubernetes avec le kind ScaledObject pour KEDA, et un Pod en phase Pending entre les Deployments.
- Pour la couche nœuds, ajoutez un Deployment pour Cluster Autoscaler, une Ressource personnalisée avec le kind NodePool pour Karpenter, une Ressource cloud du pack Cloud pour l'API du cloud, et un Node.
- Reliez-les par des arêtes étiquetées (CPU usage, replicas, Unschedulable, etc.), donnez une couleur à chaque boucle et ajoutez une étiquette Texte du pack Base avec sa période.
- Ajoutez un bloc Markdown du pack Base avec les valeurs par défaut.
L'outil de conversion YAML Kubernetes en diagramme transforme des manifestes existants en première ébauche des charges de travail ; une méthode reproductible pour transformer du YAML en diagramme lisible détaille le nettoyage. Plus d'informations sur la page du cas d'usage Kubernetes.
L'exemple utilise 13 nœuds de diagramme et reste dans les limites de l'offre Free.
FAQ
Quelle est la différence entre HPA et VPA ? Le HPA modifie le nombre de pods en cours d'exécution, d'après des métriques comme l'utilisation du CPU. Le VPA modifie les requests CPU et mémoire de chaque pod, d'après l'historique d'utilisation.
Puis-je utiliser HPA et VPA ensemble ? Oui, s'ils agissent sur des métriques différentes : HPA sur le CPU avec un VPA limité à la mémoire, ou HPA sur des métriques custom ou external avec un VPA sur les deux.
Dois-je utiliser Cluster Autoscaler ou Karpenter ? Karpenter, si votre cloud le prend en charge et que vous voulez qu'il choisisse les types d'instances et remplace les nœuds par des moins chers. Cluster Autoscaler pour les autres fournisseurs et les groupes de nœuds fixes. Jamais les deux sur les mêmes nœuds.
Kubernetes peut-il mettre un deployment à zéro ? Oui, avec KEDA, ou avec le scale-to-zero du HPA, en bêta et activé par défaut depuis Kubernetes 1.37. Les deux exigent une métrique qui existe sans pod en cours d'exécution, comme la longueur d'une file.
Pourquoi mon HPA affiche-t-il des cibles CPU inconnues ?
En général, metrics-server est absent, ou un conteneur n'a pas de request CPU, de sorte que l'utilisation ne peut pas être calculée. Exécutez kubectl describe hpa pour voir l'erreur.