[Node.js](https://nodejs.org/en/) is an open-source JavaScript runtime environment for building server-side and networking applications. In these guides we'll set up a production-ready Node.js environment on a single server.  This server will run a Node.js application managed by [PM2](http://pm2.keymetrics.io/), and provide users with secure access to the application through an Nginx reverse proxy and HTTPS using a free certificate provided by [Let's Encrypt](https://letsencrypt.org/). Choose your operating system below to get started.

CentOS

In this tutorial, we will cover setting up a production-ready Node.js environment that is composed of two CentOS 7 servers; one server will run Node.js applications managed by PM2, while the other will provide users with access to the application through an Nginx reverse proxy to the application server.

How To Set Up a Node.js Application for Production on CentOS 7

How To Set Up a Node.js Application for Production

Debian

### Introduction

Node.js is an open-source JavaScript runtime environment for easily building server-side and networking applications. The platform runs on Linux, OS X, FreeBSD, and Windows. Node.js applications can be run at the command line, but we'll focus on running them as a service, so that they will automatically restart on reboot or failure, and can safely be used in a production environment.

In this tutorial, we will cover setting up a production-ready Node.js environment on a single Debian 8 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.

## Prerequisites

This guide assumes that you have a Debian 8 server, configured with a non-root user with `sudo` privileges, as described in the [initial server setup guide for Debian 8][initial-setup].

It also assumes that you have a domain name, pointing at the server's public IP address.

Let's get started by installing the Node.js runtime on your server.

## Install Node.js

We will install the latest LTS release of Node.js, using the [NodeSource][nodesource] package archives.

First, you need to 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 Node.js 6.x archives:

```command
cd ~
curl -sL https://deb.nodesource.com/setup_6.x -o nodesource_setup.sh
```

You can inspect the contents of this script with nano (or your preferred text editor):

```command
nano nodesource_setup.sh
```

And run the script under `sudo`:
```command
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 in the same way that you did above:

```command
sudo apt-get install nodejs
```

The `nodejs` package contains the `nodejs` binary as well as `npm`, so you don't need to install `npm` separately. However, in order for some `npm` packages to work (such as those that require compiling code from source), you will need to install the `build-essential` package:

```command
sudo apt-get install build-essential
```

The Node.js runtime is now installed, and ready to run an application! Let's write a Node.js application.

## Create Node.js Application

We will write a *Hello World* application that simply returns "Hello World" to any HTTP requests. This is a sample application that will help you get your Node.js set up, which you can replace with your own application--just make sure that you modify your application to listen on the appropriate IP addresses and ports.

### Hello World Code

First, create and open your Node.js application for editing. For this tutorial, we will use `nano` to edit a sample application called `hello.js`:

```command
cd ~
nano hello.js
```

Insert the following code into the file.  If you want to, you may replace the highlighted port, `<^>8080<^>`, in both locations (be sure to use a non-admin port, i.e. 1024 or greater):

```
[label hello.js]
#!/usr/bin/env nodejs
var http = require('http');
http.createServer(function (req, res) {
  res.writeHead(200, {'Content-Type': 'text/plain'});
  res.end('Hello World\n');
}).listen(<^>8080<^>, 'localhost');
console.log('Server running at http://localhost:<^>8080<^>/');
```

Now save and exit.

This Node.js application simply listens on the specified address (`localhost`) and port (`<^>8080<^>`), 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.

### Test Application

To enable us to test the application, mark `hello.js` executable:

```command
chmod +x ./hello.js
```

And run it like so:

```command
./hello.js
```

```
[secondary_label Output]
Server running at http://localhost:<^>8080<^>/
```

<$>[note]
**Note:** Running a Node.js application in this manner will block additional commands until the application is killed by pressing **Ctrl-C**.
<$>

In order to test the application, open another terminal session on your server, and connect to **localhost** with `curl`:

```command
curl http://localhost:<^>8080<^>
```

If you see the following output, the application is working properly and listening on the proper address and port:

```
[secondary_label Output]
Hello World
```

If you do not see the proper 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**.

## Install PM2

Now we’ll install PM2, which is a process manager for Node.js applications. PM2 provides an easy way to manage and daemonize applications (run them in the background as a service).

We will use `npm`, a package manager for Node modules that installs with Node.js, to install PM2 on our server. Use this command to install PM2:

```command
sudo npm install -g pm2
```

The `-g` option tells `npm` to install the module _globally_, so that it's available system-wide.

## Manage Application with PM2

PM2 is simple and easy to use. We will cover a few basic uses of PM2.

### Start Application

The first thing you will want to do is use the `pm2 start` command to run your application, `hello.js`, in the background:

```command
pm2 start <^>hello.js<^>
```

This also adds your application to PM2's process list, which is outputted every time you start an application:

```
[secondary_label Output]
[PM2] Spawning PM2 daemon
[PM2] PM2 Successfully daemonized
[PM2] Starting <^>hello.js<^> in fork_mode (1 instance)
[PM2] Done.
┌──────────┬────┬──────┬──────┬────────┬─────────┬────────┬─────────────┬──────────┐
│ App name │ id │ mode │ pid  │ status │ restart │ uptime │ memory      │ watching │
├──────────┼────┼──────┼──────┼────────┼─────────┼────────┼─────────────┼──────────┤
│ <^>hello<^>    │ 0  │ fork │ 3524 │ online │ 0       │ 0s     │ 21.566 MB   │ disabled │
└──────────┴────┴──────┴──────┴────────┴─────────┴────────┴─────────────┴──────────┘
 Use `pm2 show <id|name>` to get more details about an app
```

As you can see, 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 an additional step needs to be taken to get the application to launch on system startup (boot or reboot). Luckily, PM2 provides an easy way to do this, the `startup` subcommand.

The `startup` subcommand generates and configures a startup script to launch PM2 and its managed processes on server boots. You must also specify the platform you are running on, which is `ubuntu`, in our case:

```command
pm2 startup systemd
```

The last line of the resulting output will include a command that you must run with superuser privileges:

```
[secondary_label Output]
[PM2] You have to run this command as root. Execute the following command:
<^>sudo env PATH=$PATH:/usr/bin /usr/local/lib/node_modules/pm2/bin/pm2 startup systemd -u sammy --hp /home/sammy<^>
```

Run the command that was generated (similar to the highlighted output above, but with your username instead of `<^>sammy<^>`) to set PM2 up to start on boot (use the command from your own output):

```command
sudo env PATH=$PATH:/usr/bin /usr/local/lib/node_modules/pm2/bin/pm2 startup systemd -u <^>sammy<^> --hp /home/<^>sammy<^>
```

This will create a systemd **unit** which runs `pm2` for your user on boot.  This `pm2` instance, in turn, runs `hello.js`.  You can check the status of the systemd unit with `systemctl`:

```command
systemctl status pm2
```

For a detailed overview of systemd, see [Systemd Essentials: Working with Services, Units, and the Journal][systemd].

### Other PM2 Usage (Optional)

PM2 provides many subcommands that allow you to manage or look up information about your applications. Note that running `pm2` without any arguments will display a help page, including example usage, that covers PM2 usage in more detail than this section of the tutorial.

Stop an application with this command (specify the PM2 `App name` or `id`):

```command
pm2 stop <^>app_name_or_id<^>
```

Restart an application with this command (specify the PM2 `App name` or `id`):

```command
pm2 restart <^>app_name_or_id<^>
```

The list of applications currently managed by PM2 can also be looked up with the `list` subcommand:

```command
pm2 list
```

More information about a specific application can be found by using the `info` subcommand (specify the PM2 *App name* or *id*):

```command
pm2 info <^>example<^>
```

The PM2 process monitor can be pulled up with the `monit` subcommand. This displays the application status, CPU, and memory usage:

```command
pm2 monit
```

Now that your Node.js application is running, and managed by PM2, let's set up the reverse proxy.

## Set Up Nginx as a Reverse Proxy Server

Now that your application is running, and listening on **localhost**, you need to set up a way for your users to access it. We will set up an Nginx web server as a reverse proxy for this purpose. This tutorial will set up an Nginx server from scratch. If you already have an Nginx server setup, you can just copy the `location` block into the server block of your choice (make sure the location does not conflict with any of your web server's existing content).

First, install Nginx using apt-get:

```command
sudo apt-get install nginx
```

Now open the default server block configuration file for editing:

```command
sudo nano /etc/nginx/sites-available/default
```

Delete everything in the file and insert the following configuration. Be sure to substitute your own domain name for the `server_name` directive. Additionally, change the port (`<^>8080<^>`) if your application is set to listen on a different port:

```
[label /etc/nginx/sites-available/default]
server {
    listen 80;

    server_name <^>example.com<^>;

    location / {
        proxy_pass http://localhost:<^>8080<^>;
        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 `http://example.com/` via a web browser would send the request to `hello.js`, listening on port `8080` 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 `8081`, you could add this location block to allow access to it via `http://example.com/app2`:

```
[label Nginx Configuration — Additional Locations]
    location /app2 {
        proxy_pass http://localhost:<^>8081<^>;
        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 and exit.

Make sure you didn't introduce any syntax errors by typing:

```command
sudo nginx -t
```

Next, restart Nginx:

```command
sudo systemctl restart nginx
```

Next, permit traffic to Nginx through a firewall, if you have it enabled.

If you’re using **ufw**, you can use the following command:

```command
sudo ufw allow 'Nginx Full'
```

With **ufw**, you can always check the status with the following command:

```command
sudo ufw status
```

If you’re using **IPTables** instead, you can permit traffic to Nginx by using the following command:

```command
sudo iptables -I INPUT -p tcp -m tcp --dport 80 -j ACCEPT
```

You can always check the status of your IPTables by running the following command:

```command
sudo iptables -S
```

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).

From here, you should continue to secure your set up by reading [How To Secure Nginx with Let’s Encrypt on Debian 8](https://www.digitalocean.com/community/tutorials/how-to-secure-nginx-with-let-s-encrypt-on-debian-8).

## Conclusion

Congratulations! You now have your Node.js application running behind an Nginx reverse proxy on a Debian 8 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. Good luck with your Node.js development!

[initial-setup]: https://www.digitalocean.com/community/tutorials/initial-server-setup-with-debian-8
[nodesource]: https://github.com/nodesource/distributions
[commercial-cert]: https://www.digitalocean.com/community/tutorials/how-to-install-an-ssl-certificate-from-a-commercial-certificate-authority
[systemd]: https://www.digitalocean.com/community/tutorials/systemd-essentials-working-with-services-units-and-the-journal




In this tutorial, we will cover setting up a production-ready Node.js environment on a single Debian 8 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.

How To Set Up a Node.js Application for Production on Debian 8

Ubuntu

14.04

### Introduction

Node.js is an open source Javascript runtime environment for easily building server-side and networking applications. The platform runs on Linux, OS X, FreeBSD, and Windows, and its applications are written in JavaScript. Node.js applications can be run at the command line but we will teach you how to run them as a service, so they will automatically restart on reboot or failure, so you can use them in a production environment. 

In this tutorial, we will cover setting up a production-ready Node.js environment that is composed of two Ubuntu 14.04 servers; one server will run Node.js applications managed by PM2, while the other will provide users with access to the application through an Nginx reverse proxy to the application server.

The CentOS version of this tutorial can be found [here](https://www.digitalocean.com/community/tutorials/how-to-set-up-a-node-js-application-for-production-on-centos-7).

## Prerequisites

This guide uses two Ubuntu 14.04 servers **with private networking** (in the same datacenter). We will refer to them by the following names:

* **app**: The server where we will install Node.js runtime, your Node.js application, and PM2
* **web**: The server where we will install the Nginx web server, which will act as a reverse proxy to your application. Users will access this server's public IP address to get to your Node.js application.

It is possible to use a single server for this tutorial, but you will have to make a few changes along the way. Simply use the localhost IP address, i.e. `127.0.0.1`, wherever the **app** server's private IP address is used.

Here is a diagram of what your setup will be after following this tutorial:

![Reverse Proxy to Node.js Application](https://assets.digitalocean.com/articles/nodejs/node_diagram.png)

Before you begin this guide, you should have a regular, non-root user with `sudo` privileges configured on both of your servers--this is the user that you should log in to your servers as. You can learn how to configure a regular user account by following steps 1-4 in our [initial server setup guide for Ubuntu 14.04](https://www.digitalocean.com/community/articles/initial-server-setup-with-ubuntu-14-04).

If you want to be able to access your **web** server via a domain name, instead of its public IP address, purchase a domain name then follow these tutorials:

* [How To Set Up a Host Name with DigitalOcean](https://www.digitalocean.com/community/tutorials/how-to-set-up-a-host-name-with-digitalocean)
* [How to Point to DigitalOcean Nameservers From Common Domain Registrars](https://www.digitalocean.com/community/tutorials/how-to-point-to-digitalocean-nameservers-from-common-domain-registrars)

Let's get started by installing the Node.js runtime on the **app** server.

## Install Node.js

We will install the latest LTS release of Node.js, on the **app** server.

On the **app** server, let's update the apt-get package lists with this command:

```command
sudo apt-get update
```

Then use `apt-get` to install the `git` package, which `npm` depends on:

```command
sudo apt-get install git
```

Go to the [Node.js Downloads page](https://nodejs.org/en/download/) and find the **Linux Binaries (.tar.xz)** download link. Right-click it, and copy its link address to your clipboard. At the time of this writing, the latest LTS release is **4.2.3**. If you prefer to install the latest stable release of Node.js, go to the [appropriate page](https://nodejs.org/en/download/stable/) and copy that link.

Change to your home directory and download the Node.js source with `wget`. Paste the download link in place of the highlighted part:

```command
cd ~
wget <^>https://nodejs.org/dist/v4.2.3/node-v4.2.3-linux-x64.tar.gz<^>
```

Now extract the tar archive you just downloaded into the `node` directory with these commands:

```command
mkdir node
tar xvf node-v*.tar.?z --strip-components=1 -C ./node
```

If you want to delete the Node.js archive that you downloaded, since we no longer need it, change to your home directory and use this `rm` command:

```command
cd ~
rm -rf node-v*
```

Next, we'll configure the global `prefix` of `npm`, where `npm` will create symbolic links to installed Node packages, to somewhere that it's in your default path. We'll set it to `/usr/local` with this command:

```command
mkdir node/etc
echo 'prefix=/usr/local' > node/etc/npmrc
```

Now we're ready to move the `node` and `npm` binaries to our installation location. We'll move it into `/opt/node` with this command:

```command
sudo mv node /opt/
```

At this point, you may want to make `root` the owner of the files:

```command
sudo chown -R root: /opt/node
```

Lastly, let's create symbolic links of the `node` and `npm` binaries in your default path. We'll put the links in `/usr/local/bin` with these commands:

```command
sudo ln -s /opt/node/bin/node /usr/local/bin/node
sudo ln -s /opt/node/bin/npm /usr/local/bin/npm
```

Verify that Node is installed by checking its version with this command:

```command
node -v
```

The Node.js runtime is now installed, and ready to run an application! Let's write a Node.js application.

## Create Node.js Application

Now we will create a *Hello World* application that simply returns "Hello World" to any HTTP requests. This is a sample application that will help you get your Node.js set up, which 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.

Because we want our Node.js application to serve requests that come from our reverse proxy server, **web**, we will utilize our **app** server's private network interface for inter-server communication. Look up your **app** server's private network address.

If you are using a DigitalOcean droplet as your server, you may look up the server's private IP address through the *Metadata* service. On the **app** server, use the `curl` command to retrieve the IP address now:

```command
curl -w "\n" http://169.254.169.254/metadata/v1/interfaces/private/0/ipv4/address 
```

You will want to copy the output (the private IP address), as it will be used to configure our Node.js application.

### Hello World Code

Next, create and open your Node.js application for editing. For this tutorial, we will use `vi` to edit a sample application called `hello.js`:

```command
cd ~
vi hello.js
```

Insert the following code into the file, and be sure to substitute the **app** server's private IP address for both of highlighted `APP_PRIVATE_IP_ADDRESS` items. If you want to, you may also replace the highlighted port, `8080`, in both locations (be sure to use a non-admin port, i.e. 1024 or greater):

```
[label hello.js]
var http = require('http');
http.createServer(function (req, res) {
  res.writeHead(200, {'Content-Type': 'text/plain'});
  res.end('Hello World\n');
}).listen(<^>8080<^>, '<^>APP_PRIVATE_IP_ADDRESS<^>');
console.log('Server running at http://<^>APP_PRIVATE_IP_ADDRESS<^>:<^>8080<^>/');
```

Now save and exit.

This Node.js application simply listens on the specified IP address and port, and returns "Hello World" with a `200` HTTP success code. This means that the application is only reachable from servers on the same private network, such as our **web** server.

## Test Application (Optional)

If you want to test if your application works, run this `node` command on the **app** server:

```command
node hello.js
```

**Note:** Running a Node.js application in this manner will block additional commands until the application is killed by pressing `CTRL+C`.

In order to test the application, open another terminal session and connect to your **web** server. Because the web server is on the same private network, it should be able to reach the private IP address of the **app** server using `curl`. Be sure to substitute in the **app** server's private IP address for `APP_PRIVATE_IP_ADDRESS`, and the port if you changed it:

```command
curl http://<^>APP_PRIVATE_IP_ADDRESS<^>:<^>8080<^>
```

If you see the following output, the application is working properly and listening on the proper IP address and port:

```
[secondary_label Output:]
Hello World
```

If you do not see the proper output, make sure that your Node.js application is running, and configured to listen on the proper IP address and port.

On the **app** server, be sure to kill the application (if you haven't already) by pressing `CTRL+C`.

## Install PM2

Now we will install PM2, which is a process manager for Node.js applications. PM2 provides an easy way to manage and daemonize applications (run them as a service).

We will use Node Packaged Modules (NPM), which is basically a package manager for Node modules that installs with Node.js, to install PM2 on our **app** server. Use this command to install PM2:

```command
sudo npm install pm2 -g
```

## Manage Application with PM2

PM2 is simple and easy to use. We will cover a few basic uses of PM2.

### Start Application

The first thing you will want to do is use the `pm2 start` command to run your application, `hello.js`, in the background:

```command
pm2 start <^>hello.js<^>
```

This also adds your application to PM2's process list, which is outputted every time you start an application:

```
[secondary_label Output:]
┌──────────┬────┬──────┬──────┬────────┬───────────┬────────┬────────────┬──────────┐
│ App name │ id │ mode │ PID  │ status │ restarted │ uptime │     memory │ watching │
├──────────┼────┼──────┼──────┼────────┼───────────┼────────┼────────────┼──────────┤
│ <^>hello<^>    │ 0  │ fork │ 5871 │ online │         0 │ 0s     │ 9.012 MB   │ disabled │
└──────────┴────┴──────┴──────┴────────┴───────────┴────────┴────────────┴──────────┘
```

As you can see, 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 an additional step needs to be taken to get the application to launch on system startup (boot or reboot). Luckily, PM2 provides an easy way to do this, the `startup` subcommand.

The `startup` subcommand generates and configures a startup script to launch PM2 and its managed processes on server boots. You must also specify the platform you are running on, which is `ubuntu`, in our case:

```command
pm2 startup ubuntu
```

The last line of the resulting output will include a command (that must be run with superuser privileges) that you must run:

```
[secondary_label Output:]
[PM2] You have to run this command as root
[PM2] Execute the following command :
[PM2] <^>sudo su -c "env PATH=$PATH:/opt/node/bin pm2 startup ubuntu -u sammy --hp /home/sammy"<^>
```

Run the command that was generated (similar to the highlighted output above) to set PM2 up to start on boot (use the command from your own output):

```command
 <^>sudo su -c "env PATH=$PATH:/opt/node/bin pm2 startup ubuntu -u sammy --hp /home/sammy"<^>
```

### Other PM2 Usage (Optional)

PM2 provides many subcommands that allow you to manage or look up information about your applications. Note that running `pm2` without any arguments will display a help page, including example usage, that covers PM2 usage in more detail than this section of the tutorial.

Stop an application with this command (specify the PM2 `App name` or `id`):

```command
pm2 stop <^>example<^>
```

Restart an application with this command (specify the PM2 `App name` or `id`):

```command
pm2 restart <^>example<^>
```

The list of applications currently managed by PM2 can also be looked up with the `list` subcommand:

```command
pm2 list
```

More information about a specific application can be found by using the `info` subcommand (specify the PM2 *App name* or *id*)::

```command
pm2 info <^>example<^>
```

The PM2 process monitor can be pulled up with the `monit` subcommand. This displays the application status, CPU, and memory usage:

```command
pm2 monit
```

Now that your Node.js application is running, and managed by PM2, let's set up the reverse proxy.

## Set Up Reverse Proxy Server

Now that your application is running, and listening on a private IP address, you need to set up a way for your users to access it. We will set up an Nginx web server as a reverse proxy for this purpose. This tutorial will set up an Nginx server from scratch. If you already have an Nginx server setup, you can just copy the `location` block into the server block of your choice (make sure the location does not conflict with any of your web server's existing content).

On the **web** server, let's update the apt-get package lists with this command:

```command
sudo apt-get update
```

Then install Nginx using apt-get:

```command
sudo apt-get install nginx
```

Now open the default server block configuration file for editing:

```command
sudo vi /etc/nginx/sites-available/default
```

Delete everything in the file and insert the following configuration. Be sure to substitute your own domain name for the `server_name` directive (or IP address if you don't have a domain set up), and the **app** server private IP address for the `APP_PRIVATE_IP_ADDRESS`. Additionally, change the port (`8080`) if your application is set to listen on a different port:

```
[label /etc/nginx/sites-available/default]
server {
    listen 80;

    server_name <^>example.com<^>;

    location / {
        proxy_pass http://<^>APP_PRIVATE_IP_ADDRESS<^>:<^>8080<^>;
        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 **web** server to respond to requests at its root. Assuming our server is available at `example.com`, accessing `http://example.com/` via a web browser would send the request to the application server's private IP address on port `8080`, which would be received and replied to by the Node.js application.

You can add additional `location` blocks to the same server block to provide access to other applications on the same **web** server. For example, if you were also running another Node.js application on the **app** server on port `8081`, you could add this location block to allow access to it via `http://example.com/app2`:

```
[label Nginx Configuration — Additional Locations]
    location /app2 {
        proxy_pass http://<^>APP_PRIVATE_IP_ADDRESS<^>:<^>8081<^>;
        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 and exit.

On the **web** server, restart Nginx:

```command
sudo service nginx restart
```

Assuming that your Node.js application is running, and your application and Nginx configurations are correct, you should be able to access your application via the reverse proxy of the **web** server. Try it out by accessing your **web** 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 Ubuntu 14.04 servers. This reverse proxy setup is flexible enough to provide your users access to other applications or static web content that you want to share. Good luck with your Node.js development!

Also, if you are looking to encrypt transmissions between your web server and your users, [here is a tutorial that will help you get HTTPS (TLS/SSL) support set up](https://www.digitalocean.com/community/tutorials/how-to-install-an-ssl-certificate-from-a-commercial-certificate-authority).

Node.js is an open source Javascript runtime environment for easily building server-side and networking applications. The platform runs on Linux, OS X, FreeBSD, and Windows, and its applications are written in JavaScript. Node.js applications can be run at the command line but we will...

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

16.04

### Introduction

Node.js is an open-source JavaScript runtime environment for building server-side and networking applications. The platform runs on Linux, MacOS, FreeBSD, and Windows. Node.js applications can be run at the command line, but we'll focus on running them as a service, so that they will automatically restart on reboot or failure, and can safely be used in a production environment.

In this tutorial, we will cover setting up a production-ready Node.js environment on a single Ubuntu 16.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

This guide assumes that you have the following:

- An Ubuntu 16.04 server, configured with a non-**root** user with `sudo` privileges, as described in the [initial server setup guide for Ubuntu 16.04](https://www.digitalocean.com/community/tutorials/initial-server-setup-with-ubuntu-16-04).
- A domain name pointed at your server's public IP, as per [How to Set Up a Host Name with DigitalOcean](https://www.digitalocean.com/community/tutorials/how-to-set-up-a-host-name-with-digitalocean). This tutorial will use **example.com** throughout.
- Nginx installed, covered in [How To Install Nginx on Ubuntu 16.04](https://www.digitalocean.com/community/tutorials/how-to-install-nginx-on-ubuntu-16-04)
- Nginx configured with SSL using Let's Encrypt certificates. [How To Secure Nginx with Let's Encrypt on Ubuntu 16.04](https://www.digitalocean.com/community/tutorials/how-to-secure-nginx-with-let-s-encrypt-on-ubuntu-16-04) will walk you through the process.

When you've completed the prerequisites you will have a server serving the default Nginx placeholder page at **https://<^>example.com<^>/**.

Let's get started by installing the Node.js runtime on your server.

## Step 1 — Installing Node.js

We will install the latest LTS release of Node.js, using the [NodeSource][nodesource] package archives.

First, you need to 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 Node.js 16.x archives:

```command
cd ~
curl -sL https://deb.nodesource.com/setup_16.x -o nodesource_setup.sh
```

You can inspect the contents of this script with `nano` (or your preferred text editor):

```command
nano nodesource_setup.sh
```

Then run the script under `sudo`:

```command
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 in the same way that you did above:

```command
sudo apt-get install nodejs
```

The `nodejs` package contains the `node` binary as well as `npm`, so you don't need to install `npm` separately. However, in order for some `npm` packages to work (such as those that require compiling code from source), you will need to install the `build-essential` package:

```command
sudo apt-get install build-essential
```

The Node.js runtime is now installed, and ready to run an application. Let's write a Node.js application.

## Step 2 — Creating a Node.js Application

We will write a *Hello World* application that returns "Hello World" to any HTTP requests. This is a sample application that will help you get your Node.js set up, which you can replace with your own application — just make sure that you modify your application to listen on the appropriate IP addresses and ports.

### Hello World Code

First, create and open your Node.js application for editing. For this tutorial, we will use `nano` to edit a sample application called `hello.js`:

```command
cd ~
nano hello.js
```

Insert the following code into the file. If you want to, you may replace the highlighted port, `<^>8080<^>`, in both locations (be sure to use a non-admin port, i.e. 1024 or greater):

```
[label hello.js]
#!/usr/bin/env nodejs
var http = require('http');
http.createServer(function (req, res) {
  res.writeHead(200, {'Content-Type': 'text/plain'});
  res.end('Hello World\n');
}).listen(<^>8080<^>, 'localhost');
console.log('Server running at http://localhost:<^>8080<^>/');
```

Now save and exit.

This Node.js application listens on the specified address (`localhost`) and port (`<^>8080<^>`), 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.

### Test Application

In order to test your application, set `hello.js` to be executable using `chmod`:

```command
chmod +x ./hello.js
```

Then run it like so:

```command
./hello.js
```

```
[secondary_label Output]
Server running at http://localhost:<^>8080<^>/
```

<$>[note]
**Note:** Running a Node.js application in this manner will block additional commands until the application is killed by pressing **Ctrl-C**.
<$>

In order to test the application, open another terminal session on your server, and connect to **localhost** with `curl`:

```command
curl http://localhost:<^>8080<^>
```

If you see the following output, the application is working properly and listening on the proper address and port:

```
[secondary_label Output]
Hello World
```

If you do not see the proper 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, switch back to your other terminal and kill the Node.js application (if you haven't already) by pressing **Ctrl+C**.

## Step 3 — Installing PM2

Now we will install PM2, which is a process manager for Node.js applications. PM2 provides an easy way to manage and daemonize applications (run them in the background as a service).

We will use `npm`, a package manager for Node modules that installs with Node.js, to install PM2 on our server. Use this command to install PM2:

```command
sudo npm install -g pm2
```

The `-g` option tells `npm` to install the module _globally_, so that it's available system-wide.

## Step 4 — Managing Applications with PM2

We will cover a few basic uses of PM2.

### Start Application

The first thing you will want to do is use the `pm2 start` command to run your application, `hello.js`, in the background:

```command
pm2 start <^>hello.js<^>
```

This also adds your application to PM2's process list, which is outputted every time you start an application:

```
[secondary_label 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     │ namespace   │ version │ mode    │ pid      │ uptime │ ↺    │ status    │ cpu      │ mem      │ user     │ watching │
├─────┼──────────┼─────────────┼─────────┼─────────┼──────────┼────────┼──────┼───────────┼──────────┼──────────┼──────────┼──────────┤
│ 0   │ hello    │ default     │ N/A     │ fork    │ 13734    │ 0s     │ 0    │ online    │ 0%       │ 25.0mb   │ sammy    │ disabled │
└─────┴──────────┴─────────────┴─────────┴─────────┴──────────┴────────┴──────┴───────────┴──────────┴──────────┴──────────┴──────────┘
```

As you can see, PM2 automatically assigns a **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 an additional step needs to be taken to get the application to launch on system startup (boot or reboot). Luckily, PM2 provides an easy way to do this, the `startup` subcommand.

The `startup` subcommand generates and configures a startup script to launch PM2 and its managed processes on server boots:

```command
pm2 startup systemd
```

The last line of the resulting output will include a command that you must run with superuser privileges:

```
[secondary_label Output]
[PM2] Init System found: systemd
[PM2] You have to run this command as root. Execute 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 that was generated (similar to the highlighted output above, but with your username instead of `<^>sammy<^>`) to set PM2 up to start on boot (use the command from your own output):

```command
sudo env PATH=$PATH:/usr/bin /usr/lib/node_modules/pm2/bin/pm2 startup systemd -u <^>sammy<^> --hp /home/<^>sammy<^>
```

This will create a systemd **unit** which runs `pm2` for your user on boot.  This `pm2` instance, in turn, runs `hello.js`.  You can check the status of the systemd unit with `systemctl`:

```command
systemctl status pm2-<^>sammy<^>
```

For a detailed overview of systemd, see [Systemd Essentials: Working with Services, Units, and the Journal][systemd].

### Other PM2 Usage (Optional)

PM2 provides many subcommands that allow you to manage or look up information about your applications. Note that running `pm2` without any arguments will display a help page, including example usage, that covers PM2 usage in more detail than this section of the tutorial.

Stop an application with this command (specify the PM2 `App name` or `id`):

```command
pm2 stop <^>app_name_or_id<^>
```

Restart an application with this command (specify the PM2 `App name` or `id`):

```command
pm2 restart <^>app_name_or_id<^>
```

The list of applications currently managed by PM2 can also be looked up with the `list` subcommand:

```command
pm2 list
```

More information about a specific application can be found by using the `info` subcommand (specify the PM2 *App name* or *id*):

```command
pm2 info <^>example<^>
```

The PM2 process monitor can be pulled up with the `monit` subcommand. This displays the application status, CPU, and memory usage:

```command
pm2 monit
```

Now that your Node.js application is running, and managed by PM2, let's set up the reverse proxy.

## Step 5 — Setting Up Nginx as a Reverse Proxy Server

Now that your application is running, and listening on **localhost**, 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, we set up our Nginx configuration in the `/etc/nginx/sites-available/default` file. Open the file for editing:

```command
sudo nano /etc/nginx/sites-available/default
```

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.

```
[label /etc/nginx/sites-available/default]
. . .
    location / {
        proxy_pass http://localhost:<^>8080<^>;
        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 `8080` 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 `8081`, you could add this location block to allow access to it via `http://example.com/app2`:

```
[label /etc/nginx/sites-available/default — Optional]
    location /app2 {
        proxy_pass http://localhost:<^>8081<^>;
        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 and exit.

Make sure you didn't introduce any syntax errors by typing:

```command
sudo nginx -t
```

Next, restart Nginx:

```command
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 16.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. Good luck with your Node.js development.

[nodesource]: https://github.com/nodesource/distributions
[commercial-cert]: https://www.digitalocean.com/community/tutorials/how-to-install-an-ssl-certificate-from-a-commercial-certificate-authority
[initial-setup]: https://digitalocean.com/community/tutorials/initial-server-setup-with-ubuntu-16-04
[systemd]: https://www.digitalocean.com/community/tutorials/systemd-essentials-working-with-services-units-and-the-journal
[howto-nameservers]: https://www.digitalocean.com/community/tutorials/how-to-point-to-digitalocean-nameservers-from-common-domain-registrars
[howto-hostname]: https://docs.digitalocean.com/products/networking/dns/
[howto-letsencrypt-auto]: https://www.digitalocean.com/community/tutorials/how-to-secure-nginx-with-let-s-encrypt-on-ubuntu-16-04#step-6-set-up-auto-renewal
[howto-letsencrypt]: https://www.digitalocean.com/community/tutorials/how-to-secure-nginx-with-let-s-encrypt-on-ubuntu-16-04


Node.js is an open source JavaScript runtime environment for easily building server-side and networking applications. Node.js applications can be run at the command line but this guide focuses on running them as a service using PM2, so that they will automatically restart on reboot or failure, and can safely be used in a production environment.

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

18.04

### Introduction

[Node.js](https://nodejs.org/en/) is an open-source JavaScript runtime environment for building server-side and networking applications. The platform runs on Linux, macOS, FreeBSD, and Windows. Though you can run Node.js applications at the command line, this tutorial 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 tutorial, you will set up a production-ready Node.js environment on a single Ubuntu 18.04 server.  This server will run a Node.js application managed by [PM2](http://pm2.keymetrics.io/), 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](https://letsencrypt.org/).

## Prerequisites

This guide assumes that you have the following:

- An Ubuntu 18.04 server setup, as described in the [initial server setup guide for Ubuntu 18.04](https://www.digitalocean.com/community/tutorials/initial-server-setup-with-ubuntu-18-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](https://www.digitalocean.com/docs/networking/dns/quickstart/). This tutorial will use the domain name **example.com** throughout.
- Nginx installed, as covered in [How To Install Nginx on Ubuntu 18.04](https://www.digitalocean.com/community/tutorials/how-to-install-nginx-on-ubuntu-18-04).
- Nginx configured with SSL using Let's Encrypt certificates. [How To Secure Nginx with Let's Encrypt on Ubuntu 18.04](https://www.digitalocean.com/community/tutorials/how-to-secure-nginx-with-let-s-encrypt-on-ubuntu-18-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](https://github.com/nodesource/distributions) 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 Node.js 8.x archives:

```command
cd ~
curl -sL https://deb.nodesource.com/setup_8.x -o nodesource_setup.sh
```

You can inspect the contents of this script with `nano` or your preferred text editor:

```command
nano nodesource_setup.sh
```

When you're done inspecting the script, run it under `sudo`:

```command
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:

```command
sudo apt install nodejs
```

To check which version of Node.js you have installed after these initial steps, type:

```command
nodejs -v
```
```
[secondary_label Output]
v8.11.3
```
<$>[note]
**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`](https://www.npmjs.com/), 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:

```command
npm -v
```
```
[secondary_label Output]
5.6.0
```
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:

```command
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`:

```command
cd ~
nano hello.js
```

Insert the following code into the file:

```js
[label ~/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: 

```command
node hello.js
```
You will see the following output:

```
[secondary_label Output]
Server running at http://localhost:3000/
```

<$>[note]
**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`:

```command
[environment second]
curl http://localhost:<^>3000<^>
```

If you see the following output, the application is working properly and listening on the correct address and port:

```
[secondary_label Output]
[environment second]
Hello World!
```

If you do not see 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: 

```command
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:

```command
pm2 start <^>hello.js<^>
```

This also adds your application to PM2's process list, which is outputted every time you start an application:

```
[secondary_label 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.
┌──────────┬────┬──────┬──────┬────────┬─────────┬────────┬─────┬───────────┬───────┬──────────┐
│ App name │ id │ mode │ pid  │ status │ restart │ uptime │ cpu │ mem       │ user  │ watching │
├──────────┼────┼──────┼──────┼────────┼─────────┼────────┼─────┼───────────┼───────┼──────────┤
│ <^>hello<^>    │ 0  │ fork │ 1338 │ online │ 0       │ 0s     │ 0%  │ 23.0 MB   │ sammy │ disabled │
└──────────┴────┴──────┴──────┴────────┴─────────┴────────┴─────┴───────────┴───────┴──────────┘
 Use `pm2 show <id|name>` to get more details about an app
```

As you can see, 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: 

```command
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:

```
[secondary_label Output]
[PM2] Init System found: systemd
[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<^>`: 

```command
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: 

```command
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`:

```command
sudo systemctl start pm2-<^>sammy<^>
```
Check the status of the systemd unit:

```command
systemctl status pm2-<^>sammy<^>
```

For a detailed overview of systemd, see [Systemd Essentials: Working with Services, Units, and the Journal](https://www.digitalocean.com/community/tutorials/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`):

```command
pm2 stop <^>app_name_or_id<^>
```

Restart an application:

```command
pm2 restart <^>app_name_or_id<^>
```

List the applications currently managed by PM2:

```command
pm2 list
```

Get information about a specific application using its `App name`:

```command
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:

```command
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 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:

```command
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:

```
[label /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<^>`:

```
[label /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:

```command
sudo nginx -t
```

Restart Nginx:

```command
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 18.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. 

Node.js is an open-source JavaScript runtime environment for building server-side and networking applications. Node.js applications can be run at the command line but this guide focuses on running them as a service using PM2, so that they will automatically restart on reboot or failure, and can safely be used in a production environment.

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

### Introduction

[Node.js](https://nodejs.org/en/) is an open-source JavaScript runtime environment for building server-side and networking applications. The platform runs on Linux, macOS, FreeBSD, and Windows. Though you can run Node.js applications at the command line, this tutorial will focus on running them as a service. This means that the applications will restart on reboot or failure and are safe for use in a production environment.

In this tutorial, you will set up a production-ready Node.js environment on a single Debian 9 server.  This server will run a Node.js application managed by [PM2](http://pm2.keymetrics.io/), and provide users with secure access to the application through an [Nginx](https://nginx.org/) reverse proxy. The Nginx server will offer HTTPS, using a free certificate provided by [Let's Encrypt](https://letsencrypt.org/).

## Prerequisites

This guide assumes that you have the following:

- A Debian 9 server setup, as described in the [initial server setup guide for Debian 9](https://www.digitalocean.com/community/tutorials/initial-server-setup-with-debian-9). You should have a non-root user with sudo privileges and an active firewall.
- A [domain name pointed at your server's public IP](https://www.digitalocean.com/docs/networking/dns/quickstart/). This tutorial will use the domain name **example.com** throughout.
- Nginx installed, as covered in [How To Install Nginx on Debian 9](https://www.digitalocean.com/community/tutorials/how-to-install-nginx-on-debian-9).
- Nginx configured with SSL using Let's Encrypt certificates. [How To Secure Nginx with Let's Encrypt on Debian 9](https://www.digitalocean.com/community/tutorials/how-to-secure-nginx-with-let-s-encrypt-on-debian-9) 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](https://github.com/nodesource/distributions) package archives.

To install the NodeSource PPA and access its contents, you will first need to update your package index and install `curl`:

```command
sudo apt update
sudo apt install curl
```

Make sure you're in your home directory, and then use `curl` to retrieve the installation script for the Node.js <^>8<^>.x archives:

```command
cd ~
curl -sL https://deb.nodesource.com/setup_<^>8<^>.x -o nodesource_setup.sh
```

You can inspect the contents of this script with `nano` or your [preferred text editor](https://www.digitalocean.com/community/tutorials/initial-server-setup-with-debian-9#step-six-—-completing-optional-configuration):

```command
nano nodesource_setup.sh
```

When you're done inspecting the script, run it under `sudo`:

```command
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:

```command
sudo apt install nodejs
```

To check which version of Node.js you have installed after these initial steps, type:

```command
nodejs -v
```
```
[secondary_label Output]
v<^>8.11.4<^>
```
<$>[note]
**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`](https://www.npmjs.com/), 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:

```command
npm -v
```
```
[secondary_label Output]
<^>5.6.0<^>
```
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:

```command
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`:

```command
cd ~
nano hello.js
```

Insert the following code into the file:

```js
[label ~/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: 

```command
node hello.js
```
You will see the following output:

```
[secondary_label Output]
Server running at http://localhost:3000/
```

<$>[note]
**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`:

```command
[environment second]
curl http://localhost:<^>3000<^>
```

If you see the following output, the application is working properly and listening on the correct address and port:

```
[secondary_label Output]
[environment second]
Hello World!
```

If you do not see 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](http://pm2.keymetrics.io/), 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: 

```command
sudo npm install pm2@latest -g
```

The `-g` option tells `npm` to install the module globally, so it's available system-wide.

Let's first use the `pm2 start` command to run your application, `hello.js`, in the background:

```command
pm2 start <^>hello.js<^>
```

This also adds your application to PM2's process list, which is outputted every time you start an application:

```
[secondary_label 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.
┌──────────┬────┬──────┬──────┬────────┬─────────┬────────┬─────┬───────────┬───────┬──────────┐
│ App name │ id │ mode │ pid  │ status │ restart │ uptime │ cpu │ mem       │ user  │ watching │
├──────────┼────┼──────┼──────┼────────┼─────────┼────────┼─────┼───────────┼───────┼──────────┤
│ <^>hello<^>    │ 0  │ fork │ 1338 │ online │ 0       │ 0s     │ 0%  │ 23.0 MB   │ sammy │ disabled │
└──────────┴────┴──────┴──────┴────────┴─────────┴────────┴─────┴───────────┴───────┴──────────┘
 Use `pm2 show <id|name>` to get more details about an app
```

As you can see, 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: 

```command
pm2 startup systemd
```

The last line of the resulting output will include a command to run with superuser privileges to set PM2 to start on boot:

```
[secondary_label Output]
[PM2] Init System found: systemd
[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<^>`: 

```command
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: 

```command
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`:

```command
sudo systemctl start pm2-<^>sammy<^>
```
Check the status of the systemd unit:

```command
systemctl status pm2-<^>sammy<^>
```

For a detailed overview of systemd, see [Systemd Essentials: Working with Services, Units, and the Journal](https://www.digitalocean.com/community/tutorials/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`):

```command
pm2 stop <^>app_name_or_id<^>
```

Restart an application:

```command
pm2 restart <^>app_name_or_id<^>
```

List the applications currently managed by PM2:

```command
pm2 list
```

Get information about a specific application using its `App name`:

```command
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:

```command
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 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:

```command
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:

```
[label /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<^>`:

```
[label /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:

```command
sudo nginx -t
```

Restart Nginx:

```command
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 a Debian 9 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. 



Node.js is an open-source JavaScript runtime environment for building server-side and networking applications. In this tutorial, you will set up a production-ready Node.js environment on a single Debian 9 server.

How To Set Up a Node.js Application for Production on Debian 9

### Introduction

[Node.js](https://nodejs.org/en/) is an open-source JavaScript runtime environment for building server-side and networking applications. The platform runs on Linux, macOS, FreeBSD, and Windows. Though you can run Node.js applications at the command line, this tutorial will focus on running them as a service. This means that the applications will restart on reboot or failure and are safe for use in a production environment.

In this tutorial, you will set up a production-ready Node.js environment on a single Debian 10 server.  This server will run a Node.js application managed by [PM2](http://pm2.keymetrics.io/), and provide users with secure access to the application through an [Nginx](https://nginx.org/) reverse proxy. The Nginx server will offer HTTPS, using a free certificate provided by [Let's Encrypt](https://letsencrypt.org/).

## Prerequisites

This guide assumes that you have the following:

- A Debian 10 server setup, as described in the [initial server setup guide for Debian 10](https://www.digitalocean.com/community/tutorials/initial-server-setup-with-debian-10). You should have a non-root user with `sudo` privileges and an active firewall.
- A [domain name pointed at your server's public IP](https://www.digitalocean.com/docs/networking/dns/quickstart/). 
- Nginx installed, as covered in [How To Install Nginx on Debian 10](https://www.digitalocean.com/community/tutorials/how-to-install-nginx-on-debian-10).
- Nginx configured with SSL using Let's Encrypt certificates. [How To Secure Nginx with Let's Encrypt on Debian 10](https://www.digitalocean.com/community/tutorials/how-to-secure-nginx-with-let-s-encrypt-on-debian-10) 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://<^>your_domain<^>/`.

## Step 1 — Installing Node.js

Let's begin by installing the latest LTS release of Node.js, using the [NodeSource](https://github.com/nodesource/distributions) package archives.

To install the NodeSource PPA and access its contents, you will first need to update your package index and install `curl`:

```command
sudo apt update
sudo apt install curl
```
Make sure you're in your home directory, and then use `curl` to retrieve the installation script for the Node.js <^>10<^>.x archives:

```command
cd ~
curl -sL https://deb.nodesource.com/setup_<^>10<^>.x -o nodesource_setup.sh
```

You can inspect the contents of this script with `nano` or your [preferred text editor](https://www.digitalocean.com/community/tutorials/initial-server-setup-with-debian-9#step-six-—-completing-optional-configuration):

```command
nano nodesource_setup.sh
```

When you're done inspecting the script, run it under `sudo`:

```command
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:

```command
sudo apt install nodejs
```

To check which version of Node.js you have installed after these initial steps, type:

```command
nodejs -v
```
```
[secondary_label Output]
v<^>10.16.0<^>
```
<$>[note]
**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`](https://www.npmjs.com/), 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:

```command
npm -v
```
```
[secondary_label Output]
<^>6.9.0<^>
```
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:

```command
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, we can 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`:

```command
cd ~
nano hello.js
```

Insert the following code into the file:

```
[label ~/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: 

```command
node hello.js
```
You will see the following output:

```
[secondary_label Output]
Server running at http://localhost:3000/
```

<$>[note]
**Note:** Running a Node.js application in this manner will block additional commands until you kill the application by pressing `CTRL+C`.
<$>

To test the application, open another terminal session on your server, and connect to `localhost` with `curl`:

```command
[environment second]
curl http://localhost:<^>3000<^>
```

If you see the following output, the application is working properly and listening on the correct address and port:

```
[secondary_label Output]
[environment second]
Hello World!
```

If you do not see 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](http://pm2.keymetrics.io/), 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: 

```command
sudo npm install pm2 -g
```

The `-g` option tells `npm` to install the module globally, so it's available system-wide.

Let's first use the `pm2 start` command to run the `hello.js` application in the background:

```command
pm2 start <^>hello.js<^>
```

This also adds your application to PM2's process list, which is outputted every time you start an application:

```
[secondary_label 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.
┌──────────┬────┬──────┬──────┬────────┬─────────┬────────┬─────┬───────────┬───────┬──────────┐
│ App name │ id │ mode │ pid  │ status │ restart │ uptime │ cpu │ mem       │ user  │ watching │
├──────────┼────┼──────┼──────┼────────┼─────────┼────────┼─────┼───────────┼───────┼──────────┤
│ <^>hello<^>    │ 0  │ fork │ 1338 │ online │ 0       │ 0s     │ 0%  │ 23.0 MB   │ sammy │ disabled │
└──────────┴────┴──────┴──────┴────────┴─────────┴────────┴─────┴───────────┴───────┴──────────┘
 Use `pm2 show <id|name>` to get more details about an app
```

As you can see, PM2 automatically assigns an `App name` based on the filename without the `.js` extension, along with 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. Type the following:

```command
sudo pm2 startup
```

You will see output that looks like this, describing the service configuration that PM2 has generated:

```
[secondary_label Output]
[PM2] Init System found: systemd
Platform systemd
Template
[Unit]
Description=PM2 process manager
Documentation=https://pm2.keymetrics.io/
After=network.target

[Service]
Type=forking
User=root
LimitNOFILE=infinity
LimitNPROC=infinity
LimitCORE=infinity
Environment=PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin
Environment=PM2_HOME=/root/.pm2
PIDFile=/root/.pm2/pm2.pid
Restart=on-failure

ExecStart=/usr/lib/node_modules/pm2/bin/pm2 resurrect
ExecReload=/usr/lib/node_modules/pm2/bin/pm2 reload all
ExecStop=/usr/lib/node_modules/pm2/bin/pm2 kill

[Install]
WantedBy=multi-user.target

Target path
/etc/systemd/system/pm2-root.service
Command list
[ 'systemctl enable pm2-root' ]
[PM2] Writing init configuration in /etc/systemd/system/pm2-root.service
[PM2] Making script booting at startup...
[PM2] [-] Executing: systemctl enable pm2-root...
Created symlink /etc/systemd/system/multi-user.target.wants/pm2-root.service → /etc/systemd/system/pm2-root.service.
[PM2] [v] Command successfully executed.
+---------------------------------------+
[PM2] Freeze a process list on reboot via:
$ pm2 save

[PM2] Remove init script via:
$ pm2 unstartup systemd
```
You have now created a systemd *unit* that runs `pm2` on boot.  This `pm2` instance, in turn, runs `hello.js`.  

Start the service with `systemctl`: 

```command
sudo systemctl start pm2-root.service
```
Check the status of the systemd unit:

```command
systemctl status pm2-root.service
```

You should see output like the following:

```
[secondary_label Output]
● pm2-root.service - PM2 process manager
   Loaded: loaded (/etc/systemd/system/pm2-root.service; enabled; vendor preset: enabled)
   Active: <^>active (running)<^> since Fri 2019-07-12 16:09:54 UTC; 4s ago
```

For a detailed overview of systemd, see [Systemd Essentials: Working with Services, Units, and the Journal](https://www.digitalocean.com/community/tutorials/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`):

```command
pm2 stop <^>app_name_or_id<^>
```

Restart an application:

```command
pm2 restart <^>app_name_or_id<^>
```

List the applications currently managed by PM2:

```command
pm2 list
```

Get information about a specific application using its `App name`:

```command
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:

```command
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 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/<^>your_domain<^>` file. Open this file for editing:

```command
sudo nano /etc/nginx/sites-available/<^>your_domain<^>
```

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:

```
[label /etc/nginx/sites-available/your_domain]
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 `<^>your_domain<^>`, accessing `https://<^>your_domain<^>/` 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://<^>your_domain<^>/<^>app2<^>`:

```
[label /etc/nginx/sites-available/your_domain — 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:

```command
sudo nginx -t
```

Restart Nginx:

```command
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 domain in the browser: `https://<^>your_domain<^>`. 

## Conclusion

Congratulations! You now have your Node.js application running behind an Nginx reverse proxy on a Debian 10 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. 



Node.js is an open-source JavaScript runtime environment for building server-side and networking applications. In this tutorial, you will set up a production-ready Node.js environment on a single Debian 10 server.

How To Set Up a Node.js Application for Production on Debian 10

20.04

### Introduction

[Node.js](https://nodejs.org/en/) is an open-source JavaScript runtime environment for building server-side and networking applications. The platform runs on Linux, macOS, FreeBSD, and Windows. Though you can run Node.js applications at the command line, this tutorial 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 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](http://pm2.keymetrics.io/), 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](https://letsencrypt.org/).

## Prerequisites

This guide assumes that you have the following:

- An Ubuntu 20.04 server setup, as described in the [initial server setup guide for Ubuntu 20.04](https://www.digitalocean.com/community/tutorials/initial-server-setup-with-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](https://www.digitalocean.com/docs/networking/dns/quickstart/). This tutorial will use the domain name **example.com** throughout.
- Nginx installed, as covered in [How To Install Nginx on Ubuntu 20.04](https://www.digitalocean.com/community/tutorials/how-to-install-nginx-on-ubuntu-20-04).
- Nginx configured with SSL using Let's Encrypt certificates. [How To Secure Nginx with Let's Encrypt on Ubuntu 20.04](https://www.digitalocean.com/community/tutorials/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](https://github.com/nodesource/distributions) 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.

```command
cd ~
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:

```command
nano nodesource_setup.sh
```

When you're done inspecting the script, run it under `sudo`:

```command
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:

```command
sudo apt install nodejs
```

To check which version of Node.js you have installed after these initial steps, type:

```command
node -v
```
```
[secondary_label Output]
v<^>14.4.0<^>
```
<$>[note]
**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`](https://www.npmjs.com/), 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:

```command
npm -v
```
```
[secondary_label Output]
<^>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:

```command
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`:

```command
cd ~
nano hello.js
```

Insert the following code into the file:

```js
[label ~/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: 

```command
node hello.js
```
You will receive the following output:

```
[secondary_label Output]
Server running at http://localhost:3000/
```

<$>[note]
**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`:

```command
[environment second]
curl http://localhost:<^>3000<^>
```

If you get the following output, the application is working properly and listening on the correct address and port:

```
[secondary_label Output]
[environment second]
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: 

```command
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:

```command
pm2 start <^>hello.js<^>
```

This also adds your application to PM2's process list, which is outputted every time you start an application:

```
[secondary_label 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               │ 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: 

```command
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:

```
[secondary_label 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/bin/pm2 startup systemd -u <^>sammy<^> --hp /home/<^>sammy<^>
```

Run the command from the output, with your username in place of `<^>sammy<^>`: 

```command
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: 

```command
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`:

```command
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:

```command
systemctl status pm2-<^>sammy<^>
```

For a detailed overview of systemd, please review [Systemd Essentials: Working with Services, Units, and the Journal](https://www.digitalocean.com/community/tutorials/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`):

```command
pm2 stop <^>app_name_or_id<^>
```

Restart an application:

```command
pm2 restart <^>app_name_or_id<^>
```

List the applications currently managed by PM2:

```command
pm2 list
```

Get information about a specific application using its `App name`:

```command
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:

```command
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 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:

```command
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:

```
[label /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<^>`:

```
[label /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:

```command
sudo nginx -t
```

Restart Nginx:

```command
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. 



Node.js is an open-source JavaScript runtime environment for building server-side and networking applications. The platform runs on Linux, macOS, FreeBSD, and Windows. Though you can run Node.js applications at the command line, this tutorial will…

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

12.04

### Introduction
---
This tutorial aims to help you setup up an Ubuntu server to run Node.js applications, including apps based on Express, Geddy, or Sails. These instructions will help you avoid some security mistakes, as well as provide some surprising benefits such as:

- You will not run your app as root; therefore, your app will be more secure.

- You will be using port 80 to run your app, which typically can only be accessed by the root user. (You will able to run your app using a custom URL such as http://mysite.com - but you will not have to specify a port.)

- Your application will restart if it crashes, and it will keep a log of unhandled exceptions.

- Your application will restart when the server starts - i.e. it will run as a service.

These instructions assume that the reader has only a basic knowledge of Linux. You may skip the information that you do not need, but following the steps closely may provide some advantages.

## Create a Safe Account to Run Your Code
---
When you first set up your DigitalOcean droplet, you received instructions to log on using the root account. The instructions looked something like this:

To login to your droplet, you will need to open a terminal window and copy and paste the following string:

```
ssh root@192.241.xxx.xxx
```

Please note, '192.241.xxx.xxx' will be different for you. Simply follow the instructions you received from DigitalOcean when your virtual server was setup and log on using ssh.

As most of us understand, if you run your code using the root account, and if a hostile party compromises the code, that party could get total control of your VPS.

To avoid this, let's setup a safe account that can still perform root operations if we supply the appropriate password. For the purposes of this tutorial, let's call our safe user "safeuser"– you can name it whatever you like. For now, log on as the root user and follow these steps:

* Create the user with a folder in `/home/safeuser/`:

```
useradd -s /bin/bash -m -d /home/safeuser -c "safe user" safeuser
```

* Create a password for `safeuser` - you will be asked to type it twice after you enter the following command:

```
passwd safeuser
```

* Give the safe user permission to use root level commands:

``` 
usermod -aG sudo <^>username<^>
```

## Login as the Safe User
---
Log out of your DigitalOcean root session by pressing ctrl-D. 

Please note that the command to log on as the safe user is the same command you used before, but the user name has changed. Once you have logged on as the safe user, every time you want to run a command that has root privileges, you are going to have to proceed the command with the word **sudo**. From the command line on your own machine, log on using the command that appears below.

```
ssh safeuser@192.241.xxx.xxx
```

## Install GIT
---
One you have logged on, install GIT (we are going to use GIT to install Node.js.). If, for any reason, you are unfamiliar with GIT, it is a beautiful tool that is going to become a big part of your life. Read [the GIT book](http://git-scm.com/book, 'GIT Book') if you want to know more. Installing it on Ubuntu is easy:

```
sudo apt-get install git
```

The word **sudo** indicates that you want to run this command as root. You will be prompted for your password - i.e. the safe user password. When you provide your password, the command will run.

## Install Latest Node.JS
---
Please note that v0.10.24 is the most recent version of Node as of this writing. If there is a newer version, please use that version number instead.

Type the following commands, one line at a time, and watch the magic as your droplet downloads, compiles, and installs the Node.js:

```
sudo apt-get install build-essential
sudo apt-get install curl openssl libssl-dev
git clone https://github.com/joyent/node.git
cd node
git checkout v0.10.24
./configure
make
sudo make install
```

When you type sudo make, a lot of things are going to happen. Be patient.

When the make install process ends, make sure all went well by typing:

```
node -v
```

If all went well, you should see: ```v0.10.24.```
 
## Give Safe User Permission To Use Port 80
---
Remember, we do NOT want to run your applications as the root user, but there is a hitch: **your safe user does not have permission to use the default HTTP port (80)**. You goal is to be able to publish a website that visitors can use by navigating to an easy to use URL like <^>http://mysite.com<^>.

Unfortunately, unless you sign on as root, you’ll normally have to use a URL like http://mysite.com:3000 - notice the port number.

A lot of people get stuck here, but the solution is easy. There a few options but this is the one I like. Type the following commands:

```
sudo apt-get install libcap2-bin
sudo setcap cap_net_bind_service=+ep /usr/local/bin/node
```

Now, when you tell a Node application that you want it to run on port 80, it will not complain.

## Use NPM To Install A Package Called PM2.
---
NPM is a package manager that you will use to install frameworks and libraries to use with your Node.js applications. NPM was installed with Node.js. PM2 is a sweet little tool that is going to solve two problems for you:

1. **It is going to keep your site up by restarting the application if it crashes.** These crashes should NOT happen, but it is good know that PM2 has your back. (Some people may be aware of Forever.js, another tool that is used to keep node based sites running - I think you will find that PM2 has a lot to offer.)

2. **It is going to help you by restarting your node application as a service every time you restart the server.** Some of use know of other ways to do this, but pm2 makes it easier, and it has some added flexibility.

Install PM2 by typing thr following at the command line:

```
sudo npm install pm2 -g
```

## Create a Simple Node App
---
This is where you can test your environment to be sure everything is working as it should. In this example, I will use the IP address, but your goal should be to use a domain name. Look at these instructions later: [How To Set Up a Host Name with DigitalOcean](https://www.digitalocean.com/community/articles/how-to-set-up-a-host-name-with-digitalocean "Set up host name")

First, create a simple node app just for testing. At the command line type: 

```
nano app.js
```

Then enter the following lines of code into the nano editor:

```
var http = require('http');
var server = http.createServer(function (request, response) {
  response.writeHead(200, {"Content-Type": "text/plain"});
  response.end("Hello World\n");
});
server.listen(80);
console.log("Server running at http://127.0.0.1:80/");
```

Press **ctrl-X** to exit - when nano asks if you want to save, answer yes. 

Now you have a node based application called app.js that you can use to test your environment.

You can run app.js at the command line by typing: ```node app.js```

Do that, and you should be able to see your hello world text by using a browser and typing your IP address as the URL. You can interrupt execution by pressing crtl-C. This is NOT how we want to run our application. There is a MUCH better way. We will use PM2 to run it instead of using Node directly.

## Run your app using PM2, and ensure that your node.js application starts automatically when your server restarts
---
There are some huge benefits for you if you run your application using pm2. Instead of running your app as above, run it using the following command:
```pm2 start app.js```

You should see this report:

![Img](https://assets.digitalocean.com/articles/PM2_Node.js/1.png)

What are the advantages of running your application this way?

- PM2 will automatically restart your application if it crashes.

- PM2 will keep a log of your unhandled exceptions - in this case, in a file at /home/safeuser/.pm2/logs/app-err.log.

- With one command, PM2 can ensure that any applications it manages restart when the server reboots. Basically, your node application will start as a service.

Run this command to run your application as a service by typing the following:
```
sudo env PATH=$PATH:/usr/local/bin pm2 startup -u safeuser
```
Please note, you may not be using safeuser as the user name - use the name that corresponds to your setup. You should see the following report:

```
Adding system startup for /etc/init.d/pm2-init.sh ...
   /etc/rc0.d/K20pm2-init.sh -> ../init.d/pm2-init.sh
   /etc/rc1.d/K20pm2-init.sh -> ../init.d/pm2-init.sh
   /etc/rc6.d/K20pm2-init.sh -> ../init.d/pm2-init.sh
   /etc/rc2.d/S20pm2-init.sh -> ../init.d/pm2-init.sh
   /etc/rc3.d/S20pm2-init.sh -> ../init.d/pm2-init.sh
   /etc/rc4.d/S20pm2-init.sh -> ../init.d/pm2-init.sh
   /etc/rc5.d/S20pm2-init.sh -> ../init.d/pm2-init.sh
```

**Now our stated objectives have been reached!**

- You are not running as root; therefore, your app is more secure.

- You are using port 80, which can usually only be used by the root user.

- Your application will restart if it crashes, and it will keep a log on unhandled exceptions.

- Your application will restart when the server starts.

Have fun! This is a fairly robust setup to start with. 

**After thought: ** You may notice a file folder called node in the safeuser directory. It was used during installation, but you no longer need it. You can delete it by typing the following:

```
rm -rf /home/safuser/node
```

There is a lot more to learn about node, but this tutorial will put you on the right path. To learn more about pm2, visit [the pm2 repo](https://github.com/Unitech/pm2 "click here to visit the pm2 repo")

**Important Clarification**: There is a startup script that starts your Node applications, but you will avoid a lot of confusion if you understand how it works. The script is called 'pm2-init.sh.' It lives in the 'etc/init.d/' directory, but it does NOT start app.js. Instead, it starts the programs that were running under PM2 the last time the server shutdown.

This is important. If your node application does not show up in the list when you type **pm2 list,** then your app will not restart when the server restarts. Follow the proper instructions for starting your apps using pm2 to ensure that they will restart: ```pm2 start app.js```

By Jim Cassidy


Use these instructions to setup an Ubuntu server to run Node.js applications, including apps based on Express, Geddy, or Sails. This will help you avoid some security mistakes and will provide some surprising benefits. 

How To Use PM2 to Setup a Node.js Production Environment On An Ubuntu VPS

Sign up for Infrastructure as a Newsletter.

Working on improving health and education, reducing inequality, and spurring economic growth? DigitalOcean would like to help.

Working on improving health and education, reducing inequality, and spurring economic growth? We'd like to help.

Get paid to write technical tutorials and select a tech-focused charity to receive a matching donation.

You get paid; we donate to tech nonprofits.

DigitalOcean makes it simple to launch in the cloud and scale up as you grow – whether you’re running one virtual machine or ten thousand.