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

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.

Guillaume Da Silva
Staff Solutions Architect
NOV 17, 2026 · 19 MIN
EKS Auto Mode and Karpenter Now Support GPU DRA: The NodePool YAML You Still Write, and When You Can Skip It

Key points:

  • 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.

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

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 ModeSelf-managed Karpenter (1.15+)Managed node groups / self-managed nodes
Minimum Kubernetes for DRA1.361.34 (Karpenter docs)1.34 recommended (1.33 possible)
NVIDIA DRA driverBuilt into the node runtimeYou install it with HelmYou install it with Helm
EFA DRA driver (DRANET)Built inYou install itYou install it
DeviceClass objectsYou create themCreated by the driver's Helm chartCreated by the driver's Helm chart
Scale from zero on a pending claimYesYes, alpha, settings.enableDRA: trueNo, the node group must exist
DRA and device plugin on the same nodePrevented by Auto ModeYour job (labels, nodeSelectors)Your job
GPU sharing through DRA (time-slicing, MIG)Not available; share one ResourceClaim across Pods insteadTime-slicing via consumable capacity (alpha); MIG only with static capacityDriver alpha gates
Multi-node NVLink (ComputeDomains)Not supportedStatic capacity onlySupported
Extra costAuto Mode fee per instance, on top of EC2None from AWSNone from AWS

Sources: Amazon EKS device management docs and Karpenter DRA docs.

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).

Here is the minimum set, adapted from the AWS walkthrough (Deploy an accelerated workload with DRA):

YAML|1. The DeviceClass, same name and selector as the upstream NVIDIA chart
apiVersion: resource.k8s.io/v1
kind: DeviceClass
metadata:
  name: gpu.nvidia.com
spec:
  selectors:
  - cel:
      expression: "device.driver == 'gpu.nvidia.com' && device.attributes['gpu.nvidia.com'].type == 'gpu'"
---
# 2. A GPU NodePool on the Auto Mode default NodeClass
apiVersion: karpenter.sh/v1
kind: NodePool
metadata:
  name: gpu-dra
spec:
  disruption:
    consolidationPolicy: WhenEmpty
    consolidateAfter: 1h
  template:
    spec:
      nodeClassRef:
        group: eks.amazonaws.com
        kind: NodeClass
        name: default
      requirements:
      - key: karpenter.sh/capacity-type
        operator: In
        values: ["on-demand"]
      - key: eks.amazonaws.com/instance-family
        operator: In
        values: ["g6", "g6e"]
      taints:
      - key: nvidia.com/gpu
        effect: NoSchedule
---
# 3. One claim template per GPU profile
apiVersion: resource.k8s.io/v1
kind: ResourceClaimTemplate
metadata:
  name: single-gpu
spec:
  spec:
    devices:
      requests:
      - name: gpu
        exactly:
          deviceClassName: gpu.nvidia.com
          count: 1

Then every workload carries the same three additions:

YAML
spec:
  resourceClaims:
  - name: gpu
    resourceClaimTemplateName: single-gpu
  containers:
  - name: server
    image: your-registry/inference:1.0
    resources:
      claims:
      - name: gpu
  tolerations:
  - key: nvidia.com/gpu
    operator: Exists
    effect: NoSchedule

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:

YAML
template:
  metadata:
    labels:
      eks.amazonaws.com/device-manager-nvidia: dra
      eks.amazonaws.com/device-manager-efa: dra

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.

Step by step, from the Karpenter DRA docs and the EKS docs:

  1. 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.
  2. 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.
  3. 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.
  4. 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.
  5. 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.
  6. 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).
  7. 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 ownEKS Auto ModeSelf-managed Karpenter
NVIDIA DRA driver install and upgradesNoYes (Helm)
EFA DRA driver (DRANET)NoYes, if you use EFA
Karpenter install, upgrades, feature gatesNoYes
EC2NodeClass / NodeClassOptional (default NodeClass works)Yes
GPU NodePoolYesYes
DeviceClass gpu.nvidia.comYesNo, the driver chart creates it
ResourceClaimTemplate per GPU profileYesYes
Claim + toleration in each workloadYesYes
Labels and nodeSelectors to isolate DRA nodesOnly for static poolsYes, 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.

GapEKS Auto ModeSelf-managed KarpenterWhere to run it instead
g7e instancesNot supported with DRANot supported per the EKS docsDevice plugin
MIG through DRANot availableNo dynamic provisioning (metadata covers whole GPUs only)Static capacity, managed node groups
Time-slicing through DRANot availableAlpha, consumable capacity, Kubernetes 1.36+Device plugin time-slicing
ComputeDomains (multi-node NVLink, GB200)Not supportedStatic capacity onlyStatic pools, managed node groups
EFA-only instances without GPUs (hpc7a, c6in)Metadata "coming soon"Check your Karpenter releaseStatic capacity or EFA device plugin
nvidia.com/gpu extended resource requestsServed by device plugin nodes"Not treated as a DRA Pod"Rewrite as claims
Custom networkInterfaces + dynamic provisioning + GPU/EFA alignmentUndefined behavior, Pods stay PendingUndefined behavior, Pods stay PendingStatic capacity
Neuron (Trainium, Inferentia) via DRANot available, use the Neuron device pluginYou install the Neuron DRA driverDevice plugin on Auto Mode

Sources: Amazon EKS device management, EKS Auto Mode accelerated workloads.

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 situationMy recommendation
New inference cluster, one or two GPU models, no platform engineerAuto Mode on 1.36+ with DRA, one DeviceClass, claim templates per model
Existing self-managed Karpenter with tuned GPU NodePoolsStay 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 BlocksStatic NodePool with device manager labels (Auto Mode) or static Karpenter capacity
GB200 / multi-node NVLinkKarpenter static capacity or managed node groups; Auto Mode doesn't support ComputeDomains
Heavy MIG or time-slicing to cut costDevice plugin, or Karpenter alpha consumable capacity in staging only
Cluster pinned below 1.36Karpenter 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.

For a broader view of whether Auto Mode fits your team at all, see AWS EKS Auto Mode with Qovery: valuable or not? and the best alternatives to EKS Auto Mode.

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 todayYour own EKS 1.36+ connected to QoveryEKS Auto Mode on its own
GPU scheduling modelNVIDIA device pluginDRA (or device plugin)DRA (or device plugin)
NodePool YAML you writeNoneDepends on Auto Mode or KarpenterGPU NodePool, DeviceClass
Per-service GPU settingYes, GPU countClaims in your Helm chartClaims in your manifests
Who upgrades Kubernetes and KarpenterQoveryYou (or AWS with Auto Mode)AWS for nodes, you for the control plane version
Preview environments, RBAC, audit logsYesYesNo
Select GPU by model or memoryInstance types per node poolCEL selectors on claimsCEL 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.

If several teams share the GPUs, DRA decides which device a Pod gets and a queue decides whose Pod runs first. That second half is in how to share GPUs fairly across teams with Kueue.

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 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 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 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.