← Back to blog
AiAbout 7 min read

NVIDIA Open-Sourced a Control Plane for GPU Kubernetes

Published Nov 8, 2026
NVIDIA Open-Sourced a Control Plane for GPU Kubernetes

The awkward part of GPU infrastructure comes after you get the cards: handing a slice of them to a team in a way that team can use without handing them the whole machine.

That is the problem dsx-ai-factory/nvke is aimed at, and the project name is literal: NVIDIA Kubernetes Engine. NVIDIA open-sourced it under Apache 2.0, it is written in Go against 1.27.3, and it is in preview. It picked up around 345 stars a day this week, which for an infrastructure repo with 809 stars total means most of its audience found it in the last few days.

What it is, in NVIDIA's own framing

The README is careful about definitions, and the care is worth reproducing because it prevents a lot of confusion.

NVIDIA is explicit that NVKE is neither a Kubernetes distribution nor a Cluster API flavour. The project calls itself a self-hosting factory for Kubernetes clusters. A throwaway seed cluster stands up a management cluster. The management plane running on that management cluster then provisions and lifecycle-manages many isolated workload clusters on demand.

An installation therefore has two kinds of cluster. The management cluster runs the NVKE management plane and the infrastructure controllers. The workload clusters run customer applications, each with its own control plane, its own etcd, and its own node pools. You operate the management plane. Your customers use their clusters through the Kubernetes API and kubectl, and from their side it looks like a managed service.

This is the shape a platform team at a neocloud, a research lab, or a company with its own GPU racks ends up building by hand. Somebody has to own the boring middle: provisioning machines, joining nodes, replacing failed hardware, upgrading Kubernetes versions, and doing it per tenant without cross-contamination. NVKE is that middle, packaged.

The identity bit is the interesting bit

Most of the components here are things you would expect. The part that surprised me is node identity.

Nodes attest through SPIFFE/SPIRE using their TPM before they receive join credentials. If you have ever wondered how a cluster knows that the machine asking to join is the machine you provisioned and not something else that found the endpoint, this is the answer, and it is the correct one. Attestation happens against hardware, not against a token somebody copied out of a config map.

etcd data encryption is available per cluster, which for a multi-tenant setup is table stakes rather than a feature.

Machines come from NVIDIA Infra Controller, or NICo, which is the sole compatible infrastructure provider at preview. That is a real constraint. If your hardware is managed by something else, this is not pluggable yet.

Trying it without a GPU

The friendliest thing in the repo is the local quickstart, which runs a development management plane and a workload cluster on simulated machines. No NVIDIA account required. The requirements are a Linux host or VM, amd64 or arm64, at least 6 CPUs, 12 GiB of free memory, 100 GiB of free disk, Docker, and virtual TPM support. On macOS you use a Colima VM.

The goal of that exercise is narrow and practical: get to a workload cluster and confirm its nodes report Ready. If that works, you have seen the whole loop without touching silicon.

Building from source is the other path and it is refreshingly boring:

git clone https://github.com/dsx-ai-factory/nvke.git
cd nvke
make build

That produces nine binaries in bin/: agent, updater, controller, nvkectl, capd-reboot-controller, nvke-os-image-check, management-engine, tenant-api, operator-api. Building does not start a management plane or create a cluster, which sounds obvious until you have run a make target that did exactly that.

For a real installation you supply the machines, networking, node images and registries yourself, and you configure access to NICo. The companion repo nvkr, NVIDIA Kubernetes Recipes, builds the node images and NVKE components from pinned inputs, and owns the build and release evidence. Splitting "what gets built" from "what gets deployed" is the right seam, and it means the artifacts have a provenance story separate from the control plane.

The limitations section reads like a confession

Here is where NVKE earns some trust.

The preview comes with explicit warnings, in the README, not buried in a wiki. API authentication is off and the API uses plain HTTP after installation. You are expected to configure authentication and protected access before admitting callers. The management cluster does not upgrade, scale, or replace itself. There is no management-plane upgrade procedure and no backup or restore procedure. FDE node images are for evaluation only and provide no data-at-rest confidentiality.

That list is unusual. Most preview announcements write "not for production" and move on. NVIDIA enumerated the specific ways you will get hurt, which lets you decide whether your evaluation is safe.

For anyone planning to deploy: the plain HTTP plus no auth combination means the management plane must sit behind a network boundary you control, full stop. This is not a "we will harden it later" situation, it is a "do not route this" situation.

Who this is for

Three groups, roughly.

The first is anyone running a GPU cloud. If you sell Kubernetes clusters on your own hardware, the build-versus-buy math on a control plane is miserable, because it is not the thing customers pay for and it is the thing that pages you at 3am. An Apache 2.0 management plane with a kubectl-shaped surface for tenants is attractive even at preview quality, because you can read the code.

The second is large enterprises with a central platform team and internal customers. The "operator runs the plane, customers get clusters" model maps directly onto how a bank or a manufacturer actually allocates GPU capacity, which is a ticket, a quota, and an isolated namespace, not a shared cluster with RBAC hope.

The third is research institutions. Multi-tenant isolation with per-cluster etcd and TPM attestation is close to what a university needs when four labs share a DGX rack and one of them is doing something that must not be visible to the others.

What it is not for is a single team with eight GPUs. You would spend more time on the control plane than on the models.

The strategic read

NVIDIA's software strategy has been consistent for a while: make the hardware easy to consume, and let the orchestration layer be free. CUDA, NCCL, Triton, NIM, and now a Kubernetes management plane. None of it is where the margin is. All of it makes the silicon more usable, which is where the margin is.

There is also a competitive angle. The managed Kubernetes story for GPUs has largely been the hyperscalers' to tell, because they own both the control plane service and the hardware. NVKE gives the same shape to anyone with racks, and it does it in a way that does not require sending the workload to AWS. For a sovereign cloud or a regulated industry buyer, that is a real option that did not exist as open source before.

The counterargument is maintenance. A control plane is a service you upgrade on a schedule, patch on a Friday, and rebuild when the etcd snapshot is corrupt. It is not a library you bump in a lockfile. The absence of a management-plane upgrade path in the preview is not a documentation gap, it is the hardest part of the problem, and NVIDIA has not solved it in public yet.

So treat this as a preview of an architecture rather than a product. Read the code, run the local quickstart, form an opinion about whether the seed-cluster bootstrapping model holds up when the management cluster itself needs to move. That question, not the model catalogue, is what determines whether a GPU Kubernetes control plane is genuinely commodity software.

Apache 2.0 means you can fork it if the answer is no. That is the actual value of the release.

Related articles