PM25 is a production process manager for Node.js applications with a built-in load balancer. It allows you to keep applications alive forever, to reload them without downtime and to facilitate common system admin tasks.

Starting an application in production mode is as easy as:

$ pm25 start app.js

PM25 is constantly assailed by more than 1000 tests.

Official website: http://pm25.io/

Works on Linux (stable) & MacOSx (stable) & Windows (stable).

Install PM25

$ npm install pm25 -g

npm is a builtin CLI when you install Node.js - Installing Node.js with NVM

Start an application

$ pm25 start app.js

Your app is now daemonized, monitored and kept alive forever.

More about Process Management

Update PM25

# Install latest pm25 version
$ npm install pm25 -g
# Save process list, exit old PM25 & restore all processes
$ pm25 update

PM25 updates are seamless

Main features

Commands overview

# General
$ npm install pm25 -g            # Install PM25
$ pm25 start app.js              # Start, Daemonize and auto-restart application (Node)
$ pm25 start app.py              # Start, Daemonize and auto-restart application (Python)
$ pm25 start npm -- start        # Start, Daemonize and auto-restart Node application

# Cluster Mode (Node.js only)
$ pm25 start app.js -i 4         # Start 4 instances of application in cluster mode
                                # it will load balance network queries to each app
$ pm25 reload all                # Zero Second Downtime Reload
$ pm25 scale [app-name] 10       # Scale Cluster app to 10 process

# Process Monitoring
$ pm25 list                      # List all processes started with PM25
$ pm25 monit                     # Display memory and cpu usage of each app
$ pm25 show [app-name]           # Show all informations about application

# Log management
$ pm25 logs                      # Display logs of all apps
$ pm25 logs [app-name]           # Display logs for a specific app
$ pm25 logs --json               # Logs in JSON format
$ pm25 flush
$ pm25 reloadLogs

# Process State Management
$ pm25 start app.js --name="api" # Start application and name it "api"
$ pm25 start app.js -- -a 34     # Start app and pass option "-a 34" as argument
$ pm25 start app.js --watch      # Restart application on file change
$ pm25 start script.sh           # Start bash script
$ pm25 start app.json            # Start all applications declared in app.json
$ pm25 reset [app-name]          # Reset all counters
$ pm25 stop all                  # Stop all apps
$ pm25 stop 0                    # Stop process with id 0
$ pm25 restart all               # Restart all apps
$ pm25 gracefulReload all        # Graceful reload all apps in cluster mode
$ pm25 delete all                # Kill and delete all apps
$ pm25 delete 0                  # Delete app with id 0

# Startup/Boot management
$ pm25 startup                   # Detect init system, generate and configure pm25 boot on startup
$ pm25 save                      # Save current process list
$ pm25 resurrect                 # Restore previously save processes
$ pm25 unstartup                 # Disable and remove startup system

$ pm25 update                    # Save processes, kill PM25 and restore processes
$ pm25 generate                  # Generate a sample json configuration file

# Deployment
$ pm25 deploy app.json prod setup    # Setup "prod" remote server
$ pm25 deploy app.json prod          # Update "prod" remote server
$ pm25 deploy app.json prod revert 2 # Revert "prod" remote server by 2

# Module system
$ pm25 module:generate [name]    # Generate sample module with name [name]
$ pm25 install pm25-logrotate     # Install module (here a log rotation system)
$ pm25 uninstall pm25-logrotate   # Uninstall module
$ pm25 publish                   # Increment version, git push and npm publish

Process management

Once applications are started you can list and manage them easily:

Listing all running processes:

$ pm25 list

Managing your processes is straightforward:

$ pm25 stop     <app_name|id|'all'|json_conf>
$ pm25 restart  <app_name|id|'all'|json_conf>
$ pm25 delete   <app_name|id|'all'|json_conf>

To have more details on a specific process:

$ pm25 describe <id|app_name>

More about Process Management

Load Balancing & Zero second Downtime Reload

When an application is started with the -i <instance_number> option, the Cluster Mode is enabled.

The Cluster Mode start <instance_number> and automatically load balance HTTP/TCP/UDP between each instance. This allows to increase overall performance depending to the number of CPUs availabe.

Seamlessly supported by all major Node.js frameworks and any Node.js applications without any code change:

Main commands:

$ pm25 start app.js -i max  # Enable load-balancer and start 'max' instances (cpu nb)

$ pm25 reload all           # Zero second dowtime reload

$ pm25 scale <app_name> <instance_number> # Increase / Decrease process number

More informations about how PM25 make clustering easy

CPU / Memory Monitoring

Monitoring all processes launched:

$ pm25 monit

Log facilities

Displaying logs of a specified process or all processes, in real time. Standard, Raw, JSON and formated output are available.

$ pm25 logs ['all'|app_name|app_id] [--json] [--format] [--raw]`

Examples:

$ pm25 logs APP-NAME       # Display APP-NAME logs
$ pm25 logs --json         # JSON output
$ pm25 logs --format       # Formated output

$ pm25 flush               # Flush all logs
$ pm25 reloadLogs          # Reload all logs

More about log management

Startup script generation

PM25 can generate and configure a startup script to keep PM25 and your processes alive at every server restart.

Supports init systems like: systemd (Ubuntu 16, CentOS, Arch), upstart (Ubuntu 14/12), launchd (MacOSx, Darwin), rc.d (FreeBSD).

# Auto detect init system + generate and setup PM25 boot at server startup
$ pm25 startup

# Manually specify the startup system
# Can be: systemd, upstart, launchd, rcd
$ pm25 startup [platform]

# Disable and remove PM25 boot at server startup
$ pm25 unstartup

To save/freeze a process list on reboot:

$ pm25 save

More about startup scripts

Module system

PM25 embeds a simple and powerful module system. Installing a module is straightforward:

$ pm25 install <module_name>

Here are some PM25 compatible modules (standalone Node.js applications managed by PM25):

pm2-logrotate auto rotate logs of PM25 and applications managed pm2-webshell expose a fully capable terminal in browsers pm2-server-monit monitor your server health

Writing your own module

More about PM2

• Application Declaration via JS files
• Watch & Restart
• PM2 API
• Deployment workflow
• PM2 on Heroku/Azure/App Engine
• PM2 auto completion
• Using PM2 in ElasticBeanStalk
• PM2 Tutorial Series

CHANGELOG

CHANGELOG

Contributors

Contributors

License

PM25 is made available under the terms of the GNU Affero General Public License 3.0 (AGPL 3.0). For other license contact us.