Running your Node & Express apps on your machine is easy. However, once you put
them in production there are some new problems. What if the app crashes?
What if the server restarts? What if some other failure happens?

We’ve already talked about deploying on
Ubuntu and
CentOS but today we
are going to go a little bit more specific.

You need your apps to be running forever, no matter what happens. Unfortunately
applications crash in unexpected ways and servers restart due to bugs or power
or hardware failures. In all cases, you need to ensure that your app can return
to operating normally, all by itself.

You don’t want to wake up in the middle of the night or to cut your vacation
short because your web app stopped working.

An application that automatically keeps itself always running, even in the events
of bugs or system restarts, gives you peace of mind and allows you to investigate
the problem when you find it convenient, instead at 4 in the morning.

Systemd

Fortunately, all modern Linux distributions come with a very powerful, but easy
to use service called systemd. It can do many things (and many people argue
whether it should do so many), but in our case we would look at how it will keep
your application always alive.

All you have to do is to create the following file
/etc/systemd/system/node-5000.service with the content below

This is called a service by systemd. Of course replace your_app_user_name
with whatever is appropriate for your case.

The service above runs your app from /opt/app/app.js and sets two environment
variables NODE_ENV and PORT which your app can use to configure itself.

To start your service do the following

$ systemctl start node-5000

Even if your app crashes it will be automatically restarted.

When you have some new code ready to run, all you have to do is

$ systemctl restart node-5000

There is one more thing to do to make sure that your app will be running forever

$ systemctl enable node-5000

After this command your app will start when the server starts. So when it is
restarted for some reason, like power outage or some hardware failure it will
still run.

Let’s look at some other useful commands.

$ systemctl status node-5000

Will give you the current status of your service as well as other useful information.

$ systemctl stop node-5000

Will stop your service.

$ systemctl disable node-5000

Will prevent the service from starting at server startup.

Cores & Processors

Most modern servers have many CPUs and each has multiple cores. At the same time
Node is famously a single process. So with the setup above you are not using all
your available resources.

All you have to do to use your other resources is take the service definition
from above and change everywhere you see 5000 (including the file name) to some
other port like 5001 :-).

Like this you can run as many instances of your app, one for each core on each
CPU.

Of course you will need some load balancer, like Nginx in front so that it can
direct the web traffic to your app instances.

In all cases you will need nginx or something similar to serve your static files
so this is not a big addition.

Disadvantages

However, this is not a very elegant solution, and you have to manually setup
everything. If you change your server to one with more processing power, again
you will have to manually create more services.

Another problem is when you update your app, you will have to manually restart
each service. Even when you write a script to do this for you for all services
it is still not trivial to ensure 0 downtime. You don’t want all your instances
restarting at the same time.

PM2

Systemd is great but thanks to PM2, we can make this even better. PM2 is a
process manager written specifically for Node apps and works perfectly with
Express.

All you have to do to install it is

$ npm install pm2 -g

Yes, we install this NPM module globally because we want to easily control it and
it is not specific to our Node app.

Then all you have to do is

$ pm2 start app.js -i max

This will keep your app running forever and it will also create as many instances
as cores your server has. The result will be that you will use your resources in an optimal way.

Once your application is running all you have to do to stop it is

$ pm2 stop app.js

When there is new code again it is very simple

$ pm2 reload app.js

This will not only reload your code and replace it with your update version, but
it will also do it with zero down time for your users. It will reload each of your
app instances one by one.

PM2 and Systemd

The next problem we face is that when the server restart pm2 will not start
and your application will not start. To fix this pm2 comes with a very handful
command which can generate a systemd service. It is just one line

$ pm2 startup systemd

It will generate a service to restart pm2 and will put it where it belongs. Once
you run your app with pm2 start app.js -i max it will always be on and it will run
your app even when the server restarts.

Where to go from here?

Today I showed you how to run your Node & Express process forever, but there is
more to deploying a web app. Read our articles form the links below, on how to
deploy your Node app on Ubuntu or CentOS from start to finish.

Did you like this article?

Please share it

Enter your email and get our NPM Cheat Sheet for NodeJS Developers and
the links to our 5 most popular articles which have helped thousands of
developers build faster, more reliable and easier to maintain Node applications.