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:
| Dimension | Limit |
|---|---|
| Nodes per cluster | 5,000 |
| Pods per node | 110 |
| Pods per cluster | 150,000 |
| Containers per cluster | 300,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.
| Service | Nodes per cluster | Pods per node | Other limits |
|---|---|---|---|
| Amazon EKS | Up to 100,000 | Based on the instance’s network interfaces; managed node groups cap it at 110 below 30 vCPUs and 250 above | 450 nodes per managed node group and 30 managed node groups per cluster by default, both adjustable |
| GKE Standard | 65,000; increases are not all automatic | 110 by default, up to 512 | 200,000 Pods per cluster; 1,000 nodes per node pool per zone |
| GKE Autopilot | 5,000 | Set dynamically, 8 to 256 | 200,000 Pods per cluster |
| Azure AKS | 5,000 across all node pools | Up to 250; default 30 with Azure CNI | 1,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 cluster | Several smaller clusters | |
|---|---|---|
| Blast radius | A control plane problem or bad cluster-wide change affects everything | Failures stay inside one cluster |
| Upgrades | One upgrade touches every workload at once | Upgrade one cluster at a time and learn from the first |
| Utilization | One pool of capacity, better bin packing | Spare capacity in each cluster |
| Isolation | Namespaces, RBAC and network policies separate teams | Hard boundary between teams, customers or environments |
| Control plane cost | One control plane | One 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.