/
Kubernetes-Ressourcen & Pod-Sizing
Kategorie

Kubernetes-Ressourcen & Pod-Sizing

Interaktiver Kubernetes-Ressourcen-Rechner (Pod-CPU- & Memory-Sizing) mit clientseitiger Echtzeitanalyse und Visualisierung.

QoS-Engine
Cloud-Reserven
Voreinstellungen
Betriebsmodus

Workload-Profiler

Basis-CPU
450m (0.45 cores)
Schnellauswahl
Basis-Speicher
1,536 MiB (1.50 GiB)
Schnellauswahl
QoS-Strategie
Burstable
CPU-Limit-Verhältnis2.00x
RAM-Limit-Puffer+25%
Cloud-Anbieter
Max. Pods
DaemonSet-CPU
DaemonSet-RAM
Summe der Pod-Requests: 563m / 1,920Mi
6 Pod-Anzahl
Benötigte Nodes1Nodesm6i.xlarge
Pod-Requests563m CPU1,920 MiB RAM
Zugewiesene QoSBurstableadj: 883
Monatliche Kosten$140.16730 Stunden pro Monat
Allocatable-Kapazität pro Node
4 vCPU / 16 GiB Raw
CPU-Balken-Titel (Total: 4000m)Allocatable: 3670m (91.8%)
Kube-Reserved: 80mDaemonSet Overhead: 250mWorkload Pods: 3378mFreie Kapazität (Slack)
Kube-Reserved (80m)DaemonSet (250m)Pod-Workload (3378m)Freie Kapazität (Slack)
Arbeitsspeicher-Aufteilung (Total: 16384 MiB)Allocatable: 13022 MiB (79.5%)
Kube-Reserved RAM: 2762MiBDaemonSet RAM: 600MiBWorkload RAM: 11520MiBFreie Kapazität (Slack)
Kube-Reserved (2762 MiB)DaemonSet (600 MiB)Pod-Workload (11520 MiB)Freie Kapazität (Slack)
Sizing-Diagnose
EngpassBalanced / Density Aligned
CFS-StatusModerate (Burst headroom available)
Eviction-VerhaltenMedium (Protected up to request ceiling)
AST-Ausführungsstatus
Format-Tag: VISUALIZER
Hauptmetrik
3.38 vCPU-Einheit / 11.25 GiB RAM
6 Aktive Replikate
Effizienz / Kapazität
92.0% Kerne / 88.5% RAM-Einheit
Balanced / Density Aligned
Netto-Ergebnis
$140.16
1 Nodes vom Typ m6i.xlarge

Clientseitige Verarbeitung

Hochleistungsberechnung, die vollständig im Browser-Speicher ausgeführt wird.

Datenschutz ohne Server-Upload

Alle Payloads verbleiben strikt lokal – ohne jegliche externe Serverkommunikation.

Produktionsreifer Export

Saubere, optimierte Ausgabeformate, bereit für das sofortige Deployment.

Technische Referenz & Architektur-Leitfaden

Kubernetes Ressourcen & Pod-Sizing — Referenzhandbuch

Interaktiver Kubernetes-Ressourcenrechner (Pod-CPU- & RAM-Sizing) mit clientseitiger Echtzeitanalyse und visueller Kapazitätsplanung.

Kubernetes Ressourcen & Pod-Sizing — Referenzhandbuch — Client-seitige In-Memory-Architektur und Datenfluss
Kubernetes Ressourcen & Pod-Sizing — Referenzhandbuch — Client-seitige In-Memory-Architektur und Datenfluss

Wichtige Parameter & Einstellungen

Pod-CPU-Basislast (P95 in Millicores)Millicores (mCPU) / vCPU dezimal

Kontinuierliche CPU-Kernauslastung im 95. Perzentil (P95), ermittelt über ein 7-tägiges Prometheus- oder Datadog-Beobachtungsfenster unter stabiler Produktionslast (ohne Kaltstart-Anomalien). Bewertet anhand der 100-ms-Quota-Abrechnungsperioden des Linux Completely Fair Scheduler (CFS).

