Nov 17, live webinar: ECS to EKS without freezing the roadmap for a quarter

AKS Now Manages DRA for GPU Node Pools: How to Get the Same GPU Scheduling on EKS, GKE or Your Own Kubernetes

AKS added managed Dynamic Resource Allocation (DRA) for NVIDIA GPU node pools in preview. DRA itself is upstream Kubernetes (resource.k8s.io/v1, GA since 1.34) and the NVIDIA DRA driver is open source, so you can run the same claim-based GPU scheduling on EKS, GKE or a self-managed cluster. Here is how, and what each cloud still leaves to you.

Guillaume Da Silva
Staff Solutions Architect
NOV 16, 2026 · 17 MIN
AKS Now Manages DRA for GPU Node Pools: How to Get the Same GPU Scheduling on EKS, GKE or Your Own Kubernetes

Key points:

  • AKS managed DRA for GPUs is a preview, documented on November 7, 2026. You create a GPU node pool with --enable-managed-gpu=true --gpu-driver-mode DRA on Kubernetes 1.35 or later, and AKS installs and maintains the NVIDIA DRA driver for you. Cluster autoscaler and node auto-provisioning are not supported yet (Microsoft Learn).
  • The scheduling model itself is upstream Kubernetes. Dynamic Resource Allocation (the resource.k8s.io/v1 API with DeviceClass, ResourceClaim, ResourceClaimTemplate and ResourceSlice) went GA in Kubernetes 1.34 (Kubernetes blog). A ResourceClaim written for AKS runs unchanged on EKS, GKE or kubeadm, as long as an NVIDIA DRA driver publishes the GPUs.
  • The driver is the same open-source project everywhere. The NVIDIA DRA driver for GPUs lives in kubernetes-sigs/dra-driver-nvidia-gpu, latest release v0.5.1 (October 12, 2026). AKS manages it for you; on EKS Auto Mode (1.36+) it ships in the node runtime; on EKS with Karpenter or node groups, GKE Standard and self-managed clusters you install it with Helm.
  • AKS removes driver lifecycle work, and lock-in depends on how you write manifests. The portable recipe is a DRA-only GPU node pool per cloud, one shared DeviceClass name, and workloads that request GPUs only through ResourceClaimTemplates. Keep cloud-specific details (node pool flags, labels, taints) out of application manifests.
  • Qovery schedules GPUs through the NVIDIA device plugin today. On clusters Qovery manages you get GPU node pools and a GPU count per service, which becomes an nvidia.com/gpu request. Qovery does not install the NVIDIA DRA driver or create DeviceClasses for you. On your own cluster you can deploy the driver and claim-based workloads through Qovery as Helm services.

Qovery · Infrastructure control plane
Build with Claude Code, Deploy with Qovery
Learn more

Since KubeCon North America, three customers have asked me the same question in slightly different words: "Azure now manages DRA for GPUs, do we have to move to AKS to get it?" You don't. Microsoft took the most annoying part of DRA, keeping a GPU driver stack in sync with node images, and turned it into a node pool flag. That is useful. The scheduling model underneath is upstream Kubernetes, and the driver is an open-source Kubernetes SIG project.

I'm a solutions architect at Qovery, and I spend a good part of my week on GPU clusters that live in customers' own AWS, GCP, Azure and Scaleway accounts. Below is what AKS announced, what DRA is and which parts are stable, how to run the same thing on EKS, GKE and self-managed clusters, and where Qovery fits and where it doesn't.

What did AKS announce for Dynamic Resource Allocation on GPU node pools?

AKS added managed DRA for NVIDIA GPU node pools as a public preview, announced at KubeCon + CloudNativeCon North America 2026 and documented on Microsoft Learn on November 7, 2026 (Microsoft Learn). Instead of asking for nvidia.com/gpu: 1, workloads describe the device they need in a ResourceClaim, and AKS runs and updates the NVIDIA DRA driver on the node pool (Cloud Native Now).

