What Is nvke and How to Use It: NVIDIA's Open Source Bare Metal GPU Kubernetes Platform

Want to turn your own servers with GPUs into production grade Kubernetes, without the cost and lock in of public cloud? nvke is NVIDIA's bare metal GPU Kubernetes control plane, short for NVIDIA Kubernetes Engine. Running inside the NVIDIA DSX AI Factory ecosystem, it lets you deploy and manage GPU accelerated Kubernetes on your own hardware, covering everything from the control plane to node lifecycle, so you keep full ownership of the stack.

What Is nvke

nvke, short for NVIDIA Kubernetes Engine, is NVIDIA's bare metal GPU Kubernetes control plane, positioned as a Certified Kubernetes AI Platform. Running in the NVIDIA DSX AI Factory ecosystem, it lets enterprises deploy and manage GPU accelerated Kubernetes clusters on their own hardware, covering the control plane, tenant clusters, and node lifecycle. For another NVIDIA AI infrastructure project, see What Is auto-ontology and How to Use It: NVIDIA's Open Source Semantic Layer for AI Agents. Unlike simply spinning up GPU instances in the cloud, nvke gives the whole stack back to you, orchestrated by one control plane from power on to cluster ready, avoiding lock in to a single cloud vendor and keeping data on premises.

Tenant clusters are carved out of the same physical pool, so capacity can be reassigned between teams without buying new hardware for every project.

Features

• Unified control. One plane covers the control plane VIP over BGP, tenant clusters, bare metal image builds, and authentication, so operators manage one surface.
• Bare metal orchestration. Run production grade GPU Kubernetes on local hardware without cloud managed services or per GPU billing.
• Fine grained auth. OIDC and JWT claim based auth integrate with Teleport, Entra, and CI OIDC, matching enterprise identity systems.
• Local simulation. nico-sim runs ARM64 node images on Apple Silicon via QEMU and Apple HVF, so you can test on a laptop.
• Standard base. Built on Kubernetes and Cluster API, reusing mature lifecycle management instead of a custom scheduler.
• Vendor neutral. Open standards and open source keep you free of one cloud's GPU scheduling lock in and pricing.
• Image pipeline. Bare metal images are built and versioned as part of the same workflow, so node provisioning is reproducible rather than hand assembled.
• CLI first operations. The nvkectl command exposes cluster creation, node lifecycle, and day two operations through one consistent interface.
• Observability hooks. Standard Kubernetes APIs let existing monitoring and logging stacks attach without a bespoke integration layer.

How to Use

1. Prepare hardware. Get GPU capable bare metal servers and plan the control plane and tenant clusters up front.
2. Pull the code. Clone the repo and set up the Go environment per the documentation.
3. Build images. Use the os-image module to build bare metal node images with auth and boot configuration baked in.
4. Deploy control plane. Initialize the plane with the nvkectl CLI and configure the BGP virtual IP for the control plane.
5. Onboard nodes. Bring bare metal nodes into the cluster, with the agent module owning node lifecycle.
6. Verify locally. Simulate ARM64 nodes with nico-sim on Apple Silicon to test the flow before touching production.
7. Wire the ecosystem. Put the cluster into existing CI and OIDC so teams consume GPU through their current workflows.

Supported Platforms

The project is split into several Go modules, each owning a slice of the lifecycle, and the nvkectl CLI is the main operator entry point. Because it builds on Cluster API, node provisioning and upgrades follow patterns that platform teams already know, which shortens the learning curve.

Pricing

nvke is Apache-2.0 and free for commercial and personal use on your own hardware. The code ships as multiple Go modules on GitHub, including controller, node agent, auth, management engine, and the nvkectl CLI, with no fee or approval from NVIDIA. You can audit and extend it like any open source project, and there is no usage based metering.

Budget instead goes to hardware, power, and operations, which is the trade off to weigh against a managed cloud service.

Use Cases

• Self built AI platform. Run production grade GPU Kubernetes on local hardware, dodging cloud cost and lock in.
• AI Factory rollout. Extend the DSX AI Factory management to your own clusters for a consistent control surface.
• Multi tenant isolation. Split resources into tenant clusters for different teams or external customers.
• Edge and simulation. Use nico-sim on Apple Silicon for light verification and lower trial cost before scaling.
• Compliance. Meet internal security and audit needs through fine grained OIDC auth and on premises data.
• Cost sensitive work. For steady heavy GPU use, owned hardware amortizes far below ongoing cloud spend.
• Regulated workloads. Keep training data and model weights on premises while still offering self service GPU clusters to internal teams.
• Hybrid capacity. Burst to cloud for peaks while keeping a predictable baseline on owned hardware.

How It Works

nvke is open sourced and maintained by NVIDIA as part of the DSX AI Factory ecosystem. The project is organized as several Go modules: controller handles orchestration, agent owns nodes, and management-engine runs the control, exposed through the nvkectl CLI. With recent active commits, it keeps adding Apple Silicon simulation and claim based auth. Released as a Certified Kubernetes AI Platform, it targets enterprises that need local GPU orchestration. It frees NVIDIA's AI infrastructure know how as an open source control plane, lowering the gap from bare metal to production Kubernetes, and its open source stance lets enterprises audit and extend rather than hand critical infrastructure to a black box.

Go modules split responsibilities across provisioning, authentication, and simulation, so each piece can be replaced without rewriting the whole control plane.

Conclusion

If you plan to build production grade GPU Kubernetes on your own hardware while keeping full control of the stack, nvke is NVIDIA's official answer. It pulls the complexity of bare metal orchestration under one control plane and keeps your data on premises. For enterprises, it means holding the initiative on GPU clusters instead of being led by cloud bills, and it ships under a permissive Apache-2.0 license. Project address https://github.com/dsx-ai-factory/nvke , docs https://docs.nvidia.com/nvke/ .

Start with nico-sim on a laptop to validate the workflow before committing physical servers.