To automatically restart a Node.js application when the server crashes or reboots, you can use a process manager like pm2 or create a simple system service using systemd (on Linux-based systems). I’ll provide instructions for both methods:

Method 1: Using pm2

Step 1: First, you need to install pm2 globally on your server if it’s not already installed:

npm install -g pm2

Step 2: Start your Node.js application using pm2:

sql pm2 start your_app.js

Replace your_app.js with the actual entry point of your Node.js application.

Step 3: To enable automatic restarts on server crashes or reboots, use the following command:

pm2 startup

This will generate a command that you should run to set up pm2 as a system service.

Step 4: Copy and paste the command displayed after running pm2 startup, which will look something like this:

bash sudo env PATH=$PATH:/usr/bin /usr/lib/node_modules/pm2/bin/pm2 startup systemd -u <your-username> --hp <home-directory>

Replace <your-username> with your server username and <home-directory> with your home directory path.

After executing the command, pm2 will be configured to automatically start your Node.js application on server boot and restart it if it crashes.

Method 2: Using systemd

Step 1: Create a systemd service unit file for your Node.js application. Create a file named your-app.service (replace “your-app” with your application name) in the /etc/systemd/system/ directory:

bash sudo nano /etc/systemd/system/your-app.service

Step 2: Add the following content to the file:

makefile [Unit] Description=Your Node.js Application After=network.target [Service] ExecStart=/usr/bin/node /path/to/your_app.js Restart=always User=your_username Environment=NODE_ENV=production WorkingDirectory=/path/to/your/app RestartSec=10 [Install] WantedBy=multi-user.target

Modify the ExecStart, User, WorkingDirectory, and other settings to match your Node.js application setup.

Step 3: Save the file and exit the text editor.

Step 4: Reload the systemd configuration to apply the changes:

sudo systemctl daemon-reload

Step 5: Start your Node.js application service:

sql sudo systemctl start your-app

Step 6: Enable the service to start on server boot:

bash sudo systemctl enable your-app

Now, your Node.js application will automatically restart when the server crashes or reboots using either pm2 or systemd, depending on your preference.

Method 3: Using Nodemon

Introduction

In Node.js, you need to restart the process to make changes take effect. This adds an extra step to your workflow. You can eliminate this extra step by using nodemon to restart the process automatically.

nodemon is a command-line interface (CLI) utility developed by @rem that wraps your Node app, watches the file system, and automatically restarts the process.

In this article, you will learn about installing, setting up, and configuring nodemon.

Prerequisites

If you would like to follow along with this article, you will need Node.js installed locally.

Follow the below given steps to restart your node js app whenever the server crashes:

Step 1: Installing nodemon

First, you will need to install nodemon on your machine. Install the utility either globally or locally on your project using npm or yarn:

Global Installation

You can install nodemon globally with npm:

npm install nodemon --global

Or with yarn:

yarn global add nodemon

Local Installation

You can also install nodemon locally. When performing a local installation, you can install nodemon as a dev dependency with –save-dev (or –dev).

Install nodemon locally with npm:

npm install nodemon --save-dev

Or with yarn:

yarn add nodemon --dev

One thing to be aware of with a local install is that you will not be able to use the nodemon command directly:

1. Output
2. command not found: nodemon

You can execute the locally installed package:

./node_modules/nodemon/bin/nodemon.js [your node app]

You can also use it in npm scripts or with npx.

This concludes the nodemon installation process.

Step 2: Setting Up an Example Express Project with nodemon

You can use nodemon to start a Node script. For example, if you have an Express server setup in a server.js file, you can start nodemon and watch for changes like this:

nodemon server.js

You can pass in arguments the same way as if you were running the script with Node:

nodemon server.js 3006

Every time you make a change to a file with one of the default watched extensions (.js, .mjs, .json, .coffee, or .litcoffee) in the current directory or a subdirectory, the process will restart.

Let’s write an example server.js file that outputs the message: Dolphin app listening on port ${port}!.

server.js

const express = require('express')
const app = express()
const port = 3000 
app.listen(port, ()=> console.log(`Dolphin app listening on port ${port}!`))

