Modernizing Enterprise Infrastructure: Deploying KubeVirt to Run Legacy Windows and Linux VMs Inside Kubernetes

The Paradigm Shift in Enterprise Infrastructure: Unifying Containers and Virtual Machines

As enterprise IT departments accelerate their cloud-native journeys, a common architectural roadblock emerges: the persistent reliance on legacy workloads. While microservices and containers offer unparalleled scalability and velocity, many core business systems remain deeply anchored in traditional virtual machines (VMs). These systems—ranging from proprietary Windows-based enterprise resource planning (ERP) systems to legacy Linux kernels running critical database engines—cannot be easily containerized without massive code refactoring, unacceptable risks, and prohibitive engineering costs.

Historically, organizations have been forced to maintain separate, siloed infrastructure stacks: a traditional virtualization platform (such as VMware vSphere or Microsoft Hyper-V) alongside a modern container orchestration platform like Kubernetes. This dual-stack architecture introduces significant structural friction, including duplicate operational overhead, disparate monitoring tools, fragmented security compliance matrices, and inflated licensing costs.

KubeVirt solves this systemic challenge. As a Cloud Native Computing Foundation (CNCF) incubating project, KubeVirt provides a virtual machine management add-on for Kubernetes. By extending the Kubernetes API via Custom Resource Definitions (CRDs), KubeVirt allows operators to run, manage, and provision traditional virtual machines side-by-side with standard application containers within the exact same Kubernetes cluster.

Understanding the KubeVirt Architecture

To successfully operate KubeVirt in a production environment, it is critical to understand how it abstracts and integrates virtualization artifacts into cloud-native paradigms. KubeVirt does not reinvent hypervisor technology; instead, it orchestrates standard, proven virtualization technologies through Kubernetes primitives.

At its core, KubeVirt leverages KVM (Kernel-based Virtual Machine) and QEMU inside standard Linux containers to execute virtual machine instances. The architecture is composed of several key components that coordinate seamlessly:

virt-api: This component serves as the entry point for all virtualization-related API requests. It acts as an API extension server, validating and mutating custom resources like VirtualMachine and VirtualMachineInstance.
virt-controller: Operating as a standard Kubernetes controller, it monitors the state of custom resources and manages the lifecycle of VM pods. It is responsible for creating the pods in which the VMs actually execute.
virt-handler: Deployed as a DaemonSet across all worker nodes, this component communicates directly with the local containerd or CRI-O runtime. It is responsible for configuring the host network and storage interfaces and launching the virtualization backend.
virt-launcher: For every virtual machine instance created, a corresponding virt-launcher pod is scheduled. This pod runs the actual QEMU/KVM process. If the VM within the pod crashes or terminates, the virt-launcher process reports the state back to the control plane, ensuring containment and isolation.

Prerequisites for Production-Grade Deployment

Before initiating the deployment of KubeVirt to host demanding workloads like Microsoft Windows Server or enterprise Linux distributions, your underlying infrastructure must meet strict validation criteria:

Hardware Virtualization Support: The underlying Kubernetes worker nodes must feature physical CPUs equipped with Intel VT-x or AMD-V virtualization extensions. KVM kernel modules must be loaded and accessible (/dev/kvm). While software emulation is possible for testing environments, it is structurally non-viable for production performance.
Container Network Interface (CNI): While standard overlay networks (like Flannel or basic Calico) can support VM communication, enterprise deployments typically require Multus CNI. Multus allows pods (and consequently VMs) to attach to multiple network interfaces, enabling dedicated storage networks or direct access to legacy VLANs via bridge interfaces.
Storage Provisioning (CSI): High-performance, persistent block storage is non-negotiable for VMs. Your Container Storage Interface (CSI) must support ReadWriteOnce (RWO) for local configurations and preferably ReadWriteMany (RWX) using block mode to enable advanced features like Live Migration.

Step-by-Step Implementation and Deployment

1. Deploying the KubeVirt Operator

KubeVirt utilizes the Operator pattern to manage its entire lifecycle. The operator handles upgrading, maintaining, and monitoring the virtualization components automatically. To deploy the KubeVirt Operator, we target the official release repository:

kubectl create -f https://github.com/kubevirt/kubevirt/releases/download/v1.1.0/kubevirt-operator.yaml

