Kubernetes v1.36 has arrived, and with it comes a major milestone for cluster operators and developers alike: In-Place Pod-Level Resources Vertical Scaling has graduated to Beta. This means you can now dynamically adjust the aggregate resource budget of a running Pod—often without restarting any container—right out of the box. In this article, we break down everything you need to know about this feature, from why it matters to how to put it into practice.
1. The Big News: Beta with Default Enablement
First and foremost, the InPlacePodLevelResourcesVerticalScaling feature gate is now enabled by default in Kubernetes v1.36. This marks the graduation from Alpha to Beta, following the earlier General Availability of in-place vertical scaling for individual containers. The feature allows you to modify the Pod-level resource budget (.spec.resources) on a running Pod, typically without forcing a container restart. For anyone managing complex Pods with multiple containers (like those with sidecars), this is a game-changer.
2. Why Pod-Level Resources Matter for Sidecars and More
Traditional resource allocation required setting limits per container, which becomes cumbersome when containers share workloads. Pod-level resources let you define a single resource budget for the entire Pod. Containers that lack individual limits automatically inherit from this pool, scaling their effective boundaries as the Pod’s aggregate changes. In practice, you can expand the shared CPU or memory pool during peak demand without recalculating limits for each container manually. This simplification is especially valuable for sidecar patterns (e.g., logging, proxying) where containers need to flexibly share resources.
3. How Pod-Level Resizing Works: The Kubelet’s Role
When you submit a resize request via the resize subresource, the Kubelet treats the change as a resize event for every container that inherits its limits from the Pod-level budget. The Kubelet then checks each container’s resizePolicy to decide the action: either apply cgroup updates dynamically (non-disruptive) or restart the container. This per-container decision ensures that workloads with strict continuity requirements can keep running while others accept brief restarts for safety.
4. Understanding the ResizePolicy: NotRequired vs. RestartContainer
Each container can define a resizePolicy that dictates how the Kubelet handles resource changes. Two restart policies exist:
- NotRequired (non-disruptive): The Kubelet tries to update cgroup limits in real-time via the Container Runtime Interface (CRI). No container restart needed.
- RestartContainer (disruptive): The container is restarted to safely apply the new resource boundaries. This is useful when the runtime cannot adjust limits in place.
Note: Currently, the resizePolicy is only supported at the container level, not at the Pod level. The Kubelet always defers to individual container settings.
5. Live Example: Scaling a Shared CPU Pool
Imagine a Pod with a 2 CPU Pod-level limit and two containers that inherit that limit. To double the CPU to 4, you apply a simple patch via the resize subresource:
kubectl patch pod shared-pool-app --subresource resize --patch \
'{"spec":{"resources":{"limits":{"cpu":"4"}}}}'Because both containers have restartPolicy: NotRequired, the Kubelet updates their cgroups on the fly. The sidecar and main app continue running without interruption, now sharing the expanded pool. This pattern makes it easy to handle traffic spikes or batch jobs without downtime.
6. Node-Level Safety: Feasibility and Verification
Submitting a resize patch is only the start. The Kubelet runs a sequence of checks to ensure node stability. It verifies that the node has sufficient allocatable resources to accommodate the new aggregate budget. If the resize would exceed the node’s capacity, the request is rejected. The Kubelet also validates that the new Pod-level resource values are consistent with any container-level limits. This multi-step safety net prevents oversubscription and maintains cluster health.
In summary, Kubernetes v1.36’s in-place Pod-level vertical scaling Beta opens up new flexibility for dynamic resource management. By enabling this feature by default, the community has made it easier than ever to optimize resource usage for complex Pods. Whether you’re running sidecars, batch jobs, or auto-scaling microservices, this feature is worth exploring in your clusters today.