Kubernetes v1.36 introduces an alpha feature called Pod-Level Resource Managers, which extends the kubelet's Topology, CPU, and Memory Managers to support pod-level resource specifications (.spec.resources). This shift from a per-container allocation model to a pod-centric one brings greater flexibility and efficiency for performance-sensitive workloads. In the following Q&A, we explain what this feature is, why it was needed, and how it can be used.
- What are Pod-Level Resource Managers?
- Why were Pod-Level Resource Managers introduced?
- How do Pod-Level Resource Managers work?
- What real-world use case does this feature address?
- How does the Topology Manager scope affect pod-level resource allocation?
- How can I enable this alpha feature in my cluster?
What are Pod-Level Resource Managers?
Pod-Level Resource Managers are a new alpha feature in Kubernetes v1.36 that allows the kubelet to allocate CPU, memory, and NUMA resources at the pod level rather than solely at the container level. By enabling the PodLevelResourceManagers and PodLevelResources feature gates, the Topology Manager, CPU Manager, and Memory Manager can now consider a pod-wide resource budget defined in .spec.resources. This enables hybrid allocation models where the main container gets exclusive, NUMA-aligned resources, while sidecar containers share a pooled subset of the pod's budget. This brings more efficient resource usage for performance-critical workloads without sacrificing NUMA alignment.
Why were Pod-Level Resource Managers introduced?
Before v1.36, if you needed exclusive, NUMA-aligned resources for a primary container (e.g., in ML training or low-latency databases), every container in the pod had to request integer CPU units to achieve Guaranteed QoS. This was wasteful for lightweight sidecars like loggers or proxies, which often need fractional CPUs. Without integer requests across all containers, the pod fell back to Burstable QoS, losing NUMA guarantees. Pod-Level Resource Managers solve this by allowing a pod-level budget: the primary container can claim exclusive CPU slices from that budget, while sidecars share a pool made from the remaining resources. This eliminates the trade-off between performance and resource efficiency.
How do Pod-Level Resource Managers work?
When enabled, the kubelet uses the pod-level resources field to determine the total CPU and memory budget for the entire pod. The Topology Manager performs NUMA alignment based on this budget, assigning it to a single NUMA node. The main container (or containers with explicit integer requests) then receives exclusive slices from that budget. The leftover resources form a pod shared pool, which sidecar containers can use without dedicated allocations. These sidecars share the pool but remain isolated from the main container's exclusive slices and from other pods. The CPU Manager and Memory Manager enforce this separation, ensuring predictable performance for the primary workload while allowing lightweight sidecars to share resources efficiently.
What real-world use case does this feature address?
A typical use case is a latency-sensitive database pod that includes a main database container, a metrics exporter, and a backup agent sidecar. Before this feature, you had to request integer CPUs for all three containers to maintain Guaranteed QoS, wasting cores on the sidecars. With Pod-Level Resource Managers (and the Topology Manager set to pod scope), you define a pod budget—say 8 CPUs and 16Gi memory. The database container gets exclusive, NUMA-aligned CPUs and memory from that budget. The remaining resources become a shared pool for the metrics exporter and backup agent. They can run with fractional CPU requests and share the pool, while being strictly isolated from the database's exclusive resources. This allows safe co-location of auxiliary containers without compromising performance or wasting cores.
How does the Topology Manager scope affect pod-level resource allocation?
The Topology Manager has several scopes (container, pod, etc.) that determine how NUMA alignment is applied. When using pod-level resource managers, the pod scope is the most relevant. With pod scope, the Topology Manager performs a single NUMA alignment based on the entire pod’s resource budget. All containers within the pod are aligned to the same NUMA node. The main container(s) with exclusive resources are pinned to specific CPU and memory from that node, while sidecars share a pool also on that node. This ensures that the primary workload gets local memory access while sidecars still benefit from being on the same NUMA node, minimizing cross-node traffic. Other scopes (like container) are not designed for pod-level budgets and may not provide the same benefits.
How can I enable this alpha feature in my cluster?
To use Pod-Level Resource Managers, your cluster must be running Kubernetes v1.36 or later. Enable the feature by setting two feature gates on the kubelet: PodLevelResourceManagers=true and PodLevelResources=true. You also need to configure the Topology Manager to use scope: pod in its policy. For example, in your kubelet configuration, add featureGates: {PodLevelResourceManagers: true, PodLevelResources: true} and set topologyManagerPolicy: best-effort or restricted with topologyManagerScope: pod. Note that this is an alpha feature, so it is not enabled by default and may have changes in future releases. Test it in non-production environments first.