Zum Inhalt springen

Kubernetes Resource Calculator · Kubernetes

Kubernetes-CPU und -Arbeitsspeicher auf einen Blick summieren.

Verwandeln Sie CPU-Requests und -Limits in Millicores wie 250m und Arbeitsspeicher in Mi / Gi in normalisierte Werte und Summen über Replicas hinweg — kostenlos, online, ohne erforderliche Registrierung.

Läuft in Ihrem Browser CPU & Arbeitsspeicher Keine Registrierung Aktualisiert am 19.07.2026

Kubernetes Resource Calculator Playground

CPU takes cores or millicores (500m, 1, 2.5). Memory takes binary (256Mi, 4Gi) or decimal (1G) suffixes, or bytes. Leave a field blank to skip it.

Result

Enter a CPU or memory value — or pick an example — to see a per-pod and total-across-replicas breakdown here.

Die Lücke

Ein falsches Suffix, ein Node-Pool über dem Budget.

Kubernetes-Ressourcenmengen vermischen zwei Zahlensysteme — Bruchteile von Kernen, gemessen in Millicores, und Arbeitsspeicher, gemessen in binären Mebibytes, die fast wie dezimale Megabytes aussehen. Multiplizieren Sie einen Request pro Container im Kopf mit einer Anzahl von Replicas, ist die Fehlerart still: ein zu klein dimensionierter Node-Pool, ein Pod, der nie geplant wird, oder ein versehentlich unter seinem Request gesetztes Limit, das der API-Server ablehnt.

Dieser kostenlose Kubernetes Resource Calculator verwandelt diese Mengen in die konkreten Fakten, die Sie tatsächlich benötigen — normalisierte CPU in Millicores, Arbeitsspeicher in exakten Bytes und die gesamte CPU und den gesamten Arbeitsspeicher über Pods und Replicas hinweg, die ein Workload reserviert und begrenzt — sodass Sie die Zahlen bestätigen können, bevor sie in ein Manifest gelangen. Vollständig im Browser, ohne Installation und ohne dass jemals Daten Ihr Gerät verlassen.

Codieren Sie die Werte als Nächstes in ein Secret? Greifen Sie zum Base64 Encoder / Decoder.

Die Pipeline

So funktioniert es.

Vier deterministische Schritte laufen bei jedem Tastenanschlag — alle in Ihrem Browser-Tab, mit exakter Ganzzahlarithmetik.

  1. Die Mengen parsen.

    Jeder Request und jedes Limit wird als Kubernetes-Menge gelesen — eine Zahl plus ein optionales Einheitensuffix wie m, Mi oder Gi.

  2. Die Einheiten normalisieren.

    CPU wird in ganze Millicores und Arbeitsspeicher in exakte Bytes umgewandelt, sodass binäre (Mi/Gi) und dezimale (M/G) Werte korrekt verglichen werden.

  3. Mit den Replicas multiplizieren.

    Requests und Limits pro Container werden mit der Anzahl der Replicas multipliziert, um die gesamte CPU und den gesamten Arbeitsspeicher zu ergeben, die der Workload reserviert und begrenzt.

  4. Die Konflikte markieren.

    Jede Zeile, deren normalisiertes Limit niedriger ist als ihr Request, wird markiert, da Kubernetes ein Limit unterhalb des garantierten Requests ablehnt.

Einheitenreferenz

Was jedes Suffix bedeutet.

Kubernetes-CPU verwendet Millicores; Arbeitsspeicher verwendet zwei Suffixfamilien — binär Ki/Mi/Gi und dezimal K/M/G — die nah beieinander, aber nie gleich sind.

CPU- & Arbeitsspeicher-Suffixe

CPU normalisiert auf Millicores (1000m = ein Kern); Arbeitsspeicher normalisiert auf Bytes, wobei Mi/Gi gleich 1024^n und M/G gleich 1000^n sind.

resource-suffixes
cpu suffix     meaning              example       millicores
(none)         whole cores          2             2000m
m              millicores           250m          250m
0.x            fractional cores     0.5           500m

memory suffix  meaning              example       bytes
Ki             1024^1  (binary)     512Ki         524,288
Mi             1024^2  (binary)     256Mi         268,435,456
Gi             1024^3  (binary)     2Gi           2,147,483,648
K              1000^1  (decimal)    512K          512,000
M              1000^2  (decimal)    256M          256,000,000
G              1000^3  (decimal)    2G            2,000,000,000

note  Mi/Gi are 1024^n (mebi/gibi); M/G are 1000^n (mega/giga).
      1 Gi = 1,073,741,824 bytes  ≈  1.074 GB

Summen über Replicas hinweg

Jeder Request und jedes Limit pro Container wird mit der Anzahl der Replicas multipliziert, sodass Sie einen Node-Pool gegen die Requests dimensionieren und die Obergrenze gegen die Limits im Blick behalten können.

totals
container  requests          limits            replicas
api        cpu 250m mem 256Mi  cpu 500m mem 512Mi   3

totals
  cpu     requests 750m       limits 1500m  (1.5 cores)
  memory  requests 768Mi      limits 1536Mi (1.5 Gi)

Nächster Schritt

Dimensioniert? Codieren Sie die Werte in ein Secret.

Sobald die Requests und Limits korrekt aussehen, landet Konfiguration, die daneben mitläuft — Tokens, Verbindungszeichenfolgen, Zertifikate — oft in einem Kubernetes Secret, dessen data-Werte Base64-codiert sein müssen. Der Base64 Encoder / Decoder erledigt das im Browser, oder durchsuchen Sie das vollständige Tool-Verzeichnis für den Rest des Kits.

secret.yaml
apiVersion: v1
kind: Secret
metadata:
  name: api
