27. Oktober 2026 · 6 Min. Lesezeit
Der Cluster nutzte 160 Millicores. Seine Requests brauchten sechs Nodes.
Die Frage war einfach: Können drei mittelgroße Nodes die Produktion tragen? Das Produkt hatte noch keine Kunden, der Cluster war am Tag zuvor neu aufgebaut worden, und die Node-Rechnung wirkte hoch für etwas, das meist im Leerlauf war. In der Produktion gab es keinen metrics-server, also installierte ich ihn als EKS-Add-on und schaute nach, bevor ich irgendetwas beantwortete.
Der gesamte Cluster nutzte etwa 160 Millicores CPU und 6 GiB Speicher. Er lief auf sechs Nodes, grob 245 $ im Monat an Compute für eine Last, die bequem auf einen Laptop gepasst hätte.
Der Rest dieses Beitrags handelt von der Lücke zwischen diesen beiden Tatsachen, denn sie ist das häufigste Missverständnis über Kubernetes-Kapazität, und sie entscheidet, was du zahlst.
Der Scheduler schaut nie auf die Nutzung
Der Kubernetes-Scheduler platziert einen Pod auf einem Node, wenn die Requests des Pods in das passen, was von den allokierbaren Ressourcen des Nodes übrig ist. Er liest keine Live-CPU. Er fragt nie, wie ausgelastet der Pod ist. Ein Node mit 5 % echter Auslastung ist für den Scheduler voll, wenn die Requests darauf der Größe des Nodes entsprechen.
Deshalb ist kubectl top das falsche Werkzeug zur Dimensionierung, und die Ausgabe von kubectl describe node das richtige:
kubectl top nodes # was genutzt wird
kubectl describe node <node> | grep -A8 "Allocated resources" # was reserviert ist
Die erste Zahl war winzig. Die zweite hatte drei große Nodes, einen mittleren und zwei kleine Core-Nodes gefüllt. Die Reservierungen kamen von wenigen Komponenten, keine davon ausgelastet:
- der Node-Provisioner (Karpenter) forderte eine volle CPU an,
- ein Warm-Pool-Platzhalter reservierte 900 Millicores, damit neue Nodes schon warm sind,
- der CPU-Embedding-Server lief mit zwei Replicas zu je einer CPU und 1,5 GiB und verbrauchte im Leerlauf etwa 12 MiB Speicher.
Zusammen bestimmten diese Requests, nicht irgendein Traffic, wie viele Maschinen es gab. Der Cluster wurde danach dimensioniert, was seine Workloads in Eile angefordert hatten, nicht danach, was sie taten.
Die Lehre ist deutlich: Requests bestimmen die Node-Anzahl. Wer eine kleinere Rechnung will, hat als Hebel die Zahlen in seinen Manifesten, und denen kann man erst trauen, wenn man die echte Nutzung daneben gemessen hat.
Der Umbau
Mit der Messung in der Hand wählte ich die Form:
- Drei
m7g.large-Nodes, einer pro Availability Zone. Nichtm6g, das für dasselbe Geld langsamer ist, und nichtm8g, das mehr kostet für CPU, die wir nicht brauchten. - Cluster Autoscaler statt Karpenter. Für einen so kleinen und vorhersehbaren Cluster ist eine verwaltete Node-Group mit einem einfachen Autoscaler leichter zu durchschauen als ein Provisioner, der Instanztypen spontan wählt. Das war eine Entscheidung, die ich traf, solange es keine Kunden gab; bei einer großen, sprunghaften Flotte würde ich sie nicht blind treffen.
- Embedding-Server auf 250 Millicores und 1 GiB gekürzt. Er lief mit etwa 12 MiB im Leerlauf, selbst das ist großzügig.
- Zonenverteilung für die Workloads, damit der Ausfall einer Zone nicht einen ganzen Service mitnimmt.
Nach der Änderung passten die Requests auf zwei Nodes bei etwa 92 % CPU und 62 % Speicher, und der dritte Node existiert für die Zonenverteilung. Das Hochskalieren auf einen vierten Node dauerte 75 Sekunden, das Zurückskalieren auf drei etwa 12 Minuten. Die Anwendung antwortete bei jeder Prüfung während der Migration mit 200.
Auch die Autoscaler lesen Requests
Hier wird es interessant, denn dieselbe Regel, die die Node-Anzahl aufblähte, bricht stillschweigend beide Autoscaler.
Das Utilization-Ziel des Horizontal Pod Autoscalers ist ein Prozentsatz der Requests. Bei einem winzigen Request ist 80 % eine winzige Zahl:
resources:
requests:
cpu: 100m
metrics:
- type: Resource
resource:
name: cpu
target:
type: Utilization
averageUtilization: 80 # greift bei 80m CPU, nicht bei 80 % eines Cores
Ein Service, der fast nichts tut, überschreitet 80 Millicores sofort, also springt jeder Service fast sofort auf seine maximale Replica-Zahl. Das Ziel sieht im Review vernünftig aus und bedeutet in der Produktion nichts.
Der Cluster Autoscaler vergrößert den Cluster bei Pending-Pods, nicht bei ausgelasteter CPU. Bei winzigen Requests passen drei Replicas von allem bequem auf drei Nodes, also ist nie ein Pod pending, also fügt der Autoscaler nie einen Node hinzu, selbst wenn die CPU am Anschlag ist. Der Fehlerfall ist ein Cluster, der heiß läuft und sich weigert zu wachsen.
Beide Probleme haben dieselbe Lösung: Setze Requests nahe an der echten Nutzung, bevor du Autoscaling einschaltest. Sonst greift der HPA zu früh und der Cluster Autoscaler zu spät, und beide arbeiten genau wie entworfen.
Die Falle, die still etwa 60 $ im Monat kostet
Ein Review-Fund verdient einen eigenen Absatz, weil er unsichtbar bleibt, bis man die Rechnung liest. Der Cluster Autoscaler hat als Standard skip-nodes-with-system-pods=true. Jeder Node, der einen kube-system-Pod ohne PodDisruptionBudget hält, der kein DaemonSet ist, wird nie heruntergeskaliert. Zwei unserer Controller, der Load-Balancer-Controller und der EFS-CSI-Controller, hatten kein PDB.
Ein Node, der unter Last hochskaliert wurde und zufällig einen davon bekam, würde also für immer bleiben, etwa 60 $ im Monat pro festhängendem Node, ohne Alert und ohne Spur in den Logs. Ein Skalierungstest mit einem Wegwerf-Pod auf dem neuen Node fängt das nicht, weil der Wegwerf-Pod kein System-Pod ist. Ich habe den Modul-Default auf false gesetzt und live angewendet. Wenn du den Cluster Autoscaler betreibst, prüfe dieses Flag und prüfe deine System-Pods auf PDBs.
Wenn die teure Arbeit woanders läuft
Die Folgefrage war die naheliegende: Wie viele Nutzer kann das bedienen? Die Antwort hat weniger mit den Nodes zu tun, als ich erwartet hatte.
Die Nodes des Clusters sind fast im Leerlauf, weil das Sprachmodell bei einem gehosteten Anbieter läuft. Eine Chat-Nachricht kostet ein paar Spring-Hops, ein Query-Embedding auf dem CPU-Embedding-Server und eine Vektor-Abfrage; die schwere Arbeit passiert auf fremder Hardware. Die ersten Kapazitätsgrenzen sind also nicht die CPU:
- die Rate Limits des Anbieter-Plans, da ein Key alles bedient,
- Dokument-Uploads, die sich auf dem CPU-Embedding-Server stauen,
- feste Replica-Zahlen und
- die maximale Kapazitätseinstellung der Datenbank.
Erst danach zählt Compute. Mein grobes Modell, das eine Schätzung und kein Lasttest ist, sagt etwa 800 bis 1.500 gleichzeitig aktive Nutzer auf drei Nodes, sobald Autoscaling und Anbieter-Limits geklärt sind, und realistische Kosten um 2.400 $ im Monat bei 10.000 gleichzeitigen Nutzern, mit der Wachstumsregel drei weitere Nodes pro 800 Nutzer. Die CPU pro Request in diesem Modell ist eine Schätzung auf etwa den Faktor zwei genau, und ein Lasttest gegen die Demo-Umgebung ersetzt sie durch Zahlen.
Es geht nicht um die Zahl. Es geht darum, dass die Kapazität deines Clusters nicht die Kapazität deines Produkts ist, wenn die teure Arbeit bei einem Anbieter läuft. Lies die Limits des Anbieters, bevor du deine eigenen Nodes skalierst.
Was bleibt
- Requests bestimmen die Node-Anzahl, nicht die Nutzung. Miss die echte Nutzung, dann setze Requests daneben. Vergleiche
kubectl topmit dem Allocated-Resources-Block, nicht mit deinem Bauchgefühl. - Prüfe Autoscaler gegen deine Requests. Der Prozentsatz des HPA ist ein Anteil der Requests, und der Cluster Autoscaler reagiert nur auf Pending-Pods. Winzige Requests lassen den ersten zu früh und den zweiten nie greifen.
- Prüfe Scale-down-Blocker.
skip-nodes-with-system-podsplus ein fehlendes PDB lässt bezahlte Nodes still für immer laufen. - Finde den echten Engpass vor der Dimensionierung. Läuft der teure Schritt bei einem Anbieter, kommen dessen Limits vor deiner CPU.