Kubernetes resource calculator

Type quantities to see their exact value, or paste workloads to total requests and limits with every accounting rule spelled out.

Target KubernetesSchema pack 2026.10.0, self-authored. What it covers

Quantity calculator

Exact rational arithmetic using the Kubernetes quantity grammar.

Exact value	Canonical	Notes
0.1 cores = 100m	100m
104857600 bytes	100Mi	100Mi / ≈104.857M
0.1 bytes	100m	"100m" means 0.1 bytes (m = milli, 1/1000). For mebibytes write "100Mi".
1.5 cores = 1500m	1500m
1000000000 bytes	1G	≈953.674Mi / 1G

CPU total 4600m (4.6 cores) · Bytes total 2104857600.1 (≈1.96Gi)

Workloads

Opening local draft…

# Synthetic example: init container, native sidecar and replicas
apiVersion: apps/v1
kind: Deployment
metadata:
  name: checkout
  namespace: shop
spec:
  replicas: 4
  strategy:
    rollingUpdate:
      maxSurge: 25%
      maxUnavailable: 0
  selector:
    matchLabels: { app: checkout }
  template:
    metadata:
      labels: { app: checkout }
    spec:
      initContainers:
        - name: migrate
          image: registry.example.com/shop/migrate:2.0.1
          resources:
            requests: { cpu: "1", memory: 1Gi }
        - name: log-shipper
          image: registry.example.com/infra/shipper:0.9.0
          restartPolicy: Always
          resources:
            requests: { cpu: 100m, memory: 64Mi }
            limits: { memory: 128Mi }
      containers:
        - name: app
          image: registry.example.com/shop/checkout:3.2.0
          resources:
            requests: { cpu: 500m, memory: 512Mi }
            limits: { cpu: "1", memory: 512Mi }
---
apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: node-agent
  namespace: infra
spec:
  selector:
    matchLabels: { app: node-agent }
  template:
    metadata:
      labels: { app: node-agent }
    spec:
      containers:
        - name: agent
          image: registry.example.com/infra/agent:5.1.0
          resources:
            limits: { cpu: 200m, memory: 200Mi }

Requests and limits

Accounting profile

DaemonSet nodesAssumed eligible nodesExtra pod overhead CPUExtra pod overhead memory

Include rollout surge Use HPA maxReplicas

Target 1.31: native sidecars are counted alongside app containers.

Requests and limits per workload
Workload	QoS	Pod CPU req	Pod mem req	Replicas	Total CPU	Total mem	Peak CPU	Peak mem
Deployment/checkout	Burstable	1000m	1Gi	4	4000m	4Gi	5000m	5Gi
DaemonSet/node-agent	Guaranteed	200m	200Mi	3	600m	600Mi	600m	600Mi
All workloads (requests)					4600m	≈4.585Gi	5600m	≈5.585Gi

Exact totals: CPU 4.6 cores, memory 4924112896 bytes (≈4.924G decimal). Peak includes rollout surge where enabled.

Deployment/checkout: how this was counted

Container	Role	CPU req	CPU lim	Mem req	Mem lim
migrate	init (runs before, sequential)	1000m	—	1Gi	—
log-shipper	sidecar (runs with app)	100m	—	64Mi	128Mi
app	app	500m	1000m	512Mi	512Mi

App + sidecars: 600m / 576Mi
Init peak: 1000m / 1Gi
Overhead: 0m / 0
Pod request: max(app, init) + overhead = 1000m / 1Gi
Pod limit: unbounded / 640Mi
Replicas: 4: spec.replicas
Peak: 5: RollingUpdate maxSurge 25% of 4 = 1 → 1 (rounded up); maxUnavailable 0

Regular init containers run one at a time before app containers start, so their requests are compared (max), not added.

DaemonSet/node-agent: how this was counted

Container	Role	CPU req	CPU lim	Mem req	Mem lim
agent	app	200m*	200m	200Mi*	200Mi

