Training Module

Kubernetes Ressourcenmanagement & Autoscaling — Requests, Limits und HorizontalPodAutoscaler

In diesem 90-Minuten-Modul klärt ihr die Frage, die jedem produktiven Deployment vorausgeht: Wie viel darf ein Container eigentlich verbrauchen – und was passiert, wenn er mehr will? Zuerst die Unterscheidung, die am häufigsten durcheinandergeht: requests ist der Bedarf, den der Scheduler garantiert einplant, limits ist die Obergrenze, die der Kubelet auf dem Node zur Laufzeit durchsetzt. Daraus leitet ihr her, warum CPU bei Überschreitung nur gedrosselt (Throttling), Memory dagegen mit einem Out-Of-Memory-Kill beendet wird – und warum genau dieses Verhältnis von requests zu limits die drei Quality-of-Service-Klassen Guaranteed, Burstable und BestEffort ergibt, die bei Ressourcenknappheit über die Eviction-Reihenfolge entscheiden. Der zweite Block ergänzt eine LimitRange: ein Namespace-Default für Requests/Limits, damit Container ohne eigene Angabe nicht automatisch als BestEffort laufen – bewusst abgegrenzt von der ResourceQuota aus dem Modul Administration, die ein Namespace-Aggregat begrenzt, keinen Container-Default setzt. Den größten Block bildet der HorizontalPodAutoscaler (HPA): sein Regelkreis, der in festen Intervallen Metriken abfragt und die Replica-Zahl anpasst, kubectl autoscale als imperativer Weg und ein autoscaling/v2-Manifest als deklarativer Weg – und die harte Kopplung, die in der Praxis am häufigsten übersehen wird: Ohne gesetzte requests.cpu auf dem Ziel-Deployment hat der HPA keine Bezugsgröße für averageUtilization und skaliert schlicht nicht. Der VerticalPodAutoscaler schließt als reines Konzept ab – bewusst ohne eigenes Hands-on, weil VPA und HPA sich bei CPU/Memory gegenseitig ausschließen und ein eigener VPA-Recommender-Stack den Rahmen dieses Moduls sprengen würde. In drei Hands-on-Übungen vergleicht ihr die QoS-Klassen live inklusive Eviction-Reihenfolge, weist CPU-Throttling mit kubectl top pod nach und baut einen kompletten HPA-Regelkreis von Scale-out bis Scale-down auf – die Last dafür erzeugt ihr ausschließlich in-cluster über einen busybox-Pod, ohne externes Tool und ohne Egress. Voraussetzung ist das Modul “Kubernetes Workloads & Konfiguration” – der HPA setzt ein bestehendes Deployment voraus. Die Session läuft weiterhin vollständig lokal über Minikube, ohne Cloud-Account und ohne Kostenwirkung.

Format

90 Minuten, live (remote oder vor Ort), Input & Hands-on

Teilnehmende

Entwickler:innen und Ops, die Ressourcen-Requests/-Limits produktionsreif setzen und Autoscaling verlässlich konfigurieren wollen

Voraussetzungen

Abgeschlossenes Modul “Kubernetes Workloads & Konfiguration” oder gleichwertige Vorkenntnisse, lauffähige lokale Docker-Umgebung für Minikube

Warum dieses Training für deine Organisation wirkt

Requests entscheiden übers Scheduling, Limits übers Überleben

Wer beide Felder für dasselbe hält, versteht weder, warum ein Pod dauerhaft Pending bleibt (zu hohe requests), noch warum ein anderer plötzlich mit OOMKilled neu startet (zu knapp bemessene limits). Zwei unterschiedliche Mechanismen, zwei unterschiedliche Komponenten, zwei unterschiedliche Fehlerbilder.

QoS ist kein Label, sondern eine Ableitung

Niemand setzt eine QoS-Klasse direkt – sie ergibt sich aus dem Verhältnis von requests zu limits. Wer das nicht herleiten kann, wird bei der ersten Memory-Pressure-Situation im Cluster kalt erwischt: Genau diese Klasse entscheidet, welcher Pod zuerst evictet wird.

HPA ohne requests.cpu skaliert nicht