Standard: 250m
Spitzenlast-Puffer & tageszeitliche Burst-Reserve (%)Prozent (%)

Dynamischer Sicherheitspuffer, berechnet als Request_CPU = Basis_CPU * (1 + Puffer_Prozent / 100). SRE-Best-Practices (Site Reliability Engineering) empfehlen 20 % bis 30 % Puffer, um tageszeitliche Lastspitzen zuverlässig abzufangen, ohne Pod-Evictions oder Scheduling-Engpässe auf Node-Ebene auszulösen.

Standard: 25%
Pod-Arbeitsspeicher-Working-Set (RSS + aktiver Cache)Megabyte (MiB) / Gigabyte (GiB)

Aktive Resident Set Size (RSS) und nicht freigebbarer Speicher basierend auf der Kubernetes-Metrik container_memory_working_set_bytes. Im Gegensatz zum freigebbaren Page-Cache bildet dieser Wert den Basisschwellenwert, bevor Linux-cgroup-v1/v2-Speicherdruck-Controller aktiv eingreifen.

Standard: 512Mi
Ziel-QoS-Klassenspezifikation des PodsKubernetes-QoS-Stufe (Guaranteed | Burstable | BestEffort)

Quality-of-Service-Stufe, die das oom_score_adj-Scoring des Linux-Kernels steuert. Guaranteed erfordert cpu.limits == cpu.requests UND memory.limits == memory.requests (oom_score_adj: -997 bis -998, niedrigste Eviction-Priorität); Burstable erfordert requests < limits (dynamischer oom_score_adj: 1000 - 1000 * mem_req / node_mem); BestEffort verzichtet auf beide Angaben (oom_score_adj: 1000, wird zuerst beendet).

Standard: Burstable
Hardwareprofil der Ziel-Worker-Node-InstanzCompute-Instanztyp (vCPU / GiB RAM)

Hardwarespezifikation des Bare-Metal-Hosts oder der virtuellen Maschine (z. B. AWS m6i.2xlarge mit 8 vCPUs und 32 GiB RAM oder GCP n2-standard-8). Unterliegt stufenweisen Cloud-Abzügen: Allocatable = Bruttokapazität - Kubelet_Reserved - System_Reserved - Eviction_Hard_Threshold (100 MiB).

Standard: 8 vCPU / 32 GiB RAM
Horizontale Deployment-Replika-AnzahlGanzzahl (Pods / Skalierungsziele)

Zielanzahl an Replikas für Hochverfügbarkeit und N+1- / N+2-Fehlerdomänen-Redundanz über mehrere Verfügbarkeitszonen hinweg. Bestimmt unmittelbar die Bin-Packing-Dimensionen der Worker-Nodes: Nodes_Needed = max(ceil(Gesamt_CPU_Req / Allocatable_CPU), ceil(Gesamt_Mem_Req / Allocatable_Mem), ceil(Gesamt_Replikas / Effektive_Max_Pods)).

Standard: 12

Profi-Tipps & Best Practices

P99-Latenz-Klippen durch Weglassen von CFS-CPU-Limits bei Multi-Threaded-Runtimes eliminieren

Das Definieren von 'resources.limits.cpu' aktiviert den Quota-Mechanismus des Linux Completely Fair Scheduler (cpu.cfs_quota_us über ein Fenster von 100 ms via cpu.cfs_period_us). Multi-Threaded-Laufzeitumgebungen (Go-Goroutinen, JVM-GC-Threads, Node.js-Worker-Pools) verteilen Rechenlast parallel auf alle vCPUs des Nodes. Wenn 8 Threads für 12,5 ms laufen, verbrauchen sie 100 ms Quota in nur 13 ms Echtzeit. Der Linux-Kernel drosselt (throttled) den gesamten Prozess daraufhin für die verbleibenden 87 ms. Dies erzeugt künstliche P99-Latenzspitzen und Upstream-Timeouts, obwohl der Host-Node bei lediglich 20 % CPU-Auslastung liegt. Die SRE-Best-Practice für latenzkritische Microservices lautet daher: Großzügige CPU-Requests passend zu P95 + Puffer festlegen, CPU-Limits weglassen und strikte Memory-Limits setzen, um vor Memory Leaks zu schützen.

