單頁文件

PM2 進程管理快速入門

PM2 是一個守護程序管理器，可幫助您管理並保持應用程序在線。開始使用 PM2 很簡單，它提供了一個簡單直觀的 CLI，可以通過 NPM 安裝。

安裝

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

$ 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

以及凍結進程列表以進行自動重生

$ 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 管理多個應用程式時，請使用 JavaScript 配置文件將它們組織起來。

生成配置

要生成一個示例配置文件，您可以輸入此命令

$ 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 選項對於 start/restart/stop/delete 也是有效的

您甚至可以通過以逗號分隔的方式指定要操作的多個應用程式

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 [env name] 選項

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

可用屬性

可以使用以下屬性來微調應用程式的行為和配置

一般

高級功能

記錄檔

控制流程

部署

注意事項

使用 JSON 應用聲明時傳遞的所有命令行選項將被刪除，即

CWD

cwd: 您的 JSON 聲明不需要與您的腳本一起存在。如果您希望將 JSON(s) 保留在腳本以外的位置（比如，/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的值可以是
  • 數字例如："min_uptime": 3000表示3000毫秒。
  • 字符串因此，我們將其縮短並輕鬆配置：h，m和s，例如："min_uptime": "1h"表示一小時，"min_uptime": "5m"表示五分鐘，"min_uptime": "10s"表示十秒（這些將被轉換為毫秒）。
• max_memory_restart max_memory_restart的值可以是
  • 數字例如："max_memory_restart": 1024表示1024字節（不是位元組）。
  • 字符串因此，我們將其縮短並輕鬆配置：G，M和K，例如："max_memory_restart": "1G"表示一個吉字節，"max_memory_restart": "5M"表示五兆字節，"max_memory_restart": "10K"表示十千字節（這些將被轉換為字節）。

• 選擇性的值。例如，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 cluster 模塊，以便擴展應用程序的子進程可以自動共享服務器端口。要了解更多信息，請參閱官方 Node.js 文檔中關於 cluster 模塊的 How It Works。

用法

要啟用集群模式，只需傳遞 -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 相對，它會終止並重新啟動進程，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沒有正確的密鑰來克隆您的存儲庫所致。您需要在每一步驟中驗證密鑰是否可用。

第一步 如果您確定您的金鑰正確運作，首先在目標伺服器上嘗試執行 git clone your_repo.git。如果成功，請繼續進行下一步。如果失敗，請確保您的金鑰存儲在伺服器和您的 git 帳戶中。

第二步 默認情況下，ssh-copy-id 複製的是預設身份，通常命名為 id_rsa。如果這不是適當的金鑰

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

這將您的公共金鑰添加到 ~/.ssh/authorized_keys 文件中。

第三步 如果您收到以下錯誤

--> 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 [應用程式名稱] 選項

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 將在發送最終 SIGKILL 信號之前等待 1600 毫秒。您可以通過在應用程序配置文件中設置 kill_timeout 選項來修改此延遲。

關於應用程序狀態管理的更多信息請參閱此處

開發環境

您可能希望告訴開發人員在容器內進行編程，以保持開發、測試和生產環境的一致性。

將 pm2-runtime 替換為 pm2-dev 將啟用監視和重啟功能。這在開發容器中非常有趣，當主機文件被公開為容器的一個 VOLUME 時。

使用 PM2.io

Keymetrics.io是建立在 PM2 之上的監控服務，可以輕鬆監控和管理應用程序（日誌、重啟、異常監控...）。一旦您在 Keymetrics 上創建了一個 Bucket，您將獲得一個公鑰和一個秘密鑰。

要使用 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 中，但您可以使用 env_production 來決定使用 pm2 start ecosystem.config.js --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_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

這將編寫基本的 logrotate 配置到 /etc/logrotate.d/pm2-user，看起來像這樣

/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 Daemon（同 pm2 kill）。請注意當 Daemon 被終止時，所有其處理也會被終止。同時請注意，即使終止了 Daemon，仍需明確斷開與 Daemon 的連接。

pm2.describe(process, fn)

pm2.connect(errback) - 連接至正在運行的 pm2 Daemon（"上帝"）或啟動並使之成為 Daemon。一旦啟動，即使腳本退出，pm2 進程仍將繼續運行。
pm2.connect(noDaemonMode, errback)

