Open your hypervisor and set up your VM. You can use this example for reference or use your own hypervisor instructions.

KVM Example Configuration

This example shows the VM setup process for a system with Libvirt and KVM/QEMU installed.

Confirm that the SHA256 checksum matches the one posted on the Cumulus Downloads website to ensure the image download has not been corrupted.

$ sha256sum ./Downloads/cumulus-netq-server-2.4.1-ts-amd64-qemu.qcow2
$ E93617F1DB5AB3BA597B0EC0C9CFE4CB5AA435245BF62A04769D2A806DA12BE7  ./Downloads/cumulus-netq-server-2.4.1-ts-amd64-qemu.qcow2

Copy the QCOW2 image to a directory where you want to run it.
Tip: Copy, instead of moving, the original QCOW2 image that was downloaded to avoid re-downloading it again later should you need to perform this process again.
```
$ sudo mkdir /vms
$ sudo cp ./Downloads/cumulus-netq-server-2.4.1-ts-amd64-qemu.qcow2 /vms/ts.qcow2
```
Create the VM.
For a Direct VM, where the VM uses a MACVLAN interface to sit on the host interface for its connectivity:
```
$ virt-install --name=netq_ts --vcpus=8 --memory=65536 --os-type=linux --os-variant=generic --disk path=/vms/ts.qcow2,format=qcow2,bus=virtio,cache=none --network=type=direct,source=eth0,model=virtio -import --noautoconsole
```
Replace the disk path value with the location where the QCOW2 image is to reside. Replace network model value (eth0 in the above example) with the name of the interface where the VM is connected to the external network.

Or, for a Bridged VM, where the VM attaches to a bridge which has already been setup to allow for external access:
```
$ virt-install --name=netq_ts --vcpus=8 --memory=65536 --os-type=linux --os-variant=generic \ --disk path=/vms/ts.qcow2,format=qcow2,bus=virtio,cache=none --network=bridge=br0,model=virtio --import --noautoconsole
```
Replace network bridge value (br0 in the above example) with the name of the (pre-existing) bridge interface where the VM is connected to the external network.

Make note of the name used during install as this is needed in a later step.
Watch the boot process in another terminal window.
```
$ virsh console netq_ts
```

Confirm that the SHA256 checksum matches the one posted on the Cumulus Downloads website to ensure the image download has not been corrupted.

$ sha256sum ./Downloads/cumulus-netq-server-2.4.1-ts-amd64-qemu.qcow2
$ 383E976F1A0572B9556B3A93FC790222C3A278CA04D96360AC9F3878704F4371  ./Downloads/cumulus-netq-server-2.4.1-ts-amd64-qemu.qcow2

Copy the QCOW2 image to a directory where you want to run it.
Tip: Copy, instead of moving, the original QCOW2 image that was downloaded to avoid re-downloading it again later should you need to perform this process again.
```
$ sudo mkdir /vms
$ sudo cp ./Downloads/cumulus-netq-server-2.4.1-ts-amd64-qemu.qcow2 /vms/ts.qcow2
```
Create the VM.
For a Direct VM, where the VM uses a MACVLAN interface to sit on the host interface for its connectivity:
```
$ virt-install --name=netq_ts --vcpus=4 --memory=8192 --os-type=linux --os-variant=generic --disk path=/vms/ts.qcow2,format=qcow2,bus=virtio,cache=none --network=type=direct,source=eth0,model=virtio -import --noautoconsole
```
Replace the disk path value with the location where the QCOW2 image is to reside. Replace network model value (eth0 in the above example) with the name of the interface where the VM is connected to the external network.

Or, for a Bridged VM, where the VM attaches to a bridge which has already been setup to allow for external access:
```
$ virt-install --name=netq_ts --vcpus=4 --memory=8192 --os-type=linux --os-variant=generic \ --disk path=/vms/ts.qcow2,format=qcow2,bus=virtio,cache=none --network=bridge=br0,model=virtio --import --noautoconsole
```
Replace network bridge value (br0 in the above example) with the name of the (pre-existing) bridge interface where the VM is connected to the external network.

Make note of the name used during install as this is needed in a later step.
Watch the boot process in another terminal window.
```
$ virsh console netq_ts
```

