进程守护

进程守护的概念

进程守护是一种确保关键进程持续运行的机制。当目标进程意外退出时，守护进程能够自动重启它。在Node.js中，这种技术尤为重要，因为单线程的特性使得未捕获的异常可能导致整个应用崩溃。通过实现进程守护，可以显著提高应用的稳定性和可靠性。

为什么需要进程守护

Node.js应用可能因为多种原因崩溃：内存泄漏、未处理的异常、外部依赖故障等。在生产环境中，这些崩溃会导致服务不可用。进程守护解决了以下问题：

• 自动恢复崩溃的服务
• 减少人工干预
• 提高系统可用性
• 记录崩溃信息用于后续分析

原生Node.js实现

使用Node.js的child_process模块可以构建简单的守护进程：

const { spawn } = require('child_process');

function startProcess() {
  const child = spawn('node', ['app.js']);
  
  child.stdout.on('data', (data) => {
    console.log(`stdout: ${data}`);
  });

  child.stderr.on('data', (data) => {
    console.error(`stderr: ${data}`);
  });

  child.on('close', (code) => {
    console.log(`子进程退出，代码 ${code}`);
    // 进程退出后立即重启
    setTimeout(startProcess, 1000);
  });
}

startProcess();

这个实现有几个缺点：缺乏完善的日志管理、没有崩溃频率限制、无法处理进程挂起（无响应但未退出）的情况。

使用PM2进行进程守护

PM2是Node.js生态中最流行的进程管理工具，提供了完善的守护功能：

# 安装PM2
npm install pm2 -g

# 启动应用并守护
pm2 start app.js

# 常用命令
pm2 list         # 查看进程列表
pm2 logs         # 查看日志
pm2 monit        # 监控面板
pm2 reload all   # 零停机重启

PM2的高级配置可以通过ecosystem.config.js文件：

module.exports = {
  apps: [{
    name: 'app',
    script: './app.js',
    instances: 'max',  // 根据CPU核心数启动多个实例
    autorestart: true, // 自动重启
    watch: false,      // 文件变化时重启
    max_memory_restart: '1G', // 内存超过1G时重启
    env: {
      NODE_ENV: 'production'
    }
  }]
};

集群模式下的守护

对于需要多进程运行的应用，Node.js的cluster模块结合守护机制可以提供更好的可靠性：

const cluster = require('cluster');
const numCPUs = require('os').cpus().length;

if (cluster.isMaster) {
  console.log(`主进程 ${process.pid} 正在运行`);
  
  // 衍生工作进程
  for (let i = 0; i < numCPUs; i++) {
    cluster.fork();
  }

  cluster.on('exit', (worker, code, signal) => {
    console.log(`工作进程 ${worker.process.pid} 已退出`);
    // 立即重启崩溃的工作进程
    cluster.fork();
  });
} else {
  // 工作进程执行实际应用代码
  require('./app.js');
  console.log(`工作进程 ${process.pid} 已启动`);
}

高级守护策略

基本的重启机制可能导致"重启风暴"，需要更智能的策略：

1. 指数退避重启：随着连续崩溃增加重启间隔

let restartAttempts = 0;
const maxDelay = 60000; // 最大延迟1分钟

function startWithBackoff() {
  const delay = Math.min(1000 * Math.pow(2, restartAttempts), maxDelay);
  setTimeout(startProcess, delay);
  restartAttempts++;
}

// 成功运行一段时间后重置计数器
function resetRestartCounter() {
  restartAttempts = 0;
}

2. 健康检查机制：定期检查进程响应性

const healthCheck = setInterval(() => {
  if (!isProcessResponsive()) {
    console.error('进程无响应，强制重启');
    killProcess();
    startProcess();
  }
}, 30000);

3. 崩溃分析：根据退出码采取不同策略

child.on('close', (code, signal) => {
  if (code === 0) {
    // 正常退出，可能不需要重启
    console.log('进程正常终止');
  } else if (code === 1) {
    // 已知错误，延迟重启
    setTimeout(startProcess, 5000);
  } else {
    // 未知错误，立即重启
    startProcess();
  }
});

容器环境中的进程守护

