DEV Community: Dean Jones

While Linux is running other processes in the background

Dean Jones — Thu, 27 Oct 2022 18:42:12 +0000

When working in the Linux family of operating systems, there are times when you need to start a long process, such as searching for a file, and at the same time return to working in the console. It's perfectly reasonable to open multiple terminals and do each task individually, but what if we're not looking for the easy way out? In this case, it would make sense to run the process in the background. Let's see how to do it in two ways.

First you need to understand the syntax of the command line. Running one program/script, etc. execute explicitly, for example:

ping 10.10.0.1
or

./script.sh
or

/home/admin/scripts/script.sh
To start one program at the end of another, use the && (double ampersand) logical operator, for example:

mysqldump mybase -u user1 > db.sql && tar zcvf db.tar db.sql
Not a very good example, since you could use the redirect “|”, approximately it would look like this:

mysqldump mybase -u user1 | tar -cvf db.tar -
All of these examples are great for scripting, but running "long" processes will make the terminal inaccessible, as noted above. In this case, the following example will help:

find / -iname “*.txt” > abc.list &
It is the single & at the end of the line, separated by a space.

As you can see, the first line starts the process, but since there are few txt files in the system, the process ends. A subsequent press of Enter in the terminal reports that the process has completed successfully.

Let's consider another option. Let's use the ping utility, we will write the results to a file.

Due to the lack of restrictive parameters for this command, its execution will be interrupted when the hard disk space runs out.

Terminating the process with killall will show that the process did not end on its own, but was “killed”.

You can control background processes, in this case, with the command:

jobs

The jobs command itself will show how many processes are running and what exactly is running, but the different keys help display more information. The -l switch will also show the system process ID (PID). The -p switch will display only PIDs, without a description.

You can use the fg 1 or %1 command to enter foreground mode.

Alternative way.

Use the screen multiplexer utility. Some distributions require installation.

CentOS:

yum install screen
Ubuntu:

apt-get install screen
Running the command is simple:

screen

After execution, a window with introductory text will appear.

Press Enter.

The contents of the terminal will be updated. We can execute a command, for example, the same ping. To return to the main terminal, press ctrl + a, and then the d key.

A message will appear in the terminal that the process has been detached.

You can view the running screens with the command:

screen -list

Return to the process can be done with the command:

screen -r
or

screen -r
In our case:

screen -r 2636.pts-0.ubuntu

As you can see, the process was running in the background.

Sometimes you need a script that would run a process in the background when the system boots. In this case, you should use the following example:

screen -d -m -S SCREEN_NAME program_1
-d -m Runs the screen process in detached mode. A new session will be created, but it will not be shown.

-S - will set the name for the process. Useful when multiple screen processes are running.

You can open the process window with the command:

screen -r my_ping

For more information visit hostrooster.com

How to set up NGINX with Node.js on Debian using HostRooster

Dean Jones — Tue, 25 Oct 2022 14:22:26 +0000

This post explains how to set up the Debian operating system-powered virtual server where node.js and the NGINX web server will be installed.

*What is Node.js and NGINX?
*
A JavaScript framework called Node.js is capable of serving responsive and dynamic content. Like HTML or CSS, JavaScript is often a built-in browser language. Additionally, Node.js is a JavaScript server-side platform similar to PHP. Node.js frequently integrates with other well-liked server programs like NGINX or Apache. In this article, we'll look at setting up NGINX to handle requests from the outside world and Node.js to handle requests from the inside.

*Initial requirements
*
The majority of the commands in this manual call for superuser rights. Install the sudo command, enable superuser mode, and add your user to the sudo group if you encounter the following bash error while using the sudo command: sudo: command not found:

su - apt-get install sudo -y usermod -aG sudo yourusername

Update local repositories and packages:

sudo apt-get update && sudo apt-get upgrade
Installing and configuring NGINX

Install NGINX as well as the screen module, which will be used later:

apt-get install nginx screen
Start nginx:

service nginx start
Use the cd command to change to the following directory:

cd /etc/nginx/sites-available/
Create a new file, replacing example.com with your domain name or IP address:

touch example.com
Paste the following lines into the generated file, replacing example.com with your domain name or IP address:

`#Names a server and declares the listening port
server {
listen 80;
server_name example.com www.example.com;

Configures the publicly served root directory

Configures the index file to be served

root /var/www/example.com;
index index.html index.htm;

These lines create a bypass for certain pathnames

www.example.com/test.js is now routed to port 3000

instead of port 80

location /test.js {
proxy_pass http://example.com:3000;
proxy_set_header Host $host;
}
}`

