Community Blog Deploying Node.js Apps for Production on Alibaba Cloud

Deploying Node.js Apps for Production on Alibaba Cloud

In this tutorial, we will cover setting up a production-ready Node.js application using services provided by Alibaba Cloud.

By Kati Frantz, Alibaba Cloud Tech Share Author. Tech Share is Alibaba Cloud's incentive program to encourage the sharing of technical knowledge and best practices within the cloud community.


Node.js is a Javascript runtime environment used to build high-performance and fast server-side applications. Node.js server-side applications, if deployed in the wrong way could become really slow and not be able to support a growing traffic.

In this tutorial, we will cover setting up a production-ready Node.js application using the amazing services provided by Alibaba Cloud services. We'll be deploying an application called Node.js Blog, and to do this, we'll be using the following Alibaba Cloud services:

  • Elastic Compute Service: A virtual computing environment that includes the CPU, memory, OS, bandwidth, disks, and other basic computing components. We'll use this service to launch a Linux instance, to which we'll deploy our Node.js application.
  • ApsaraDB for MongoDB: A secure, reliable, and elastically scalable cloud database service. We'll use this service to launch a MongoDB database for our Node.js application.


Before you begin this tutorial you'll need the following:

  • The Node.js application we'll be deploying. You can find it on this Github repository
  • An Ubuntu 16.04 64 bit ECS instance. You can create one using this tutorial.
  • An ApsaraDB for MongoDB instance. You can create one using this tutorial.
  • Successfully connect to your ECS instance. To connect using SSH, you can follow this tutorial.

Note: Make sure the ECS instance and the ApsaraDB for MongoDB instance are created in exactly the same zone. This will improve application performance and also avoid any connection issues or restrictions.

Step 1 - Installing All Server Dependencies

In this step, we'll be installing all the dependencies we need to be able to run our node js application. To follow along, make sure you are logged in to your ECS instance.

Installing Git

To be able to get the application code from GitHub, we'll have to clone the repository using git. Let's install git on our instance using the following command:

sudo apt-get install git

To verify the installation, run the following command to check the version of git installed: git --version. In my case, I receive the following output: git version 2.7.4.

Installing Node.js

To run a node.js application, we need to install the specific node js version required for this application to run. For our node js blog, we require Node version 8 or above. To install it, run the following command:

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

This command downloads a file called nodesource_setup.sh which is a shell script to install node js on our instance. Run this shell script with the following command:

sudo bash nodesource_setup.sh

And finally, to complete the installation, run the following:

sudo apt-get install -y nodejs

To verify your node js installation, run node -v to see what version of node was installed. In my case I receive the latest subversion of version 8 which is v8.13.0.

Installing Nginx

Nginx is one of the most popular web servers in the world and is being used by some of the largest sites. To deploy our application, we'll be serving our application using nginx as a proxy server. We'll talk more about this. To install nginx, run the following:

sudo apt-get install nginx

To test your installation, run nginx -v to see the installed version. In my case, I receive the following output: nginx version: nginx/1.10.3 (Ubuntu).

Installing PM2 Process Manager

Node.js applications are very brittle, and in production, we need to use a powerful process manager to monitor out node js application, making sure the process is always running. The process manager we'll use in this case is called pm2 and comes as a node js package. PM2 not only monitors our node js application for crashes, but also automatically scales our node js application, optimizing all the CPUs on the instance. To install PM2, run the following:

npm i -g pm2

To verify your installation, run pm2 -v. In my case, I receive the following output: 3.2.2.

Step 2 - Getting the Application Code

In this step, we'll clone the application repository so we can run on our instance.

Cloning the Application Code

To clone the application code, run the following command:

cd /home
git clone https://github.com/bahdcasts/node-js-blog.git

Installing Project Dependencies

To install the project dependencies, run the following command:

cd /home/node-js-blog
npm install

Setting up Environment Variables