It builds on AKS managed GPU node pools, where AKS already installs and maintains the NVIDIA GPU driver, the Kubernetes device plugin and the DCGM metrics exporter (Microsoft Learn). The new part is a driver mode switch. Here is what the preview requires, straight from the docs:

  • Kubernetes 1.35 or later on the cluster, and the aks-preview CLI extension at version 22.0.0b6 or later.
  • The ManagedGPUExperiencePreview feature flag registered on the subscription.
  • A node pool created with --enable-managed-gpu=true --gpu-driver-mode DRA. If you omit --gpu-driver-mode, you get the device plugin.
  • No cluster autoscaler and no node auto-provisioning (NAP) on DRA GPU pools during the preview. AzureContainerLinux is not a supported OS SKU.
  • No in-place switch. You create a new DRA pool next to the existing device plugin pool and migrate workloads, because existing nvidia.com/gpu requests are not translated into claims.
BASH
az aks nodepool add \
  --resource-group "$RESOURCE_GROUP" \
  --cluster-name "$CLUSTER_NAME" \
  --name gpunp \
  --node-vm-size Standard_NC24ads_A100_v4 \
  --enable-managed-gpu=true \
  --gpu-driver-mode DRA \
  --node-count 1

Microsoft shipped a second DRA driver alongside it. Managed support for DRANET, the Kubernetes SIG network driver that hands RDMA NICs to pods through the same claim model, is documented for RDMA-capable VM sizes on Kubernetes 1.35+ (Microsoft Learn). Pixel Robots, who attended the AKS pre-day, reported managed DRA for GPUs as public preview and managed DRANET as GA (Pixel Robots).

Microsoft's own callout says AKS previews are excluded from SLAs and "aren't meant for production use." If you run production inference on AKS today, the device plugin path remains the supported one.

What is Dynamic Resource Allocation in Kubernetes, and is it GA?

Dynamic Resource Allocation is the Kubernetes API for requesting hardware devices through claims instead of integer counts. Its core, the resource.k8s.io/v1 API group, graduated to GA in Kubernetes 1.34 (Kubernetes blog), and the DynamicResourceAllocation feature gate has been Stable since 1.34 (Kubernetes feature gates).

DRA has four objects (Kubernetes docs):

  • ResourceSlice. Published by a driver on each node. It lists the devices and their attributes (model, memory, driver version, PCIe root, NUMA node).
  • DeviceClass. Cluster-scoped, written by the platform team. It selects a category of devices with a CEL expression, for example "NVIDIA full GPUs".
  • ResourceClaim. Namespaced. A request for one or more devices from a class, optionally narrowed by more CEL selectors.
  • ResourceClaimTemplate. Generates one ResourceClaim per Pod, which is what a Deployment with several replicas wants.

The scheduler reads the slices, finds a node where the claim can be satisfied together with the Pod's other constraints, and records the allocation in the claim's status. The kubelet then asks the driver to prepare the device for the container.

Core DRA is GA, but several features around it graduated later. If you write manifests that need to work on AKS, EKS and GKE at the same time, your floor is the oldest Kubernetes version across those clusters. Here is where each piece stands in Kubernetes 1.37, from the feature gate table (Kubernetes feature gates):

DRA featureFeature gateStatusWhat it gives you for GPUs
Core DRA (claims, classes, slices)DynamicResourceAllocationStable since 1.34Claim-based GPU requests, CEL selection on attributes
Prioritized list of alternativesDRAPrioritizedListStable since 1.36"Give me an H100, else an A100" in one claim
Admin access to in-use devicesDRAAdminAccessStable since 1.36Monitoring or debugging Pods that see allocated GPUs
Extended resource mappingDRAExtendedResourceBeta in 1.36, Stable in 1.37Plain nvidia.com/gpu requests served by a DRA driver
Device taints and DeviceTaintRulesDRADeviceTaints, DRADeviceTaintRulesStable in 1.37Fence one bad GPU instead of draining the node
Partitionable devicesDRAPartitionableDevicesBeta since 1.36Dynamic partitioning, the basis for dynamic MIG
Consumable capacityDRAConsumableCapacityBeta since 1.36Several claims sharing one device's capacity