Confirm that the SHA256 checksum matches the one posted on the Cumulus Downloads website to ensure the image download has not been corrupted.

$ sha256sum ./Downloads/cumulus-netq-server-3.0.0-ts-amd64-qemu.qcow2
$ 58EC6D6B4F2C6D377B3CD7C6E36792C6E2C89B06069561C50F316EA01F8A2ED2  ./Downloads/cumulus-netq-server-3.0.0-ts-amd64-qemu.qcow2

Copy the QCOW2 image to a directory where you want to run it.
Tip: Copy, instead of moving, the original QCOW2 image that was downloaded to avoid re-downloading it again later should you need to perform this process again.
```
$ sudo mkdir /vms
$ sudo cp ./Downloads/cumulus-netq-server-3.0.0-ts-amd64-qemu.qcow2 /vms/ts.qcow2
```
Create the VM.
For a Direct VM, where the VM uses a MACVLAN interface to sit on the host interface for its connectivity:
```
$ virt-install --name=netq_ts --vcpus=8 --memory=65536 --os-type=linux --os-variant=generic --disk path=/vms/ts.qcow2,format=qcow2,bus=virtio,cache=none --network=type=direct,source=eth0,model=virtio -import --noautoconsole
```
Replace the disk path value with the location where the QCOW2 image is to reside. Replace network model value (eth0 in the above example) with the name of the interface where the VM is connected to the external network.

Or, for a Bridged VM, where the VM attaches to a bridge which has already been setup to allow for external access:
```
$ virt-install --name=netq_ts --vcpus=8 --memory=65536 --os-type=linux --os-variant=generic \ --disk path=/vms/ts.qcow2,format=qcow2,bus=virtio,cache=none --network=bridge=br0,model=virtio --import --noautoconsole
```
Replace network bridge value (br0 in the above example) with the name of the (pre-existing) bridge interface where the VM is connected to the external network.

Make note of the name used during install as this is needed in a later step.
Watch the boot process in another terminal window.
```
$ virsh console netq_ts
```

Confirm that the SHA256 checksum matches the one posted on the Cumulus Downloads website to ensure the image download has not been corrupted.

$ sha256sum ./Downloads/cumulus-netq-server-3.0.0-ts-amd64-qemu.qcow2
$ 599C3AA617937156D38A2205B4D111F83EBCFD63EDA7A791060375B30CB1DA90  ./Downloads/cumulus-netq-server-3.0.0-ts-amd64-qemu.qcow2

Copy the QCOW2 image to a directory where you want to run it.
Tip: Copy, instead of moving, the original QCOW2 image that was downloaded to avoid re-downloading it again later should you need to perform this process again.
```
$ sudo mkdir /vms
$ sudo cp ./Downloads/cumulus-netq-server-3.0.0-ts-amd64-qemu.qcow2 /vms/ts.qcow2
```
Create the VM.
For a Direct VM, where the VM uses a MACVLAN interface to sit on the host interface for its connectivity:
```
$ virt-install --name=netq_ts --vcpus=4 --memory=8192 --os-type=linux --os-variant=generic --disk path=/vms/ts.qcow2,format=qcow2,bus=virtio,cache=none --network=type=direct,source=eth0,model=virtio -import --noautoconsole
```
Replace the disk path value with the location where the QCOW2 image is to reside. Replace network model value (eth0 in the above example) with the name of the interface where the VM is connected to the external network.

Or, for a Bridged VM, where the VM attaches to a bridge which has already been setup to allow for external access:
```
$ virt-install --name=netq_ts --vcpus=4 --memory=8192 --os-type=linux --os-variant=generic \ --disk path=/vms/ts.qcow2,format=qcow2,bus=virtio,cache=none --network=bridge=br0,model=virtio --import --noautoconsole
```
Replace network bridge value (br0 in the above example) with the name of the (pre-existing) bridge interface where the VM is connected to the external network.

Make note of the name used during install as this is needed in a later step.
Watch the boot process in another terminal window.
```
$ virsh console netq_ts
```

Confirm that the SHA256 checksum matches the one posted on the Cumulus Downloads website to ensure the image download has not been corrupted.