Save changes and change directory:
cd /etc/nginx/sites-enabled/
Create a symbolic link to the created file:
ln -s /etc/nginx/sites-available/example.com
Remove the default symbolic link:
rm default
Restart NGINX to apply the new configuration:
service nginx reload
Creating directories and HTML files

Create the following directory hierarchy, replacing example.com:
mkdir -p /var/www/example.com
Change to the created directory:
cd /var/www/example.com
Create an index file:
touch index.html
Insert the following lines:
`<!DOCTYPE html>

` If you have not finished the guide, the button below will not `work.

` The button links to test.js. The test.js request is passed through NGINX and then handled by the Node.js server. `

Go to test.js

Installing Node.js`

At this point, NGINX is listening on port 80 and serving the content. It is also configured to forward requests to the /test.js application on port 3000.
Install the Node Version Manager:
wget -qO- https://raw.githubusercontent.com/creationix/nvm/v0.33.11/install.sh | bash
Close and reopen your terminal.
Install Node.js with the following command: nvm install 0.10

Create the following file:
touch /var/www/example.com/server.js

Paste the following content into it:
`//nodejs.org/api for API docs //Node.js web server var http = require("http"), //Import Node.js modules url = require("url"), path = require("path"), fs = require("fs");
http.createServer(function(request, response) { //Create server var name = url.parse(request.url).pathname; //Parse URL var filename = path.join(process.cwd(), name); //Create filename fs.readFile(filename, "binary", function(err, file) { //Read file if(err) { //Tracking Errors response.writeHead(500, {"Content-Type": "text/plain"}); response.write(err + "n"); response.end(); return; } response.writeHead(200); //Header request response response.write(file, "binary"); //Sends body response response.end(); //Signals to server that }); //header and body sent }).listen(3000); //Listening port console.log("Server is listening on port 3000.") //Terminal output

Start a new screen session:
`screen

Next, press Enter and start the Node.js server:
node server.js`

Press the key combination Ctrl+A, then D .

Create a test application

Create a file with test data:
`touch /var/www/example.com/test.js

And paste the following data into it:
<!DOCTYPE html>

Your Node.JS server is working.

` The below button is technically dynamic. You are now using Javascript on both the client-side and the server-side. `

Display the date and time.

Open port 80 for http connection:iptables -A INPUT -p tcp --dport 80 -j ACCEPT
``
Navigate in your browser to your domain or ip address. The next page will be displayed. Click the Go to the test.js button :

If everything is configured correctly, using the Display the date and time button on a new page, you can display the current time and date:

Node.js and [NGINX]

CLI vs API: What's the Difference?

Dean Jones — Tue, 13 Sep 2022 16:49:05 +0000

****In this article, we will discuss why API and CLI automation tools are required, as well as how to use them using HostRooster as an example.

What is Command Line Interface (CLI)?
API (Application Programming Interface) is a method for one program to interact with another when elements from one application are used within another.

It's difficult to know what to do next with these tools based on their definitions, so let's take a closer look at each one in a detail.

1. Command Lind Interface
Before graphical user interfaces we're created, the only way to interact with a computer was via command language which was second nature to most people at that point. How many of you remember using ms-dos. Does not seem that long ago at all, but that was more than 20 years ago and despite the advent of graphical interfaces over the last couple of decades, the command line still remains an important tool today. But why? Well, i believe it is because it provides quick and direct access to the necessary functions of a computer and or server over and above the new graphical interfaces.

2. How the Command Lind Interface CLI's Operates
A users first needs to enter text commands into the interface command line and then sit and wait for the computer to respond. The tool then translates user requests into operating-system-friendly functions and responds to the user. Proving you have entered something the the computer can understand. You'll get back a positive response or command line error. The Command Line displays errors for incorrect command syntax, commands that are not valid for the active window, or commands that are lacking required parameter or have incorrect parameters. Commands in the CLI can be either one word or multiple lines, known as scripts.

For example, you can determine the volume of the created disk using the hostrooster command line interface as follows:

>s2ctl server get-volume l1s12345 --volume-id 20210
hostrooster tool *s2ctl allows you to control your infrastructure from the terminal.

As a result, you will receive detailed server information as foolows:

id: 20210 name: boot server_id: l1s12345 size_mb: 25600 created: '1970-01-01T0:00:00.0000000Z'

The Command Line Inferface tool can be used to automate routine tasks. You or your programming team can create a set of commands that the computer will execute at a specific time or when a specific situation occurs.

With quick commands and the input line, you can do everything that is available in the hostrooster control panel GUI.

What is API?
Well the wikipedia definition is a programming interface that allows two or more computer programs to communicate with one another. It is a type of software interface that provides a service to other programs. An API specification is a document or standard that describes how to build or use such a connection or interface.

