Skip to content

Chapter 6: Virtualization & Hypervisors

Virtualization lets one physical machine run many isolated operating systems, and it underpins every cloud and almost every data centre. This chapter explains why we virtualize, how hypervisors trap and emulate privileged operations, Type 1 versus Type 2 designs, and the CPU features — VT-x, AMD-V, EPT/NPT, IOMMU, SR-IOV — that make it fast. It then tours the major platforms (KVM/QEMU/libvirt, Hyper-V, VMware vSphere after Broadcom, Xen, Proxmox VE, Nutanix AHV, OpenStack and desktop hypervisors), the VM lifecycle from templates to live migration and HA, microVMs for serverless, how VMs compare with containers, and virtual desktops.

6.1 Why Virtualize? Ideas and a Short History

Virtualization lets one physical computer pretend to be many separate computers, called virtual machines (VMs). A thin layer of software, the hypervisor, shares out the real CPU, memory, disks and network so that each VM runs its own complete operating system as if it owned the hardware. It is the foundation of every public cloud and of almost every company data centre.

Virtualization began on 1960s mainframes and returned with x86 servers around 2000.
Six decades of virtualization. Virtualization began on 1960s mainframes and returned with x86 servers around 2000.

Think of it like…

A physical server is like a big house where one family uses only the kitchen; virtualization turns it into a block of flats — each household (VM) gets its own front door, rooms and lock, while sharing the building's foundations, plumbing and electricity (the hardware).

Real-world example

The fictional Pinewood Insurance had 60 physical servers, most using under 10% of their CPU. Systems engineer Grace consolidates them as VMs onto four modern hosts. Power and cooling costs drop sharply, new servers are ready in ten minutes instead of six weeks, and when one host fails its VMs restart automatically on the others.

