Welcome to the latest Kubernetes release! v1.36 brings a significant enhancement: In-Place Vertical Scaling for Pod-Level Resources has graduated to Beta and is now enabled by default. This feature allows you to adjust the aggregate resource budget of a running pod on the fly, without always restarting containers. Below, we answer common questions about this update, from what it is to how it works in practice. Jump to a specific question: What's new? | Why pod-level scaling? | How resizePolicy works | Example of scaling | Node-level checks | Pod-level resizePolicy?

What is the key change in Kubernetes v1.36 for vertical scaling?

Kubernetes v1.36 marks the Beta graduation of In-Place Pod-Level Resources Vertical Scaling, enabled by the InPlacePodLevelResourcesVerticalScaling feature gate. This follows the earlier Beta of Pod-Level Resources in v1.34 and the General Availability of In-Place Pod Vertical Scaling in v1.35. Now, you can modify the aggregate resource budget (.spec.resources) for a running pod without necessarily restarting containers. The feature is on by default, making it easier to manage resource allocation for complex pods, especially those with sidecars. This update simplifies operations by allowing dynamic adjustments to the shared pool of CPU and memory, reducing the need for manual per-container recalculations during peak demand.

Why is pod-level in-place vertical scaling useful?

The pod-level resource model simplifies management for pods with multiple containers, such as those using sidecars. Instead of assigning individual limits to each container, you define a collective resource pool at the pod level. With in-place vertical scaling, you can adjust this aggregate boundary on-the-fly. This is particularly valuable when containers do not have their own limits—they inherit the pod-level budget and automatically scale their effective boundaries to fit the new dimensions. For example, during traffic spikes, you can expand the shared CPU pool without recalculating limits for each container. This reduces operational overhead and ensures that all containers in the pod can efficiently utilize available resources.

How does the resizePolicy affect container restarts during pod-level scaling?

When a pod-level resize is triggered, the Kubelet treats it as a resize event for every container that inherits its limits from the pod budget. To determine whether a restart is necessary, the Kubelet checks the resizePolicy defined inside each container. If a container's policy is NotRequired, the Kubelet will attempt to update the cgroup limits dynamically through the Container Runtime Interface (CRI)—a non-disruptive update. If the policy is RestartContainer, the container will be restarted to safely apply the new aggregate boundary. Note that the resizePolicy is currently not supported at the pod level; the Kubelet always defers to individual container settings to decide whether an in-place update or a restart is needed.

Can you show an example of scaling a shared resource pool?

Absolutely. Consider a pod named shared-pool-app that defines a pod-level limit of 2 CPU and 4Gi memory. The two containers—main-app and sidecar—do not have individual limits, so they share the pool. Both containers have a resizePolicy of NotRequired for CPU. To double the CPU capacity from 2 to 4, you apply a patch using the resize subresource:

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

Because both containers allow non-disruptive updates, the Kubelet will adjust the cgroup limits live, without restarting any containers. The shared pool expands seamlessly, and both containers can immediately use up to 4 CPUs collectively.

What node-level checks does the Kubelet perform before applying a pod-level resize?

Applying a resize patch is only the first step. The Kubelet performs several feasibility and safety checks to ensure node stability. It follows a specific sequence: first, it validates that the requested resources are available on the node (e.g., enough free CPU or memory). Then it checks that the change doesn't violate any quality-of-service (QoS) guarantees for other pods. The Kubelet also verifies that the resize is consistent with the pod's existing resource allocations and that no conflicts arise with node-level resource management policies. If all checks pass, the Kubelet proceeds to apply the new limits, either in-place (for containers with NotRequired policy) or via restart. These safeguards prevent overcommitment and maintain overall cluster stability.

Is resizePolicy supported at the pod level?

No, currently the resizePolicy is not supported at the pod level. The feature is only configurable within individual container specifications. When a pod-level resize occurs, the Kubelet examines each container's own resizePolicy to decide whether that container can be updated non-disruptively or requires a restart. This design gives fine-grained control per container. For example, a critical container might be set to RestartContainer to ensure a clean application of new limits, while a sidecar can be set to NotRequired for a seamless update. Future versions of Kubernetes may introduce pod-level policy support, but as of v1.36, the container-level approach remains the standard.