脚本怎样监控进程状态

本文目录导读：

1. Shell脚本监控
2. Python监控脚本
3. 添加告警功能
4. 使用crontab定期执行
5. 系统级监控方案
6. 使用建议

Shell脚本监控

基础进程检查脚本

#!/bin/bash
# 定义要监控的进程名
PROCESS_NAME="nginx"
LOG_FILE="/var/log/process_monitor.log"
# 检查进程是否存在
if pgrep -x "$PROCESS_NAME" > /dev/null; then
    echo "$(date): $PROCESS_NAME 运行正常" >> $LOG_FILE
else
    echo "$(date): $PROCESS_NAME 未运行，尝试启动..." >> $LOG_FILE
    # 尝试启动服务
    systemctl start $PROCESS_NAME 2>/dev/null || service $PROCESS_NAME start 2>/dev/null
    # 检查是否启动成功
    if [ $? -eq 0 ]; then
        echo "$(date): $PROCESS_NAME 启动成功" >> $LOG_FILE
    else
        echo "$(date): $PROCESS_NAME 启动失败" >> $LOG_FILE
    fi
fi

资源使用监控

#!/bin/bash
MONITOR_PID=$1
THRESHOLD_CPU=80
THRESHOLD_MEM=90
# 监控指定PID的资源使用
while true; do
    if [ -d "/proc/$MONITOR_PID" ]; then
        # 获取CPU和内存使用率
        CPU_USAGE=$(ps -p $MONITOR_PID -o %cpu --no-headers)
        MEM_USAGE=$(ps -p $MONITOR_PID -o %mem --no-headers)
        # 检查是否超过阈值
        if (( $(echo "$CPU_USAGE > $THRESHOLD_CPU" | bc -l) )); then
            echo "警告: 进程 $MONITOR_PID CPU使用率: $CPU_USAGE%"
        fi
        if (( $(echo "$MEM_USAGE > $THRESHOLD_MEM" | bc -l) )); then
            echo "警告: 进程 $MONITOR_PID 内存使用率: $MEM_USAGE%"
        fi
        sleep 5
    else
        echo "进程 $MONITOR_PID 已不存在"
        exit 1
    fi
done

Python监控脚本

完整进程监控

#!/usr/bin/env python3
import psutil
import time
import logging
import subprocess
import os
class ProcessMonitor:
    def __init__(self, process_name, restart_command=None):
        self.process_name = process_name
        self.restart_command = restart_command
        self.setup_logging()
    def setup_logging(self):
        logging.basicConfig(
            level=logging.INFO,
            format='%(asctime)s - %(levelname)s - %(message)s',
            handlers=[
                logging.FileHandler('process_monitor.log'),
                logging.StreamHandler()
            ]
        )
    def find_process(self):
        """查找进程"""
        for proc in psutil.process_iter(['pid', 'name', 'cpu_percent', 'memory_percent']):
            try:
                if self.process_name.lower() in proc.info['name'].lower():
                    return proc
            except (psutil.NoSuchProcess, psutil.AccessDenied):
                pass
        return None
    def check_process_health(self, process):
        """检查进程健康状况"""
        cpu_percent = process.cpu_percent(interval=1)
        memory_percent = process.memory_percent()
        if cpu_percent > 90:
            logging.warning(f"CPU使用率过高: {cpu_percent}%")
        if memory_percent > 90:
            logging.warning(f"内存使用率过高: {memory_percent}%")
        # 检查进程状态
        if process.status() == psutil.STATUS_ZOMBIE:
            logging.error("进程已变为僵尸进程")
            return False
        return True
    def restart_process(self):
        """重启进程"""
        if self.restart_command:
            try:
                subprocess.run(self.restart_command, shell=True, check=True)
                logging.info(f"进程 {self.process_name} 重启成功")
                return True
            except subprocess.CalledProcessError as e:
                logging.error(f"重启失败: {e}")
                return False
        else:
            logging.warning("未配置重启命令")
            return False
    def monitor(self, interval=5):
        """持续监控"""
        logging.info(f"开始监控进程: {self.process_name}")
        while True:
            process = self.find_process()
            if process is None:
                logging.warning(f"进程 {self.process_name} 未运行")
                self.restart_process()
            else:
                if not self.check_process_health(process):
                    logging.error("进程异常，尝试重启")
                    self.restart_process()
                else:
                    logging.info(f"进程 {process.info['name']} (PID: {process.info['pid']}) 运行正常")
            time.sleep(interval)
# 使用示例
if __name__ == "__main__":
    monitor = ProcessMonitor(
        process_name="nginx",
        restart_command="systemctl restart nginx"
    )
    monitor.monitor()

添加告警功能

邮件告警

#!/usr/bin/env python3
import smtplib
from email.mime.text import MIMEText
import psutil
import time
class AlertMonitor:
    def __init__(self, process_name, email_config):
        self.process_name = process_name
        self.email_config = email_config
    def send_alert(self, subject, message):
        """发送邮件告警"""
        msg = MIMEText(message)
        msg['Subject'] = subject
        msg['From'] = self.email_config['from']
        msg['To'] = self.email_config['to']
        try:
            with smtplib.SMTP(self.email_config['smtp_server'], 
                            self.email_config['smtp_port']) as server:
                server.starttls()
                server.login(self.email_config['username'], 
                           self.email_config['password'])
                server.send_message(msg)
                print(f"告警邮件已发送: {subject}")
        except Exception as e:
            print(f"发送告警失败: {e}")
    def check_and_alert(self):
        """检查并发送告警"""
        for proc in psutil.process_iter(['pid', 'name']):
            try:
                if self.process_name in proc.info['name']:
                    return  # 进程运行正常
            except (psutil.NoSuchProcess, psutil.AccessDenied):
                pass
        # 进程未运行，发送告警
        self.send_alert(
            f"进程告警: {self.process_name} 已停止",
            f"时间: {time.ctime()}\n进程: {self.process_name}\n状态: 未运行"
        )
# 配置示例
email_config = {
    'from': 'monitor@example.com',
    'to': 'admin@example.com',
    'smtp_server': 'smtp.gmail.com',
    'smtp_port': 587,
    'username': 'monitor@example.com',
    'password': 'your_password'
}
monitor = AlertMonitor('nginx', email_config)
monitor.check_and_alert()

使用crontab定期执行

# 编辑crontab
crontab -e
# 每分钟检查一次进程状态
* * * * * /path/to/monitor_script.sh
# 或者使用更复杂的调度
*/5 * * * * /path/to/monitor_script.sh  # 每5分钟
0 * * * * /path/to/monitor_script.sh    # 每小时

系统级监控方案

systemd服务监控

# /etc/systemd/system/process-monitor.service
[Unit]
Description=Process Monitor Service
After=network.target
[Service]
Type=simple
ExecStart=/usr/local/bin/monitor.py
Restart=always
RestartSec=10
User=root
[Install]
WantedBy=multi-user.target

使用supervisor

# /etc/supervisor/conf.d/monitor.conf
[program:process-monitor]
command=/usr/local/bin/monitor.py
autostart=true
autorestart=true
stderr_logfile=/var/log/monitor.err.log
stdout_logfile=/var/log/monitor.out.log

使用建议

1. 选择合适的监控频率：不要太频繁以免消耗资源
2. 合理设置日志轮转：避免日志文件过大
3. 配置告警机制：及时发现和处理问题
4. 测试自动恢复功能：确保重启命令有效
5. 设置资源限制：防止监控脚本自身占用过多资源

根据你的具体需求选择合适的方案,可以组合使用多种方法实现完整的进程监控。