Zum Inhalt springen

Kubernetes-Autoscaling-Diagramm: HPA, VPA, KEDA, Cluster Autoscaler und Karpenter

Die Kubernetes-Autoscaling-Regelkreise in einem Diagramm: was HPA, VPA, KEDA, Cluster Autoscaler und Karpenter beobachten, wann sie handeln und wo sie kollidieren.

· Gründer & Entwickler

Veröffentlicht am

Eine orders-Queue speist KEDA, das ein worker-Deployment skaliert. metrics-server speist einen HPA für das api-Deployment und einen VPA für dessen Memory-Requests. Ein Pending-Pod geht an Cluster Autoscaler oder Karpenter, die per Cloud-API einen neuen Node holen.

Um 9:00 Uhr verdoppelt sich der Traffic. Innerhalb von etwa 30 Sekunden fordert der HorizontalPodAutoscaler sechs weitere API-Replicas an. Vier starten; zwei bleiben Pending, weil auf keinem Node Platz für ihre CPU-Requests ist. Der Node-Autoscaler bittet die Cloud um eine Maschine, und die letzten beiden starten, sobald sie hochgefahren ist und dem Cluster beigetreten ist.

Dieser Morgen lief über mehrere Regelkreise, jeder mit eigenem Eingang und eigenem Takt. Gut eingestellt, bemerkt sie niemand. Mit falschen Requests oder zwei Autoscalern, die sich widersprechen, werden Pods in einer Schleife evictet oder Nodes skalieren nie herunter.

Dieser Beitrag behandelt jeden Regelkreis mit seinen aktuellen Standardwerten (Kubernetes 1.37), die Stellen, an denen sie sich in die Quere kommen, und ein Diagramm, das alle zeigt.

Die Autoscaling-Regelkreise im Überblick

Regelkreis Ändert Beobachtet Standardintervall
HorizontalPodAutoscaler (HPA) Replica-Anzahl Resource-, Custom- und External-Metriken 15 s
VerticalPodAutoscaler (VPA) CPU- und Memory-Requests Nutzungsverlauf 1 min
KEDA Replica-Anzahl, bis auf null Event-Quellen wie die Queue-Länge 30 s Polling
Cluster Autoscaler Größe der Node-Gruppe Nicht planbare Pods 10 s Scan
Karpenter Einzelne Nodes Nicht planbare Pods, Node-Kosten Batches von 1 bis 10 s

Pods verbinden die Ebenen, und Requests sind die Währung: Der Scheduler und beide Node-Autoscaler entscheiden anhand der angeforderten CPU und des angeforderten Speichers, nicht anhand der tatsächlichen Nutzung, wie die Kubernetes-Dokumentation zum Node-Autoscaling betont.

HPA: Replicas aus Metriken

Der HPA-Controller läuft im kube-controller-manager und rechnet alle 15 Sekunden neu. CPU und Memory kommen aus metrics.k8s.io, bereitgestellt von metrics-server, der jeden kubelet alle 15 Sekunden abfragt. Diese API wurde in Kubernetes 1.37 als v1 stabil, der HPA liest aber weiterhin v1beta1. Andere Metriken kommen über Adapter für deine Metrik-Pipeline: custom.metrics.k8s.io für Werte wie Requests pro Sekunde, external.metrics.k8s.io für Werte außerhalb des Clusters wie eine Cloud-Queue. Die HPA-Referenz dokumentiert die Formel:

desiredReplicas = ceil(currentReplicas × currentMetricValue / desiredMetricValue)

Bei 4 Replicas mit 90 % CPU und einem Ziel von 60 % fordert der HPA ceil(4 × 90 / 60) = 6 an. Bei 64 % tut er nichts: Das Verhältnis von 1,07 liegt innerhalb der Standardtoleranz von 10 %. Die Auslastung bezieht sich auf die Requests; ein Container ohne CPU-Request macht es dem HPA unmöglich, auf CPU zu reagieren. Bei mehreren Metriken gewinnt das größte Ergebnis.

Einstellung Standard
Sync-Intervall 15 s
Toleranz 10 %; ein Feld pro HPA ist seit 1.37 stabil
Scale-down-Stabilisierung 300 s, mit der höchsten Empfehlung in diesem Fenster
Scale-up-Limit 100 % oder 4 Pods pro 15 s, je nachdem, was mehr ist
CPU-Initialisierungszeit 5 min; die CPU noch nicht bereiter Pods wird ignoriert

