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

  1. Owned nodes, in a data center or on a provider you rent servers from by the month, carry the normal load.
  2. Demand rises. The Horizontal Pod Autoscaler adds replicas, or a batch of jobs arrives, and the new Pods stay in Pending because no node has room.
  3. 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.
  4. The scheduler places the Pending Pods on the new cloud nodes.
  5. 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

DesignHow overflow reaches the cloudTrade-off
One cluster with on-premises and cloud nodesThe scheduler places Pending Pods on cloud nodes that join the same clusterOne API and one scheduler, but every node needs an encrypted network path to the control plane and to other Pods
Separate cluster in the cloudA multi-cluster job queue or a deployment pipeline sends work to the second clusterEach 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 NoSchedule and 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 Pending and trigger cloud capacity. The Cluster Autoscaler ignores Pods below its expendable priority cutoff, -10 by 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-cost annotation 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:

yaml
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: NoSchedule

What to burst and what to keep local

Bursts wellKeep on owned hardware
Stateless web and API replicasDatabases and other stateful services
CI jobs and buildsWorkloads that read large datasets from local storage
Batch processing, rendering, simulationsChatty services that call each other many times per request
Training jobs that fit inside one cloud siteWorkloads 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.

On this page