Once the operator is deployed and running, we trigger the creation of the actual KubeVirt control plane resource, which instructs the operator to spin up the virt-api, virt-controller, and virt-handler infrastructure components across the cluster:

kubectl create -f https://github.com/kubevirt/kubevirt/releases/download/v1.1.0/kubevirt-cr.yaml

2. Managing the Environment via virtctl

To interact effectively with virtual machines, operators require specialized subcommands that do not natively exist within kubectl. KubeVirt provides an administrative utility called virtctl. It enables actions such as starting, stopping, restarting, and opening native VNC/Serial consoles to the running operating systems. Install it locally via GitHub releases or through your local package managers:

Example: Accessing a VM console using virtctl: virtctl vnc my-windows-legacy-vm

Provisioning Legacy Storage: Importing Windows and Linux Disk Images

One of the primary challenges when migrating legacy VMs into KubeVirt is handling disk images. KubeVirt pairs perfectly with the Containerized Data Importer (CDI) project to streamline this onboarding flow. CDI uses custom resources like DataVolume to automate the downloading, unzipping, and conversion of standard VM image formats (such as .qcow2, .raw, or .vmdk) directly into persistent volume claims (PVCs).

Consider the following structured manifest designed to pull an official enterprise Linux cloud image into a dedicated Block mode PVC:

apiVersion: cdi.kubevirt.io/v1beta1
kind: DataVolume
metadata:
  name: enterprise-linux-golden-image
spec:
  source:
    http:
      url: "https://cloud.debian.org/images/cloud/bookworm/latest/debian-12-genericcloud-amd64.qcow2"
  pvc:
    accessModes:
      - ReadWriteOnce
    resources:
      requests:
        storage: 40Gi
    storageClassName: premium-block-storage
    volumeMode: Block

Architecting the VirtualMachine (VM) Definition

Once your underlying image is imported and attached to a PersistentVolume, you can define a declarative state for your virtual machine using a VirtualMachine manifest. Below is an enterprise-ready configuration that exposes custom resource limits, mounts the storage via a block device, and passes initialization configurations using cloud-init.

apiVersion: kubevirt.io/v1
kind: VirtualMachine
metadata:
  name: enterprise-legacy-app
  labels:
    kubevirt.io/os: linux
spec:
  running: true
  template:
    metadata:
      labels:
        kubevirt.io/domain: enterprise-legacy-app
    spec:
      domain:
        cpu:
          cores: 4
        resources:
          requests:
            memory: 8Gi
        devices:
          disks:
            - name: boot-volume
              disk: {}
            - name: cloudinitvolume
              disk: {}
          interfaces:
            - name: default
              masquerade: {}
      networks:
        - name: default
          pod: {}
      volumes:
        - name: boot-volume
          persistentVolumeClaim:
            claimName: enterprise-linux-golden-image
        - name: cloudinitvolume
          cloudInitNoCloud:
            userData: |
              #cloud-config
              password: TemporaryPassword123!
              chpasswd: { expire: False }
              ssh_pwauth: True

Operational Superiority: The Enterprise Benefits of KubeVirt

By shifting to a unified KubeVirt model, enterprise organizations achieve distinct strategic and operational transformations:

Unified Declarative GitOps Pipelines: Legacy VMs can now be defined as code. Your application teams can use tools like ArgoCD or Flux to deploy their entire stack—a legacy Windows service database combined with front-end React apps in containers—via a single unified repository.
Advanced Live Migration: KubeVirt enables zero-downtime maintenance operations. If an underlying physical worker node requires a kernel upgrade or hardware replacement, KubeVirt can seamlessly live migrate running Windows/Linux VMs to another node with minimal network interruption.
Shared Observability Ecosystem: Say goodbye to fragmented monitoring tools. Your legacy VMs now expose metrics directly to Prometheus and can be visualized seamlessly in Grafana alongside standard container metrics. Security audits, log aggregations via Fluentd/Loki, and network policies can be completely unified.

Conclusion

KubeVirt provides the definitive architectural link between legacy virtualized environments and modern cloud-native topologies. Instead of delaying modernizations or bearing the exorbitant risks of rush-refactoring business-critical systems, KubeVirt empowers IT organizations to migrate legacy Windows and Linux VMs cleanly inside a Kubernetes Cluster. By standardizing operations under a single, highly available control plane, your organization drastically cuts management complexity, eliminates platform siloes, and accelerates its journey toward comprehensive infrastructure modernization.