Scale-to-zero ist Beta und in 1.37 standardmäßig aktiv: Mit einer Object- oder External-Metrik kannst du minReplicas: 0 setzen, wie die Release-Ankündigung erklärt. CPU und Memory können eine Workload nicht aus dem Nullzustand wecken, weil sie an laufenden Pods gemessen werden.

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: Requests aus dem Nutzungsverlauf

Der VPA ist ein Add-on aus dem Kubernetes-Autoscaler-Projekt, dessen aktuelle Release-Linie 1.8 ist. Er besteht aus drei Komponenten:

  1. Der Recommender berechnet pro Container jede Minute ein Ziel, eine Untergrenze und eine Obergrenze. Memory folgt den Spitzen über 8 Tage; der CPU-Verlauf verliert alle 24 Stunden die Hälfte seines Gewichts.
  2. Der Updater prüft Pods jede Minute und evictet oder skaliert diejenigen außerhalb der Grenzen, unter Beachtung von PodDisruptionBudgets.
  3. Der Admission Controller, ein Mutating Webhook, schreibt die empfohlenen Requests in neue Pods.
Update-Modus Wirkung
Off Nur Empfehlungen
Initial Requests nur bei der Pod-Erstellung gesetzt
Recreate Pods werden evictet und neu erstellt
InPlaceOrRecreate Wird an Ort und Stelle angepasst, bei Fehlschlag evictet
InPlace Nur an Ort und Stelle angepasst; Alpha in VPA 1.7
Auto Veralteter Alias für Recreate

Das In-Place-Resize von Pods ist seit Kubernetes 1.35 stabil, und InPlaceOrRecreate ist seit VPA 1.6 allgemein verfügbar. Der Updater evictet weiterhin, wenn eine Anpassung nicht machbar ist oder länger als fünf Minuten aufgeschoben bleibt. Lass Off eine Woche laufen und vergleiche die Empfehlungen mit deinen Requests, bevor du Updates aktivierst. Der VPA unterstützt noch keine Workloads mit resources auf Pod-Ebene; den Rest behandelt die VPA-Referenz.

Cluster Autoscaler vs. Karpenter

Beide reagieren auf Pods, die der Scheduler als nicht planbar markiert hat, und beide simulieren das Scheduling mit Requests, nicht mit der Node-Auslastung.

Cluster Autoscaler vergrößert Node-Gruppen, die du vorab definierst, etwa AWS Auto Scaling Groups. Alle 10 Sekunden probiert er nicht planbare Pods auf einem Template-Node jeder Gruppe aus, wählt mit einem Expander eine Gruppe (standardmäßig least-waste) und bittet die Cloud, sie zu vergrößern; seine FAQ nennt dafür unter 30 Sekunden bei Clustern unter 100 Nodes als Ziel. Ein Node, dessen Pods weniger als 50 % der allokierbaren CPU und des Speichers anfordern und der anderswohin umziehen könnte, wird nach 10 Minuten entfernt. Restriktive PodDisruptionBudgets, lokaler Speicher und Pods mit der Annotation safe-to-evict: "false" verhindern das.

Karpenter kennt keine Node-Gruppen. Ein NodePool legt Einschränkungen wie Instanzfamilien, Zonen und Limits fest; eine NodeClass enthält die Cloud-Einstellungen. Karpenter bündelt wartende Pods 1 bis 10 Sekunden lang, packt sie per Bin-Packing und startet Instanzen direkt, auf AWS mit bis zu 60 Instanztypen im EC2-Fleet-Angebot. Das Entfernen behandeln die Disruption-Docs: Consolidation löscht oder ersetzt schlecht ausgelastete Nodes (standardmäßig WhenEmptyOrUnderutilized), gedriftete Nodes werden ersetzt, und Budgets begrenzen beides standardmäßig auf 10 % der Nodes eines NodePools. Nodes laufen außerdem nach 720 Stunden ab.

Cluster Autoscaler Karpenter
Skalierungseinheit Vordefinierte Node-Gruppen Einzelne Nodes, pro Batch gewählt
Instanztypen Fest pro Gruppe Jeder Typ, den der NodePool erlaubt
Nodes entfernen Unter 50 % angefordert für 10 Minuten Consolidation und Drift innerhalb von Budgets, plus Ablauf
Cloud-Anbieter Viele Weniger, darunter AWS und Azure

Zum Zeitpunkt des Schreibens (November 2026) baut EKS Auto Mode auf Karpenter auf, AKS Node Auto-Provisioning betreibt Karpenter für dich, und GKE verwaltet seinen eigenen Cluster Autoscaler. Betreibe pro Node-Menge einen Node-Autoscaler; die Migrationsanleitung von Karpenter skaliert den Cluster Autoscaler auf null Replicas.