在Docker等容器环境中，进程守护需要特殊考虑：

1. 容器启动脚本（entrypoint.sh）：

#!/bin/sh
while true; do
  node app.js
  exit_code=$?
  if [ $exit_code -eq 0 ]; then
    break # 正常退出不重启
  fi
  sleep 5
done

2. Docker Compose配置示例：

version: '3'
services:
  app:
    build: .
    restart: unless-stopped # 使用Docker自带的重启策略
    deploy:
      restart_policy:
        condition: on-failure
        max_attempts: 3
        window: 120s

监控与告警

完善的守护系统需要配合监控：

1. 使用PM2的监控功能：

pm2 install pm2-logrotate  # 日志轮转
pm2 set pm2-logrotate:max_size 10M
pm2 set pm2-logrotate:retain 30

2. 集成外部监控系统：

const axios = require('axios');

process.on('uncaughtException', (err) => {
  // 发送错误告警
  axios.post('https://monitor.example.com/alerts', {
    app: 'my-node-app',
    error: err.stack,
    timestamp: new Date()
  }).finally(() => {
    process.exit(1); // 仍然退出进程，由守护机制重启
  });
});

性能考量

进程守护可能影响系统性能，需要注意：

1. 资源限制：防止无限重启消耗系统资源

const MAX_RESTARTS = 10;
let restartsInLastHour = 0;

setInterval(() => {
  restartsInLastHour = 0; // 每小时重置计数器
}, 3600000);

function startProcess() {
  if (restartsInLastHour >= MAX_RESTARTS) {
    console.error('达到最大重启次数，停止尝试');
    return;
  }
  restartsInLastHour++;
  // ...正常启动逻辑
}

2. 优雅退出：确保重启前完成现有请求

process.on('SIGTERM', () => {
  server.close(() => {
    console.log('服务器已关闭');
    process.exit(0);
  });
  
  // 强制超时
  setTimeout(() => {
    console.error('强制退出');
    process.exit(1);
  }, 5000);
});

实际案例分析

某电商网站在大促期间遇到的典型问题：

1. 内存泄漏导致每小时崩溃2-3次
2. 原始解决方案：手动重启，导致5-10分钟服务不可用
3. 引入PM2守护后的配置：

module.exports = {
  apps: [{
    name: 'api-server',
    script: './server.js',
    max_restarts: 10,
    min_uptime: 5000,
    kill_timeout: 3000,
    listen_timeout: 5000,
    env: {
      NODE_ENV: 'production',
      MEMORY_LIMIT: '1500' // MB
    }
  }]
}

4. 配合监控告警，将平均恢复时间从8分钟降低到15秒以内

错误处理最佳实践

健壮的守护系统需要完善的错误处理：

1. 全局错误捕获：

process.on('uncaughtException', (err) => {
  logger.fatal('未捕获异常', { error: err.stack });
  // 记录足够信息后仍退出，由守护进程重启
  process.exit(1);
});

process.on('unhandledRejection', (reason, promise) => {
  logger.error('未处理的Promise拒绝', { reason });
});

2. 子进程错误处理：

const child = spawn('node', ['app.js'], {
  stdio: ['ignore', 'pipe', 'pipe', 'ipc'] // 使用IPC通信
});

child.on('message', (msg) => {
  if (msg.type === 'error') {
    // 处理子进程报告的预期错误
  }
});

多环境配置策略

不同环境需要不同的守护策略：

1. 开发环境配置（ecosystem.dev.config.js）：

module.exports = {
  apps: [{
    name: 'app-dev',
    script: 'app.js',
    watch: true, // 开发时监听文件变化
    ignore_watch: ['node_modules', 'logs'],
    max_memory_restart: '500M',
    env: {
      NODE_ENV: 'development'
    }
  }]
}

2. 生产环境配置（ecosystem.prod.config.js）：

module.exports = {
  apps: [{
    name: 'app-prod',
    script: 'dist/app.js',
    instances: 'max',
    exec_mode: 'cluster',
    autorestart: true,
    watch: false,
    max_memory_restart: '2G',
    env: {
      NODE_ENV: 'production'
    }
  }]
}