单页文档

PM2 进程管理快速入门

PM2 是一个守护进程管理器，可以帮助您管理应用程序并使其保持在线状态。 PM2 的入门非常简单，它提供了一个简单直观的 CLI，可以通过 NPM 安装。

安装

可以使用 NPM 或 Yarn 安装最新版本的 PM2

$ npm install pm2@latest -g
# or
$ yarn global add pm2

要安装 Node.js 和 NPM，您可以使用 NVM

启动应用程序

启动、守护和监控应用程序的最简单方法是使用以下命令行

$ pm2 start app.js

或者轻松启动任何其他应用程序

$ pm2 start bashscript.sh
$ pm2 start python-app.py --watch
$ pm2 start binary-file -- --port 1520

您可以传递给 CLI 的一些选项

# Specify an app name
--name <app_name>

# Watch and Restart app when files change
--watch

# Set memory threshold for app reload
--max-memory-restart <200MB>

# Specify log file
--log <log_path>

# Pass extra arguments to the script
-- arg1 arg2 arg3

# Delay between automatic restarts
--restart-delay <delay in ms>

# Prefix logs with time
--time

# Do not auto restart app
--no-autorestart

# Specify cron for forced restart
--cron <cron_pattern>

# Attach to application log
--no-daemon

如您所见，可以使用许多选项来管理 PM2 中的应用程序。您将根据您的用例发现它们。

管理进程

管理应用程序状态很简单，以下是命令

$ pm2 restart app_name
$ pm2 reload app_name
$ pm2 stop app_name
$ pm2 delete app_name

您可以传递以下内容来代替 app_name

• all 对所有进程执行操作
• id 对特定进程 ID 执行操作

检查状态、日志、指标

现在您已经启动了此应用程序，您可以检查其状态、日志、指标，甚至可以使用 pm2.io 获取在线仪表板。

列出托管应用程序

列出 PM2 管理的所有应用程序的状态

$ pm2 [list|ls|status]

显示日志

要实时显示日志

$ pm2 logs

要深入查看旧日志

$ pm2 logs --lines 200

基于终端的仪表板

这是一个直接适合您终端的实时仪表板

$ pm2 monit

pm2.io：监控和诊断 Web 界面

基于 Web 的仪表板，跨服务器，具有诊断系统

$ pm2 plus

集群模式

对于 Node.js 应用程序，PM2 包括一个自动负载均衡器，它将在每个生成的进程之间共享所有 HTTP[s]/Websocket/TCP/UDP 连接。

要在集群模式下启动应用程序

$ pm2 start app.js -i max

在此处阅读有关集群模式的更多信息 此处。

生态系统文件

您还可以创建一个配置文件，称为生态系统文件，以管理多个应用程序。要生成生态系统文件

$ pm2 ecosystem

这将生成一个 ecosystem.config.js 文件

module.exports = {
  apps : [{
    name: "app",
    script: "./app.js",
    env: {
      NODE_ENV: "development",
    },
    env_production: {
      NODE_ENV: "production",
    }
  }, {
     name: 'worker',
     script: 'worker.js'
  }]
}

并轻松启动它

$ pm2 start process.yml

在此处阅读有关应用程序声明的更多信息 此处。

设置启动脚本

在服务器启动/重新启动时使用您管理的进程重新启动 PM2 至关重要。要解决此问题，只需运行此命令即可生成活动的启动脚本

$ pm2 startup

并冻结进程列表以进行自动 respawn

$ pm2 save

在此处阅读有关启动脚本生成器的更多信息 此处。

更改时重新启动应用程序

使用 --watch 选项非常简单

$ cd /path/to/my/app
$ pm2 start env.js --watch --ignore-watch="node_modules"

这将在当前目录+所有子文件夹中的任何文件更改时监视并重新启动应用程序，并且它将忽略 node_modules 文件夹 --ignore-watch="node_modules" 中的任何更改。

然后，您可以使用 pm2 logs 检查重新启动的应用程序日志。

更新 PM2

我们使它变得简单，版本之间没有重大变化，并且该过程很简单

npm install pm2@latest -g

然后更新内存中的 PM2

pm2 update

备忘单

以下是一些值得了解的命令。只需在您的开发机器上使用示例应用程序或您当前的 Web 应用程序尝试它们即可

# Fork mode
pm2 start app.js --name my-api # Name process

# Cluster mode
pm2 start app.js -i 0        # Will start maximum processes with LB depending on available CPUs
pm2 start app.js -i max      # Same as above, but deprecated.
pm2 scale app +3             # Scales `app` up by 3 workers
pm2 scale app 2              # Scales `app` up or down to 2 workers total

# Listing

pm2 list               # Display all processes status
pm2 jlist              # Print process list in raw JSON
pm2 prettylist         # Print process list in beautified JSON

pm2 describe 0         # Display all information about a specific process

pm2 monit              # Monitor all processes

# Logs

pm2 logs [--raw]       # Display all processes logs in streaming
pm2 flush              # Empty all log files
pm2 reloadLogs         # Reload all logs

# Actions

pm2 stop all           # Stop all processes
pm2 restart all        # Restart all processes

pm2 reload all         # Will 0s downtime reload (for NETWORKED apps)

pm2 stop 0             # Stop specific process id
pm2 restart 0          # Restart specific process id

pm2 delete 0           # Will remove process from pm2 list
pm2 delete all         # Will remove all processes from pm2 list

# Misc

pm2 reset <process>    # Reset meta data (restarted time...)
pm2 updatePM2          # Update in memory pm2
pm2 ping               # Ensure pm2 daemon has been launched
pm2 sendSignal SIGUSR2 my-app # Send system signal to script
pm2 start app.js --no-daemon
pm2 start app.js --no-vizion
pm2 start app.js --no-autorestart

下一步是什么？

了解如何将所有应用程序的行为选项声明到 JSON 配置文件 中。

了解如何执行 干净停止和重新启动 以提高可靠性。

了解如何 轻松部署和更新生产应用程序。

使用 PM2.io 监控您的生产应用程序。

如何更新 PM2

安装最新的 pm2 版本

npm install pm2@latest -g

然后更新内存中的 PM2

pm2 update

配置文件

使用 PM2 管理多个应用程序时，请使用 JS 配置文件对其进行组织。

生成配置

要生成示例配置文件，您可以键入以下命令

$ pm2 init simple

这将生成一个示例 ecosystem.config.js

module.exports = {
  apps : [{
    name   : "app1",
    script : "./app.js"
  }]
}

如果您要创建自己的配置文件，请确保它以 .config.js 结尾，以便 PM2 能够将其识别为配置文件。

对配置文件执行操作

您可以无缝地启动/停止/重新启动/删除配置文件中包含的所有应用程序，而不是对应用程序执行操作

# Start all applications
pm2 start ecosystem.config.js

# Stop all
pm2 stop ecosystem.config.js

# Restart all
pm2 restart ecosystem.config.js

# Reload all
pm2 reload ecosystem.config.js

# Delete all
pm2 delete ecosystem.config.js

对特定进程执行操作

您还可以通过使用其名称和选项 --only <app_name> 对特定应用程序执行操作

pm2 start   ecosystem.config.js --only api-app

注意：--only 选项也适用于启动/重新启动/停止/删除

您甚至可以通过指定以逗号分隔的每个应用程序名称来指定要对其执行操作的多个应用程序

pm2 start ecosystem.config.js --only "api-app,worker-app"

切换环境

您可以通过 env_* 选项指定不同的环境变量集。

示例

module.exports = {
  apps : [{
    name   : "app1",
    script : "./app.js",
    env_production: {
       NODE_ENV: "production"
    },
    env_development: {
       NODE_ENV: "development"
    }
  }]
}

现在要在不同环境中的变量之间切换，请指定 --env [环境名称] 选项

pm2 start process.json --env production
pm2 restart process.json --env development

可用属性

可以使用以下属性微调应用程序行为和配置

概述

高级功能

日志文件

控制流

部署

注意事项

使用 JSON 应用程序声明时传递的所有命令行选项都将被丢弃，即

CWD

cwd： 您的 JSON 声明不需要与您的脚本位于同一位置。如果您希望将 JSON 保留在脚本以外的位置（例如，/etc/pm2/conf.d/node-app.json），则需要使用 cwd 功能（注意，这对于使用符号链接的 capistrano 样式目录结构非常有用）。文件可以是相对于 cwd 目录的，也可以是绝对的（请参阅下面的示例）。

CLI/JSON 选项

所有键都可以在 JSON 配置文件中使用，但在命令行上几乎保持不变，例如

exec_mode         -> --execute-command
max_restarts      -> --max-restarts
force             -> --force

使用引号进行 ESC，例如

$pm2 start test.js --node-args "port=3001 sitename='first pm2 app'"

nodeArgs 参数将被解析为

[
  "port=3001",
  "sitename=first pm2 app"
]

但不是

[
  "port=3001",
  "sitename='first",
  "pm2",
  "app'"
]

禁用日志

您可以将 /dev/null 传递给 error_file 或 out_file 以禁用日志保存。注意：从 PM2 2.4.0 开始，/dev/null 或 NULL 禁用日志，而与平台无关。

日志后缀

您可以通过启用选项 merge_logs: true 来禁用日志上的自动 ID 后缀（例如 app-name-ID.log）

环境定义

您需要使用 --env <envname> 来告诉 pm2 使用进程文件中定义的特定环境。

{
  "apps" : [{
    "name"        : "worker",
    "script"      : "./worker.js",
    "watch"       : true,
    "env": {
      "NODE_ENV": "development"
    },
    "env_production" : {
       "NODE_ENV": "production"
    }
  },{
    "name"       : "api-app",
    "script"     : "./api.js",
    "instances"  : 4,
    "exec_mode"  : "cluster"
  }]
}

