A hypervisor is the software that lets you run multiple virtual machines on a single physical machine, and the Kernel-based Virtual Machine (KVM) is one of the best. Built into Linux, KVM is fast (near-native performance), open-source (free!), and flexible (supports Windows, Linux, and more). It’s trusted by both cloud providers and homelabbers for its stability and low overhead.

If you want to turn your Ubuntu 24.04 or Kubuntu 24.04 (Kubuntu is a Ubuntu variant with KDE Plasma desktop) system into a powerful hypervisor without Proxmox’s complexity, this guide is for you. With KVM, you’ll spin up virtual machines (VMs) in minutes, and with Cockpit’s web-based manager, you’ll control them from your browser.

In this tutorial, you’ll transform an Ubuntu 24.04 or Kubuntu 24.04 Desktop or Server – fresh or existing – into a KVM hypervisor. You’ll set up the backend (KVM, QEMU, libvirt), add Cockpit for web-based VM management, and create a guest VM to test it all. Whether you’re a coder, homelabber, or IT enthusiast, this guide is beginner-friendly.

Table of Contents

• Before You Start: What You Should Know

• What You’ll Need

• Why KVM on Ubuntu/Kubuntu 24.04?

• Step 1: Check Virtualization Support

• Step 2: Install KVM and Backend Tools

• Step 3: Set Up a Network Bridge

• Step 4: Install Cockpit for Web Management

• Step 5: Create a Guest VM

• Step 6: Run and Test Your Guest VM

• Keep Exploring Your Hypervisor

• Wrapping Up

Before You Start: What You Should Know

This guide is designed for virtualization newcomers, but you’ll need a few basic skills:

• Running terminal commands like sudo apt install or nano and so on.

• Basic Linux navigation (for example, editing files in /etc).

• Basic networking knowledge, such as understanding network interfaces (for example, enp4s0 or wlp3s0), IP addresses, and concepts like bridging or NAT. You’ll use tools like ip link or nmcli to set up a network bridge in Step 3.

• Optional: Experience with VMs helps but isn’t required – I’ll explain everything.

No worries if terms like “libvirt” sound new. I’ll break them down as we go.

What You’ll Need

• A computer: Running Ubuntu 24.04 or Kubuntu 24.04 Desktop or Server (fresh or existing). Minimum: 4GB RAM, 20GB storage, CPU with virtualization support (Intel VT-x or AMD-V). More RAM/storage for multiple VMs.

• Internet access: To download packages and VM ISOs.

• A web browser: Firefox (default on Ubuntu) or Chrome to access Cockpit.

• An ISO image: An ISO image for your guest VM (for example, Ubuntu 24.04 Desktop ISO from ubuntu.com or Windows ISO if you have it already).

• 30–45 minutes: Depending on your setup speed.

Why KVM on Ubuntu/Kubuntu 24.04?

KVM turns your Linux kernel into a hypervisor, letting you run VMs with near-native speed. Paired with QEMU (for hardware emulation) and libvirt (for management), it’s a lightweight alternative to Proxmox or VMware. Its strengths include:

• Performance: Runs VMs efficiently, ideal for homelabs or dev environments.

• Free and Open-Source: No licenses, just like Ubuntu/Kubuntu, and so on.

• Flexibility: Supports diverse guest OSs (Linux, Windows, BSD).

• Integration: Cockpit’s web UI makes VM management a breeze, no CLI required.

Here’s what each tool does:

• KVM: A Linux kernel module that turns your system into a hypervisor, enabling VMs to run with near-native performance by leveraging CPU virtualization features (for example, Intel VT-x).

• QEMU: A powerful emulator that provides the virtual hardware (for example, CPU, disk, network) for your VMs, working with KVM for fast execution.

• libvirt: A management layer that simplifies VM creation, networking, and storage, offering tools like virsh and APIs for automation.

• Cockpit: A web-based interface for managing VMs, system resources, and networks, perfect for beginners who want a visual dashboard.

Ubuntu 24.04 (“Noble Numbat”) brings the latest kernel and tools, ensuring top-notch KVM compatibility. Let’s build your hypervisor!

Step 1: Check Virtualization Support

