7 Key Insights into Kubernetes v1.36: In-Place Pod-Level Vertical Scaling Reaches Beta

Kubernetes continues to evolve, and the latest release—v1.36—brings a significant milestone for resource management. After the graduation of Pod-Level Resources to Beta in v1.34 and the General Availability of In-Place Pod Vertical Scaling in v1.35, the community now celebrates the Beta status of In-Place Pod-Level Resources Vertical Scaling. This feature, enabled by default via the InPlacePodLevelResourcesVerticalScaling feature gate, empowers cluster operators to adjust a running Pod's aggregate resource budget (.spec.resources) without forcing a container restart in many cases. In this article, we break down the seven most important things you need to know about this update.

1. Feature Overview: What Graduated to Beta?

Kubernetes v1.36 officially promotes In-Place Pod-Level Resources Vertical Scaling to Beta. This means the feature is now turned on by default for all clusters running v1.36. In practical terms, it allows you to modify the total resource limits (CPU and memory) for an entire Pod—using the .spec.resources field—while the Pod is already running. The key advantage? In most scenarios, containers do not need to be restarted, leading to zero downtime during resource adjustments. This is a natural evolution from earlier releases that enabled per-container in-place resizing and then Pod-level resource definition.

2. Why Pod-Level In-Place Resize Matters

Managing resources for complex Pods—especially those with sidecar containers—has always been tricky. Previously, you had to calculate individual container limits and hope they didn't conflict. The Pod-level resource model simplifies this by letting all containers in a Pod share a collective pool of resources. With v1.36, you can now adjust this shared boundary on the fly. This is particularly useful for workloads that experience sudden spikes in demand: instead of recalculating limits for each container manually, you simply expand the Pod-level budget. Containers without their own individual limits automatically inherit the new boundaries, making scaling more efficient and less error-prone.

3. How It Works: Resource Inheritance and the resizePolicy

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. The actual behavior depends on each container's resizePolicy. This field, defined per container, tells the Kubelet whether a container can be updated in place (NotRequired) or must be restarted (RestartContainer). The Kubelet consults the restartPolicy within each container's resizePolicy to decide the appropriate action. Currently, there is no Pod-level resizePolicy; the enforcement always descends to individual container settings.

4. Non-Disruptive vs. Disruptive Updates

The decision between a seamless update and a restart boils down to two options:

• Non-Disruptive Updates: If a container's restartPolicy is set to NotRequired, the Kubelet attempts to update the cgroup limits dynamically via the Container Runtime Interface (CRI). The container keeps running with the new resource boundaries.
• Disruptive Updates: If the policy is RestartContainer, the container will be stopped and started again to safely apply the new aggregate boundaries. This ensures that any state-dependent resource changes are handled properly.

Choosing the right policy for each container is critical to balancing flexibility and stability.

5. Walkthrough: Scaling a Shared Resource Pool

Let's walk through a concrete example. Imagine a Pod called shared-pool-app with a Pod-level CPU limit of 2 CPUs. It contains two containers: main-app and sidecar. Neither container defines its own CPU limit, so they share the 2-CPU pool. To double the capacity to 4 CPUs, you apply a patch to the resize subresource:

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

Both containers have resizePolicy with restartPolicy: NotRequired, so the Kubelet updates the cgroup limits in place. The containers continue running, now able to use up to 4 CPUs collectively—no restarts, no manual recalculations.

6. Node-Level Safety Checks

Applying a resize patch is only the first step. The Kubelet performs several checks to ensure node stability before committing the change:

1. Feasibility: The Kubelet verifies that the node has enough available resources to accommodate the new Pod-level budget.
2. Capacity: It checks if the requested resources are within the node's allocatable capacity.
3. Ordering: Updates are applied in a controlled sequence—usually starting with containers that don't require a restart to minimize disruption.
4. Rollback: If any step fails, the Kubelet can revert to the previous resource allocation to avoid instability.

These checks ensure that even dynamic scaling does not compromise overall cluster health.

7. Looking Ahead: Limitations and Future Directions

While this Beta release is powerful, it has a notable limitation: resizePolicy is currently not supported at the Pod level. The Kubelet always defers to individual container settings to decide if a change can be applied in place. This means you still need to define resizePolicy for each container that inherits Pod-level limits. Future Kubernetes releases may introduce a Pod-level policy for even simpler management. For now, the feature provides a solid foundation for dynamic, in-place scaling of shared resource pools—greatly simplifying operations for sidecar-heavy or multi-container Pods.

The graduation of In-Place Pod-Level Resources Vertical Scaling to Beta marks a significant step forward for Kubernetes resource management. It reduces operational overhead, enables faster scaling response, and lays the groundwork for even more intelligent resource automation. Start experimenting with it in your v1.36 clusters today!