Der mit Abstand häufigste Grund für einen HPA, der stur bei einer Replica verharrt: Das Ziel-Deployment hat gar kein requests.cpu gesetzt. Ohne Bezugsgröße kann averageUtilization nichts berechnen – ein Stolperstein, den dieses Modul vorab ausräumt.

Was Teilnehmende mitnehmen

  • requests (Scheduler-Einplanung) und limits (Kubelet-Durchsetzung) auf Container-Ebene unterscheiden und korrekt setzen.
  • Das unterschiedliche Verhalten bei Überschreitung herleiten: CPU-Throttling (komprimierbar) vs. Memory-OOMKill (nicht komprimierbar).
  • Die drei Quality-of-Service-Klassen Guaranteed/Burstable/BestEffort aus dem Verhältnis von requests zu limits herleiten und deren Eviction-Reihenfolge bei Ressourcenknappheit benennen.
  • Eine LimitRange als Namespace-Default für Requests/Limits einsetzen und sauber von der ResourceQuota (Namespace-Aggregat statt Container-Default) abgrenzen.
  • Den HPA-Regelkreis erklären und einen HorizontalPodAutoscaler sowohl imperativ mit kubectl autoscale als auch deklarativ mit einem autoscaling/v2-Manifest anlegen.
  • Die harte Kopplung des HPA an gesetzte requests.cpu auf dem Ziel-Deployment benennen – ohne sie skaliert der HPA nicht.
  • Den VerticalPodAutoscaler als Konzept einordnen: automatische Requests/Limits-Empfehlung statt Replica-Skalierung, und warum er sich mit dem HPA bei derselben Metrik ausschließt.
  • In drei Hands-on-Übungen die QoS-Klassen live vergleichen (inkl. Eviction), CPU-Throttling mit kubectl top pod nachweisen und einen HPA End-to-End von Scale-out bis Scale-down live betreiben.

Für wen dieses Modul ideal ist

  • • Entwickler:innen und Ops mit abgeschlossenem Modul “Kubernetes Workloads & Konfiguration” oder gleichwertigen Vorkenntnissen
  • • Alle, die OOMKilled oder CPU-Throttling schon einmal live gesehen haben, die Ursache dahinter aber nicht sicher herleiten konnten
  • • Teams, die vor der ersten produktiven Autoscaling-Konfiguration wissen wollen, welche Voraussetzung dabei am häufigsten übersehen wird

Rahmendaten

  • • Dauer: 90 Minuten live (remote oder vor Ort)
  • • Format: Input, Live-Demo, drei Hands-on-Übungen zu QoS/Eviction, CPU-Throttling und HPA End-to-End
  • • Voraussetzungen: abgeschlossenes Modul “Kubernetes Workloads & Konfiguration”, lauffähige lokale Docker-Umgebung, keine Cloud-Kostenwirkung

Modulaufbau & Agenda

  1. Requests, Limits & Quality of Service (30 min, Hands-on): requests vs. limits herleiten, CPU-Throttling vs. Memory-OOMKill, die drei QoS-Klassen Guaranteed/Burstable/BestEffort – mit den Hands-on-Übungen QoS-Klassen live vergleichen inkl. Eviction sowie CPU-Throttling mit kubectl top pod nachweisen.

  2. LimitRange: Namespace-Default für Requests/Limits (10 min): ein Namespace-Default für Container ohne eigene Angabe, klar abgegrenzt von der namespace-aggregierenden ResourceQuota aus dem Modul Administration.

  3. HorizontalPodAutoscaler: Regelkreis, imperativ & deklarativ (30 min, Hands-on): der HPA-Regelkreis, kubectl autoscale imperativ, ein autoscaling/v2-Manifest deklarativ, die harte Kopplung an gesetzte requests.cpu – mit dem Hands-on HPA End-to-End: in-cluster erzeugte Last, Scale-out und Scale-down live beobachten.

  4. VerticalPodAutoscaler als Konzept, ohne eigenes Hands-on (5 min): automatische Requests/Limits-Empfehlung statt Replica-Skalierung, und warum VPA und HPA sich bei derselben Metrik ausschließen.

  5. Abgrenzung & Q&A (15 min): was dieses Modul bewusst nicht behandelt – Cluster-Autoscaler/Node-Autoscaling, Custom/External Metrics und KEDA, DaemonSet, sowie PVC-Storage-Requests – und offene Fragen.