KEDA: Queues und Scale-to-zero

KEDA, ein CNCF-Graduated-Projekt, ergänzt ereignisgesteuertes Skalieren mit mehr als 70 Scalern: Consumer-Lag auf Kafka-Partitionen, RabbitMQ- oder SQS-Queue-Länge, Prometheus-Abfragen, Cron. Ein ScaledObject verweist auf ein Deployment. Der KEDA-Operator erledigt 0 auf 1 und zurück selbst, fragt alle 30 Sekunden ab und skaliert nach einer Cooldown-Zeit von 300 Sekunden auf null. Von 1 auf N verwaltet er einen HPA und füttert ihn über die External-Metrics-API, wie die ScaledObject-Referenz beschreibt.

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

Scale-to-zero kostet einen Cold Start, was zu einer dauerhaften Queue passt. Bei HTTP braucht es eine Pufferschicht, weil Services keine Requests halten, solange kein Pod bereit ist. Da HPA-Scale-to-zero in Beta ist, kann ein HPA auf einer External-Metrik jetzt allein auf null gehen, aber KEDA bringt weiterhin die Scaler, die Trigger-Authentifizierung und ScaledJobs für Batch-Arbeit mit. Das Diagramm zur ereignisgesteuerten Architektur zeigt die Queues rund um solche Worker.

Wie die Regelkreise interagieren und wo sie kollidieren

  • HPA und VPA auf einer Metrik. Der VPA erhöht die CPU-Requests, die Auslastung sinkt, der HPA entfernt Replicas, die übrigen Pods laufen heißer, und der VPA erhöht die Requests erneut. Kombiniere einen HPA auf CPU mit einem VPA, der auf Memory beschränkt ist (controlledResources: ["memory"]), oder skaliere mit Custom-Metriken.
  • KEDA plus dein eigener HPA. Zwei Controller würden dieselbe Replica-Anzahl schreiben. Übergib einen bestehenden HPA mit der Annotation transfer-hpa-ownership von KEDA.
  • VPA auf DaemonSets. Er verdirbt die Vorhersage der Node-Autoscaler, was ein neuer Node ausführen wird; die Kubernetes-Dokumentation rät davon ab.
  • Falsche Requests. Zu niedrig, und neue Nodes helfen nicht; zu hoch, und Nodes wirken nie unterausgelastet.

Auch das Timing zählt. Ein CPU-Spike erreicht eine Entscheidung nach bis zu 15 Sekunden bis zum nächsten Scrape plus 15 bis zum nächsten HPA-Sync. Pods, die nicht passen, warten bis zu 10 weitere Sekunden auf einen Scan des Cluster Autoscalers oder 1 bis 10 auf den Batch von Karpenter. Dann bootet die VM: AWS sagt, Karpenter starte Kapazität in unter einer Minute; die FAQ des Cluster Autoscalers nennt drei bis vier Minuten auf Google Compute Engine. Für schnelleren Puffer betreibst du Platzhalter-Pods mit niedriger Priorität, die echte Pods verdrängen, wie diese FAQ beschreibt.

Das Kubernetes-Autoscaling-Diagramm

Eine orders-Queue speist KEDA, das ein worker-Deployment skaliert. metrics-server speist einen HPA für das api-Deployment und einen VPA für dessen Memory-Requests. Ein Pending-Pod geht an Cluster Autoscaler oder Karpenter, die per Cloud-API einen neuen Node holen.

21 Komponenten · 13 Verbindungen

In Archboard öffnen
Diagramminhalt
  • 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
Die Autoscaling-Regelkreise eines Clusters. Der HPA setzt alle 15 Sekunden die Replicas anhand der CPU, der VPA setzt Memory-Requests, KEDA skaliert einen Worker nach Queue-Länge, und ein Pending-Pod geht an Cluster Autoscaler oder Karpenter, die bei der Cloud einen Node anfordern.

So liest du es:

  • Obere Reihe, Türkis: KEDA liest die orders-Queue und skaliert das worker-Deployment zwischen null und N Replicas.
  • Mittlere Reihe, Blau: Der HPA skaliert das api-Deployment alle 15 Sekunden anhand der CPU-Auslastung.
  • Unten, Violett: Der VPA setzt nur Memory-Requests für api und konkurriert daher nie mit dem HPA.
  • Mitte: Ein Replica, das auf keinen Node passt, bleibt Pending. Die Node-Ebene reagiert auf diesen Pod, nicht auf die CPU.
  • Rechts, Bernstein: Cluster Autoscaler ändert die Größe einer Node-Gruppe, oder Karpenter startet Instanzen, jeweils über die Cloud-API, und die neue VM tritt bei. Der Markdown-Block listet die Standardwerte auf.

