The Best of Both Worlds: Running VMs Inside Kubernetes on Dedicated Servers Using KubeVirt

Infrastructure engineering teams frequently face a costly dilemma: how to modernise applications without abandoning legacy workloads. Modern microservices run inside Kubernetes containers, but legacy databases, monolithic applications, or Windows Server instances still require traditional Virtual Machines (VMs).

Traditionally, companies renting bare-metal dedicated servers solved this by building two separate clusters: one running a hypervisor like VMware ESXi or Proxmox for VMs, and another running bare-metal Kubernetes for containers. This dual-infrastructure approach doubles your hardware spend, complicates network architecture, and creates operational silos.

Fortunately, KubeVirt eliminates this compromise. KubeVirt is an open-source Kubernetes extension that allows you to run traditional Virtual Machines natively inside Kubernetes pods. In this tutorial, we will walk you through setting up a KubeVirt bare metal dedicated server environment, empowering you to replace VMware on dedicated servers and manage all your containerized and virtualized workloads through a single kubectl interface.

What You'll Learn

The Dual-Infrastructure Trap (VMware vs. Kubernetes)

When migrating infrastructure to high-performance bare-metal servers, many enterprises attempt to run Kubernetes inside virtual machines on top of a hypervisor like Proxmox or VMware. While this provides VM flexibility, it introduces a major performance penalty known as virtualization overhead. You lose direct access to raw NVMe storage, CPU instruction sets, and network interfaces.

Conversely, running Kubernetes directly on bare metal gives you 100% hardware efficiency, but leaves no room for legacy monolithic apps or Windows services that cannot easily be containerized into Docker images.

How KubeVirt Architecture Works Under the Hood

KubeVirt solves this by flipping the architecture on its head: instead of running Kubernetes inside virtual machines, you run VMs inside Kubernetes.

KubeVirt adds custom resource definitions (CRDs) to your Kubernetes API server. When you request a Virtual Machine, KubeVirt creates a standard Kubernetes Pod called a virt-launcher. Inside this pod, KubeVirt executes a standard QEMU/KVM instance.

To Kubernetes, the VM is just another pod that can be scheduled, network-routed, monitored, and backed up like any container. To the operating system inside the VM, it is a full virtual machine with dedicated vCPUs, RAM, virtual disks, and network interface cards (NICs).

Step 1: Bare Metal Hardware Prerequisites & Hardware Virtualization

Because KubeVirt runs actual KVM virtual machines, your underlying bare-metal dedicated server must support hardware-assisted virtualization (Intel VT-x or AMD-V).

egrep -c '(vmx|svm)' /proc/cpuinfo
                                

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

ls -l /dev/kvm
                                

Step 2: Preparing Your Bare-Metal Kubernetes Cluster

To follow this tutorial, you should have an existing bare-metal Kubernetes cluster (v1.28 or newer) running on your iDatam dedicated server infrastructure.

Verify that your cluster nodes are healthy and kubectl is configured:

kubectl get nodes -o wide
                            

Ensure your container runtime (such as containerd) is operational across all worker nodes.

Step 3: Deploying the KubeVirt Operator and CRDs

KubeVirt uses an operator pattern to manage its lifecycle, deploy Custom Resource Definitions (CRDs), and manage virtualization components across worker nodes.

export KUBEVIRT_VERSION=$(curl -s https://api.github.com/repos/kubevirt/kubevirt/releases/latest | grep '"tag_name":' | sed -E 's/.*"([^"]+)".*/\1/')
echo "Installing KubeVirt Version: ${KUBEVIRT_VERSION}"
                                

kubectl apply -f https://github.com/kubevirt/kubevirt/releases/download/${KUBEVIRT_VERSION}/kubevirt-operator.yaml
                                

kubectl apply -f https://github.com/kubevirt/kubevirt/releases/download/${KUBEVIRT_VERSION}/kubevirt-cr.yaml
                                

kubectl get pods -n kubevirt -w
                                

kubectl get kubevirt -n kubevirt -o jsonpath='{.items[*].status.phase}'
                                

Step 4: Installing virtctl and Writing a VM Specification

To manage Virtual Machines (start, stop, pause, open serial consoles), KubeVirt provides a command-line tool called virtctl.

VERSION=$(curl -s https://api.github.com/repos/kubevirt/kubevirt/releases/latest | grep '"tag_name":' | sed -E 's/.*"([^"]+)".*/\1/')
curl -L -o virtctl https://github.com/kubevirt/kubevirt/releases/download/${VERSION}/virtctl-${VERSION}-linux-amd64
chmod +x virtctl
sudo mv virtctl /usr/local/bin/
                                

virtctl version
                                

apiVersion: kubevirt.io/v1
kind: VirtualMachine
metadata:
  name: ubuntu-legacy-app
  labels:
    app: legacy-database
spec:
  running: false
  template:
    metadata:
      labels:
        kubevirt.io/domain: ubuntu-legacy-app
    spec:
      domain:
        devices:
          disks:
            - name: containerdisk
              disk:
                bus: virtio
            - name: cloudinitdisk
              disk:
                bus: virtio
          interfaces:
            - name: default
              masquerade: {}
        resources:
          requests:
            memory: 2Gi
            cpu: "2"
      networks:
        - name: default
          pod: {}
      volumes:
        - name: containerdisk
          containerDisk:
            image: kubevirt/ubuntu-ci-container-disk:22.04
        - name: cloudinitdisk
          cloudInitNoCloud:
            userData: |
              #cloud-config
              user: idatam
              password: SecurePassword2026!
              chpasswd: { expire: False }
              ssh_pwauth: True
                                

Step 5: Provisioning, Launching, and Interacting with the VM

With your manifest prepared, you can manage the life cycle of your Virtual Machine using familiar Kubernetes commands.

kubectl apply -f ubuntu-vm.yaml
                                

kubectl get vm
                                

virtctl start ubuntu-legacy-app
                                

kubectl get vmi
kubectl get pods
                                

virtctl console ubuntu-legacy-app
                                

kubectl expose vmi ubuntu-legacy-app --name=ubuntu-vm-ssh --port=22 --type=NodePort
                                

kubectl get svc ubuntu-vm-ssh
                                

ssh -p <NodePort> idatam@<Server-IP>
                                

By consolidating your infrastructure on a KubeVirt bare metal dedicated server, you get the efficiency and raw performance of bare-metal Kubernetes alongside the isolation and compatibility of traditional Virtual Machines. This strategy allows you to sunset costly hypervisor licenses, streamline cluster administration, and run your entire software stack on unified bare-metal hardware.