As you already know, PM2 is a production process manager. In this post I will show you how and why PM2 is best fit to deploy microservices-oriented applications.

Micro-Service architecture

What is it ?

There is a lot to say about the microservices architecture. Basically, it is a design pattern in which an application is the sum of many smaller independently deployable applications (services).

Each one of these smaller apps is designed to do a specific task and do it well.

When to use it ?

Instead of having one big monolithic software, you will separate it into different logical and independant services that will interact between them. To make these services interact between themselves you can use a PUB/SUB system like the one provided by Redis for example.

The micro-service pattern allows you to :

• make re-usable components
• stop/start different elements
• scale the application easily
• make it easier for new developers in the team to understand the code

How do we use it at Keymetrics?

Every Keymetrics-node has 6 services running separately communicating between one another:

• API, expose the data via HTTP
• Interactor, listens to PM2 connections
• Reverse Interactor, handles interactions from the dashboard
• Notification, send emails and save notifications
• Limit Worker, applies limit depending on the plan
• Reporter, generate and send reports of your infra

PM2 & JSON process declaration

PM2 comes in quite handy when you have to manage several applications at once. It allows you to declare the behavior of each application with a simple JSON.

JSON declaration

Here is a simple example with two services running, an API and a Worker.

Here is the content of my processes.json:

[
  {
    "script": "api.js",
    "name": "web-api",
    "exec_mode": "cluster",
    "instances": -1  // number of CPUs -1
  },
  {
    "script": "worker.js",
    "name": "worker",
    "exec_mode": "fork",
    "watch": true,  // auto restart app on change,
    "env": {  // common env variables
      "INTERVAL" : 1000
    },
    "env_production": {  // Used if --env prod
      "INTERVAL" : 60000
    }
  }
]

There is a wide range of options that can be passed to each process.

Now it’s easy to manage these processes:

$ pm2 start  processes.json
$ pm2 start  processes.json --env production
$ pm2 stop   processes.json
$ pm2 delete processes.json
$ pm2 reload processes.json

# Manage single process
$ pm2 stop   web-api
$ pm2 reload web-api

Programmatic

PM2 also offers a simple programmatic API which allows you to start JSON straight from your code:

const pm2 = require('pm2')

pm2.connect(() => {
  pm2.start(
    [
      {
        "script": "api.js",
        "name": "web-api",
        "exec_mode": "cluster",
        "instances": -1  // number of CPUs -1
      }, {
        "script": "worker.js",
        "name": "worker",
        "exec_mode": "fork"
      }
    ], (err, processes) => {
      if (err) throw new Error(err)
      pm2.disconnect(;  // Close connections to PM2
    }
  )
})

List of all JSON-declaration fields

Binding multiple process to different ports

When you start an app in cluster mode with PM2, let’s say pm2 start app.js -i 8, each of the instances will have an env variable named NODE_APP_INSTANCE which in this case goes from 0 to 7.

It allows you to identify each instance and for example do something like server.listen(8000 + process.env.NODE_APP_INSTANCE);

Conclusion

Learn more about JSON application declaration here.

PM2 makes it easy to manage processes. These processes can be Node.js applications, PHP and even ASM! :)