Device taints were the headline of 1.37 on EKS, and I won't repeat that analysis here. Romaric covered it with the dollar math per failed GPU in Kubernetes 1.37 on EKS: DRA device taints, Metrics API GA and upgrade order.

The CNCF's 2025 annual survey found that 66% of organizations hosting generative AI models use Kubernetes for some or all of their inference (CNCF). Every one of those clusters asks the scheduler for GPUs somehow, and an integer count leaves a lot of information on the floor.

How is DRA different from the NVIDIA device plugin?

The device plugin advertises GPUs as an integer, nvidia.com/gpu: 8, and the scheduler only knows "this node has N of them". DRA advertises each GPU as a device with attributes, so a claim can ask for a specific model, a minimum amount of memory, or two GPUs on the same PCIe root, and the scheduler picks a node that matches. AWS sums it up in one line of its comparison table: rich attributes through ResourceSlice objects versus an "integer count of nvidia.com/gpu extended resources" (Amazon EKS docs).

CapabilityNVIDIA device pluginNVIDIA DRA driver
How a Pod asksresources.limits: nvidia.com/gpu: 1ResourceClaim or ResourceClaimTemplate referencing a DeviceClass
What the scheduler seesA count per nodeEach device with attributes and capacity
Pick a GPU model or memory sizeNode labels plus nodeSelector (needs GPU Feature Discovery)CEL selector on the claim
Fallback between GPU typesSeparate Deployments or node affinity tricksPrioritized list in one claim (Stable in 1.36)
Fence one faulty GPUCordon and drain the nodeDevice taint on that GPU (Stable in 1.37)
Multi-node NVLink (GB200 class)Not supportedComputeDomain resources
GPU sharing (MIG, MPS, time-slicing)GA, static configurationStatic supported; dynamic MIG and time-slicing still alpha
Minimum KubernetesAny supported version1.34 for the driver on EKS; 1.35 for AKS managed DRA and GKE
MaturityYears in productionDriver at v0.5.x, core API GA

Two rules apply on every cloud. First, never run both on the same node. AWS warns that doing so "can cause silent oversubscription of the underlying devices to multiple pods on the same node" (Amazon EKS docs), and AKS says the same thing in its limitations. Second, plan a separate node pool for DRA. Every managed offering I checked migrates with side-by-side pools.

What does the NVIDIA DRA driver do, and who maintains it?

The NVIDIA DRA driver for GPUs is the open-source component that publishes GPUs as ResourceSlices and prepares them for containers. It started under NVIDIA's GitHub organization and now lives in kubernetes-sigs/dra-driver-nvidia-gpu, with images on registry.k8s.io (GitHub). The repository has about 730 stars and ships roughly every two months: v0.4.1 on June 30, v0.5.0 on August 19 and v0.5.1 on October 12, 2026 (releases).

It runs two kubelet plugins. gpu-kubelet-plugin handles full GPUs and MIG devices. compute-domain-kubelet-plugin handles ComputeDomains, the multi-node NVLink feature you need on GB200-class systems. You can disable either at install time (Amazon EKS docs).

v0.5.0 added support for deployment with the NVIDIA GPU Operator v26.7.0, multi-user MPS, NUMA attributes, and cross-namespace GPU sharing using DRA consumable capacity behind an alpha ConsumableShares gate (v0.5.0 release notes). Several features you might want for cost reasons (dynamic MIG, time-slicing, health-check taints) sit behind alpha feature gates that are off by default. AWS recommends static MIG configuration or the device plugin if you depend on GPU sharing today.

The attributes it publishes are what make claims expressive. For a full GPU you get productName, architecture, driverVersion, cudaComputeCapability, uuid, PCIe and NUMA locality, and a memory capacity (driver docs). This is the selector the driver documents for "more than 40 GiB of GPU memory":