Stufenförmige Berechnungsformeln für Node-Allocatable bei GKE und EKS berücksichtigen

Berechnen Sie die Clusterkapazität niemals anhand unbereinigter Brutto-Hardwarespezifikationen. Cloud-Provider ziehen Systemkapazitäten nach einer offiziellen stufenweisen Formel ab: Reservierter_RAM = 25 % von [0..4 GiB] + 20 % von [4..8 GiB] + 10 % von [8..16 GiB] + 6 % von [16..128 GiB] + 2 % von [>128 GiB], ergänzt um einen unveränderlichen Hard-Eviction-Schwellenwert von 100 MiB. Bei einem 32-GiB-Worker-Node (z. B. AWS m6i.2xlarge oder GCP n2-standard-8) ergibt dies einen Abzug von 25 %(4) + 20 %(4) + 10 %(8) + 6 %(16) + 0,1 GiB = 1,0 + 0,8 + 0,8 + 0,96 + 0,1 = 3,66 GiB. Es verbleiben somit lediglich ~28,34 GiB Allocatable RAM. Wird dies in Bin-Packing-Algorithmen ignoriert, führt dies zu unplatzierten Pods im Status 'Pending' und vorzeitiger Preemption beim Node-Bootvorgang.

IP-Erschöpfung durch MaxPods im AWS VPC CNI bei hochdichter Node-Planung vermeiden

Der Knotenbedarf im Cluster wird häufig nicht durch CPU- oder Speichererschöpfung limitiert, sondern durch Netzwerkschnittstellen-Grenzen des CNI-Plugins. Beim Standard-AWS-VPC-CNI wird die maximale Pod-Anzahl pro EC2-Instanz durch ENI-Limits bestimmt: MaxPods = (ENIs - 1) * (IPv4_pro_ENI - 1) + 2. Eine m6i.large-Instanz (2 vCPU, 8 GiB) unterstützt beispielsweise nur 3 ENIs mit jeweils 10 IPs, was die Pod-Dichte unabhängig von der Leichtgewichtigkeit der Container strikt auf 29 Pods deckelt. Bei der Berechnung der Worker-Node-Anzahl via Nodes_Needed = max(ceil(Gesamt_CPU_Req / Allocatable_CPU), ceil(Gesamt_Mem_Req / Allocatable_Mem), ceil(Gesamt_Replikas / Effektive_Max_Pods)) führt das Ignorieren dieser MaxPods-Obergrenze dazu, dass Nodes rechentechnisch halb leer bleiben, während verbleibende Replikas mangels freier IPs nicht gescheduled werden können.

Stateful Data-Stores mit Guaranteed-QoS-Pods und fixiertem oom_score_adj absichern

Bei akutem Arbeitsspeichermangel bewertet der Out-Of-Memory (OOM) Killer des Linux-Kernels jeden Prozess anhand seines Werts in /proc/[pid]/oom_score. Kubernetes bildet die Pod-QoS-Klassen direkt auf oom_score_adj ab: Guaranteed-Pods (cpu.limits == cpu.requests UND memory.limits == memory.requests) erhalten den Wert -997 oder -998, was sie praktisch vor einer Eviction schützt, solange der Kernel selbst noch über ausreichend Speicher verfügt. Burstable-Pods erhalten dynamische Scores zwischen 2 und 999, berechnet über max(floor(1000 * mem_request / node_capacity), 1000 - 1000 * mem_request / node_capacity), während BestEffort-Pods fest auf 1000 gesetzt und somit sofort beendet werden. Konfigurieren Sie PostgreSQL-, Redis-, Kafka- und Ingress-Controller-Pods stets als Guaranteed, um kaskadierende Failover-Schleifen bei Speicherengpässen auf Node-Ebene zu verhindern.