First, you’ll want to confirm that your CPU supports virtualization (most modern ones do). To do that, open a terminal (like Konsole on Kubuntu) and run:

lscpu | grep Virtualization

Look for "VT-x" (Intel) or "AMD-V" (AMD). If present, you’re good!

If nothing shows, check your BIOS/UEFI:

• Reboot, enter BIOS (usually F2, Del, or Esc).

• Enable "Intel VT-x" or "AMD-V" under CPU settings.

• Save and reboot.

Step 2: Install KVM and Backend Tools

Let’s install KVM, QEMU, and libvirt. These will form the backbone of your hypervisor:

Start by updating your system (you may need to restart your computer after the update):

sudo apt update && sudo apt upgrade -y

Then install the virtualization packages:

sudo apt install qemu-kvm libvirt-daemon-system libvirt-clients bridge-utils -y

• qemu-kvm: Emulates hardware for VMs.

• libvirt-daemon-system: Manages VMs.

• libvirt-clients: CLI tools like virsh for hypervisor management.

• bridge-utils: For network bridging.

Next, verify that KVM is loaded:

lsmod | grep kvm

You’ll see “kvm_intel” or “kvm_amd” if successful.

Finally, add your (current) user to the libvirt group for permission:

sudo usermod -aG libvirt $USER

Log out and back in to apply these changes.

Step 3: Set Up a Network Bridge

VMs need network access, so you’ll create a bridge (br0) to connect them to your physical network. This allows VMs to act like devices on your network (bridged networking).

Ubuntu 24.04 and Kubuntu 24.04 Desktop typically use NetworkManager, while Ubuntu Server may use Netplan. We’ll prioritize the NetworkManager approach, with Netplan as an alternative.

Note: Installing libvirt (Step 2) creates a default bridge called virbr0 for NAT-based networking, which isolates VMs from the physical network (IPs like 192.168.122.x). For direct network access (IPs like 192.168.0.x), use br0 as described below, and select it in Step 5’s VM setup.

You can verify whether your system is using NetworkManager or Netplan. Open a console and run systemctl status NetworkManager. If you see the status active and running, go with NetworkManager.

Option 1: NetworkManager (Recommended for Kubuntu/Ubuntu desktop)

Check your network interface:

ip link

Example: enp4s0. Replace enp4s0 below if yours differs.

First, find your Ethernet connection name:

nmcli connection show

Look for the NAME column where DEVICE is enp4s0 (for example, “Wired connection 1” or “Ethernet connection”). Note this name. Ignore virbr0, which is libvirt’s default NAT bridge.

Then create a bridge named br0:

sudo nmcli connection add type bridge ifname br0 con-name bridge-br0

Enslave your interface to the bridge:

sudo nmcli connection add type ethernet ifname enp4s0 master br0 con-name bridge-slave-enp4s0

Disable the old connection (replace with your connection name identified earlier):

sudo nmcli connection down "Wired connection 1"
sudo nmcli connection delete "Wired connection 1"

Enable DHCP on the bridge:

sudo nmcli connection modify bridge-br0 ipv4.method auto

Activate the bridge:

sudo nmcli connection up bridge-br0

Verify:

ip addr show br0
nmcli connection show

Now you’ll want to ensure br0 is active, enp4s0 is enslaved, and virbr0 is separate. First, test the internet with ping 8.8.8.8.

Then you need to define br0 in libvirt (to appear in Cockpit’s VM network dropdown). To do this, create br0.xml in your home directory:

nano ~/br0.xml

Then add the following:

<network>
  <name>br0</name>
  <forward mode='bridge'/>
  <bridge name='br0'/>
</network>

Save and exit (Ctrl+O, Enter, Ctrl+X).

Now define and start the following:

sudo virsh net-define ~/br0.xml
sudo virsh net-start br0
sudo virsh net-autostart br0

Verify like this:

virsh net-list --all

You can now delete ~/br0.xml after defining, as libvirt stores it in /etc/libvirt/qemu/networks/.

rm ~/br0.xml

Option 2: Netplan (For Ubuntu Server or If Preferred)

If you see renderer: networkd in /etc/netplan/???.yaml or prefer Netplan, follow these steps.

First, check your interface:

ip link

