Import your virtual appliances into OpenShift Virtualization

As expected, the OVA includes the OVF metadata file and, in this case, a single virtual image disk in the VMDK format. OpenShift Virtualization supports IMG or QCOW images, therefore we need to convert the virtual disk; this conversion can be achieved with either the virt-v2v or qemu-img tools. virt-v2v is a powerful tool designed to transfer VMs from one virtualization platform to another, including converting the virtual disk to the right format. For our purposes, the simpler qemu-img tool is good enough, so we issue the following command:

qemu-img convert -cpf vmdk -O qcow2 \
      common-lampstack-8.3-8.3.12-r4-debian-12-amd64-disk-0.vmdk \
      bitnami-lampstack-8.3.12.qcow2

Now we need to extract the basic requirements from the OVF file. First we look for the minimal number of vCPUs required:

grep -A 4 "Number of Virtual CPUs" common-lampstack-8.3-8.3.12-r4-debian-12-amd64.ovf 

       <rasd:Description>Number of Virtual CPUs</rasd:Description>
           <rasd:ElementName>1 virtual CPU(s)</rasd:ElementName>
           <rasd:InstanceID>1</rasd:InstanceID>
           <rasd:ResourceType>3</rasd:ResourceType>
           <rasd:VirtualQuantity>1</rasd:VirtualQuantity>

Then, we check for minimum amount of memory needed:

grep -A 4 "Memory Size" common-lampstack-8.3-8.3.12-r4-debian-12-amd64.ovf

       <rasd:Description>Memory Size</rasd:Description>
           <rasd:ElementName>1024MB of memory</rasd:ElementName>
           <rasd:InstanceID>2</rasd:InstanceID>
           <rasd:Reservation>1024</rasd:Reservation>
           <rasd:ResourceType>4</rasd:ResourceType>

Finally, we look for the disk size:

grep -A 4 "Disk" common-lampstack-8.3-8.3.12-r4-debian-12-amd64.ovf 

 <DiskSection>
       <Info>Virtual disk information</Info>
       <Disk ovf:capacity="10" ovf:capacityAllocationUnits="byte * 2^30" ovf:diskId="vmdisk1" ovf:fileRef="file1" ovf:format="http://www.vmware.com/interfaces/specifications/vmdk.html#streamOptimized"/>
     </DiskSection>

Hence, this OVA requires one virtual CPU, 1 GiB of memory and 10 GiBs of disk. To meet these requirements, we could use one the OpenShift Virtualization pre-defined instance types, in particular for this OVA the u1.small (1 vCPUs, 2GB of memory) instance type seems appropriate. Alternatively, we can create a custom instance type to match the requirements exactly, which can be achieved with the virtctl command, which greatly simplifies management and use of OpenShift Virtualization specific CRDs. However, before invoking virtctl, we need to log in to our target OpenShift Virtualization cluster. For this we’ll use the API token (which can be easily generated from the cluster webUI); and select the project/namespace (if different from the one selected when you log in):

oc login --token=<YOUR-API-TOKEN> --server=<YOUR OCP SERVER API URL>

Logged into <YOUR-OCP-SERVER> as "<YOUR-OCP-USERID>" using the token provided.
    You have access to the following projects and can switch between them with 'oc project <projectname>':
      * br-scratch
        openshift-virtualization-os-images
        ova-import-demo
        windows-builder
    Using project "br-scratch".

oc project ova-import-demo 

Now using project "ova-import-demo" on server <YOUR-OCP-SERVER-URL>

Now we could create a new instance type with the hardware requirements from the OVA with virtctl as follows:

virtctl create instancetype --name small-instance-for-ova --cpu 1 --memory 1Gi

apiVersion: instancetype.kubevirt.io/v1beta1
    kind: VirtualMachineClusterInstancetype
    metadata:
     creationTimestamp: null
     name: small-instance-for-ova
    spec:
     cpu:
       guest: 1
     memory:
       guest: 1Gi

The next step is to upload the virtual disk image. For this, we use virtctl again:

virtctl image-upload dv bitnami-lampstack-8.3.12 --force-bind --insecure --size=10Gi \
    --image-path bitnami-lampstack-8.3.12.qcow2

PVC br-scratch/bitnami-lampstack-8.3.12 not found 
    DataVolume br-scratch/bitnami-lampstack-8.3.12 created
    Waiting for PVC bitnami-lampstack-8.3.12 upload pod to be ready...
    Pod now ready
    Uploading data to https://cdi-uploadproxy-openshift-cnv.apps.cnv2.engineering.redhat.com
    822.99 MiB / 822.99 MiB [=========================================================================] 100.00% 1m14s
    Uploading data completed successfully, waiting for processing to complete, you can hit ctrl-c without interrupting the progress
    Processing completed successfully

As can be seen from the output, the command created a DataVolume (backed by a PVC) and populated it with the data from the disk image; now all that is left for us is to create a bootable volume (AKA, data source) that pairs between the PVC and an InstanceType. Unfortunately, virtctl doesn’t generate manifests for DataSource, so we need to create it manually to match the following YAML:

apiVersion: cdi.kubevirt.io/v1beta1
    kind: DataSource
    metadata:
     generation: 4
     labels:
       instancetype.kubevirt.io/default-instancetype: u1.small
       instancetype.kubevirt.io/default-preference: ubuntu
     name: bitnami-lamp-stack-8.3.12-u1.small
    spec:
     source:
       pvc:
         name: bitnami-lampstack-8.3.12
         namespace: <YOUR-NAMESPACE>

Let's verify that the data source has been properly created. First we check whether the instance type has been properly set:

oc get datasources.cdi.kubevirt.io bitnami-lampstack-
    8.3.12-r4-debian-12-amd64 -o json | jq '.metadata.labels' 

{ 
     "instancetype.kubevirt.io/default-instancetype": "u1.large", 
     "instancetype.kubevirt.io/default-preference": "ubuntu" 
    }

And that the data source is pointing to the PVC where the OVA's virtual disk was upload to:

oc get datasources.cdi.kubevirt.io bitnami-lampstack-8.3.12-r4-debian-12-amd64 -o json | jq '.status.source'

{
      "pvc": {
        "name": "bitnami-lampstack-8.3.12-r4-debian-12-amd64",
        "namespace": "ova-import-demo"
      }
    }

We are now ready to start creating virtual machines for our imported OVA. To demonstrate this, we will select the Create VirtualMachine -> From InstanceType function in the OpenShift Virtualization console as shown in Figure 1, then select the project (namespace) where the OVA was imported to as shown in Figure 2. Then select the bootable volume that was created as part of the import process, validate that the default instance type is selected (and if desired, change it), then validate the rest of the VM configuration and click the Create VirtualMachine button (Figure 3) and wait until the new virtual machine is running.

After a while the new VM is running and ready to use. Clearly for OVA usage instructions, you will need to get the documentation from the OVA provider. For this particular OVA, we see in the console a link to documentation as well as initial credentials (see Figure 4).

Putting the pieces together

While the step-by-step process described above is fairly straightforward, it would be better to have a tool that automates the entire process. To demonstrate this concept, we developed ovaimporter, a small utility (not an official utility), that runs as a Pod in the cluster that takes an OVAs either from your machine or directly from the OVA’s publisher web site, and automatically creates a bootable volume. This utility is available here. The following Figures show ovaimporter at work.

First, we need to log in to the cluster and select a project/namespace. We need to do the same for this tool, as shown in Figure 5. Once logged in you can either download an OVA directly from the vendor by filling up the URL file (Figure 6), or uploading from the local file system by drag and drop, or by clicking the Select File button and selecting the file (Figure 7).

In both cases, after the file has been saved by the ovaimporter, clicking the Proceed button will open up the progress page (Figure 8) and initiate the automated importing process. Once the process is finished, clicking the Next OVA button will bring you back to the OVA source page where you can repeat the import process for another OVA.

Wrapping up

That's it! While the terminology may require some getting used to, in this article we’ve shown how easy it is to import an OVA into OpenShift Virtualization