Dieses Modul setzt das Aufbaumodul Kubernetes Workloads & Konfiguration — die Objekte für den Alltag voraus. Der HPA skaliert ein bestehendes Deployment – ohne die dortige Deployment-Mechanik (Rolling Update, Replica-Steuerung) ergibt der Hands-on-Teil dieses Moduls keinen Sinn und wird hier nicht erneut eingeführt.

Dieses Modul ist unabhängig von den sechs weiteren Vertiefungsmodulen auf Kubernetes Workloads & Konfiguration: Kubernetes Administration — RBAC, Node-Betrieb und Cluster-Netzwerk, Kubernetes Networking Vertiefung — Service Discovery, DNS und Ingress-Pfadregeln, Kubernetes Anwendungsdesign — Multi-Container-Patterns, Jobs & Security Context, Kubernetes Storage — Volumes, PersistentVolumes & Claims, Kubernetes: Monitoring & Troubleshooting und Helm — Paketmanagement für Kubernetes. Die ResourceQuota aus dem Modul Administration begrenzt einen Namespace als Ganzes (Aggregat über alle Pods); die LimitRange dieses Moduls setzt stattdessen einen Default pro Container – beide Konzepte ergänzen sich, keines ersetzt das andere. Storage-Requests einer PersistentVolumeClaim sind ein eigenes Konzept und bereits Teil des Moduls Kubernetes Storage, hier nicht Thema. Die resources.requests/ resources.limits, die viele öffentliche Helm-Charts in ihren values setzen, sind exakt die hier erklärten Felder – das Modul Helm — Paketmanagement für Kubernetes zeigt nur, wo man sie in einem Chart überschreibt, nicht was sie bewirken. Alle sieben Vertiefungsmodule setzen nur das Workloads-Modul voraus, nicht sich gegenseitig, und lassen sich in beliebiger Reihenfolge buchen.

Hands-on Inhalte (Auszug)

QoS-Klassen live vergleichen

  • Drei Pods deployen – Guaranteed (requests = limits), Burstable (requests < limits) und BestEffort (keine Angabe) – und mit kubectl describe pod jeweils die zugewiesene QoS-Klasse ablesen
  • Memory-Pressure auf dem Node simulieren und die Eviction-Reihenfolge live beobachten: BestEffort zuerst, danach Burstable oberhalb seiner Requests, Guaranteed zuletzt

CPU-Throttling nachweisen

  • Einen Pod mit knapp bemessenem limits.cpu und einem CPU-Stress-Prozess im Container starten
  • Mit kubectl top pod wiederholt beobachten, dass der gemessene Verbrauch nahe am Limit einpendelt, aber nie darüber steigt – im Unterschied zum Memory-OOMKill kein Absturz, sondern Drosselung

HPA End-to-End: Scale-out

  • Ein Deployment mit gesetztem requests.cpu anwenden und per kubectl autoscale –cpu-percent=50 –min=2 –max=6 einen HPA erstellen
  • Last ausschließlich in-cluster erzeugen: ein busybox-Pod mit einer wget-Schleife gegen den ClusterIP-Service – kein externes Tool, kein Egress
  • kubectl get hpa -w und kubectl get pods -w parallel beobachten, während die Replica-Zahl unter Last steigt

HPA End-to-End: Scale-down

  • Den Last-Pod löschen und die CPU-Auslastung wieder unter den Zielwert fallen lassen
  • Das Stabilisierungsfenster für den Rückbau live beobachten – der HPA baut Replicas bewusst langsamer ab, als er sie aufbaut

Dieses Modul ist Teil unserer Pilotphase. Gemeinsam mit euch definieren wir passende Metriken (z. B. Zeit bis zum ersten beobachteten Scale-out) und werten sie im Anschluss transparent aus. Ergebnisse veröffentlichen wir, sobald sie belastbar sind.

Bereit, das Modul zu buchen?

Wir passen die Hands-on-Übung auf euren Erfahrungsstand und eure Zielumgebung an.

Academy Briefing anfragen