Kryptografisches In-Browser-Sandboxing & deterministisches O(n)-Bin-Packing

Zur Gewährleistung vollständiger Zero-Trust-Datensicherheit laufen Kapazitätsberechnungen und mehrdimensionale Vektor-Bin-Packing-Simulationen strikt lokal in der Browser-Runtime mit O(n)-First-Fit-Decreasing-Komplexität ab. Cluster-Ressourcentopologien, Pod-Definitionen und Replika-Zahlen verbleiben vollständig isoliert im Arbeitsspeicher des Clients. Für Layout-Entropie kommen native CSPRNG-Primitive der Web Crypto API zum Einsatz – ganz ohne serverseitige Telemetrie oder Egress-Logging, in voller Übereinstimmung mit DSGVO-, SOC 2 Type II- und RFC-geprüften Vertraulichkeitsstandards.

Häufige Fehlerquellen & Fehlerbehebung

⚠️Pods werden mit Exit Code 137 (OOMKilled) beendet, obwohl App-Metriken Speicher unterhalb des Limits anzeigen

Exit Code 137 signalisiert die Beendigung durch das Signal SIGKILL (128 + 9). Diese Diskrepanz entsteht, weil Anwendungs-Laufzeitumgebungen (z. B. der Node.js-Heap oder die Go-Runtime) lediglich den virtuellen Speicher oder den gemanagten Heap ausweisen. Der cgroup-v1/v2-Speicher-Controller des Linux-Kernels überwacht hingegen 'container_memory_working_set_bytes'. Dieser Wert beinhaltet Memory-Mapped Files (mmap), aktive I/O-Page-Caches und native Speicherallokationen außerhalb des Heaps. Übersteigt memory.current den Wert memory.max (limits.memory), löst der cgroup-Controller unverzüglich einen OOM-Kill aus – ohne Vorwarnung an den Anwendungsprozess. Lösung: Fragen Sie in Prometheus 'container_memory_working_set_bytes{pod=...}' statt anwendungsinterner Metriken ab, erhöhen Sie resources.limits.memory um 25 % bis 35 % über das beobachtete P95-Working-Set oder optimieren Sie Dateideskriptoren für Memory-Mapped Files und native Thread-Pool-Allokationen.

⚠️Multi-Threaded-Anwendungen verzeichnen massive P99-Latenzspitzen trotz geringer CPU-Auslastung des Clusters

Hierbei handelt es sich um die klassische Quota-Throttling-Falle des Linux Completely Fair Scheduler (CFS). Wird 'resources.limits.cpu' gesetzt, konfiguriert das Kubelet den Parameter 'cpu.cfs_quota_us' bezogen auf ein Abrechnungsintervall von 100.000 µs (100 ms). Parallele Anwendungen (etwa Java-JVM mit parallelem GC, Go-Goroutinen-Scheduling über runtime.GOMAXPROCS oder Webserver mit Multi-Worker-Architektur) führen Threads gleichzeitig über alle verfügbaren Host-Kerne aus. Besitzt ein Pod auf einem 8-Kern-Node ein Limit von 1000m (1 Kern = 100 ms Quota), verbrennen 8 aktive Threads die 100 ms Gesamtquota in nur 12,5 ms Echtzeit. Der Linux-Kernel drosselt alle Container-Threads daraufhin für die restlichen 87,5 ms des Intervalls. Lösung: Prüfen Sie die Prometheus-Metrik 'container_cpu_cfs_throttled_periods_total / container_cpu_cfs_periods_total'. Liegt das Throttling über 5 %, entfernen Sie 'resources.limits.cpu' vollständig oder erhöhen Sie das Limit auf das 3-Fache der Requests. Passen Sie zudem Runtime-Thread-Pools (z. B. GOMAXPROCS oder Javas ActiveProcessorCount) exakt an die CPU-Requests des Pods an.

⚠️Deployment-Replikas verharren im Status Pending mit '0/N nodes available: Insufficient cpu', obwohl Nodes ungenutzte Kapazitäten aufweisen