Example: enp4s0.

Next, edit the Netplan config like so:

sudo nano /etc/netplan/01-netcfg.yaml

Use the following:

network:
  version: 2
  renderer: networkd
  ethernets:
    enp4s0:
      dhcp4: no
  bridges:
    br0:
      interfaces: [enp4s0]
      dhcp4: yes

Save and exit (Ctrl+O, Enter, Ctrl+X).

Now, set strict permissions to avoid errors:

sudo chmod 600 /etc/netplan/01-netcfg.yaml

And apply:

sudo netplan apply

Now verify:

ip addr show br0

Test the internet with ping 8.8.8.8 (from console).

Troubleshooting:

• Permissions error: If Netplan complains about “too open” permissions, recheck sudo chmod 600 /etc/netplan/01-netcfg.yaml.

• NetworkManager conflict: If using Netplan, ensure /etc/netplan/01-network-manager-all.yaml is backed up or deleted (sudo mv /etc/netplan/01-network-manager-all.yaml /etc/netplan/01-network-manager-all.yaml.bak).

• No onternet: Restart NetworkManager (sudo systemctl restart NetworkManager) or reboot.

• Wrong bridge: If a VM uses virbr0 (NAT, 192.168.122.x), recheck Step 5’s network setting and select br0.

• br0 missing in Cockpit: Define br0 in libvirt (step 9 above) or ensure br0 is active (ip addr show br0).

Step 4: Install Cockpit for Web Management

Cockpit provides a slick web UI to manage VMs. Let’s go ahead and set it up.

First, you’ll need to install Cockpit and its VM plugin:

sudo apt install cockpit cockpit-machines -y

Then you can start and enable Cockpit:

sudo systemctl enable --now cockpit.socket
systemctl status cockpit.socket

Now open your browser (for example, Firefox on Ubuntu) and visit:

https://localhost:9090