Most node js applications would require setting up server environment variables. This project uses a package called dot-env, and using this package, we can place all our environment variables in a file called .env. We'll create this file, and add some environment variables to it. Run the following command:

cd /home/node-js-blog
nano .env

This opens a new file called .env using the terminal code editor nano. Place the following content into the file:


These are the environment variables required for this project to work. The PORT is the specific port on which our Node js application will run on. The EXPRESS_SESSION_KEY is just a random string used to encrypt user sessions.

Also, the images of this blog are uploaded to cloudinary, and the cloudinary environment variables are required for that. You could skip this, since it's not the focus of this tutorial. This is just to show you how to setup your own custom environment variables when deploying your own Node js projects.

The final environment variable is the DB_URI and this will be the environment variable for connecting to our ApsaraDB for MongoDB instance. We'll add this in a later step.

Note: To quit the nano editor, use CTRL + X and then Y.

Step 3 - Connecting to the MongoDB Instance

In this step, we'll connect our application to the ApsaraDB for MongoDB instance we created earlier.

Whitelisting Our Server IP on ApsaraDB for MongoDB

By default the MongoDB instance doesn not permit connections from any address. Using the console, we'll whitelist the IP address of our ECS instance so that our application can open a successful connection.

First, visit your console, open the MongoDB instance, and visit the Data Security tab. Here, click on the Manually modify button to add a new IP address.


Save the changes. This action gives the permission for our application to connect to this MongoDB instance.

Setting up DB_URI Connection String

From the Database Connection tab, get the connection string to the database:


Setting the DB_URI Environment Variable

Now copy the connection string, and update the value of the DB_URI environment variable. Using nano .env, your .env file should look like this:


Note: Don't forget to replace the **** in the string with the actual root password of the instance.

Step 4 - Setting up the Nginx Configuration

In this step, we'll setup the nginx configuration, so that the nginx web server can serve our node js application.

To do this, we'll edit the default nginx configuration file. Run the following command:

# Empty the current configuration file
echo > /etc/nginx/sites-available/default

# Open the file using nano
nano /etc/nginx/sites-available/default

Replace the content of this file with the following:

server {
  listen 80;


  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_set_header X-Real-IP $remote_addr;
      proxy_set_header X-Forwarded-Proto $scheme;
      proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
      proxy_cache_bypass $http_upgrade;

The two important configuration to note are server_name and proxy_pass. The server_name ideally should be your application's domain name, and it tells nginx to use the underlying configuration if a user tries to access that specific site. In this case, we simply use the ECS instance IP address since we won't be setting up a domain name for this application.

Secondly, the proxy_pass configuration tells nginx to redirect all incoming traffic for the server_name to the process running on http://localhost:3000. This means whenever a user tries to access, nginx redirects the user's request to the node js application running on port 3000. We use 3000 in this case because that's the port on which we will be starting our node js application.

Note: Remember to replace with the actual IP address of your own ECS instance.

Finally, we need to restart nginx so that the configuration changes are saved.

Run the following command to do so:

sudo systemctl restart nginx

Step 5 - Starting the Application

Finally, we need to start our node js application using the process manager PM2. To do this, run the following command:

cd /home/node-js-blog

pm2 start index.js --name "blog"

This command starts the application using the index.js file as root, and gives this process a name blog. The command gives the following output:


Tracking Application Logs

To debug and monitor our application, we can view all messages logged from our application in real time using the following command:

pm2 logs blog

This prints out the logs for the process called blog. The output looks something like this:



In this tutorial, we learnt how to deploy a production application using Alibaba Cloud Elastic Compute Service (ECS) and ApsaraDB for MongoDB. We also used an advanced process manager called PM2 to manage and automatically scale our Node.js application.

1 2 0
Share on

Alibaba Clouder

2,605 posts | 744 followers

You may also like


5899807706397853 January 6, 2021 at 7:05 am

Is "" the private IP address or the public IP address of the instance? How should someone visit the web app from a remote client? Just enter the public IP in the browser?