Installation on Docker (Linux / Ubuntu)
When creating a server to host DATPROF Runtime, both Linux and Windows can be used as the underlying operating system. While the overall installation process for these two systems is overall pretty similar, this page serves as a general instruction on how to host Runtime on Ubuntu, and for this example we’ll be doing so inside of a Docker Container. By using Docker, we gain access to a stable, isolated operating system which can be used to run Runtime without interference from other programs, while still being able to communicate with other clients.
For this guide, we’ll be using the docker on Windows command-line, but the commands should be the same if you are starting from for instance Ubuntu or another distribution of Linux. If you are installing on a stand-alone instance of Linux, the second half of this page can be used for installation steps.
Requirements
For this guide, the only things you need is a working installation of Docker and the Linux Runtime installation files. To find out how to set this up, you can consult these guide:
Linux (Docker Engine): https://docs.docker.com/engine/install/
Windows (Docker Desktop):https://docs.docker.com/desktop/
Docker Setup
Choosing a container image
For this guide, you can realistically choose whatever Linux distribution has an available container image, and offers the support you require from the OS. Some examples:
Ubuntu
Red Hat (and most other RHEL compatible distros)
CentOS
Debian
Pulling the container image
The next step is pulling our container image. Here, you can specify both which image you’d like to pull, as well as the desired version. If no version is provided, the default is to pull the latest available version.
Syntax:
docker pull <image_name>:<version(optional)>
Example:
docker pull ubuntu:latest
If you’re doing this on a machine which is not connected to the internet, you’ll need to pull the docker image on a machine which is connected to the internet. after this you can export the image using the docker save command, and transfer it to desired server. Then, you can import the image using the docker load command.
Starting the container
When running the container there’s a few things we need to make sure we’re supplying in order to work with the container.
Volumes
In order to persist data, we need to supply Docker with a valid location on our operating system to store any information we create during the lifecycle of the container. If this step is skipped, the container would store information as long as it’s running, but would then be wiped clean if it’s ever shut down.
In the example below I store the volume on the machine running Docker in /data/docker_volumes. This can be any location on your filesystem, just make sure you’ve created the necessary directories for this beforehand. The location on the container should be /data.
Port Mapping
After we’ve successfully installed Runtime on our container, we’ll need to be able to connect to the web interface over port 7070. This means we’ll need to map that port from the host to the container. This means that any attempt to connect to the server itself over port 7070 is redirected to port 7070 on the docker container.
Miscellaneous flags
Other than the above, we’ll also be using the -it option to run the docker container in interactive mode, so we are automatically connected to the container and are able to execute bash commands on it. Lastly, we use the --name option to give our container a non-random name.
syntax:
docker run -it -v <host_volume>:/<container_volume> -p <host_port>:<container_port> --name <desired_name> <docker_image>
example:
docker run -it -v /data/docker_volumes/ubuntu_runtime:/data -p 7070:7070 --name Ubuntu_Runtime ubuntu:latest
Linux configuration
Once we’ve connected to our container (or are using a standalone instance of Linux), we need to install Runtime. To do this, we’ll copy the files from our host to the container. Alternatively, you can also download the latest version of the application directly from the container as well.
Copying the installation files from host
To copy files from the host to the container we use the docker cp command. Here’s an example:
Syntax:
docker cp <file_path_to_runtime_installation_files>/runtime-latest-linux.tar.gz <container_name>:<destination_filepath_on_container>
Example:
docker cp runtime-latest-linux.tar.gz Runtime_Ubuntu:/lib/Datprof_Runtime
(Optional) Downloading directly to the machine
If you have internet connectivity on the instance that will be running Runtime, you can also directly download the latest version of Runtime from our download server. For this, we’ll use the wget command-line tool, which is included in almost every Linux distribution by default.
Example:
wget "https://downloads.datprof.com:8443/Runtime/runtime-latest-linux.tar.gz"
Unzipping the installation files
Before we can start Runtime, need to unzip the installation files, as the download files are packed into .tar.gz archive by default. To do this, we use the tar bash tool.
Syntax:
tar -xvzf <name_of_zipped_runtime_files>
Example:
tar -xvzf runtime-latest-linux.tar.gz
Creating a DATA folder
Before Runtime can be started, a DATA folder is required. This can either be an existing DATA folder moved onto the Linux instance as demonstrated above, but we can also just create a new, empty DATA folder. To do this:
Syntax:
mkdir <folder_name>
Example:
mkdir DATA
Starting Runtime
To start Runtime, navigate into the bin folder of the Runtime installation files, and execute the following command.
syntax:
<path_to_runtimeStart_file> <path_to_data_folder>
Example:
./runtimeStart ../DATA
To check whether Runtime is running, you can execute the ps -a command. This will produce an overview of all running processes, with Runtime running as a Java process:
---Sample ps -a output---
PID TTY TIME CMD
29 pts/1 00:00:58 java
114 pts/1 00:00:04 java
234 pts/1 00:00:00 ps
Alternatively, you can also execute ps aux to get a more verbose overview of running processes:
USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND
root 1 0.0 0.0 4588 3696 pts/0 Ss+ 10:13 0:00 /bin/bash
root 9 0.0 0.0 4588 3912 pts/1 Ss 10:13 0:00 bash
root 29 0.9 5.1 14202592 840288 pts/1 Sl 10:14 1:26 /usr/lib/Datprof_Runtime/runtime-4.11.0/jdk/bin/java -D
root 114 0.1 1.0 8328328 176032 pts/1 Sl 10:14 0:16 /usr/lib/Datprof_Runtime/runtime-4.11.0/jdk/bin/java -D
root 369 0.0 0.0 2800 1112 pts/2 Ss+ 10:32 0:00 /bin/sh
root 3262 33.3 0.0 7888 3840 pts/1 R+ 12:41 0:00 ps aux
Connecting to Runtime
Connecting to Runtime on Linux, whether this is in a Docker container or in a standalone Linux server works the same as for any other installation. Simply open a supported internet browser (for example: Google Chrome, Mozilla Firefox) on the machine itself, or externally. After this, supply the IP or DNS name of the server, followed by port 7070.
Scenario | Format |
---|---|
Approaching Runtime from the same machine as where this is installed / running | |
Approaching Runtime from a client machine: | Syntax: http://<ip_or_dns_name>:7070 Example: OR |
If you are unable to connect to Runtime, it’s possible that your Linux instance currently does not allow traffic to the server over port 7070! You can enable access through firewall configuration on the server. As this may work differently depending on which distribution of Linux is being used, this is not detailed in this guide.