Kubernetes 1.37 DRA Explained: GPU & AI Workloads Guide (2026)

Kubernetes 1.37 DRA Explained: GPU & AI Workloads Guide

Kubernetes 1.37 (released August 26, 2026) significantly advances Dynamic Resource Allocation (DRA), making it the definitive framework for scheduling GPUs and AI workloads across heterogeneous, multi-node clusters.

This release brings critical DRA features to Stable and Beta, including device taints, workload-aware gang scheduling, and extended resource support—enabling operators to quarantine faulty GPUs, co-schedule distributed training jobs, and share accelerators across pods without manual device plugin management.

What Is Dynamic Resource Allocation (DRA)?

Dynamic Resource Allocation (DRA) is a Kubernetes feature that lets you request and share specialized hardware resources—such as GPUs, TPUs, and RDMA NICs—among Pods using a declarative, attribute-based model.

Unlike traditional device plugins that expose resources as simple counts (e.g., nvidia.com/gpu: 2), DRA allows device drivers and cluster admins to define DeviceClasses with rich metadata (memory size, NVLink topology, MIG capability, NUMA placement). Workloads then request resources via ResourceClaims that match specific device attributes using CEL expressions.

Key benefits include:

• Flexible device filtering: Use CEL to request "Hopper GPUs with ≥40GB memory and NVLink connectivity."

• Device sharing: Multiple Pods or containers can share the same GPU via a shared ResourceClaim.

• Per-workload device configuration: Attach vendor-specific configs to claims, not nodes.

• Centralized categorization: Define cost-optimized vs. high-performance DeviceClasses for different workloads.

• Simplified Pod specs: Pods reference claims instead of specifying raw resource quantities.

What's New in Kubernetes 1.37 for DRA?

1. DRA Device Taints and Tolerations (Stable)

This feature mirrors the node taint model but applies it to individual devices.

Use case: A GPU is overheating or undergoing driver maintenance. Instead of cordoning the entire node, you can taint just that GPU:

apiVersion: resource.k8s.io/v1alpha3
kind: DeviceTaintRule
metadata:
  name: gpu-maintenance
spec:
  nodeName: worker-01
  deviceName: nvidia-gpu-0
  taints:
  - key: maintenance
    effect: NoSchedule

Pods without a matching toleration will avoid this GPU. Diagnostic jobs can add a toleration to override the taint.

2. DRA Extended Resource Support (GA)

DRA drivers can now satisfy traditional extended resource requests (e.g., example.com/gpu: 3) without requiring a separate device plugin or explicit ResourceClaim.

This simplifies migration: existing workloads using resources.limits.nvidia.com/gpu can work with DRA drivers directly, while new workloads adopt the full ResourceClaim model.

3. DRA Resource Claim Status with Network Interface Data (Stable)

The .status.devices field on ResourceClaims now includes standardized network interface metadata (interface name, MAC, IP addresses).

This is critical for GPU workloads using RDMA fabrics (e.g., NVIDIA GPUDirect, InfiniBand) that require precise network topology awareness.

4. Gang Scheduling with Workload-Aware Preemption (Beta)

Gang scheduling (KEP-4671) ensures that all Pods in a distributed training job are scheduled together—or not at all.

Why it matters: Without gang scheduling, a multi-node training job might partially schedule, leaving GPUs idle while waiting for the remaining Pods. This wastes expensive accelerator capacity.

Example: A 70B-parameter model training job requires 8× H100 GPUs across 4 nodes. With gang scheduling, you define a PodGroup with minCount: 4. The scheduler waits until all 4 nodes have available GPUs before placing any Pod.

Important: Gang scheduling is disabled by default in 1.37. Enable it via:

• Feature gate: GenericWorkload

• API group: scheduling.k8s.io/v1alpha3

Workload-aware preemption (KEP-5710) also graduated to Beta, allowing the scheduler to preempt lower-priority workloads to satisfy gang scheduling constraints.

5. DRA Group Claim Sharing (Beta)

Multiple Pods can now share a single ResourceClaim for large multi-node tasks.

This is ideal for distributed training where all Pods in a job need access to the same set of GPUs or RDMA NICs, reducing claim management overhead.

6. Pod-Level Resources (Stable)

CPU, memory, and hugepage requests/limits can now be set at the Pod level instead of per container.

For multi-container GPU workloads (e.g., model server + sidecar, prefill + decode pods), this eliminates redundant resource declarations and simplifies scheduling.

Example: Scheduling a Distributed AI Training Job

Here's how to use DRA and gang scheduling for a multi-node training workload in Kubernetes 1.37:

Step 1: Define a DeviceClass

apiVersion: resource.k8s.io/v1alpha3
kind: DeviceClass
metadata:
  name: nvidia-h100-nvlink
spec:
  selectors:
  - cel:
      expression: >
        device.attributes['nvidia.com'].model == 'H100' &&
        device.attributes['nvidia.com'].memory >= 80Gi &&
        device.attributes['nvidia.com'].nvlink == true

This DeviceClass matches H100 GPUs with ≥80GB memory and NVLink connectivity.

Step 2: Create a ResourceClaimTemplate

apiVersion: resource.k8s.io/v1alpha3
kind: ResourceClaimTemplate
metadata:
  name: h100-training-claim
spec:
  spec:
    deviceClassName: nvidia-h100-nvlink
    count: 8

Step 3: Define a PodGroup for Gang Scheduling

apiVersion: scheduling.k8s.io/v1alpha3
kind: PodGroup
metadata:
  name: training-job-001
spec:
  minCount: 4  # All 4 Pods must schedule together
  scheduleTimeoutSeconds: 300

Step 4: Deploy Pods with ResourceClaims

apiVersion: v1
kind: Pod
metadata:
  name: trainer-0
  labels:
    workload: training-job-001
spec:
  resourceClaims:
  - name: gpu-claim
    resourceClaimTemplateName: h100-training-claim
  containers:
  - name: trainer
    image: pytorch:2.4-cuda12
    command: ["torchrun", "--nproc_per_node=8", "train.py"]

Repeat for trainer-1 through trainer-3, all labeled with workload: training-job-001. The gang scheduler ensures all 4 Pods are placed simultaneously.

Migration Path: From Device Plugins to DRA

If you're currently using NVIDIA Device Plugin or similar, here's a pragmatic migration strategy:

1. Inventory workloads: Classify by device shape (whole-GPU training, MIG inference, multi-node jobs).

2. Upgrade to Kubernetes 1.34+: DRA Core APIs became GA in 1.34; 1.37 adds critical production features.

3. Install DRA driver: Deploy the NVIDIA GPU DRA driver (or AMD/Google equivalent) alongside or instead of the legacy device plugin.

4. Create DeviceClasses: Define classes for different workload types (e.g., h100-training, a100-inference-mig).

5. Migrate incrementally: Start with new workloads using ResourceClaims; keep legacy workloads on extended resources until DRA Extended Resource support is validated.

6. Add Kueue for batch admission: If multiple teams compete for GPUs, use Kueue with ClusterQueues, ResourceFlavors, and fair-sharing policies.

7. Test gang scheduling: Enable GenericWorkload feature gate and test PodGroup scheduling in non-production.

Operational Best Practices for AI Workloads

• Use device taints for maintenance: Taint GPUs undergoing driver updates or thermal issues without cordoning entire nodes.

• Monitor ResourceClaim status: Use .status.devices to track allocated IPs and interface names for RDMA workloads.

• Enable HPA scale-to-zero: For inference endpoints, set spec.minReplicas: 0 to release GPUs during idle periods (enabled by default in 1.37).

• Validate topology awareness: Ensure DRA drivers expose NUMA, NVLink, and PCIe topology attributes for optimal placement.

• Test cold-start latency: Scale-to-zero and gang scheduling introduce cold-start delays; evaluate tradeoffs for latency-sensitive workloads.

What's Still Alpha or Coming Soon?

• CompositePodGroup API (Alpha): Describes complex, heterogeneous workloads with mixed scheduling requirements.

• DRA Workload Resource Claims (Beta): Workload-level claims (vs. per-Pod) expected to reach GA in 1.38 or 1.39.

• Derived Attributes (Alpha): Use CEL expressions to match devices based on custom rules (e.g., "GPUs adjacent to the same PCIe root")

• Fractional Capacity Requests (Alpha): DRA Consumable Capacity now supports fractional values for precise allocation of shared resources.

Final Thoughts

Kubernetes 1.37 cements DRA as the production-ready framework for GPU and AI workload scheduling. With device taints, gang scheduling, and extended resource support now Stable or Beta, operators can confidently migrate from legacy device plugins to a more flexible, attribute-driven model.

For teams running distributed training, multi-tenant inference, or HPC workloads, the practical next steps are: test gang scheduling in non-production, audit DRA device taint policies, and evaluate HPA scale-to-zero for cost optimization.

The era of "GPU as a count" is over. In 2026, Kubernetes schedules GPUs by attribute, topology, and workload intent—and DRA in 1.37 makes that operational reality.