Scheduling-Entscheidungen in Kubernetes basieren ausschließlich auf den definierten Ressourcen-'Requests' der Pods, NICHT auf dem tatsächlichen Echtzeit-CPU-Verbrauch. Wenn vier Pods mit jeweils 2000m CPU-Request auf einem 8-vCPU-Node platziert sind, ist der Node für den Kube-Scheduler zu 100 % reserviert – selbst wenn die Container real nur mit 5 % Last laufen. Ein fünfter Pod mit einem Request von 1000m wird abgewiesen und verbleibt im Status 'Pending'. Zudem belegen DaemonSets (z. B. calico-node, aws-node, fluentbit, datadog) auf jedem Node Vorab-Ressourcen, bevor Anwendungs-Pods platziert werden können. Lösung: Führen Sie 'kubectl describe node <name>' aus und prüfen Sie den Abschnitt 'Allocated resources'. Passen Sie die Pod-Größen an (Right-Sizing), indem Sie die CPU-Requests auf den realen P95-Basisverbrauch zuzüglich 20 % Puffer reduzieren. Dies setzt Scheduler-Kapazitäten frei und ermöglicht dem Kube-Scheduler das Bin-Packing ausstehender Workloads, ohne unnötige Cloud-Instanzen hochfahren zu müssen.

Häufig gestellte Fragen (FAQ)

Wie berechnet man CPU- und Memory-Requests sowie Limits in Kubernetes?▼

Zur Berechnung von CPU- und Memory-Requests ermitteln Sie zunächst den P95-Verbrauch unter stabiler Last über einen Zeitraum von 7 Tagen via Prometheus oder Datadog. Setzen Sie die Requests auf den P95-Wert zuzüglich eines Puffers von 20 % bis 30 % (Request = P95 * 1,25), um tageszeitliche Lastspitzen abzufedern, ohne Scheduler-Evictions zu riskieren. Für Memory-Limits empfiehlt sich eine Obergrenze von 20 % bis 30 % über dem Request, um temporäre Heap-Ausdehnungen und Memory-Mapped-File-Puffer aufzufangen, bevor die cgroup-Grenze 'memory.max' des Linux-Kernels erreicht wird. Bei CPU-Limits entspricht es moderner Best-Practice für latenzkritische Microservices, Limits auf das 2- bis 3-Fache der Requests festzusetzen oder ganz wegzulassen, um Quota-Throttling durch den Linux Completely Fair Scheduler (CFS) zu verhindern. Dies wird idealerweise mit Cluster-Autoscaling und Guaranteed-Speicherobergrenzen kombiniert.

Was ist der Unterschied zwischen den QoS-Klassen Guaranteed und Burstable in Kubernetes?▼

Die QoS-Klasse Guaranteed erfordert, dass CPU- und Memory-Requests exakt ihren jeweiligen Limits entsprechen (cpu.limits == cpu.requests UND memory.limits == memory.requests) – und zwar für alle Container im Pod. Dies weist dem Prozess einen oom_score_adj von -997 bis -998 zu, was nahezu vollständige Immunität gegen Evictions bei Speicherknappheit auf dem Node garantiert. Burstable greift, wenn Requests strikt niedriger als Limits sind oder CPU-Limits ganz weggelassen werden; hierbei wird der oom_score_adj dynamisch zwischen 2 und 999 berechnet. Bei drohendem Speichermangel beenden das Kubelet und der Linux-OOM-Killer zuerst BestEffort-Pods (oom_score_adj: 1000), danach Burstable-Pods, die ihren Memory-Request überschreiten, und erst ganz zuletzt Guaranteed-Pods.

Sollten CPU-Limits für Kubernetes-Pods in Produktion immer gesetzt werden?▼