Or use your KVM server’s IP (for example, https://192.168.0.100:9090) if remote. Log in with your username and password. Ignore the self-signed certificate warning.

Allow Cockpit’s port if you’re using a firewall:

sudo ufw allow 9090

You’ll see Cockpit’s dashboard. Turn on administrative access by clicking on “Turn on administrative access”. Then, click “Virtual Machines” to manage VMs.

Step 5: Create a Guest VM

Let’s create a guest VM using Cockpit. We’ll use an Ubuntu 24.04 Desktop ISO as an example:

To start, download the Ubuntu 24.04 Desktop ISO from ubuntu.com and save it (for example, /home/ranju/Downloads/ubuntu-24.04.1-desktop-amd64.iso).

In Cockpit, go to “Virtual Machines” and click “Create VM”. Here are the specs:

• Name: TestVM

• Installation Type: Local install media (or your desired installation type)

• Installation Source: Browse to your ISO (for example, /home/ranju/Downloads/ubuntu-24.04.1-desktop-amd64.iso).

• OS: Select “Ubuntu 24.04” (usually Cockpit auto-detects).

• Storage: Create new qcow2 volume (preferred). Note: disk is created in /var/lib/libvirt/images/.

• Storage limit: 20GB (adjust as needed).

• Memory: 4GB (adjust as needed).

Click “Create and Edit”. Cockpit opens an advanced dialog where there are options for customization (for example, CPU, Network Interfaces and Boot order, and so on). Make sure that br0 has been selected as interface source. Finally, click “Install”.

In Cockpit’s VM console, follow the installer to set up the guest OS (username, password, and so on).

Troubleshooting:

• Permissions error: If you have permission error for the ISO, then copy the ISO to the default temp folder (/tmp/) and locate the ISO from there.

    cp /home/ranju/Downloads/ubuntu-24.04.1.iso /tmp/
  

Step 6: Run and Test Your Guest VM

Your VM is running! Let’s test it:

1. In Cockpit, under “Virtual Machines,” click TestVM. You’ll see its console (a live view of the VM’s screen).

2. Log into the guest Ubuntu using the credentials you set.

3. Test networking:

   • Open a terminal in the VM (via Cockpit’s console).

   • Run ip addr in the console to confirm a physical network IP (for example, 192.168.0.x with br0, not 192.168.122.x with virbr0).

   • Run ping 8.8.8.8 to confirm internet access.

4. Experiment: Open a browser in the VM, visit a website, or install apps to simulate real use.

If the VM boots and connects to your network, your KVM hypervisor is rocking! You can stop, restart, or delete it from Cockpit.

Keep Exploring Your Hypervisor

You’ve turned your Ubuntu 24.04 into a KVM hypervisor – congrats! Try these next steps:

• Add more VMs: Create Windows or other Linux VMs using different ISOs.

• Use virt-manager: Install virt-manager for a desktop-based alternative to Cockpit (sudo apt install virt-manager).

• Back up VMs: Export VM disks with virsh for safety.

• Scale up: Add storage or RAM for heavier workloads, like my Proxmox cluster guide.

Check your VMs anytime via CLI:

virsh list --all

Wrapping Up

You’ve built a fast, free KVM hypervisor on Ubuntu 24.04, complete with Cockpit’s web UI and a running guest VM. It’s a perfect playground for coding, testing, or homelab fun.

Share your ideas or comments with me – I’d love to hear them!

In this tutorial, you’ll set up a 3-node Proxmox cluster using three computers (or virtual machines for practice). By the end, you’ll have a working cluster ready to host virtual machines (VMs) and experiment with cool features like guest migration and VM replication etc.

Let’s dive in!

Prerequisites: What You’ll Need to Know

This guide is beginner-friendly for clustering, but you’ll need some basic skills to follow along. You should be comfortable with:

• Installing an OS from a USB drive (don’t worry, I’ll walk you through the steps).

• Using a terminal for simple commands like ping or nano.

• Setting up a home network with static IPs (for example, knowing your router’s IP range). No advanced virtualization or clustering experience is required—I’ll explain the key concepts as we go.

What You’ll Need

• Three computers (or VMs): Start with at least 8GB RAM and 100GB storage per machine, plus a virtualization-capable CPU (most modern ones work). These specs are a baseline—actual RAM and storage depend on how many VMs you want to host (e.g., more VMs need more resources).

• Proxmox VE: Free and open-source. Grab the ISO from proxmox.com.

• Network connection: All three must be on the same network and be able to ping each other.

• A web browser: For Proxmox’s web interface.

• 30–60 minutes: Depending on your setup pace.

Why Proxmox and Clustering?

Proxmox VE is a free, open-source virtualization platform built on Debian Linux. It uses KVM for VMs (fully virtualized systems) and LXC for containers (lightweight app environments), all managed via a slick web interface.

Clustering means linking multiple Proxmox machines—called nodes—so they act as one system. Think of it like a team: each node shares the workload, and you control them from a single dashboard. This setup lets you move (migrate) VMs between nodes, boost reliability, and experiment with high availability (HA)—where VMs auto-restart (on healthy node) if a node fails.

Plus, Proxmox offers a handy replication feature: it can sync VM data between nodes automatically, keeping backups ready if something goes wrong.

It’s a must-have skill for DevOps, app testing, or IT tinkering.

2 Nodes vs. 3 Nodes: Which Should You Choose?

Before we build your 3-node cluster, let’s explore your options. Clustering can start with 2 nodes or go to 3 (or more). Here’s why you might pick one over the other:

• 2-Node Cluster:

  • Pros: Easier setup with just two machines. Great for learning basics or small projects. Uses less hardware.

  • Cons: No quorum—a voting majority to keep the cluster running if a node fails—so HA isn’t reliable. You’d need an extra trick (like a quorum device) to avoid stalling.

  • Best For: Learning, Testing clustering, or limited resources.

• 3-Node Cluster:

  • Pros: Built-in quorum—two out of three nodes keep things going if one crashes. Ideal for HA practice. More stable and scalable.

  • Cons: Needs an extra machine and a bit more setup time.

  • Best For: Serious learners or small production setups.

We’ll go with 3 nodes—it’s the sweet spot for stability and real-world skills.

Step 1: Install Proxmox VE on All Three Machines

First, download the Proxmox VE ISO from proxmox.com. Make a bootable USB with Rufus (Windows), dd (Linux/macOS), or Raspberry Pi Imager (available for all platforms).

For dd, use this command (replace placeholders with your ISO and USB device):

sudo dd if=proxmox-ve.iso of=/dev/sdX bs=1M status=progress oflag=sync

Boot each machine from the USB and follow the installer. Stick with the default partitioning scheme (it uses EXT4 filesystem) and set static IPs and hostnames as follows (or you can use your own IPs knowing your router’s IP range):

• Node 1: 172.20.1.101 [hostname: node01.local]

• Node 2: 172.20.1.102 [hostname: node02.local]

• Node 3: 172.20.1.103 [hostname: node03.local]

After installation, each node displays its IP on the console (for example, https://172.20.1.101:8006). Test it by opening a browser, visiting each IP, and logging in with root and your password. You’ll see the Proxmox dashboard.

Step 2: Prepare Your Nodes

Now, let’s get your nodes ready to talk to each other—a crucial step for clustering. Without this, they won’t recognize each other properly.

Update /etc/hosts on all three nodes to map IPs to hostnames (since we’re not using a DNS server). Open the file with:

nano /etc/hosts

Add these lines (IPs and hostnames) on each node:

172.20.1.101 node01.local node01
172.20.1.102 node02.local node02
172.20.1.103 node03.local node03

Save and exit (Ctrl+O, Enter, Ctrl+X). This ensures nodes can resolve each other’s names (for example, node01 pings node02.local).

Next, check connectivity. From Node 1’s console (or SSH), ping the others:

ping 172.20.1.102

ping 172.20.1.103

Repeat from Node 2 and Node 3. If pings fail, check your network or firewall.

Finally, sync their clocks—clusters need precise time to coordinate. On each node, run:

ntpdate pool.ntp.org

All three nodes are now primed for clustering.

Step 3: Create the Cluster on Node 1

Let’s set up the cluster starting with Node 1. Log into its web interface at https://172.20.1.101:8006. On the left sidebar, click Datacenter, then Cluster. Hit the Create Cluster button, and a dialog pops up. Name your cluster—let’s call it MyCluster and click Create. A task window will appear, showing the process. Wait a few seconds until you see “TASK OK”—that means your cluster is live and Node 1 is its first member. Now we can add the other nodes!

Step 4: Join Node 2 and Node 3 to the Cluster

With the cluster created, let’s bring in Node 2 and Node 3. On Node 1’s cluster page, click Join Information, then Copy Information—this copies a key you’ll need.

Open Node 2’s web interface (https://172.20.1.102:8006), go to Datacenter > Cluster > Join Cluster, paste the key into the Information field, enter Node 1’s root password, and click Join MyCluster.

Repeat this process on Node 3’s interface (https://172.20.1.103:8006). Refresh Node 1’s dashboard—under Datacenter, you’ll see all three nodes with green checkmarks.

Your 3-node cluster is up!

Step 5: Test Your Cluster

Let’s verify it works by creating and moving a test VM. On Node 1, click Create VM, name it TestVM, skip the ISO, and finish with defaults (no disk content needed). Hit the Start button to boot it up.

Now, let’s migrate it around—migration means moving the VM from one node to another to test your cluster’s flexibility. Right-click TestVM, select Migrate, choose Node 2, and click Migrate. The VM stops briefly, copies to Node 2, and restarts (normal without shared storage).

Repeat this, migrating it from Node 2 to Node 3. If it hops between nodes successfully, your cluster’s rocking! With three nodes, you’ve got quorum—try shutting down Node 3 to see the others stay active.

What’s Next?

You’ve built a 3-node Proxmox cluster for free—congrats! Take it further with:

• Shared storage: Add NFS or a spare drive for live VM migration (no stopping/shutdown needed).

• High Availability: Enable HA—VMs auto-restart on a healthy node if one fails.

• VM Replication: Configure Replication—Sync VM data between nodes automatically, keeping backups ready if something goes wrong.

• Scale up: Add more nodes or try LXC containers.

Check your cluster’s health anytime (from console) with:

pvecm status

Wrapping Up

You’ve just set up a 3-node Proxmox cluster at no cost. It’s a playground for virtualization, DevOps practice, or even hosting small projects. Share your thoughts with me – I’d love to hear how you liked it.