vcluster
vCluster - Create fully functional virtual Kubernetes clusters - Each vcluster runs inside a namespace of the underlying k8s cluster. It's cheaper than creating separate full-blown clusters and it offers better multi-tenancy and isolation than regular namespaces.
Top Related Projects
Home for Cluster API, a subproject of sig-cluster-lifecycle
Little helper to run CNCF's k3s in Docker
Run Kubernetes locally
Lightweight Kubernetes
Kubernetes IN Docker - local clusters for testing Kubernetes
Backup and migrate Kubernetes applications and their persistent volumes
Quick Overview
vcluster is an open-source project that creates virtual Kubernetes clusters within a host Kubernetes cluster. It allows users to create lightweight, isolated environments for development, testing, and multi-tenancy scenarios without the overhead of spinning up separate physical clusters.
Pros
- Efficient resource utilization by running multiple virtual clusters on a single host cluster
- Improved isolation and security between different teams or projects
- Easy to set up and manage compared to full-fledged Kubernetes clusters
- Supports most standard Kubernetes tools and workflows
Cons
- Some limitations in terms of supported Kubernetes features compared to full clusters
- Potential performance overhead due to the virtualization layer
- Requires careful planning for resource allocation to avoid overloading the host cluster
- Learning curve for understanding the concept and management of virtual clusters
Getting Started
To get started with vcluster, follow these steps:
- Install the vcluster CLI:
curl -L -o vcluster "https://github.com/loft-sh/vcluster/releases/latest/download/vcluster-$(uname -s)-$(uname -m)" && chmod +x vcluster && sudo mv vcluster /usr/local/bin
- Create a virtual cluster:
vcluster create my-vcluster
- Connect to the virtual cluster:
vcluster connect my-vcluster
- Use kubectl to interact with the virtual cluster:
kubectl get pods
- Delete the virtual cluster when done:
vcluster delete my-vcluster
For more advanced usage and configuration options, refer to the official vcluster documentation.
Competitor Comparisons
Home for Cluster API, a subproject of sig-cluster-lifecycle
Pros of Cluster API
- Provides a standardized, declarative approach to cluster lifecycle management across various infrastructure providers
- Offers more extensive support for managing multiple clusters and complex multi-cloud deployments
- Has strong community support and is part of the official Kubernetes SIG ecosystem
Cons of Cluster API
- Requires more setup and configuration compared to vcluster's lightweight approach
- Has a steeper learning curve, especially for users new to Kubernetes cluster management
- May be overkill for simple use cases or local development environments
Code Comparison
vcluster:
apiVersion: v1
kind: ConfigMap
metadata:
name: my-vcluster-config
data:
config.yaml: |
sync:
nodes: false
Cluster API:
apiVersion: cluster.x-k8s.io/v1beta1
kind: Cluster
metadata:
name: my-cluster
spec:
clusterNetwork:
pods:
cidrBlocks: ["192.168.0.0/16"]
infrastructureRef:
apiVersion: infrastructure.cluster.x-k8s.io/v1beta1
kind: AWSCluster
name: my-cluster
The code examples demonstrate the difference in complexity and scope between the two projects. vcluster focuses on lightweight virtual clusters within an existing Kubernetes cluster, while Cluster API provides a more comprehensive approach to managing full-fledged Kubernetes clusters across various infrastructure providers.
Little helper to run CNCF's k3s in Docker
Pros of k3d
- Lightweight and fast setup for local Kubernetes development
- Supports multi-node clusters, simulating more realistic environments
- Integrates well with existing Docker infrastructure
Cons of k3d
- Limited to local development environments
- Doesn't provide true multi-tenancy or isolation between virtual clusters
- May not fully replicate production Kubernetes environments
Code Comparison
k3d:
k3d cluster create mycluster --servers 3 --agents 2
vcluster:
vcluster create mycluster
kubectl config use-context vcluster_mycluster
Key Differences
- k3d creates lightweight Kubernetes clusters using k3s in Docker containers, ideal for local development and testing.
- vcluster creates virtual clusters within existing Kubernetes clusters, providing better isolation and multi-tenancy.
- k3d is more focused on local development, while vcluster can be used in both local and production environments.
- vcluster offers better resource isolation and namespace separation between virtual clusters.
- k3d provides an easier setup for multi-node clusters, which can be beneficial for testing distributed applications.
Both tools serve different purposes and can be complementary in a Kubernetes development workflow, with k3d excelling in local development and vcluster offering more flexibility for multi-tenancy and production-like environments.
Run Kubernetes locally
Pros of Minikube
- Simulates a full Kubernetes cluster on a local machine, providing a more realistic environment
- Supports multiple hypervisors and operating systems, offering greater flexibility
- Includes built-in addons for enhanced functionality and easier management
Cons of Minikube
- Requires more system resources due to running a full VM
- Setup and teardown can be slower compared to lightweight alternatives
- Limited scalability for testing larger deployments or multi-node scenarios
Code Comparison
Minikube:
minikube start
kubectl create deployment hello-minikube --image=k8s.gcr.io/echoserver:1.10
kubectl expose deployment hello-minikube --type=NodePort --port=8080
minikube service hello-minikube
vcluster:
vcluster create my-vcluster
vcluster connect my-vcluster
kubectl create deployment hello-vcluster --image=k8s.gcr.io/echoserver:1.10
kubectl expose deployment hello-vcluster --type=ClusterIP --port=8080
kubectl port-forward service/hello-vcluster 8080:8080
The code comparison shows that both tools allow for creating and interacting with Kubernetes deployments, but vcluster operates within an existing cluster, while Minikube creates a standalone environment. Minikube's approach is more straightforward for local development, while vcluster offers more flexibility for working within existing infrastructure.
Lightweight Kubernetes
Pros of k3s
- Lightweight and resource-efficient, suitable for edge computing and IoT devices
- Includes built-in storage and load balancing solutions
- Easier to set up and manage for standalone Kubernetes clusters
Cons of k3s
- Limited flexibility in terms of customization compared to vcluster
- May not be ideal for creating multiple virtual clusters within a single host cluster
- Less suitable for development and testing environments that require isolation
Code Comparison
k3s installation:
curl -sfL https://get.k3s.io | sh -
vcluster creation:
vcluster create my-vcluster
Key Differences
- k3s is a lightweight Kubernetes distribution, while vcluster creates virtual clusters within existing Kubernetes clusters
- k3s is better suited for production environments, especially in resource-constrained scenarios
- vcluster excels in creating isolated development and testing environments within a shared cluster
Use Cases
- k3s: Edge computing, IoT devices, small-scale production deployments
- vcluster: Development environments, testing, multi-tenancy scenarios in shared clusters
Community and Ecosystem
- k3s has a larger community and ecosystem, being part of the CNCF landscape
- vcluster is gaining traction for its unique approach to virtual Kubernetes clusters
Kubernetes IN Docker - local clusters for testing Kubernetes
Pros of kind
- Creates a full, isolated Kubernetes cluster, ideal for testing and development
- Supports multi-node clusters, allowing for more realistic testing scenarios
- Integrates well with CI/CD pipelines and automated testing frameworks
Cons of kind
- Requires more system resources due to running full nodes
- Slower to start up compared to lightweight alternatives
- Limited flexibility in customizing the underlying host environment
Code Comparison
kind:
kind: Cluster
apiVersion: kind.x-k8s.io/v1alpha4
nodes:
- role: control-plane
- role: worker
vcluster:
apiVersion: v1
kind: ConfigMap
metadata:
name: my-vcluster-config
data:
values.yaml: |
sync:
nodes:
enabled: true
Key Differences
vcluster creates virtual clusters within an existing Kubernetes cluster, while kind creates standalone clusters using Docker containers. vcluster is more lightweight and faster to start, but kind provides a more isolated and complete cluster environment. vcluster allows for easier integration with existing cluster resources, while kind offers better isolation for testing purposes.
Both tools serve different use cases and can be valuable in different scenarios. kind is better suited for full cluster testing and CI/CD pipelines, while vcluster excels in multi-tenancy scenarios and rapid development environments within existing clusters.
Backup and migrate Kubernetes applications and their persistent volumes
Error generating comparison
Convert
designs to code with AI
Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.
Try Visual CopilotREADME
Tenant Clusters for AI clouds, AI factories, and production Kubernetes
Run your infrastructure like a hyperscaler. Every team, customer, and training run gets its own isolated cluster.
Website · Quickstart · Documentation · Blog · Slack
CNCF Certified Kubernetes · Distribution · Kubernetes AI Conformant
About
vCluster creates Tenant Clusters: fully isolated environments delivered as managed Kubernetes, or as the foundation for Slurm, Ray, Run:ai and inference clusters. Each gets its own API server, CRDs and RBAC, and runs on an existing cluster or standalone on bare metal. CNCF Certified Kubernetes.
Every cluster becomes a product you can ship. Sell it to customers or serve it to internal teams from the same platform, with each tenant seeing only their own cluster and nothing else. The control plane stays invisible to tenants: no shared control plane nodes, no in-cluster agent pods, and no lateral path between environments.
Because a Tenant Cluster is upstream Kubernetes, everything built for the standard API works against it unmodified: kubectl, Helm, Argo, Crossplane, operators, and CRDs.
40M+ Tenant Clusters deployed. vCluster runs in production at Adobe, CoreWeave, NVIDIA, Nebius, Lintasarta, Atlan, Deloitte, and across 50+ AI clouds and Fortune 500 platform organizations, powering 100K+ GPUs and 1M+ CPUs.

