Why the NVIDIA GPU Operator fails to install, and how to fix it
nvidia-driver-daemonset pod: Error: failed to load kernel module nvidia: Device or resource busy
Also appears as
- gpu-feature-discovery CrashLoopBackOff
- Error: could not load NVIDIA driver: version mismatch with pre-installed driver
Short answer
GPU Operator installation problems almost always come from a preinstalled host driver conflicting with the Operator's own driver container, or from Node Feature Discovery never labeling GPU nodes so downstream components stay unscheduled. Check kubectl get pods -n gpu-operator first to see which subsystem is failing, then confirm whether the node has a preexisting driver and whether NFD applied the expected NVIDIA labels.
Affects: Kubernetes clusters installing the NVIDIA GPU Operator via Helm, most common on nodes with a preinstalled host driver
Diagnose the failing subsystem fast
- 1Run kubectl get pods -n gpu-operator to see which component (driver, toolkit, device plugin, NFD) is failing.
- 2If the driver daemonset shows 'Device or resource busy', check for a preinstalled driver with dpkg -l | grep nvidia-driver.
- 3Either remove the preinstalled driver or set driver.enabled=false in the Operator's Helm values.
- 4If nothing schedules onto the GPU node at all, check Node Feature Discovery labels with kubectl get nodes --show-labels.
- 5If the driver fails with a signature error, check mokutil --sb-state for Secure Boot before assuming a driver bug.
How to confirm this is your problem
- nvidia-driver-daemonset pods stuck in CrashLoopBackOff
- gpu-feature-discovery or device-plugin pods never start
- Helm install of gpu-operator completes but no node reports nvidia.com/gpu
- driver daemonset logs show 'Device or resource busy' or a signature error
Root causes and fixes
Preinstalled host driver conflicts with the Operator's own driver container
The GPU Operator expects to manage the NVIDIA driver itself inside a driver container and load the kernel module from there; if the node image already has a driver installed via apt or a cloud provider's base image, the kernel module is already loaded and owns the GPU, so the Operator's driver daemonset fails to load its own module because the device is busy, and the two installations conflict rather than coexist.
Fix: Either use a node image with no preinstalled NVIDIA driver and let the Operator manage it fully, or set driver.enabled=false in the Operator's Helm values so it uses the host's existing driver instead of trying to install its own.
helm show values nvidia/gpu-operator | grep -A3 driver: helm upgrade gpu-operator nvidia/gpu-operator -n gpu-operator --set driver.enabled=false
Node Feature Discovery not detecting or mislabeling GPU nodes
The Operator relies on Node Feature Discovery to label which nodes have NVIDIA PCI devices so it knows where to schedule driver and device plugin daemonsets; if NFD is not running, misconfigured, or excluded by a node's taints, GPU nodes never get labeled and the Operator's components never get scheduled onto them at all.
Fix: Confirm NFD worker pods are Running on every GPU node and check for the NVIDIA PCI presence label; reinstall or reconfigure NFD if labels are missing.
kubectl get pods -n gpu-operator -l app=nvidia-node-feature-discovery kubectl get nodes --show-labels | grep pci-10de
Container runtime not configured or mismatched (containerd vs Docker) for the Operator's toolkit container
The Operator's container-toolkit daemonset writes runtime configuration into containerd's or Docker's config file to register the nvidia runtime automatically; if the cluster uses a nonstandard containerd config path, a read-only filesystem, or a runtime the Operator does not recognize, that automatic registration silently fails and no container on the node can request a GPU even though the driver loaded fine.
Fix: Check the containerd config path the Operator expects matches your actual node image, and inspect the container-toolkit daemonset logs for explicit registration errors; override the config path via Helm values if your distribution uses a nonstandard location.
kubectl logs -n gpu-operator -l app=nvidia-container-toolkit-daemonset cat /etc/containerd/config.toml | grep nvidia
Secure Boot enabled without signed driver modules
When UEFI Secure Boot is enabled on a node, the kernel refuses to load any kernel module that is not cryptographically signed with a key enrolled in the machine owner key database, and the Operator's default driver container ships unsigned modules for many configurations, causing the driver daemonset to fail to load with a signature verification error.
Fix: Either disable Secure Boot on GPU nodes, or use the Operator's precompiled signed driver variant and enroll the appropriate MOK key as documented for your distribution.
mokutil --sb-state
Diagnostic commands
Check Operator pod status across the namespace
kubectl get pods -n gpu-operator
Any pod in CrashLoopBackOff or Init:Error points directly to which subsystem, driver, toolkit, device plugin, or NFD, is failing.
Read the driver daemonset logs
kubectl logs -n gpu-operator -l app=nvidia-driver-daemonset --tail=100
Device or resource busy means a conflicting preinstalled driver; signature verification failures point to Secure Boot.
Confirm NFD labeled the node
kubectl get node <gpu-node> --show-labels
Missing NVIDIA-related labels means NFD never detected the GPU hardware, so nothing downstream gets scheduled.
Check for a preinstalled driver conflicting with the Operator
lsmod | grep nvidia && dpkg -l | grep nvidia-driver
If a driver package is already installed outside the Operator's management, it needs to be removed or the Operator set to skip driver installation.
Stopping it from happening again
- Use a minimal node image with no preinstalled NVIDIA driver when planning to run the GPU Operator
- Decide upfront whether the Operator or the OS image owns the driver, and set driver.enabled accordingly, never both
- Verify Node Feature Discovery is healthy before troubleshooting any other Operator component
- Document Secure Boot state per node pool since it changes the required driver installation path
When this becomes an architecture problem
If Operator install problems keep recurring across a heterogeneous fleet of node images and driver versions, standardizing on a single golden GPU node image with a known driver ownership model is a platform decision worth making once, rather than resolving conflicts per node pool.
Frequently asked questions
Should I let the GPU Operator install the driver, or use the host's preinstalled driver?
For most clusters, let the Operator manage the driver fully by using a node image with no NVIDIA driver preinstalled, since this gives you centralized version control and upgrade management through Helm values. Only set driver.enabled=false and rely on a preinstalled host driver if your node image is managed by a process outside your control, such as a locked-down cloud provider image, where you cannot remove the existing driver.
What does 'Device or resource busy' mean in the driver daemonset logs?
It means the NVIDIA kernel module is already loaded on the node, almost always because a driver was preinstalled through the OS package manager or a base image, and the Operator's own driver container is trying to load a second, potentially different, copy of the module into a kernel slot that is already occupied. The fix is to remove the preinstalled driver or tell the Operator to skip driver management for that node pool.
Why do GPU Operator pods never even get scheduled onto a GPU node?
This usually points to Node Feature Discovery. The Operator's daemonsets use nodeSelectors tied to labels that NFD applies after detecting NVIDIA PCI hardware; if NFD is not running, is misconfigured, or the node has a taint NFD's pods do not tolerate, those labels never appear, and every downstream Operator component that depends on them stays unscheduled.
Does Secure Boot actually block the GPU Operator, or just slow it down?
It fully blocks the default driver installation path. With Secure Boot enabled, the kernel will refuse to load any unsigned kernel module, and the Operator's standard driver container includes modules that may not be signed for your specific configuration. You either need to disable Secure Boot on GPU nodes or explicitly use the Operator's signed driver option with a properly enrolled MOK key.
Size it properly next time
Free calculators that prevent this class of failure before you provision hardware.
Kubernetes Cluster Cost Calculator
Estimate the true monthly and annual cost of a Kubernetes cluster, including compute, control plane fees, managed service premiums, and utilization waste.
Free ToolOn-Prem AI Deployment Checklist
A 30-point pre-deployment checklist covering use cases, hardware, security, model operations, and rollout for self-hosted enterprise LLMs.
Free ToolGPU Sizing Calculator for LLM Inference
Work out how many GPUs you need to serve a given open-weight model to your user base, based on memory footprint and token throughput.
Related problems
Kubernetes GPU pod stuck in Pending
A GPU pod stays Pending when no node advertises the nvidia.com/gpu resource because the device plugin is down or missing, the pod requests more GPUs than any single node has, or a taint, toleration, or nodeSelector mismatch blocks placement on the GPU pool. Always start with kubectl describe pod, since the Events section states the exact blocking reason rather than leaving you to guess between these causes.
nvidia-container-cli errors when starting a GPU container
nvidia-container-cli initialization errors mean the host's NVIDIA kernel module failed to load or the driver's supported CUDA version does not meet the minimum your container image requires. Check nvidia-smi on the bare host first; if it fails there, fix the kernel module or driver before touching Docker. If the host is healthy, compare its CUDA support against your image's requirement and either upgrade the driver or use an older image tag.
GPU not visible inside a Docker container
Docker containers cannot see a host GPU unless the NVIDIA Container Toolkit is installed and the nvidia runtime is registered with the daemon, since containers are isolated from host devices by default. The fix is almost always to install nvidia-container-toolkit, run nvidia-ctk runtime configure, restart Docker, and launch with --gpus all. If nvidia-smi already fails on the host itself, the problem is the driver, not Docker.
NVIDIA driver installation fails on Ubuntu
The single most common reason NVIDIA driver installation fails on Ubuntu is Secure Boot rejecting the unsigned or self-signed kernel module at load time, since most machines now ship with Secure Boot enabled out of the box. The fix is enrolling the MOK key the installer generates, or disabling Secure Boot in the BIOS, then clearing any lingering nouveau or mixed-install conflicts before rebooting.
GuideOn-Prem GPU Cluster Design: Node Sizing, Networking, and Storage
Design an on-prem GPU cluster: node sizing for H100/H200/B200, InfiniBand vs RoCE networking, storage throughput, and rack power for enterprise AI workloads.
GuideOn-Prem LLM Deployment Architecture: Reference Guide
Reference architecture for on-prem LLM deployment: inference servers, GPU sizing, RAG pipelines, and security zones for regulated manufacturers.
Still stuck, or tired of fighting your own infrastructure?
Netray deploys and operates on-prem AI for regulated manufacturers and defense suppliers. We have debugged this stack in production, on air-gapped networks, at scale.