• noDaemonMode -（預設：false）如果第一個參數為 true，pm2 將不會以 Daemon 模式運行，並在相關腳本退出時終止。默認情況下，腳本退出後，pm2 仍保持運行。如果 pm2 已經運行，您的腳本將連接到現有的 Daemon，但在您的處理退出後仍將終止。
• errback(error) - 完成連接或啟動 pm2 Daemon 進程時調用。

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 - 包含與 options 參數相同選項的 JSON 文件的路徑。
• errback(err,proc) - 腳本已啟動時調用的錯誤回調。 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 - 標準輸出日誌文件路徑。
    • pm_err_log_path - 標準錯誤日誌文件路徑。
    • 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 上實施了一種新的重新啟動模式，使您的應用程序以更智能的方式重新啟動。當出現異常（例如數據庫掉線）時，而不是像瘋狂一樣重新啟動您的應用程序，指數退避重新啟動會增加重新啟動之間的時間間隔，減輕您的 DB 或外部提供者的壓力… 使用起來相當簡單

$ 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
}

無自動重新啟動

這在我們希望運行 1 次性腳本並且不希望處理程序管理器在腳本完成運行後重新啟動我們的腳本時非常有用。

CLI

$ pm2 start app.js --no-autorestart

透過配置文件，使用 autorestart 屬性

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

跳過特定退出代碼的自動重新啟動

有時，您可能希望應用程式在失敗時（即非零退出代碼）自動重新啟動，而當它正常關閉時（即退出代碼等於 0）不希望處理程序管理器重新啟動它。

在這種情況下，您仍然可以使用 PM2，只需設置 stop_exit_codes 選項為應該跳過自動重新啟動的退出代碼

CLI

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

或者透過配置檔案，使用 stop_exit_codes 屬性

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

指數遞增退避重啟延遲

在 PM2 Runtime 上實施了一種新的重新啟動模式，使您的應用程序以更智能的方式重新啟動。當出現異常（例如數據庫掉線）時，而不是像瘋狂一樣重新啟動您的應用程序，指數退避重新啟動會增加重新啟動之間的時間間隔，減輕您的 DB 或外部提供者的壓力… 使用起來相當簡單

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

您可以看到重啟之間的延遲將以指數移動平均方式增加，直到達到重啟之間的最大延遲為 15000ms。

當應用程式恢復到穩定模式（連續運行時間超過 30 秒，無需重啟）時，重啟延遲將自動重置為 0ms。

通過 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 將變成優雅重新加載。

配置殺死超時

通過命令行界面，這將將超時設置為 3000ms

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 等待 3000ms 以接收 ready 信號。

通過命令行界面，這將將超時設置為 10000ms

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 服務器接受一個連接時，它將自動將您的應用程序標記為就緒。您可以增加 PM2 等待時間以使用與 --wait-ready 優雅啟動相同的變量：進程文件中的 listen_timeout 項目或通過 CLI 的 --listen-timeout=XXXX。

解釋：信號流

當進程被 PM2 停止/重新啟動時，一些系統信號按照一定的順序發送到您的進程中。

首先，將 SIGINT 信號發送到您的進程中，您可以捕獲該信號以知道您的進程即將停止。如果您的應用程序在 1.6 秒內未自行退出（（可自定義）），則將收到一個 SIGKILL 信號以強制進程退出。

信號 SIGINT 可以通過設置環境變量 PM2_KILL_SIGNAL 替換為任何其他信號（例如 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 源映射的機制。

PM2 將自動檢測 JavaScript 源映射檔案，如果您啟動 app.js，它也將期望 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'

最後確保 pm2 已經更新到與 authbind 一起使用。

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

如何使用 pm2 在 Ubuntu VPS 上設置 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 開始應用程序時指定 env 變量 PROCESS_FILE，它將設置為進程標題。當嘗試從進程獲取特定數據時，這很有用，例如您可以使用 ps -fC name。

編譯器

參考 使用編譯器與 PM2 教程。

用戶提示來自問題

• Vagrant 和 pm2 #289
• 在不同端口上啟動相同的應用程序 #322
• 使用 ansible 與 pm2
• 作為參數的 Cron 字串
• 當進程達到特定記憶體量時重新啟動
• 黏性會話和 socket.io 討論
• EACCESS - 理解 pm2 使用者/根權限

外部資源和文章

• 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 <使用者名稱> 選項和 --hp <使用者家目錄>。

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 模塊要求。我們將簡單地更改 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。

• 在命令行創建環境時： 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 選項啟動，則停止應用程序不會阻止它在文件更改時重新啟動。要完全禁用 watch 功能，請執行： pm2 stop app --watch 或通過 pm2 restart app --watch 在應用程序重新啟動時切換 watch 選項。

要監視特定路徑，請使用生態系統文件，watch 可以接受字符串或路徑數組。默認為 true

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