ð Quick start
# Install the vCluster CLI
brew install loft-sh/tap/vcluster
# Create a Tenant Cluster
vcluster create my-vcluster --namespace team-x
# Use kubectl as usual. You are now inside your Tenant Cluster.
kubectl get namespaces
Prerequisites: a running Kubernetes cluster and kubectl configured.
ð³ Run locally on Docker with vind
No Kubernetes cluster? Run a complete Tenant Cluster in Docker containers with vind (vCluster in Docker). Like kind, but with the full vCluster feature set: UI, sleep and resume, LoadBalancer, image cache, and external nodes joining over VPN.
vcluster create my-vcluster --driver docker
kubectl get namespaces
ð® Try it in the browser
ð vCluster free tier
Real usage, not a gated demo. Unlimited Tenant Clusters up to 64 CPUs and 32 GPUs, plus the full vCluster Platform UI, for free. Get started free â
ð§© Every kind of cluster
One platform turns raw compute into the cluster type each tenant actually asks for. Kubernetes is the foundation; the rest are delivered on top of it.
| Cluster type | What a tenant gets |
|---|---|
| Kubernetes Clusters | A dedicated, CNCF-certified Kubernetes cluster with its own API server, CRDs, and RBAC |
| Nested Clusters | Tenant Clusters running on the Control Plane Cluster's shared nodes for maximum density |
| Inference Clusters | Serving stacks such as Dynamo and llm-d, isolated per tenant |
| Ray Clusters | Ray for distributed training and data processing, isolated per tenant |
| Run:ai Clusters | Run:ai scheduling on top of an isolated Tenant Cluster |
| Slurm Clusters (Beta) | Managed Slurm for HPC and batch training |
| Agent Sandbox Clusters (Coming soon) | Isolated clusters for agentic and untrusted code execution |
Slurm, Ray, Run:ai, inference, and agent sandbox clusters are delivered through vCluster Platform. This repository is the open-source engine that every one of them is built on.
ðï¸ Architectures
vCluster supports multiple deployment architectures. Two things vary independently: where the control plane runs (an existing Kubernetes cluster, a standalone binary, or Docker) and how tenant workloads are placed (shared nodes or private nodes). The modes below combine them, offering progressively stronger isolation from dense shared infrastructure through to fully standalone deployments on bare metal.
Architecture comparison
| Shared Nodes | Dedicated Nodes | Private Nodes | Standalone | |
|---|---|---|---|---|
| Control Plane Cluster | Required | Required | Required | Not required |
| Node isolation | â | â | â | â |
| CNI/CSI isolation | â | â | â | â |
| Bare metal ready | · | · | â | â |
| Best for | Dev/test, density | Production tenants | Compliance, GPU | AI factories, edge |
Minimal configuration
ð¹ Shared Nodes: maximum density, minimum cost
Tenant Clusters share the Control Plane Cluster's nodes. Workloads run as regular pods in a namespace.
sync:
fromHost:
nodes:
enabled: false # Uses pseudo nodes
ð¹ Dedicated Nodes: isolated compute on labeled node pools
Tenant Clusters get their own set of labeled nodes on the Control Plane Cluster. Workloads are isolated but still managed by the Control Plane Cluster.
sync:
fromHost:
nodes:
enabled: true
selector:
labels:
tenant: my-tenant
ð¹ Private Nodes v0.27+: full CNI/CSI isolation
External nodes join the Tenant Cluster directly with their own CNI, CSI, and networking stack, through a token-based process. No cross-tenant visibility, and complete infrastructure separation from the Control Plane Cluster. Nodes can also join over an encrypted VPN overlay v0.30+, so one Tenant Cluster can span sites, networks, and clouds.
privateNodes:
enabled: true
controlPlane:
service:
spec:
type: NodePort
ð¹ vCluster Standalone v0.29+: no Control Plane Cluster required
A complete, zero-dependency Kubernetes distribution. Run the whole control plane as a self-contained binary directly on bare metal or VMs. This is how providers solve the "cluster one" problem when building infrastructure from scratch.
controlPlane:
standalone:
enabled: true
joinNode:
enabled: true
privateNodes:
enabled: true
â¡ Auto Nodes v0.28+: Karpenter-powered dynamic autoscaling
Automatically provision and deprovision private nodes based on workload demand. Works across public cloud, private cloud, hybrid, and bare metal environments. Node profiles v0.36+ let each pool carry its own node configuration.
autoNodes:
enabled: true
nodeProvider: <provider>
privateNodes:
enabled: true
ð³ vind v0.32+: a complete Tenant Cluster in Docker, no Kubernetes required
The control plane and worker nodes run as containers on a single Docker host, using private nodes underneath. There is no Control Plane Cluster and no Kubernetes dependency at all, which makes this the fastest way to get a real Tenant Cluster on a laptop or a CI runner. Docker deployment is driven by the CLI rather than byvcluster.yaml.
vcluster create my-vcluster --driver docker
⨠Key features
| Feature | Description |
|---|---|
| ðï¸ Its own API server, per tenant | Every Tenant Cluster runs a dedicated control plane: API server, controller manager, and data store. Full Kubernetes API isolation, not a namespace with rules layered on top |
| ð Strong tenant isolation | Tenants hold admin inside their Tenant Cluster while holding minimal permissions on the Control Plane Cluster |
| ð® GPU-aware scheduling | Dynamic Resource Allocation with resource claims, resource claim templates, and device classes, plus in-place pod resizing |
| â¡ Auto Nodes | Karpenter-powered provisioning and deprovisioning of private nodes across cloud, hybrid, and bare metal, with per-pool node profiles |
| ð¥ï¸ Standalone deployment | Run without a Control Plane Cluster on dedicated infrastructure or bare metal, purpose-built for AI factories and on-prem GPU fleets |
| ð³ Runs on Docker | A complete Tenant Cluster in Docker containers with no Kubernetes dependency, through vcluster create --driver docker |
| ð Node VPN (Platform) | Private nodes join over an encrypted overlay, so a single Tenant Cluster can span sites, networks, and clouds |
| ð¸ Snapshot and restore | Snapshot a Tenant Cluster to S3, OCI, Azure Blob, or local storage, and restore it elsewhere |
| ð¤ Sleep mode (Platform) | Pause inactive Tenant Clusters to save resources, with instant wake when needed |
| ð Shared platform stack (Shared / Dedicated Nodes) | Reuse the Control Plane Cluster's CNI, CSI, ingress, and other infrastructure, with no duplicate platform components |
| ð Resource syncing (Shared / Dedicated Nodes) | Bidirectional sync of any Kubernetes resource: pods, services, secrets, configmaps, CRDs, and Gateway API objects |
| ð§© Integrations | Native support for cert-manager, external-secrets, KubeVirt, Istio, and metrics-server |
| ð High availability | Multiple replicas with leader election. Embedded etcd or external databases (PostgreSQL, MySQL, RDS) |
Shared platform stack, resource syncing, and Control Plane Cluster integrations apply in Shared and Dedicated Nodes modes, where the Tenant Cluster reuses the Control Plane Cluster's CNI, CSI, and platform stack. Private Nodes and Standalone deployments bring their own CNI, CSI, and platform components.
ð What's new
| Version | Feature | Description |
|---|---|---|
| v0.36 | Gateway API and node profiles | Gateway API sync for Tenant Clusters, node profiles for private nodes, and a pinnable standalone advertise address |
| v0.35 | Snapshots and Kubernetes 1.36 | etcd v3 snapshot facilities for embedded etcd, wildcard custom resource proxy, kine metrics, Kubernetes v1.36 |
| v0.34 | Multi-region platform and standalone snapshots | Active/active vCluster Platform across regions (Route 53 + RDS), standalone snapshots (S3 / OCI / local), first-class template parameters |
| v0.33 | Enterprise reliability and storage | Automatic leaf-cert regeneration, Azure Blob snapshot destinations, workload-level sleep annotations |
| v0.32 | Docker driver and DRA | Run vCluster on Docker, Dynamic Resource Allocation (DRA) for GPU workloads, in-place pod resizing |
| v0.27âv0.31 | Architecture foundations | Private Nodes (v0.27), Auto Nodes (v0.28), Standalone (v0.29), vCluster VPN and Netris (v0.30), snapshot and cross-cluster APIs (v0.31) |
ð Full changelog
ð¯ Who runs vCluster
| Use case | What it solves | Learn more |
|---|---|---|
| AI cloud providers | Launch a hyperscaler-like managed cluster experience for GPU customers. Automate tenant, cluster, and bare metal provisioning end to end. | View â |
| AI factories | Run AI on-prem where your data and GPUs live. Give every team the GPU access they need without multiplying infrastructure. | View â |
| Internal GPU platforms | Maximize GPU utilization without sacrificing isolation. Self-service Kubernetes for AI/ML teams. | View â |
| Distributed inference | Isolated, production-grade serving stacks per tenant, per model, or per customer. | View â |
| Sovereign clouds | Data residency and tenant isolation enforced at the infrastructure layer. | View â |
| Bare metal Kubernetes | Run production Kubernetes on bare metal with zero VMs. Isolation without virtualization overhead. | View â |
| Software vendors | Ship Kubernetes-native products. Each customer gets their own isolated Tenant Cluster. | View â |
| Environments and cost savings | Consolidate clusters, pause idle workloads with sleep mode, and cut Kubernetes cost at scale. | View â |
Start turnkey with the vCluster Platform UI and CLI, or call the APIs and put your own portal and brand in front. It is a two-way door, with no re-platforming.
ð The vCluster stack
vCluster is the foundation of a broader platform for running Kubernetes and AI infrastructure on your own hardware, from a single rack to 100K-GPU superclusters.
| Product | What it does |
|---|---|
| vCluster | Tenant Clusters. A dedicated control plane per tenant, with API, data, and optionally network isolation |
| vNode | Runtime-level isolation. Kernel-enforced boundaries (Linux user namespaces, seccomp, cgroups, AppArmor) without VM overhead |
| vMetal | Bare metal provisioning and lifecycle for GPU fleets. Turns GPU racks into a cloud platform |
| Netris (integration) | Hardware-enforced network isolation via programmatic VLANs, VRFs, and ACLs |
Together they provide the full stack for an AI factory: certified Kubernetes, isolated Tenant Clusters, runtime workload sandboxing, and GPU infrastructure operations. The ClusterMAX⢠security criteria call for strong isolation between tenants, and name vNode Private Nodes.
ð¢ Trusted by
| Nebius AI cloud tenant isolation |
QumulusAI 1 min to spin up isolated K8s |
Polarise 100% data residency at the infra layer |
| Boost-Run <45 days to production launch |
Lintasarta 170+ Tenant Clusters in production |
CoreWeave GPU cloud at scale |
| Atlan 100 â 1 clusters |
Fortune 500 Insurance 70% reduction in Kubernetes cost |
Deloitte Enterprise Kubernetes platform |
| Aussie Broadband 99% faster provisioning |
Ada 10x developer productivity |
Scanmetrix 99% faster deployments |
Also used by: Adobe, NVIDIA, ABBYY, Precisely, Shipwire, and many more, with 50+ GPU clouds and Fortune 500s running vCluster in production.
ð Learn more
ð¤ Conference talks
| Event | Speaker | Title | Link |
|---|---|---|---|
| NVIDIA GTC 2026 | Lukas Gentele | Build a Software-Defined Multi-Tenant NVLinked Cluster | Watch |
| KubeCon NA 2025 (Keynote) | Lukas Gentele | Autoscaling GPU Clusters Anywhere | Watch |
| Platform Engineering Day NA 2025 (Keynote) | Saiyam Pathak | AI-Ready Platforms: Scaling Teams Without Scaling Costs | Watch |
| Rejekts NA 2025 | Hrittik Roy, Saiyam Pathak | Beyond the Default Scheduler: Navigating GPU MultiTenancy in AI Era | Watch |
| KubeCon EU 2025 | Paco Xu, Saiyam Pathak | A Huge Cluster or Multi-Clusters? Identifying the Bottleneck | Watch |
| HashiConf 2025 | Scott McAllister | GPU sharing done right: Secrets, security, and scaling with Vault and vCluster | Watch |
| FOSDEM 2025 | Hrittik Roy, Saiyam Pathak | Accelerating CI Pipelines: Rapid Kubernetes Testing with vCluster | Watch |
| KubeCon India 2024 (Keynote) | Saiyam Pathak | From Outage To Observability: Lessons From a Kubernetes Meltdown | Watch |
| CNCF Book Club 2024 | Marc Boorshtein | Kubernetes: An Enterprise Guide (vCluster) | Watch |
| KCD NYC 2024 | Lukas Gentele | Tenant Autonomy & Isolation In Multi-Tenant Kubernetes Clusters | Watch |
| KubeCon EU 2023 | Ilia Medvedev, Kostis Kapelonis | How We Securely Scaled Multi-Tenancy with VCluster, Crossplane, and Argo CD | Watch |
| KubeCon NA 2022 | Joseph Sandoval, Dan Garfield | How Adobe Planned For Scale With Argo CD, Cluster API, And VCluster | Watch |
| KubeCon NA 2022 | Whitney Lee, Mauricio Salatino | What a RUSH! Let's Deploy Straight to Production! | Watch |
| TGI Kubernetes 2022 | TGI | TGI Kubernetes 188: vCluster | Watch |
| Mirantis Tech Talks 2022 | Mirantis | Multi-tenancy & Isolation using Virtual Clusters (vCluster) in K8s | Watch |
| Solo Webinar 2022 | Rich Burroughs, Fabian Keller | Speed your Istio development environment with vCluster | Watch |
| KubeCon NA 2021 | Lukas Gentele | Beyond Namespaces: Virtual Clusters are the Future of Multi-Tenancy | Watch |
ð¬ Community voice
| Channel | Speaker | Title | Link |
|---|---|---|---|
| TeKanAid 2024 | TeKanAid | Getting Started with vCluster: Build Your IDP with Backstage, Crossplane, and ArgoCD | Watch |
| Rawkode 2021 | David McKay, Lukas Gentele | Hands on Introduction to vCluster | Watch |
| Kubesimplify 2021 | Saiyam Pathak, Lukas Gentele | Let's Learn vCluster | Watch |
| TechWorld with Nana 2021 | Nana | Build your Self-Service Kubernetes Platform with Virtual Clusters | Watch |
| DevOps Toolkit 2021 | Viktor Farcic | How To Create Virtual Kubernetes Clusters | Watch |
Featured in 4 books on Kubernetes and platform engineering.
ð YouTube channel · Blog · Resources
ð¤ Contributing
We welcome contributions. Check out the contributing guide to get started.
ð¬ Connect with us
- Join our Slack community, 5K+ engineers
- Follow on LinkedIn, 28K+
- Follow on X, 3.7K+
- Watch on YouTube
- Read the blog
- Book a consultation
ð License
vCluster is licensed under the Apache 2.0 License.
© 2026 vCluster Labs. All rights reserved.
Made with â¤ï¸ by the vCluster community.
â Star us on GitHub. It helps.
Top Related Projects
Home for Cluster API, a subproject of sig-cluster-lifecycle
Little helper to run CNCF's k3s in Docker
Run Kubernetes locally
Lightweight Kubernetes
Kubernetes IN Docker - local clusters for testing Kubernetes
Backup and migrate Kubernetes applications and their persistent volumes
Convert
designs to code with AI
Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.
Try Visual Copilot