Autoscaling-Diagramme klar zeichnen

  • Ein Regelkreis, eine Linie. Das Signal geht in den Controller hinein; was er ändert, kommt heraus.
  • Schreib das Intervall neben jeden Controller. Es beantwortet die meisten „Warum hat es nicht skaliert“-Fragen.
  • Benenne die Ressource, die jeder Autoscaler besitzt, damit sich ein HPA und ein VPA auf einer Workload sichtbar nicht überschneiden.
  • Zeichne den Pending-Pod. Er ist die Übergabe zwischen Pod-Ebene und Node-Ebene.
  • Lass weg: einzelne Replicas, kubelets und zusätzliche Scaler.

Häufige Fehler sind ein HPA-Pfeil direkt zu den Nodes, beide Node-Autoscaler so gezeichnet, als liefen sie zusammen, und keine Erwähnung der Requests. Für den Cluster um die Regelkreise siehe So zeichnest du ein Kubernetes-Architekturdiagramm.

In Archboard nachbauen

  1. Melde dich mit Google oder GitHub an und erstelle ein Diagramm.
  2. Füge aus dem Paket Kubernetes zwei Deployment-Nodes hinzu, worker und api, dazu einen HPA und einen VPA für api. Setze den VPA-Update-Modus auf InPlaceOrRecreate.
  3. Füge einen Metriken-Node aus dem Paket DevOps für metrics-server und eine Warteschlange aus dem Paket Daten hinzu.
  4. Füge eine Benutzerdefinierte Ressource aus dem Paket Kubernetes mit der Kind ScaledObject für KEDA hinzu, und einen Pod mit der Phase Pending zwischen den Deployments.
  5. Füge für die Node-Ebene ein Deployment für Cluster Autoscaler hinzu, eine Benutzerdefinierte Ressource mit der Kind NodePool für Karpenter, eine Cloud-Ressource aus dem Paket Cloud für die Cloud-API und einen Node.
  6. Verbinde sie mit beschrifteten Edges (CPU usage, replicas, Unschedulable und so weiter), gib jedem Regelkreis eine Farbe und füge ein Text-Label aus dem Paket Basis mit seinem Intervall hinzu.
  7. Füge aus dem Paket Basis einen Markdown-Block mit den Standardwerten hinzu.

Das Tool Kubernetes-YAML zu Diagramm macht aus bestehenden Manifesten einen ersten Entwurf der Workloads; eine wiederholbare Methode, aus YAML ein lesbares Diagramm zu machen, zeigt das Aufräumen. Mehr auf der Kubernetes-Use-Case-Seite.

Das Beispiel nutzt 13 Diagramm-Nodes und bleibt damit im Free-Plan.

FAQ

Was ist der Unterschied zwischen HPA und VPA? Der HPA ändert, wie viele Pods laufen, anhand von Metriken wie der CPU-Auslastung. Der VPA ändert die CPU- und Memory-Requests jedes Pods anhand des Nutzungsverlaufs.

Kann ich HPA und VPA zusammen verwenden? Ja, wenn sie auf unterschiedlichen Metriken arbeiten: HPA auf CPU mit einem auf Memory beschränkten VPA, oder HPA auf Custom- oder External-Metriken mit VPA auf beidem.

Sollte ich Cluster Autoscaler oder Karpenter verwenden? Karpenter, wenn deine Cloud es unterstützt und du willst, dass es Instanztypen wählt und Nodes durch günstigere ersetzt. Cluster Autoscaler für andere Anbieter und feste Node-Gruppen. Nie beide auf denselben Nodes.

Kann Kubernetes ein Deployment auf null skalieren? Ja, mit KEDA oder mit HPA-Scale-to-zero, Beta und seit Kubernetes 1.37 standardmäßig aktiv. Beide brauchen eine Metrik, die auch ohne laufende Pods existiert, etwa die Queue-Länge.

Warum zeigt mein HPA unbekannte CPU-Ziele an? Meist fehlt metrics-server, oder ein Container hat keinen CPU-Request, sodass die Auslastung nicht berechnet werden kann. Führe kubectl describe hpa aus, um den Fehler zu sehen.

Kostenlos starten — ein Seat, keine Kreditkarte.

Ähnliche Beiträge

← Zurück zum Blog

In einer Minute ein Canvas öffnen

Melden Sie sich mit Google oder GitHub an. Kostenlos für einen Sitzplatz. Upgraden Sie, wenn das Team dazukommt.