From the Boot Disk section select the Ubuntu 18.04 TLS. - purely because this version seems to works well with Docker, Docker Compose etc.

You can leave the rest of the main Machine Configuration selections as the default values.

However, under the MANAGEMENT->Availability policy section, you can set Preemptibility to On - if you wish to keep your GCP costs low.

Click the CREATE button.

Once the VM is up and running, from the VM Instances list, click the SSH link on your rtc instance to open a shell and proceed with Step 2 below 

Step 2 - Installing Docker Engine on Ubuntu using the Repository

Full installation instructions are available at https://docs.docker.com/engine/install/ubuntu/.
Nevertheless, each key step is detailed below:

From the Ubuntu Command Line confirm Docker is not previously installed:

Since this is a fresh VM there should be no previous version of Docker and will see a 'Command docker not found' message.

Update the repositories and install the required packages:

Adds Docker's official GPG Key:

As your logged in as the home user and not as root - you will see the following error message - we can just ignore it for now - as this is not a production type setup we are performing.

Next we add a stable repository to download docker from,  update the apt package index and then install the latest version of the Docker engine and containerd :

Hit 'Y' when it asks about disk space usage etc.

Once the installation completes, you can verify that the Docker Engine is intalled correctly by running the 'hello-world' docker image:

You will see various download related messages followed by a ' Hello from Docker !' message - if so, Hurrah your Docker installation appears to be working correctly!

Step 3 - Installing docker-compose

We will be using a docker-compose.yml file to configure / orchestrate our RTC container - and for that we need to install the Docker Compose tool: 

Just hit 'Y' if you are asked about disk space usage.

The installation of docker-compose should then be completed.

Step 4 - Managing Docker as a non-root user

As the Docker daemon binds to a Unix socket instead of a TCP port and by default, that Unix socket is owned by the user root - other users can only access it using sudo.
The Docker daemon always runs as the root user.
To avoid having to repeatedly preface the docker command with sudo, we can create a Unix group called docker and add users to it.
When the Docker daemon starts, it creates a Unix socket which is then accessible by members of the docker group

Use the following steps to create a Unix group called docker (which may already exist!), add users to it and activate the changes to the group membership:

Once you have executed the above, Log out and stop and start the rtc VM instance to allow the changes to take effect.
Once restarted, click SSH again to open a shell.

You can verify that the changes have worked by running e.g. the  previous 'hello world' command without the use of sudo.

Step 5 - Replicating the rtc config directory structure

Referring back to my original article, you will note that in order to deploy RTC inside docker, I create a localhost directory structure, where I store and access my RTC config, log files and licence file – outside of the Docker container - which I then refer to in my docker-compose.yml file.
You could try and create the same directory structure and upload each file individually. However, if you have already deployed RTC locally, then the easiest way is to leverage the GCP Cloud Storage bucket functionality and then upload your local files into a bucket and then use the gsutils command to copy them into your rtc VM.

Assuming you already have the directory structure and files on your local PC, perform the following steps.
From the GCP console, navigate to the Cloud Storage section:

1. Create a Storage bucket with a unique name - I called mine 'rtc353un'.
2. Select a region closest to you
3. Leave the remaining settings at their default values and click Create.
4. Use the CREATE FOLDER option to create a log folder and debug folder
5. Upload the config folder from your local PC into the root folder of the bucket
6. Check the config folder contents to ensure the REFINITV_LICENSE and rtc.cnf files have been uploaded successfully
7. Upload your local docker-compose.yml into the root of the bucket

Your bucket contents should now look something like:

In your shell console, use the gsutils copy command to copy the directory structure and files from the bucket into your home directory - replacing rtc353un with your bucket name:

The previously uploaded docker-compose.yml will contain the volume binds for your local PC., so it needs to be edited to reflect the VM directory structure. You can do this using nano which should already be installed.

When editing make sure the absolute directory address is used - otherwise you may see permission errors from docker. Once you have finished editing, save the yml file and exit nano.

We are now ready to run Docker Compose...
As mentioned in my original article, the following command creates and starts an RTC instance in detached mode – i.e., runs the container in the background. 

You can check if the RTC container is up and running by using the docker inspect and docker container ls commands:

If all is well,, you should see something like:

If the container is continously trying to start, then the chances are that it's a volume bind error - so back to the earlier step and recheck the docker-compose.yml file using nano.

You can also check the log files in real-time to see what the issue might be (replacing the hex Container ID with the output from the docker container ls command - as shown above):

Assuming that RTC is up and running successfully, we can continue with the RT-SDK installation

Step 6 - Install the RT-SDK

First, we need to repeat some of the earlier steps - this time for the RT-SDK

• Step 1 - create a VM instance with Ubuntu Bionic 18.04 (LTS) and call it something like rt-sdk1
• Step 2 - install the Docker Engine
• Step 4 - perform the docker group steps so you can work as a non-root user

Once the above steps have been done, you need to pull the current RT-SDK Java image from Docker Hub:

Once the pull is complete we can then run the docker container in interactive mode as follow (where the hex Image ID is the one listed by the docker images command (see below):

If you have previously started the container and its still running, you can connect to it using the docker exec command (where image ID is as shown above):

Once you have the RT-SDK container running, you need to edit one of the examples to connect to and consume data from the rtc container which should still be running.

The simplest example that comes with the RT-SDK package is the example 100 for Market Price Streaming.

Change directory to the location of the example - so for example 100 it would be:

Install an editor such as nano and then edit the example source code:

In the example source code, you will need to modify

• the server hostname/IP address
• the service name
• and the name of the RIC you want to subscribe to

For the ex100_MP_Streaming example, you need to change

• the hostname to the IP address of your rtc VM
• the service name to ELEKTRON_DD
• you could also change the RIC from 'IBM.N' to another RIC of your choice e.g. 'EUR='

The easiest way to get the IP address for the RTC container is by clicking the 3 dots next to the rtc VM instance entry and selecting 'View network details'

Copy the IP address and apply to the example source code, along with service name and RIC name as required.

In the ex100_MP_Streaming example, you can apply the changes in the main() method as shown below

Save the changes to the source code and then change your directory back to /opt/refinitiv/Real-Time-SDK/Java and then run the example.

For the ex100_MP_Streaming example you would perform the following:

The first time you run gradle it takes a few moments - after a few moments, you should see streaming data for the RIC you specified in the source code:

Next Steps?

My colleague's initial objective was to get an RT-SDK Consumer application connecting to an RTC instance - both on the Google Cloud Platform - all on the same default network - with no dependencies on localhost installation.

As you will note, the steps outlined above successfully fulfil those objectives - in a relatively simple manner.

Part 2 of the original article which led to this has additional sections on running + testing Interactive and Non-Interactive Providers as well Posting functionality. Once you have moved beyond experimenting with the Consumer functionality/examples - you should be able to apply the other instructions from my article to this GCP deployment as well.

Finally, I would like to thank my colleague Douglas for documenting this process and allowing me to share it with the wider Refinitiv Developer community - thank you!