Nein, das Setzen harter CPU-Limits ist bei multi-threaded Microservices oft kontraproduktiv. Die Angabe von 'resources.limits.cpu' veranlasst den Completely Fair Scheduler des Linux-Kernels, strikte Millisekunden-Quotas (cpu.cfs_quota_us) über 100-ms-Zeitfenster durchzusetzen. Wenn Multi-Threaded-Runtimes (Go, Java, Node.js-Worker-Pools) Lastspitzen über mehrere Host-Kerne verteilen, erschöpfen sie dieses Quota in nur 10 bis 20 ms. Der Kernel drosselt die Ausführung daraufhin für die restlichen 80 bis 90 ms. Das verursacht künstliche P99-Latenzsprünge und Verbindungsabbrüche, während der Host-Node zu 60 % unbeschäftigt bleibt. In Produktionsumgebungen empfiehlt es sich daher meist, großzügig bemessene CPU-Requests festzulegen, CPU-Limits wegzulassen und strikte Memory-Limits zu konfigurieren, um OOM-Kaskaden zuverlässig abzuwenden.

Warum brechen Kubernetes-Pods mit dem Exit Code 137 (OOMKilled) ab?▼

Exit Code 137 steht für die Beendigung eines Prozesses durch das Linux-Signal SIGKILL (128 + 9 = 137), ausgelöst durch den Out-Of-Memory-Killer. Dies geschieht in zwei Szenarien: 1) Überschreitung des Container-cgroup-Limits: Der Wert container_memory_working_set_bytes übersteigt 'resources.limits.memory', woraufhin der cgroup-Controller des Kernels den betreffenden Container sofort stoppt. 2) Speichererschöpfung des Host-Nodes: Der physische Arbeitsspeicher unterschreitet den Hard-Eviction-Schwellenwert des Kubelets (standardmäßig 100 MiB), woraufhin der System-OOM-Killer Pods mit dem höchsten oom_score_adj gezielt beendet (in der Regel BestEffort-Pods oder Burstable-Pods, die ihren Request überschreiten).

Wie viel CPU und Arbeitsspeicher reserviert Kubernetes für das Node-Betriebssystem?▼

Cloud-Anbieter reservieren Systemkapazitäten über gestufte Berechnungsformeln für 'kube-reserved' und 'system-reserved'. Bei AWS EKS und GCP GKE folgt die Speicherreservierung einer offiziellen Stufenkurve: 25 % der ersten 4 GiB, 20 % der nächsten 4 GiB (4 bis 8 GiB), 10 % der folgenden 8 GiB (8 bis 16 GiB), 6 % der weiteren 112 GiB (16 bis 128 GiB) sowie 2 % für Speicher jenseits von 128 GiB – zuzüglich eines obligatorischen Hard-Eviction-Schwellenwerts von 100 MiB. Bei der CPU werden ca. 6 % des ersten Kerns, 1 % des zweiten Kerns, 0,5 % der Kerne 3 und 4 sowie 0,25 % aller weiteren Kerne reserviert, um den Linux-Kernel, systemd und Kubelet-Dienste abzusichern.

Wie berechnet man die Anzahl benötigter Worker-Nodes für einen Kubernetes-Cluster?▼

Berechnen Sie die Gesamtanzahl der erforderlichen Cluster-Nodes mittels mehrdimensionalem Vektor-Bin-Packing: Nodes_Needed = max(ceil(Gesamt_Pod_CPU_Req / Allocatable_Node_CPU), ceil(Gesamt_Pod_Mem_Req / Allocatable_Node_Mem), ceil(Gesamt_Replikas / Effektive_Max_Pods)). Ziehen Sie zunächst stufenweise Cloud-Reservierungen und DaemonSet-Bedarfe von der Hardware-Bruttokapazität ab, um den tatsächlichen Wert für 'Allocatable' zu ermitteln. Summieren Sie anschließend alle Pod-Replika-Requests. Prüfen Sie abschließend, ob der Cluster CPU-limitiert, speicherlimitiert oder durch CNI-IP-Dichtegrenzen (z. B. AWS VPC CNI ENI-Limits) beschränkt ist, und runden Sie zur Gewährleistung von N+1-Hochverfügbarkeit auf die nächste ganze Zahl auf.

Verwandte Tools & Hilfsprogramme

Alle Tools →