$ sha256sum ./Downloads/cumulus-netq-server-3.1.0-ts-amd64-qemu.qcow2
$ 58EC6D6B4F2C6D377B3CD7C6E36792C6E2C89B06069561C50F316EA01F8A2ED2  ./Downloads/cumulus-netq-server-3.1.0-ts-amd64-qemu.qcow2

Copy the QCOW2 image to a directory where you want to run it.
Tip: Copy, instead of moving, the original QCOW2 image that was downloaded to avoid re-downloading it again later should you need to perform this process again.
```
$ sudo mkdir /vms
$ sudo cp ./Downloads/cumulus-netq-server-3.1.0-ts-amd64-qemu.qcow2 /vms/ts.qcow2
```
Create the VM.
For a Direct VM, where the VM uses a MACVLAN interface to sit on the host interface for its connectivity:
```
$ virt-install --name=netq_ts --vcpus=8 --memory=65536 --os-type=linux --os-variant=generic --disk path=/vms/ts.qcow2,format=qcow2,bus=virtio,cache=none --network=type=direct,source=eth0,model=virtio -import --noautoconsole
```
Replace the disk path value with the location where the QCOW2 image is to reside. Replace network model value (eth0 in the above example) with the name of the interface where the VM is connected to the external network.

Or, for a Bridged VM, where the VM attaches to a bridge which has already been setup to allow for external access:
```
$ virt-install --name=netq_ts --vcpus=8 --memory=65536 --os-type=linux --os-variant=generic \ --disk path=/vms/ts.qcow2,format=qcow2,bus=virtio,cache=none --network=bridge=br0,model=virtio --import --noautoconsole
```
Replace network bridge value (br0 in the above example) with the name of the (pre-existing) bridge interface where the VM is connected to the external network.

Make note of the name used during install as this is needed in a later step.
Watch the boot process in another terminal window.
```
$ virsh console netq_ts
```

Confirm that the SHA256 checksum matches the one posted on the Cumulus Downloads website to ensure the image download has not been corrupted.

$ sha256sum ./Downloads/cumulus-netq-server-3.1.0-ts-amd64-qemu.qcow2
$ 599C3AA617937156D38A2205B4D111F83EBCFD63EDA7A791060375B30CB1DA90  ./Downloads/cumulus-netq-server-3.1.0-ts-amd64-qemu.qcow2

Copy the QCOW2 image to a directory where you want to run it.
Tip: Copy, instead of moving, the original QCOW2 image that was downloaded to avoid re-downloading it again later should you need to perform this process again.
```
$ sudo mkdir /vms
$ sudo cp ./Downloads/cumulus-netq-server-3.1.0-ts-amd64-qemu.qcow2 /vms/ts.qcow2
```
Create the VM.
For a Direct VM, where the VM uses a MACVLAN interface to sit on the host interface for its connectivity:
```
$ virt-install --name=netq_ts --vcpus=4 --memory=8192 --os-type=linux --os-variant=generic --disk path=/vms/ts.qcow2,format=qcow2,bus=virtio,cache=none --network=type=direct,source=eth0,model=virtio -import --noautoconsole
```
Replace the disk path value with the location where the QCOW2 image is to reside. Replace network model value (eth0 in the above example) with the name of the interface where the VM is connected to the external network.

Or, for a Bridged VM, where the VM attaches to a bridge which has already been setup to allow for external access:
```
$ virt-install --name=netq_ts --vcpus=4 --memory=8192 --os-type=linux --os-variant=generic \ --disk path=/vms/ts.qcow2,format=qcow2,bus=virtio,cache=none --network=bridge=br0,model=virtio --import --noautoconsole
```
Replace network bridge value (br0 in the above example) with the name of the (pre-existing) bridge interface where the VM is connected to the external network.

Make note of the name used during install as this is needed in a later step.
Watch the boot process in another terminal window.
```
$ virsh console netq_ts
```

Confirm that the SHA256 checksum matches the one posted on the Cumulus Downloads website to ensure the image download has not been corrupted.

$ sha256sum ./Downloads/netq-3.2.0-ubuntu-18.04-ts-qemu.qcow2
$ 7772531F02B932B0B35CA74E710341BEC6428CD2B089A3C3C6EFE25D2F668AD5  ./Downloads/netq-3.2.0-ubuntu-18.04-ts-qemu.qcow2

