Virtual Server Image Import to K5: Using the K5 Command Console

Fujitsu Cloud Service K5 makes it possible for customers to upload their own images to the K5 platform for use. At this time, importing Virtual Server Images needs to be carried out through the APIs and there a a few steps that you need to go through to successfully import an image:

  1. Prepare the source Virtual Server that will be used as the image according to the guide in the K5 IaaS Features Handbook.
  2. Obtain the VMDK file for the source Virtual Server that you will be importing to K5, some important notes:
    1. If the source Virtual Server file is not a VMDK you will need to convert it to a VMDK file as this is the only type of image you can import.
    2. You can only upload a single Virtual Server Hard Disk as an image
  3. Upload the Virtual Server Image File to an Object Storage Container in the ‘default’ project in your K5 account, some important notes:
    1. The ‘default’ project name is your Contract ID plus ‘-prj’.
    2. K5 Object Storage has a maximum object size of 5GB. If the Image is larger than 5GB then you’ll need to do a multi-part upload and bring it back together with a manifest file. I’ll blog on this in the coming days and link this in.
  4. Execute an Image Import API command to import the Image from Object Storage.
  5. Publish the imported Image to the projects in your K5 account that you want to use it in.

Fortunately, all of the above from step 2 to 5 has been wrapped up in to my K5 Command Console Application. This is not an official Fujitsu application and usage of it remains at your own risk.

You can find the latest version of the application at https://github.com/fujitsuk5/K5-Command-Console.

This blog will walk you through the steps to use the K5 Command Console to upload and import a Virtual Server image, please ensure you are using a image that has been prepared in line with the guidelines in the K5 IaaS Features Handbook.

Step 1: Login to the K5 Region

Once you have downloaded the K5 Command Console and opened it up, enter your Contract ID (Domain), Username, Password and the K5 Region you want to upload the image to and press ‘Authenticate’

blog-imageimport-step1

Important Note: The User Account that you use to Import the Virtual Server image must have the System Owner Role on the Default Project or a custom Imager Role created and assigned. The user account and password used

Step 2: Scope to the Default Project

Find the ‘Default’ Project in the list and press the ‘Scope To’ button. It will be the one ending in ‘-prj’:

blog-imageimport-step2.png

Step 3: Upload to Object Storage

Once authenticated and scoped to the Default Project, navigate to the “Storage” Tab and then the “Object Storage” Tab under that

Pressing the “List Containers” button will present a list of Object Containers that already exist in the Project’s Object Storage area. It’s best practise to create a new Container for each Image that you will be uploading to K5.

To create a new Container, provide a name for the Container in the ‘Container Name’ input box and press ‘Create Container’:

blog-imageimport-step3

Once created, select the Container you have just created in the list and press the “Show Objects >>>>>” button:

blog-imageimport-step4

Next we can proceed with the Upload of our VMDK file, click the ‘Upload Object’ to be presented with a File Section Dialog:

blog-imageimport-step5

Once you select the file, you will get the following window appear that will progress the upload. The application will automatically chunk the file in to 200MB chunks and upload to Object Storage, it will pull it back together at the end using a manifest file.

blog-imageimport-step6

Once uploaded, click on ‘Show Objects >>>>>’ again to refresh the view for the Container that you uploaded to and you should see the Object has been uploaded. If the file size was larger than 200MB you will see multiple objects suffixed with -00000 (incremental numbers).

Step 4: Initiate Import of Image

Select the object name that matches the file you uploaded (the one without the -00000 suffixes) and then from the ‘Import As’ drop down select the type of Image you are importing and then press the ‘VM Import from Object’ button:

blog-imageimport-step7

This will initiate an Import Task for that Image from Object Storage. Pressing the ‘Check Import Status’ button will allow you to view the status of this Import.

Step 5: Checking the Import Process

Pressing the ‘Check Import Status’ button will take you to the ‘Tasks’ screen that allows you to monitor the progress. This screen will update every 30 seconds automatically:

blog-imageimport-step8

Step 6: Sharing the Imported Image with other Projects

Once the Image has been successfully imported it will be available for use in the ‘Default’ Project in your account. To use it in other Projects you will need to publish the Image to the other Projects.

To do this, head to the ‘Compute’ and then ‘Images’ Tab and press the ‘List Images’ button. This will present a list of all Images in the ‘Default’ Project:

blog-imageimport-step9

Find the Image you Imported and then in the ‘Project ID to Share With’ input enter the Project UID of the Project you want to share with and click the ‘Share’ button.

Once you have done this click on the ‘Projects’ tab and scope to the Project you have just shared the image with.

Now enter the Image UID of the image you imported (can be found via the’Show\Hide Debug button) in the ‘Image ID to Accept’ input and click the ‘Accept’ button.

You have now successfully uploaded, imported and published the Image to a project. From within K5 you can now use this Image to create new Virtual Servers.

I’ll create more detailed blog posts detailing out the API calls in the coming weeks.

Cloud Service K5 – Console Access to Virtual Servers

Fujitsu’s Cloud Service K5 now has the ability for users to access the console of a Virtual Server through a web browser. This means you no longer need to have a Global IP to SSH or RDP on to the Virtual Server.

To access the console of the Virtual Server you will need to make an API call to retrieve the URL to access it. Follow these steps to access the console of  a Virtual Server:

Step 1: Authenticate

The first step you will need to do is to authenticate to the Cloud Service K5 Identity API and scope to the Project the Virtual Server is in. If you are unsure how to do this have a look at the following GitHub Repository:

https://github.com/fujitsuk5/K5-Auth-API

Step 2: Request URL for Console Access

The next step is to call an API to request a URL to access the Console of the Virtual Server. The API you need to make a POST  request to is as follows:

https://compute.region_name.cloud.global.fujitsu.com/v2/project_id/servers/server_id/actions

Replace region_name  with the K5 region you are accessing (eg uk-1), replace project_id  with the Project ID the Server resides in and replace server_id  with the ID of the Server you want to get the Console for.

As part of the request you will also need to send the following JSON body to instruct K5 to give you the URL for the Virtual Server Console:

{“os-getVNCConsole”: {“type”: “novnc”}}”

An example CURL request:

Curl –X “POST” –d “{“get_vnc_console”: {“type”: “novnc”}}” –H “X-Auth-Token:” –H “Accept:application/json” –H “Content-Type:application/json” https://compute.region_name.cloud.global.fujitsu.com/v2/project_id/server/server_id/actions

A successful response would return something similar to the following:

{“console”:{“url”:”https://console-a.uk-1.cloud.global.fujitsu.com/vnc_auto.html?token=84bcca56″,”type”:”novnc”}}

Step 3: Connect to the URL

Extract the URL from the response and enter it in to a Web Browser to access the Console of the Virtual Server.

Important Notes about Console Access

  1. The URL returned is only valid for 10 minutes
  2. The URL returned is only valid for a single use
  3. The maximum session time is 30 minutes

Also, you will need to have a user account created on the Linux Servers that does not require a Key Pair file to log in if you want to access the Console of those Virtual Servers.

Cloud Service K5 Bare Metal Servers – Deploying Alternate Operating Systems

Overview of the Bare Metal

Fujitsu Cloud Service K5 enables their customers to deploy Bare Metal servers, there are four types of bare metal servers available today:

  • BS-256 – 36 cores and 256GB RAM
  • BS-512 – 36 cores and 512GB RAM
  • BM-1T – 72 cores and 1TB RAM
  • BM-2T – 72 cores and 2TB RAM

Bare Metal can be orchestrated and consumed only through the APIs, when deploying the Bare Metal Server you can only deploy RHEL for SAP 6.6 as an Image, it is not possible to directly install any other operating system.

This guide will walk you through the steps necessary to install KVM on top of the RHEL on the Bare Metal Servers and then deploy Windows Server 2012 Trial Edition in to a Virtual Machine running on KVM.

Preparing for Bare Metal

Before you can deploy a Bare Metal server the K5 Project that you are deploying to needs to be prepared first. The following steps will walk you through preparing a K5 Project for a Bare Metal Server.

Step 1: Prepare a Project

First we need to instruct K5 to prepare the Project for Bare Metal and pull in the correct images for deployment.

Make a POST request to https://compute-b.uk-1.cloud.global.fujitsu.com with the following in the body of the request:

INSERT_PROJECT_ID_HERE

The following is an example of a curl command that can be used to execute the request.

Curl –I –X “POST” –d “INSERT_PROJECT_ID_HERE” –H “X-Auth-Token: YOUR_TOKEN” –H “Accept:application/xml” –H “Content-Type:application/xml” https://compute-b.uk-1.cloud.global.fujitsu.com
Step 2: Create a K5 Network

Bare Metal servers cannot be connected directly to normal K5 networks, a special network configuration needs to be created. Firstly we need to create a network in K5 using the APIs:

Make a POST request to https://networking.uk-1.cloud.global.fujitsu.com/v2.0/networks with the following body:

{“network”: {“name”: “nw-fcx_subnet-b:”,”admin_state_up”: true,”availability_zone”:””}}

The following is an example of a curl command that can be used to execute the request.

Curl –I –X “POST” –d “{“network”:{“name”: “nw-fcx_subnet-b:”,”admin_state_up”: true,”availability_zone”:””}}” –H “X-Auth-Token: YOUR_TOKEN” –H “Accept:application/json” –H “Content-Type:application/json” https://networking.uk-1.cloud.global.fujitsu.com/v2.0/networks

NOTE: The network name must start with the prefix “nw-fcx_subnet-b:”

Step 3: Create a K5 Subnet

Next we need to create a K5 Subnet to attach to the Network we just created.

Make a POST request to https://networking.uk-1.cloud.global.fujitsu.com/v2.0/subnets  with the following body:

{“subnet”:{“network_id”: ” “,”name”:”fcx_subnet-b:”,”ip_version”: 4,”cidr”:””,”availability_zone”:””,”allocation_pools”:[{“start”: “”, “end”:””}]}}

NOTE: The field in the command needs to be replaced with the Network ID of the Network created in Step 2.

The following is an example of a curl command that can be used to execute the request.

Curl –I –X “POST” –d “{“subnet”: {“network_id”: ” “,”name”:”fcx_subnet-b:”,”ip_version”: 4,”cidr”:””,”availability_zone”:””, “allocation_pools”: [{“start”: “”, “end”:””}]}}” –H “X-Auth-Token: YOUR_TOKEN” –H “Accept:application/json” –H “Content-Type:application/json” https://networking.uk-1.cloud.global.fujitsu.com/v2.0/subnets

NOTE: The subnet name must start with the prefix “nw-fcx_subnet-b:”

Step 4: Creating a Bare Metal Network

Now that we have a K5 Network and Subnet created we can create a Bare Metal network and attach it to the Subnet we create in Step.

Make a POST request to https://compute-b.uk-1.cloud.global.fujitsu.com/networks with the following body:

Note: Replace with the subnet created in Step 3 and replace AZ with the Availability Zone the Subnet is in eg UK-1a.

The following is an example of a curl command that can be used to execute the request.

Curl –I –X “POST” –d ” –H “X-Auth-Token: YOUR_TOKEN” –H “Accept:application/xml” –H “Content-Type:application/xml” https://compute-b.uk-1.cloud.global.fujitsu.com/networks
Step 5: Creating a Bare Metal Server

We now have the perquisites in place to deploy a Bare Metal server.

Make a POST request to https://compute-b.uk-1.cloud.global.fujitsu.com/l_servers with the following body:

NOTE: Replace with either RHEL_6_6_SAP_HANA_en_for_BS (if the template is BS-256 or BS-512) or RHEL_6_6_SAP_HANA_en_for_BM (if the template is BM-1T or BM-2T)

NOTE: Replace with the name you want the Bare Metal Server to have

NOTE: Replace with either BS-256, BS-512, BM-1T or BM-2T

NOTE: Replace with the Bare Metal Network ID created in Step 4 (eg ror-svror1_17967)

NOTE: Replace with the Availability Zone you are deploying to.

The following is an example of a curl command that can be used to execute the request.

Curl –I –X “POST” –d “”/>” />” –H “X-Auth-Token: YOUR_TOKEN” –H “Accept:application/xml” –H “Content-Type:application/xml” https://compute-b.uk-1.cloud.global.fujitsu.com/l_servers

This will initiate the deployment of the Bare Metal server which can take up to an hour.

Step 6: Checking the progress of deployment

When you initiate the deployment of a Bare Metal server, a successful request will return a Task ID that you can use to track the deployment process.

Make a GET to https://compute-b.uk-1.cloud.global.fujitsu.com/tasks/

The response body will include details on the progress of the Task. The following is an example of a curl command that can be used to execute the request.

Curl –I –X “GET” –H “X-Auth-Token: YOUR_TOKEN” –H “Accept:application/xml” –H “Content-Type:application/xml” https://compute-b.uk-1.cloud.global.fujitsu.com/tasks/
Step 7: Accessing the Bare Metal Server

Once the Bare Metal Server has been created you will be able to SSH to it. However you cannot assign a Global IP to Bare Metal Servers so you will need to create a Jump box (Linux or Windows) running in K5 to SSH to first and then SSH to the Bare Metal Server.

Note: For the purpose of this guide you will need both a Linux (Ubuntu) and a Windows Jump Box.

If you do not already have a Jump Box in your project:

  1. Create a Virtual Network
  2. Create a Linux VM and attach it to that Network
  3. Create a Virtual Router
  4. Connect the Virtual Router to the Virtual Network you have just created and to the Virtual Network created in Step 2.
  5. Assign a Global IP to the new Linux Machine.
  6. Create a Security Group to all SSH traffic in from an External IP
Step 8: Deploying Squid3 to Ubuntu Jump Box

Squid3 is a proxy server that we will use to provide internet connectivity to the Bare Metal Server. This will need to be installed on an Ubuntu box that has a Global IP assigned and attached to the Network created previously.

To install Squid3, connected to the Ubuntu server via SSH and run the following command:

sudo apt-get install squid3

No changes are required from the default installation of squid.

Step 9: Deploying BIND9 to Ubuntu Jump Box

BIND9 is a DNS server that can be deployed to Ubuntu. We will need to deploy a DNS server to act in forwarding mode that the bare metal server will use to look up domain names for internet access.

To install BIND9, connect to the Ubuntu server via SSH and run the following command:

sudo apt-get install bind9
Step 10: Configuring BIND9

We will need to configure BIND9 to act as a DNS forwarder. To do this we need to edit the following file:

/etc/bind/named.conf.options

Replace the contents of this file with the following:

acl goodclients {

192.168.1.0/24;

localhost;

192.168.87.0/24;

};

options {

directory “/var/cache/bind”;

recursion yes;

allow-query { goodclients; };

forwarders {

8.8.8.8;

};

forward only;

dnssec-validation auto;

auth-nxdomain no;    # conform to RFC1035

listen-on-v6 { any; };

};

NOTE: This file create an Access Control List Group called “goodclients” and allows a range of IP address to use the DNS Server.

NOTE: This file assumes that the network the Ubuntu Server is connected to a Network with the CIDR of 192.168.1.0/24 – update this to reflect the actual Network CIDR.

NOTE: This file assumes that the network the Bare Metal Server is connected to a Network with the CIDR of 192.168.87.0/24 – update this to reflect the actual Network CIDR.

Once you update this file, save changes and restart the BIND9 service:

sudo service bind9 restart
Step 11: Updating Security Groups

Once we have installed SQUID3 and BIND9 we need to update the Security Group for the Ubuntu box to allow DNS traffic in and SQUID3 traffic in.

In the security group add the following rules:

  • Allow DNS in from 192.168.87.0/24 (Or the IP Range of the Bare Metal Network)
  • Allow TCP port 3128 traffic in from 192.168.87.0/24 (Or the IP Range of the Bare Metal Network)
Step 12: Installing the RHUI Entitlement

The first step we need to carry out is deploying the RHUI Entitlement package that will grant the Bare Metal Server access to the Red Hat repositories that Fujitsu host. Obtain the following file:

rhui-entitlement6-2.0-1.noarch.rpm

Execute the following command on the Bare Metal Server:

yum install rhui-entitlement6-2.0-1.noarch.rpm
Step 13: Installing KVM

On the Bare Metal Server run the following command:

yum install kvm

Once the installation has completed run the following command to install the supporting tools:

yum install virt-manager libvirt libvirt-python python-virtinst virt-viewer
Step 14: Downloading Windows Server 2012 ISO

This guide will walk you through preparing a Windows Server 2012 Trial ISO to use as the source to build a Virtual Machine in KVM. Navigate to the following folder on the Bare Metal Server:

/var/lib/libvirt/images

Execute the following command to download the Windows Server 2012 ISO:

wget http://care.dlservice.microsoft.com/dl/download/6/D/A/6DAB58BA-F939-451D-9101-7DE07DC09C03/9200.16384.WIN8_RTM.120725-1247_X64FRE_SERVER_EVAL_EN-US-HRM_SSS_X64FREE_EN-US_DV5.ISO
Step 15: Downloading VirtIO drivers

When deploying Windows Server 2012 from the ISO you will also need to get the VirtIO drivers for the installation process to be able to access the disks that will be attached to the virtual machine. Navigate to the following folder on the Bare Metal Server:

/var/lib/libvirt/images

Execute the following command to download the Windows Server 2012 ISO:

wget https://fedorapeople.org/groups/virt/virtio-win/direct-downloads/stable-virtio/virtio-win.iso
Step 16: Creating Disk for VM

We can now create a disk that we will later use to attach to the Virtual Machine. Navigate to the following folder on the Bare Metal Server:

/var/lib/libvirt/images

Execute the following command to create a disk:

qemu-img create –f qcow2 ws2012.qcow2 100GB

NOTE: This will create a 100GB disk.

Step 17: Create the Virtual Machine

We are now ready to create a Virtual Machine and power it on to deploy the Operating System from the ISO. Navigate to the following folder on the Bare Metal Server:

/var/lib/libvirt/images

Execute the following command to create a disk:

virt-install –connect qemu:///system –name ws2012 –ram 2048 –vcpus 2 –network network=default,model=virtio –disk path=ws2012.qcow2,format=qcow2,device=disk,bus=virtio –cdrom 9200.16384.WIN8_RTM.120725-1247_X64FRE_SERVER_EVAL_EN-US-HRM_SSS_X64FREE_EN-US_DV5.ISO –disk path=virtio-win.iso,device=cdrom –vnc –os-type windows –os-variant win2k8

NOTE: This will create a VM with 2 vCPUS and 2GB RAM.

You can check the virtual machine has been created and powered on by running the following command:

virsh list –all
Step 18: Connect to console on Virtual Machine

To connect to the console of the Virtual Machine we have just deployed we will need to use a Windows Jump Box Server. On this Windows Server the following applications are required to be installed:

You will need to configure Putty to enable X11 forwarding, this can be done by going to:

Connections -> SSH -> X11 -> Enable X11 forwarding:

Using Putty on the Windows Jump Box, connect directly to the Bare Metal Server and execute the following command:

Virt-viewer –c qemu+ssh:///system ws2012

This will use XMing to display the console of the Virtual Machine.

NOTE: ws2012 is the name of the server we are connecting to

You can now configure the installation of Windows Server 2012 Trial edition.

Step 19: Post Installation Steps

Once Windows Server 2012 has been installed you will need to install the VirtIO network drivers to enable network communication from the Virtual Machine. You can find the drivers for this on the ISO Image Mounted inside the guest operating system.

Navigate to Device Manager and install the drivers.

Creating a Virtual Machine on a Dedicated Host in K5

Fujitsu’s Cloud Service K5 provides customers with the ability to deploy Virtual Machines that run on dedicated hosts assigned to a customers environment, Fujitsu call this Virtual Private Cloud.

In order to create Virtual Machines you will first need to ensure that you have asked Fujitsu to provide some dedicated hosts to your environment.

NOTE: You can mix a K5 Public Cloud and K5 Virtual Private Cloud environment within a single account.

Virtual Machines running on dedicated hosts can only be configured through the K5 APIs, the following details out how to create a KVM based Virtual Machine on a dedicated host on K5:

Step 1: Authenticate

Authenticate and scope to the project in K5 where your dedicated hosts have been assigned. See theFujitsu K5 GitHub repository for an example of how to do this:

https://github.com/fujitsuk5/K5-Auth-API

Step 2: Retrieve a List of Virtual Machine Flavors

Once you have authenticated and obtained a Token you can then go on and retrieve a list of Virtual Machine Flavors that K5 provides.

You will need to issue a GET request to the Compute API endpoint in the region you want to query, for example to query the UK region of K5 for a list of Flavors:

GET https://compute.uk-1.cloud.global.fujitsu.com/v2/flavors

An example of this request using curl:

curl -i -H "X-Auth-Token: TOKEN_ID" -H "accepts:application/json" https://compute.uk-1.cloud.global.fujitsu.com/v2/flavors

At the time of writing this blog the following Flavors are available:

ID Name CPU RAM
1101 S-1 1 vCPU 4GB
1102 S-2 2 vCPU 8GB
1103 S-4 4 vCPU 16GB
1104 S-8 8 vCPU 32GB
1105 S-16 16 vCPU 64GB
1201 M-1 1 vCPU 8GB
1202 M-2 2 vCPU 16GB
1203 M-4 4 vCPU 32GB
1204 M-8 8 vCPU 64GB
1205 M-16 16 vCPU 128GB
1503 XM-4 4 vCPU 128GB

Step 3: Retrieve a List of Images

Now that we have the list of available images to choose for deployment we need to obtain a list of Images that we can deploy.

You will need execute the following to obtain a list of Images.

GET https://image.uk-1.cloud.global.fujitsu.com/v2/images

An example of the request using curl:

curl -i -H "X-Auth-Token: TOKEN_ID" -H "accepts:application/json" https://image.uk-1.cloud.global.fujitsu.com/v2/images

At the time of writing this blog the following Images are available in the UK deployment of K5:

ID Name
37a9d80a-f014-4424-826e-a6e5ae397a3d Windows Server 2012 R2 SE 64bit + SQL Server 2014 SE SP2 (English) 01
41857965-6ee8-4393-94b3-299a0c6988cc Red Hat Enterprise Linux 7.2 64bit (English) 01
20403cb8-4ada-4c5a-b524-d1ff393f0bb7 Windows Server 2008 R2 SE SP1 64bit (English) 01
6e1610db-1115-4260-8dc2-bcdd526a54be Windows Server 2012 R2 SE 64bit (English) 01
58fd966f-b055-4cd0-9012-cf6af7a4c32b CentOS 7.2 64bit (English) 01
0e330855-aeff-423c-99b2-7ee16adb5f68 FJK5-NAS-V02
2d1b7b6b-93cf-4a9b-aacc-43ce61b8073c CentOS 6.5 64bit (English) 04
ffa17298-537d-40b2-a848-0a4d22b49df5 Ubuntu Server 14.04 LTS (English) 01
db9766f0-c95c-4f1c-bb29-304a90405e3e Red Hat Enterprise Linux 6.5 64bit (English) 02

Step 4: Retrieve a List of Networks

Assuming that you already have a virtual network created within your K5 project then you can obtain a list of networks by:

GET https://network.uk-1.cloud.global.com/v2/networks

An example of the request using curl:

curl -i -H "X-Auth-Token: TOKEN_ID" -H "accepts:application/json" https://network.uk-1.cloud.global.fujitsu.com/v2/networks

This will return a list of networks and their associated details that we’ll need later.

Step 5: Create Virtual Machine

We now have all the prerequisite pieces of information we need to build a virtual machine in K5. This time we will make a POST request to the compute API endpoint and pass a JSON payload in the request that tells K5 what to deploy.

An example of the JSON payload we will be sending:

{
"server":
{
"name": "<SOME_NAME>",
"availability_zone": "UK-1a",
"imageRef": "",
"flavorRef": "<FLAVOR_ID_WE_GOT_EARLIER",
"block_device_mapping_v2":
[{
"boot_index": "0",
"uuid":"<IMAGE_ID_WE_GOT_EARLIER>",
"volume_size": "100",
"device_name":"/dev/vda",
"source_type": "image",
"destination_type": "volume",
"delete_on_termination": "True"
}],
"key_name": "<KEY_PAIR_NAME>",
"max_count": 1,
"min_count": 1,
"networks":
[{
"uuid": "<NETWORK_ID_WE_GOT_EARLIER>"
}],
"security_groups":
[{
"name": ""
}]
},
"OS-SCH-HNT:scheduler_hints":
{
"fcx.dedicated": "True"
}
}

You will need to replace the variables in the above JSON payload example with the ones you want (Availability Zone, Image ID, Flavor ID, Network ID, Key Name).

Take note of the last section “OS-SCH-HNT:scheduler_hints”. It’s the “fcx.dedicted: True” part of the JSON payload that tells K5 that this Virtual Machine request should be deployed on the Dedicated Hosts.

Execute a POST request to the following URL passing the JSON above as the payload:

POST https://compute.uk-1.cloud.global.fujitsu.com/v2/<PROJECT_ID>/servers

Replace <PROJECT_ID> with the Project ID you want to deploy the Virtual Server to.

And there we have it, K5 will now be provisioning a Virtual Machine on a Dedicated Host and should appear in the K5 portal for you to manage.