Kubernetes v1.36: On-the-Fly Pod Resource Scaling Goes Beta – What You Need to Know

In Kubernetes v1.36, the community has advanced another major milestone for resource management. Following the General Availability of In-Place Pod Vertical Scaling in v1.35 and earlier Beta releases for Pod-Level Resources, the latest update brings In-Place Pod-Level Resources Vertical Scaling to Beta, enabled by default. This feature lets you adjust the aggregate resource budget for all containers in a pod without necessarily restarting them. It's a game-changer for complex pods with sidecars, enabling on-the-fly expansion of shared pools during peak loads. Below, we answer the most important questions about this new capability.

What is In-Place Pod-Level Resources Vertical Scaling?

This feature allows you to update the spec.resources field of a running pod to change the total CPU and memory budget allocated to all its containers collectively. Previously, you could scale individual container resources, but the pod-level budget was static after creation. Now, by patching the resize subresource, the Kubelet adjusts cgroup limits dynamically, often without restarting containers. It's especially valuable for pods where containers inherit limits from the pod-level budget, eliminating manual per-container recalculations.

Kubernetes v1.36: On-the-Fly Pod Resource Scaling Goes Beta – What You Need to Know

How Does v1.36 Improve on Previous Versions?

v1.34 introduced Pod-Level Resources as Beta, letting you define a shared resource pool. v1.35 made In-Place Vertical Scaling GA for individual containers. v1.36 combines both: you can now perform in-place vertical scaling on the pod-level budget itself. This means you can double the CPU limit for a pod with multiple sidecars in one step, and the Kubelet will propagate the change to all containers that inherit from that pool. The InPlacePodLevelResourcesVerticalScaling feature gate is enabled by default, so no extra configuration is needed.

What Are the Practical Benefits of Non-Disruptive Scaling?

The main advantage is zero downtime for scaling operations. During traffic spikes, you can expand the shared resource pool for a pod containing a main app and a logging sidecar, both without individual limits. The containers automatically adjust their effective boundaries to the new pod-level dimensions. This avoids the need to restart containers, preserving open connections and cached data. It reduces operational overhead and improves responsiveness to load changes.

How Does the Kubelet Decide Whether a Container Must Restart?

When you initiate a pod-level resize, the Kubelet treats it as a resize event for every container that inherits its limits from the pod-level budget. It then checks the container's resizePolicy setting:

NotRequired – The Kubelet updates cgroup limits via the Container Runtime Interface (CRI) without restarting the container.
RestartContainer – The container is restarted to apply the new aggregate boundary safely.

Currently, resizePolicy is not supported at the pod level; the Kubelet always defers to individual container settings. You can define different policies per resource (e.g., CPU NotRequired, memory RestartContainer) within the same container.

Walk Me Through a Real-World Scaling Example

Imagine a pod named shared-pool-app with two containers – main-app and sidecar – both without individual limits. The pod-level limit is 2 CPUs and 4Gi memory. To double CPU capacity to 4 CPUs during peak load, you apply this patch:

kubectl patch pod shared-pool-app --subresource resize --patch \
  '{"spec":{"resources":{"limits":{"cpu":"4"}}}}'

Because both containers have resizePolicy set to NotRequired for CPU, the Kubelet dynamically updates their cgroup limits without restarts. The sidecar and main app continue running, now sharing 4 CPUs. This ad hoc scaling avoids manual recalculations and downtime.

What Node-Level Checks Ensure Safe Resizing?

Applying the patch is only the first step. The Kubelet performs a series of checks to maintain node stability:

Verifies the requested pod-level resources are available on the node.
Confirms that the new budget does not exceed the node's allocatable capacity.
Checks existing QoS guarantees – requests are not reduced below what's already allocated.
Updates cgroups in a specific sequence to avoid transient resource conflicts.

If any check fails, the resize is rejected and the pod retains its previous configuration. The feature ensures that scaling operations are safe even under high load.

Are There Any Limitations or Prerequisites?

Yes. The most notable limitation is that resizePolicy cannot be set at the pod level – it must be defined per container. Additionally, the feature only applies to pods where containers inherit their requests/limits from the pod-level budget. Pods with explicit per-container limits are not affected. The feature is enabled by default in v1.36, but if you're upgrading, verify that InPlacePodLevelResourcesVerticalScaling is not manually disabled. Also, the CRI must support dynamic cgroup updates (most runtimes do).