Copy the QCOW2 image to a directory where you want to run it.
Tip: Copy, instead of moving, the original QCOW2 image that was downloaded to avoid re-downloading it again later should you need to perform this process again.
```
$ sudo mkdir /vms
$ sudo cp ./Downloads/netq-3.2.0-ubuntu-18.04-ts-qemu.qcow2 /vms/ts.qcow2
```
Create the VM.
For a Direct VM, where the VM uses a MACVLAN interface to sit on the host interface for its connectivity:
```
$ virt-install --name=netq_ts --vcpus=8 --memory=65536 --os-type=linux --os-variant=generic --disk path=/vms/ts.qcow2,format=qcow2,bus=virtio,cache=none --network=type=direct,source=eth0,model=virtio -import --noautoconsole
```
Replace the disk path value with the location where the QCOW2 image is to reside. Replace network model value (eth0 in the above example) with the name of the interface where the VM is connected to the external network.

Or, for a Bridged VM, where the VM attaches to a bridge which has already been setup to allow for external access:
```
$ virt-install --name=netq_ts --vcpus=8 --memory=65536 --os-type=linux --os-variant=generic \ --disk path=/vms/ts.qcow2,format=qcow2,bus=virtio,cache=none --network=bridge=br0,model=virtio --import --noautoconsole
```
Replace network bridge value (br0 in the above example) with the name of the (pre-existing) bridge interface where the VM is connected to the external network.

Make note of the name used during install as this is needed in a later step.
Watch the boot process in another terminal window.
```
$ virsh console netq_ts
```

Confirm that the SHA256 checksum matches the one posted on the Cumulus Downloads website to ensure the image download has not been corrupted.

$ sha256sum ./Downloads/netq-3.2.0-ubuntu-18.04-tscloud-qemu.qcow2
$ DDC24C25CD50DF5C6F1C0D7070ACA8317A6C4AB52F3A95EA005BA9777849981E  ./Downloads/netq-3.2.0-ubuntu-18.04-tscloud-qemu.qcow2

Copy the QCOW2 image to a directory where you want to run it.
Tip: Copy, instead of moving, the original QCOW2 image that was downloaded to avoid re-downloading it again later should you need to perform this process again.
```
$ sudo mkdir /vms
$ sudo cp ./Downloads/netq-3.2.0-ubuntu-18.04-tscloud-qemu.qcow2 /vms/ts.qcow2
```
Create the VM.
For a Direct VM, where the VM uses a MACVLAN interface to sit on the host interface for its connectivity:
```
$ virt-install --name=netq_ts --vcpus=4 --memory=8192 --os-type=linux --os-variant=generic --disk path=/vms/ts.qcow2,format=qcow2,bus=virtio,cache=none --network=type=direct,source=eth0,model=virtio -import --noautoconsole
```
Replace the disk path value with the location where the QCOW2 image is to reside. Replace network model value (eth0 in the above example) with the name of the interface where the VM is connected to the external network.

Or, for a Bridged VM, where the VM attaches to a bridge which has already been setup to allow for external access:
```
$ virt-install --name=netq_ts --vcpus=4 --memory=8192 --os-type=linux --os-variant=generic \ --disk path=/vms/ts.qcow2,format=qcow2,bus=virtio,cache=none --network=bridge=br0,model=virtio --import --noautoconsole
```
Replace network bridge value (br0 in the above example) with the name of the (pre-existing) bridge interface where the VM is connected to the external network.

Make note of the name used during install as this is needed in a later step.
Watch the boot process in another terminal window.
```
$ virsh console netq_ts
```

Confirm that the SHA256 checksum matches the one posted on the Cumulus Downloads website to ensure the image download has not been corrupted.

$ sha256sum ./Downloads/netq-3.2.1-ubuntu-18.04-ts-qemu.qcow2
$ F4EF2B16C41EBF92ECCECD0A6094A49EB30AD59508F027B18B9DDAE7E57F0A6F  ./Downloads/netq-3.2.1-ubuntu-18.04-ts-qemu.qcow2