TEXT
device.capacity['gpu.nvidia.com'].memory.isGreaterThan(quantity("40Gi"))

This is the piece AKS now manages for you. Everywhere else, someone on your team owns the Helm release, its upgrades and its compatibility with the node image's NVIDIA kernel driver.

How do I run DRA for GPUs on EKS, GKE or a self-managed cluster?

You install the same NVIDIA DRA driver, keep the device plugin off on the DRA nodes, and write the same ResourceClaims. What differs per cloud is who installs the driver, which node images carry the host NVIDIA driver, and whether the autoscaler understands claims.

Amazon EKS

AWS recommends the DRA driver for new deployments on Kubernetes 1.34 and later and supports it on EKS Auto Mode, Karpenter, managed node groups and self-managed nodes (Amazon EKS docs):

  • EKS Auto Mode on 1.36+ includes the NVIDIA DRA driver in the node runtime. You don't install it, but you create the gpu.nvidia.com DeviceClass yourself.
  • Karpenter, managed node groups and self-managed nodes need a Helm install. The EKS-optimized AL2023 NVIDIA and Bottlerocket AMIs already carry the host driver, CUDA user-mode driver and container toolkit.
  • Karpenter 1.15 supports DRA with both static and dynamic capacity provisioning. Dynamic provisioning requires Karpenter feature gates.
  • Bottlerocket enables the device plugin by default. Set settings.kubelet-device-plugins.nvidia.enabled = false (Bottlerocket 1.63.0+) before you use DRA.
  • g7e instances are not supported with DRA and dynamic provisioning, because neither Auto Mode nor Karpenter has DRA device metadata for them.

The install AWS documents:

BASH
helm install dra-driver-nvidia-gpu \
  oci://registry.k8s.io/dra-driver-nvidia/charts/dra-driver-nvidia-gpu \
  --version 0.4.1 \
  --create-namespace \
  --namespace nvidia \
  --set resources.computeDomains.enabled=false \
  --set gpuResourcesEnabledOverride=true

The AWS page still pins 0.4.1. Check the release list and test the newer chart in staging before you bump it. If you still have EKS clusters on 1.34, note that standard support for that version ends on December 2, 2026 (EKS version calendar), so a DRA rollout is a good reason to upgrade first.

Google Kubernetes Engine

GKE supports DRA for GPUs on Standard clusters running 1.35 or later (GKE docs). You create the GPU node pool with gpu-driver-version=disabled in the --accelerator flag, add the node labels gke-no-default-nvidia-gpu-device-plugin=true and nvidia.com/gpu.present=true, and install the NVIDIA DRA driver with Helm. For autoscaling, add the cloud.google.com/gke-nvidia-gpu-dra-driver=true label.

Google is explicit about the boundaries (GKE DRA overview):

  • DRA is available only in Standard mode, and only for GPUs.
  • Time-sharing GPUs, multi-instance GPUs and MPS can't be used with DRA on GKE.
  • The managed DCGM metrics package for Cloud Monitoring is not available, and "the GPU driver for DRA is owned by NVIDIA, not by GKE".
  • With third-party DRA drivers, the cluster autoscaler needs at least one node in the pool and "might not work correctly".

Self-managed Kubernetes (kubeadm, k3s, on-premise, Scaleway Kapsule)

On a cluster you run yourself, DRA works on any Kubernetes 1.34+ control plane, since the API is GA and on by default. You need three things on each GPU node: the host NVIDIA driver and container toolkit (the NVIDIA GPU Operator can install these), no device plugin on the same node, and the DRA driver from the same Helm chart. The work is the same as EKS without the AMI help. The trade-off is that nobody tests your node image, kernel and driver combination except you.

Side by side