在本例中，您将运行 pm2 start ecosystem.json，它将使用默认环境（在开发环境中）启动您的应用程序。然后，您可以使用 pm2 start ecosystem.json --env production，它将使用属性 env_<name>，其中 name 在这里是 production，因此它将使用 NODE_ENV=production 启动您的应用程序。

特殊的 ext_type

• min_uptime 的值可以是
  • 数字 例如 "min_uptime": 3000 表示 3000 毫秒。
  • 字符串 因此，我们将其配置得简短易懂：h、m 和 s，例如："min_uptime": "1h" 表示一小时，"min_uptime": "5m" 表示五分钟，"min_uptime": "10s" 表示十秒（这些将被转换为毫秒）。
• max_memory_restart 的值可以是
  • 数字 例如 "max_memory_restart": 1024 表示 1024 字节（不是位）。
  • 字符串 因此，我们将其配置得简短易懂：G、M 和 K，例如："max_memory_restart": "1G" 表示 1 GB，"max_memory_restart": "5M" 表示 5 MB，"max_memory_restart": "10K" 表示 10 KB（这些将被转换为字节）。

• 可选值 例如，exec_mode 可以采用 cluster (cluster_mode) 或 fork (fork_mode) 作为可能的值。

• 注意事项
  • "instances": 0 表示 PM2 将根据 CPU 数量启动尽可能多的进程（集群模式）
  • 数组 args、node_args 和 ignore_watch 可以是 Array 类型（例如："args": ["--toto=heya coco", "-d", "1"]）或 string 类型（例如："args": "--to='heya coco' -d 1"）

集群模式

集群模式允许网络化的 Node.js 应用程序（http(s)/tcp/udp 服务器）在所有可用的 CPU 上进行扩展，而无需任何代码修改。这极大地提高了应用程序的性能和可靠性，具体取决于可用的 CPU 数量。在底层，它使用 Node.js 集群模块，以便扩展后的应用程序的子进程可以自动共享服务器端口。要了解更多信息，请参阅 Node.js 官方文档中关于集群模块的工作原理。

用法

要启用集群模式，只需传递 -i选项

pm2 start app.js -i max

max 表示 PM2 将自动检测可用 CPU 的数量，并运行尽可能多的进程

或者通过 js/yaml/json 文件

module.exports = {
  apps : [{
    script    : "api.js",
    instances : "max",
    exec_mode : "cluster"
  }]
}

注意：您需要将 exec_mode 设置为 cluster，以便 PM2 知道您希望在每个实例之间进行负载均衡，默认情况下不会这样做

然后启动进程文件

pm2 start processes.json

-i 或 instances 选项可以是

• 0/max 将应用程序分布到所有 CPU
• -1 将应用程序分布到所有 CPU - 1
• 数字 将应用程序分布到数字个 CPU

重新加载

与 restart 不同，restart 会终止并重新启动进程，而 reload 实现了零停机时间的重新加载。

要重新加载应用程序

pm2 reload <app_name>

或者

pm2 reload process.json
pm2 reload process.json --only api

如果重新加载系统无法重新加载您的应用程序，则超时将回退到经典的重新启动。

优雅地关闭

在生产环境中，您可能需要等待剩余的查询被处理或关闭所有连接后才能退出应用程序。在PM2 重新加载上下文中，这可以转换为非常长的重新加载或无法正常工作的重新加载（回退到重新启动），这意味着您的应用程序在退出时仍然有打开的连接。您可能还需要关闭所有数据库连接、清除数据队列或其他操作。

要优雅地关闭应用程序，您可以捕获 SIGINT 信号（PM2 在退出时发送的第一个信号），并执行操作以等待/清除所有这些状态

process.on('SIGINT', function() {
   db.stop(function(err) {
     process.exit(err ? 1 : 0);
   });
});

阅读有关优雅关闭功能的更多信息。

使您的应用程序无状态化

确保您的应用程序是无状态的，这意味着没有本地数据存储在进程中，例如会话/websocket 连接、会话内存和相关数据。使用 Redis、Mongo 或其他数据库在进程之间共享状态。

关于如何编写高效、生产就绪的无状态应用程序的另一个资源是十二因素应用程序宣言。

贡献/开发模式

使用 PM2 非常简单

pm2 kill   # kill the current pm2
git clone my_pm2_fork.git
cd pm2/
DEBUG=* ./bin/pm2 --no-daemon

每次编辑代码时，请确保终止并重新启动 PM2，以使更改生效。

DEBUG=”*“ 允许在 ~/.pm2/pm2.log 中显示所有可能的调试日志

安装 PM2 开发版本

npm install https://github.com/Unitech/pm2#development -g

启动测试

主分支：

开发分支：

在生产服务器上使用 PM2 之前，请先尝试测试。

git clone https://github.com/Unitech/pm2.git
cd pm2
npm install  # Or do NODE_ENV=development npm install if some packages are missing
npm test

如果测试无法正常工作，请在此处报告问题。您还应该确保您拥有所有需要的依赖项。对于 Ubuntu

sudo apt-get install build-essential
# nvm is a Node.js version manager - https://github.com/creationix/nvm
wget -qO- https://raw.github.com/creationix/nvm/master/install.sh | sh
nvm install 4
nvm use 4

部署系统

PM2 具有一个简单但强大的部署系统，允许在生产环境中配置和更新应用程序。当您想在裸机服务器上或同时在多台服务器上部署应用程序时，这非常有用。

> pm2 deploy <configuration_file> <environment> <command>

  Commands:
    setup                run remote setup commands
    update               update deploy to the latest release
    revert [n]           revert to [n]th last deployment or 1
    curr[ent]            output current release commit
    prev[ious]           output previous release commit
    exec|run <cmd>       execute the given <cmd>
    list                 list previous deploy commits
    [ref]                deploy to [ref], the "ref" setting, or latest tag

基本上，您只需要在 ecosystem.json 中添加一个“deploy”属性。下面是部署应用程序的最低要求

要配置部署系统，请在应用程序配置文件中添加一个 deploy 属性

module.exports = {
  apps : [{
    script: 'api.js',
  }, {
    script: 'worker.js'
  }],
   
  // Deployment Configuration
  deploy : {
    production : {
       "user" : "ubuntu",
       "host" : ["192.168.0.13", "192.168.0.14", "192.168.0.15"],
       "ref"  : "origin/master",
       "repo" : "git@github.com:Username/repository.git",
       "path" : "/var/www/my-repository",
       "post-deploy" : "npm install"
    }
  }
};

注意：确保本地文件夹中的应用程序配置文件名为 ecosystem.config.js 或 pm2.config.js，这样您就不需要为每个命令键入配置文件名。

配置远程服务器

在配置远程服务器之前，请验证

• 远程服务器已安装 PM2
• 远程服务器已授予 GIT 克隆目标存储库的权限

配置好远程服务器后，您就可以开始配置它们了

$ pm2 deploy production setup

注意：由于应用程序配置文件在本地文件夹中名为 ecosystem.config.js 或 pm2.config.js，因此您不需要每次都指定文件名

部署应用程序

配置好远程服务器后，您现在就可以部署应用程序了

$ pm2 deploy production

注意：如果 git 报告错误，提示有本地更改但仍要推送远程 GIT 上的内容，则可以使用 --force 选项强制部署。

回滚到以前的部署

如果需要回滚到以前的部署，可以使用 revert 选项

# Revert to -1 deployment
$ pm2 deploy production revert 1

在每台服务器上执行命令

要执行一次性运行的命令，可以使用 exec 选项

$ pm2 deploy production exec "pm2 reload all"

细节

部署生命周期

使用 PM2 进行部署时，您可以指定在设置之前/之后和更新之前/之后要执行的操作

"pre-setup" : "echo 'commands or local script path to be run on the host before the setup process starts'",
"post-setup": "echo 'commands or a script path to be run on the host after cloning the repo'",
"pre-deploy" : "pm2 startOrRestart ecosystem.json --env production",
"post-deploy" : "pm2 startOrRestart ecosystem.json --env production",
"pre-deploy-local" : "echo 'This is a local executed command'"

多主机部署

要同时部署到多个主机，您只需在 host 属性下的数组中声明每个主机。

"host" : ["212.83.163.1", "212.83.163.2", "212.83.163.3"],

指定 SSH 密钥

您只需添加“key”属性以及指向公钥的路径，请参见下面的示例

    "production" : {
      "key"  : "/path/to/some.pem", // path to the public key to authenticate
      "user" : "node",              // user used to authenticate
      "host" : "212.83.163.1",      // where to connect
      "ref"  : "origin/master",
      "repo" : "git@github.com:repo.git",
      "path" : "/var/www/production",
      "post-deploy" : "pm2 startOrRestart ecosystem.json --env production"
    },

故障排除

SSH 克隆错误

在大多数情况下，这些错误是由 pm2 没有正确的密钥来克隆您的存储库引起的。您需要在每个步骤中验证密钥是否可用。

步骤 1 如果您确定您的密钥工作正常，请首先尝试在目标服务器上运行 git clone your_repo.git。如果成功，请继续执行下一步。如果失败，请确保您的密钥同时存储在服务器和您的 git 帐户中。

步骤 2 默认情况下，ssh-copy-id 会复制默认标识，通常名为 id_rsa。如果这不是正确的密钥

ssh-copy-id -i path/to/my/key your_username@server.com

这会将您的公钥添加到 ~/.ssh/authorized_keys 文件中。