How it works

  1. Install a hypervisor on the physical host (or use a cloud provider's).
  2. Create VMs, each with virtual CPUs, memory, disks and network cards drawn from the host's pools.
  3. Install a guest operating system and applications inside each VM, exactly as on a physical server.
  4. The hypervisor schedules vCPUs onto real cores, maps guest memory to real RAM and routes virtual I/O to real devices.
  5. Management tools add snapshots, templates, live migration and high availability across many hosts.

Who uses it

Systems administrators, cloud and infrastructure engineers, data-centre architects, DevOps teams, security researchers who analyse malware safely and students building home labs.

Key takeaway

Know the core benefits for interviews: consolidation (higher utilisation), isolation, encapsulation (a VM is just files), hardware independence, and fast provisioning, snapshots and migration.

Going deeper

  • IBM's CP-40 (1967) and CP-67 ran several copies of an OS on one mainframe; VM/370 (1972) made it a product, and IBM z/VM still runs thousands of Linux guests on today's IBM Z mainframes.
  • Before virtualization, x86 servers commonly ran one application each at roughly 5-15% average CPU utilisation; consolidation ratios of 10:1 or more were the original business case.
  • VMware (founded 1998) made x86 virtualization practical with Workstation in 1999 and ESX Server in 2001, using binary translation because x86 could not be virtualized by trapping alone.
  • Amazon EC2 launched in 2006 on the Xen hypervisor; from 2017 AWS moved to its Nitro system, a KVM-based hypervisor with I/O offloaded to dedicated Nitro cards.
  • Encapsulation means a VM is a handful of files (configuration, disks, memory state), which is what makes copying, backing up, snapshotting and migrating whole servers possible.
  • Hypervisors also enable isolation for security: Windows VBS, Android's protected VMs, Qubes OS and cloud multi-tenancy all rely on the hypervisor as a strong boundary.

Common mistakes & misconceptions

  • Thinking virtualization makes software faster — it adds a small overhead (often a few percent for CPU-bound work); the gains are utilisation, flexibility and recovery.
  • Confusing virtualization with emulation — a hypervisor runs guest code directly on the same CPU architecture; emulators like QEMU's TCG translate other architectures, far slower.
  • Assuming more VMs is always better — oversubscribing CPU and memory causes contention, ballooning and swapping that hurt every VM on the host.

Try it: Check whether your own CPU supports hardware virtualization

# Linux: count CPU threads that advertise Intel VT-x (vmx) or AMD-V (svm)
grep -Ec '(vmx|svm)' /proc/cpuinfo
ls -l /dev/kvm 2>/dev/null && echo 'KVM ready'
# Windows (PowerShell): look for 'Virtualization Enabled In Firmware'
systeminfo | Select-String 'Hyper-V|Virtualization'
# macOS on Apple silicon: hardware virtualization is always available
sysctl kern.hv_support

Key kernels, commands, tools, standards & concepts

Name What it does Example
Virtual machine (VM)
General · Concept · Current · Beginner
A software-defined computer with virtual CPU, memory, disk and network devices, running its own operating system. A developer runs Windows Server 2025, Ubuntu and a firewall appliance as three VMs on one laptop.
Hypervisor (virtual machine monitor)
General · Concept · Current · Beginner
The software layer that creates VMs, shares hardware between them and keeps them isolated. ESXi, Hyper-V, KVM and Xen are hypervisors; each can host dozens of VMs per server.
Server consolidation
General · Concept · Current · Beginner
Running many lightly loaded workloads as VMs on fewer, busier physical servers. Pinewood replaces 60 servers at under 10% CPU with four hosts running about 70% average.
Encapsulation
General · Concept · Current · Beginner
A whole VM is stored as files — configuration, virtual disks and saved state — that can be copied and moved. An admin copies a VM's .vmx and .vmdk files to another datastore to clone a test server.
Isolation
General · Concept · Current · Beginner
VMs cannot see each other's memory or disks; a crash or compromise in one should not affect the others. A malware analyst detonates ransomware inside a VM, then reverts it, leaving the host untouched.
Guest and host
General · Concept · Current · Beginner
The host is the physical machine running the hypervisor; guests are the operating systems inside VMs. A Windows 11 host runs an Ubuntu guest in VirtualBox for a Linux course.
IBM CP-40 / CP-67 / VM/370
IBM (1967-1972) · Operating system · Legacy · Intermediate
Pioneering mainframe systems that ran multiple full virtual machines, establishing the hypervisor idea. Students on 1970s mainframes each had a private virtual machine running the CMS single-user OS.
IBM z/VM
IBM · Software · Current · Advanced
Today's descendant of VM/370, hosting large numbers of Linux and z/OS guests on IBM Z mainframes. A bank consolidates hundreds of Linux servers as guests under z/VM on a single mainframe.
Hardware independence
General · Concept · Current · Beginner
VMs see standard virtual hardware, so they can move between different physical server models without reinstalling. Pinewood moves its VMs from old Dell hosts to new HPE hosts without changing drivers inside the guests.
Emulation vs virtualization
General · Concept · Current · Intermediate
Emulation interprets or translates another CPU's instructions; virtualization runs guest code natively on the same CPU type. QEMU emulates an Arm board on an x86 PC slowly, but with KVM it virtualizes x86 guests at near-native speed.
Amazon EC2 and Nitro
Amazon Web Services (2006; Nitro 2017) · Platform · Current · Intermediate
AWS's VM service, first built on Xen, now on the Nitro hypervisor with networking and storage on dedicated cards. Launching an m7i.large instance starts a Nitro-based VM with 2 vCPUs and 8 GiB of memory in about a minute.
Virtualization overhead
General · Concept · Current · Intermediate
The extra cost of VM exits, address translation and virtual I/O; small with hardware assist and paravirtual drivers. A CPU-bound benchmark runs within a few percent of bare metal, but an emulated disk is much slower than virtio.
Multi-tenancy
General · Concept · Current · Intermediate
Running workloads from different customers or teams on shared hardware, relying on the hypervisor for isolation. Two competing retailers' VMs may share one cloud host without ever seeing each other's data.

6.2 How a Hypervisor Works: Popek-Goldberg and Trap-and-Emulate

A guest OS expects to control the CPU completely, but the hypervisor cannot allow that. The classic trick is trap-and-emulate: run the guest kernel with reduced privileges, so whenever it tries a privileged operation the CPU 'traps' to the hypervisor, which performs a safe, virtual version of the operation and resumes the guest. Popek and Goldberg proved in 1974 exactly when this works.

Privileged instructions trap and are emulated; on pre-2005 x86, some sensitive ones silently did not trap.
Trap-and-emulate in action. Privileged instructions trap and are emulated; on pre-2005 x86, some sensitive ones silently did not trap.

Think of it like…

Trap-and-emulate is like a hotel guest trying to adjust the building's main thermostat: the panel is locked, so a staff member appears, adjusts only the temperature in that guest's room, and lets the guest believe they changed the setting.

Real-world example

Ravi, a student at the fictional Westbridge Polytechnic, writes a toy hypervisor for an OS course. When his guest kernel executes HLT to idle, the CPU exits to his code; he marks the vCPU idle and runs another VM. When the guest reads CPUID, his hypervisor hides the host's real model and reports a generic CPU — trap-and-emulate in action.

How it works

  1. The hypervisor runs at the highest privilege; the guest kernel runs deprivileged (classically ring 1 or 3, today VMX non-root mode).
  2. Ordinary instructions (adds, loads, most jumps) run directly on the CPU at full speed.
  3. A privileged or sensitive instruction (such as changing page tables or disabling interrupts) traps to the hypervisor.
  4. The hypervisor decodes the instruction and applies it to the VM's virtual CPU state and virtual devices only.
  5. The hypervisor resumes the guest at the next instruction; the guest never notices the detour.

Who uses it

Hypervisor and kernel developers, cloud platform engineers, security researchers studying VM escapes, and students on operating-systems courses.

Key takeaway

State the Popek-Goldberg theorem precisely: an efficient VMM can be built if every sensitive instruction is also privileged (so it traps); classic x86 broke this rule.

Going deeper

  • Popek and Goldberg's 1974 paper 'Formal Requirements for Virtualizable Third Generation Architectures' defines three VMM properties: equivalence (fidelity), resource control (safety) and efficiency (most instructions run natively).
  • Sensitive instructions read or change machine state (control registers, interrupt flags, I/O); privileged instructions trap when run outside the most privileged mode. Virtualizable means sensitive is a subset of privileged.
  • A 2000 analysis by Robin and Irvine found 17 sensitive but unprivileged instructions on the Pentium, including POPF, PUSHF, SGDT, SIDT, SMSW, LAR and LSL — the reason x86 needed binary translation or paravirtualization.
  • Three historical answers to x86's flaw: binary translation (VMware 1999), paravirtualization where the guest calls the hypervisor explicitly (Xen 2003), and hardware assist that adds a new guest mode (Intel VT-x 2005, AMD-V 2006).
  • Memory is the hardest part: early hypervisors kept shadow page tables that mirrored every guest page-table change, causing many exits until EPT and NPT moved this into hardware.
  • Each VM exit and re-entry costs from hundreds to a few thousand CPU cycles, so hypervisor engineering is largely about avoiding exits — for example with posted interrupts and paravirtual devices.
  • A bug in the hypervisor's emulation code can become a 'VM escape'; the 2015 VENOM flaw in QEMU's virtual floppy controller (CVE-2015-3456) is a famous example.

Common mistakes & misconceptions

  • Assuming the guest runs in an emulator — with trap-and-emulate nearly all guest instructions run natively; only a small fraction trap.
  • Thinking 'privileged' and 'sensitive' mean the same — the gap between them is exactly what made classic x86 hard to virtualize.
  • Believing VMs are perfectly invisible — timing differences, CPUID flags and virtual device names let software detect it is in a VM.

Try it: See VM exits happening on a Linux KVM host (needs root and a running VM)

# Summarise KVM exit reasons for 10 seconds (perf with KVM support)
sudo perf kvm stat record -a sleep 10
sudo perf kvm stat report
# Or count exits through tracepoints
sudo perf stat -e 'kvm:kvm_exit' -a sleep 5

Key kernels, commands, tools, standards & concepts

Name What it does Example
Popek and Goldberg virtualization requirements
Gerald Popek and Robert Goldberg (1974) · Concept · Current · Intermediate
Formal conditions for building an efficient VMM: sensitive instructions must be a subset of privileged ones. Exam answer: classic x86 failed because POPF changed interrupt state without trapping in user mode.
Equivalence, resource control, efficiency
Popek and Goldberg (1974) · Concept · Current · Intermediate
The three properties of a VMM: behave like real hardware, keep full control of resources, run most code natively. An emulator meets equivalence and control but fails efficiency because every instruction is interpreted.
Innocuous instruction
Popek and Goldberg · Concept · Current · Intermediate
An instruction that is neither privileged nor sensitive, so a guest can run it directly at full speed. Arithmetic, loads, stores and most jumps are innocuous — the bulk of guest code never involves the hypervisor.
Sensitive instruction
Popek and Goldberg · Concept · Current · Intermediate
An instruction that reads or modifies privileged machine state or behaves differently depending on privilege level. SGDT reveals the real descriptor-table address even to a deprivileged guest on classic x86.
Trap-and-emulate
General · Concept · Current · Beginner
Running the guest deprivileged so privileged operations trap to the hypervisor, which emulates them virtually. A guest writing to an emulated serial port traps, and the hypervisor appends the byte to a log file.
VM exit and VM entry
Intel VT-x, AMD-V · Concept · Current · Intermediate
The hardware switch from guest to hypervisor (exit) and back (entry), saving and restoring CPU state. perf kvm stat shows EPT_VIOLATION and IO_INSTRUCTION as the most common exit reasons on a busy host.
Ring deprivileging
x86 (pre-VT-x hypervisors) · Concept · Legacy · Advanced
Running guest kernels in ring 1 or ring 3 instead of ring 0 so the hypervisor can keep ring 0. 32-bit Xen ran paravirtual guest kernels in ring 1, using x86 segmentation to protect itself.
Shadow page tables
VMware, Xen, KVM (pre-EPT/NPT) · Concept · Legacy · Advanced
Hypervisor-maintained page tables mapping guest virtual addresses directly to host physical addresses. On a 2006 server, a fork-heavy guest workload caused thousands of exits per second to update shadow tables.
Binary translation
VMware (1999) · Concept · Legacy · Advanced
Translating guest kernel code at run time, replacing sensitive instructions with safe calls into the VMM. VMware's translator cached translated code blocks, so repeated kernel paths ran almost at native speed.
Paravirtualization (concept)
Xen (2003), Denali · Concept · Current · Intermediate
Modifying the guest OS to call the hypervisor directly (hypercalls) instead of relying on traps. A Xen PV Linux guest asks the hypervisor via hypercall to update page tables in batches.
Hypercall
Xen, KVM, Hyper-V · Concept · Current · Intermediate
A deliberate call from the guest kernel to the hypervisor, analogous to a system call from an app to a kernel. A Hyper-V-enlightened Windows guest uses a hypercall to flush remote TLBs efficiently.
VM escape
General (e.g. VENOM, CVE-2015-3456) · Attack · Current · Advanced
Exploiting a hypervisor or virtual-device bug so code inside a VM runs on the host or in other VMs. VENOM let a guest overflow QEMU's floppy controller buffer, forcing urgent patches across clouds.
VM detection (red pills)
Security research · Concept · Current · Advanced
Techniques software uses to notice it runs in a VM: CPUID hypervisor bit, device names, timing anomalies. Some malware checks for VirtualBox Guest Additions and exits to evade analysis sandboxes.

6.3 Type 1 vs Type 2 Hypervisors

Hypervisors come in two classic kinds. A Type 1 ('bare-metal') hypervisor runs directly on the server hardware and is the operating system of the host — examples are VMware ESXi, Microsoft Hyper-V, Xen and KVM-based platforms. A Type 2 ('hosted') hypervisor is an application running on an ordinary desktop OS, such as VirtualBox or VMware Workstation.

Type 1 vs Type 2 at a glance

Type 1 (bare metal) Type 2 (hosted)
Runs on hardware directly a desktop operating system
Examples ESXi, Hyper-V, Xen, KVM, AHV VirtualBox, Workstation, Parallels
Performance near native, low jitter good, shares host resources
Attack surface small, dedicated host OS bugs add risk
Management remote consoles, clusters, APIs local GUI on one machine
Features HA, live migration, SDN snapshots, shared folders
Typical user data centres, clouds developers, students, testers

The line blurs (KVM, Hyper-V), but the operational difference — server platform vs desktop app — remains useful.

Think of it like…

A Type 1 hypervisor is like a purpose-built apartment block managed by a building company; a Type 2 hypervisor is like renting out spare rooms in your own family house — it works, but the household (host OS) comes first.

Real-world example

The fictional Elm Street Clinic runs its patient-records system on two Type 1 hosts (Proxmox VE) in a locked server room. Its IT contractor, Lucas, uses VMware Workstation Pro (Type 2) on his laptop to test a software upgrade on a copy of the records VM before applying it to production.

How it works

  1. Type 1: power on the server and it boots straight into the hypervisor, which owns CPU scheduling and memory.
  2. Type 1: VMs are created and managed remotely through a web console or API, often across a cluster.
  3. Type 2: install the hypervisor app on Windows, macOS or Linux and start it like any program.
  4. Type 2: the host OS schedules the hypervisor process; a kernel driver gives it access to hardware virtualization.
  5. Both: guests see virtual hardware and run unmodified operating systems using CPU virtualization extensions.

Who uses it

Infrastructure engineers choose Type 1 for production servers; developers, testers, students and security analysts use Type 2 on their workstations.

Key takeaway

Classic interview point: KVM turns the Linux kernel itself into the hypervisor, and Hyper-V runs beneath Windows (which becomes the 'root partition'), so both are usually classed as Type 1 even though a full OS appears to be present.

Going deeper

  • The terms come from Robert Goldberg's 1973 PhD thesis on virtual machine architectures, long before x86 virtualization existed.
  • KVM is a Linux kernel module; once loaded, Linux schedules vCPUs as ordinary threads and manages guest memory with its normal memory manager, which is why KVM inherits Linux's scheduler, NUMA and cgroups features.
  • When Hyper-V is enabled on Windows 11 or Server, the hypervisor loads first and the Windows you log in to becomes the privileged root partition — which is also how VBS, WSL 2 and Windows Sandbox work.
  • Type 2 hypervisors use the host's virtualization APIs: on Windows many now run on top of Hyper-V's Windows Hypervisor Platform, and on macOS they use Apple's Hypervisor.framework or Virtualization.framework.
  • ESXi's VMkernel is a purpose-built kernel with a small footprint; it can boot from a small device, while vCenter handles cluster-wide management separately.
  • Some classify 'hosted' Type 1 designs separately (Hyper-V root partition, Xen dom0), but in exams the simple rule — runs on hardware vs runs on an OS — is what is expected.

Common mistakes & misconceptions

  • Saying Hyper-V is Type 2 because Windows is visible — the hypervisor runs underneath Windows, which is itself a privileged VM.
  • Running production servers on a Type 2 hypervisor on a desktop PC — you lose HA, remote management and isolation from desktop activity.
  • Assuming two Type 2 hypervisors cannot coexist — modern VirtualBox and VMware Workstation can run on Windows with Hyper-V enabled, though sometimes more slowly.

Try it: Find out whether you are inside a VM, and which hypervisor

# Linux
systemd-detect-virt          # prints kvm, microsoft, vmware, oracle, xen ... or none
lscpu | grep -i hypervisor
# Windows PowerShell
(Get-CimInstance Win32_ComputerSystem).Model    # 'Virtual Machine', 'VMware...' etc.
(Get-CimInstance Win32_ComputerSystem).HypervisorPresent

Key kernels, commands, tools, standards & concepts

Name What it does Example
Type 1 (bare-metal) hypervisor
Goldberg (1973) · Concept · Current · Beginner
A hypervisor running directly on hardware and acting as the host's operating system. A data-centre server boots ESXi from local flash and runs 40 VMs.
Type 2 (hosted) hypervisor
Goldberg (1973) · Concept · Current · Beginner
A hypervisor running as an application on a conventional host operating system. A student installs VirtualBox on Windows 11 to run Kali Linux for a security course.
VMware ESXi
Broadcom (VMware) · Software · Current · Beginner
VMware's Type 1 hypervisor built on the VMkernel, managed individually or through vCenter. An ESXi host's web client shows CPU ready time to diagnose an overloaded VM.
Microsoft Hyper-V
Microsoft (2008) · Software · Current · Beginner
Microsoft's Type 1 hypervisor in Windows Server and Windows Pro/Enterprise, with Windows as the root partition. Enabling Hyper-V on Windows 11 Pro lets a developer run Linux VMs from Hyper-V Manager.
KVM
Linux kernel (2007) · Software · Current · Beginner
Kernel-based Virtual Machine: a Linux module that turns the kernel into a Type 1 hypervisor. OpenStack, Proxmox VE and Google Compute Engine all run guest VMs on KVM.
Xen
Xen Project, Linux Foundation (2003) · Software · Current · Intermediate
A microkernel-style Type 1 hypervisor with a privileged control domain (dom0) managing guests. XCP-ng hosts boot Xen first, then a Linux dom0 that manages storage and networking.
Hypervisor attack surface
General · Concept · Current · Intermediate
The code a guest can reach — emulated devices, hypercalls, the host OS — which attackers target for VM escapes. A Type 2 hypervisor inherits every vulnerability of the desktop OS underneath it, unlike a minimal ESXi host.
Hosted hypervisor kernel drivers
Oracle (vboxdrv), Broadcom (vmmon) · Component · Current · Advanced
Type 2 hypervisors install a kernel driver that switches the CPU into guest mode on behalf of the user-space app. After a Linux kernel update, VirtualBox VMs fail until the vboxdrv module is rebuilt for the new kernel.
Root partition / control domain
Hyper-V, Xen (dom0) · Concept · Current · Intermediate
A privileged VM that owns physical device drivers and management tools on some Type 1 hypervisors. Rebooting the Windows root partition of a Hyper-V host restarts every guest on that host.
Windows Hypervisor Platform (WHP)
Microsoft · API · Current · Advanced
An API letting third-party virtualization software run guests on top of the Hyper-V hypervisor. VirtualBox and QEMU use WHP on Windows when Hyper-V or VBS is already enabled.
Apple Hypervisor and Virtualization frameworks
Apple (macOS 10.10+, 11+) · API · Current · Advanced
macOS APIs giving apps hardware-accelerated VMs; Virtualization.framework adds ready-made virtio devices. UTM and Parallels Desktop run Linux and macOS guests on Apple silicon through these frameworks.
Bare-metal server
General · Concept · Current · Beginner
A physical server dedicated to one tenant, without a hypervisor or with one the customer controls. A trading firm rents bare-metal cloud servers to avoid hypervisor jitter for latency-sensitive code.

6.4 Hardware-Assisted Virtualization: VT-x, AMD-V, EPT/NPT, IOMMU, Nesting and Confidential VMs

Since 2005-2006, Intel and AMD processors include special virtualization instructions that add a new 'guest mode', so the hypervisor no longer needs tricks like binary translation. Later additions translate guest memory addresses in hardware (EPT/NPT), let devices be safely handed to VMs (IOMMU), allow hypervisors inside VMs (nested virtualization) and even encrypt VM memory from the host (confidential VMs).

The guest controls stage 1; the hypervisor controls stage 2 — both walked by hardware.
Two-stage address translation with EPT/NPT. The guest controls stage 1; the hypervisor controls stage 2 — both walked by hardware.

Think of it like…

Hardware assist is like a building adding a proper concierge desk and keycard system: instead of staff following guests around (software tricks), the doors themselves know which rooms each keycard may open, and the concierge is called only when something unusual happens.

Real-world example

Wei, a cloud engineer at the fictional Tidewater Hosting, compares two servers: an old one without EPT and a new one with it. A memory-heavy Java service runs about 20% faster on the new host because guest page-table updates no longer cause VM exits. For a healthcare customer she enables AMD SEV-SNP so even Tidewater's administrators cannot read that VM's memory.

How it works

  1. The hypervisor enables virtualization (VMXON on Intel, EFER.SVME on AMD) and sets up a control structure per vCPU (VMCS or VMCB).
  2. VM entry (VMLAUNCH/VMRESUME or VMRUN) loads guest state and runs the guest in non-root (guest) mode.
  3. The guest runs natively until an event configured to exit occurs — for example CPUID, I/O port access, an EPT violation or an external interrupt.
  4. On a VM exit the CPU saves guest state and jumps to the hypervisor, which handles the reason and resumes the guest.
  5. Memory accesses go through two-stage translation (guest page tables, then EPT/NPT), cached in a TLB tagged per VM (VPID/ASID).

Who uses it

Hypervisor and cloud platform engineers, performance engineers, firmware engineers, security researchers and anyone sizing servers for virtualization.

Key takeaway

Know the vendor names: Intel VT-x + EPT + VT-d; AMD-V (SVM) + NPT/RVI + AMD-Vi; Arm EL2 + Stage-2 translation + SMMU. Virtualization must often be switched on in UEFI setup.

Going deeper

  • Intel VT-x first shipped in late 2005 Pentium 4 models and AMD-V (SVM, codenamed Pacifica) in 2006; second-level translation followed with AMD's Rapid Virtualization Indexing (Barcelona, 2007) and Intel EPT (Nehalem, 2008).
  • With 4-level tables on both stages, a worst-case TLB miss needs up to 24 memory references instead of 4, which is why large pages (2 MB, 1 GB) and big TLBs matter so much to VM performance.
  • VPID (Intel) and ASID (AMD) tag TLB entries with a VM identifier so the TLB need not be flushed on every VM switch; APICv/AVIC and posted interrupts deliver interrupts to guests without exits.
  • An IOMMU (Intel VT-d, AMD-Vi, Arm SMMU) translates and restricts device DMA, so a device assigned to a VM can only reach that VM's memory — essential for passthrough and SR-IOV.
  • On Arm, hypervisors run at exception level EL2 with Stage-2 translation; the Virtualization Host Extensions (ARMv8.1) let a host kernel such as Linux/KVM run entirely in EL2 for lower overhead.
  • Nested virtualization runs a hypervisor inside a VM; Intel VMCS shadowing reduces its cost, and clouds such as Azure and Google Cloud offer it on selected VM types for labs, CI and WSL inside VMs.
  • Confidential VMs encrypt guest memory with keys the host cannot read: AMD SEV (2016), SEV-ES and SEV-SNP (EPYC 7003, 2021), Intel TDX (Xeon, from 2023) and Arm CCA Realms (Armv9), all with remote attestation.

Common mistakes & misconceptions

  • Forgetting to enable VT-x/AMD-V or the IOMMU in UEFI setup — many PCs ship with them off, and hypervisors then fail or fall back to slow emulation.
  • Expecting nested virtualization to be fast — every level multiplies exits; use it for labs and testing, not heavy production workloads.
  • Assuming confidential VMs protect against bugs in your own guest OS — they protect memory from the host and operator, not from an attacker inside the VM.

Try it: Inspect virtualization features of your CPU (Linux)

grep -o -E 'vmx|svm|ept|npt|vpid' /proc/cpuinfo | sort | uniq -c
cat /sys/module/kvm_intel/parameters/nested 2>/dev/null   # Y/1 = nested enabled (Intel)
cat /sys/module/kvm_amd/parameters/nested 2>/dev/null     # AMD
dmesg | grep -i -E 'DMAR|AMD-Vi|IOMMU' | head -5

Key kernels, commands, tools, standards & concepts

Name What it does Example
Intel VT-x
Intel (2005) · Concept · Current · Intermediate
Intel's CPU virtualization extensions adding VMX root (hypervisor) and non-root (guest) modes. The 'vmx' flag in /proc/cpuinfo tells you KVM can use VT-x on that machine.
AMD-V (SVM)
AMD (2006) · Concept · Current · Intermediate
AMD's Secure Virtual Machine extensions, entering guests with VMRUN and a VMCB control block. The 'svm' flag on a Ryzen laptop shows AMD-V is available once enabled in firmware setup.
VMCS / VMCB
Intel / AMD · Concept · Current · Advanced
Per-vCPU in-memory control structures holding guest state, host state and which events cause VM exits. KVM sets the VMCS to exit on CPUID so it can hide host CPU features from guests.
EPT / NPT (second-level address translation)
Intel (2008) / AMD (2007) · Concept · Current · Intermediate
Hardware page tables mapping guest-physical to host-physical memory, removing shadow page tables. Tidewater's memory-heavy Java service runs faster on hosts with EPT because page-table changes no longer exit.
VPID / ASID
Intel / AMD · Concept · Current · Advanced
TLB tags identifying which VM an address translation belongs to, avoiding full TLB flushes on VM switches. Two busy VMs on one core keep their cached translations because their TLB entries carry different VPIDs.
APICv, AVIC and posted interrupts
Intel / AMD · Concept · Current · Advanced
Hardware support for virtual interrupt controllers so interrupts reach guests without VM exits. A network-heavy VM handles more packets per second once posted interrupts are enabled.
IOMMU (Intel VT-d, AMD-Vi, Arm SMMU)
Intel, AMD, Arm · Component · Current · Intermediate
Translates and restricts device DMA addresses, enabling safe device assignment to VMs. Booting Linux with intel_iommu=on lets an admin pass a GPU through to a VM using VFIO.
Arm EL2 and VHE
Arm (ARMv7-A virtualization extensions; ARMv8.1 VHE) · Concept · Current · Advanced
Arm's hypervisor exception level and the extension letting a host OS kernel run directly in EL2. KVM on an AWS Graviton or Ampere server runs the host kernel in EL2 using VHE.
Nested virtualization
Intel, AMD, KVM, Hyper-V, clouds · Concept · Current · Intermediate
Running a hypervisor inside a VM, with the outer hypervisor emulating virtualization extensions to it. A trainer runs a three-node Proxmox lab inside cloud VMs that support nested virtualization.
VMCS shadowing
Intel (Haswell, 2013) · Concept · Current · Advanced
Lets a nested hypervisor read and write its VMCS without exiting to the outer hypervisor every time. Nested KVM on a modern Xeon spends far fewer cycles in exits thanks to VMCS shadowing.
AMD SEV-SNP
AMD (EPYC, 2021) · Concept · Current · Advanced
Encrypts each VM's memory with its own key and adds integrity protection plus attestation against a malicious host. A hospital runs patient analytics in Azure confidential VMs backed by SEV-SNP.
Intel TDX (Trust Domain Extensions)
Intel (Xeon, 2023+) · Concept · Current · Advanced
Runs VMs as isolated 'trust domains' whose memory and CPU state are hidden from the hypervisor. Google Cloud's C3 confidential VMs use TDX so customers can attest the guest before sending secrets.
Arm Confidential Compute Architecture (CCA)
Arm (Armv9-A) · Concept · Emerging · Advanced
Adds 'Realms' — protected VM environments isolated from both the normal-world hypervisor and the OS. Future Arm servers can run a Realm VM whose memory even the cloud host's hypervisor cannot read.
Hardware performance of virtualization
General · Concept · Current · Intermediate
With VT-x/AMD-V, EPT/NPT and paravirtual I/O, typical CPU-bound workloads run within a few percent of bare metal. A benchmark compiling the Linux kernel takes 102 seconds on bare metal and 105 in a KVM VM.

6.5 Virtual I/O: Emulation, Paravirtualization, virtio, Passthrough and SR-IOV

A VM needs disks, network cards and graphics, but the real devices are shared. Hypervisors offer three main options: emulate a well-known real device (most compatible, slowest), provide a paravirtual device designed for VMs such as virtio (fast, needs a driver), or hand a real device directly to the VM with passthrough or SR-IOV (fastest, least flexible).

Shared-memory rings let one notification move a whole batch of packets.
A network packet's path with virtio-net and vhost-net. Shared-memory rings let one notification move a whole batch of packets.

Think of it like…

Device I/O is like getting post in a shared building: emulation is a concierge who opens and retypes every letter, paravirtualization is a shared post room with labelled pigeonholes, and passthrough gives your flat its own private letterbox on the street.

Real-world example

At the fictional Copperleaf Games studio, a build server VM uses an emulated e1000 network card and only reaches 2 Gbit/s. Systems engineer Ines switches it to virtio-net with vhost-net, and throughput rises close to the 25 Gbit/s link. For the GPU-rendering VM she passes an entire graphics card through using VFIO and the IOMMU.

How it works

  1. Emulated device: the guest's normal driver touches virtual registers, each access traps, and QEMU or the hypervisor mimics the real hardware.
  2. Paravirtual device: the guest's virtio driver puts requests in shared-memory queues (virtqueues) and sends one notification for a batch.
  3. The back end (QEMU, vhost in the host kernel or vhost-user in a user-space switch) processes the queue and talks to real hardware.
  4. Passthrough: the IOMMU maps a physical device into the VM, and the guest's native driver controls it directly.
  5. SR-IOV: one physical card exposes many Virtual Functions, each passed to a different VM with near-native performance.

Who uses it

Virtualization and cloud engineers, network and storage engineers, performance tuners, GPU/AI infrastructure teams and telecom (NFV) engineers.

Key takeaway

Rule of thumb: always use paravirtual drivers (virtio, Hyper-V synthetic devices, VMware VMXNET3/PVSCSI) for production VMs; use passthrough or SR-IOV only when you need maximum performance or a specific device.

Going deeper

  • Full emulation (QEMU's e1000, IDE, Cirrus VGA) works with any guest OS out of the box but costs a VM exit per register access, limiting throughput and adding latency.
  • virtio, introduced for Linux by Rusty Russell around 2007-2008, is now an OASIS standard (VIRTIO 1.x) defining devices such as virtio-net, virtio-blk, virtio-scsi, virtio-fs, virtio-gpu, virtio-vsock and the memory balloon.
  • vhost-net moves the virtio back end into the host kernel; vhost-user moves it into a user-space process such as a DPDK-based switch; vDPA lets real NICs implement the virtio data path in hardware.
  • SR-IOV (PCI-SIG, 2007) splits a device into one Physical Function and many Virtual Functions; NICs commonly offer 64-256 VFs, giving VMs near line-rate networking but complicating live migration.
  • On Linux, device passthrough uses VFIO with the IOMMU; devices are assigned by IOMMU group, so devices that share a group must be passed through together.
  • GPU sharing options include full passthrough, NVIDIA vGPU time-slicing, and NVIDIA Multi-Instance GPU (MIG, from A100 in 2020) that partitions one GPU into up to seven hardware-isolated instances.
  • Each platform has its own paravirtual stack: Xen split drivers (netfront/netback), Hyper-V VMBus synthetic devices, VMware VMXNET3 and PVSCSI; Windows guests on KVM need the virtio-win drivers.

Common mistakes & misconceptions

  • Installing a Windows guest on KVM without virtio-win drivers — setup cannot see a virtio disk; load the driver ISO during installation.
  • Using passthrough everywhere 'for speed' — passthrough and SR-IOV VMs usually cannot live-migrate or snapshot memory easily.
  • Ignoring IOMMU groups — passing through one device of a shared group fails or exposes other devices to the VM.

Try it: Check which virtual devices a Linux VM is using

lspci -nn | grep -i -E 'virtio|vmware|hyper-v|ethernet|vga'
ls /sys/bus/virtio/drivers/          # virtio_net, virtio_blk ...
ethtool -i eth0 2>/dev/null || ethtool -i enp1s0   # driver: virtio_net
lsblk -o NAME,SIZE,TYPE,TRAN

Key kernels, commands, tools, standards & concepts

Name What it does Example
Device emulation
QEMU, VMware, Hyper-V · Concept · Current · Beginner
The hypervisor imitates a well-known real device so unmodified guests can use their standard drivers. An old Windows XP VM works with an emulated Intel e1000 NIC without extra drivers.
virtio
OASIS VIRTIO Technical Committee · Specification · Current · Intermediate
Standard family of paravirtual devices using shared-memory queues, supported by KVM, cloud VMs and many OSes. Every new KVM VM in Proxmox defaults to a VirtIO SCSI disk controller and virtio-net NIC.
Virtqueue
OASIS VIRTIO · Concept · Current · Advanced
A ring of buffer descriptors in shared memory used by virtio drivers and devices to exchange requests. A virtio-blk driver posts 32 read requests to the virtqueue, then sends one notification.
vhost-net and vhost-user
Linux kernel, QEMU, DPDK · Component · Current · Advanced
Move virtio back-end processing into the host kernel (vhost-net) or a user-space switch (vhost-user). A telecom NFV host uses vhost-user with OVS-DPDK to reach millions of packets per second per VM.
vDPA (virtio data path acceleration)
Linux kernel, NIC vendors · Concept · Emerging · Advanced
Hardware NICs implement the virtio data path so guests keep standard virtio drivers at hardware speed. A cloud provider offloads virtio-net to SmartNICs while VMs still see ordinary virtio devices.
virtio-win drivers
Red Hat / Fedora project · Software · Current · Intermediate
Signed Windows drivers for virtio disks, network, balloon and the QEMU guest agent. Ines mounts virtio-win.iso during Windows Server setup so the installer detects the VirtIO SCSI disk.
PCI passthrough (VFIO)
Linux kernel (VFIO), IOMMU · Concept · Current · Advanced
Assigning a physical PCI device exclusively to one VM so its native driver controls it directly. A rendering VM gets a whole GPU via VFIO and reaches about the same frame rate as bare metal.
SR-IOV
PCI-SIG (2007) · Specification · Current · Advanced
Lets one PCIe device present many lightweight Virtual Functions, each assignable to a different VM. A 100 GbE NIC exposes 64 VFs so 64 VMs each get hardware-accelerated networking.
NVIDIA vGPU and MIG
NVIDIA · Software · Current · Advanced
Ways to share data-centre GPUs between VMs: time-sliced virtual GPUs or hardware-partitioned GPU instances. An AI lab splits one GPU into seven MIG instances for seven students' notebook VMs.
VMBus and synthetic devices
Microsoft Hyper-V · Component · Current · Intermediate
Hyper-V's channel-based paravirtual bus connecting guest drivers (VSCs) to root-partition services (VSPs). A Linux VM on Hyper-V uses hv_netvsc and hv_storvsc drivers over VMBus.
VMXNET3 and PVSCSI
Broadcom (VMware) · Component · Current · Intermediate
VMware's paravirtual network adapter and SCSI controller, recommended for production VMs. Switching a SQL Server VM from LSI Logic SAS to PVSCSI lowers storage CPU overhead.
Memory ballooning
VMware, KVM (virtio-balloon), Hyper-V, Xen · Concept · Current · Intermediate
A guest driver 'inflates' to hand unused memory back to the host when memory is overcommitted. During a busy hour the host reclaims 4 GB from idle VMs by inflating their balloon drivers.
virtio-fs and virtio-vsock
Red Hat, Linux community · Component · Current · Advanced
virtio-fs shares host directories with guests at local-file speed; vsock gives host-guest sockets without networking. Kata Containers mounts container files into its VM with virtio-fs and talks to its agent over vsock.
QEMU guest agent
QEMU project · Software · Current · Intermediate
A helper inside the guest that lets the host freeze file systems, read IP addresses and shut down cleanly. Proxmox asks the guest agent to freeze the database disk before taking a consistent backup.

6.6 KVM, QEMU and libvirt: The Open-Source Virtualization Stack

Most open-source and many public clouds use the same trio. KVM is a Linux kernel module that runs guest code using the CPU's virtualization extensions; QEMU is a user-space program that provides each VM's virtual hardware (disks, network cards, firmware); and libvirt is a management layer with a stable API, used by tools such as virsh, virt-manager, Cockpit and OpenStack.

Management tools talk to libvirt; each VM is a QEMU process accelerated by KVM in the kernel.
The KVM / QEMU / libvirt stack. Management tools talk to libvirt; each VM is a QEMU process accelerated by KVM in the kernel.

Think of it like…

KVM is the engine, QEMU is the car body with seats, lights and dashboard, and libvirt is the fleet-management office that books, starts, parks and tracks every car through one standard form.

Real-world example

Tomasz, a Linux admin at the fictional Brightfield Analytics, needs a test PostgreSQL server. On an Ubuntu host he runs one virt-install command; libvirt writes the VM's XML definition, starts a QEMU process with KVM acceleration, attaches a qcow2 disk and a virtio NIC on the default NAT network, and boots Debian with OVMF UEFI firmware. virsh snapshot-create saves a restore point before his experiment.

How it works

  1. Load KVM (kvm plus kvm_intel or kvm_amd); it exposes /dev/kvm to user space.
  2. libvirt (virtqemud or the older libvirtd) reads a domain XML definition describing CPUs, memory, disks, NICs and firmware.
  3. libvirt starts a QEMU process for the VM; QEMU opens /dev/kvm and asks KVM to create the VM and its vCPUs with ioctl calls.
  4. Each vCPU is a host thread looping on the KVM_RUN ioctl; exits KVM cannot handle (like emulated I/O) return to QEMU.
  5. libvirt configures networks (bridges, NAT), storage pools, cgroups, SELinux/AppArmor labels and exposes everything through virsh and its API.

Who uses it

Linux system administrators, cloud platform engineers (OpenStack, Proxmox, OpenShift Virtualization), home-lab enthusiasts and RHCSA/RHCE candidates.

Key takeaway

Remember who does what: KVM = CPU and memory virtualization in the kernel; QEMU = device emulation and VM process in user space; libvirt = management API and tools. 'QEMU/KVM' VMs are ordinary Linux processes you can see with ps.

Going deeper

  • KVM was written by Avi Kivity at Qumranet and merged into Linux 2.6.20 in February 2007; Red Hat bought Qumranet in 2008 and KVM now underpins OpenStack, Proxmox VE, Nutanix AHV, Google Compute Engine and AWS Nitro.
  • QEMU, started by Fabrice Bellard in 2003, can emulate whole systems of other architectures with its Tiny Code Generator (TCG) or accelerate same-architecture guests with KVM, Hyper-V's WHP, Apple's HVF or Xen; the 11.x series was current in 2026.
  • Common QEMU machine types are q35 (modern PCIe chipset) and the older i440fx for x86, and 'virt' for Arm and RISC-V; OVMF provides UEFI firmware with Secure Boot, and swtpm provides a virtual TPM 2.0 for Windows 11 guests.
  • libvirt (2005, Red Hat) describes VMs as 'domains' in XML; recent versions split the monolithic libvirtd into modular daemons such as virtqemud, virtnetworkd and virtstoraged.
  • qcow2 ('QEMU copy-on-write v2') supports thin provisioning, internal snapshots, backing files for linked clones, compression and encryption; qemu-img converts between qcow2, raw, VMDK, VHDX and VDI.
  • sVirt gives each VM's QEMU process its own SELinux or AppArmor label, so even a VM escape into QEMU cannot read other VMs' disk images.
  • Kernel Samepage Merging (KSM) deduplicates identical memory pages across VMs, raising density for many similar guests at some CPU and side-channel risk.

Common mistakes & misconceptions

  • Running QEMU without KVM by mistake — if /dev/kvm is missing (virtualization off in UEFI), VMs fall back to TCG emulation and run many times slower.
  • Editing VM XML files on disk directly — use virsh edit or the API, otherwise libvirt overwrites your change.
  • Letting qcow2 backing chains grow long with many external snapshots — performance drops; merge them with virsh blockcommit.

Try it: Create and manage a small KVM VM with libvirt (Linux host with virtualization enabled)

sudo apt install qemu-system-x86 libvirt-daemon-system virtinst   # Debian/Ubuntu
virt-install --name demo --memory 2048 --vcpus 2 \
  --disk size=10 --cdrom ~/Downloads/debian-netinst.iso \
  --os-variant debian12 --boot uefi
virsh list --all
virsh dominfo demo
virsh snapshot-create-as demo before-upgrade
qemu-img info /var/lib/libvirt/images/demo.qcow2

Key kernels, commands, tools, standards & concepts

Name What it does Example
KVM (Kernel-based Virtual Machine)
Linux kernel (Qumranet / Red Hat, 2007) · Software · Current · Beginner
Linux kernel modules (kvm, kvm_intel, kvm_amd) providing hardware-accelerated CPU and memory virtualization. lsmod | grep kvm shows kvm_intel loaded on an Intel host ready for VMs.
/dev/kvm API
Linux kernel · API · Current · Advanced
The ioctl interface user-space VMMs use to create VMs, add vCPUs, map memory and run guest code. QEMU, Firecracker and Cloud Hypervisor all drive the same KVM_CREATE_VM and KVM_RUN calls.
QEMU
QEMU project (Fabrice Bellard, 2003) · Software · Current · Beginner
Open-source machine emulator and virtualizer providing virtual hardware; accelerated by KVM or other hypervisors. qemu-system-aarch64 boots an Arm Linux image on an x86 laptop using TCG emulation.
TCG (Tiny Code Generator)
QEMU project · Component · Current · Advanced
QEMU's dynamic binary translator that emulates foreign CPU architectures without hardware virtualization. A RISC-V developer runs a RISC-V Linux VM on an x86 workstation with QEMU's TCG.
libvirt
libvirt project (Red Hat, 2005) · Software · Current · Intermediate
Stable API, daemons and XML formats for managing KVM, QEMU, Xen, LXC and other hypervisors. OpenStack Nova creates instances by sending domain XML to libvirt on each compute node.
virsh
libvirt project · Command · Current · Beginner
libvirt's command-line shell for listing, starting, stopping, editing, snapshotting and migrating VMs. virsh start web01 && virsh console web01 boots a VM and attaches to its serial console.
virt-install
virt-manager project · Command · Current · Beginner
Creates a new libvirt VM from an ISO, network install or existing disk image in one command. Tomasz scripts virt-install with --os-variant debian12 to build identical test VMs.
virt-manager
virt-manager project (Red Hat) · Tool · Current · Beginner
Desktop GUI for creating and managing libvirt VMs locally or on remote hosts over SSH. A student builds a three-VM Active Directory lab on a Fedora laptop with virt-manager.
Cockpit (cockpit-machines)
Cockpit project (Red Hat) · Tool · Current · Beginner
Web console for Linux servers whose Machines page manages libvirt VMs in a browser. An admin opens https://host:9090 to start a VM and view its console without the CLI.
qemu-img and qcow2
QEMU project · Tool · Current · Intermediate
Disk-image tool and QEMU's copy-on-write format with thin provisioning, snapshots and backing files. qemu-img convert -f vmdk -O qcow2 old.vmdk new.qcow2 moves a VMware disk to KVM.
OVMF and swtpm
TianoCore EDK II; swtpm project · Software · Current · Intermediate
UEFI firmware for VMs with Secure Boot support, and a software TPM 2.0 emulator for guests. A Windows 11 VM on KVM installs only after attaching OVMF Secure Boot firmware and an swtpm vTPM.
QEMU machine types (q35, virt)
QEMU project · Concept · Current · Advanced
Versioned virtual motherboard models defining chipset and devices; pinning a version keeps migration compatible. Hosts in a cluster pin pc-q35-9.2 so VMs migrate between different QEMU versions safely.
sVirt
libvirt with SELinux / AppArmor · Concept · Current · Advanced
Mandatory access control labels per VM so a compromised QEMU process cannot touch other VMs' files. ps -eZ | grep qemu shows each VM running with a unique svirt_t category pair.
Kernel Samepage Merging (KSM)
Linux kernel · Concept · Current · Advanced
Scans memory and merges identical pages across processes and VMs into one copy-on-write page. Fifty Windows VMs share many identical system pages, saving several GB of host RAM with KSM.

6.7 Microsoft Hyper-V

Hyper-V is Microsoft's Type 1 hypervisor, built into Windows Server and the Pro, Enterprise and Education editions of Windows. When it is enabled, the hypervisor starts first and Windows runs on top as a privileged 'root partition' that holds the device drivers and management tools; VMs run in isolated 'child partitions'. The same hypervisor technology runs Microsoft Azure and powers Windows security features.

Guest I/O travels over VMBus to the root partition, which owns the real drivers.
Hyper-V partitions and VMBus. Guest I/O travels over VMBus to the root partition, which owns the real drivers.

Think of it like…

Hyper-V is like an airport: the hypervisor is air-traffic control that owns the runways, the root partition is the airport operations building with all the maintenance crews (drivers), and each child partition is an aircraft that requests services through a dedicated radio channel (VMBus).

Real-world example

The fictional Marlow Accountancy runs a two-node Windows Server 2025 Hyper-V cluster. During a firmware update, admin Zainab live-migrates 14 VMs to the second node with no downtime, patches the first host, then moves them back. Hyper-V Replica copies the payroll VM to a branch office every five minutes for disaster recovery.

How it works

  1. Enable the Hyper-V role (Server) or feature (Windows 11 Pro/Enterprise) and restart.
  2. The hypervisor (hvix64.exe on Intel, hvax64.exe on AMD) loads first, then Windows boots as the root partition.
  3. Create VMs in Hyper-V Manager, Windows Admin Center, PowerShell (New-VM) or System Center VMM; choose Generation 2 for UEFI, Secure Boot and vTPM.
  4. Guests use enlightened kernels and synthetic devices that talk to the root partition's Virtualization Service Providers over VMBus.
  5. Add clustering for live migration and failover, checkpoints for rollback, and Hyper-V Replica or Azure Site Recovery for disaster recovery.

Who uses it

Windows server administrators, Microsoft infrastructure engineers, MSPs, Azure Local and Azure engineers, and developers using Hyper-V on Windows 11.

Key takeaway

Know that Hyper-V is Type 1 even on a desktop, that Generation 2 VMs use UEFI with Secure Boot, and that WSL 2, Windows Sandbox and virtualisation-based security all rely on the same hypervisor.

Going deeper

  • Hyper-V shipped with Windows Server 2008 and became available on client Windows from Windows 8 (2012); the free standalone Hyper-V Server 2019 was the last of its kind.
  • Generation 1 VMs emulate a legacy BIOS PC; Generation 2 VMs use UEFI, boot from SCSI or the network, support Secure Boot and a virtual TPM, and are required for shielded VMs and Windows 11 guests.
  • Linux has shipped Hyper-V drivers (Linux Integration Services) upstream since 2009-2011, so modern distributions run as fully enlightened Hyper-V and Azure guests without extra software.
  • Production checkpoints use VSS inside Windows guests (or file-system freeze in Linux) to create application-consistent restore points; standard checkpoints also save memory state.
  • Live migration can move running VMs between hosts with or without shared storage (shared-nothing migration), using SMB Direct/RDMA and compression to speed memory copying.
  • Windows Server 2025 Hyper-V adds GPU partitioning with live migration and support for very large VMs; Datacenter edition licenses unlimited Windows Server guests on a host.
  • Azure runs a hypervisor derived from Hyper-V across its data centres, and on Windows 11 the same hypervisor powers VBS, Credential Guard, WSL 2 and Windows Sandbox.

Common mistakes & misconceptions

  • Turning off Hyper-V to fix another hypervisor without realising it also disables VBS, Credential Guard, WSL 2 and Windows Sandbox.
  • Treating checkpoints as backups — they live on the same storage and slow disks as they grow; delete them after use and run real backups.
  • Using Generation 1 for new VMs out of habit — Generation 2 is faster to boot and supports Secure Boot and vTPM.

Try it: Manage Hyper-V from PowerShell (Windows 11 Pro/Enterprise or Server, elevated)

Enable-WindowsOptionalFeature -Online -FeatureName Microsoft-Hyper-V -All   # then restart
New-VM -Name Lab01 -Generation 2 -MemoryStartupBytes 2GB -NewVHDPath C:\VMs\Lab01.vhdx -NewVHDSizeBytes 40GB
Set-VMProcessor Lab01 -Count 2
Get-VM | Select-Object Name, State, CPUUsage, MemoryAssigned, Uptime
Checkpoint-VM -Name Lab01 -SnapshotName 'clean install'

Key kernels, commands, tools, standards & concepts

Name What it does Example
Hyper-V hypervisor
Microsoft (2008) · Software · Current · Beginner
Microsoft's Type 1 hypervisor loaded before Windows, partitioning CPU and memory between root and child partitions. bcdedit shows hypervisorlaunchtype Auto on a host with Hyper-V enabled.
Root (parent) partition
Microsoft · Concept · Current · Intermediate
The privileged Windows instance that owns physical devices and runs the virtualization management stack. Zainab patches the root partition's NIC driver; every VM's network goes through it.
Child partitions
Microsoft · Concept · Current · Intermediate
Isolated partitions hosting guest operating systems, with no direct access to physical hardware by default. A Linux web server and a Windows SQL Server run in separate child partitions on one host.
VSP / VSC
Microsoft · Component · Current · Advanced
Virtualization Service Providers in the root partition serve requests from Virtualization Service Clients in guests. storvsc in a Linux guest sends disk I/O to the storage VSP in the root partition.
Enlightenments and Integration Services
Microsoft · Concept · Current · Intermediate
Guest awareness of Hyper-V plus services for time sync, heartbeat, shutdown, key-value exchange and backup. Hyper-V Manager shows a VM's heartbeat as 'OK' through Integration Services.
Generation 1 vs Generation 2 VMs
Microsoft · Concept · Current · Beginner
Gen 1 emulates BIOS and legacy devices; Gen 2 uses UEFI, Secure Boot, vTPM and synthetic devices. A Windows 11 guest needs Gen 2 because it requires UEFI Secure Boot and TPM 2.0.
Hyper-V Manager
Microsoft · Tool · Current · Beginner
Built-in MMC console for creating and managing VMs on local or remote Hyper-V hosts. A developer uses Quick Create in Hyper-V Manager to spin up an Ubuntu VM in minutes.
Hyper-V PowerShell module
Microsoft · Tool · Current · Intermediate
Cmdlets such as New-VM, Start-VM, Checkpoint-VM and Move-VM for automating Hyper-V. A script creates ten identical lab VMs from a sysprepped VHDX overnight.
System Center Virtual Machine Manager (SCVMM)
Microsoft · Software · Current · Intermediate
Enterprise management for Hyper-V fabrics: templates, clouds, networking and multi-cluster operations. A university manages 30 Hyper-V hosts and self-service VM templates with SCVMM.
Hyper-V live migration
Microsoft · Concept · Current · Intermediate
Moves a running VM between hosts without downtime, optionally including storage (shared-nothing). Move-VM -Name Payroll -DestinationHost HV02 shifts the VM before host maintenance.
Checkpoints (standard and production)
Microsoft · Concept · Current · Beginner
Point-in-time VM states; production checkpoints are application-consistent and exclude memory. Before an ERP upgrade, Zainab creates a production checkpoint so she can roll back cleanly.
Hyper-V Replica
Microsoft · Service · Current · Intermediate
Asynchronous replication of VMs to another Hyper-V host every 30 seconds, 5 minutes or 15 minutes. If the main office floods, the payroll VM's replica starts at the branch with minutes of data loss.
Windows Sandbox
Microsoft (Windows 10 1903) · Software · Current · Beginner
A disposable, lightweight Windows VM on Windows Pro/Enterprise that resets every time it closes. An analyst opens a suspicious invoice attachment inside Windows Sandbox, then closes it to wipe everything.
Dynamic Memory
Microsoft · Concept · Current · Intermediate
Adjusts a VM's RAM between minimum and maximum values based on demand, using a balloon-style driver. Twenty desktop VMs share host memory efficiently, each ranging from 2 GB to 8 GB.

6.8 VMware vSphere, ESXi and the Broadcom Era

For two decades VMware vSphere — the ESXi hypervisor plus the vCenter management server — was the default way companies ran VMs. Broadcom bought VMware for about $69 billion in November 2023, ended perpetual licences, bundled products into subscriptions and raised many customers' costs, which started a large migration to other platforms between 2024 and 2026.

Twenty years of technical leadership, then a licensing shock that reshaped the market.
VMware from start-up to the Broadcom era. Twenty years of technical leadership, then a licensing shock that reshaped the market.

Think of it like…

vSphere was the comfortable, well-run apartment complex everyone lived in; when a new landlord bought the building, raised rents and changed lease rules, many tenants started touring other buildings — and some moved.

Real-world example

The fictional Harrow County runs 400 VMs on 12 ESXi hosts. When its renewal quote under the new VMware Cloud Foundation subscription arrives at three times the old support cost, IT manager Dele pilots Proxmox VE and Hyper-V. The county keeps vSphere for its core SQL cluster this year but plans to move 60% of its VMs within two years.

How it works

  1. Install ESXi on each host; it boots the VMkernel and runs VMs from VMFS, NFS or vSAN datastores.
  2. Deploy vCenter Server as an appliance to manage all hosts as clusters.
  3. Enable HA to restart VMs after host failure and DRS to balance load with automatic vMotion.
  4. Use vSAN for software-defined storage and NSX for software-defined networking and micro-segmentation.
  5. License per physical CPU core through a subscription (VMware Cloud Foundation or vSphere Foundation) since perpetual licences ended.

Who uses it

VMware administrators, data-centre and infrastructure architects, IT managers and procurement teams, and engineers planning migrations to alternative hypervisors.

Key takeaway

Know both the technology (ESXi, vCenter, vMotion, HA, DRS, vSAN, NSX) and the business shift: Broadcom closed the deal on 22 November 2023, moved to subscription-only per-core licensing and bundled products into VCF and VVF.

Going deeper

  • ESXi's VMkernel is a purpose-built POSIX-like kernel; vCenter Server Appliance (VCSA) runs on Photon OS and manages up to thousands of hosts with features such as HA, DRS, vMotion and Storage vMotion.
  • Broadcom now sells mainly two per-core subscription bundles, VMware Cloud Foundation (VCF) and vSphere Foundation (VVF), with a 16-core minimum per CPU; April 2025 reports described a 72-core minimum per order.
  • Broadcom dropped free ESXi in early 2024 and restored it with ESXi 8.0 Update 3e in April 2025; Workstation Pro and Fusion Pro became free for personal use in May 2024, then for all uses in November 2024.
  • VMware Cloud Foundation 9.0 (June 2025) brought ESXi 9.0, a unified operations and automation console, and positioned VCF as a private-cloud platform rather than a set of separate products.
  • AT&T sued Broadcom in 2024 over support renewals, and European cloud trade body CISPE complained to EU regulators about licensing changes; these cases signalled how widely customers felt the impact.
  • Migration targets in 2024-2026 included Nutanix AHV, Proxmox VE, Hyper-V and Azure Local, Red Hat OpenShift Virtualization, XCP-ng, HPE's KVM-based VM Essentials and public cloud; Proxmox VE 8.2 (April 2024) added an ESXi import wizard.
  • Migration tools include Nutanix Move, Red Hat's Migration Toolkit for Virtualization, virt-v2v, Azure Migrate, the Proxmox import wizard and backup products like Veeam that restore VMware backups to other hypervisors.

Common mistakes & misconceptions

  • Planning a migration only around the hypervisor — the hard parts are storage, backup, networking (NSX rules), monitoring, automation scripts and staff skills.
  • Assuming free ESXi suits production — it lacks vCenter management, HA, vMotion and official API write access; it is for labs and small single-host uses.
  • Forgetting guest drivers when migrating — VMware Tools and VMXNET3/PVSCSI must be replaced by virtio or Hyper-V drivers before or during conversion.

Try it: Inventory a vSphere environment with PowerCLI (PowerShell; needs vCenter credentials)

Install-Module VMware.PowerCLI -Scope CurrentUser   # newer releases ship as VCF.PowerCLI
Connect-VIServer vcenter.example.local
Get-VMHost | Select-Object Name, Version, NumCpu, MemoryTotalGB
Get-VM | Measure-Object                       # how many VMs you would migrate
Get-VM | Select-Object Name, NumCpu, MemoryGB, ProvisionedSpaceGB | Export-Csv vms.csv

Key kernels, commands, tools, standards & concepts

Name What it does Example
VMware vSphere
Broadcom (VMware) · Platform · Current · Beginner
VMware's server virtualization suite: ESXi hosts managed by vCenter with HA, DRS and vMotion. Harrow County runs 400 VMs across 12 vSphere hosts in two clusters.
vCenter Server
Broadcom (VMware) · Software · Current · Beginner
Central management appliance for ESXi hosts, clusters, templates, permissions and automation APIs. Dele uses vCenter's inventory to export every VM's CPU, RAM and disk size for migration planning.
vMotion and Storage vMotion
VMware (2003) · Concept · Current · Intermediate
Live migration of running VMs between hosts (vMotion) or between datastores (Storage vMotion). A VM moves to a new SAN during business hours with no interruption for users.
vSphere HA and DRS
Broadcom (VMware) · Concept · Current · Intermediate
HA restarts VMs after host failure; DRS balances load across hosts automatically using vMotion. When a host's power supply fails at 2 a.m., HA restarts its 30 VMs on other hosts within minutes.
vSAN
Broadcom (VMware, 2014) · Software · Current · Intermediate
Hyperconverged software-defined storage pooling local disks across ESXi hosts into shared datastores. A branch office runs a two-node vSAN cluster with a witness instead of buying a SAN.
NSX
Broadcom (VMware, from Nicira 2012) · Software · Current · Advanced
Software-defined networking and distributed firewalling for VMs, including micro-segmentation. NSX rules allow the web tier to reach only the app tier on port 8443.
VMFS
Broadcom (VMware) · File system · Current · Intermediate
Clustered file system letting many ESXi hosts share the same block storage LUNs safely. Eight hosts mount a 20 TB VMFS 6 datastore on an iSCSI SAN.
VMware Cloud Foundation (VCF)
Broadcom (VCF 9.0, June 2025) · Platform · Current · Intermediate
Broadcom's flagship private-cloud bundle of vSphere, vSAN, NSX and management, sold as per-core subscriptions. A bank standardises on VCF 9 for its private cloud and accepts the higher subscription cost.
VMware vSphere Foundation (VVF)
Broadcom (VMware) · Platform · Current · Intermediate
A smaller subscription bundle for mid-sized environments, including vSphere and operations tools. A manufacturer chooses VVF because it does not need NSX networking.
Broadcom licensing changes
Broadcom (from December 2023) · Concept · Current · Beginner
End of perpetual licences, product bundling and per-core subscriptions with minimum core counts. A 24-host customer's renewal triples because it must now buy the full bundle per core.
Free ESXi (8.0 Update 3e)
Broadcom (April 2025) · Software · Current · Beginner
A no-cost ESXi edition restored in 2025 for labs and small single-host use, without vCenter features. A home-lab user installs free ESXi 8 on a mini PC to practise for VMware exams.
PowerCLI
Broadcom (VMware) · Tool · Current · Intermediate
PowerShell modules for automating vSphere, vSAN, NSX and VCF. Get-VM | Where-Object PowerState -eq 'PoweredOff' lists idle VMs that may be decommissioned.
Omnissa
KKR (2024, ex-VMware EUC) · Organisation · Current · Beginner
Company formed when Broadcom sold VMware's end-user computing business (Horizon, Workspace ONE) to KKR. A hospital's Horizon VDI contract now renews with Omnissa instead of VMware.
VMware migration wave (2024-2026)
Industry trend · Concept · Current · Beginner
Organisations moving some or all VMs off vSphere to alternative hypervisors or cloud after licensing changes. A school district moves 150 VMs to Proxmox VE using its ESXi import wizard over three weekends.
Migration tools
Nutanix Move, Red Hat MTV, virt-v2v, Azure Migrate, Veeam · Tool · Current · Intermediate
Software that copies VM disks from vSphere, converts drivers and recreates VMs on another platform. virt-v2v converts a Windows VM from ESXi to KVM, installing virtio drivers during conversion.

6.9 Xen, Proxmox VE, Nutanix AHV and Other Platforms

Beyond VMware and Hyper-V, several virtualization platforms matter in 2026. Xen is a veteran open-source hypervisor behind XCP-ng and Citrix's XenServer; Proxmox VE is a free, open-source KVM-and-container platform hugely popular with small businesses and home labs; Nutanix AHV is the KVM-based hypervisor of Nutanix's hyperconverged platform; and KubeVirt-based products run VMs inside Kubernetes.

Three popular VMware alternatives

Proxmox VE Nutanix AHV XCP-ng
Hypervisor KVM + LXC KVM Xen
Licence AGPLv3, optional subscription commercial open source, optional support
Management built-in web UI, API Prism Element / Central Xen Orchestra
Storage ZFS, Ceph, LVM, NFS Nutanix distributed storage local, NFS, iSCSI, XOSTOR
Base OS Debian 13 Nutanix AOS CentOS-derived dom0
Typical buyer SMB, labs, MSPs enterprise HCI SMB, ex-XenServer users

All three are mature; the choice is mostly about support model, storage design and cost.

Think of it like…

Choosing a virtualization platform is like choosing a car brand after your old dealer raised prices: some are free kit cars you maintain yourself (Proxmox, XCP-ng), some are premium all-inclusive brands with service plans (Nutanix), and some are hybrids that also carry your other cargo (KubeVirt for VMs and containers together).

Real-world example

The fictional Sandpiper Logistics leaves VMware. Its small branch sites move to three-node Proxmox VE clusters with Ceph storage, while the head office chooses Nutanix with AHV for vendor support. The development team runs legacy Windows build VMs next to containers on OpenShift Virtualization so one platform manages both.

How it works

  1. List requirements: support level, budget, storage design, backup integration, staff skills and existing hardware.
  2. Pilot candidate platforms with representative VMs and measure performance, management effort and backup and restore.
  3. Design storage (local ZFS, Ceph, Nutanix distributed storage, external SAN) and networking (bridges, VLANs, SDN).
  4. Convert or import VMs, install the right guest drivers and agents, and verify applications.
  5. Set up clustering, high availability, monitoring and backups before moving critical workloads.

Who uses it

Infrastructure engineers, MSPs, SMB IT teams, home-lab users, platform engineers combining VMs and Kubernetes, and architects running VMware exit projects.

Key takeaway

Know one fact per platform: Xen has dom0 and PV/HVM/PVH guests; Proxmox VE = Debian + KVM + LXC + ZFS/Ceph under AGPLv3; Nutanix AHV = KVM managed through Prism; KubeVirt = VMs as Kubernetes objects.

Going deeper

  • Xen came from the University of Cambridge (SOSP 2003 paper 'Xen and the Art of Virtualization'): a small hypervisor plus a privileged Linux dom0, with guests in PV, HVM or PVH mode. Xen 4.22 shipped in July 2026.
  • Xen remains important in embedded and automotive systems on Arm, in Qubes OS for security compartments, and in XCP-ng (Vates) and XenServer 8 (Cloud Software Group, formerly Citrix Hypervisor).
  • Proxmox VE combines KVM VMs and LXC containers on Debian with ZFS, Ceph and HA clustering; 9.0 (August 2025) moved to Debian 13 'Trixie', 9.1 followed in November 2025, 9.2 in May 2026, and an arm64 build in August 2026.
  • Proxmox Backup Server adds deduplicated, incremental, encrypted VM backups, and the Proxmox VE enterprise repository is available with a paid subscription; the free no-subscription repository receives the same code a little earlier.
  • Nutanix AHV is included with Nutanix Cloud Infrastructure at no extra hypervisor charge; Prism Central manages multi-cluster estates and Nutanix Move migrates VMs from ESXi and Hyper-V.
  • KubeVirt (CNCF incubating project) runs each VM inside a pod with libvirt and QEMU; Red Hat OpenShift Virtualization and SUSE Harvester build on it, letting platform teams manage VMs with kubectl and GitOps.
  • Other KVM-based options include OpenNebula, Apache CloudStack, Oracle Linux Virtualization Manager (from oVirt), HPE Morpheus VM Essentials and Microsoft's Azure Local for Hyper-V-based hyperconverged clusters.

Common mistakes & misconceptions

  • Running a two-node Proxmox cluster without a quorum device — when one node fails the other loses quorum; add a QDevice or a third node.
  • Picking a platform only on licence price — support response times, backup integration and staff training often cost more than licences.
  • Assuming KubeVirt replaces a full virtualization platform for every team — VM operations such as live migration and storage need careful Kubernetes design.

Try it: Try Proxmox VE's command line (on a Proxmox host or nested lab VM)

pveversion -v | head -5
qm list                                  # KVM virtual machines
pct list                                 # LXC containers
qm create 120 --name test --memory 2048 --cores 2 --net0 virtio,bridge=vmbr0
pvecm status                             # cluster quorum
# Xen / XCP-ng host: xl list   or   xe vm-list

Key kernels, commands, tools, standards & concepts

Name What it does Example
Xen Project hypervisor
Xen Project, Linux Foundation · Software · Current · Intermediate
Open-source Type 1 hypervisor with a small core and a privileged dom0 managing devices and guests. xl list on a Xen host shows Domain-0 plus each running guest domain.
dom0 and domU
Xen Project · Concept · Current · Intermediate
dom0 is Xen's privileged control domain with drivers and tools; domUs are unprivileged guest domains. Rebooting dom0 on an XCP-ng host interrupts all its domU guests.
PV, HVM and PVH guests
Xen Project · Concept · Current · Advanced
Xen guest modes: paravirtualized, fully hardware-virtualized, and PVH combining hardware assist with PV interfaces. Modern Linux guests on Xen boot as PVH for lower overhead and a smaller attack surface.
XCP-ng and Xen Orchestra
Vates (open source) · Software · Current · Intermediate
A free Xen-based virtualization platform and its web management and backup tool. A school replaces free ESXi with XCP-ng 8.3 and manages it from Xen Orchestra.
XenServer
Cloud Software Group (formerly Citrix Hypervisor) · Software · Current · Intermediate
Commercial Xen-based hypervisor commonly paired with Citrix virtual desktops. A Citrix VDI farm runs its desktop VMs on XenServer 8 hosts.
Proxmox VE
Proxmox Server Solutions GmbH (AGPLv3) · Platform · Current · Beginner
Debian-based open-source platform for KVM VMs and LXC containers with clustering, HA, ZFS and Ceph. Sandpiper's branch sites run three-node Proxmox VE 9 clusters with Ceph replicated storage.
Proxmox Backup Server
Proxmox Server Solutions GmbH · Software · Current · Intermediate
Deduplicating, incremental and encrypted backup server for Proxmox VMs, containers and hosts. Nightly backups of 80 VMs take minutes because only changed chunks are sent.
Ceph
Ceph Foundation (Linux Foundation) · Software · Current · Advanced
Distributed storage providing replicated block (RBD), object and file storage across many servers. Proxmox stores VM disks in Ceph RBD with three replicas, so a node failure loses no data.
Nutanix AHV
Nutanix · Software · Current · Intermediate
Nutanix's KVM-based hypervisor, included with its hyperconverged infrastructure software. The head office runs 300 VMs on AHV and patches hosts with one-click rolling upgrades.
Nutanix Prism
Nutanix · Tool · Current · Intermediate
Nutanix's web management: Prism Element per cluster and Prism Central for multi-cluster operations. An admin creates VM categories and security policies for 12 clusters from Prism Central.
KubeVirt
CNCF (incubating; Red Hat-originated) · Software · Current · Advanced
Kubernetes add-on that runs VMs as pods, managed with custom resources such as VirtualMachine. kubectl get vmi lists running VM instances next to ordinary pods in a namespace.
Red Hat OpenShift Virtualization
Red Hat · Platform · Current · Advanced
Red Hat's supported KubeVirt-based feature for running VMs alongside containers on OpenShift. A bank moves 200 VMs from vSphere to OpenShift Virtualization with the Migration Toolkit for Virtualization.
SUSE Harvester
SUSE (open source) · Platform · Current · Advanced
Hyperconverged infrastructure built on Kubernetes, KubeVirt and Longhorn storage, managed with Rancher. An edge retailer runs Harvester in stores to host both POS VMs and Kubernetes apps.
OpenNebula and Apache CloudStack
OpenNebula Systems; Apache Software Foundation · Software · Current · Intermediate
Open-source cloud management platforms orchestrating KVM (and other) hypervisors into private clouds. A regional hosting company offers self-service VMs to customers with Apache CloudStack on KVM.
HPE Morpheus VM Essentials
Hewlett Packard Enterprise · Software · Current · Intermediate
HPE's KVM-based virtualization offering with management tools, aimed at VMware migration customers. An HPE customer pilots VM Essentials on existing ProLiant servers before renewing VMware.

6.10 OpenStack: Building Your Own Cloud

OpenStack is a collection of open-source services that turns racks of servers into a self-service cloud like a mini AWS. Users ask an API for VMs, networks, volumes and images; OpenStack services decide where to run them and configure hypervisors (usually KVM), virtual networks and storage automatically. Telecom operators, research centres and hosting providers run some of the largest deployments.

Every step is an API call between services; the compute node does the actual VM start with libvirt and KVM.
Booting an OpenStack instance. Every step is an API call between services; the compute node does the actual VM start with libvirt and KVM.

Think of it like…

OpenStack is like a hotel's booking system and staff combined: guests (users) book rooms online (the API), the reservation desk (Nova scheduler) picks a free room on the right floor, housekeeping prepares it (Glance image, Neutron network, Cinder volume), and the keycard system (Keystone) checks who may enter.

Real-world example

At the fictional Northern Lights Research Institute, 400 scientists share a 120-server OpenStack cloud. Dr Ayo runs 'openstack server create' for a 32-core analysis VM; within a minute Nova picks a host with free capacity, Glance supplies an Ubuntu image, Neutron attaches a private network with a floating IP, and Cinder adds a 2 TB data volume. Quotas keep any single project from taking the whole cloud.

How it works

  1. The user authenticates with Keystone and receives a token listing their project and roles.
  2. A request to the Nova API asks for an instance with a flavor (size), image, network and key pair.
  3. The Nova scheduler asks Placement for hosts with enough resources and picks a compute node.
  4. nova-compute on that host fetches the image from Glance, requests a port from Neutron and a volume from Cinder.
  5. nova-compute tells libvirt to boot the KVM guest; cloud-init inside the VM applies the user's SSH key and settings.

Who uses it

Cloud and platform engineers, telecom NFV engineers, research computing teams, hosting providers and anyone running private or sovereign clouds.

Key takeaway

Map each service to its AWS equivalent: Nova ≈ EC2, Neutron ≈ VPC, Cinder ≈ EBS, Swift ≈ S3, Glance ≈ AMIs, Keystone ≈ IAM, Heat ≈ CloudFormation, Octavia ≈ ELB.

Going deeper

  • OpenStack started in 2010 as a joint project of Rackspace (Swift object storage) and NASA (Nova compute); the OpenInfra Foundation that hosts it joined the Linux Foundation in 2025.
  • Releases come every six months with alphabetical names and year-based numbers: 2025.1 Epoxy, 2025.2 Flamingo, 2026.1 Gazpacho (April 2026) and 2026.2 Hibiscus (September 2026); the 'SLURP' .1 releases allow skipping one release when upgrading.
  • Core services: Keystone (identity), Nova (compute), Placement (resource inventory), Neutron (networking with OVN or Open vSwitch), Glance (images), Cinder (block storage), Swift (object storage) and Horizon (web dashboard).
  • Commonly added services: Heat (orchestration templates), Octavia (load balancers), Ironic (bare-metal provisioning), Manila (shared file systems), Barbican (secrets), Designate (DNS) and Magnum (Kubernetes clusters).
  • Deployment tools include Kolla-Ansible (services in containers), OpenStack-Ansible, Canonical OpenStack (Sunbeam) and Red Hat OpenStack Services on OpenShift, which runs the control plane on Kubernetes.
  • Large users include CERN, telecom operators running network functions, and European providers building 'sovereign cloud' services; Ceph is the most common storage back end for Glance, Cinder and Nova.

Common mistakes & misconceptions

  • Underestimating operations effort — OpenStack is many distributed services plus a database and message queue (RabbitMQ); plan for automation, monitoring and upgrade testing.
  • Treating OpenStack as a hypervisor — it orchestrates hypervisors (mostly KVM via libvirt); performance and isolation still come from the layers below.
  • Skipping cloud-init in images — without it, instances cannot pick up SSH keys, hostnames or user data from the metadata service.

Try it: Use the OpenStack CLI against any OpenStack cloud (credentials from your provider's clouds.yaml)

pip install python-openstackclient
export OS_CLOUD=mycloud
openstack flavor list
openstack image list
openstack server create --flavor m1.small --image ubuntu-24.04 \
  --network private --key-name mykey demo-vm
openstack server list

Key kernels, commands, tools, standards & concepts

Name What it does Example
OpenStack
OpenInfra Foundation (Linux Foundation) · Platform · Current · Intermediate
Open-source cloud platform of cooperating services for compute, networking, storage and identity. A telecom operator runs its 5G core network functions as VMs on an OpenStack cloud.
Nova
OpenStack · Service · Current · Intermediate
Compute service that schedules and manages VM instances on hypervisor hosts. openstack server resize demo-vm m1.large moves the VM to a bigger flavor.
Placement
OpenStack · Service · Current · Advanced
Tracks resource inventories (vCPU, RAM, disk, GPUs) and usage so the scheduler can pick suitable hosts. The scheduler finds only three hosts with a free GPU because Placement tracks each GPU as a resource.
Neutron
OpenStack · Service · Current · Intermediate
Networking service providing tenant networks, subnets, routers, security groups and floating IPs, often via OVN. A project creates a private network and router, then assigns a floating IP to its web server.
Keystone
OpenStack · Service · Current · Intermediate
Identity service handling authentication, tokens, projects, roles and the service catalogue. Keystone federates with the institute's SAML login so scientists use their normal accounts.
Glance
OpenStack · Service · Current · Beginner
Image service storing and serving VM disk images such as Ubuntu, Rocky Linux or Windows. openstack image create --file rocky9.qcow2 rocky-9 uploads a new base image.
Cinder
OpenStack · Service · Current · Intermediate
Block-storage service creating persistent volumes that attach to instances, backed by Ceph, LVM or SANs. Dr Ayo's 2 TB data volume survives when she deletes and recreates her analysis VM.
Swift
OpenStack · Service · Current · Intermediate
Highly available object storage with an HTTP API, originally from Rackspace Cloud Files. A research archive stores 2 PB of instrument data as objects in Swift.
Horizon
OpenStack · Tool · Current · Beginner
OpenStack's web dashboard for users and administrators. A new student launches her first VM from Horizon without learning the CLI.
Heat
OpenStack · Service · Current · Intermediate
Orchestration service that builds whole stacks of resources from templates (HOT format). A Heat template creates three web VMs, a load balancer and a database in one command.
Ironic
OpenStack · Service · Current · Advanced
Provisions bare-metal servers through the same API as VMs, using IPMI or Redfish. HPC users request whole physical nodes through Ironic for benchmark-sensitive jobs.
Kolla-Ansible
OpenStack · Tool · Current · Advanced
Deploys and upgrades OpenStack services as containers using Ansible playbooks. Ops engineers upgrade from 2025.1 to 2026.1 with a tested Kolla-Ansible run.
Flavors, quotas and projects
OpenStack · Concept · Current · Beginner
Flavors define instance sizes; projects group users and resources; quotas cap each project's usage. The physics project's quota of 400 vCPUs stops one job from consuming the whole cloud.
cloud-init
Canonical (open source) · Software · Current · Beginner
Runs at first boot to apply SSH keys, hostname, packages and scripts from cloud metadata. user-data with runcmd: [apt-get install -y nginx] gives a freshly booted VM a web server.
OpenStack release cadence
OpenInfra Foundation · Concept · Current · Intermediate
Two releases per year, alphabetically named (Epoxy, Flamingo, Gazpacho, Hibiscus) with SLURP skip-level upgrades. A provider upgrades only every year, going from 2025.1 Epoxy straight to 2026.1 Gazpacho.

6.11 Desktop Hypervisors: VirtualBox, VMware Workstation and Fusion, Parallels, UTM

Desktop hypervisors let you run other operating systems in windows on your own laptop — a Linux VM on Windows, Windows on a Mac, or a disposable lab of several servers. In 2026 the main choices are free: Oracle VirtualBox, VMware Workstation Pro and Fusion Pro, Hyper-V on Windows Pro, and UTM on Mac, with Parallels Desktop as the polished paid option for Apple silicon Macs.

Most are now free; the right one depends on your host operating system and CPU architecture.
Desktop hypervisor choices in 2026. Most are now free; the right one depends on your host operating system and CPU architecture.

Think of it like…

A desktop hypervisor is like a set of fold-out guest rooms in your home: you can set up a room for a visitor (a VM) in minutes, rearrange or reset it whenever you like, and pack it away when they leave — but every guest still shares your kitchen and electricity.

Real-world example

Aisha, a cybersecurity student at the fictional Riverside College, builds a home lab on a 32 GB Windows laptop: a Windows Server 2025 domain controller, a Windows 11 client and a Kali Linux attacker VM in VMware Workstation Pro on an isolated host-only network. Before each exercise she takes snapshots, and afterwards she reverts all three VMs to a clean state in seconds.

How it works

  1. Install a desktop hypervisor and enable virtualization (VT-x/AMD-V) in the PC's UEFI setup if needed.
  2. Create a VM: choose the guest OS, CPU cores, memory, disk size and network mode (NAT, bridged or host-only).
  3. Attach an installer ISO and install the guest OS as on a real PC.
  4. Install guest tools (VirtualBox Guest Additions, VMware Tools, Parallels Tools, spice/virtio drivers) for graphics, clipboard and shared folders.
  5. Take snapshots before risky changes and export finished VMs as OVA files to share.

Who uses it

Students, developers, testers, cybersecurity learners and analysts, trainers, IT support staff testing upgrades, and Mac users needing Windows apps.

Key takeaway

Match the tool to the host: Windows/Linux → VirtualBox or Workstation Pro (or Hyper-V on Windows); Apple silicon Mac → Parallels, VMware Fusion, UTM or VirtualBox 7.1+, running Arm guest OSes.

Going deeper

  • VMware Workstation Pro and Fusion Pro became free for personal use in May 2024 and for commercial use in November 2024; the separate Workstation Player and Fusion Player products were discontinued.
  • VirtualBox (originally Innotek, then Sun, now Oracle) is GPLv3 open source; version 7.1 (September 2024) added Apple silicon Mac hosts for Arm guests, and the 7.2 series followed from August 2025.
  • On Apple silicon Macs, VMs must run Arm operating systems (Linux arm64, Windows 11 on Arm, macOS); x86 guests need slow full emulation, though Rosetta can be used inside Linux VMs for x86 binaries.
  • Apple's macOS licence allows up to two additional macOS VMs on the same Mac, and Microsoft authorises Windows 11 on Arm in Parallels Desktop and VMware Fusion on Apple M-series Macs.
  • Network modes matter for labs: NAT shares the host's connection, bridged puts the VM on the real LAN with its own address, host-only/internal networks keep malware labs isolated from the internet.
  • Vagrant (HashiCorp) automates desktop VMs from a Vagrantfile, and Canonical's Multipass launches Ubuntu VMs with one command on Windows, macOS and Linux.

Common mistakes & misconceptions

  • Giving VMs more RAM and cores than the host can spare — the host starts swapping and every VM slows; leave at least 4-8 GB for the host OS.
  • Running malware samples in a bridged VM with shared folders and clipboard enabled — use host-only networking and disable sharing.
  • Expecting x86 Windows or Linux ISOs to run fast on an Apple silicon Mac — download Arm builds instead.

Try it: Create and start a headless VirtualBox VM from the command line

VBoxManage createvm --name lab01 --ostype Ubuntu_64 --register
VBoxManage modifyvm lab01 --memory 4096 --cpus 2 --nic1 nat
VBoxManage createmedium disk --filename lab01.vdi --size 20000
VBoxManage storagectl lab01 --name SATA --add sata
VBoxManage storageattach lab01 --storagectl SATA --port 0 --type hdd --medium lab01.vdi
VBoxManage list vms

Key kernels, commands, tools, standards & concepts

Name What it does Example
Oracle VirtualBox
Oracle (GPLv3; 7.2 series) · Software · Current · Beginner
Free open-source Type 2 hypervisor with snapshots, OVA import/export and a full command-line interface. A teacher distributes one .ova so the whole class imports an identical Linux lab into VirtualBox.
VirtualBox Extension Pack
Oracle (PUEL licence) · Software · Current · Intermediate
Separately licensed add-on providing features such as USB 3 passthrough and disk encryption; commercial use requires a licence. IT checks licensing before rolling the Extension Pack out to 200 office PCs.
VMware Workstation Pro
Broadcom (VMware) · Software · Current · Beginner
Desktop hypervisor for Windows and Linux hosts, free for all uses since November 2024. Aisha builds a three-VM Active Directory attack lab with linked clones in Workstation Pro.
VMware Fusion Pro
Broadcom (VMware) · Software · Current · Beginner
VMware's Mac desktop hypervisor for Intel and Apple silicon Macs, free for all uses since November 2024. A Mac developer runs Windows 11 on Arm in Fusion to test a web app in Edge.
Parallels Desktop
Parallels (Alludo) · Software · Current · Beginner
Commercial Mac hypervisor known for tight macOS integration and authorised Windows 11 on Arm support. An accountant runs Windows-only tax software on her M3 MacBook Air with Parallels Desktop.
UTM
UTM project (open source) · Software · Current · Beginner
Free Mac app using Apple's Virtualization framework or QEMU, able to emulate other CPU architectures. A student runs an x86 Windows XP VM in UTM's emulation mode for a retro computing project.
Hyper-V Quick Create
Microsoft · Tool · Current · Beginner
A simplified Hyper-V wizard on Windows Pro/Enterprise for creating VMs from gallery images or ISOs. A developer creates an Ubuntu VM in Hyper-V without installing extra software.
GNOME Boxes
GNOME project · Software · Current · Beginner
Simple desktop front end to QEMU/KVM and libvirt for trying operating systems on Linux. A Fedora user downloads and boots a Debian VM in Boxes with three clicks.
Guest tools / additions
Oracle, Broadcom, Parallels, QEMU · Software · Current · Beginner
Drivers and services inside the guest for display resizing, clipboard, shared folders, time sync and clean shutdown. Installing VirtualBox Guest Additions lets the Ubuntu VM resize when the window is maximised.
NAT, bridged and host-only networking
Desktop hypervisors · Concept · Current · Beginner
VM network modes: share the host's address (NAT), join the LAN directly (bridged), or stay on a private host network. Aisha's malware lab uses host-only networking so nothing inside can reach the internet.
OVF / OVA
DMTF (Open Virtualization Format) · Standard · Current · Intermediate
A portable package format describing a VM's hardware and disks; OVA is the single-file tar version. A vendor ships its network appliance as an OVA that imports into VirtualBox, Workstation or ESXi.
Vagrant
HashiCorp · Tool · Current · Intermediate
Automates creating and configuring development VMs from a Vagrantfile across several hypervisors. vagrant up builds the same three-VM test environment on every developer's laptop.
Multipass
Canonical · Tool · Current · Beginner
Command-line tool that launches Ubuntu VMs instantly on Windows, macOS and Linux. multipass launch 24.04 --name dev gives a student a fresh Ubuntu VM in under a minute.

6.12 The VM Lifecycle: Images, Templates, Snapshots, Live Migration and High Availability

A VM has a life: it is built from an image or template, configured, run, protected with snapshots and backups, moved between hosts while running, recovered automatically if a host fails, and finally retired. Knowing these operations — and their limits — is the daily work of anyone running virtual infrastructure.

Automate the loop so every VM starts from a known-good, current image.
The VM lifecycle. Automate the loop so every VM starts from a known-good, current image.

Think of it like…

Managing VMs is like running a fleet of hire cars: you build a standard model (template), give each customer one (clone), take photos before risky trips (snapshots), keep insurance (backups), swap cars between depots without stopping the journey (live migration), send a replacement when one breaks down (HA), and scrap old cars (retirement).

Real-world example

Femi, infrastructure lead at the fictional Kingsgate Bank, builds a hardened Rocky Linux golden image every month with Packer. New VMs are linked clones customised by cloud-init in under two minutes. Before patching, he snapshots; backups run nightly with changed-block tracking; and when a host shows memory errors, its VMs are live-migrated away before HA ever needs to step in.

How it works

  1. Build a golden image (OS, patches, agents, hardening) — ideally automatically with a tool like Packer.
  2. Turn it into a template and deploy VMs as full or linked clones, customised at first boot by cloud-init or Sysprep.
  3. Run and monitor VMs; resize CPU, memory and disks as needs change.
  4. Protect them: short-lived snapshots before changes, scheduled image-level backups, and replication for disaster recovery.
  5. Move them with live migration for maintenance and load balancing, and let HA restart them after failures.
  6. Retire unused VMs and reclaim their storage to avoid VM sprawl.

Who uses it

Virtualization and cloud administrators, backup and DR specialists, DevOps engineers building images, and SREs running maintenance windows.

Key takeaway

Snapshots are not backups: they depend on the original disk, live on the same storage and slow the VM as they grow — keep them for hours or days, not months.

Going deeper

  • Common disk formats: raw (simplest, fastest), qcow2 (KVM; thin, snapshots, backing files), VMDK (VMware), VHDX (Hyper-V, up to 64 TB) and VDI (VirtualBox); qemu-img converts between them.
  • Pre-copy live migration copies memory while the VM runs, re-sends pages dirtied in each round, then pauses briefly to copy the remainder and CPU state; downtime is typically tens to hundreds of milliseconds.
  • Post-copy migration switches the VM to the destination immediately and fetches missing pages on demand — it guarantees completion for busy VMs but a network failure mid-way can lose the VM.
  • HA clusters use heartbeats and quorum to detect failed hosts, fence them (power off via IPMI or Redfish so they cannot corrupt shared disks), then restart their VMs elsewhere — typically within a few minutes.
  • Image-level backup products use changed-block tracking (VMware CBT, Hyper-V RCT, QEMU dirty bitmaps) so nightly backups copy only blocks changed since the last run.
  • Windows templates must be generalised with Sysprep to reset the machine SID and identity; Linux templates should clear machine-id, SSH host keys and logs, and use cloud-init for first-boot settings.
  • Thin provisioning and CPU/memory overcommitment raise density, but watch datastore free space and CPU-ready or steal time; ratios of 3-5 vCPUs per physical core are common for general workloads.

Common mistakes & misconceptions

  • Keeping snapshots for weeks — delta files grow, performance drops and merging later can take hours; delete them after the change is verified.
  • Cloning Windows VMs without Sysprep — duplicate identities cause domain and management-agent problems.
  • Assuming HA protects against everything — it restarts VMs after host failure but not after guest OS corruption, ransomware or site loss; you still need backups and DR.

Try it: Snapshot, clone and inspect disk images with libvirt and qemu-img (Linux KVM host)

virsh snapshot-create-as web01 pre-patch --description 'before July patches'
virsh snapshot-list web01
virsh snapshot-revert web01 pre-patch
# linked clone: a new qcow2 that uses the golden image as its backing file
qemu-img create -f qcow2 -b golden.qcow2 -F qcow2 web02.qcow2
qemu-img info --backing-chain web02.qcow2

Key kernels, commands, tools, standards & concepts

Name What it does Example
Golden image
General · Concept · Current · Beginner
A standard, patched and hardened base image from which all new VMs of a type are built. Kingsgate rebuilds its Rocky Linux 9 golden image monthly so new VMs start fully patched.
Template
VMware, Proxmox, Hyper-V, OpenStack · Concept · Current · Beginner
A VM marked as a master copy that cannot be started directly but can be cloned repeatedly. Right-click → Clone to VM in vCenter deploys a new web server from the 'web-2026-10' template.
Full vs linked clones
General · Concept · Current · Intermediate
Full clones copy the whole disk; linked clones share the parent's disk and store only differences. A training lab spins up 40 linked clones in seconds, using a fraction of the storage of full clones.
Packer
HashiCorp · Tool · Current · Intermediate
Builds identical machine images for many platforms from one template file. One Packer template produces the same hardened image for vSphere, Proxmox and AWS.
Sysprep
Microsoft · Tool · Current · Intermediate
Generalises a Windows installation, removing machine-specific identity before it becomes a template. sysprep /generalize /oobe /shutdown prepares a Windows Server 2025 VM for templating.
Snapshot / checkpoint
General · Concept · Current · Beginner
Saves a VM's disk (and optionally memory) state at a point in time so you can revert later. Femi snapshots a database VM before patching and reverts within a minute when the patch fails.
Disk image formats
qcow2, VMDK, VHDX, VDI, raw · Concept · Current · Beginner
File formats storing virtual disks; each hypervisor prefers its own but tools convert between them. qemu-img convert -O vhdx turns a KVM qcow2 disk into a Hyper-V VHDX.
Thin vs thick provisioning
General · Concept · Current · Intermediate
Thin disks allocate space as data is written; thick disks reserve all space up front. A datastore with 10 TB of thin disks on 6 TB of storage fills up overnight when a log explodes.
Live migration
VMware vMotion, Hyper-V, KVM, Xen · Concept · Current · Intermediate
Moves a running VM's memory, CPU state and network identity to another host with near-zero downtime. virsh migrate --live web01 qemu+ssh://host2/system moves a VM before host maintenance.
Pre-copy vs post-copy migration
Live migration algorithms · Concept · Current · Advanced
Pre-copy iterates dirty memory before switching; post-copy switches first and pulls pages on demand. A VM writing memory faster than the network can copy it only completes migration with post-copy.
High availability (HA) and fencing
General · Concept · Current · Intermediate
Automatically restarts VMs on surviving hosts after a failure, first isolating the failed host. Proxmox HA fences a hung node through its watchdog, then restarts its VMs on the other two nodes.
Changed-block tracking
VMware CBT, Hyper-V RCT, QEMU dirty bitmaps · Concept · Current · Advanced
Records which disk blocks changed since the last backup so incremental backups are fast. A 2 TB file server's nightly backup copies only 18 GB of changed blocks.
Overcommitment
General · Concept · Current · Intermediate
Allocating more vCPUs or memory to VMs than physically exist, relying on not all being busy at once. Monitoring shows CPU ready time above 10%, a sign the host's vCPU overcommitment is too high.
VM sprawl
General · Concept · Current · Beginner
Uncontrolled growth of forgotten or unused VMs wasting licences, storage and security effort. An audit finds 90 VMs with no owner; 60 are retired, freeing 25 TB of storage.

6.13 MicroVMs, Serverless Isolation and VMs vs Containers

Containers start fast and are small, but share the host's kernel; VMs isolate strongly but have traditionally been heavy. MicroVMs such as AWS Firecracker close the gap: tiny virtual machines with only a handful of virtual devices that boot in around a tenth of a second, so cloud providers can give every serverless function or container its own hardware-isolated sandbox.

VMs, microVMs and containers

Traditional VM MicroVM Container
Kernel own full guest kernel own minimal guest kernel shares host kernel
Isolation boundary hardware virtualization hardware virtualization namespaces, cgroups
Boot / start time tens of seconds about 125 ms milliseconds to 1 s
Memory overhead hundreds of MB under 5 MiB VMM a few MB
Devices many emulated + PV a few virtio devices host devices via kernel
Different OS yes (Windows, BSD) Linux guests mainly same kernel only
Typical use general servers serverless, sandboxes microservices, CI

MicroVMs keep a separate guest kernel but strip everything else away.

Think of it like…

A traditional VM is a fully furnished house, a container is a room in a shared house, and a microVM is a prefabricated tiny home: its own walls, door and lock like a house, but quick to put up and cheap enough to give everyone one.

Real-world example

The fictional Quickbite food-delivery app processes every order with short serverless functions. On AWS Lambda each function runs inside its own Firecracker microVM, so a bug in a neighbouring customer's code cannot reach Quickbite's data. Its developers still package code as container images, getting container convenience with VM-level isolation.

How it works

  1. A control plane receives a request to run a function or container.
  2. A minimal VMM (Firecracker, Cloud Hypervisor) asks KVM to create a microVM with a few vCPUs, a little memory and virtio devices.
  3. A stripped-down guest kernel boots directly (no BIOS or bootloader) and starts the workload or a small agent.
  4. The workload runs isolated by hardware virtualization; the VMM process itself is jailed with seccomp and cgroups.
  5. When work ends the microVM is destroyed or snapshotted so it can be restored quickly next time.

Who uses it

Cloud and serverless platform engineers, security architects designing multi-tenant systems, platform teams choosing between VMs and containers, and SREs.

Key takeaway

Know the trade-off triangle — VMs: strongest isolation, slowest and heaviest; containers: lightest and fastest, shared kernel; microVMs: VM-grade isolation with near-container speed and density.

Going deeper

  • Firecracker, open-sourced by AWS in November 2018 and written in Rust, powers Lambda and Fargate; AWS cites start-up in about 125 ms, under 5 MiB overhead per microVM and up to 150 microVMs per second per host.
  • Firecracker deliberately emulates only virtio-net, virtio-block, virtio-vsock, a serial console and a minimal keyboard controller (used for reset) — no USB, PCI passthrough or GPU — to keep the attack surface tiny.
  • Cloud Hypervisor (originally from Intel, now a Linux Foundation project) and Google's crosvm are related Rust VMMs that share components through the rust-vmm project; Cloud Hypervisor adds features like hotplug and passthrough for cloud workloads.
  • Kata Containers runs each Kubernetes pod inside a lightweight VM (with QEMU, Cloud Hypervisor or Firecracker) so container images keep working while gaining a VM boundary.
  • Snapshot-and-restore of microVMs reduces cold starts further: AWS Lambda SnapStart restores functions from a cached Firecracker snapshot of an initialised runtime.
  • Containers share one kernel, so a kernel vulnerability can break isolation between tenants; that is why public clouds put untrusted customers' containers inside VMs or microVMs, while trusted internal workloads often share hosts.
  • VMs remain the right choice for different operating systems (Windows, BSD), legacy monolithic apps, kernel-level customisation, and licence or compliance boundaries; containers win for fast-changing microservices and CI pipelines.

Common mistakes & misconceptions

  • Treating containers as equally strong isolation as VMs — they share the host kernel; use VMs, microVMs or sandboxed runtimes for untrusted multi-tenant code.
  • Assuming microVMs can run anything a VM can — minimal devices mean no GPUs, USB or Windows guests in Firecracker.
  • Framing VMs versus containers as either-or — most production Kubernetes nodes are themselves VMs, combining both layers.

Try it: Peek at what Firecracker needs (Linux host with KVM; download the release binary from the official GitHub)

ls -l /dev/kvm                                   # KVM must be available
./firecracker --api-sock /tmp/fc.sock &          # start the VMM, configured via REST API
curl --unix-socket /tmp/fc.sock -X PUT http://localhost/machine-config \
  -d '{"vcpu_count": 1, "mem_size_mib": 256}'
# then set boot-source (kernel), drives (rootfs) and call InstanceStart

Key kernels, commands, tools, standards & concepts

Name What it does Example
MicroVM
General (popularised by AWS Firecracker) · Concept · Current · Intermediate
A minimal VM with few virtual devices and a slim kernel, built for fast start-up and high density. A CI provider starts a fresh microVM for every job and throws it away afterwards.
Firecracker
Amazon Web Services (open source, 2018) · Software · Current · Intermediate
Rust-based minimal VMM on KVM, configured through a REST API, powering Lambda and Fargate. Each Quickbite function invocation runs in a Firecracker microVM on a shared Lambda host.
Cloud Hypervisor
Linux Foundation project (Intel-originated) · Software · Current · Advanced
Rust-based VMM for modern cloud workloads on KVM and Microsoft's hypervisor, with hotplug and passthrough. Kata Containers can use Cloud Hypervisor as its VMM for faster pod start-up than QEMU.
crosvm
Google (ChromeOS) · Software · Current · Advanced
Rust VMM with sandboxed device processes, used for Linux and Android VMs on ChromeOS and Android. A Chromebook's Linux development environment runs inside a crosvm virtual machine.
rust-vmm
rust-vmm community · Resource · Current · Advanced
Shared Rust crates (KVM bindings, virtio devices, memory models) for building VMMs. A start-up builds its own sandbox VMM from rust-vmm crates instead of writing KVM code from scratch.
Kata Containers
OpenInfra Foundation · Software · Current · Intermediate
Gives each pod its own microVM, using QEMU, Cloud Hypervisor or Firecracker as the VMM, with a guest agent inside. A SaaS platform sets runtimeClassName: kata so customer code runs behind a VM boundary on shared nodes.
AWS Lambda
Amazon Web Services (2014) · Service · Current · Beginner
Serverless function service running code on demand, isolated per function in Firecracker microVMs. An image-resize function runs only when a photo is uploaded, billed per millisecond.
AWS Fargate
Amazon Web Services · Service · Current · Intermediate
Serverless containers for ECS and EKS where each task or pod runs in its own VM-isolated environment. A team runs containers without managing EC2 nodes; each Fargate task is isolated from other customers.
Lambda SnapStart
Amazon Web Services · Service · Current · Advanced
Reduces cold starts by restoring functions from a cached snapshot of an already initialised microVM. A Java function's start-up drops from seconds to well under one second with SnapStart.
Serverless isolation
General · Concept · Current · Intermediate
Keeping many customers' short-lived workloads separate on shared hosts, usually with microVMs or sandboxes. Two companies' functions run on the same server, each in its own microVM, never sharing a kernel.
Cold start
General · Concept · Current · Beginner
Extra latency when a function or container must start a new environment before handling a request. The first request after idle takes 400 ms; later requests reuse the warm microVM and take 20 ms.
VM vs container isolation
General · Concept · Current · Beginner
VMs isolate with separate kernels and hardware virtualization; containers isolate processes on a shared kernel. A kernel privilege-escalation bug lets a container escape to the host, but not out of a VM.
When to choose a VM
General · Concept · Current · Beginner
VMs suit different OSes, legacy apps, strong tenant isolation and kernel customisation. A legacy Windows ERP stays in a VM while new microservices run as containers on Kubernetes.
libkrun
Red Hat / containers community · Software · Emerging · Advanced
A library giving processes a KVM-based microVM, used by Podman's krun runtime and Apple silicon container tools. podman run --runtime krun starts a container inside its own tiny VM.

6.14 Virtual Desktops (VDI and DaaS)

Virtual Desktop Infrastructure (VDI) runs users' Windows or Linux desktops as VMs in a data centre or cloud. Users connect from any laptop, thin client or tablet using a remote display protocol; only screen pixels, keyboard and mouse travel over the network, so data never leaves the data centre. Cloud versions are called Desktop-as-a-Service (DaaS), such as Azure Virtual Desktop and Windows 365.

Only pixels and input cross the network; the desktop and its data stay in the data centre.
Connecting to a virtual desktop. Only pixels and input cross the network; the desktop and its data stay in the data centre.

Think of it like…

VDI is like a library reading room: instead of taking valuable books home (data on laptops), readers come to a secure room and read them there — and with VDI the 'room' appears on any screen they use.

Real-world example

The fictional Meridian Health network gives 1,200 clinicians non-persistent Windows 11 desktops on Azure Virtual Desktop. A nurse taps her badge on a ward thin client, her session follows her from room to room, and FSLogix loads her profile in seconds. Patient data stays in Azure, so a stolen thin client exposes nothing.

How it works

  1. The user opens a client app or browser and signs in through the gateway, usually with MFA.
  2. The connection broker checks entitlements and picks a desktop or session host from a pool, powering one on if needed.
  3. The user's profile (for example an FSLogix container) attaches at sign-in.
  4. A display protocol (RDP, HDX, Blast Extreme, PCoIP) streams the screen and returns keyboard, mouse, audio and USB.
  5. At sign-out, non-persistent desktops reset to the golden image, ready for the next user.

Who uses it

End-user computing (EUC) engineers, Citrix and Omnissa Horizon administrators, Azure Virtual Desktop and Windows 365 admins, and healthcare, finance and education IT teams.

Key takeaway

Know the four big platforms — Citrix (Cloud Software Group), Omnissa Horizon (formerly VMware Horizon), Azure Virtual Desktop and Windows 365 — and the difference between persistent and non-persistent desktops.

Going deeper

  • Persistent desktops keep each user's changes like a personal PC; non-persistent (pooled) desktops reset at sign-out, making patching and security easier but requiring profile and app-layering tools.
  • Windows 11 Enterprise multi-session, offered only through Azure Virtual Desktop (in Azure or on Azure Local), lets several users share one Windows client VM, cutting cost per user.
  • Windows 365 (launched August 2021) sells a fixed-price persistent Cloud PC per user, while Azure Virtual Desktop is pay-as-you-go infrastructure you design and size yourself.
  • Main display protocols: Microsoft RDP (default port 3389, with UDP transport and RDP Shortpath), Citrix HDX/ICA, Omnissa Blast Extreme and PCoIP (now HP Anyware) — each adapts compression to bandwidth and latency.
  • FSLogix profile containers store each user's profile in a VHDX on a file share and attach it at sign-in, so non-persistent desktops feel personal; Microsoft includes FSLogix with most Microsoft 365 licences.
  • Broadcom sold VMware's end-user computing business, including Horizon, to KKR in 2024, creating Omnissa; Citrix is owned by Cloud Software Group alongside XenServer.
  • GPU-accelerated VDI with NVIDIA vGPU serves designers and engineers running CAD; sizing usually starts from per-user vCPU, RAM and IOPS profiles (task, knowledge and power users).

Common mistakes & misconceptions

  • Assuming VDI is cheaper than laptops — savings come from security and management; infrastructure, licences and storage IOPS often cost more than expected.
  • Forgetting the 'boot storm' — hundreds of desktops starting or signing in at 9 a.m. overload storage unless you pre-start pools or size for peak.
  • Ignoring latency — remote desktops feel sluggish beyond roughly 100-150 ms round-trip; place hosts near users.

Try it: See the remote display protocol from the inside of a Windows session

# In a Windows desktop session (PowerShell)
query session                 # shows rdp-tcp#N if you are connected via RDP
$env:SESSIONNAME             # Console = local; RDP-Tcp#n = remote session
# On the client: mstsc /v:server.example.com opens a Remote Desktop connection

Key kernels, commands, tools, standards & concepts

Name What it does Example
Virtual Desktop Infrastructure (VDI)
General · Concept · Current · Beginner
Hosting user desktops as VMs centrally and delivering them over a remote display protocol. Call-centre staff use thin clients to reach Windows desktops running in the company data centre.
Desktop-as-a-Service (DaaS)
General · Concept · Current · Beginner
Virtual desktops delivered as a cloud subscription, with the provider running the infrastructure. A start-up gives contractors Cloud PCs instead of shipping them laptops.
Persistent vs non-persistent desktops
General · Concept · Current · Beginner
Persistent desktops keep user changes; non-persistent ones reset to a golden image at sign-out. Developers get persistent desktops; hospital ward staff use non-persistent pooled desktops.
Azure Virtual Desktop (AVD)
Microsoft · Service · Current · Intermediate
Microsoft's cloud VDI service with pooled or personal host pools and Windows 11 multi-session. Meridian Health runs 60 multi-session hosts serving 1,200 clinicians on AVD.
Windows 365 Cloud PC
Microsoft (2021) · Service · Current · Beginner
A per-user, fixed-price persistent Windows Cloud PC managed through Intune. A new hire signs in to windows365.microsoft.com from a personal Mac and gets her work PC.
Windows 11 Enterprise multi-session
Microsoft · Operating system · Current · Intermediate
A Windows client edition allowing several simultaneous interactive users, offered through Azure Virtual Desktop. Ten finance users share one 8-vCPU multi-session VM instead of ten single-user VMs.
Citrix Virtual Apps and Desktops
Citrix (Cloud Software Group) · Software · Current · Intermediate
Long-established VDI and published-application platform using the HDX protocol. A bank publishes its trading application through Citrix to brokers working from home.
Omnissa Horizon
Omnissa (formerly VMware Horizon) · Software · Current · Intermediate
VDI and app-publishing platform using the Blast Extreme protocol, now owned by KKR-backed Omnissa. A university provides Horizon desktops with engineering software to students' own laptops.
Amazon WorkSpaces
Amazon Web Services · Service · Current · Intermediate
AWS's managed virtual desktop service for Windows and Linux desktops. A consultancy spins up WorkSpaces for a three-month project team, then deletes them.
Remote Desktop Protocol (RDP)
Microsoft · Specification · Current · Beginner
Microsoft's remote display protocol, default TCP/UDP port 3389, used by Remote Desktop, AVD and Windows 365. mstsc /v:server01 opens an RDP session; exposing 3389 directly to the internet invites attacks.
HDX, Blast Extreme and PCoIP
Citrix; Omnissa; HP (Anyware) · Specification · Current · Intermediate
Vendor display protocols optimising graphics, audio, video and USB redirection over varied networks. Blast Extreme adapts video quality so a Horizon session stays usable over hotel Wi-Fi.
Connection broker
General · Component · Current · Intermediate
Authenticates users, checks entitlements and assigns them to an available desktop or session host. The broker sends Raj to the least-loaded session host in the 'Finance' pool.
FSLogix profile containers
Microsoft · Software · Current · Intermediate
Stores each user's profile in a VHDX attached at sign-in, making non-persistent desktops feel personal. Outlook's cache follows each nurse between pooled desktops because it lives in her FSLogix container.
Thin clients
IGEL, HP, Dell and others · Concept · Current · Beginner
Low-power, locked-down endpoints whose main job is connecting to virtual desktops. Ward thin clients have no local data, so losing one is a non-event for security.
Remote Desktop Services (RDS)
Microsoft (Windows Server) · Service · Current · Intermediate
On-premises session-based desktops and RemoteApp programs hosted on Windows Server. A small firm publishes its accounting app via RDS RemoteApp to 25 users.