AKS managed DRAEKSGKESelf-managed
StatusPublic previewSupported (AWS recommends for 1.34+)Supported on StandardUpstream GA
Minimum Kubernetes1.351.34 (Auto Mode: 1.36)1.351.34
Who installs and upgrades the DRA driverAKSAuto Mode: AWS. Otherwise you (Helm)You (Helm)You (Helm)
Host NVIDIA driverAKS managed GPU poolEKS AL2023 NVIDIA or Bottlerocket AMIYou disable GKE's install; NVIDIA-ownedYou or GPU Operator
Autoscaling with DRANot supported in previewKarpenter 1.15 (dynamic needs gates); Auto ModeCluster autoscaler with caveatsDepends on your autoscaler
GPU sharing with DRACheck per configurationStatic recommended; dynamic is alphaNot availableDriver alpha gates
Migration from device pluginNew pool, then move workloadsNew pool or node groupNew node poolNew nodes

Today the most mature autoscaling story for DRA GPUs is on AWS, and AKS managed DRA trades autoscaling away for managed drivers during the preview. If your inference traffic is spiky, that matters more than who maintains the Helm chart.

GPU workloads in your own cloud account, without a platform team.
Qovery runs GPU node pools on clusters it manages in your own AWS, GCP, Azure or Scaleway account, or connects to the Kubernetes cluster you already run. Start deploying in under 10 minutes.

How do I keep GPU scheduling portable across AKS, EKS, GKE and my own clusters?

Write your workloads against DRA objects only, give the DeviceClass the same name on every cluster, and push everything cloud-specific down into the node pool layer. Done that way, moving a GPU service from AKS to EKS or to a Scaleway or on-premise cluster changes only the node pool definition.

Here is the layout I recommend to customers:

  1. One DeviceClass name across clusters. The NVIDIA Helm chart creates gpu.nvidia.com with the selector device.driver == 'gpu.nvidia.com' && device.attributes['gpu.nvidia.com'].type == 'gpu'. On EKS Auto Mode you create that same object yourself. The AKS docs use aks-dra-gpu only to avoid clashing with an existing class; you can create gpu.nvidia.com with the identical selector on AKS too (Microsoft Learn).
  2. Put ResourceClaimTemplates in the application chart instead of raw counts, one claim template per GPU profile your services need.
  3. Select on attributes the NVIDIA driver publishes everywhere. Use productName or memory from the NVIDIA driver, not cloud labels like kubernetes.azure.com/agentpool or karpenter.sh/nodepool.
  4. Keep cloud specifics in the infrastructure layer. Node pool flags, taints, Karpenter NodePools and GKE labels sit in Terraform or your platform config, next to the cluster.

A claim template that runs unchanged on all four:

YAML
apiVersion: resource.k8s.io/v1
kind: ResourceClaimTemplate
metadata:
  name: gpu-40gi
spec:
  spec:
    devices:
      requests:
      - name: gpu
        exactly:
          deviceClassName: gpu.nvidia.com
          count: 1
          selectors:
          - cel:
              expression: device.capacity['gpu.nvidia.com'].memory.isGreaterThan(quantity("40Gi"))
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: inference
spec:
  replicas: 2
  selector:
    matchLabels: { app: inference }
  template:
    metadata:
      labels: { app: inference }
    spec:
      resourceClaims:
      - name: gpu
        resourceClaimTemplateName: gpu-40gi
      containers:
      - name: server
        image: your-registry/inference:1.0
        resources:
          claims:
          - name: gpu
      tolerations:
      - key: nvidia.com/gpu
        operator: Exists
        effect: NoSchedule

The toleration is the one piece that varies with how each pool is tainted. AKS GPU pools may carry sku=gpu:NoSchedule, so add that toleration if your AKS pool has it.

There is also a shortcut for teams that can't rewrite every chart. With extended resource mapping (Stable in 1.37), a DeviceClass can declare extendedResourceName: nvidia.com/gpu, and the scheduler then serves plain nvidia.com/gpu requests through the DRA driver. AWS documents that the NVIDIA chart sets this on 1.34+ and warns that it "changes how every GPU Pod in the cluster is treated", and that Karpenter doesn't honor it for dynamic provisioning (Amazon EKS docs, KEP-5004). I treat it as a migration bridge on 1.37 clusters, because you lose the attribute selection that made DRA worth it.