type: Opaque
data:
  # values are base64-encoded
  token: c3VwZXItc2VjcmV0

FAQ

Fragen, beantwortet.

Tippen Sie auf eine Frage, um die Antwort aufzuklappen.

Ein Millicore (das Suffix m, wie in 250m) ist ein Tausendstel eines CPU-Kerns, sodass 1000m einer vCPU / einem Hyperthread entspricht. Kubernetes misst CPU in diesen Bruchteileinheiten, weil ein Pod selten einen ganzen Kern benötigt — 250m bedeutet einen garantierten Anteil von einem Viertel Kern. Eine einfache Zahl wie 0,5 ist dasselbe wie 500m; der Rechner normalisiert alles auf Millicores, damit Requests und Summen übereinstimmen.

Mi ist ein Mebibyte — 1024 × 1024 = 1.048.576 Bytes — während MB üblicherweise ein Megabyte von 1.000.000 Bytes meint. Die Kubernetes-Speichersuffixe Ki / Mi / Gi sind binär (Potenzen von 1024); die suffixfreien K / M / G sind dezimal (Potenzen von 1000). Sie liegen nah beieinander, sind aber nicht gleich: 1 Gi entspricht etwa 1,074 GB. Werden sie vermischt, kommt es zu stiller Unterversorgung, weshalb der Rechner die beiden Familien getrennt hält und beide in exakte Bytes umrechnet.

Ein Request ist das, was der Scheduler für einen Container reserviert — er garantiert diese Menge an CPU und Arbeitsspeicher und wird vom Bin-Packing verwendet, um den Pod auf einem Node zu platzieren. Ein Limit ist die harte Obergrenze: CPU oberhalb des Limits wird gedrosselt, und Arbeitsspeicher oberhalb des Limits führt dazu, dass der Container per OOM beendet wird. Requests steuern die Kapazitätsplanung; Limits begrenzen den Schadensradius. Der Rechner summiert beide, sodass Sie einen Node-Pool gegen die Requests dimensionieren und die Obergrenze gegen die Limits im Blick behalten können.

Das ist ungültig — der Kubernetes-API-Server weist einen Container ab, dessen Limit niedriger ist als sein Request, denn Sie können eine Ressource nicht unterhalb der bereits garantierten Menge begrenzen. Der Rechner markiert jede Zeile, in der das normalisierte Limit unter den normalisierten Request fällt, sodass Sie den Fehler hier erkennen statt bei einem fehlgeschlagenen Apply oder einer Ablehnung durch einen Admission-Webhook.

Nein. Jede Menge wird zu 100 % clientseitig in Ihrem Tab geparst, normalisiert und summiert — es gibt keinen Server, kein Konto und kein Logging. Sie können Ressourcenblöcke aus internen Manifesten bedenkenlos einfügen; nichts wird hochgeladen.

Der gesamte Request und das gesamte Limit eines Pods ist die Summe der einzelnen Werte aller seiner Container. Multiplizieren Sie diese Pod-Summe mit der Anzahl der Replicas, um zu erhalten, was das gesamte Deployment reserviert. Beispielsweise ergeben 3 Replicas mit je 250m CPU und 256Mi Arbeitsspeicher insgesamt 750m CPU und 768Mi. Geben Sie die Werte pro Container und die Anzahl der Replicas in den Rechner ein, und er berechnet die Summen des Workloads sofort.

Mi (Mebibytes) und Gi (Gibibytes) sind Binäreinheiten, bei denen 1024Mi gleich 1Gi sind. Teilen Sie Mi durch 1024, um Gi zu erhalten, und multiplizieren Sie Gi mit 1024, um Mi zu erhalten. Ein Gi entspricht 1.073.741.824 Bytes, was etwas größer ist als 1G (1.000.000.000 Bytes). Der Rechner normalisiert alle Speicherwerte intern auf exakte Bytes, sodass Mi- und Gi-Eingaben ohne manuelle Umrechnung korrekt verglichen und summiert werden.

Ja, der Rechner ist vollständig kostenlos. Er läuft vollständig in Ihrem Browser ohne Server, ohne Konto und ohne Datenupload — Sie müssen sich weder registrieren noch anmelden. Sie können Ressourcenwerte aus internen Manifesten bedenkenlos einfügen, da nichts Ihr Gerät verlässt.

Basieren Sie die Requests auf der beobachteten p95- oder p99-Nutzung, die Sie mit kubectl top über einen repräsentativen Zeitraum von 24 Stunden erfasst haben, und setzen Sie die Limits dann auf etwa das Zwei- bis Fünffache des Request-Werts. Zu hoch angesetzte Requests verschwenden planbare Node-Kapazität; zu niedrig angesetzte lassen den Pod unter Last verhungern und verursachen CPU-Drosselung oder OOMKills. Verwenden Sie den Rechner, um die Werte pro Container über die Replicas zu summieren, bevor Sie Zahlen in ein Manifest übernehmen.

More free, private DevOps tools.

Der Kubernetes Resource Calculator ist ein Tool in OpsCanopy — einem wachsenden Schirm browserbasierter Validatoren, Konverter und Tester, die niemals einen Server berühren.

Neu bei Docker?  Zum Docker-Guide →

29 kostenlose Tools, jedes einzelne offlinefähig — opscanopy.com funktioniert ohne Registrierung, und nichts wird hochgeladen.

Verwandt: der Base64 Encoder / Decoder und der Subnet Calculator, oder durchsuchen Sie das vollständige Tool-Verzeichnis.

Ohne Gewähr zur Vereinfachung bereitgestellt; bestätigen Sie kritische Kapazitätsänderungen stets anhand Ihrer eigenen Quelle. OpsCanopy ist kostenlos und offen.