App + sidecars: 200m / 200Mi
Init peak: 0m / 0
Overhead: 0m / 0
Pod request: max(app, init) + overhead = 200m / 200Mi
Pod limit: 200m / 200Mi
Replicas: 3: one pod per eligible node; assumed 3 node(s) (profile)
Peak: 3: DaemonSet maxSurge 0 (unparsed)

"agent": cpu, memory request not set, so it defaults to the limit (API defaulting). A namespace LimitRange could also inject defaults; none is known here.

This is arithmetic over the supplied manifests. Node allocatable, LimitRange defaults, admission mutation and scheduler decisions are not known, so it cannot tell you whether pods will fit.

Exact quantities

Quantities are parsed with the Kubernetes grammar and kept as exact fractions, never floating point. m means one thousandth, so 100m of CPU is 0.1 core and 100m of memory is 0.1 byte. Ki, Mi and Gi are powers of 1024. k, M and G are powers of 1000. 1Gi is 1,073,741,824 bytes and 1G is 1,000,000,000.

How pod totals are counted

App containers and native sidecars (init containers with restartPolicy: Always, 1.29 and later) run together, so their requests add up. Regular init containers run one at a time before the app, so each is compared, together with any sidecars started before it. The pod request is the larger of the two, plus pod overhead. That figure is multiplied by replicas. For DaemonSets, the node count is an assumption you set.

When only a limit is set, the request defaults to the limit. A LimitRange in your namespace could inject other defaults. That is unknown here and listed as an assumption.

Questions

Is 1000m the same as 1 CPU?

Yes. 1 = 1000m. CPU precision is 1m, and finer values are rounded up by the API.

Why is my memory request flagged?

Memory written with m (for example 128m) means millibytes. You almost certainly meant Mi.

Does this tell me whether pods will schedule?

No. It is arithmetic. Node allocatable, other workloads, taints and affinity decide scheduling in a real cluster.

Other tools

Manifest editorEdit multi-document Kubernetes YAML with per-document identity, duplicate detection, a relationship graph with an accessible table, and findings tied to source lines.YAML validatorValidate Kubernetes YAML against a versioned schema pack with separate YAML, schema, cross-object and policy findings.Deployment generatorGenerate a Deployment with Service, Ingress, PodDisruptionBudget and HPA: named ports, probes, requests and a hardened security context, validated as you type.Service generatorBuild ClusterIP, NodePort, LoadBalancer, headless and ExternalName Services, and check selector and targetPort mapping against a pasted workload.RBAC analyzerInspect Roles, ClusterRoles and bindings offline: subject-to-permission matrix, aggregated-role handling, risky verbs, and "can this subject do X" checks scoped to the supplied rules.NetworkPolicy explainerExplain which pods each NetworkPolicy isolates and test traffic scenarios between pods, namespaces and IPs with additive allow-list reasoning.Probe builderBuild liveness, readiness and startup probes and see their timing: when the first check runs, how long until a failure triggers action, and what that action is.Manifest diffCompare two Kubernetes bundles by text or by object: objects matched by identity, list items matched by name, and status or server fields ignored only when you choose.API deprecationsFind Kubernetes APIs removed or deprecated for your target version, using a dated pack, and preview field-aware migrations with the semantic changes you need to review.CronJob schedulePreview the next runs of a Kubernetes CronJob schedule in its spec.timeZone, explain concurrency and deadline settings, and catch TZ= in the schedule string.Secret encoderEncode and decode Kubernetes Secret values locally, build Secret YAML with data or stringData, and inspect an existing Secret with values masked by default.Redact exportFind Secret data, tokens, credential-bearing env values and last-applied annotations in Kubernetes YAML, review each one, and export a redacted copy.TemplatesSynthetic Kubernetes templates with safe defaults — web app, StatefulSet, CronJob, NetworkPolicy, RBAC, HPA, sidecar — each tested against the schema pack for every supported version.