Server - Ubuntu 20.04 LTS

Introduction

Hello, welcome to the Roboteur Server setup guide for Ubuntu 20.04 LTS. This guide assumes you have an instance of Ubuntu already installed. In this guide we’ll walk you through installing the prerequisites for installing and running the server artifacts reverse proxied through NGINX and secured with LetsEncrypt, with the option of using Certbot for assistance. Also included in this guide are in-depth tutorials for installing and configuring the prerequisites.

Installation and setup

Server Artifacts

In this section we’ll define and scribe the server artifacts to be installed and run. The Roboteur server is Node.js web server shipped in a single folder.

This server folder contains:

Name	Description
config folder	For configuration details please refer to the documentation
cv folder	Required for computer vision features
dist folder	Contains the Node.js server file to run
site folder	Contains the Roboteur Studio web application
*.traineddata files	Required for OCR features
package. json	The Node.js server application dependencies installation file

Prerequisites installation

The Roboteur Server requires the following to be installed on Ubuntu before installation of the package.json artifact.

Tool	Description
Nginx	A tutorial on how to install Nginx can be found below or online
CMake	Required to build OpenCv. A tutorial on how to install CMake can be found below or online
Node.js	Required runtime for the server found in dist. A tutorial on how to install Node.js can be found below or online
PM2	A process manager for running Node.js servers in production. PM2 can be installed globally once Node.js has been installed using the Node.js package manager npm. Run: npm i -g pm2@latest Installation documentation can be found on the PM2 site.A tutorial for installing PM2 to run a Node.js server in production can be found below or online.
SSL certificate	The Nginx configuration in this guide uses LetsEncrypt certificates generated by CertBot

Nginx configuration

• Once Nginx has been installed and configured, the following updates should be made to the default configuration.
• Update the domain uat.roboteur.com with the domain of your instance in the following configuration files located in /etc/nginx

/etc/nginx/sites-enabled/default

server {
  listen 80;
  return 301 https://uat.roboteur.co.uk$request_uri;
}

server {  
  listen 443 ssl; 
  server_name uat.roboteur.co.uk;
  ssl_certificate /etc/letsencrypt/live/uat.roboteur.co.uk/fullchain.pem;
  ssl_certificate_key /etc/letsencrypt/live/uat.roboteur.co.uk/privkey.pem;
  include /etc/letsencrypt/options-ssl-nginx.conf;     
  ssl_dhparam /etc/letsencrypt/ssl-dhparams.pem;

  location / {
    proxy_pass http://127.0.0.1:3035$request_uri;
  }

} 

/etc/nginx/nginx.conf

