Virtualisation¶

Exercise virtualisation-annex.pdf · PDF

In the next three weeks you will install Debian, Ubuntu Server and Windows 11. How many PCs do you have? One. And you are not allowed to erase its Ubuntu. So how?

You could buy a second disk, or carry three USB sticks, or ask for three PCs each. Or you could build three computers out of software, all running at the same time inside one real machine. That is what every cloud provider sells, what the Android emulator on a programmer's laptop is, and what you will do tomorrow.

One kitchen, three restaurants¶

Some restaurants on delivery apps have no dining room at all. Several brands cook in one shared kitchen, and the customer never knows.

Now translate it:

flowchart TB
    subgraph VMS ["Virtual machines"]
        direction LR
        subgraph VM1 ["VM: deb-lab"]
            A1["Apps"] --- G1["<b>Guest</b><br>Debian 13"]
        end
        subgraph VM2 ["VM: ubu-srv"]
            A2["Apps"] --- G2["<b>Guest</b><br>Ubuntu Server"]
        end
        subgraph VM3 ["VM: win11"]
            A3["Apps"] --- G3["<b>Guest</b><br>Windows 11"]
        end
    end
    VMS --> HV["<b>Hypervisor</b><br>the coordinator: shares CPU, RAM, disk"]
    HV --> HOS["<b>Host OS</b><br>Linux on the class server"]
    HOS --> HW["<b>Host hardware</b><br>the server's real CPU, RAM and SSD"]

The guest does not know it is a guest. Debian inside a VM checks its hardware, loads its drivers and writes to its disk exactly as it would on a real PC. And its "disk" is one file in a folder of the host: delete that file and the whole computer is gone.

Why virtualise?¶

For a developer this is daily life: one laptop that tests your app on Windows, on Linux and on Android. The Android emulator is a virtual machine.

A little history¶

The idea is older than the PC. In the 1960s a computer cost millions and had to be shared. At an IBM research centre in Cambridge, Massachusetts, a system called CP-40 gave each user a complete virtual computer; it was in daily use by 1967. On 2 August 1972 IBM announced it as a product, VM/370.

Then small, cheap PCs arrived and nobody needed it — until PCs became powerful enough to have power to spare. In 1999 a new company, VMware, sold the first program that ran virtual machines on an ordinary PC.

Two kinds of hypervisor¶

Where does the coordinator sit? The classic answer, from research by Popek and Goldberg in 1974, gives two types:

flowchart TB
    subgraph T1 ["Type 1: bare metal"]
        direction TB
        V1["VM · VM · VM"] --> H1["<b>Hypervisor</b>"] --> HW1["Hardware"]
    end
    subgraph T2 ["Type 2: hosted"]
        direction TB
        V2["VM · VM"] --> H2["<b>Hypervisor</b><br>an app"] --> OS2["Host OS"] --> HW2["Hardware"]
    end

Our tools: virt-manager, libvirt, QEMU, KVM¶

Four pieces of software work together, one on top of the other:

flowchart TB
    VMM["<b>virt-manager</b><br>the window you click"] -->|"orders"| LV["<b>libvirt</b><br>the list of VMs"]
    LV -->|"starts"| Q["<b>QEMU</b><br>imitates disk, network, screen"]
    Q -->|"through /dev/kvm"| K["<b>KVM</b><br>kernel module"]
    K --> CPU["<b>Real CPU</b><br>with VT-x / AMD-V"]

Is KVM type 1 or type 2? It lives inside the kernel and touches the hardware directly, so it is usually counted as type 1 — even though a normal Linux system runs around it. The two types are a useful map, not a law. Proxmox VE, which you will install later in this unit, is KVM with a web page on top.

Where does the stack run in this course?¶

On two machines. The VMs of this course do not run on the classroom PC. They run on the class server: a real, powerful machine in a data centre that your teacher switches on before each class. The server is the host: libvirt, QEMU and KVM run there. Your classroom PC runs only virt-manager, which shows each VM's screen and sends it your mouse and keyboard — like a remote control.

flowchart LR
    subgraph PC ["Your classroom PC (Ubuntu)"]
        VMM["<b>virt-manager</b><br>the window you click"]
    end
    subgraph SRV ["Class server: the host"]
        direction TB
        LV["<b>libvirt</b><br>your own list of VMs"] --> Q["<b>QEMU</b>"] --> K["<b>KVM</b>"] --> CPU["<b>Real CPU</b>"]
    end
    VMM -->|"orders, over SSH"| LV

