KubeVirt virtualisation & VDI · built in Europe
KubeVirt runs full virtual machines — real QEMU/KVM guests — as first-class Kubernetes workloads. One control plane schedules VMs, virtual desktops and containers across one network fabric and one storage layer. It is an open exit from per-core hypervisor licensing and a sovereign home for Windows and Linux VDI, without a big-bang rewrite.
EU-owned, in the Netherlands, on 100% renewable power · View pricing
One platform for VMs, desktops and containers.
KubeVirt is a Kubernetes extension that runs a full virtual machine — QEMU/KVM under
libvirt — inside a pod, described by a standard VirtualMachine resource. That
single decision collapses two stacks into one: the same scheduler, the same network fabric
and the same storage layer serve your containers, your server VMs and your virtual
desktops.
The problem it solves. Most estates run two parallel platforms — a proprietary hypervisor for VMs and Kubernetes for containers — staffed, licensed and operated separately. The economics of that split changed sharply, and not in your favour.
$ kubectl get vm -n desktops NAME AGE STATUS READY win11-pool-014 21d Running True win11-pool-015 21d Running True cad-gpu-03 9d Running True # drain a host — the guest keeps its session $ virtctl migrate cad-gpu-03 VM cad-gpu-03 was scheduled to migrate # requires ReadWriteMany storage (Ceph RWX)
Run and on-call for the virtualisation platform — the undifferentiated heavy lifting.
Your VMs and desktops, fully in your hands — with full cluster-admin.
VMs and containers, one platform — open, with no lock-in. A KubeVirt VM and a container run side by side on the identical cloud-native foundation as our Virtual Private Cloud and Dedicated Private Cloud. The only difference between tiers is the isolation and dedication of the compute beneath them — shared-hardware VPC nodes, or single-tenant bare-metal DPC nodes for regulated, high-security desktops and VMs. KubeVirt is an open-source CNCF project, so nothing about the platform traps you here: your VMs are declarative YAML and portable disk images, not a proprietary appliance format.
Virtual machines as Kubernetes-native objects.
A declarative VirtualMachine resource defines the guest; KubeVirt reconciles it into a running VirtualMachineInstance. Start, stop, restart and live-migrate are API operations — not console clicks.
Guests run on hardware-accelerated KVM under libvirt — the same hypervisor technology underneath most Linux virtualisation — for near-native performance, not slow software emulation.
Each VM runs in a virt-launcher pod, so node selection, taints, tolerations, affinity, quotas and priority all apply — VMs and containers compete for the same fleet on the same rules.
Reusable VirtualMachineInstancetype and preference objects separate sizing (CPU/memory) from guest tuning — so "a medium Windows desktop" is one named, version-controlled shape.
VMs live in Git like everything else. Define, review and roll out desktop fleets and server VMs through Argo CD or Flux — the same pipeline that ships your containers.
A legacy database VM can sit in the same namespace as the containerised services that call it, sharing one network and one set of NetworkPolicies — no gateway between two platforms.
The OpenShift and KubeVirt capabilities powering your VMs and desktops.
A virtual desktop is just a VM with a display protocol and a connection broker in front of it. KubeVirt makes that desktop a Kubernetes object — so the same platform that runs your server VMs runs Windows and Linux desktops for your users, GPU-accelerated where the work demands it, on infrastructure that stays in the EU.
Full desktop guests — Windows or your preferred Linux — running as KubeVirt VMs, provisioned from version-controlled templates and instancetypes rather than hand-built golden images.
Desktop pools scale with demand on the shared fleet — spin up seasonal capacity, contractor desktops or a training lab as declarative resources, then tear them down.
Attach a GPU to a desktop for CAD, 3D, GIS, video and graphics workloads — the engineering workstation experience, delivered from a sovereign data centre rather than a tower under a desk.
On the desktop broker and protocol, the honest version. KubeVirt provides the desktop VMs and console access; the user-facing connection broker and remote-display protocol (session brokering, gateway, client) is the piece to confirm for a production VDI rollout. We will tell you precisely what GRN provides versus what you bring or we contract as an add-on. Pending validation
The operational test of any virtualisation platform is what happens on a Tuesday-night patch window. KubeVirt live-migrates a running guest off a host so you can drain it for maintenance — and reschedules VMs when a host fails. There is one hard requirement, and we state it plainly.
A running VM moves between hosts with its memory state intact, for zero-downtime node drains and maintenance. This requires ReadWriteMany storage so both hosts reach the disk: we provide it via Rook Ceph RWX. Confirm GA
If a host dies, affected VMs are rescheduled onto healthy nodes — a dead host becomes an event, not an outage, the same way it would for a container workload.
Per-VM eviction strategy (LiveMigrate or shutdown) tells the platform how to handle a node drain — migrate the stateful guests, cleanly stop the disposable ones.
The requirement, stated up front. Live migration needs shared ReadWriteMany storage so the source and destination hosts both reach the VM's disk — this is a property of how QEMU/KVM migration works, not a GRN limitation. We satisfy it with Ceph RWX. VMs on local-NVMe boot disks cannot live-migrate; they HA-reschedule with a restart instead. Choose the storage class per workload and you choose the failure behaviour with it.
Graphics and compute desktops need a real GPU, not a software framebuffer. KubeVirt exposes host GPUs to guests two ways — full passthrough for a dedicated card, or mediated devices (NVIDIA vGPU) to slice one physical GPU across several desktops. We state which we offer rather than implying both.
A whole physical GPU is bound to a single VM via VFIO for maximum, dedicated performance — for heavy CAD, rendering, simulation or a GPU compute VM that needs the entire card.
One physical GPU is partitioned into mediated devices (NVIDIA vGPU) and shared across several desktops — the cost-efficient route for a fleet of accelerated VDI seats. Confirm mode
GPU node pools, stated honestly. GPU desktops and compute VMs schedule onto dedicated GPU node pools. The exact NVIDIA models, the choice between passthrough and licensed vGPU, and per-seat sizing depend on current hardware — tell us the workload and we will confirm what is available. Confirm GPU models
CDI / DataVolume imports VMDK, qcow2 or raw disks into a Ceph volume
Capture it as a reusable instancetype + preference your team can stamp out
Run via kubectl / virtctl and Argo CD / Flux; we keep the hosts healthy
Scheduled Velero backups and CSI volume snapshots to your RPO/RTO
Drain hosts with live migration on RWX, grow pools, move to GPU nodes
Export disk image and YAML to any KubeVirt cluster — a copy, not a contract
Day-2, addressed honestly. Host patching, KubeVirt upgrades and hardware replacement are ours, run with live migration so guests stay up where storage allows. Guest-OS patching, in-VM software and licensing stay yours — KubeVirt does not manage what runs inside the VM, and we will not pretend it does. Backups are only as good as their last successful restore, so we size and test them against the RPO/RTO you give us. Confirm cadence
A VM's strongest property is its isolation boundary: a guest runs behind the KVM hardware-virtualisation line, with its own kernel, not a shared one. KubeVirt keeps that boundary and adds the Kubernetes primitives your team already audits against.
The fear is a forced rewrite. The reality should be a phased move: bring the VMs across as VMs, run them next to your containers, and modernise the ones worth modernising on your own timeline. KubeVirt is the bridge that makes coexistence the default, not the exception.
On compliance, the honest version. The platform runs under EU-only data residency with a signed DPA and no US Cloud Act exposure — the substantive part of most regulated requirements, and a real advantage for desktops handling personal data. We will support PCI-DSS and HIPAA-aligned, NIS2-ready deployments on dedicated, isolated infrastructure — but we do not claim certifications we do not hold. Tell us your compliance scope and we will tell you precisely what we can and cannot attest to.
The operational and commercial differences you can verify.
EU-owned infrastructure under Dutch jurisdiction — not a US hyperscaler's "European region", which stays subject to the US Cloud Act regardless of where the disk images sit. Your desktops and VM data stay in the EU, with KVM hardware isolation and a signed DPA.
No per-socket, per-core or per-VM hypervisor licence. Storage is a published €/GB-month, networking functions are included free, and annual commitments take 10% off. The Broadcom renewal shock is replaced by an open stack with a price you can read off a page.
Hosted in the Netherlands on 100% renewable solar energy, with server heat reused to warm nearby buildings and peak-shaving to ease grid congestion. Sustainability with a mechanism behind it, not a logo.
KubeVirt is a CNCF project and your VMs are portable disk images plus declarative YAML. There is no proprietary VM format or vendor-only management API in the path — which is the whole argument for moving off a closed hypervisor.
One scheduler, one network fabric, one storage layer, one backup tool and one upgrade calendar for VMs, desktops and containers — instead of two parallel platforms staffed and licensed separately.
The control-plane SLA scales with tier, up to a contractual 99.99% on dedicated infrastructure — backed by redundant control-plane nodes, an etcd quorum and live migration for maintenance.
A layered, cloud-native stack — every layer a portable component.
Your VMs, desktops and containers on top, KVM-enabled renewable-powered hosts at the bottom. Every layer is a named component you could reproduce on any KubeVirt cluster; none of it is a black box you can only run here.
Windows and Linux VMs, pooled virtual desktops and containers — all described as standard Kubernetes resources, deployed via kubectl, virtctl or Argo CD / Flux against one API.
KubeVirt's virt-controller, virt-handler and virt-api turn a VirtualMachine CRD into a running VirtualMachineInstance — a QEMU/KVM guest under libvirt, scheduled into a pod like any other workload. CDI imports and clones disk images.
Multus attaches multiple NICs to a VM: pod-network for cloud-native traffic, plus bridge, VLAN or SR-IOV attachments for line-rate, layer-2 reachability your VMs expect. MetalLB advertises services and desktop endpoints — included free.
CDI / DataVolumes import VMDK and qcow2 disks; Rook Ceph provides ReadWriteMany volumes for live migration and ReadWriteOnce for boot disks; OpenEBS serves local NVMe for latency-sensitive guests; Velero handles VM snapshots and backup.
Bare-metal hosts with CPU virtualisation extensions (Intel VT-x / AMD-V) and, where ordered, NVIDIA GPUs for VDI and compute VMs — EU-owned, in the Netherlands, on 100% renewable solar with server-heat reuse.
Every layer uses standard, portable components — KubeVirt, Ceph, Multus, Velero — nothing proprietary you cannot reproduce on another Kubernetes cluster.
What teams run on it.
Move VMs off vSphere onto an open, Kubernetes-native stack with no per-core hypervisor licence — replacing a renewal shock with a published price.
Windows and Linux virtual desktops for staff and contractors, pooled and provisioned from templates, with data kept inside EU jurisdiction.
A legacy database or appliance VM running next to the containerised services that call it — one namespace, one network, one set of policies.
Licensed or unportable software that will stay a VM for years — given a modern, automated home without a forced rewrite.
CAD, 3D, design and AI workstations as GPU-accelerated desktops — the power of a tower under the desk, delivered from a sovereign data centre.
Finance, healthcare and government VMs and desktops on EU-sovereign, single-tenant infrastructure with a signed DPA — subject to your compliance scope. Review
The detail a virtualisation engineer actually evaluates.
Items tagged for review are confirmed against a live cluster before publishing — we would rather leave a value open than print one we cannot stand behind.
| Virtualisation | KubeVirt (QEMU/KVM under libvirt) on managed Kubernetes |
| Guest OS support | Windows & Linux VMs Confirm matrix |
| VM definition | VirtualMachine / VirtualMachineInstance CRDs |
| Sizing | Instancetypes + preferences; cx1 / m1 / n1 / o1 / rt1 families |
| Live migration | Requires ReadWriteMany (Ceph RWX) Confirm GA |
| Storage classes | Ceph RWX / RWO, OpenEBS local NVMe, Ceph S3 |
| Disk import formats | VMDK, qcow2, raw via CDI / DataVolume |
| Networking | Multus multi-NIC, bridge / VLAN, SR-IOV, MetalLB |
| GPU | Passthrough (VFIO) and/or vGPU (mediated devices) Confirm mode |
| Backup / DR | Velero, CSI snapshots, cross-region replication |
| Migration tooling | Migration Toolkit for Virtualization (Forklift) Pending validation / CDI import |
| Security | KVM isolation, sVirt/SELinux, RBAC, NetworkPolicy |
| API & automation | Standard Kubernetes API, virtctl, GitOps |
| Tenancy | Shared-hardware (VPC) or single-tenant bare-metal (DPC) |
| Control-plane SLA | Up to 99.99% (tier-dependent) |
| Region | Netherlands (EU), 100% renewable-powered |
| Storage class | Implementation | Best for | Price |
|---|---|---|---|
| Shared file (RWX) | Rook Ceph FS | Live-migratable VM & desktop disks | € 0.044 / GB-mo |
| Block (RWO) | Rook Ceph RBD | General VM boot & data disks | € 0.044 / GB-mo |
| Local NVMe | OpenEBS LocalVolume | Latency-sensitive guests (HA-reschedule) | € 0.044 / GB-mo |
| Disk import / clone | CDI + DataVolume | Importing VMDK / qcow2 / raw images | Included |
| S3 object | Ceph ObjectBucketClaim | Image registries, artefacts, archives | € 0.044 / GB-mo |
| Cross-region replication | Ceph VolumeReplication | Geo-redundancy / DR for VMs | € 0.0465 / GB-mo |
| Snapshots & backup | Velero + CSI snapshots | Scheduled VM backup to meet RPO/RTO | € 0.008 / GB-mo |
| Function | Implementation | Price |
|---|---|---|
| Multi-NIC attachment | Multus CNI (additional NetworkAttachmentDefinitions) | Included |
| Layer-2 / bridge & VLAN | Bridge / VLAN attachments — VMs on your existing subnets | Included |
| Line-rate networking | SR-IOV virtual functions for throughput-bound VMs | Included |
| Load balancing / ingress to VMs | MetalLB (Layer 2 / BGP) | Included |
| Pod-network & policy | CNI + NetworkPolicy (default-deny capable) | Included |
| Public / floating IPv4 | MetalLB-advertised address | € 3.00 / mo |
| BYO-IP / BYO-ASN (BGP) | MetalLB BGP peering | € 50.00 / mo |
Dual-stack IPv4 / IPv6 throughout. All storage classes are dynamically provisioned and expandable. Prices in EUR, ex VAT; 10% discount on annual commitment. Verify current rates on the pricing page before quoting.
An objective capability comparison against the major virtualisation platforms. Subjective claims ("faster", "simpler") are left out — only things you can check on a product page or in a licence agreement.
| Capability | GRN.CLOUD KubeVirt | Traditional hypervisors | Hyperscaler | ||
|---|---|---|---|---|---|
| VMware vSphere / VCF | Nutanix AHV | Proxmox VE | Hyperscaler VMs | ||
| Licensing model | No hypervisor licence; published €/GB + tiers | Per-core subscription bundles | Per-core/node subscription | Open source; paid support optional | Metered per-VM-hour |
| Open source / no lock-in | ✓ KubeVirt, CNCF | ✕ Proprietary | ✕ Proprietary | ✓ AGPL | ✕ Proprietary platform |
| VMs + containers unified | ✓ one control plane | ~ via Tanzu add-on | ~ via NKP add-on | ~ VMs + LXC, not K8s-native | ~ separate services |
| Kubernetes-native API | ✓ VMs as CRDs | vCenter API | Prism API | Proxmox API | Cloud-specific API |
| EU sovereignty (non-US-owned) | ✓ Netherlands | ✕ US-owned (Broadcom) | ✕ US-owned | ✓ EU-developed (open) | ✕ US-owned |
| Live migration | ✓ on RWX Confirm GA | ✓ vMotion | ✓ | ✓ | ~ varies / often opaque |
| GPU passthrough / vGPU | ✓ Confirm mode | ✓ vGPU | ✓ | ~ passthrough; vGPU manual | ✓ GPU instances |
| Pricing transparency | Published €/GB, flat tiers | Quote / bundle-gated | ~ quote-based | Public | ~ complex metering |
| Managed control-plane SLA | Up to 99.99% | You operate it | You operate it | You operate it | Cloud SLA varies |
| 100% renewable-powered | ✓ | Depends on your DC | Depends on your DC | Depends on your DC | ~ varies by region |
✓ yes · ~ partial · ✕ no. Compiled from public product & pricing pages, June 2026; vendor features and licensing change — verify before quoting.
The questions a virtualisation engineer actually asks.
KubeVirt is an open-source CNCF project that extends Kubernetes to run virtual machines as first-class workloads. It manages QEMU/KVM guests through standard VirtualMachine resources, so the same cluster schedules VMs, virtual desktops and containers on one control plane. GRN runs it on its managed OKD/OpenShift-based platform.
Real VMs. Each guest is a full QEMU/KVM virtual machine with its own kernel and virtual hardware, running under libvirt — not a container with a VM-shaped label. KubeVirt wraps that guest in a virt-launcher pod so Kubernetes can schedule and manage it, but the isolation boundary is the hardware-virtualisation line, exactly as in a traditional hypervisor.
Yes — KubeVirt runs Windows guests as well as Linux, which is what makes it viable for VDI and for legacy app hosting. You remain responsible for Windows licensing and in-guest patching.
A running VM moves between hosts with its memory state preserved, for zero-downtime maintenance. It requires ReadWriteMany storage so both the source and destination host can reach the disk — we provide that via Rook Ceph RWX. VMs on local-NVMe disks cannot live-migrate; they HA-reschedule with a restart instead.
Yes. The cleanest path is the Migration Toolkit for Virtualization (Forklift), which imports vSphere VMs and disks into KubeVirt; the always-available path is importing your disk images directly with CDI. We will confirm which we run as a managed capability for your estate rather than promise a one-click conversion.
The Containerized Data Importer (CDI) imports and clones disk images — VMDK, qcow2 or raw — into Ceph-backed DataVolumes that your VMs boot from. Importing is the same declarative workflow as everything else: describe the source, and CDI provisions the disk.
KubeVirt supports both full GPU passthrough (a whole card bound to one VM via VFIO) and vGPU via mediated devices (NVIDIA vGPU, one card shared across desktops). Which GRN offers, on which GPU models, depends on current hardware — tell us the workload and we will confirm.
Multus attaches additional NICs to a VM beyond the pod network — bridge or VLAN attachments put a guest directly on your existing layer-2 subnets, and SR-IOV virtual functions give throughput-bound VMs line-rate networking. It is included free.
Scheduled Velero backups and CSI volume snapshots capture VM disk state; cross-region replication via Ceph VolumeReplication covers geo-redundancy. Backup storage is €0.008/GB-month and cross-region replication €0.0465/GB-month, sized to your RPO/RTO targets.
Yes — that is the point. VMs are declarative YAML, so kubectl, virtctl and Argo CD / Flux manage them exactly as they manage containers. Define a desktop fleet in Git, review it as a pull request, and roll it out through your existing pipeline.
Guests run on hardware-accelerated KVM under libvirt — the same technology underneath most Linux virtualisation — so compute is near-native, not emulated. The KubeVirt layer orchestrates the VM; it does not sit in the data path of CPU or memory. Use SR-IOV and local NVMe where a workload is network- or disk-bound.
There is no per-socket, per-core or per-VM hypervisor licence. You pay for the compute tier and published €/GB-month storage, with networking functions included and 10% off on annual commitment — so the Broadcom renewal multiple is replaced by a price you can read off the pricing page. KubeVirt itself is open source.
No. KubeVirt is an open CNCF project and your VMs are portable disk images plus declarative YAML — export them to any KubeVirt cluster. There is no proprietary VM format or vendor-only management API in the path, which is the whole argument for moving off a closed hypervisor in the first place.
The control-plane SLA scales with tier, up to a contractual 99.99% on dedicated infrastructure — backed by redundant control-plane nodes, an etcd quorum and live migration for maintenance. Guest-level availability also depends on your storage choice and eviction strategy, which we design with you.
Genuinely EU-owned infrastructure under Dutch jurisdiction — not a US hyperscaler's "European region", which remains subject to the US Cloud Act regardless of where the desktops and disk images live. EU-only residency, a signed DPA, and no US ownership in the chain.
Run VMs and virtual desktops next to your containers on KubeVirt — an open, Kubernetes-native platform with no per-core licence — or talk to our engineers about a phased exit from VMware without a big-bang rewrite.
100% renewable energy · EU data residency · No US Cloud Act exposure · Open source, no hypervisor lock-in