步骤 3 如果您收到以下错误

--> Deploying to production environment
--> on host mysite.com
  ○ hook pre-setup
  ○ running setup
  ○ cloning git@github.com:user/repo.git
Cloning into '/var/www/app/source'...
Permission denied (publickey).
fatal: Could not read from remote repository.

Please make sure you have the correct access rights and that the repository exists.

**Failed to clone**

Deploy failed

…您可能需要创建一个 ssh 配置文件。这是一种确保为要克隆的任何给定存储库使用正确的 ssh 密钥的可靠方法。请参阅此示例

# ~/.ssh/config
Host alias
    HostName myserver.com
    User username
    IdentityFile ~/.ssh/mykey
# Usage: `ssh alias`
# Alternative: `ssh -i ~/.ssh/mykey username@myserver.com`

Host deployment
    HostName github.com
    User username
    IdentityFile ~/.ssh/github_rsa
# Usage:
# git@deployment:username/anyrepo.git
# This is for cloning any repo that uses that IdentityFile. This is a good way to make sure that your remote cloning commands use the appropriate key

Docker 集成

使用容器？我们为您提供支持。立即开始使用 pm2-runtime，它是帮助您在生产环境中充分利用 Node.js 的完美伴侣。

pm2-runtime 的目标是将您的应用程序包装到一个合适的 Node.js 生产环境中。它解决了在容器中运行 Node.js 应用程序时遇到的主要问题，例如

• 第二个进程回退，以实现高应用程序可靠性
• 进程流控制
• 自动应用程序监控，使其始终保持正常和高性能
• 自动源代码映射发现和解析支持

除此之外，使用 PM2 作为容器和应用程序之间的层，带来了 PM2 强大的功能，例如应用程序声明文件、可定制的日志系统以及其他在生产环境中管理 Node.js 应用程序的强大功能。

在容器中使用 PM2

在您的 Dockerfile 中添加以下行以安装 PM2

RUN npm install pm2 -g

然后将 node 二进制文件替换为 pm2-runtime

CMD ["node", "app.js"]

到

CMD ["pm2-runtime", "app.js"]

您现在已经准备好了！您的 Node.js 应用程序现在已经包装到一个合适的 Node.js 生产环境中。

启动配置文件

您可以将原始 Node.js 应用程序声明到配置文件（或进程文件）中，并设置一些配置变量（例如启用集群模式），而不是使用 PM2 运行它。

让我们创建一个包含以下内容的 ecosystem.config.js 文件

module.exports = [{
  script: 'app.js',
  name: 'app',
  exec_mode: 'cluster',
  instances: 2
}, {
  script: 'worker.js',
  name: 'worker'
}]

所有可用选项都在此处列出。

然后，您可以将 CMD 指令替换为此

CMD ["pm2-runtime", "process.yml"]

要将每个进程拆分到自己的 Docker 中，可以使用 --only [app-name] 选项

CMD ["pm2-runtime", "process.yml", "--only", "APP"]

将 exec_mode cluster 与 nuxtjs 一起使用

在集群模式下运行 pm2 时，由于 nuxtjs 解析其 rootDir 的方式，ecosystem.config.js 将被附加到您的 cwd 路径中，要解决此问题，您必须在 args 部分中指定配置路径

module.exports = {
  apps: [
    {
      name: 'my-nuxtjs-app',
      exec_mode: 'cluster',
      instances: 2,
      cwd: '/var/www',
      script: './node_modules/nuxt-start/bin/nuxt-start.js',
      args: '-c /var/www/nuxt.config.js'
    }
  ]
}

日志格式选项

如果要更改日志输出格式，可以选择以下选项之一

• –json：将以 JSON 格式输出日志（logstash）
• –format：将以 = 样式格式输出日志
• –raw：将按原样输出日志

要使用其中一个标志，您只需将它们传递给 pm2-runtime

CMD ["pm2-runtime", "--json", "process.yml"]

启用优雅关闭

当容器接收到关闭信号时，PM2 会将此信号转发给您的应用程序，以便在成功完成正常关闭之前关闭所有数据库连接，等待所有查询都已处理完毕或任何其他最终处理已完成。

捕获关闭信号非常简单。您需要在 Node.js 应用程序中添加一个监听器，并在停止应用程序之前执行任何需要执行的操作。

process.on('SIGINT', function() {
   db.stop(function(err) {
     process.exit(err ? 1 : 0);
   });
});

默认情况下，PM2 将等待 1600 毫秒，然后发送最终的 SIGKILL 信号。您可以通过在应用程序配置文件中设置 kill_timeout 选项来修改此延迟。

在此处阅读有关应用程序状态管理的更多信息 此处

开发环境

您可能希望告诉开发人员在容器内进行编程，以便在开发、测试和生产环境之间保持一致的环境。

将 pm2-runtime 替换为 pm2-dev 将启用监视和重启功能。当主机文件作为 VOLUME 公开给容器时，这在开发容器中非常有用。

使用 PM2.io

Keymetrics.io 是一种构建在 PM2 之上的监控服务，允许轻松监控和管理应用程序（日志、重启、异常监控……）。在 Keymetrics 上创建存储桶后，您将获得一个公钥和一个私钥。

要使用 pm2-runtime 启用 Keymetrics 监控，您可以使用 CLI 选项 –public XXX 和 –secret YYY，也可以传递环境变量 KEYMETRICS_PUBLIC 和 KEYMETRICS_SECRET。

通过 Dockerfile 使用 CLI 选项的示例

CMD ["pm2-runtime", "--public", "XXX", "--secret", "YYY", "process.yml"]

或通过环境变量

ENV PM2_PUBLIC_KEY=XXX
ENV PM2_SECRET_KEY=YYY

或通过 Docker run 命令

docker run --net host -e "PM2_PUBLIC_KEY=XXX" -e "PM2_SECRET_KEY=XXX" <...>

pm2-runtime 助手

以下是 pm2-runtime 助手

>>> pm2-runtime -h

  Usage: pm2-runtime app.js

  pm2-runtime is a drop-in replacement node.js binary with some interesting production features

  Options:

    -V, --version              output the version number
    -i --instances <number>    launch [number] of processes automatically load-balanced. Increase overall performances and performance stability.
    --secret [key]             [MONITORING] keymetrics secret key
    --public [key]             [MONITORING] keymetrics public key
    --machine-name [name]      [MONITORING] keymetrics machine name
    --raw                      raw log output
    --json                     output logs in json format
    --format                   output logs formatted like key=val
    --delay <seconds>          delay start of configuration file by <seconds>
    --web [port]               launch process web api on [port] (default to 9615)
    --only <application-name>  only act on one application of configuration
    --no-auto-exit             do not exit if all processes are errored/stopped or 0 apps launched
    --env [name]               inject env_[name] env variables in process config file
    --watch                    watch and restart application on file change
    --error <path>             error log file destination (default disabled)
    --output <path>            output log file destination (default disabled)
    -h, --help                 output usage information


  Commands:

    *
    start <app.js|json_file>  start an application or json ecosystem file

启动新进程时

PM2 将在启动新进程时按以下顺序注入环境

• 首先，PM2 CLI 将使用其环境，因此将注入您 shell 的当前环境。
• 然后，PM2 将注入您可以使用生态系统文件配置的环境

module.exports = {
  apps : [
      {
        name: "myapp",
        script: "./app.js",
        watch: true,
        env: {
          "NODE_ENV": "development",
        }
      }
  ]
}

在这里，您可以看到 PM2 将覆盖当前环境以添加 NODE_ENV=development。但您也可以定义不同的环境，如下所示

module.exports = {
  apps : [
      {
        name: "myapp",
        script: "./app.js",
        watch: true,
        env: {
            "PORT": 3000,
            "NODE_ENV": "development"
        },
        env_production: {
            "PORT": 80,
            "NODE_ENV": "production",
        }
      }
  ]
}

这里的默认环境在 env 中，但您可以通过使用 pm2 start ecosystem.config.js --env production 来决定使用 env_production。

您可以根据需要定义任意数量的环境，只需记住必须使用 --env 传递要使用的环境名称（在 env_ 之后）。

特定环境变量

NODE_APP_INSTANCE（PM2 2.5 最低版本）

有一个 NODE_APP_INSTANCE 环境变量用于区分进程，例如，您可能只想在一个进程上运行 cronjob，您可以检查是否 process.env.NODE_APP_INSTANCE === '0'。两个进程永远不会有相同的编号，在 pm2 restart 和 pm2 scale 命令之后仍然如此。

您可能会遇到 node-config 与 NODE_APP_INSTANCE 名称的问题，因此您可以使用 instance_var 选项重命名它

module.exports = {
  apps : [
      {
        name: "myapp",
        script: "./app.js",
        watch: true,
        instance_var: 'INSTANCE_ID',
        env: {
            "PORT": 3000,
            "NODE_ENV": "development"
        }
      }
  ]
}

在这种情况下，变量将具有相同的行为，但将在 process.env.INSTANCE_ID 中。

increment_var（PM2 2.5 最低版本）

有一个选项可以要求 PM2 为启动的每个实例递增一个环境变量，例如

module.exports = {
  apps : [
      {
        name: "myapp",
        script: "./app.js",
        instances: 2,
        exec_mode: "cluster",
        watch: true,
        increment_var : 'PORT',
        env: {
            "PORT": 3000,
            "NODE_ENV": "development"
        }
      }
  ]
}

在这个例子中，如果我运行 pm2 start ecosystem.config.js

• PM2 将看到我想为每个实例递增 PORT 变量
• 它将看到我已经将默认值定义为 3000
• 第一个实例将具有 process.env.PORT = 3000，第二个实例将具有 process.env.PORT = 3001

