How the Cloud Run calculator works

01 What the memory limit does

• Each instance gets one memory limit, 512 MiB by default, up to 32 GiB. An instance that exceeds it is terminated. Cloud Run docs
• The container's filesystem is in memory: files it writes use the instance's memory, and can use it all up. Cloud Run docs

With no separate reservation and running out ending the instance, the calculator sizes the limit from the peak alone. The average you enter doesn't change the result.

Lambda and Azure Functions also size from the peak alone: see the Lambda guide and the Azure Functions guide.

02 From peak usage to a memory limit

memory = peak × (1 + limit margin)    rounded up to a whole Mi, kept within 128Mi–32Gi

The limit margin comes from the sensitivity, workload type and environment you choose; the sizing model explains it, and it's an assumption too.

--memory takes Mi and Gi (or decimal M and G); the calculator writes Mi, or Gi for whole gibibytes. The first generation execution environment goes down to 128 MiB, the second needs 512 MiB. Cloud Run docs

Worked example

Peak 630 MiB, generic workload, medium sensitivity, production:

Above 4 GiB, the memory also sets the CPU. Peak 5000 MiB, same profile:

03 Google's formula: concurrency

Google's own way to size an instance's memory counts requests, not samples: Cloud Run docs

memory = standing memory + memory per request × concurrency

The calculator applies it with three optional fields: the instance's idle memory (the standing memory), the maximum concurrency now, and the maximum concurrency planned. Cloud Run defaults to 80 concurrent requests per instance from the console (80 per vCPU from the CLI) and allows up to 1,000. Cloud Run docs

memory per request = (peak − idle memory) ÷ concurrency now
planned peak       = idle memory + memory per request × concurrency planned
memory             = planned peak × (1 + limit margin)

With the same concurrency, the planned peak is the measured peak, so nothing changes. The measured peak is taken to have happened at the current maximum concurrency; if it happened with fewer requests in flight, memory per request comes out low. Assumption Without the idle memory, the whole peak counts as per-request memory, and a warning says the result is an upper bound when concurrency goes up, a lower one when it goes down.

Peak 630 MiB at a concurrency of 80, with 120 MiB idle, planning for 160:

04 The CPU it needs

Instances get 1 vCPU by default. Less than 1 vCPU is possible, but only with a concurrency of 1, request-based billing and the first generation environment. Cloud Run docs

So up to 4 GiB the calculator leaves CPU at the default and doesn't suggest a fraction; above it, it adds the fewest vCPU the memory needs. Assumption

05 What the calculator writes

gcloud run services update <service> --memory 6500Mi --cpu 2

spec:
  template:
    spec:
      containers:
      - resources:
          limits:
            memory: 6500Mi
            cpu: 2

gcloud run services update SERVICE --memory SIZE is the documented command, and the service YAML takes the same values under each container's resources.limits. Cloud Run docs --cpu only appears when the memory needs more than the default.

06 Every warning, and why

07 Where the numbers come from

Cloud Run's built-in metrics include "Container memory utilization". Cloud Run docs The documentation lists it without its unit; we read it as a share of the instance's current limit, as the console charts it. So multiply its p99 over a representative period by the current limit to get the peak in MiB, and its p50 for the average, which doesn't change the result. Assumption

08 All assumptions in one place

Besides the margins of the shared sizing model:

Our default: a value we chose. Our reading: how we read documentation that isn't explicit. About your setup: something we take for granted about your data or cluster.

Values you can change

The calculator’s Advanced: margins and defaults section, closed by default, lets you replace these values when your setup differs. Each field’s “?” says how it moves the result; a value outside the range is used at its nearest end, and “Reset to defaults” puts them all back.

09 References

• Configure memory limits — range, units, the gcloud command and Google's sizing formula.
• Configure CPU limits — the default and the CPU each memory size needs.
• Container runtime contract — the in-memory filesystem and what happens past the limit.
• Service YAML reference — resources.limits.memory and cpu.
• Monitor health and performance — the built-in metrics.

← Back to the Cloud Run calculator