Copy the QCOW2 image to a directory where you want to run it.
Tip: Copy, instead of moving, the original QCOW2 image that was downloaded to avoid re-downloading it again later should you need to perform this process again.
```
$ sudo mkdir /vms
$ sudo cp ./Downloads/netq-3.2.1-ubuntu-18.04-ts-qemu.qcow2 /vms/ts.qcow2
```
Create the VM.
For a Direct VM, where the VM uses a MACVLAN interface to sit on the host interface for its connectivity:
```
$ virt-install --name=netq_ts --vcpus=8 --memory=65536 --os-type=linux --os-variant=generic --disk path=/vms/ts.qcow2,format=qcow2,bus=virtio,cache=none --network=type=direct,source=eth0,model=virtio -import --noautoconsole
```
Replace the disk path value with the location where the QCOW2 image is to reside. Replace network model value (eth0 in the above example) with the name of the interface where the VM is connected to the external network.

Or, for a Bridged VM, where the VM attaches to a bridge which has already been setup to allow for external access:
```
$ virt-install --name=netq_ts --vcpus=8 --memory=65536 --os-type=linux --os-variant=generic \ --disk path=/vms/ts.qcow2,format=qcow2,bus=virtio,cache=none --network=bridge=br0,model=virtio --import --noautoconsole
```
Replace network bridge value (br0 in the above example) with the name of the (pre-existing) bridge interface where the VM is connected to the external network.

Make note of the name used during install as this is needed in a later step.
Watch the boot process in another terminal window.
```
$ virsh console netq_ts
```

Confirm that the SHA256 checksum matches the one posted on the Cumulus Downloads website to ensure the image download has not been corrupted.

$ sha256sum ./Downloads/netq-3.2.1-ubuntu-18.04-tscloud-qemu.qcow2
$ DDC24C25CD50DF5C6F1C0D7070ACA8317A6C4AB52F3A95EA005BA9777849981E  ./Downloads/netq-3.2.1-ubuntu-18.04-tscloud-qemu.qcow2

Copy the QCOW2 image to a directory where you want to run it.
Tip: Copy, instead of moving, the original QCOW2 image that was downloaded to avoid re-downloading it again later should you need to perform this process again.
```
$ sudo mkdir /vms
$ sudo cp ./Downloads/netq-3.2.1-ubuntu-18.04-tscloud-qemu.qcow2 /vms/ts.qcow2
```
Create the VM.
For a Direct VM, where the VM uses a MACVLAN interface to sit on the host interface for its connectivity:
```
$ virt-install --name=netq_ts --vcpus=4 --memory=8192 --os-type=linux --os-variant=generic --disk path=/vms/ts.qcow2,format=qcow2,bus=virtio,cache=none --network=type=direct,source=eth0,model=virtio -import --noautoconsole
```
Replace the disk path value with the location where the QCOW2 image is to reside. Replace network model value (eth0 in the above example) with the name of the interface where the VM is connected to the external network.

Or, for a Bridged VM, where the VM attaches to a bridge which has already been setup to allow for external access:
```
$ virt-install --name=netq_ts --vcpus=4 --memory=8192 --os-type=linux --os-variant=generic \ --disk path=/vms/ts.qcow2,format=qcow2,bus=virtio,cache=none --network=bridge=br0,model=virtio --import --noautoconsole
```
Replace network bridge value (br0 in the above example) with the name of the (pre-existing) bridge interface where the VM is connected to the external network.

Make note of the name used during install as this is needed in a later step.
Watch the boot process in another terminal window.
```
$ virsh console netq_ts
```

Confirm that the SHA256 checksum matches the one posted on the Cumulus Downloads website to ensure the image download has not been corrupted.

$ sha256sum ./Downloads/netq-3.3.0-ubuntu-18.04-ts-qemu.qcow2
$ 69D2A4A010229AC4A8C11FC6E3621648FBB3D725B095A0A29EFCF937FA38B44F  ./Downloads/netq-3.3.0-ubuntu-18.04-ts-qemu.qcow2

