GCP Machine Type Decoder

Read a GCP machine type name: the series and its processor, the memory family's ratio, and the vCPU count. Including the trailing letter that means ARM, and the custom memory band that decides whether a type is rejected or billed as extended.

Paste below, or drop a file anywhere on this panel

Or drop a file anywhere on this panel. Nothing is uploaded: the analysis runs in this tab.

The answer appears here

Paste on the left and press Decode the types. Nothing leaves this tab.

Wanted a different tool?

  • Azure VM Size Decoder for the same job on Azure, where the architecture is a feature letter rather than part of the series.

Examples

Real input you can load into the tool above. Each one shows a different thing going wrong, because that is what the tool is for.

One letter from x86

t2a is ARM and t2d is x86 AMD. They sit next to each other in every list and run different binaries.

t2a-standard-4

Not a small standard instance

e2-medium is shared-core: one vCPU of guaranteed time over two virtual cores, with bursting that runs out

e2-medium

A size from a utilisation measurement

8000 MB is not a multiple of 256 and 3 vCPUs is odd. Both are rejected, and both are what a measurement produces.

n2-custom-3-8000

Memory past the band

16 GB per vCPU is extended memory, billed at a higher rate than the same memory on a type with more vCPUs

n2-custom-4-65536

Common mistakes

These are the ones that fail silently. The config is accepted, nothing raises an error, and the consequence arrives later.

  1. Choosing t2a because it sits next to t2d and is cheaper

    The trailing a means ARM. x86 binaries do not run, every container image needs an arm64 build, and any agent from a vendor's x86 repository will not install. t2d, one letter away, is x86 AMD.

    Instead:Confirm the whole stack has arm64 builds first, or use t2d for the same scale-out shape on x86.

  2. Treating e2-medium as a small e2-standard

    The micro, small and medium sizes are shared-core: a fraction of a vCPU with bursting, falling back to a baseline well below one core under sustained load. Anything benchmarked on one measures the burst.

    Instead:Use the smallest standard size for a constant load. Shared-core is right for something idle most of the time.

  3. Sizing a custom type from a measured utilisation figure

    Custom memory must be a multiple of 256 MB and vCPUs above 1 must be even, so 3 vCPUs and 8000 MB are both rejected. They are exactly the numbers a utilisation measurement produces.

    Instead:Round the vCPUs up to even and the memory to the nearest 256 MB.

  4. Adding memory to a custom type past the band

    Above roughly 8 GB per vCPU it is extended memory, billed at a higher rate. So the same total memory can cost less on a type with more vCPUs than on one paying the extended premium.

    Instead:Compare against a highmem type or more vCPUs inside the band before accepting the -ext price.

  5. Reading highcpu as a bigger machine

    The memory family is a ratio: highcpu is about 1 GB per vCPU against standard's 4. So n2-highcpu-32 has less memory than n2-standard-16 despite twice the vCPUs, which shows up as an out of memory kill on a machine that looks larger.

    Instead:Read the family before the number. The vCPU count says nothing about the memory on its own.

One letter on the series changes the instruction set

n2-standard-8 is a series, a memory family and a vCPU count. The series is the one that decides whether your binaries run at all.

t2a and c4a are ARM, t2d and n2d are AMD

A trailing a means ARM: x86 binaries do not run, every container image needs an arm64 build, and any agent installed from a vendor's x86 repository will not install. A trailing d means AMD rather than Intel, which is a price and performance difference and not a compatibility one. t2a and t2d sit next to each other in every list and are different architectures.

t2a-standard-4    Ampere Altra, ARM
t2d-standard-4    AMD EPYC, x86
n2d-standard-4    AMD EPYC, x86
c4a-standard-4    Google Axion, ARM

e2-micro, e2-small and e2-medium are a different product

They are shared-core: a fraction of a vCPU with the ability to burst above it. An e2-medium is one vCPU of guaranteed time spread over two virtual cores. Sustained load falls back to a baseline well below one core, so anything benchmarked on one is measuring the burst rather than the steady state. They are not small versions of e2-standard.

e2 has no guaranteed CPU platform

It runs on whichever host is available, Intel or AMD, and the platform is not selectable. Benchmarks vary between instances of the same type, and anything depending on a specific instruction set extension may or may not find it. That is the trade for the price, and n2, n2d and the c series are where you go when the platform matters.

A custom type has a band, and going over it costs more

Memory must be a multiple of 256 MB and between roughly 0.5 and 8 GB per vCPU on the N series. Below the floor the type is rejected. Above the ceiling it is accepted and billed as extended memory at a higher rate, which is what the -ext suffix marks. So the same total memory can be cheaper on a type with more vCPUs than on one paying the extended premium.

n2-custom-4-32768    8 GB per vCPU, inside the band
n2-custom-4-65536   16 GB per vCPU, extended memory
n2-custom-4-8000     not a multiple of 256, rejected
n2-custom-3-16384    odd vCPU count, rejected

The memory family is a ratio, not a size

standard is about 4 GB per vCPU, highmem about 8, highcpu about 1. So n2-highcpu-32 has less memory than n2-standard-16 despite having twice the vCPUs, which is the sizing mistake that shows up as an out of memory kill on a machine that looks larger.

Custom types do not exist everywhere

They are available on the general purpose series, e2, n1, n2 and n2d. The compute optimised and memory optimised series offer predefined sizes only, and a custom name against c2 or m1 is rejected rather than rounded to something near it.

What this cannot see

Whether the type exists where you are deploying. Machine types are per zone, the newer series are in far fewer regions than the older ones, and quota is separate again. gcloud compute machine-types list --zones ZONE is the authority and is already filtered to what you can actually create. This reads the name, which is enough to catch the architecture, the band and the shared-core surprise before any of that matters.

Related google cloud tools

GCP Signed URL Decoder A bearer token in a URL GCP Storage Bucket Analyzer Two access systems, one visible GCP Resource Name Parser Project ID is not project number GCP Cloud Run Config Analyzer No CPU between requests GCP Pub/Sub Subscription Analyzer Duplicates are the ack deadline GCP Firewall Rule Analyzer On a tie, the deny wins
All 9 google cloud tools

Elsewhere on the site

Terraform Validator & Formatter Kubernetes YAML Generator Kubernetes YAML Validator AWS IAM Policy Validator & Analyzer