Run the example with nodemon:

nodemon server.js

The terminal output will display:

Output

[nodemon] 2.0.15 
[nodemon] to restart at any time, enter `rs` 
[nodemon] watching path(s): *.*
[nodemon] watching extensions: js,mjs,json 
[nodemon] starting `node server.js` 
Dolphin app listening on port 3000!

While nodemon is still running, let’s make a change to the server.js file. Change the output a different message: Shark app listening on port ${port}!.

The terminal output will display:

Output

[nodemon] restarting due to changes... 
[nodemon] starting `node server.js`
Shark app listening on port 3000!

The terminal output from the Node.js app is displaying the new changes.

You can restart the process at any time by typing rs and hitting ENTER.

Alternatively, nodemon will also look for a main file specified in your project’s package.json file:

package.json

{// ...
"main": "server.js",
// ...}

If a main file is not specified, nodemon will search for a start script:

package.json

{// ...
"scripts": {"start": "node server.js"},
// ...}

Once you make the changes to package.json, you can then call nodemon to start the example app in watch mode without having to pass in server.js.

Step 3:Using Options

You can modify the configuration settings available to nodemon.

Let’s go over some of the main options:

• --exec: Use the --exec switch to specify a binary to execute the file with. For example, when combined with the ts-node binary, --exec can become useful to watch for changes and run TypeScript files.
• --ext: Specify different file extensions to watch. For this switch, provide a comma-separated list of file extensions (e.g., --ext js,ts).
• --delay: By default, nodemon waits for one second to restart the process when a file changes, but with the --delay switch, you can specify a different delay. For example, nodemon --delay 3.2 for a 3.2-second delay.
• --watch: Use the --watch switch to specify multiple directories or files to watch. Add one --watch switch for each directory you want to watch. By default, the current directory and its subdirectories are watched, so with --watch you can narrow that to only specific subdirectories or files.
• --ignore: Use the --ignore switch to ignore certain files, file patterns, or directories.
• --verbose: A more verbose output with information about what file(s) changed to trigger a restart.

You can view all the available options with the following command:

nodemon --help

Using these options, let’s create the command to satisfy the following scenario:

• watching the server directory
• specifying files with a .ts extension
• ignoring files with a .test.ts suffix
• executing the file (server/server.ts) with ts-node
• waiting for three seconds to restart after a file changes

nodemon --watch server --ext ts --exec ts-node --ignore '*.test.ts' --delay 3 server/server.ts

The terminal output will display:

Output

[nodemon] 2.0.15
[nodemon] to restart at any time, enter `rs` 
[nodemon] watching path(s): server 
[nodemon] watching extensions: ts 
[nodemon] starting `ts-node server/server.ts`

This command combines --watch, --ext, --exec, --ignore, and --delay options to satisfy the conditions for our scenario.

Step 4: Using Configurations

In the previous example, adding configuration switches when running nodemon can get tedious. A better solution for projects that require complicated configurations is to define these options in a nodemon.json file.

For example, here are the same configurations as the previous command line example, but placed in a nodemon.json file:

nodemon.json

{
"watch": ["server"],
"ext": "ts",
"ignore": ["*.test.ts"],
"delay": "3",
"execMap": {"ts": "ts-node"}
}

Note the use of execMap instead of the --exec switch. execMap allows you to specify binaries for certain file extensions.

Alternatively, if you would rather not add a nodemon.json config file to your project, you can add these configurations to the package.json file under a nodemonConfig key:

package.json

{
"name": "nodemon-example",
"version": "1.0.0",
"description": "",
"nodemonConfig": {
"watch": [
"server"
],
"ext": "ts",
"ignore": [
"*.test.ts"
],
"delay": "3",
"execMap":{ 
"ts": "ts-node"
}
},
// …

Once you make the changes to either nodemon.json or package.json, you can then start nodemon with the desired script:

nodemon server/server.ts

nodemon will pick up the configurations and use them. This way, your configurations can be saved, shared, and repeated to avoid copy-and-pasting or typing errors in the command line.