If several teams share those GPUs, DRA decides which device a Pod gets, and something like Kueue decides whose Pod goes first. That second half is covered in how to share GPUs fairly across teams with Kueue.

Should I move my GPU workloads to DRA now or stay on the device plugin?

Move new GPU node pools to DRA when you are on Kubernetes 1.34+ (1.35+ on AKS and GKE) and you need what counts can't express: mixed GPU models in one cluster, memory-based placement, multi-node NVLink, or per-GPU fencing on 1.37. Stay on the device plugin for production pools that depend on autoscaling on AKS or GKE, or on MIG and time-slicing.

GPU failures are frequent enough to justify the move for training clusters. During a 54-day snapshot of Llama 3 405B pre-training on up to 16K H100 GPUs, Meta recorded 419 unexpected interruptions, and GPU issues caused 58.7% of them (Meta, "The Llama 3 Herd of Models"). Per-device fencing turns each of those from a full-node drain into one fenced GPU.

Your situationMy recommendation
Production inference on AKS with spiky trafficStay on the device plugin until managed DRA supports autoscaling and leaves preview
New training cluster on EKS 1.36+ with H100 or GB200DRA with Karpenter static capacity first, then dynamic provisioning once tested
One GPU model, steady load, one teamDevice plugin is fine; revisit when you add a second GPU type
Mixed A100 and H100 fleet, several teamsDRA plus Kueue, with a prioritized list for fallback
Heavy MIG or time-slicing to cut costDevice plugin or static MIG with DRA; dynamic MIG is still alpha
Multi-cloud GPU footprint (Azure plus AWS or Scaleway)DRA on every cloud with one DeviceClass name and shared claim templates

For context on the wider inference stack (model servers, routing, autoscaling on queue depth), see what production AI inference on Kubernetes actually requires and running several open-weight models on one GPU cluster.

What does Qovery do for GPU scheduling, and what doesn't it do?

Qovery runs GPU workloads on Kubernetes in your own cloud account and schedules them through the NVIDIA device plugin. It does not configure DRA today, and I'd rather you read that here than find out during a proof of concept.

What Qovery does:

  • GPU node pools on Qovery-managed clusters in your AWS, GCP, Azure or Scaleway account. On AWS this runs through Karpenter: you enable GPU nodes in the cluster settings, pick instance types, mix On-Demand and Spot, and Qovery installs the NVIDIA device plugin (Deploying AI apps with GPUs on AWS EKS and Karpenter).
  • A GPU count per service. In the service settings you set how many GPUs a container needs, and Qovery renders it as an nvidia.com/gpu request and limit.
  • The operational layer around the GPUs: git-push deployments, a preview environment per pull request, environment auto-stop so idle GPU nodes don't bill all weekend, per-environment RBAC, audit logs and managed cluster upgrades.
  • Any existing cluster. You can connect an EKS, GKE, AKS, Kapsule, k3s or on-premise cluster you already run (Kubernetes 1.31+) and deploy to it.

What Qovery does not do today:

  • It doesn't install or upgrade the NVIDIA DRA driver, create DeviceClasses, or turn a service's GPU setting into a ResourceClaim.
  • Qovery-managed EKS currently runs Kubernetes up to 1.35, which has core DRA but not extended resource mapping (Beta from 1.36) or Stable device taints (1.37).

If you want DRA with Qovery now, the practical path is your own cluster. Install the NVIDIA DRA driver chart through Qovery as a Helm service, keep your claim templates and Deployments in a Helm chart deployed the same way, and you keep Qovery's environments, previews, RBAC and audit trail on top. That keeps the DRA pieces in standard Helm charts you can move to any cluster. I'd validate the DRA node pool and the driver upgrade path in a cloned environment first, which Qovery's environment cloning makes cheap.

