How many nodes and Pods can a Kubernetes cluster have?

Upstream Kubernetes is designed for clusters of up to 5,000 nodes, 150,000 Pods in total, 300,000 containers in total and 110 Pods per node, all at the same time. Managed services publish their own ceilings, some far above that: GKE Standard allows 65,000 nodes and Amazon EKS up to 100,000. In practice, most clusters hit other limits first: the size of the etcd data store, the request load on the API server and the IP address space for Pods.

The upstream limits

The Kubernetes documentation states that Kubernetes is designed for configurations that meet all of these criteria:

DimensionLimit
Nodes per cluster5,000
Pods per node110
Pods per cluster150,000
Containers per cluster300,000

These numbers are not hard caps in the code. They describe what the project tests and supports. Larger clusters exist, but they need tuning of the control plane and its data store that a default installation does not have.

What actually limits a cluster

The data store

Every object in the cluster lives in etcd: Pods, Services, ConfigMaps, Secrets, Events, completed Jobs and custom resources. According to the etcd documentation, the default storage limit is 2 GiB, 8 GiB is the suggested maximum for normal environments, and a single request may be at most 1.5 MiB. When the store fills up, writes stop.

Object count and churn matter more than node count. A small cluster with tens of thousands of finished Jobs, verbose Events or large custom resources can strain etcd sooner than a large, quiet one. Large installations often keep Events in a separate etcd instance.

API server load

Each node’s kubelet, each DaemonSet Pod and each controller watches the API server. More nodes mean more watches and more status updates, and every additional DaemonSet multiplies that by the node count. Broad LIST calls over all namespaces are the most expensive requests at scale.

The API server protects itself with API Priority and Fairness: it sorts requests into priority levels and queues, so one noisy client cannot starve system components. Clients that exceed their share get HTTP 429 responses. The control plane usually becomes slow under request load long before it reaches a node limit.

IP address space

Every Pod needs an IP address. In clusters that assign each node a Pod range, the range size fixes both Pods per node and node count. GKE, for example, reserves a /24 per node for the default of 110 Pods, so a /16 Pod range fits at most 256 nodes. On EKS with the Amazon VPC CNI, Pods use addresses from the VPC subnets, and the number of network interfaces and IP addresses of each instance type sets its default Pod limit. Plan the Pod and Service ranges for the largest size the cluster will ever reach, because changing them later usually means rebuilding the cluster.

Pods per node

The kubelet’s default maxPods is 110. Raising it needs a matching IP range per node and enough CPU and memory for the kubelet and container runtime to manage that many containers.

Limits of managed Kubernetes services

As of November 2026, the major providers document these limits. Some need a quota increase or specific cluster settings.

ServiceNodes per clusterPods per nodeOther limits
Amazon EKSUp to 100,000Based on the instance’s network interfaces; managed node groups cap it at 110 below 30 vCPUs and 250 above450 nodes per managed node group and 30 managed node groups per cluster by default, both adjustable
GKE Standard65,000; increases are not all automatic110 by default, up to 512200,000 Pods per cluster; 1,000 nodes per node pool per zone
GKE Autopilot5,000Set dynamically, 8 to 256200,000 Pods per cluster
Azure AKS5,000 across all node poolsUp to 250; default 30 with Azure CNI1,000 nodes per node pool, 100 node pools; Free tier recommended for 10 nodes

AWS announced the 100,000-node figure in July 2025 for large AI training and inference workloads, and its engineering post states that the underlying improvements are only available to new clusters created with ultra scale capabilities enabled.

One big cluster or several smaller ones

Hitting a limit is rarely the reason to split a cluster. The more common reasons are operational:

One large clusterSeveral smaller clusters
Blast radiusA control plane problem or bad cluster-wide change affects everythingFailures stay inside one cluster
UpgradesOne upgrade touches every workload at onceUpgrade one cluster at a time and learn from the first
UtilizationOne pool of capacity, better bin packingSpare capacity in each cluster
IsolationNamespaces, RBAC and network policies separate teamsHard boundary between teams, customers or environments
Control plane costOne control planeOne per cluster, plus tooling to manage many

Teams that run several clusters need consistent configuration and rollout across them; see Kubernetes fleet management. Teams that share one cluster need strong multi-tenancy controls.

Cluster size on Cloudfleet

Cloudfleet Kubernetes Engine (CFKE) sets no cluster size limit on any cluster type. The API server enforces a 1 GiB data store quota and a 1 MiB limit per object, described in Kubernetes API server quotas, and uses API Priority and Fairness to keep the control plane responsive, as explained in control plane scalability.

On this page