Copy the QCOW2 image to a directory where you want to run it.
Tip: Copy, instead of moving, the original QCOW2 image that was downloaded to avoid re-downloading it again later should you need to perform this process again.
```
$ sudo mkdir /vms
$ sudo cp ./Downloads/netq-3.3.0-ubuntu-18.04-ts-qemu.qcow2 /vms/ts.qcow2
```
Create the VM.
For a Direct VM, where the VM uses a MACVLAN interface to sit on the host interface for its connectivity:
```
$ virt-install --name=netq_ts --vcpus=8 --memory=65536 --os-type=linux --os-variant=generic --disk path=/vms/ts.qcow2,format=qcow2,bus=virtio,cache=none --network=type=direct,source=eth0,model=virtio -import --noautoconsole
```
Replace the disk path value with the location where the QCOW2 image is to reside. Replace network model value (eth0 in the above example) with the name of the interface where the VM is connected to the external network.

Or, for a Bridged VM, where the VM attaches to a bridge which has already been setup to allow for external access:
```
$ virt-install --name=netq_ts --vcpus=8 --memory=65536 --os-type=linux --os-variant=generic \ --disk path=/vms/ts.qcow2,format=qcow2,bus=virtio,cache=none --network=bridge=br0,model=virtio --import --noautoconsole
```
Replace network bridge value (br0 in the above example) with the name of the (pre-existing) bridge interface where the VM is connected to the external network.

Make note of the name used during install as this is needed in a later step.
Watch the boot process in another terminal window.
```
$ virsh console netq_ts
```

Confirm that the SHA256 checksum matches the one posted on the Cumulus Downloads website to ensure the image download has not been corrupted.

$ sha256sum ./Downloads/netq-3.3.0-ubuntu-18.04-tscloud-qemu.qcow2
$ 8ADF1CBBE48DC57E22C6081CF6AB59127B4613C9BCDEE0BBB5A11DE1347B725D  ./Downloads/netq-3.3.0-ubuntu-18.04-tscloud-qemu.qcow2

Copy the QCOW2 image to a directory where you want to run it.
Tip: Copy, instead of moving, the original QCOW2 image that was downloaded to avoid re-downloading it again later should you need to perform this process again.
```
$ sudo mkdir /vms
$ sudo cp ./Downloads/netq-3.3.0-ubuntu-18.04-tscloud-qemu.qcow2 /vms/ts.qcow2
```
Create the VM.
For a Direct VM, where the VM uses a MACVLAN interface to sit on the host interface for its connectivity:
```
$ virt-install --name=netq_ts --vcpus=4 --memory=8192 --os-type=linux --os-variant=generic --disk path=/vms/ts.qcow2,format=qcow2,bus=virtio,cache=none --network=type=direct,source=eth0,model=virtio -import --noautoconsole
```
Replace the disk path value with the location where the QCOW2 image is to reside. Replace network model value (eth0 in the above example) with the name of the interface where the VM is connected to the external network.

Or, for a Bridged VM, where the VM attaches to a bridge which has already been setup to allow for external access:
```
$ virt-install --name=netq_ts --vcpus=4 --memory=8192 --os-type=linux --os-variant=generic \ --disk path=/vms/ts.qcow2,format=qcow2,bus=virtio,cache=none --network=bridge=br0,model=virtio --import --noautoconsole
```
Replace network bridge value (br0 in the above example) with the name of the (pre-existing) bridge interface where the VM is connected to the external network.

Make note of the name used during install as this is needed in a later step.
Watch the boot process in another terminal window.
```
$ virsh console netq_ts
```

Confirm that the SHA256 checksum matches the one posted on the Cumulus Downloads website to ensure the image download has not been corrupted.

$ sha256sum ./Downloads/netq-3.3.1-ubuntu-18.04-ts-qemu.qcow2
$ 0A00383666376471A8190E2367B27068B81D6EE00FDE885C68F4E3B3025A00B6  ./Downloads/netq-3.3.1-ubuntu-18.04-ts-qemu.qcow2