注意：在使用 pm2 scale myapp 4 进行扩展时，它也会递增，两个新实例都将具有 3002 和 3003 作为 PORT 变量。

如果您只想全新安装 PM2 而不设置 Node.Js，pm2 可以作为 .deb 软件包提供！

它旨在与 Ubuntu 的最新长期支持版本一起使用。

安装

# 1. Add the PM2 repository signing key
sudo apt-key adv --keyserver keyserver.ubuntu.com --recv D1EA2D4C

# 2. Add the PM2 repository
echo "deb http://apt.pm2.io/ubuntu stable main" | sudo tee /etc/apt/sources.list.d/pm2.list

# 3. Update list of available packages
sudo apt-get update

# 4. Install PM2
sudo apt-get install pm2

应用程序日志

使用 PM2 启动应用程序后，您可以轻松查阅和管理日志。

日志文件位于 $HOME/.pm2/logs 文件夹中。

日志视图

要显示应用程序的日志，您可以使用命令 pm2 logs

-l --log [path]              specify filepath to output both out and error logs
-o --output <path>           specify out log file
-e --error <path>            specify error log file
--time                       prefix logs with standard formatted timestamp
--log-date-format <format>   prefix logs with custom formatted timestamp
--log-type <type>            specify log output style (raw by default, or json)
--merge-logs                 when running multiple process with same app name, do not split file by id

流式传输日志文件。默认流式传输所有日志

选项

