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:
- Output
- 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 thets-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
) withts-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.