If you are on AKS specifically and looking at its 1.37 LTS timeline, Romaric's note on the AKS LTS upgrade covers the dates.

How do I set this up with Qovery from Claude Code or Cursor?

Install the Qovery Agent Skills, optionally add the MCP Server, then ask your agent in plain language. These are the only commands you need:

BASH|1. Agent Skills, globally (Claude Code, Cursor, Codex, OpenCode, Gemini CLI...)
curl -fsSL https://skill.qovery.com/install.sh | bash

# 2. Or scoped to the current project
curl -fsSL https://skill.qovery.com/install.sh | bash -s -- --project

# 3. MCP Server in Claude Code over OAuth, read-only by default
claude mcp add --transport http qovery https://mcp.qovery.com/mcp --callback-port 4242

# 4. Write access, only when you explicitly want it (also enable it in the Qovery Console)
claude mcp add --transport http qovery "https://mcp.qovery.com/mcp?read_write=true" --callback-port 4242

The first two install skills such as qovery-onboard and qovery-deploy, which do the deploying; the MCP Server reads and operates what already exists, and the OAuth step asks you to approve access. A useful first prompt: "connect my existing EKS cluster to Qovery and deploy the NVIDIA DRA driver Helm chart as a Helm service in a staging environment." The agent asks you to approve each step. The walkthrough is in the AI agent quickstart and on the Claude Code integration page.

Frequently asked questions
What did AKS announce about Dynamic Resource Allocation for GPU node pools?

AKS added managed DRA for NVIDIA GPU node pools as a public preview, documented on November 7, 2026. You create a node pool with --enable-managed-gpu=true --gpu-driver-mode DRA on Kubernetes 1.35 or later, and AKS installs and maintains the NVIDIA DRA driver. Cluster autoscaler and node auto-provisioning are not supported on those pools during the preview.

How do I get the same GPU scheduling as AKS managed DRA without Azure lock-in?

Install the open-source NVIDIA DRA driver (kubernetes-sigs/dra-driver-nvidia-gpu) on a dedicated GPU node pool on EKS, GKE or your own Kubernetes 1.34+ cluster, with the device plugin disabled on those nodes. Create the same gpu.nvidia.com DeviceClass everywhere and request GPUs only through ResourceClaimTemplates. Your application manifests then run unchanged on any of those clusters.

Is Kubernetes Dynamic Resource Allocation generally available?

Yes. The core resource.k8s.io/v1 API (DeviceClass, ResourceClaim, ResourceClaimTemplate, ResourceSlice) became GA in Kubernetes 1.34. Prioritized lists and admin access went Stable in 1.36, and extended resource mapping and device taints went Stable in 1.37. Partitionable devices and consumable capacity are still beta.

Does EKS support DRA for NVIDIA GPUs?

Yes. AWS recommends the NVIDIA DRA driver for new deployments on Kubernetes 1.34+ and supports it on EKS Auto Mode (1.36+, driver included in the node runtime), Karpenter, managed node groups and self-managed nodes. Outside Auto Mode you install the driver with Helm, and Karpenter 1.15 handles DRA with static capacity and, behind feature gates, dynamic provisioning.

Does Qovery configure DRA for GPU workloads?

No, not today. Qovery provides GPU node pools on the clusters it manages in your own cloud account and lets you set a GPU count per service, which it schedules through the NVIDIA device plugin. On a cluster you connect to Qovery, you can deploy the NVIDIA DRA driver and claim-based workloads as Helm services and keep Qovery's environments, preview environments, RBAC and audit logs on top.

Guillaume Da Silva
About the author
Guillaume Da Silva

Guillaume is a Staff Solutions Architect at Qovery. He helps customers troubleshoot production infrastructure and writes about Kubernetes operations, AI agents, and reliable cloud platforms.

Next step

GPU workloads in your own cloud account, without a platform team.

Qovery runs GPU node pools on clusters it manages in your own AWS, GCP, Azure or Scaleway account, or connects to the Kubernetes cluster you already run. Start deploying in under 10 minutes.