user www-data;
worker_processes auto;
pid /run/nginx.pid;
include /etc/nginx/modules-enabled/*.conf;

events {
  worker_connections 768;
}

http {
  # Basic Settings
  sendfile on;
  tcp_nopush on;
  tcp_nodelay on;
  keepalive_timeout 65;
  types_hash_max_size 2048;
  include /etc/nginx/mime.types;
  default_type application/octet-stream;

  # SSL Settings
  ssl_protocols TLSv1 TLSv1.1 TLSv1.2 TLSv1.3; # Dropping SSLv3
  ssl_prefer_server_ciphers on;

  # Logging Settings
  access_log /var/log/nginx/access.log;
  error_log /var/log/nginx/error.log;

  # Gzip Settings
  gzip on;

  # Virtual Host Configs
  include /etc/nginx/conf.d/*.conf;
  include /etc/nginx/sites-enabled/*;
}

Installing Package.json dependencies

Once Node.js is installed copy the server artifacts folder to a suitable location for example: /var/www/html

Once copied run the following commands from your terminal

 cd /var/www/html

 npm install

This will install the dependencies in the package.json file in the server folder

Once installation is complete, run the following command to start the Roboteur server with PM2

 pm2 start dist/index.js

To verify that the server is running, use the following PM2 command

 pm2 list

To monitor the server logs running under PM2, use the following command

 pm2 logs

To learn more about running Node.js applications with PM2 and Nginx, please see the tutorial below or online or refer to the PM2 documentation site

How To Install Nginx on Ubuntu 20.04 LTS

In this tutorial, we will show you how to install Nginx on Ubuntu 20.04 LTS. For those of you who didn’t know, Nginx is a powerful web server software that can be used on your server. It is also known for its high performance and low memory usage which will allow fewer resources to be used but getting the job done efficiently. A popular setup is to use it as a proxy for Apache, which can then serve application requests.

This article assumes you have at least basic knowledge of Linux, know how to use the shell, and most importantly, you host your site on your own VPS. The installation is quite simple and assumes you are running in the root account, if not you may need to add ‘sudo‘ to the commands to get root privileges. I will show you through the step-by-step installation of Nginx on a Ubuntu 20.04 (Focal Fossa) server.

Install Nginx on Ubuntu 20.04 LTS Focal Fossa

Step 1

First, make sure that all your system packages are up-to-date by running the following apt commands in the terminal.

sudo apt update
sudo apt upgrade

Step 2

Installing Nginx on Ubuntu 20.04.

Nginx is available in the default Ubuntu repositories. To install it run the following command:

sudo apt install nginx

Once the installation is completed, run the commands to enable Nginx to automatically startup when your server starts:

sudo systemctl stop nginx.service
sudo systemctl start nginx.service
sudo systemctl enable nginx.service
sudo systemctl status nginx.service

Step 3

Configuring firewall.

Meanwhile, you need to make sure that your firewall is configured to allow traffic on HTTP (80) and HTTPS (443) ports. Nginx registers itself as a service with ufw :

sudo ufw allow in "Nginx Full"

Step 4

Accessing Test the Installation.

To test Nginx setup, open your browser and browse to the server hostname or IP address and you should see the Nginx default test page as shown below:

Step 5

Nginx Configuration File’s Structure.

Content:

• /var/www/html: The actual web content, which by default only consists of the default Nginx page you saw earlier, is served out of the /var/www/html directory. This can be changed by altering Nginx configuration files.

Server Configuration:

• /etc/nginx: The Nginx configuration directory. All of the Nginx configuration files reside here.
• /etc/nginx/nginx.conf: The main Nginx configuration file. This can be modified to make changes to the Nginx global configuration.
• /etc/nginx/sites-available/: The directory where per-site server blocks can be stored. Nginx will not use the configuration files found in this directory unless they are linked to the sites-enabled directory. Typically, all server block configuration is done in this directory and then enabled by linking to the other directory.
• /etc/nginx/sites-enabled/: The directory where enabled per-site server blocks are stored. Typically, these are created by linking to configuration files found in the sites-available directory.
• /etc/nginx/snippets: This directory contains configuration fragments that can be included elsewhere in the Nginx configuration. Potentially repeatable configuration segments are good candidates for refactoring into snippets.

Server Logs:

• /var/log/nginx/access.log: Every request to your web server is recorded in this log file unless Nginx is configured to do otherwise.
• /var/log/nginx/error.log: Any Nginx errors will be recorded in this log.

Congratulations! You have successfully installed Nginx. Thanks for using this tutorial for installing the Nginx web server in Ubuntu 20.04 LTS (Focal Fossa) system. For additional help or useful information, we recommend you check the official Nginx website.

How To Install CMake on Ubuntu 20.04 LTS

In this tutorial, we will show you how to install CMake on Ubuntu 20.04 LTS. For those of you who didn’t know, CMake is a cross-platform free and open-source software tool designed to build, test, and package the software. CMake uses a simple platform and compiler-independent configuration files to control the software compilation process. It leads to the production of native makefiles and workspaces, which are, in turn, used in a compiler environment of choice.

This article assumes you have at least basic knowledge of Linux, know how to use the shell, and most importantly, you host your site on your own VPS. The installation is quite simple and assumes you are running in the root account, if not you may need to add ‘sudo‘ to the commands to get root privileges. I will show you through the step-by-step installation of the CMake on Ubuntu 20.04 (Focal Fossa). You can follow the same instructions for Ubuntu 18.04, 16.04, and any other Debian-based distribution like Linux Mint.

Install CMake on Ubuntu 20.04 LTS Focal Fossa

Step 1

First, make sure that all your system packages are up-to-date by running the following apt commands in the terminal.

sudo apt update
sudo apt upgrade

Step 2

Installing CMake on Ubuntu 20.04.

• Install CMake using Snap. Run the following command to install CMake packages:

sudo snap install cmake

Once the installation completes, run the “–version” command below to see the CMake version installed in your system:

cmake --version

Install CMake using the official website. Now we download the CMake source code from its official website:

wget

Next, extract the contents:

tar -zxvf cmake-3.20.0.tar.gz
cd cmake-3.20.0

After that, run the command below to compile and install CMake in your Ubuntu system:

sudo ./bootsrap
make 
sudo make install

To confirm that CMake installed successfully in your system, run the “version” command:

cmake --version

Congratulations! You have successfully installed CMake. Thanks for using this tutorial for installing the CMake on Ubuntu 20.04 LTS Focal Fossa system. For additional help or useful information, we recommend you check the official CMake website.

How To Install Node.js on Ubuntu 20.04 LTS

In this tutorial, we will show you how to install Node.js on Ubuntu 20.04 LTS server. For those of you who didn’t know, Node.js is a cross-platform JavaScript runtime environment built on Chrome’s JavaScript, designed to execute JavaScript code on the server-side. It is generally used to build back-end applications, but it is also popular as a full-stack and front-end solution. npm is the default package manager for Node.js and the world’s largest software registry.

This article assumes you have at least basic knowledge of Linux, know how to use the shell, and most importantly, you host your site on your own VPS. The installation is quite simple and assumes you are running in the root account, if not you may need to add ‘sudo‘ to the commands to get root privileges. I will show you through the step-by-step installation of Node.js on a Ubuntu 20.04 (Focal Fossa) server. Install Node.js on Ubuntu 20.04 LTS Focal Fossa

Step 1

First, make sure that all your system packages are up-to-date by running the following apt commands in the terminal.

sudo apt update
sudo apt upgrade

Step 2

Installing Node.js on Ubuntu 20.04.

Install Node.js and npm from Node Source You simply need to add the PPA for the version you want to install:

curl -sL https://deb.nodesource.com/setup_14.x | sudo -E bash -

To install, run the commands below:

sudo apt install nodejs

Once done, verify the installation by running:

node --version
npm --version

Install Node.js and npm via Snap Another way to install Node.js is via Snap package management:

sudo apt install snapd
sudo snap install node --channel=14/stable --classic

Congratulations! You have successfully installed Node.js. Thanks for using this tutorial for installing Node.js on Ubuntu 20.04 LTS (Focal Fossa) system. For additional help or useful information, we recommend you check the official Node.js website.

How To Set Up a Node.js Application for Production on Ubuntu 20.04

In this tutorial, you will set up a production-ready Node.js environment on a single Ubuntu 20.04 server. This server will run a Node.js application managed by PM2, and provide users with secure access to the application through an Nginx reverse proxy. The Nginx server will offer HTTPS using a free certificate provided by Let’s Encrypt.

Prerequisites

• An Ubuntu 20.04 server setup, as described in the initial server setup guide for Ubuntu 20.04. You should have a non-root user with sudo privileges and an active firewall.
• A domain name pointed at your server’s public IP. This tutorial will use the domain name example.com throughout.
• Nginx installed, as covered in How To Install Nginx on Ubuntu 20.04.
• Nginx is configured with SSL using Let’s Encrypt certificates. How To Secure Nginx with Let’s Encrypt on Ubuntu 20.04 will walk you through the process.

When you’ve completed the prerequisites, you will have a server serving your domain’s default placeholder page at https://example.com/.

Step 1

Installing Node.js

Let’s begin by installing the latest LTS release of Node.js, using the NodeSource package archives. First, install the NodeSource PPA in order to get access to its contents. Make sure you’re in your home directory, and use curl to retrieve the installation script for the most recent LTS version of Node.js from its archives.

curl -sL https://deb.nodesource.com/setup_14.x -o nodesource_setup.sh

You can inspect the contents of this script with nano or your preferred text editor:

nano nodesource_setup.sh

When you’re done inspecting the script, run it under sudo:

sudo bash nodesource_setup.sh

The PPA will be added to your configuration and your local package cache will be updated automatically. After running the setup script from Nodesource, you can install the Node.js package:

sudo apt install nodejs

To check which version of Node.js you have installed after these initial steps, type:

node -v
v14.4.0

Note

When installing from the NodeSource PPA, the Node.js executable is called nodejs, rather than node. The nodejs package contains the nodejs binary as well as npm, a package manager for Node modules, so you don’t need to install npm separately. npm uses a configuration file in your home directory to keep track of updates. It will be created the first time you run npm. Execute this command to verify that npm is installed and to create the configuration file:

npm -v   
6.14.5

In order for some npm packages to work (those that require compiling code from source, for example), you will need to install the build-essential package:

sudo apt install build-essential

You now have the necessary tools to work with npm packages that require compiling code from source. With the Node.js runtime installed, let’s move on to writing a Node.js application.

Step 2

Creating a Node.js Application

Let’s write a Hello World application that returns “Hello World” to any HTTP requests. This sample application will help you get Node.js set up. You can replace it with your own application — just make sure that you modify your application to listen on the appropriate IP addresses and ports. First, let’s create a sample application called hello.js:

cd ~
nano hello.js

Insert the following code into the file: ~/hello.js

const http = require('http');

const hostname = 'localhost';
const port = 3000;

const server = http.createServer((req, res) => {
  res.statusCode = 200;
  res.setHeader('Content-Type', 'text/plain');
  res.end('Hello World!\n');
});

server.listen(port, hostname, () => {
  console.log(`Server running at http://${hostname}:${port}/`);
});

Save the file and exit the editor. This Node.js application listens on the specified address (localhost) and port (3000), and returns “Hello World!” with a 200 HTTP success code. Since we’re listening on localhost, remote clients won’t be able to connect to our application. To test your application, type:

node hello.js

You will receive the following output:

Server running at http://localhost:3000/

Note

Running a Node.js application in this manner will block additional commands until the application is killed by pressing CTRL+C. To test the application, open another terminal session on your server, and connect to localhost with curl:

curl http://localhost:3000

If you get the following output, the application is working properly and listening on the correct address and port:

Hello World!

If you do not get the expected output, make sure that your Node.js application is running and configured to listen on the proper address and port. Once you’re sure it’s working, kill the application (if you haven’t already) by pressing CTRL+C.

Step 3

Installing PM2

Next let’s install PM2, a process manager for Node.js applications. PM2 makes it possible to daemonize applications so that they will run in the background as a service. Use npm to install the latest version of PM2 on your server:

sudo npm install pm2@latest -g

The -g option tells npm to install the module globally, so that it’s available system-wide. Let’s first use the pm2 start command to run your application, hello.js, in the background:

pm2 start hello.js

This also adds your application to PM2’s process list, which is outputted every time you start an application:

[PM2] Spawning PM2 daemon with pm2_home=/home/sammy/.pm2
[PM2] PM2 Successfully daemonized
[PM2] Starting /home/sammy/hello.js in fork_mode (1 instance)
[PM2] Done.
┌────┬────────────────────┬──────────┬──────┬───────────┬──────────┬──────────┐
│ id │ name               │ mode     │  ↺   │ status    │ cpu      │ memory   │
├────┼────────────────────┼──────────┼──────┼───────────┼──────────┼──────────┤
│ 0  │ hello              │ fork     │ 0    │ online    │ 0%       │ 25.2mb   │
└────┴────────────────────┴──────────┴──────┴───────────┴──────────┴──────────┘

As indicated above, PM2 automatically assigns an App name (based on the filename, without the .js extension) and a PM2 id. PM2 also maintains other information, such as the PID of the process, its current status, and memory usage. Applications that are running under PM2 will be restarted automatically if the application crashes or is killed, but we can take an additional step to get the application to launch on system startup using the startup subcommand. This subcommand generates and configures a startup script to launch PM2 and its managed processes on server boots: pm2 startup systemd

The last line of the resulting output will include a command to run with superuser privileges in order to set PM2 to start on boot:

[PM2] Init System found: systemd
sammy
[PM2] To setup the Startup Script, copy/paste the following command:
sudo env PATH=$PATH:/usr/bin /usr/lib/node_modules/pm2/bin/pm2 startup systemd -u sammy --hp /home/sammy

Run the command from the output, with your username in place of sammy:

sudo env PATH=$PATH:/usr/bin /usr/lib/node_modules/pm2/bin/pm2 startup systemd -u sammy --hp /home/sammy

As an additional step, we can save the PM2 process list and corresponding environments:

pm2 save

You have now created a systemd unit that runs pm2 for your user on boot. This pm2 instance, in turn, runs hello.js. Start the service with systemctl:

sudo systemctl start pm2-sammy

If at this point you encounter an error, you may need to reboot, which you can achieve with sudo reboot. Check the status of the systemd unit:

systemctl status pm2-sammy

For a detailed overview of systemd, please review Systemd Essentials: Working with Services, Units, and the Journal. In addition to those we have covered, PM2 provides many subcommands that allow you to manage or look up information about your applications. Stop an application with this command (specify the PM2 App name or id):

pm2 stop app_name_or_id

Restart an application:

pm2 restart app_name_or_id

List the applications currently managed by PM2:

pm2 list

Get information about a specific application using its App name:

pm2 info app_name

The PM2 process monitor can be pulled up with the monit subcommand. This displays the application status, CPU, and memory usage:

pm2 monit

Note

Running pm2 without any arguments will also display a help page with example usage. Now that your Node.js application is running and managed by PM2, let’s set up the reverse proxy.

Step 4

Setting Up Nginx as a Reverse Proxy Server

Your application is running and listening on localhost, but you need to set up a way for your users to access it. We will set up the Nginx web server as a reverse proxy for this purpose. In the prerequisite tutorial, you set up your Nginx configuration in the /etc/nginx/sites-available/example.com file. Open this file for editing:

sudo nano /etc/nginx/sites-available/example.com

Within the server block, you should have an existing location / block. Replace the contents of that block with the following configuration. If your application is set to listen on a different port, update the highlighted portion to the correct port number: /etc/nginx/sites-available/example.com

server {
...
    location / {
        proxy_pass http://localhost:3000;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';
        proxy_set_header Host $host;
        proxy_cache_bypass $http_upgrade;
    }
...
}

This configures the server to respond to requests at its root. Assuming our server is available at example.com, accessing https://example.com/ via a web browser would send the request to hello.js, listening on port 3000 at localhost. You can add additional location blocks to the same server block to provide access to other applications on the same server. For example, if you were also running another Node.js application on port 3001, you could add this location block to allow access to it via https://example.com/app2: /etc/nginx/sites-available/example.com — Optional

server {
...
    location /app2 {
        proxy_pass http://localhost:3001;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';
        proxy_set_header Host $host;
        proxy_cache_bypass $http_upgrade;
    }
...
}

Once you are done adding the location blocks for your applications, save the file and exit your editor. Make sure you didn’t introduce any syntax errors by typing:

sudo nginx -t

Restart Nginx:

sudo systemctl restart nginx

Assuming that your Node.js application is running, and your application and Nginx configurations are correct, you should now be able to access your application via the Nginx reverse proxy. Try it out by accessing your server’s URL (its public IP address or domain name).

Conclusion

Congratulations! You now have your Node.js application running behind an Nginx reverse proxy on an Ubuntu 20.04 server. This reverse proxy setup is flexible enough to provide your users access to other applications or static web content that you want to share.