EKS Auto Mode and Karpenter Now Support GPU DRA: The NodePool YAML You Still Write, and When You Can Skip It
On November 9, 2026, AWS added Dynamic Resource Allocation for NVIDIA GPUs and EFA to EKS Auto Mode (Kubernetes 1.36+) and Karpenter (1.15+). Here is what changes, the YAML each path still asks you to write, the gaps that remain, and where Qovery-managed EKS stands today.
AWS announced Dynamic Resource Allocation (DRA) for NVIDIA GPUs and EFA devices on EKS Auto Mode and Karpenter on November 9, 2026. Auto Mode ships the NVIDIA DRA driver and the EFA DRA driver (DRANET) in its node runtime and needs Kubernetes 1.36 or later. Karpenter scales nodes from pending ResourceClaims starting with version 1.15, behind an alpha settings.enableDRA flag (AWS What's New, Amazon EKS docs).
Auto Mode removes the driver work, and the YAML stays. You still write a GPU NodePool, a gpu.nvidia.com DeviceClass (Auto Mode does not create it), a ResourceClaimTemplate per GPU profile, and the claim plus toleration in every workload. Static NodePools need device manager labels on top.
Self-managed Karpenter asks for more. You install the NVIDIA DRA driver with Helm, turn on the DRA gates in the Karpenter chart, write an EC2NodeClass and a tainted GPU NodePool, and keep DRA nodes and device plugin nodes apart with labels yourself. Auto Mode enforces that separation for you.
Several GPU features still sit outside DRA on EKS. No g7e on the EKS docs' support list, no MIG or time-slicing through DRA on Auto Mode, no dynamic provisioning for MIG or multi-node NVLink ComputeDomains on Karpenter, and plain nvidia.com/gpu requests are not treated as DRA requests.
Qovery-managed EKS clusters cannot use this yet. They run Kubernetes up to 1.35 (Auto Mode DRA needs 1.36), Qovery's Karpenter release predates 1.15, and Qovery schedules GPUs through the NVIDIA device plugin. Qovery today offers the no-YAML path, with GPU node pools on Karpenter and a GPU count per service. For DRA now, connect your own EKS 1.36+ cluster to Qovery and deploy the claims as Helm services.
The first question I get about this announcement is some version of "can we stop maintaining our Karpenter GPU NodePools now?" The answer is no. AWS moved a lot of work from your team to its own side and left a smaller, different pile of YAML on yours.
I'm a Staff Solutions Architect at Qovery and I spend most of my week on EKS clusters with GPU nodes in customers' own AWS accounts. Yesterday we covered the Azure version of this story in AKS managed DRA for GPU node pools. This page stays on AWS: what changed, what Auto Mode writes for you and what it doesn't, what self-managed Karpenter still asks of you, and where Qovery-managed EKS stands.
What did AWS announce for GPU Dynamic Resource Allocation on EKS?
On November 9, 2026, AWS made Dynamic Resource Allocation available for NVIDIA GPUs and Elastic Fabric Adapter (EFA) network devices when the nodes come from EKS Auto Mode or Karpenter. Workloads describe the devices they need in a ResourceClaim, and Auto Mode or Karpenter launches an EC2 instance whose devices satisfy that claim (AWS What's New).
The announcement covers four things:
Claims by attribute. A ResourceClaim or ResourceClaimTemplate selects GPUs and EFA devices by model, architecture or memory.
Topology alignment. For distributed training and inference you can ask for a GPU and an EFA interface on the same PCIe root.
Oversubscription protection on Auto Mode. Auto Mode prevents a DRA driver and a device plugin from managing the same device type on one node.
Scale from zero. Karpenter evaluates pending claims against device metadata it ships for supported instance types, so no GPU node has to exist before the Pod.
It is available in every AWS Region except GovCloud (US) and the China Regions. Karpenter support works on all Kubernetes versions that Karpenter supports, while the Karpenter docs list Kubernetes 1.34 as the floor for DRA (Karpenter docs). Auto Mode needs Kubernetes 1.36 or later.
The EKS docs now recommend DRA drivers over device plugins "for new deployments with Kubernetes versions 1.34 and later" (Amazon EKS docs). Device plugins "remain fully supported for all Kubernetes versions," so nothing forces you to move.
The core DRA API (resource.k8s.io/v1) has been GA since Kubernetes 1.34 (Kubernetes blog). AWS shipped the EKS plumbing around it, with drivers in the node runtime and an autoscaler that understands claims.
How is DRA on EKS Auto Mode different from DRA on self-managed Karpenter?
On Auto Mode, AWS runs the NVIDIA and EFA DRA drivers and decides per node whether DRA or the device plugin manages each device type. On self-managed Karpenter, you install and upgrade the drivers, enable alpha feature gates in Karpenter, and keep DRA and device plugin nodes apart yourself. Both read the same ResourceClaims.
EKS Auto Mode
Self-managed Karpenter (1.15+)
Managed node groups / self-managed nodes
Minimum Kubernetes for DRA
1.36
1.34 (Karpenter docs)
1.34 recommended (1.33 possible)
NVIDIA DRA driver
Built into the node runtime
You install it with Helm
You install it with Helm
EFA DRA driver (DRANET)
Built in
You install it
You install it
DeviceClass objects
You create them
Created by the driver's Helm chart
Created by the driver's Helm chart
Scale from zero on a pending claim
Yes
Yes, alpha, settings.enableDRA: true
No, the node group must exist
DRA and device plugin on the same node
Prevented by Auto Mode
Your job (labels, nodeSelectors)
Your job
GPU sharing through DRA (time-slicing, MIG)
Not available; share one ResourceClaim across Pods instead
Time-slicing via consumable capacity (alpha); MIG only with static capacity
Two details from the docs affect capacity planning.
First, on Auto Mode a node's role is permanent. A node is "either a DRA node or a device plugin node per device type for its whole lifetime," and you migrate by replacing nodes. If your GPUs come from a Capacity Reservation or a Capacity Block, AWS points out that this means scaling down before scaling up.
Second, on Karpenter the dynamic path is alpha and off by default. AWS spells it out: "This support is Alpha and off by default." Static NodePools work with DRA on any Karpenter version that supports them, because Karpenter never simulates the claim there. The nodes exist first and the driver publishes ResourceSlices from them.
What YAML do you still write for GPU DRA on EKS Auto Mode?
On Auto Mode you write four things: a GPU NodePool, the gpu.nvidia.com DeviceClass, one ResourceClaimTemplate per GPU profile, and the claim reference plus toleration in each workload. You don't install, configure or upgrade any driver or device plugin.
Auto Mode does not create the DeviceClass. A Helm-installed driver creates it for you, but Auto Mode runs its drivers from the node runtime, so "you create the DeviceClass objects yourself." A claim pointing at a class that doesn't exist "is never allocated, and the Pod stays in the Pending state" (Amazon EKS docs).
The NodePool in that example carries no device manager label. With dynamic provisioning, Auto Mode sees that the pending Pod claims a GPU through DRA, launches a node with the NVIDIA DRA driver enabled and the device plugin disabled, and labels it eks.amazonaws.com/device-manager-nvidia: dra. One NodePool can then serve both DRA Pods and nvidia.com/gpu Pods.
Static capacity is where you add YAML back. A static NodePool (spec.replicas) never evaluates pending Pods, so Auto Mode has nothing to infer the device manager from. A static pool without the labels uses the device plugin. For a Capacity Block of p5.48xlarge nodes running DRA, the AWS example sets both labels:
AWS also recommends a terminationGracePeriod well under 10 minutes on Capacity Block pools, because Auto Mode starts draining 10 minutes before EC2 terminates the instances (Amazon EKS docs).
For a team with two GPU profiles on Auto Mode, the count is one DeviceClass, one or two NodePools, two ResourceClaimTemplates, and a three-part patch on every GPU Deployment. That is less than before, because the driver DaemonSets, the Helm values and the upgrade testing are gone. It is still YAML your team owns and reviews.
GPU workloads in your own AWS account, without a platform team.
Qovery runs Karpenter-based EKS clusters in your own AWS account with GPU node pools and a GPU count per service, or connects to the EKS cluster you already run. Start deploying in under 10 minutes.
What YAML do you write for GPU DRA on self-managed Karpenter?
On self-managed Karpenter you write everything Auto Mode needs except the DeviceClass, plus the driver install, the Karpenter Helm values, an EC2NodeClass, and the labels that keep DRA nodes away from device plugin nodes. You also own the upgrade path for Karpenter and the NVIDIA DRA driver.
Upgrade to Karpenter 1.15 or later. Dynamic provisioning for DRA arrived in 1.15 with Karpenter's own device metadata for supported instance types.
Turn on the gates. Set settings.enableDRA: true in the Karpenter chart. It enables the DRANVIDIAGPU and DRAEFA AWS feature gates and sets ignoreDRARequests to false. If you run only the NVIDIA driver, enable settings.awsFeatureGates.draNVIDIAGPU alone, because enableDRA assumes both drivers run on your DRA nodes. Don't combine enableDRA with the individual gates or the chart fails to render.
Upgrade the release carefully. helm upgrade --reuse-values fails here because older charts default ignoreDRARequests to true. AWS says to use --reset-then-reuse-values, which needs Helm 3.14 or later.
Install the NVIDIA DRA driver from kubernetes-sigs/dra-driver-nvidia-gpu with Helm (GitHub). The chart creates the gpu.nvidia.com DeviceClass. It schedules onto nodes labeled nvidia.com/gpu.present=true, which the EKS-optimized AMIs handle; add the label to your NodePool if you use other AMIs.
Write an EC2NodeClass with amiSelectorTerms set to the al2023@latest alias, which resolves to the NVIDIA variant on GPU instances. Leave networkInterfaces unset if you use EFA, so Karpenter attaches an interface on every EFA-capable card.
Write the GPU NodePool with the nvidia.com/gpu:NoSchedule taint and instance families that have DRA metadata (for example g6, g6e, p5, p5en, p6-b200).
Separate DRA nodes from device plugin nodes. Karpenter's device metadata applies to every NodePool that allows a supported instance type, so add a label on the DRA NodePool, a nodeSelector on the driver DaemonSets, and a nodeSelector on your DRA workloads. AWS's warning is blunt: running both on one node "can cause silent oversubscription of the underlying hardware devices."
Then the same ResourceClaimTemplates and workload patches as on Auto Mode. If you want GPU sharing, Karpenter adds an optional EC2NodeClass annotation, karpenter.k8s.aws/nvidia-consumable-capacity, for system-mediated time-slicing on Kubernetes 1.36+, also alpha.
YAML or config you own
EKS Auto Mode
Self-managed Karpenter
NVIDIA DRA driver install and upgrades
No
Yes (Helm)
EFA DRA driver (DRANET)
No
Yes, if you use EFA
Karpenter install, upgrades, feature gates
No
Yes
EC2NodeClass / NodeClass
Optional (default NodeClass works)
Yes
GPU NodePool
Yes
Yes
DeviceClass gpu.nvidia.com
Yes
No, the driver chart creates it
ResourceClaimTemplate per GPU profile
Yes
Yes
Claim + toleration in each workload
Yes
Yes
Labels and nodeSelectors to isolate DRA nodes
Only for static pools
Yes, always
If you already run self-managed Karpenter with a working GPU setup, the delta is real but bounded: a Karpenter upgrade, a driver chart, and a node-isolation scheme. If you don't run Karpenter yet, Auto Mode is the shorter road to claims, as long as your cluster can be on 1.36.
Which GPU features does DRA on EKS still not cover?
DRA on EKS covers whole NVIDIA GPUs and EFA interfaces on the instance families AWS ships metadata for. MIG, time-slicing, multi-node NVLink, some instance families and plain nvidia.com/gpu requests still fall back to static capacity or the device plugin. Check this list against your fleet before you plan a migration.
Gap
EKS Auto Mode
Self-managed Karpenter
Where to run it instead
g7e instances
Not supported with DRA
Not supported per the EKS docs
Device plugin
MIG through DRA
Not available
No dynamic provisioning (metadata covers whole GPUs only)
Instance coverage keeps moving. The Karpenter v1.15.2 release notes add "NVIDIA GPU DRA metadata for g7 and g7e" and drop NVIDIA DRA metadata for the fractional-GPU g6f and gr6f types (Karpenter v1.15.2), while the EKS user guide still lists g7e as unsupported. Instance coverage tracks Karpenter releases, so a new GPU family needs a new Karpenter version before claims can scale it from zero. Test the exact family and Karpenter version together before you trust it in production.
The fencing story from Kubernetes 1.37 also depends on your version. DRA device taints let you fence one bad GPU instead of draining the whole node, and they went Stable in 1.37. Romaric covered the dollar math in Kubernetes 1.37 on EKS: DRA device taints, Metrics API GA and upgrade order. Training clusters feel this most. During a 54-day snapshot of Llama 3 405B pre-training, Meta logged 419 unexpected interruptions, and GPU issues caused 58.7% of them (Meta, "The Llama 3 Herd of Models").
Should you move GPU workloads to Auto Mode DRA, Karpenter DRA, or stay on the device plugin?
Move to DRA when you need what an integer count can't express: GPU model or memory selection inside one NodePool, GPU and EFA on the same PCIe root, or per-GPU fencing on 1.37. Stay on the device plugin when you depend on MIG, time-slicing, g7e, or a version below 1.36 on Auto Mode. Pick Auto Mode over Karpenter when nobody on the team wants to own driver and autoscaler upgrades.
Your situation
My recommendation
New inference cluster, one or two GPU models, no platform engineer
Auto Mode on 1.36+ with DRA, one DeviceClass, claim templates per model
Existing self-managed Karpenter with tuned GPU NodePools
Stay on the device plugin until you need claims, then upgrade Karpenter to 1.15+ and add a separate DRA NodePool
Distributed training with EFA and Capacity Blocks
Static NodePool with device manager labels (Auto Mode) or static Karpenter capacity
GB200 / multi-node NVLink
Karpenter static capacity or managed node groups; Auto Mode doesn't support ComputeDomains
Heavy MIG or time-slicing to cut cost
Device plugin, or Karpenter alpha consumable capacity in staging only
Cluster pinned below 1.36
Karpenter DRA if you're on 1.34+, otherwise device plugin and plan the upgrade
Auto Mode charges a management fee per instance on top of the EC2 price (Amazon EKS pricing). On July 1, 2026, AWS cut that fee by 35% on G-series instances and by 60% on P-series and Trainium (AWS What's New). Self-managed Karpenter has no AWS fee, but your team pays in hours: every Karpenter, driver and AMI upgrade needs testing against GPU nodes. For a small GPU fleet the fee is usually cheaper than the engineer-hours. For a large always-on P-series fleet, run the numbers on your actual instance mix in the AWS Pricing Calculator.
Watch the version clock too. EKS standard support for 1.34 ends on December 2, 2026, and 1.35 ends on March 27, 2027 (EKS version calendar). Auto Mode DRA needs 1.36, which EKS released on June 2, 2026, so many clusters face a version upgrade before they can try it.
Can Qovery-managed EKS clusters use GPU DRA today?
No. Clusters that Qovery creates and manages in your AWS account cannot use DRA through Qovery today, and I'd rather you read that here than find out in a proof of concept. Three reasons, in order of how hard they are to fix:
Kubernetes version. Qovery-managed EKS currently runs Kubernetes up to 1.35. EKS Auto Mode DRA needs 1.36, and Qovery-managed clusters run Karpenter, not Auto Mode, in any case.
Karpenter version and gates. Karpenter DRA on 1.34+ would be possible by version, but dynamic provisioning needs Karpenter 1.15 with alpha gates enabled. The Karpenter release Qovery ships today predates 1.15 and doesn't enable those gates.
Device plugin model. Qovery installs and configures the NVIDIA device plugin on GPU node pools, and a service's GPU setting becomes an nvidia.com/gpu request. Qovery doesn't install the NVIDIA DRA driver, create DeviceClasses, or turn a GPU setting into a ResourceClaim.
What Qovery-managed EKS does today is the "no NodePool YAML" path, with the device plugin underneath. You enable GPU node pools in the cluster settings, pick instance types, mix On-Demand and Spot, and cap the total GPUs the cluster can use. In each service you set how many GPUs it needs, and Qovery handles the Karpenter provisioning, scheduling and placement (GPU workloads on EKS with Qovery, Deploying AI apps with GPUs on AWS EKS and Karpenter). On top you get 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.
Qovery-managed EKS today
Your own EKS 1.36+ connected to Qovery
EKS Auto Mode on its own
GPU scheduling model
NVIDIA device plugin
DRA (or device plugin)
DRA (or device plugin)
NodePool YAML you write
None
Depends on Auto Mode or Karpenter
GPU NodePool, DeviceClass
Per-service GPU setting
Yes, GPU count
Claims in your Helm chart
Claims in your manifests
Who upgrades Kubernetes and Karpenter
Qovery
You (or AWS with Auto Mode)
AWS for nodes, you for the control plane version
Preview environments, RBAC, audit logs
Yes
Yes
No
Select GPU by model or memory
Instance types per node pool
CEL selectors on claims
CEL selectors on claims
If you need DRA now, the practical route is your own cluster. Create an EKS cluster on 1.36+ (Auto Mode or Karpenter 1.15+), connect it to Qovery (any Kubernetes 1.31+ cluster works), and deploy the DeviceClass, claim templates and workloads as Helm services. You keep Qovery's environments, preview environments, RBAC and audit trail, and the DRA objects stay in standard Helm charts that also run on AKS, GKE or Scaleway. If you go multi-cloud, use one DeviceClass name everywhere, as I described in the AKS DRA article.
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 its OAuth step asks you to approve access. Two useful first prompts: "enable GPU node pools on my Qovery-managed EKS cluster and give the inference service one GPU" for the device plugin path, or "connect my existing EKS 1.36 cluster to Qovery and deploy my DRA claim templates as a Helm service in a staging environment" for DRA. 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 AWS add for GPU Dynamic Resource Allocation on EKS Auto Mode and Karpenter?
On November 9, 2026, AWS added DRA for NVIDIA GPUs and EFA devices on EKS Auto Mode and Karpenter. Auto Mode includes the NVIDIA DRA driver and the EFA DRA driver (DRANET) in its node runtime on Kubernetes 1.36+, and Karpenter 1.15+ can launch nodes for pending ResourceClaims behind an alpha settings.enableDRA flag. It is available in all AWS Regions except GovCloud (US) and China.
Do I still have to write Karpenter NodePool YAML for GPUs with EKS Auto Mode and DRA?
Yes. Auto Mode removes driver installation and upgrades, but you still write a GPU NodePool, create the gpu.nvidia.com DeviceClass yourself, add a ResourceClaimTemplate per GPU profile, and put the claim and the nvidia.com/gpu toleration in each workload. Static NodePools also need the eks.amazonaws.com/device-manager-nvidia: dra label. The only way to skip NodePool YAML is a platform that generates it for you, such as Qovery's GPU node pools, which use the device plugin today.
What is the minimum Kubernetes version for DRA on EKS Auto Mode and on Karpenter?
EKS Auto Mode supports DRA for NVIDIA GPUs and EFA on Kubernetes 1.36 and later. Karpenter's DRA docs list Kubernetes 1.34 as the minimum and dynamic provisioning requires Karpenter 1.15, while GPU time-slicing through consumable capacity requires Kubernetes 1.36. EKS standard support for 1.34 ends on December 2, 2026.
Can I use MIG or time-slicing with DRA on EKS?
Not on Auto Mode, where time-slicing and MIG through the NVIDIA DRA driver are unavailable because they are alpha upstream; you can share one GPU by pointing several Pods at the same ResourceClaim. On Karpenter, time-slicing works through alpha consumable capacity on 1.36+, and MIG claims need static capacity because Karpenter's device metadata describes whole GPUs only. Otherwise use the device plugin.
Can Qovery-managed EKS clusters use GPU DRA?
Not today. Qovery-managed EKS runs Kubernetes up to 1.35, below the 1.36 Auto Mode requires, its Karpenter release predates 1.15, and Qovery schedules GPUs through the NVIDIA device plugin with a GPU count per service. To use DRA now, connect your own EKS 1.36+ cluster to Qovery and deploy the DeviceClass, claim templates and workloads as Helm services.
Should I choose EKS Auto Mode or self-managed Karpenter for DRA GPU workloads?
Choose Auto Mode if you're on 1.36+ and want AWS to run the DRA drivers and keep DRA and device plugin nodes apart; you pay a per-instance management fee, cut by 35% on G-series and 60% on P-series in July 2026. Choose self-managed Karpenter if you need ComputeDomains on static capacity, alpha time-slicing, or no Auto Mode fee, and you have someone to own Karpenter and driver upgrades.
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 AWS account, without a platform team.
Qovery runs Karpenter-based EKS clusters in your own AWS account with GPU node pools and a GPU count per service, or connects to the EKS cluster you already run. Start deploying in under 10 minutes.