Copy the QCOW2 image to a directory where you want to run it.
Tip: Copy, instead of moving, the original QCOW2 image that was downloaded to avoid re-downloading it again later should you need to perform this process again.
```
$ sudo mkdir /vms
$ sudo cp ./Downloads/netq-3.3.1-ubuntu-18.04-ts-qemu.qcow2 /vms/ts.qcow2
```
Create the VM.
For a Direct VM, where the VM uses a MACVLAN interface to sit on the host interface for its connectivity:
```
$ virt-install --name=netq_ts --vcpus=8 --memory=65536 --os-type=linux --os-variant=generic --disk path=/vms/ts.qcow2,format=qcow2,bus=virtio,cache=none --network=type=direct,source=eth0,model=virtio -import --noautoconsole
```
Replace the disk path value with the location where the QCOW2 image is to reside. Replace network model value (eth0 in the above example) with the name of the interface where the VM is connected to the external network.

Or, for a Bridged VM, where the VM attaches to a bridge which has already been setup to allow for external access:
```
$ virt-install --name=netq_ts --vcpus=8 --memory=65536 --os-type=linux --os-variant=generic \ --disk path=/vms/ts.qcow2,format=qcow2,bus=virtio,cache=none --network=bridge=br0,model=virtio --import --noautoconsole
```
Replace network bridge value (br0 in the above example) with the name of the (pre-existing) bridge interface where the VM is connected to the external network.

Make note of the name used during install as this is needed in a later step.
Watch the boot process in another terminal window.
```
$ virsh console netq_ts
```

Confirm that the SHA256 checksum matches the one posted on the Cumulus Downloads website to ensure the image download has not been corrupted.

$ sha256sum ./Downloads/netq-3.3.1-ubuntu-18.04-tscloud-qemu.qcow2
$ FE353FC06D3F843F4041D74C853D38B0A56036C5886F6233A3ED1A9464AEB783  ./Downloads/netq-3.3.1-ubuntu-18.04-tscloud-qemu.qcow2

Copy the QCOW2 image to a directory where you want to run it.
Tip: Copy, instead of moving, the original QCOW2 image that was downloaded to avoid re-downloading it again later should you need to perform this process again.
```
$ sudo mkdir /vms
$ sudo cp ./Downloads/netq-3.3.1-ubuntu-18.04-tscloud-qemu.qcow2 /vms/ts.qcow2
```
Create the VM.
For a Direct VM, where the VM uses a MACVLAN interface to sit on the host interface for its connectivity:
```
$ virt-install --name=netq_ts --vcpus=4 --memory=8192 --os-type=linux --os-variant=generic --disk path=/vms/ts.qcow2,format=qcow2,bus=virtio,cache=none --network=type=direct,source=eth0,model=virtio -import --noautoconsole
```
Replace the disk path value with the location where the QCOW2 image is to reside. Replace network model value (eth0 in the above example) with the name of the interface where the VM is connected to the external network.

Or, for a Bridged VM, where the VM attaches to a bridge which has already been setup to allow for external access:
```
$ virt-install --name=netq_ts --vcpus=4 --memory=8192 --os-type=linux --os-variant=generic \ --disk path=/vms/ts.qcow2,format=qcow2,bus=virtio,cache=none --network=bridge=br0,model=virtio --import --noautoconsole
```
Replace network bridge value (br0 in the above example) with the name of the (pre-existing) bridge interface where the VM is connected to the external network.

Make note of the name used during install as this is needed in a later step.
Watch the boot process in another terminal window.
```
$ virsh console netq_ts
```

VMware Example Configuration

This example shows the VM setup process using an OVA file with VMware ESXi.

Enter the address of the hardware in your browser.
Log in to VMware using credentials with root access.
Click Storage in the Navigator to verify you have an SSD installed.
Click Create/Register VM at the top of the right pane.
Select Deploy a virtual machine from an OVF or OVA file, and click Next.
Provide a name for the VM, for example NetQ.

Tip: Make note of the name used during install as this is needed in a later step.
Drag and drop the NetQ Platform image file you downloaded in Step 2 above.

Click Next.
Select the storage type and data store for the image to use, then click Next. In this example, only one is available.
Accept the default deployment options or modify them according to your network needs. Click Next when you are finished.
Review the configuration summary. Click Back to change any of the settings, or click Finish to continue with the creation of the VM.

The progress of the request is shown in the Recent Tasks window at the bottom of the application. This may take some time, so continue with your other work until the upload finishes.
Once completed, view the full details of the VM and hardware.