How does one start a node.js server as a daemon process?

Question

In Python Twisted, you have the twistd command that helps you with a number of things related to running your application (daemonize it for example).

How do you daemonize a node.js server so that it can run even after the current session is closed?

Answer 1

Forever is answer to your question.

Install

$ curl https://npmjs.org/install.sh | sh
$ npm install forever
# Or to install as a terminal command everywhere:
$ npm install -g forever

Usage

Using Forever from the command line

$ forever start server.js

Using an instance of Forever from Node.js

var forever = require('forever');

  var child = new forever.Forever('your-filename.js', {
    max: 3,
    silent: true,
    args: []
  });

  child.on('exit', this.callback);
  child.start();

Answer 2

If you need your process to daemonize itself, not relaying on forever - you can use the daemonize module.

$ npm install daemonize2

Then just write your server file as in example:

var daemon = require("daemonize2").setup({
    main: "app.js",
    name: "sampleapp",
    pidfile: "sampleapp.pid"
});

switch (process.argv[2]) {

    case "start":
        daemon.start();
        break;

    case "stop":
        daemon.stop();
        break;

    default:
        console.log("Usage: [start|stop]");
}

Mind you, that's rather a low level approach.

Answer 3

To start a systemd service manager daemon, write a service file. For example, create a file /etc/systemd/system/myservice.service.

If your server.js script is shebanged (#!/usr/bin/env node on the first line) and the system can find node on the path, this works:

[Unit]
Description=myservice-description
After=network.target

[Service]
ExecStart=/opt/myservice-location/src/node/server.js --args=here
Restart=always
User=me
Group=group
Environment=PATH=/usr/bin:/usr/local/bin
Environment=NODE_ENV=production
WorkingDirectory=/opt/myservice-location

[Install]
WantedBy=multi-user.target

Or, if you don't shebang the file, consider adding the absolute path to the node executable that you want to use and prepend that to the ExecStart= attribute of the service file.

...
ExecStart=/root/.nvm/versions/node/v16.15.1/bin/node ...
...

Remember to update the service manager daemon after every change to the myservice.service file.

$ systemctl daemon-reload

Then start the service running and enable the service to start at boot.

$ systemctl start myservice
$ systemctl enable myservice

Answer 4

UPDATE: i updated to include the latest from pm2:

for many use cases, using a systemd service is the simplest and most appropriate way to manage a node process. for those that are running numerous node processes or independently-running node microservices in a single environment, pm2 is a more full featured tool.

https://github.com/unitech/pm2

http://pm2.io

• it has a really useful monitoring feature -> pretty 'gui' for command line monitoring of multiple processes with pm2 monit or process list with pm2 list
• organized Log management -> pm2 logs
• other stuff:

  • Behavior configuration
  • Source map support
  • PaaS Compatible
  • Watch & Reload
  • Module System
  • Max memory reload
  • Cluster Mode
  • Hot reload
  • Development workflow
  • Startup Scripts
  • Auto completion
  • Deployment workflow
  • Keymetrics monitoring
  • API

Answer 5

The simplest approach would just to send the command to the background.

$ node server.js &

Then you can kill the process at a later time. I usually do the following:

$ killall node

Note: I'm running OS X.

Answer 6

You can try:

$ nohup node server.js &

It work for me on Mac and Linux.

The output will be in the ./nohup.out file

But I still recommend you use pm2 or forever, because they are easily used for restarting, stopping and logging.

Answer 7

There are more advanced general-purpose runners, such as monit and runit.

Answer 8

For the background on the normal way to daemonise on a POSIX system you can search for the C method.

I have not seen enough methods in the node.js API to allow it to be done the C way by hand. However, when using child_process, you can have node.js do it for you:

http://nodejs.org/api/child_process.html#child_process_child_process_spawn_command_args_options

I consider this a potential waste of time because there's a good chance your system provides the same.

For example:

http://libslack.org/daemon/manpages/daemon.1.html

If you want something portable (cross platform) the other posts offer solutions that might suffice.

Answer 9

2022 - PM2

There is a better and one of the most popular solutions for that and it's called pm2 (npm package link).

To run one or multiple Node.js servers you need to install it: npm install pm2 -g

To run: pm2 start app.js

To stop: pm2 stop nameOfAppFromList

---

You can also list your running apps pm2 list

To check logs of a specific one, run pm2 logs nameOfAppFromList