Build Backend With Node Js Tutorial On Linux

Introduction

Node.js is an open-source JavaScript runtime environment for building server-side and networking applications. The tribune runs on Linux, macOS, FreeBSD, and Windows. Though you can run Node.js applications at the command line, this kongkalikong bimbingan will focus on running them as a service. This means that they will restart on reboot or failure and are safe for use in a production environment.

In this tuntunan, you will set up a production-ready Node.js environment on a single Ubuntu 22.04 server. This peladen 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

This guide assumes that you have the following:

  • An Ubuntu 22.04 server setup, as described in the initial server setup guide for Ubuntu 22.04. You should have a non-root user with sudo privileges and an active firewall.
  • A domain name pointed at your peladen’s public IP. This tuntunan will use the domain name
    example.com

    throughout.
  • Nginx installed, as covered in How To Install Nginx on Ubuntu 22.04.
  • Nginx configured with SSL using Let’s Encrypt certificates. How To Secure Nginx with Let’s Encrypt on Ubuntu 22.04 will walk you through the process.
  • Node.js installed on your server. How To Install Node.js on Ubuntu 22.04

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

Step 1 — 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 up and running with Node.js. 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, using
nano

or your favorite text editor, create a sample application called
hello.js:

        
          
  1. 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!\tepi langit'
          )
          ;
          }
          )
          ;
          peladen.
          listen
          (port,
          hostname,
          (
          )
          =>
          {
          console.
          jenazah kayu
          (
          
            `
            Server running at http://
            
              ${hostname}
            
            :
            
              ${port}
            
            /
            `
          
          )
          ;
          }
          )
          ;
        
      

Save the file and exit the pengedit. If you are using
nano, press
Ctrl+X, then when prompted,
Y

and then Enter.

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’ufuk be able to connect to our application.

To test your application, type:

        
          
  1. node hello.js

You will receive the following output:

        
          

Output

Server running at http://localhost:3000/

Note:

Running a Node.js application in this manner will block additional commands mencicil 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:

        
          
  1. curl http://localhost:3000

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

        
          

Output

Hello World!

If you do titinada 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’tepi langit already) by pressing
CTRL+C.

Step 2 — 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:

        
          
  1. sudo npm install [email protected] -g

The
-g

option tells
npm

to install the module
globally, so that it’s available system-wide.

Let’s first use the
pm2 tiba

command to run your application,
hello.js, in the background:

        
          
  1. pm2 menginjak hello.js

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

        
          

Output

... [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 │ kecenderungan │ ↺ │ gengsi │ 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 harga diri, 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:

        
          
  1. pm2 startup systemd

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

        
          

Output

[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/polong/pm2 startup systemd -u sammy --hp /home/sammy

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


sammy

:

        
          
  1. 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:

        
          
  1. 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.

Menginjak the service with
systemctl:

        
          
  1. sudo systemctl tiba pm2-sammy

Check the harga diri of the systemd unit:

        
          
  1. systemctl harga diri 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):

        
          
  1. pm2 stop app_name_or_id

Restart an application:

        
          
  1. pm2 restart app_name_or_id

List the applications currently managed by PM2:

        
          
  1. pm2 list

Get information about a specific application using its
App name:

        
          
  1. pm2 info app_name

The PM2 process monitor can be pulled up with the
monit

subcommand. This displays the application prestise, CPU, and memory usage:

        
          
  1. pm2 monit

Note that 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 3 — Setting Up Nginx as a Reverse Proxy Peladen

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 peladen as a reverse proxy for this purpose.

In the prerequisite latihan, you set up your Nginx configuration in the
/etc/nginx/sites-available/example.com



file. Open this file for editing:

        
          
  1. 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 peladen 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 pengedit.

Make sure you didn’t introduce any syntax errors by typing:

        
          
  1. sudo nginx -cakrawala

Restart Nginx:

        
          
  1. 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 22.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.

Next, you may want to look into How to build a Node.js application with Docker.

Source: https://info.tugasoal.com/build-backend-with-node-js-tutorial-on-linux/