Not every tenant needs the same boundary, and charging as if they did leaves margin on the table. vCluster runs shared nodes for dev and CI, Private Nodes for production, and vNode for tenants that need kernel-level hardening, all on one GPU fleet behind one control plane.
Commit to a single tenancy model and you either overspend on your cheapest customers or under-protect your most demanding ones.
A platform built on a single tenancy model has one cost structure. Your dev tier carries production overhead, and your margin goes with it.
Namespace boundaries suit internal teams who already trust each other. Paying customers running arbitrary workloads on your GPUs need a real boundary.
Separate physical clusters give you the boundary and multiply hardware cost, ops burden, and onboarding time with every tenant you add.
vCluster virtualizes the Kubernetes control plane, so every tenant gets a real, CNCF-certified cluster with its own API server, etcd, and RBAC whichever tier they buy. Underneath, the node model is yours to choose: shared nodes for dev, test, CI/CD, and trusted teams; Private Nodes, the production default, for dedicated hardware with per-tenant CNI and storage; vNode for tenants that need kernel-level hardening. One fleet, one control plane, three price points. Proven across 100K+ GPU nodes and 50+ GPU clouds.
The control plane stays the same for every tenant. What changes is where their workloads land and how hard the boundary is.
Each tenant gets their own CNCF-certified API server, etcd, scheduler, and RBAC running as a lightweight pod. The tier they pay for changes the nodes underneath, not the Kubernetes they get.
Several tenants schedule onto the same physical GPU nodes with namespace boundaries and resource quotas enforced at the platform level. The most cost-efficient model, suited to development, testing, CI/CD, and trusted internal teams.
Dedicated physical nodes join each tenant cluster privately over an encrypted WireGuard VPN, with their own CNI and CSI. No other tenant schedules onto that hardware, so GPU performance stays predictable.
vNode wraps each workload in its own runtime using seccomp, cgroups, namespaces, and AppArmor, giving container breakout protection at bare metal GPU speed. Layer it over either node model for tenants that need more.
Manage all tenant clusters across all tiers from a single UI, CLI, and API. Templates codify each tier, so a customer picking a plan gets exactly the configuration you defined, with SSO, quotas, and RBAC applied fleet-wide.
This isn’t a side project. Behind every vCluster deployment is 5+ years of deep K8s engineering, security hardening, and battle-tested infrastructure work at massive scale.
Talk to our team about your stack
Deploy vCluster on your infra in minutes
Go live with a hyperscaler-grade tenant experience in days
Multi-tenant Kubernetes means running workloads for several independent customers or teams on shared infrastructure while keeping each one separated from the others. The models differ in where the boundary sits: namespaces divide a single cluster, separate clusters give each tenant their own hardware and control plane, and control-plane virtualization gives each tenant a real cluster on shared infrastructure. vCluster takes the third approach and lets you vary the node model per tenant.
Match it to trust. Shared nodes suit development, testing, CI/CD, and internal teams you already trust, and they deliver the highest GPU density. Private Nodes are the production default and assign dedicated physical nodes with per-tenant CNI and storage, which is what paying customers running arbitrary workloads need. vNode layers kernel-native workload isolation over either model for tenants with stricter requirements.
No. Namespaces share one API server, one etcd, and one set of cluster-wide resources, so tenants can see platform internals and a misconfiguration in one namespace can reach others. Every vCluster tenant gets a separate control plane whichever tier they are on, so even the shared-node entry tier gives each tenant their own API server. For external customers running arbitrary workloads, Private Nodes moves the boundary into hardware.
Templates define each tier as a versioned configuration, so moving a customer up a tier means provisioning their cluster from a different template. Tier changes are planned as a new cluster with workloads migrated across, which leaves the running environment untouched until the switch.
Control planes run as lightweight pods, so there is no hypervisor layer or VM tax between workloads and the GPU. On Private Nodes the tenant has the hardware to themselves, so GPU throughput matches bare metal. vNode adds workload isolation using kernel-native mechanisms rather than VMs, which keeps that performance intact.
Hundreds. Control planes are lightweight pods with near-zero marginal cost per tenant, which is what makes tiering viable: the entry tier can be priced low because it costs little to run. vCluster is proven across 100K+ GPU nodes and 50+ GPU clouds, with customers running hundreds of tenant clusters in production.
See how vCluster runs dev, production, and hardened tenants on the same GPU infrastructure.
