Kubernetes v1.36 Beta Feature: Effortless In-Place Vertical Scaling for Pod-Level Resources

Introduction

Kubernetes continues to refine its resource management capabilities. After the graduation of Pod-Level Resources to Beta in v1.34 and the General Availability (GA) of In-Place Pod Vertical Scaling in v1.35, the community now celebrates a new milestone: In-Place Pod-Level Resources Vertical Scaling has reached Beta status in Kubernetes v1.36. This feature is enabled by default through the InPlacePodLevelResourcesVerticalScaling feature gate, giving administrators and developers a powerful tool for dynamic resource adjustment.

What Is Pod-Level Resources Vertical Scaling?

At its core, this feature allows you to update the aggregate .spec.resources budget for a running Pod — often without needing to restart any of its containers. Instead of manually recalculating per-container limits, you can now adjust the shared resource pool at the Pod level, and the Kubelet propagates the changes efficiently.

Why Pod-Level In-Place Resize?

Complex Pods — such as those with sidecars, init containers, or multiple microservices — benefit greatly from a simplified resource model. By allowing containers to share a collective pool of CPU and memory, the Pod-level approach reduces configuration overhead. In v1.36, you can now alter this aggregate boundary on the fly, which is especially useful when:

• Individual containers lack explicit resource limits; they automatically expand or shrink their effective boundaries to match the new Pod-level dimensions.
• Peak demand requires a quick boost to the shared pool without having to recalculate limits for each container.
• Sidecar containers or logging agents need more room during bursts, while the main application remains unaffected.

How Does It Work?

Resource Inheritance and the Resize Policy

When a Pod-level resize is initiated, the Kubelet treats the change as a resize event for every container that inherits its limits from the Pod-level budget. The decision to restart a container depends on the resizePolicy defined within each container:

• Non-disruptive Updates (NotRequired): If a container’s resizePolicy is set to NotRequired, the Kubelet tries to update the cgroup limits dynamically via the Container Runtime Interface (CRI). This means the container keeps running while its resource boundaries adjust in real time.
• Disruptive Updates (RestartContainer): If the policy is RestartContainer, the container is restarted to safely apply the new aggregate boundary.

It’s important to note that resizePolicy is not yet supported at the Pod level. The Kubelet always defers to each container’s individual settings to decide whether an update can be applied in-place or requires a restart.

Example: Scaling a Shared Resource Pool

Consider a Pod named shared-pool-app with a 2 CPU Pod-level limit. Neither its main container nor its sidecar defines individual CPU limits; they share the pool.

1. Initial Pod Specification

apiVersion: v1
kind: Pod
metadata:
  name: shared-pool-app
spec:
  resources: # Pod-level limits
    limits:
      cpu: "2"
      memory: "4Gi"
  containers:
  - name: main-app
    image: my-app:v1
    resizePolicy:
    - resourceName: "cpu"
      restartPolicy: "NotRequired"
  - name: sidecar
    image: logger:v1
    resizePolicy:
    - resourceName: "cpu"
      restartPolicy: "NotRequired"

2. The Resize Operation

To double the CPU capacity to 4 CPUs, apply a patch using the resize subresource:

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 adjusts the cgroup limits without restarting either container — a seamless expansion of the shared pool.

Node-Level Reality: Feasibility and Safety

Applying a resize patch is only the first step. The Kubelet performs a series of checks to ensure node stability and resource guarantees. When a resize request arrives, the Kubelet:

1. Validates that the new aggregate Pod resource request fits within the node’s available capacity.
2. Checks that no other Pods on the node are starved or violated.
3. Ensures that the resize does not exceed the Pod’s QoS class guarantees (for guaranteed Pods, the total resources must be within the class boundaries).
4. Updates the cgroup parameters dynamically if possible, or triggers a container restart when required by the resizePolicy.

These mechanisms make Pod-level in-place scaling safe for production clusters, as the Kubelet carefully balances flexibility with stability.

Conclusion

The graduation of In-Place Pod-Level Resources Vertical Scaling to Beta in Kubernetes v1.36 marks a significant step forward for resource agility. By enabling dynamic adjustments to the shared resource pool without container restarts, this feature simplifies operations for complex, sidecar-heavy Pods. Whether you’re handling traffic spikes or rebalancing workloads, the ability to modify the Pod-level budget in real time reduces manual overhead and improves cluster responsiveness. As always, the Kubernetes community encourages experimenting with this feature and providing feedback for future improvements.