Skip to content

Kubernetes Resource Calculator · Kubernetes

Total Kubernetes CPU and memory at a glance.

Turn CPU requests and limits in millicores like 250m and memory in Mi / Gi into normalized values and totals across replicas — free, online, no signup required.

Runs in your browser CPU & memory No signup Updated Jul 19, 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.

The Gap

One wrong suffix, a node pool over budget.

Kubernetes resource quantities mix two number systems — fractional cores measured in millicores, and memory measured in binary mebibytes that look almost like decimal megabytes. Multiply a per-container request by a replica count in your head and the failure mode is silent: a node pool sized too small, a Pod that never schedules, or a limit accidentally set below its request that the API server rejects.

This free Kubernetes resource calculator turns those quantities into the concrete facts you actually need — normalized CPU in millicores, memory in exact bytes, and the total CPU and memory across pods and replicas a workload reserves and caps — so you can confirm the numbers before they land in a manifest. Entirely in the browser, with nothing to install and no data ever leaving your device.

Encoding the values into a Secret next? Reach for the Base64 Encoder / Decoder.

The Pipeline

How it works.

Four deterministic steps run on every keystroke — all inside your browser tab, with exact integer arithmetic.

  1. Parse the quantities.

    Each request and limit is read as a Kubernetes quantity — a number plus an optional unit suffix like m, Mi or Gi.

  2. Normalize the units.

    CPU is converted to whole millicores and memory to exact bytes, so binary (Mi/Gi) and decimal (M/G) values compare correctly.

  3. Multiply by replicas.

    Per-container requests and limits are multiplied by the replica count to give the total CPU and memory the workload reserves and caps.

  4. Flag the conflicts.

    Any row whose normalized limit is lower than its request is flagged, since Kubernetes rejects a limit below the guaranteed request.

Unit Reference

What each suffix means.

Kubernetes CPU uses millicores; memory uses two families of suffix — binary Ki/Mi/Gi and decimal K/M/G — that are close but never equal.

CPU & memory suffixes

CPU normalizes to millicores (1000m = one core); memory normalizes to bytes, where Mi/Gi are 1024^n and M/G are 1000^n.

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

Totals across replicas

Each per-container request and limit is multiplied by the replica count, so you can size a node pool against requests and watch the ceiling against limits.

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)

Next Step

Sized it? Encode the values into a Secret.

Once the requests and limits read correctly, configuration that rides alongside them — tokens, connection strings, certificates — often goes into a Kubernetes Secret, whose data values must be Base64-encoded. The Base64 Encoder / Decoder handles that in the browser, or browse the full tools directory for the rest of the kit.

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

FAQ

Questions, answered.

Tap a question to expand the answer.

A millicore (the m suffix, as in 250m) is one thousandth of a CPU core, so 1000m equals one vCPU / hyperthread. Kubernetes measures CPU in these fractional units because a Pod rarely needs a whole core — 250m means a quarter of a core of guaranteed share. A plain number like 0.5 is the same as 500m; the calculator normalizes everything to millicores so requests and totals line up.

Mi is a mebibyte — 1024 × 1024 = 1,048,576 bytes — while MB usually means a megabyte of 1,000,000 bytes. Kubernetes memory suffixes Ki / Mi / Gi are binary (powers of 1024); the suffix-free K / M / G are decimal (powers of 1000). They are close but not equal: 1 Gi is about 1.074 GB. Mixing them silently under-provisions, so the calculator keeps the two families distinct and converts both to exact bytes.

A request is what the scheduler reserves for a container — it guarantees that much CPU and memory and is what bin-packing uses to place the Pod on a node. A limit is the hard ceiling: CPU above the limit is throttled, and memory above the limit gets the container OOM-killed. Requests drive capacity planning; limits cap blast radius. The calculator totals both so you can size a node pool against requests and watch the ceiling against limits.

It is invalid — the Kubernetes API server rejects a container whose limit is lower than its request, because you cannot cap a resource below the amount you have guaranteed. The calculator flags any row where the normalized limit falls under the normalized request so you catch the mistake here instead of in a failed apply or an admission webhook rejection.

No. Every quantity is parsed, normalized and totalled 100% client-side in your tab — there is no server, no account and no logging. You can safely paste resource blocks from internal manifests; nothing is uploaded.

A pod's total request and limit is the sum of all its containers' individual values. Multiply that per-pod total by the replica count to get what the whole deployment reserves. For example, 3 replicas at 250m CPU and 256Mi memory each total 750m CPU and 768Mi. Enter the per-container values and replica count into the calculator and it computes the workload totals instantly.

Mi (mebibytes) and Gi (gibibytes) are binary units where 1024Mi equals 1Gi. Divide Mi by 1024 to get Gi, and multiply Gi by 1024 to get Mi. One Gi equals 1,073,741,824 bytes, which is slightly larger than 1G (1,000,000,000 bytes). The calculator normalizes all memory values to exact bytes internally, so Mi and Gi inputs compare and total correctly without any manual conversion.

Yes, the calculator is completely free. It runs entirely in your browser with no server, no account and no data upload — you do not need to sign up or log in. You can safely paste resource values from internal manifests because nothing leaves your device.

Base requests on observed p95 or p99 usage gathered with kubectl top over a representative 24-hour period, then set limits at roughly two to five times the request value. Requests set too high waste schedulable node capacity; set too low they starve the pod under load and cause CPU throttling or OOMKills. Use the calculator to total per-container values across replicas before committing numbers to a manifest.

New to this? Read our guide on Kubernetes for DevOps.

More free, private DevOps tools.

The Kubernetes Resource Calculator is one tool in OpsCanopy — a growing canopy of browser-based validators, converters and testers that never touch a server.

New to Docker?  Read the Docker guide →

29 free tools, every one offline-capable — opscanopy.com works with no signup and nothing uploaded.

Related: the Base64 Encoder / Decoder and the Docker Run to Compose, or browse the full tools directory.

Provided as-is for convenience; always confirm critical capacity changes against your own authority. OpsCanopy is free and open.