Quantum hardware gets the headlines, but behind almost every cloud-accessible quantum service sits ordinary classical infrastructure that queues jobs, schedules them onto machines and keeps services alive. Much of that infrastructure runs on Kubernetes. This explainer sets quantum aside for a moment and describes, in plain language, how a Kubernetes cluster decides where work runs and what people do to keep that decision sensible. The practice is sometimes called KubernetesOps, and the Ops Atlas is the source of the specifics.
Start with the picture: a cluster is a shared workbench
Imagine a laboratory bench shared by many experiments. Each experiment needs space, power and time. Someone has to decide which experiment gets which corner, and what happens when the bench is full. In Kubernetes, the bench is a set of machines called nodes, the experiments are pods, and the decision-maker is the scheduler, part of the control plane. The Atlas lists the control plane, nodes, add-ons, versions, configuration, scaling, capacity and troubleshooting as the territory of cluster operations.
The scheduler reads reservations, not behaviour
When you submit a pod, you can declare a request: the amount of CPU and memory it would like held for it. The scheduler places the pod on a node with enough unreserved room. Crucially, it does not look at what the pod really uses. A pod that reserves a lot and consumes little still blocks space, and a pod that reserves little and consumes a lot can crowd out its neighbours. The Atlas puts it bluntly: requests are a contract, and the autoscalers honour the same numbers.
Here is the quantum-flavoured analogy. If every researcher books the whole instrument for a day and uses it for ten minutes, the lab looks full while the machine idles. Same effect, same cure: honest bookings, based on measurement.
What happens when a node runs short
When memory or disk on a node gets tight, the node itself starts evicting pods to protect itself. The Atlas states the order: pods whose usage exceeds their requests are chosen first, and then priority decides among the rest. This kind of eviction ignores the protective rules meant for planned maintenance. So under-asking is not free either. Reserving too little can place your pod first in line when the bench gets crowded.
How the cluster grows and shrinks
Capacity changes in two layers. Replica counts of a service can go up and down, handled by the horizontal autoscaler. To work from CPU utilisation, it needs the pod to have a CPU request, since utilisation is measured against that number. Node counts can change as well, through a cluster autoscaler or a provisioning tool such as Karpenter. By default, the cluster autoscaler removes a node only when it is requested below fifty percent. Hence padded requests are doubly wasteful: they inflate demand and also stop nodes from being released.
For a classical-quantum workflow, where bursts of pre- and post-processing jobs arrive around a handful of device runs, this elasticity is what lets one cluster absorb the peaks without keeping every machine running all week.
Keeping services alive: probes and their traps
Kubernetes can restart containers that appear stuck, using liveness probes. The Atlas has a clear warning: a liveness check should only look at the process itself. If it calls a database or another service, a brief outage in that dependency can make healthy containers restart together, which turns a small problem into a cascade. When a container does crash repeatedly, the delay between restarts grows from ten seconds toward a ceiling of five minutes, which is why a failing pod may look quiet rather than frantic.
The calendar nobody sees: versions and upgrades
All of this runs on software that moves quickly. The project cuts around three minor versions a year and keeps each supported for a bit over a year. Upgrading means moving one minor at a time, control plane first and node agents afterwards, with a drain before each node. The quantum community knows this feeling: firmware and control software on devices also changes under you, and a plan that sequences the changes prevents surprises. The Atlas’s entry, the Ops Atlas description of KubernetesOps practice, lists the metrics that tell you whether you are keeping pace, such as how many versions behind you are and how many days remain until support ends.
A worked picture of one busy afternoon
Suppose a research group submits a batch of simulation jobs just before a deadline. The horizontal autoscaler notices CPU running well above target and adds replicas of the worker service. The scheduler looks for room, finds none on the current nodes and leaves some pods waiting as unschedulable. A node-provisioning tool sees the waiting pods and adds machines. Minutes later the workers drain the queue, usage falls, and after a stabilisation delay the replicas shrink again. Nothing in that sequence needed a person, yet each step depended on a number somebody chose earlier: the target, the requests, the delay. That is the point of the discipline. People set the numbers, review them, and fix them when the afternoon does not go as planned.
Why bother learning this as a quantum enthusiast?
Because the interesting experiments of the next few years will run through cloud services, and the reliability of those services depends on boring operations. If you want to see the quantum side of the picture, read about how quantum approaches may speed up searching databases and the explainer on how quantum algorithms approach factoring. Then look at what must be running on the classical side for such demonstrations to reach you at all.
Three KubernetesOps ideas to remember
- The scheduler works from reservations; keep them honest.
- Protection rules guard planned maintenance, not every kind of disruption.
- Versions expire on a calendar; plan upgrades as a series of small, ordered steps.
That is the whole mental model in a nutshell. Everything else in cluster operations is detail layered on top of these three ideas, and the detail is easiest to learn by breaking a small lab cluster on purpose and fixing it.