The API essentially acts as a bridge between two programs, allowing them to communicate with each another via a set of protocols. Most developers do not need to understand how a third-party API work; but instead use the interface to communicate with other products and services.

An API can also be viewed as standing contract between two services that defines how the services interact with one another. The contract is written documentation that describes how developers should structure requests and responses. You can, for example, read the hostrooster API documentation, which includes a description of the API, request and response structures, error codes, and operation examples.

To begin, you must use authorization data to gain access to the API (API key, password, Secret key). To use the hostrooster API, for example, the user must first generate an API key for the project, which must then be passed with each request in the X-API-KEY header (exmaple):

-H "X-API-KEY: lmGwbvllpIqIrKROOCefefefeffKP5EYf...gfXUTpuYRefefefefShmm6r"

The operating principle
Mulesoft experts provide a good example of how the API works by comparing this tool to a restaurant. Consider sitting at a restaurant table and selecting a dish. The restaurant kitchen is a component of the "system" that will prepare the dishes you requested. However, there is insufficient link to send your order to the kitchen and deliver the food to your table. This is where the waiter (in our case, the API) comes in, taking your request or order and informing the kitchen (i.e. the system) of what to do. Then he provides you with the answer in the form of delectable food (example).

curl -X GET \ https://api.hostrooster/api/v1/servers/{server_id} \ -H 'content-type: application/json' \ -H 'x-api-key: lmGwbvllpIqIrKROOCLgE5ZefefeefYf...gfXUTpuYRpNQkCqShmm6r'

The hostrooster API accepts this request, sends it to the "kitchen" (the system), and returns a response in the form of server information.
{ "servers": [ { "id": "l1s2400", "location_id": "am2" , "cpu": 1 , "ram_mb": 1024 , "volumes": [ { "id": 2977 , "name": "boot", "size_mb": 25600, "created": "2020-11-12T09:09:30.46252" }, { "id": 2978, "name": "additional", "size_mb": 30720, "created": "2020-11-12T09:36:34.376165" } ], "nics": [ { "id": 3024, "network_id": "l1n1", "mac": "ca:05:27:ff:56:89", "ip_address": "45.14.48.218", "mask": 28, "bandwidth_mbps": 50 }, { "id": 3025, "network_id": "l1n368", "mac": "ca:05:1a:50:f6:07", "ip_address": "10.0.0.1", "mask": 24, "bandwidth_mbps": 1024 } ], "image_id": "CentOS-7.7-X64", "is_power_on": true, "name": "public-api", "login": "root", "password": "EuvzlqK6pv", "ssh_key_ids": [ 223, 224 ], "state":"Active", "created": "2020-11-12T09:09:54.6478655Z", "tags": [ "production", "elastic" ] }, { "id": "l1s2401", "location_id": "am2", "cpu": 2, "ram_mb": 3072, "volumes": [ { "id": 2979, "name": "boot", "size_mb": 25600, "created": "2020-11-12T09:43:43.257493" } ], "nics": [ { "id": 3026, "network_id": "l1n1", "mac": "ca:05:5e:6e:4d:36", "ip_address": "45.14.48.219", "mask": 28, "bandwidth_mbps": 100 } ], "image_id": "CentOS-7.7-X64", "is_power_on": false, "name": "example", "login": "root", "password": "TzJYPpAV9P9", "ssh_key_ids": [], "state": "Active", "created": "2020-11-12T09:44:05.0545552Z", "tags": [ "production", "gitlab" ], "application_ids": [ "nginx", "gitlab", "wordpress" ] } ] }
As a result, the task ID is returned, allowing you to track the process of changing the VPS settings as well as its ID.

You can automate application interaction by using the APIs of various services, sending requests and parsing responses. The use of APIs can be automated to make software development processes more flexible, allowing programmers to concentrate on more important tasks.

Today, mosts applications makes use of the API. Web applications use APIs to connect user-facing front ends with all-important back end functionality and data. Streaming services like Spotify and Netflix use APIs to distribute content. Automotive companies like Tesla send software updates via APIs. Others use APIs to unlock car data for third-parties. An interesting fact is that if all APIs in the world were to be removed one day, almost all services and most applications would cease to function!

Both tools (CLI and API) enable you to automate the process of working with hostrooster virtual machines and receive quick responses to requests without having to navigate to the control panel. What you can do with these tools is as follows and more:

control virtual machines
scale virtual machine configuration
domain name creation and deletion
connect networks
configure NAT and Firewall rules, and create and delete border gateways
view project details in the control panel
view server information and control server power
manage SSH keys
control snapshots