Kubernetes v1.36 Alpha: Pod-Level Resource Managers Bring Flexibility to Performance-Sensitive Workloads

A New Era for Resource Allocation in Kubernetes

Kubernetes v1.36 introduces a groundbreaking alpha feature: Pod-Level Resource Managers. This enhancement transforms how the kubelet's Topology, CPU, and Memory Managers handle resource allocation—shifting from a strict per-container model to a pod-centric one. For teams running performance-sensitive workloads like machine learning (ML) training, high-frequency trading, or low-latency databases, this change unlocks greater flexibility and efficiency without sacrificing the NUMA alignment essential for predictable performance.

Why Pod-Centric Resource Management?

Modern Kubernetes pods rarely contain a single container. They often include sidecar containers for logging, monitoring, service meshes, or data ingestion. Before this feature, achieving NUMA-aligned, exclusive resources for a primary application container came with a painful trade-off:

• To get Guaranteed QoS and exclusive CPU allocation for your main container, you had to allocate integer CPUs to every container in the pod—even lightweight sidecars.
• If you chose not to allocate exclusive CPUs to sidecars, the pod lost its Guaranteed QoS class entirely, forfeiting performance benefits.

This forced teams to either waste resources on sidecars or compromise performance. Pod-level resource managers eliminate this dilemma by introducing a hybrid allocation model.

How Pod-Level Resource Managers Work

By enabling the PodLevelResourceManagers and PodLevelResources feature gates, the kubelet can create a single NUMA alignment for the entire pod based on its overall resource budget. Within that budget:

• The primary container gets exclusive, dedicated CPU and memory slices from a chosen NUMA node.
• Remaining resources form a pod shared pool that auxiliary containers can share—isolated from the exclusive slices and the rest of the node.

This allows sidecar containers to operate without dedicated cores, while the primary workload enjoys Guaranteed QoS and NUMA locality. The feature supports different Topology Manager scopes (e.g., pod, container), making it adaptable to various deployment patterns.

Use Case: Tightly-Coupled Database with Topology Manager (Pod Scope)

Consider a latency-sensitive database pod comprising:

• A main database container
• A local metrics exporter sidecar
• A backup agent sidecar

With the pod Topology Manager scope and pod-level resources, the kubelet aligns the entire pod to a single NUMA node. The database container receives its exclusive CPUs and memory from that node. The remaining resources (from the pod's 8 CPU / 16 Gi budget) become the pod shared pool. The metrics exporter and backup agent run in this pool, sharing resources with each other but strictly isolated from the database's dedicated cores and the node's other workloads.

apiVersion: v1
kind: Pod
metadata:
  name: tightly-coupled-database
spec:
  # Pod-level budget ensures NUMA alignment
  resources:
    requests:
      cpu: "8"
      memory: "16Gi"
    limits:
      cpu: "8"
      memory: "16Gi"
  containers:
  - name: database
    image: my-database:latest
    # container-level resources can specify exclusive slices
    resources:
      requests:
        cpu: "6"
        memory: "12Gi"
      limits:
        cpu: "6"
        memory: "12Gi"
  - name: metrics-exporter
    image: metrics-exporter:v1
    # no exclusive CPU needed — runs from pod shared pool
  - name: backup-agent
    image: backup-agent:v1
    # also uses pod shared pool

This configuration allows safe co-location of auxiliary containers on the same NUMA node without wasting dedicated cores, enabling predictable performance for the database while keeping sidecars functional.

What This Means for Your Workloads

Pod-level resource managers are currently in alpha (Kubernetes v1.36). They represent a significant step toward more granular, efficient resource management for performance-critical applications. While still experimental, this feature promises to reduce resource waste, simplify QoS configuration, and improve overall cluster utilization—especially for pods with mixed workloads. As the feature matures, expect it to become a cornerstone of high-performance Kubernetes deployments.

For more details, refer to the official Kubernetes documentation on Pod-Level Resources.