SSH (Secure Shell) is a secure way to log in to one computer from another and type commands on it, as if you were sitting at it.

Every student is a Linux user on the server, with their own libvirt, and sees only their own VMs. Your teacher hands you a slip with three things: the server address, your user name and your password. Your VMs stay on the server from one class to the next. In the kitchen story: the shared kitchen is across town, and your PC is the phone you place your orders with.

The CPU has to help¶

QEMU alone can imitate a whole processor in software — even a different one, like a phone's ARM chip on a PC. That is emulation: it works everywhere, and it is slow.

To run the guest's instructions on the real CPU, the processor itself must offer an extra level of privilege for the hypervisor, beyond the kernel mode you met in OS architecture. Intel calls it VT-x (first processors in November 2005); AMD calls it AMD-V (2006). Without it, no KVM.

It can be switched off in the firmware setup (Unit 1). That is a classic reason for "my virtual machine will not start".

Is the host ready?¶

Before building a VM, check that the kitchen can take it. The kitchen is the host — the class server — so that is where you check. Open a terminal on your PC (Ctrl+Alt+T), log in to the server with the user and password from your slip, and run these, in order. The Exercise sheet has a box for each answer.

ssh <user>@<server>        # the prompt changes to <user>@si: you are on the server
LC_ALL=C lscpu | grep -i virtualization
grep -E -c "vmx|svm" /proc/cpuinfo
lsmod | grep kvm
ls -l /dev/kvm
virt-host-validate qemu
groups
virsh -c qemu:///session list --all
nproc
free -h
df -h ~/.local/share/libvirt/images
exit                       # back to your PC

The first time, ssh may ask whether you trust the server's key: answer yes.

What each one tells you:

Verdict: the host is ready when steps 3, 4, 5 and 7 pass.

The budget: how many VMs fit?¶

These are the three VMs you will build in this unit:

On a single PC — your own at home, for example — the rule of the course is: keep 4 GB of RAM for the host. So all three at once need 10 + 4 = 14 GB.

• A PC with 16 GB: all three fit.
• A PC with 8 GB: not all three. deb-lab alone (4 + 4), or ubu-srv with nothing else heavy.

On the class server the same sum is done for the whole class: every classmate's VMs take their RAM from the same host. That is why the rule in class is shut down the VMs you are not using — the server is shared by everyone.

The other two resources are more forgiving:

• Disk: the 109 GB must be free in the end, but virtual disks start small and grow as the guest writes, so the space is not taken on day one.
• vCPUs: 6 vCPUs on a PC with 4 threads still works, because idle VMs give their turn back — time slices again, from What is an operating system?. RAM cannot be lent that way.

Of the three resources, RAM is the one that says no first. Remember it tomorrow when virt-manager asks how much to give.

Finish by writing up three of your checks as a short Markdown note, host-check-surname.md, on your PC, with the lab report template and one verdict line: "The host is / is not ready to run KVM virtual machines because...". Keep it: tomorrow's report starts by saying on which machine the work was done.

Key takeaways¶

• A virtual machine is a computer made of software. The real machine is the host; the OS inside the VM is the guest; the hypervisor creates VMs and shares the real hardware among them.
• A VM's virtual disk is a file on the host, and its vCPUs are time on real cores. A VM divides resources; it never adds them.
• Reasons to virtualise: test, isolate, recover, share.
• Type 1 hypervisors run on the hardware (ESXi, Hyper-V, Xen, Proxmox VE); type 2 run as an app (VirtualBox, VMware Workstation). KVM lives in the kernel and is usually counted as type 1.
• The stack: virt-manager → libvirt → QEMU (imitates devices) → KVM (kernel module), which needs VT-x / AMD-V, sometimes switched off in the firmware.
• In this course the host is the class server: libvirt, QEMU and KVM run there, and you check it over SSH. Your PC runs only virt-manager.
• Plan VMs by RAM first: keep 4 GB for the host on a single PC; on the shared server, shut down the VMs you are not using.

Quick check¶

Next: open virt-manager and build your first virtual machine — Your first VM with virt-manager.