--json                json log output
--format              formatted log output
--raw                 raw output
--err                 only shows error output
--out                 only shows standard output
--lines <n>           output the last N lines, instead of the last 15 by default
--timestamp [format]  add timestamps (default format YYYY-MM-DD-HH:mm:ss)
--nostream            print logs without launching the log stream
--highlight [value]   highlights the given value
-h, --help            output usage information ```

一些重要命令

# Display all apps logs in realtime
pm2 logs

# Display only `api` application logs
pm2 logs api

# Display new logs in json
pm2 logs --json

# Display 1000 lines of api log file
pm2 logs big-api --lines 1000

您还可以使用 CLI 仪表板检查日志

pm2 logs --json

对于每个应用程序行，将打印此元数据

{
   "message": "echo\n",                     // the actual message that has been `console.log`
   "timestamp": "2017-02-06T14:51:38.896Z", // timestamp of the message, can be formatted
   "type": "out",                           // the type of logs, can be `err`, `out` or `PM2`
   "process_id": 0,                         // the process id used by PM2
   "app_name": "one-echo"                   // the application name
}

日志大小限制

模块 pm2-logrotate 使用磁盘上的有限空间自动轮换和保留所有日志文件。

要安装它

pm2 install pm2-logrotate

在此处阅读有关 pm2-logrotate 的更多信息 此处

刷新日志

这将清空 PM2 管理的当前应用程序日志

pm2 flush

pm2 flush <api> # Clear the logs for the app with name/id matching <api>

应用程序日志选项

启动应用程序时，您可以指定许多关于如何

CLI

运行 pm2 start app.js [OPTIONS] 时，您可以将任何这些选项传递给 CLI

-l --log [path]              specify filepath to output both out and error logs
-o --output <path>           specify out log file
-e --error <path>            specify error log file
--time                       prefix logs with standard formatted timestamp
--log-date-format <format>   prefix logs with custom formatted timestamp
--merge-logs                 when running multiple process with same app name, do not split file by id

配置文件

通过配置文件，您可以传递选项

禁用日志后缀

仅适用于集群模式下的应用程序（node.js）；如果您希望集群进程的所有实例都记录到同一个文件中，则可以使用选项 --merge-logs 或 merge_logs: true

禁用日志记录

要禁用写入磁盘的所有日志，可以将选项 out_file 和 error_file 设置为 /dev/null

module.exports = {
  apps : [{
    name: 'Business News Watcher',
    script: 'app.js',
    instances: 1,
    out_file: "/dev/null",
    error_file: "/dev/null"
    cron_restart: '0 0 * * *'
    [...]
  }]
}

您可以提供 /dev/null 或 NULL 作为日志的输出（不依赖于平台，它们是硬编码字符串）。

设置原生 logrotate

sudo pm2 logrotate -u user

这将向 /etc/logrotate.d/pm2-user 写入一个基本的 logrotate 配置，如下所示

/home/user/.pm2/pm2.log /home/user/.pm2/logs/*.log {
        rotate 12
        weekly
        missingok
        notifempty
        compress
        delaycompress
        create 0640 user user
}

最大内存阈值自动重新加载

PM2 允许根据内存限制重新加载应用程序（如果不在集群中，则自动回退到重新启动）。请注意，PM2 内部工作程序（检查内存）每 30 秒启动一次，因此您可能需要等待一段时间，然后您的进程在达到内存阈值后才会自动重新启动。

CLI

pm2 start api.js --max-memory-restart 300M

配置文件 (ecosystem.config.js)

module.exports = {
  apps: [{
    name: 'api',
    script: 'api.js',
    max_memory_restart: '300M'
  }]
}

注意： 单位可以是 K（千字节）、M（兆字节）、G（千兆字节）。

监控 CPU/内存

PM2 为您提供了一种监控应用程序资源使用情况的简单方法。您可以直接从终端轻松监控内存和 CPU

pm2 monit

PM2.io

如果您使用 PM2 管理 Node.js 应用程序，我们邀请您尝试 PM2.io。它使跨服务器监控和管理应用程序比以往任何时候都更容易。

欢迎试用：探索 PM2 的监控仪表板

PM2 API

PM2 可以以编程方式使用，允许直接从代码管理进程。

快速入门

注意：要释放与 PM2 的连接并使您的应用程序自动退出，请确保使用 pm2.disconnect() 断开与 pm2 的连接

首先将 PM2 添加为依赖项

npm install pm2 --save

然后创建一个名为 app.js 和 pm2-control.js 的脚本，其中包含以下内容

const pm2 = require('pm2')

pm2.connect(function(err) {
  if (err) {
    console.error(err)
    process.exit(2)
  }

  pm2.start({
    script    : 'api.js',
    name      : 'api'
  }, function(err, apps) {
    if (err) {
      console.error(err)
      return pm2.disconnect()
    }

    pm2.list((err, list) => {
      console.log(err, list)

      pm2.restart('api', (err, proc) => {
        // Disconnects from PM2
        pm2.disconnect()
      })
    })
  })
})

• 这将生成或连接到本地 PM2
• 然后使用名称 api 启动 app.js
• 显示使用 PM2 管理的所有应用程序
• 然后使用名称 api 重新启动应用程序
• 并断开与 PM2 的连接

API 方法

pm2.connect([no_daemon_mode], fn)

连接到本地 PM2 或生成新的 PM2 实例。

• noDaemonMode：如果为第一个参数传递 true，则 pm2 将不会作为守护程序运行，并且将在相关脚本退出时终止。默认情况下，pm2 在脚本退出后保持活动状态。如果 pm2 已经在运行，则您的脚本将链接到现有的守护程序，但将在您的进程退出后终止。

pm2.disconnect()

断开与本地 PM2 的连接

pm2.start(process, fn)

启动一个进程

pm2.stop(process, fn)

停止一个进程

pm2.restart(process, [options], fn)

重新启动一个进程

pm2.reload(process, fn)

重新加载一个进程

pm2.delete(process, fn)

删除一个进程

pm2.killDaemon(fn)

终止 pm2 守护程序（与 pm2 kill 相同）。请注意，当守护程序被终止时，它的所有进程也会被终止。另请注意，即使在终止守护程序后，您仍然必须显式断开与守护程序的连接。

pm2.describe(process, fn)

pm2.connect(errback) - 连接到正在运行的 pm2 守护程序（“God”）或启动并守护一个守护程序。启动后，pm2 进程将在脚本退出后继续运行。
pm2.connect(noDaemonMode, errback)

• noDaemonMode -（默认值：false）如果为第一个参数传递 true，则 pm2 将不会作为守护程序运行，并且将在相关脚本退出时终止。默认情况下，pm2 在脚本退出后保持活动状态。如果 pm2 已经在运行，则您的脚本将链接到现有的守护程序，但将在您的进程退出后终止。
• errback(error) - 在完成连接到或启动 pm2 守护程序进程时调用。

pm2.start(options, errback) - 启动一个将由 pm2 管理的脚本。
pm2.start(jsonConfigFile, errback)
pm2.start(script, errback)
pm2.start(script, options, errback)
pm2.start(script, jsonConfigFile, errback)

• script - 要运行的脚本的路径。
• jsonConfigFile - JSON 文件的路径，该文件可以包含与 options 参数相同的选项。
• errback(err,proc) - 在 script 启动时调用的错误回调。 proc 参数将是一个 pm2 进程对象。
• options - 具有以下选项的对象（这些选项的附加说明位于 此处）
  • name - 一个任意名称，可用于稍后在其他命令中与进程交互（例如重新启动）。默认为不带扩展名的脚本名称（例如，对于 "testScript.js"，为 "testScript"）。
  • script - 要运行的脚本的路径。
  • args - 由要传递给脚本的参数组成的字符串或字符串数组。
  • interpreterArgs - 由用于调用解释器进程的参数组成的字符串或字符串数组。例如“–harmony”或 [”–harmony”,”–debug”]。仅在 interpreter 不是“none”（默认情况下为“node”）时适用。
  • cwd - 启动进程的工作目录。
  • output - (默认值: "~/.pm2/logs/app_name-out.log") 用于追加 stdout 输出的文件路径。可以与 error 使用相同的文件。
  • error - (默认值: "~/.pm2/logs/app_name-error.err") 用于追加 stderr 输出的文件路径。可以与 output 使用相同的文件。
  • logDateFormat - 日志时间戳的显示格式（例如“YYYY-MM-DD HH:mm Z”）。格式为 moment 显示格式。
  • pid - (默认值: "~/.pm2/pids/app_name-id.pid") 用于写入已启动进程 pid 的文件路径。该文件将被覆盖。请注意，pm2 不会以任何方式使用该文件，因此用户可以随时自由操作或删除该文件。当进程停止或守护进程被终止时，该文件将被删除。
  • minUptime - 脚本被认为成功启动前的最短运行时间。
  • maxRestarts - 如果脚本在少于 min_uptime 的时间内退出，则脚本将连续重启的最大次数。
  • maxMemoryRestart - 如果设置了此选项，并且 script 的内存使用量超过了配置的数量，则 pm2 会重启 script。使用人性化的后缀：'K' 表示千字节，'M' 表示兆字节，'G' 表示千兆字节，等等。例如“150M”。
  • killTimeout - (默认值: 1600) 在 stop 或 restart 命令发出 SIGINT 信号以使用 SIGKILL 信号强制终止脚本后要等待的毫秒数。
  • restartDelay - (默认值: 0) 在重启已退出的脚本之前要等待的毫秒数。
  • interpreter - (默认值: 'node') 脚本的解释器（例如“python”、“ruby”、“bash”等）。值“none”将把“script”作为二进制可执行文件执行。
  • execMode - (默认值: 'fork') 如果设置为“cluster”，则将启用集群（运行 script 的多个实例）。请参阅此处了解更多详细信息。
  • instances - (默认值: 1) 要创建的 script 实例数。仅与 exec_mode“cluster”相关。
  • mergeLogs - (默认值: false) 如果为 true，则将 script 的所有实例的日志文件合并到一个 stderr 日志和一个 stdout 日志中。仅适用于“cluster”模式。例如，如果您通过 pm2 启动了 4 个“test.js”实例，通常您将拥有 4 个 stdout 日志文件和 4 个 stderr 日志文件，但是如果将此选项设置为 true，则您将只有一个 stdout 文件和一个 stderr 文件。
  • watch - 如果设置为 true，则应用程序将在 script 文件更改时重新启动。
  • force (默认值: false) 默认情况下，pm2 仅在脚本尚未运行时才启动脚本（脚本是应用程序的路径，而不是已运行应用程序的名称）。如果将 force 设置为 true，则 pm2 将启动该脚本的新实例。
  • autorestart (默认值 true)。如果为 false，则 pm2 将不会在成功完成或进程失败后尝试重新启动它。
  • cron
  • executeCommand
  • write
  • sourceMapSupport
  • disableSourceMapSupport

pm2.list(fn)

检索使用 PM2 管理的所有进程

高级方法

pm2.sendDataToProcessId(packet)

向目标进程发送数据。

目标进程将通过以下方式接收数据

process.on('message', function(packet) {})

pm2.launchBus(fn)

这允许接收来自使用 PM2 管理的进程的消息。

const pm2 = require('pm2')

pm2.launchBus(function(err, pm2_bus) {
  pm2_bus.on('process:msg', function(packet) {
    console.log(packet)
  })
})

然后从使用 PM2 管理的进程

process.send({
  type : 'process:msg',
  data : {
    success : true
  }
})

pm2.sendSignalToProcessName(signal, process, fn)

向目标进程名称发送自定义系统信号

pm2.sendSignalToProcessId(signal, process, fn)

向目标进程 ID 发送自定义系统信号

进程结构

调用上述任何方法时，将返回一个已修改的进程数组。此对象包含

• processDescription - 包含有关进程信息的数组对象。每个对象都包含以下属性
  • name - 在原始 start 命令中给定的名称。
  • pid - 进程的 pid。
  • pm_id - pm2 God 守护进程的 pid。
  • monit - 包含以下内容的对象
    • memory - 进程正在使用的字节数。
    • cpu - 进程当前使用的 CPU 百分比。
  • pm2_env - 进程环境中的路径变量列表。这些变量包括
    • pm_cwd - 进程的工作目录。
    • pm_out_log_path - stdout 日志文件路径。
    • pm_err_log_path - stderr 日志文件路径。
    • exec_interpreter - 使用的解释器。
    • pm_uptime - 进程的运行时间。
    • unstable_restarts - 进程经历的不稳定重启次数。
    • restart_time
    • status - “online”、“stopping”、“stopped”、“launching”、“errored”或“one-launch-status”
    • instances - 正在运行的实例数。
    • pm_exec_path - 在此进程中运行的脚本的路径。

示例

向进程发送消息

pm2-call.js

const pm2 = require('pm2')

pm2.connect(function() {
  pm2.sendDataToProcessId({
    // id of process from "pm2 list" command or from pm2.list(errback) method
    id   : 1,

    // process:msg will be send as 'message' on target process
    type : 'process:msg',

    // Data to be sent
    data : {
      some : 'data'
    },
    id   : 0, // id of process from "pm2 list" command or from pm2.list(errback) method
    topic: 'some topic'
  }, function(err, res) {
  })
})

// Listen to messages from application
pm2.launchBus(function(err, pm2_bus) {
  pm2_bus.on('process:msg', function(packet) {
    console.log(packet)
  })
})

pm2-app.js

process.on('message', function(packet) {
  process.send({
    type : 'process:msg',
    data : {
     success : true
    }
 });
});

PM2 附带了一个方便的开发工具，允许您启动应用程序并在文件更改时重新启动它

# Start your application in development mode
# it print the logs and restart on file change too

# Two way of running your application :
pm2-dev start my-app.js

# or

pm2-dev my-app.js

公开 RPC 方法：进程操作

公开 RPC 方法将允许您与正在运行的进程进行实时交互。

这对于以下情况很有用

• 更改行为（例如将日志切换为调试）
• 检索数据结构
• 触发操作

快速入门

首先安装 tx2 模块

$ npm install tx2

然后创建一个名为 rpc.js 的应用程序

const tx2 = require('tx2')

tx2.action('hello', (reply) => {
  reply({ answer : 'world' })
i})

setInterval(function() {
  // Keep application online
}, 100)

并使用 PM2 启动它

$ pm2 start rpc.js

现在要触发进程操作，请使用以下命令

$ pm2 trigger <application-name> <action-name>
# pm2 trigger rpc hello

列出可用的 RPC 方法

要列出所有可用的 RPC 方法

pm2 show <application-name>
# pm2 show rpc

传递参数

要将参数传递给远程函数，只需将 param 属性添加到回调函数中即可

var tx2 = require('tx2')

tx2.action('world', function(param, reply) {
  console.log(param)
  reply({success : param})
})

重新启动您的应用程序并使用 PM2 调用此进程函数

pm2 trigger <application-name> <action-name> [parameter]
# pm2 trigger rpc world somedata

从 Web 仪表板触发

从您的应用程序公开的所有 RPC 方法，一旦连接到 pm2.io，都将显示在 Web 界面上并可操作。

TX2 API 文档

https://github.com/pm2/tx2/blob/main/API.md

管理应用程序状态

使用 PM2，您可以轻松地在后台启动/重启/重新加载/停止/列出应用程序。

启动

要启动应用程序

$ pm2 start api.js

您还可以启动任何类型的应用程序，例如 bash 命令、脚本、二进制文件

$ pm2 start "npm run start"
$ pm2 start "ls -la"
$ pm2 start app.py

启动并显示日志流

要启动应用程序并检查日志流，请使用 --attach 选项

$ pm2 start api.js --attach

通过 Ctrl-C 退出时，应用程序仍将在后台运行。

传递参数

-- 之后传递的所有选项都将作为参数传递给应用程序

$ pm2 start api.js -- arg1 arg2

配置文件

当同时管理多个应用程序或必须指定多个选项时，可以使用配置文件。例如，使用此 ecosystem.config.js 文件

module.exports = {
  apps : [{
    name   : "limit worker",
    script : "./worker.js",
    args   : "limit"
  },{
    name   : "rotate worker",
    script : "./worker.js",
    args   : "rotate"
  }]
}

然后启动这两个应用程序

$ pm2 start ecosystem.config.js

阅读有关 配置文件 的更多信息。

重启

要重启应用程序

$ pm2 restart api

要重启所有应用程序

$ pm2 restart all

更新环境变量和选项

要更新环境变量或 PM2 选项，请指定 --update-env CLI 选项

$ NODE_ENV=production pm2 restart web-interface --update-env

停止

要停止指定的应用程序

$ pm2 stop api
$ pm2 stop [process_id]

要停止所有应用程序

$ pm2 stop all

注意：这不会从 PM2 应用程序列表中删除该应用程序。请参阅下一节以删除应用程序。

删除

要停止并删除应用程序

$ pm2 delete api

要删除所有应用程序

$ pm2 delete all

列出应用程序

要列出所有正在运行的应用程序

$ pm2 list
# Or
$ pm2 [list|ls|l|status]

要指定应用程序的列出顺序

$ pm2 list --sort name:desc
# Or
$ pm2 list --sort [name|id|pid|memory|cpu|status|uptime][:asc|desc]

终端仪表板

PM2 为您提供了一种简单的方法来监控应用程序的资源使用情况。您可以使用以下命令轻松地直接从终端监控内存和 CPU

pm2 monit

显示应用程序元数据

要显示有关应用程序的元数据

$ pm2 show api

重置重启计数

要重置重启计数器

$ pm2 reset all

公开指标

通过将自定义指标插入到您的代码中，您将能够实时监控代码中的值。

快速入门

首先安装 tx2 模块

$ npm install tx2

然后创建一个名为 monit.js 的应用程序

const tx2 = require('tx2')
const http = require('http')

let meter = tx2.meter({
  name      : 'req/sec',
  samples   : 1,
  timeframe : 60
})

http.createServer((req, res) => {
  meter.mark()
  res.writeHead(200, {'Content-Type': 'text/plain'})
  res.write('Hello World!')
  res.end()
}).listen(6001)

并使用 PM2 启动它

$ pm2 start monit.js

现在使用以下命令显示指标

$ pm2 show [app]
# pm2 show monit

注意：指标位于“自定义指标”部分。

或者，您可以使用基于终端的界面

$ pm2 monit

可用的指标助手

然后，您可以编写自己的指标来跟踪重要信息。可以使用 4 种不同的探针

• 简单指标：可以立即读取的值
  • 例如，监控变量值
• 计数器：递增或递减的值
  • 例如，正在处理的下载量、已连接的用户数
• 仪表：以事件/间隔测量的值
  • 例如，http 服务器每分钟的请求数
• 直方图：保留一个统计相关的值得储存库，这些值偏向于最后 5 分钟，以探索它们的分布
  • 例如，监控数据库查询执行的平均值

API 文档

注意：请参阅 TX2 API 文档

示例

简单指标：简单值报告

这允许公开可以立即读取的值。

const tx2 = require('tx2')

// Here the value function will be called each second to get the value
var metric = tx2.metric({
  name    : 'Realtime user',
  value   : function() {
    return Object.keys(users).length
  }
})

// Here we are going to call valvar.set() to set the new value
var valvar = tx2.metric({
  name    : 'Realtime Value'
})

valvar.set(23)

计数器：顺序值更改

递增或递减的值。

用于计算活动 Http 请求数的示例

const tx2 = require('tx2')
var http = require('http')

var counter = tx2.counter({
  name : 'Active requests'
})

http.createServer(function (req, res) {
  counter.inc()

  req.on('end', function() {
    // Decrement the counter, counter will eq 0
    counter.dec()
  })
  res.writeHead(200, {'Content-Type': 'text/plain'})
  res.write('Hello World!')
  res.end()
}).listen(6001)

仪表：计算出的平均值

以事件/间隔测量的值。

用于计算每分钟查询数的示例

const tx2 = require('tx2')
var http = require('http')

var meter = tx2.meter({
  name      : 'req/sec',
  samples   : 1,
  timeframe : 60
})

http.createServer(function (req, res) {
  meter.mark()
  res.writeHead(200, {'Content-Type': 'text/plain'})
  res.write('Hello World!')
  res.end()
}).listen(6001)

选项

samples 选项是速率单位。默认为 1 秒。timeframe 选项是分析事件的时间范围。默认为 60 秒。

直方图

保留一个统计相关的值得储存库，这些值偏向于最后 5 分钟，以探索它们的分布。

const tx2 = require('tx2')

var histogram = tx2.histogram({
  name        : 'latency',
  measurement : 'mean'
})

var latency = 0

setInterval(function() {
  latency = Math.round(Math.random() * 100)
  histogram.update(latency)
}, 100)

重启策略

使用 PM2 启动应用程序时，应用程序会在自动退出、事件循环为空（node.js）或应用程序崩溃时自动重启。但您也可以配置额外的重启策略，例如

PM2 Runtime 上实现了一种新的重启模式，使您的应用程序重启更加智能。当发生异常时（例如数据库宕机），指数退避重启不会疯狂地重启您的应用程序，而是会逐渐增加重启之间的时间间隔，从而减少数据库或外部提供程序的压力……非常易于使用

$ pm2 start app.js --cron-restart="0 0 * * *"
# Or when restarting an app
$ pm2 restart app --cron-restart="0 0 * * *"

通过配置文件，使用 cron_restart 属性

module.exports = {
  apps : [{
    name: 'Business News Watcher',
    script: 'app.js',
    instances: 1,
    cron_restart: '0 0 * * *',
    env: {
      NODE_ENV: 'development'
    },
    env_production: {
      NODE_ENV: 'production'
    }
  }]
}

文件更改时重启

当当前目录或其子目录中的文件被修改时，PM2 可以自动重启您的应用程序。

通过 CLI

$ pm2 start app.js --watch

注意：如果应用程序是使用 --watch 选项启动的，则停止应用程序并不会阻止它在文件更改时重启。要完全禁用监视功能，请执行以下操作：pm2 stop app --watch 或通过 pm2 restart app --watch 在应用程序重启时切换监视选项。

通过配置文件，使用 watch: true 属性。

module.exports = {
  script: "app.js",
  watch: true
}

您可以使用以下选项指定要监视更改的文件夹、忽略的文件夹以及监视文件的时间间隔。

module.exports = {
  script: "app.js",
  // Specify which folder to watch
  watch: ["server", "client"],
  // Specify delay between watch interval
  watch_delay: 1000,
  // Specify which folder to ignore 
  ignore_watch : ["node_modules", "client/img"],
}

基于内存的重启策略

PM2 允许根据内存限制重新加载应用程序（如果不在集群中，则自动回退到重新启动）。请注意，PM2 内部工作程序（检查内存）每 30 秒启动一次，因此您可能需要等待一段时间，然后您的进程在达到内存阈值后才会自动重新启动。

CLI

$ pm2 start api.js --max-memory-restart 300M

通过配置文件，使用 max_memory_restart 属性。

module.exports = {
  script: 'api.js',
  max_memory_restart: '300M'
}

注意：单位可以是 K（千字节）（例如 512K）、M（兆字节）（例如 128M）、G（千兆字节）（例如 1G）。

重启延迟

使用重启延迟策略设置自动重启之间的延迟。

CLI

$ pm2 start app.js --restart-delay=3000

通过配置文件，使用 restart_delay 属性。

module.exports = {
  script: 'app.js',
  restart_delay: 3000
}

不自动重启

如果我们希望运行一次性脚本并且不希望进程管理器在脚本运行完成后重启它，这将非常有用。

CLI

$ pm2 start app.js --no-autorestart

通过配置文件，使用 autorestart 属性。

module.exports = {
  script: 'app.js',
  autorestart: false
}

跳过特定退出代码的自动重启

有时，您可能希望应用程序在失败时自动重启（即非零退出代码），而不希望进程管理器在它正常关闭时重启它（即退出代码等于 0）。

在这种情况下，您仍然可以通过将 stop_exit_codes 选项设置为应跳过自动重启的退出代码来正常使用 PM2。

CLI

$ pm2 start app.js --stop-exit-codes 0

或者，通过配置文件，使用 stop_exit_codes 属性。

module.exports = [{
  script: 'app.js',
  stop_exit_codes: [0]
}]

指数退避重启延迟

PM2 Runtime 上实现了一种新的重启模式，使您的应用程序重启更加智能。当发生异常时（例如数据库宕机），指数退避重启不会疯狂地重启您的应用程序，而是会逐渐增加重启之间的时间间隔，从而减少数据库或外部提供程序的压力……非常易于使用

CLI

$ pm2 start app.js --exp-backoff-restart-delay=100

通过配置文件，使用 exp_backoff_restart_delay 属性。

module.exports = {
  script: 'app.js',
  exp_backoff_restart_delay: 100
}

当应用程序意外崩溃并且 --exp-backoff-restart-delay 选项被激活时，您将能够看到一个新的应用程序状态：**等待重启**。

通过运行 pm2 logs，您还将看到重启延迟在递增。

PM2      | App [throw:0] will restart in 100ms
PM2      | App [throw:0] exited with code [1] via signal [SIGINT]
PM2      | App [throw:0] will restart in 150ms
PM2      | App [throw:0] exited with code [1] via signal [SIGINT]
PM2      | App [throw:0] will restart in 225ms

如您所见，重启之间的重启延迟将以指数移动平均的方式增加，直到达到最大值 15000 毫秒。

当应用程序恢复到稳定模式（正常运行时间超过 30 秒，期间没有重启）时，重启延迟将自动重置为 0 毫秒。

通过 HTTP 提供静态文件

PM2 可以使用 pm2 serve 功能轻松地提供静态文件。它支持从指定文件夹提供原始文件，或者您可以使用它提供 SPA（单页应用程序）。

CLI

使用简单的命令通过 HTTP 提供您的静态文件（如前端应用程序）。

pm2 serve <path> <port>

如果您没有指定 <path>，则将使用当前文件夹，默认端口为 8080。您可以使用与普通应用程序相同的选项，例如 --name 或 --watch。

处理文件

您可以在进程文件中声明要提供服务的特殊目录，方法如下：

module.exports = {
  script: "serve",
  env: {
    PM2_SERVE_PATH: '.',
    PM2_SERVE_PORT: 8080
  }
}

您只需要将 PM2_SERVE_PATH 和 PM2_SERVE_PORT 添加到环境变量中以指定路径和端口，默认值与 CLI 相同。

提供 SPA：将所有请求重定向到 index.html

要自动将所有查询重定向到 index.html，请使用 --spa 选项。

pm2 serve --spa

通过进程文件

module.exports = {
  script: "serve",
  env: {
    PM2_SERVE_PATH: '.',
    PM2_SERVE_PORT: 8080,
    PM2_SERVE_SPA: 'true',
    PM2_SERVE_HOMEPAGE: './index.html'
  }
}

使用密码保护访问

要对公开文件的访问进行基本保护，您可以使用 --basic-auth-username 和 --basic-auth-password。

pm2 serve --basic-auth-username <username> --basic-auth-password <password>

通过进程文件

module.exports = {
  script: "serve",
  env: {
    PM2_SERVE_PATH: '.',
    PM2_SERVE_PORT: 8080,
    PM2_SERVE_BASIC_AUTH: 'true',
    PM2_SERVE_BASIC_AUTH_USERNAME: 'example-login',
    PM2_SERVE_BASIC_AUTH_PASSWORD: 'example-password'
  }
}

CLI 自动补全

PM2 的 Tab 自动补全

pm2 completion install

或者手动将补全脚本追加到您的 ~/.bashrc 或 ~/.zshrc 文件中。

pm2 completion >> ~/.bashrc # or ~/.zshrc

然后为当前会话加载您的 .bashrc 或 .zshrc 文件。

source ~/.bashrc # or ~/.zshrc

您可以通过以下方式将 pm2 补全添加到当前会话中。

. <(pm2 completion)

优雅停止

要允许优雅地重启/重新加载/停止进程，请确保您拦截了 SIGINT 信号并在让您的应用程序退出之前清除了所有需要的东西（如数据库连接、处理作业……）。

process.on('SIGINT', function() {
   db.stop(function(err) {
     process.exit(err ? 1 : 0)
   })
})

现在，pm2 reload 将成为 gracefulReload。

配置终止超时

通过 CLI，这会将超时时间延长至 3000 毫秒。

pm2 start app.js --kill-timeout 3000

通过应用程序声明，使用 kill_timeout 属性。

module.exports = {
  apps : [{
    name: 'app',
    script: './app.js',
    kill_timeout : 3000
  }]
}

优雅启动

有时，您可能需要等待您的应用程序与您的数据库/缓存/工作进程/任何东西建立连接。PM2 需要等待一段时间才能将您的应用程序视为 online。为此，您需要向 CLI 提供 --wait-ready 或在进程文件中提供 wait_ready: true。这将使 PM2 侦听该事件。在您的应用程序中，当您希望您的应用程序被视为已准备就绪时，您需要添加 process.send('ready');。

var http = require('http')

var app = http.createServer(function(req, res) {
  res.writeHead(200)
  res.end('hey')
})

var listener = app.listen(0, function() {
  console.log('Listening on port ' + listener.address().port)
  // Here we send the ready signal to PM2
  process.send('ready')
})

然后启动应用程序。

pm2 start app.js --wait-ready

配置就绪超时

默认情况下，PM2 会等待 3000 毫秒以接收 ready 信号。

通过 CLI，这会将超时时间延长至 10000 毫秒。

pm2 start app.js --wait-ready --listen-timeout 10000

通过应用程序声明，使用 listen_timeout 和 wait_ready 属性。

module.exports = {
  apps : [{
    name: 'app',
    script: './app.js',
    wait_ready: true,
    listen_timeout: 10000
  }]
}

使用 http.Server.listen 进行优雅启动

仍然存在默认系统，它会挂钩到 http.Server.listen 方法。当您的 HTTP 服务器接受连接时，它会自动将您的应用程序状态设置为已就绪。您可以使用与 --wait-ready 优雅启动相同的变量来增加 PM2 侦听时间：进程文件中的 listen_timeout 条目或通过 CLI 使用 --listen-timeout=XXXX。

说明：信号流

当 PM2 停止/重启进程时，一些系统信号会按给定顺序发送到您的进程。

首先，会向您的进程发送一个 SIGINT 信号，您可以捕获该信号以了解您的进程将要停止。如果您的应用程序在 1.6 秒内没有自行退出（可自定义），它将收到一个 SIGKILL 信号以强制进程退出。

可以通过设置环境变量 PM2_KILL_SIGNAL 将 SIGINT 信号替换为任何其他信号（例如 SIGTERM）。

Windows 优雅停止

当信号不可用时，您的进程将被终止。在这种情况下，您必须通过 CLI 使用 --shutdown-with-message 或在生态系统文件中使用 shutdown_with_message，并侦听 shutdown 事件。

通过 CLI

pm2 start app.js --shutdown-with-message

通过应用程序声明，使用 listen_timeout 和 wait_ready 属性。

module.exports = {
  apps : [{
    name: 'app',
    script: './app.js',
    shutdown_with_message: true
  }]
}

侦听 shutdown 事件

process.on('message', function(msg) {
  if (msg == 'shutdown') {
    console.log('Closing all connections...')
    setTimeout(function() {
      console.log('Finished closing connections')
      process.exit(0)
    }, 1500)
  }
})

如果您使用 BabelJS、Typescript 或任何其他 Javascript 超集，您可能已经注意到，当发生异常时，堆栈跟踪信息毫无意义。要获得有用的信息，您需要生成源映射文件。

生成这些源映射文件后，PM2 将自动检测它们，并帮助您检查错误。

源映射

从 1.0.2 版本开始，PM2 集成了一个支持 Javascript 源映射的机制。

如果您启动 app.js，PM2 会自动检测 Javascript 源映射文件，它将期望 app.js.map 也存在。

如果您有不同的布局，您可以通过启动应用程序来强制支持源映射。

通过 CLI

pm2 start app.js --source-map-support

或者通过 JSON 文件。

module.exports = {
   name: 'babel-app',
   script: 'app.js',
   source_map_support: true
}

检查异常

异常将记录到您的应用程序错误日志文件中。

要检查您的日志以检测异常，您可以键入以下命令：

pm2 logs main

或者，使用 keymetrics.io 获取清晰的列表和新警报的通知。

禁用源映射支持

如果您不希望 PM2 自动支持 Javascript 源映射，则可以使用 --disable-source-map-support 选项。

CLI 和 JSON 文件都支持此选项。

在没有 root 权限的情况下侦听端口 80

一般规则是您不应该以 root 身份运行 Node。但是，只有 root 可以绑定到小于 1024 的端口。这就是 authbind 的用武之地。Authbind 允许非 root 用户绑定到小于 1024 的端口。将 %user% 替换为将运行 pm2 的用户。

sudo apt-get install authbind
sudo touch /etc/authbind/byport/80
sudo chown %user% /etc/authbind/byport/80
sudo chmod 755 /etc/authbind/byport/80

您还应该为运行 pm2 的用户的配置文件添加别名，例如 ~/.bashrc 或 ~/.zshrc（请注意，您需要在之后立即运行 source ~/.bashrc 或 source ~/.zshrc）。

+alias pm2='authbind --deep pm2'

最后，确保使用 authbind 更新了 pm2。

authbind --deep pm2 update

或者，如果您已将别名添加到用户的配置文件中，则只需运行 pm2 update。

现在，您可以使用 PM2 启动可以绑定到端口 80 的应用程序，而无需 root 权限！

在同一服务器上运行多个 PM2

客户端和守护进程通过 $HOME/.pm2/pub.sock 和 $HOME/.pm2/rpc.sock 中的套接字文件进行通信。

您可以通过更改 PM2_HOME 环境变量来启动多个 PM2 实例。

PM2_HOME='.pm2' pm2 start echo.js --name="echo-node-1"
PM2_HOME='.pm3' pm2 start echo.js --name="echo-node-2"

这将启动两个不同的 PM2 实例。要列出每个不同实例管理的进程，请执行以下操作：

PM2_HOME='.pm2' pm2 list
PM2_HOME='.pm3' pm2 list

以非守护进程模式启动 PM2

在以非守护进程模式启动 PM2 之前，请确保终止所有 PM2 实例（pm2 kill）。

在不进行守护进程的情况下启动 PM2

pm2 start app.js --no-daemon

默认情况下，在 PM2 安装时还会安装 CLI pm2-runtime，它是 Node.js 二进制文件的直接替代品。

无状态应用程序

一般规则是您的生产应用程序应该是无状态的。所有数据、状态、WebSocket 会话、会话数据都必须通过任何类型的数据库或 PUB/SUB 系统共享。

否则，您的应用程序将难以在同一服务器上以及跨多个服务器进行扩展。

例如，您可以使用 connect-redis 来共享会话。

我们还建议您遵循 12 要素约定：http://12factor.net/

在服务器上设置 pm2

如何在 Ubuntu VPS 上使用 pm2 设置 Node.js 生产环境.

日志和 PID 文件

默认情况下，日志（错误和输出）、pid 文件、转储文件和 PM2 日志位于 ~/.pm2/ 中。

.pm2/
├── dump.pm2
├── custom_options.sh
├── pm2.log
├── pm2.pid
├── logs
└── pids

启用 Harmony ES6

--node-args 选项允许向 Node 解释器添加参数。要为进程启用 Harmony，请键入以下命令：

pm2 start my_app.js --node-args="--harmony"

在 JSON 声明中：

[{
  "name" : "ES6",
  "script" : "es6.js",
  "node_args" : "--harmony"
}]

CoffeeScript

CoffeeScript v1

pm2 install coffee-script 
pm2 start app.coffee

CoffeeScript v2

pm2 install coffeescript
pm2 start app.coffee

就是这样！

管道 JSON

拉取请求

• #273
• #279

#!/bin/bash

read -d '' my_json <<_EOF_
[{
    "name"       : "app1",
    "script"     : "/home/projects/pm2_nodetest/app.js",
    "instances"  : "4",
    "error_file" : "./logz/child-err.log",
    "out_file"   : "./logz/child-out.log",
    "pid_file"   : "./logz/child.pid",
    "exec_mode"  : "cluster_mode",
    "port"       : 4200
}]
_EOF_

echo $my_json | pm2 start -

进程标题

您可以在使用 PM2 启动应用程序时指定环境变量 PROCESS_FILE，它将设置进程标题。当您尝试从进程中获取特定数据时，这非常有用，例如，您可以使用 ps -fC name。

转译器

请参阅将转译器与 PM2 一起使用教程。

来自问题的用户提示

• Vagrant 和 pm2 #289
• 在不同端口上启动相同的应用程序 #322
• 将 ansible 与 pm2 一起使用
• Cron 字符串作为参数
• 当进程达到特定内存量时重启
• Sticky 会话和 socket.io 讨论
• EACCESS - 了解 pm2 用户/root 权限

外部资源和文章

• PM2 — 实用程序概述和安装
• 如何在 Ubuntu 16.04 上设置用于生产的 Node.js 应用程序
• 教程：在 AWS 上创建和管理 Node.js 服务器，第 2 部分
• 告别 node-forever，迎接 pm2
• https://www.howtoforge.com/tutorial/how-to-deploy-nodejs-applications-with-pm2-and-nginx-on-ubuntu/
• https://serversforhackers.com/editions/2014/11/04/pm2/
• http://www.allaboutghost.com/keep-ghost-running-with-pm2/
• http://blog.ponyfoo.com/2013/09/19/deploying-node-apps-to-aws-using-grunt/
• http://www.allaboutghost.com/keep-ghost-running-with-pm2/
• http://bioselemental.com/keeping-ghost-alive-with-pm2/
• http://blog.chyld.net/installing-ghost-on-ubuntu-13-10-aws-ec2-instance-with-pm2/
• http://blog.marvinroger.fr/gerer-ses-applications-node-en-production-pm2/
• https://www.codersgrid.com/2013/06/29/pm2-process-manager-for-node-js/
• http://www.z-car.com/blog/programming/how-to-rotate-logs-using-pm2-process-manager-for-node-js
• http://yosoftware.com/blog/7-tips-for-a-node-js/
• https://www.exponential.io/blog/nodeday-2014-moving-a-large-developer-workforce-to-nodejs
• http://blog.rapsli.ch/posts/2013/2013-10-17-node-monitor-pm2.html
• https://coderwall.com/p/igdqyw
• http://revdancatt.com/2013/09/17/node-day-1-getting-the-server-installing-node-and-pm2/
• https://medium.com/tech-talk/e7c0b0e5ce3c

持久化应用程序：启动脚本生成器

PM2 可以生成启动脚本并对其进行配置，以便在预期或意外的机器重启后保持进程列表不变。

生成启动脚本

要自动生成和配置启动脚本，只需键入命令（无需 sudo）pm2 startup

$ pm2 startup
[PM2] You have to run this command as root. Execute the following command:
      sudo su -c "env PATH=$PATH:/home/unitech/.nvm/versions/node/v14.3/bin pm2 startup <distribution> -u <user> --hp <home-path>

然后将显示的命令复制/粘贴到终端

sudo su -c "env PATH=$PATH:/home/unitech/.nvm/versions/node/v14.3/bin pm2 startup <distribution> -u <user> --hp <home-path>

现在 PM2 将在启动时自动重启。

注意：您可以通过 --service-name <name> 选项自定义服务名称（#3213）

保存应用程序列表以便在重启时恢复

启动所有所需的应用程序后，保存应用程序列表，以便在重启后重新生成

pm2 save

手动恢复进程

要手动恢复以前保存的进程（通过 pm2 save）

pm2 resurrect

禁用启动系统

要禁用并删除当前启动配置

pm2 unstartup

上一行代码让 PM2 检测您的平台。或者，您可以使用以下命令自己使用另一个指定的初始化系统

Node.js 版本升级后更新启动脚本

升级本地 Node.js 版本时，请务必更新 PM2 启动脚本，以便它运行您已安装的最新 Node.js 二进制文件。

首先禁用并删除当前启动配置（复制/粘贴该命令的输出）

$ pm2 unstartup

然后恢复新的启动脚本

$ pm2 startup

用户权限

假设您希望以另一个用户身份执行启动脚本。

只需更改 -u <username> 选项和 --hp <user_home>

pm2 startup ubuntu -u www --hp /home/ubuntu

指定初始化系统

如果需要，您可以自己指定使用的平台（其中平台可以是上面引用的任何一个）

pm2 startup [ubuntu | ubuntu14 | ubuntu12 | centos | centos6 | arch | oracle | amazon | macos | darwin | freebsd | systemd | systemv | upstart | launchd | rcd | openrc]

SystemD 安装检查

# Check if pm2-<USER> service has been added
$ systemctl list-units
# Check logs
$ journalctl -u pm2-<USER>
# Cat systemd configuration file
$ systemctl cat pm2-<USER>
# Analyze startup
$ systemd-analyze plot > output.svg

为了有效地等待机器联机以运行 PM2

[Unit]
Wants=network-online.target
After=network.target network-online.target

[....]

[Install]
WantedBy=multi-user.target network-online.target

Windows 启动脚本

要生成与 Windows 兼容的启动脚本，请查看优秀的 pm2-installer

支持的初始化系统

• systemd：Ubuntu >= 16，CentOS >= 7，Arch，Debian >= 7
• upstart：Ubuntu <= 14
• launchd：Darwin，MacOSX
• openrc：Gentoo Linux，Arch Linux
• rcd：FreeBSD
• systemv：Centos 6，Amazon Linux

PM2 使用 pm2 startup 命令自动检测这些初始化系统。

更新 PM2

更新 PM2 非常快（不到几秒钟）且无缝。

更新 PM2 的过程

安装最新版本的 PM2

npm install pm2 -g

您现在可以通过以下命令更新内存中的 PM2 守护程序

pm2 update

Node.js 版本升级

升级 Node.js 安装时，请确保还更新了启动 PM2 的 Node.js 版本。

要更新 PM2 启动脚本，请运行

$ pm2 unstartup
$ pm2 startup

在 AWS Elastic Beanstalk 中使用 PM2/Keymetrics

本页面将逐步指导您完成 Beanstalk 环境中的 PM2/Keymetrics 集成。我们建议使用 eb cli 以便于部署。

我们创建了一个存储库以便于测试：pm2-ebs-demo。

设置 Beanstalk

转到您的应用程序目录并使用 eb init 设置 Beanstalk。

我们需要确保 Beanstalk 将尝试使用 npm start 启动您的应用程序。为此，请在源代码包的根目录添加一个名为 Procfile 的文件，以指定启动应用程序的命令。

./Procfile

web: npm start

集成 PM2

使用 PM2 监控应用程序的最简单、侵入性最小的方法是将其作为 npm 模块进行 require。我们将简单地更改 package.json 结构以让 pm2 启动应用程序。只需将 pm2 添加到您的应用程序依赖项中：npm install pm2 --save

然后，我们需要更改启动脚本。我们从 node_modules 文件夹调用 PM2

"scripts": {
  "start": "./node_modules/pm2/bin/pm2-runtime app.js",
  "poststart":  "node ./node_modules/pm2/bin/pm2 logs"
}

• 自定义 "start" 脚本以满足您的需求。
• "poststart" 脚本是可选的，但允许直接在 AWS 仪表板上进行简单的日志检查。

就是这样！运行 eb deploy 即可在您的 ElasticBeanstalk 实例上获得一个 PM2 实例，并且开销最小。

将 PM2 与 Keymetrics 集成

我们需要从环境中将两个变量传递给 PM2 以将其与 Keymetrics 链接：KEYMETRICS_PUBLIC 和 KEYMETRICS_SECRET。

• 从 cli 创建环境时：eb create --envvars KEYMETRICS_PUBLIC=XXXXX,KEYMETRICS_SECRET=XXXXXX
• 您还可以在 AWS 仪表板的“软件配置”选项中添加这些变量。

然后，按照 pm2 集成过程进行操作，pm2 将在启动时自动链接应用程序。

在云提供商上使用 PM2

您可能会遇到无法访问 CLI 来启动 Node.js 应用程序的情况。

在这种情况下，必须将 pm2 添加为依赖项，并且必须使用启动脚本来调用它。

准备您的应用程序

设置您的生态系统文件

使用以下命令生成 ecosystem.config.js 模板

pm2 init

修改生态系统文件以满足您的需求

module.exports = {
  apps : [{
    name: "app",
    script: "./app.js",
    env: {
      NODE_ENV: "development",
    },
    env_production: {
      NODE_ENV: "production",
    }
  }]
}

在此处详细了解生态系统文件 此处。

添加 PM2 作为模块

将 pm2 作为依赖项添加到您的项目中。

使用 npm

npm install pm2

使用 yarn

yarn add pm2

package.json 中的启动脚本

在您的 package.json 中，修改您的 start 脚本，如下所示

{
  "scripts": {
    "start": "pm2-runtime start ecosystem.config.js --env production"
  }
}

部署您的应用程序

您现在可以像部署常规 node.js 应用程序一样，在您的云提供商中部署您的应用程序。

文件更改时自动重启应用程序

当当前目录或其子目录中的文件被修改时，PM2 可以自动重启您的应用程序。

pm2 start app.js --watch

或者，通过配置文件设置选项 watch: true。

如果使用 --watch 选项启动应用程序，则停止应用程序不会阻止它在文件更改时重新启动。要完全禁用监视功能，请执行以下操作：pm2 stop app --watch 或通过 pm2 restart app --watch 在应用程序重新启动时切换监视选项。

要监视特定路径，请使用生态系统文件，watch 可以采用字符串或路径数组。默认值为 true

module.exports = {
  apps: [{
    script: "app.js",
    watch: ["server", "client"],
    // Delay between restart
    watch_delay: 1000,
    ignore_watch : ["node_modules", "client/img"],
  }]
}