What is cloud bursting and how does it work with Kubernetes?
Cloud bursting is a hybrid cloud pattern in which workloads run on infrastructure you own or rent long term, and overflow demand goes to a public cloud only when that capacity is full. The cloud capacity is released again when demand falls. In Kubernetes, bursting works at the node level: Pods that cannot be scheduled on the owned nodes trigger a node autoscaler to add cloud nodes, and scheduling rules keep the steady baseline on the hardware you already pay for.
Where the term comes from
The NIST definition of cloud computing names bursting in its definition of hybrid cloud: two or more distinct cloud infrastructures “bound together by standardized or proprietary technology that enables data and application portability (e.g., cloud bursting for load balancing between clouds)” (NIST SP 800-145). The idea is economic. Owned hardware is cheapest when it runs full, and the public cloud is cheapest for capacity you need only for hours or days.
How bursting works in Kubernetes
- Owned nodes, in a data center or on a provider you rent servers from by the month, carry the normal load.
- Demand rises. The Horizontal Pod Autoscaler adds replicas, or a batch of jobs arrives, and the new Pods stay in
Pendingbecause no node has room. - A node autoscaler sees the Pending Pods and creates cloud nodes. The Kubernetes Cluster Autoscaler scales up when Pods “failed to schedule on any of the current nodes due to insufficient resources” and checks for them every 10 seconds by default.
- The scheduler places the Pending Pods on the new cloud nodes.
- Demand falls. Cloud nodes become underused and the autoscaler removes them. By default, the Cluster Autoscaler removes a node that has stayed below 50% utilization for 10 minutes and whose Pods fit elsewhere.
The overview of Kubernetes autoscaling explains how Pod and node autoscaling fit together.
One cluster or a separate cloud cluster
| Design | How overflow reaches the cloud | Trade-off |
|---|---|---|
| One cluster with on-premises and cloud nodes | The scheduler places Pending Pods on cloud nodes that join the same cluster | One API and one scheduler, but every node needs an encrypted network path to the control plane and to other Pods |
| Separate cluster in the cloud | A multi-cluster job queue or a deployment pipeline sends work to the second cluster | Each cluster runs on its own, but you operate two control planes and route traffic between them |
The single-cluster design is the closer match to the NIST idea of one environment spread across two infrastructures. Its networking requirements are covered in how nodes in different clouds join one cluster network, and the wider design question in whether one Kubernetes cluster can span multiple clouds.
The multi-cluster design works best for batch work. MultiKueue, a beta feature of the Kueue job queueing project since version 0.9, dispatches jobs from a manager cluster to worker clusters. Bursting a web service into a second cluster also needs a global load balancer or DNS that sends users to both.
Keeping the baseline on owned hardware
Without rules, the scheduler treats a cloud node like any other node and may leave it running steady workloads long after the peak. Four Kubernetes features keep bursting under control:
- Node affinity. Label nodes by location and give Pods a preferred affinity for the owned nodes. The scheduler uses them first and falls back to cloud nodes when they are full.
- Taints and tolerations. Taint cloud nodes with
NoScheduleand add a toleration only to workloads allowed to burst. Databases, Pods bound to local data and latency-sensitive services then never land in the cloud. - Priority classes. With Pod priority and preemption, high-priority services evict lower-priority batch Pods from full owned nodes. The evicted Pods go back to
Pendingand trigger cloud capacity. The Cluster Autoscaler ignores Pods below its expendable priority cutoff,-10by default, so burstable Pods need a priority above it. - Scale-down order. Kubernetes does not move running Pods back when owned capacity frees up. The
controller.kubernetes.io/pod-deletion-costannotation influences which Pods a ReplicaSet removes first when it scales down, so a controller or script can mark Pods on cloud nodes as cheaper to delete. The cloud nodes then empty out and the autoscaler removes them.
A burstable Deployment combines a preference with a toleration:
spec:
template:
spec:
priorityClassName: burstable
affinity:
nodeAffinity:
preferredDuringSchedulingIgnoredDuringExecution:
- weight: 100
preference:
matchExpressions:
- key: example.com/location
operator: In
values: ["on-premises"]
tolerations:
- key: example.com/burst
operator: Exists
effect: NoScheduleWhat to burst and what to keep local
| Bursts well | Keep on owned hardware |
|---|---|
| Stateless web and API replicas | Databases and other stateful services |
| CI jobs and builds | Workloads that read large datasets from local storage |
| Batch processing, rendering, simulations | Chatty services that call each other many times per request |
| Training jobs that fit inside one cloud site | Workloads with data that must not leave your premises |
Data decides most of this. A Pod in the cloud that reads terabytes from an on-premises file server pays for the transfer in time and, for data flowing back from the cloud, in egress fees. What cloud egress fees are explains how providers bill outbound traffic.
GPU bursting for training
Training jobs are a common reason to burst, because GPU demand comes in large, irregular blocks. Multi-node training exchanges gradients over InfiniBand or RoCE between nodes, which a WAN link between your data center and a cloud cannot replace. Burst whole jobs, not parts of a job: run a job either entirely on owned GPUs or entirely in one cloud site, with its dataset copied or cached there first.
Cloud GPU capacity is not guaranteed on demand, so plan bursts with reservations or several providers, as explained in why it is hard to get GPU capacity in the cloud.
Bursting or buying more hardware
Bursting suits short, infrequent peaks. When the cloud nodes run most of the month, buying or renting more owned capacity is usually cheaper. How to optimize Kubernetes costs across clouds covers that decision.
Cloud bursting with Cloudfleet
Cloudfleet Kubernetes Engine (CFKE) runs one cluster that combines self-managed nodes on your own servers with cloud nodes. When Pods stay Pending, node auto-provisioning creates nodes in AWS, Google Cloud or Hetzner Cloud that match their requirements, and deletes them when they are no longer needed.