Posted By
Managing infrastructure with both containers and traditional Virtual Machines (VMs) can be complex. While Kubernetes has transformed container management, many organizations still rely on VMs for legacy applications or compliance. This often leads to disorganized management tools and added complexity for DevOps teams, often resulting in silos and difficulties in scaling infrastructure.
KubeVirt addresses these challenges that DevOps teams face. It helps manage VMs alongside containers in Kubernetes. This allows users to use the same tools and processes for both. In this blog, I will show you how to deploy and manage VMs on Kubernetes using KubeVirt. I will cover the installation steps, create VMs, set up persistent storage, and provide an example that connects traditional virtualization with modern container management.
Prerequisites
Before we begin, we must have:
- A running Kubernetes cluster. We can set up a cluster using tools like minikube or any other Kubernetes provider
- kubectl configured to manage our Kubernetes cluster.
- Basic familiarity with Kubernetes concepts like pods, deployments, and services.
Steps to setup KubeVirt
First, we will select the latest version of KubeVirt and set the environment variable KUBEVIRT_LATEST_VERSION for future commands.
KUBEVIRT_LATEST_VERSION=$(curl -s https://api.github.com/repos/kubevirt/kubevirt/releases/latest | awk -F '[ \t":]+' '/tag_name/ {print $3}')
Install KubeVirt with latest version
This command sets up a "kubevirt" namespace, installs Custom Resource Definitions for KubeVirt, and configures an operator to start the KubeVirt installation when a configuration resource is detected.
kubectl create -f https://github.com/kubevirt/kubevirt/releases/download/${KUBEVIRT_LATEST_VERSION}/kubevirt-operator.yaml
Now Here We will be adding the Kubevirt Custom Resource (named kubevirt). This will prompt the KubeVirt operator to install the remaining components of KubeVirt.
kubectl create -f https://github.com/kubevirt/kubevirt/releases/download/${KUBEVIRT_LATEST_VERSION}/kubevirt-cr.yaml
NOTE: Working with minikube, direct access to local virtualization hardware might not be available. we may need to enable emulation mode.
kubectl -n kubevirt patch kubevirt kubevirt --type=merge --patch '{"spec":{"configuration":{"developerConfiguration":{"useEmulation":true}}}}'
Install the KubeVirt client, virtctl.
Until we complete the setup, we can download the virtctl command line client for KubeVirt.
curl -Lo virtctl https://github.com/kubevirt/kubevirt/releases/download/${KUBEVIRT_LATEST_VERSION}/virtctl-${KUBEVIRT_LATEST_VERSION}-linux-amd64
To ensure the downloaded binary is executable, execute the following command:
chmod +x virtctl
Put the virtctl binary in a directory included in your shell's PATH
mv virtctl $HOME/.local/bin mv virtctl /usr/local/bin
Wait for KubeVirt to finish deploying. We can check its deployment status by examining the phase of the Kubevirt Custom Resource (CR). Use the following command:
kubectl -n kubevirt get kubevirt
Once KubeVirt fully deploys, it will show:
NAME AGE PHASE kubevirt 1m Deployed
To get more details and pods deployed we can use
kubectl get pods -n kubevirt
Once the deployment completes, confirm all necessary Pods are running without issues.
Launch an instance
To create a virtual machine, install the VM manifest using the following command:
kubectl apply -f https://kubevirt.io/labs/manifests/vm.yaml
NAME_OF_VIRTUAL_MACHINE in above file is 'testvm'
Check the status of the virtual machine we just created:
kubectl get vm
Wait until it gets RUNNING
If the VM is currently in a stopped state. We can use virtctl to change its state to running:
virtctl start testvm
If failed, we can see the detailed status using
kubectl describe vm testvm
We will see a message that the VM was scheduled to start.
When we create a VirtualMachine, it automatically generates a VirtualMachineInstance, similar to how a Deployment manages Pods. This chain of actions eventually creates a Pod. We can view all these entities using a single 'kubectl get' command.
Connect to VM
Once the virtual machine is running, we can connect to its console using virtctl:
virtctl console testvm
To Exit press CTRL and "]" keys together
To stop and delete a virtual machine:
Stop the virtual machine using virtctl from outside the VM:
virtctl stop testvm
To delete the virtual machine
kubectl delete virtualmachine testvm
Persistent Storage for virtual machines:
For persistent storage in virtual machines, the KubeVirt project offers a solution through the Containerized Data Importer (CDI) add-on. CDI facilitates the import of virtual machine disk images into PersistentVolumeClaims (PVCs), providing a declarative approach to managing persistent storage.
Create a DataVolume:
CDI introduces a CustomResourceDefinition (CRD) called DataVolume (DV), which abstracts the creation and population of disk data onto PVCs in a Kubernetes cluster. Once a DV is created, CDI handles the process of copying a disk image from the specified source into a PVC. Various source types are supported, including external targets like images served over HTTP, internal sources like other PVCs, or container disks in a registry. Below is an example DataVolume that imports a CirrOS image into a PVC, enabling the underlying VM to have persistent storage across reboots.
Install CDI
Get the Latest Version
export VERSION=$(curl -Ls https://github.com/kubevirt/containerized-data-importer/releases/latest | grep -m 1 -o "v[0-9]\.[0-9]*\.[0-9]*")
Install cdi
kubectl create -f https://github.com/kubevirt/containerized-data-importer/releases/download/$VERSION/cdi-operator.yaml
To trigger the deployment of CDI, create a CDI Custom Resource (CR). This will prompt the operator to deploy CDI.
kubectl create -f https://github.com/kubevirt/containerized-data-importer/releases/download/$VERSION/cdi-cr.yaml
Check the status and wait until it gets deployed
kubectl -n cdi get cdi NAME AGE PHASE cdi 45h Deployed
Once Deployed we are Ready to Work Further
Create a Data Volume from the required image:
ubuntu-dv.yaml
---
apiVersion: cdi.kubevirt.io/v1beta1
kind: DataVolume
metadata:
name: ubuntu
spec:
source:
http:
url: https://cloud-images.ubuntu.com/focal/current/focal-server-cloudimg-amd64.img
pvc:
accessModes:
- ReadWriteOnce
resources:
requests:
storage: 3Gi
Get it Executed using the following command We can change the url and storage according to our requirement
kubectl create -f ubuntu-dv.yaml
To check the DV status:
kubectl get dv
Create an instance from the data volume
Relace HASHED_PASSWORD, SSH_PUB_KEY with its values in the file below
ubuntu-vm.yaml
---
apiVersion: kubevirt.io/v1
kind: VirtualMachine
metadata:
labels:
kubevirt.io/os: linux
name: ubuntu-vm
spec:
running: true
template:
metadata:
creationTimestamp: null
labels:
kubevirt.io/domain: ubuntu-vm
spec:
domain:
cpu:
cores: 2
devices:
disks:
- disk:
bus: virtio
name: disk0
- cdrom:
bus: sata
readonly: true
name: cloudinitdisk
resources:
requests:
memory: 512M
volumes:
- name: disk0
persistentVolumeClaim:
claimName: ubuntu
- cloudInitNoCloud:
userData: |
#cloud-config
users:
- default
- name: yash
passwd: HASHED_PASSWORD
lock_passwd: false
shell: /bin/bash
ssh_pwauth: True
chpasswd: { expire: False}
sudo: ALL=(ALL) NOPASSWD:ALL
groups: users, admin
ssh_authorized_keys:
- ssh-rsa SSH_PUB_KEY
name: cloudinitdisk
Get it executed
kubectl create -f ubuntu-vm.yaml
We can get the created resources:
kubectl get dv,pvc,vm
Once the status of VM turns to "RUNNING" and Ready is "True", we can use the command to access the instance.
virtctl console VM-NAME
If needs to connect through VNC
virtctl vnc VM-NAME
I have just explained this with an example for an Ubuntu VM. Similarly, you can apply the same process for other operating systems.
Conclusion
Using KubeVirt on Kubernetes to deploy different operating system (OS) images shows clear differences in setup times and resource needs. Lightweight options like CirrOS require fewer resources, while larger distributions such as CentOS and Ubuntu need more. Each OS image has its own benefits and considerations for deployment:
- CirrOS: A lightweight server image of 15MB, typically ready in approximately 50 seconds, making it ideal for quick provisioning and testing.
- CentOS: A robust server image at 1014 MB, requiring approximately 8 minutes for deployment, suited for enterprise applications and services.
- Ubuntu Server: With an image size of 613 MB, deployment completes in around 7 minutes, balancing performance and resource efficiency.
- Ubuntu Server (Minimal Configuration): A lighter variant at 265 MB, ready in about 97 seconds, emphasizing rapid deployment for streamlined environments.
KubeVirt has transformed how we manage infrastructure. Integrating VMs into Kubernetes simplifies operations, speeds up deployments, and helps DevOps teams avoid switching tools. However, this requires in and out understanding of how to leverage KubeVirt. This is where Opcito's experts can guide your organization through hybrid infrastructure transitions with zero-downtime. Contact our KubeVirt experts to discuss tailored solutions.
Related Blogs
