Global View virtual appliance deployment

Upload virtana-k8s-xxxx.ova and deploy the OVA from Prism Central. Refer to Deploying an OVA as VM for detailed steps.

Power on and verify the VM from Prism Element. Refer to Managing a VM (AHV) for detailed steps.

Download virtana-gv-kvm-xxxx.x.x.tar.gz from Egnyte and extract it:

KVM_FILES_PATH="/var/lib/libvirt/images"   
mkdir -p ${KVM_FILES_PATH}/virtana
cd ${KVM_FILES_PATH}/virtana
tar -xvzf virtana-gv-kvm-xxxx.x.x.tar.gz -C ${KVM_FILES_PATH}/virtana/

(Optional) Update the OS machine type in vm.xml (default: q35). Get supported types with: /usr/libexec/qemu-kvm -machine help

vim virtana-gv-kvm-xxxx.x.x/vm.xml
  <os>
    <type arch="x86_64" machine="q35">hvm</type>
  </os>

Update the network bridge in vm.xml (default: network):

vim virtana-gv-kvm-xxxx.x.x/vm.xml
    <interface type="network">
      <source network="default"/>
      <model type="virtio"/>
    </interface>
Or
    <interface type="bridge">
      <source bridge="virbr0"/>
      <model type="virtio"/>
    </interface>

Update disk file paths in vm.xml (default: /var/lib/libvirt/images):

vim virtana-gv-kvm-xxxx.x.x/vm.xml
    <disk type="file" device="disk">
      <source file="/var/lib/libvirt/images/virtana/virtana-gv-kvm-2026.2.1/disk1.qcow2"/>
      ...
      <source file="/var/lib/libvirt/images/virtana/virtana-gv-kvm-2026.2.1/disk2.qcow2"/>
    </disk>

Define and start the VM:

virsh list --all
virsh define virtana-gv-kvm-xxxx.x.x/vm.xml
virsh start virtana-gv-kvm-xxxx.x.x
virsh list --all
virsh dominfo virtana-gv-kvm-xxxx.x.x

Access the VM console and get the IP address:

virsh console virtana-gv-kvm-xxxx.x.x
virsh domifaddr virtana-gv-kvm-xxxx.x.x --source agent | grep -E "ipv4" | grep -Ev "(lo|docker0|tunl0)"

Create the namespace:

oc new-project controlplane

Check available StorageClasses:

oc get sc
oc get sc <sc-name> -o yaml | grep volumeBindingMode

Create a working directory: mkdir -p ./virtana && cd ./virtana

(Optional) Create a StorageClass with volumeBindingMode: Immediate:

cat << EOF > virtana-storage-class.yaml
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: <STORAGE_CLASS_NAME>-immediate
provisioner: <PROVISIONER>
parameters:
  type: <STORAGE_TYPE>
  encrypted: "true"
reclaimPolicy: Retain
volumeBindingMode: Immediate
allowVolumeExpansion: true
EOF
oc apply -f virtana-storage-class.yaml

Create DataVolumes (CDI Import) - 170Gi for root, 320Gi for data:

cat << EOF > virtana-rootdisk.yaml
apiVersion: cdi.kubevirt.io/v1beta1
kind: DataVolume
metadata:
  name: virtana-rootdisk
  namespace: controlplane
spec:
  source:
    upload: {}
  pvc:
    accessModes:
      - <ReadWriteOnce / ReadWriteMany>
    resources:
      requests:
        storage: 170Gi
    storageClassName: <STORAGE_CLASS_NAME>
EOF

cat << EOF > virtana-datadisk.yaml
apiVersion: cdi.kubevirt.io/v1beta1
kind: DataVolume
metadata:
  name: virtana-datadisk
  namespace: controlplane
spec:
  source:
    upload: {}
  pvc:
    accessModes:
      - <ReadWriteOnce / ReadWriteMany>
    resources:
      requests:
        storage: 320Gi
    storageClassName: <STORAGE_CLASS_NAME>
EOF

oc apply -f virtana-rootdisk.yaml
oc apply -f virtana-datadisk.yaml

Verify DataVolume status is UploadReady:

oc get datavolume -n controlplane
oc get pvc -n controlplane

Download and extract the Global View KVM tar file from Virtana Support:

tar -zxvf virtana-gv-kvm-xxxx.x.x.tar.gz

Install virtctl (skip if already installed):

tar -zxvf virtctl.tar.gz
chmod +x virtctl
sudo mv virtctl /usr/local/bin/
virtctl version

Upload disk images to DataVolumes:

virtctl image-upload dv virtana-rootdisk \
  -n controlplane \
  --image-path=./virtana-gv-kvm-xxxx.x.x/disk1.qcow2 \
  --insecure

virtctl image-upload dv virtana-datadisk \
  -n controlplane \
  --image-path=./virtana-gv-kvm-xxxx.x.x/disk2.qcow2 \
  --insecure

Deploy the Global View VirtualMachine object:

cat << EOF > virtana-globalview-vm.yaml
apiVersion: kubevirt.io/v1
kind: VirtualMachine
metadata:
  name: virtana-globalview
  namespace: controlplane
spec:
  runStrategy: Manual
  template:
    metadata:
      labels:
        kubevirt.io/domain: virtana-globalview
    spec:
      domain:
        cpu:
          cores: 12
        resources:
          requests:
            memory: 48Gi
        devices:
          disks:
            - name: rootdisk
              disk:
                bus: virtio
              bootOrder: 1
            - name: datadisk
              disk:
                bus: virtio
          interfaces:
            - name: default
              masquerade: {}
          rng: {}
        features:
          acpi: {}
        machine:
          type: q35
      networks:
        - name: default
          pod: {}
      volumes:
        - name: rootdisk
          dataVolume:
            name: virtana-rootdisk
        - name: datadisk
          dataVolume:
            name: virtana-datadisk
EOF
oc apply -f virtana-globalview-vm.yaml

The following table describes each field in the configuration file.

Start the VM and verify it's running:

virtctl start virtana-globalview -n controlplane
oc get vmi virtana-globalview -n controlplane

Access the VM console or via SSH:

virtctl console virtana-globalview -n controlplane  
virtctl ssh virtana@vmi/virtana-globalview -n controlplane

Press ctrl+] to exit.

(Optional) Create a LoadBalancer service for external access:

cat << EOF > virtana-globalview-svc.yaml
apiVersion: v1
kind: Service
metadata:
  name: virtana-globalview-svc
  namespace: controlplane
spec:
  type: LoadBalancer
  selector:
    kubevirt.io/domain: virtana-globalview
  ports:
    - name: ssh
      port: 22
      targetPort: 22
    - name: https
      port: 443
      targetPort: 443
EOF
oc apply -f virtana-globalview-svc.yaml
oc get service virtana-globalview-svc -n controlplane
ssh virtana@<LB_IP/HOSTNAME>