系统管理命令 on Linux邪修

systemctl 命令详解

Mon, 01 Jan 0001 00:00:00 +0000

systemctl 命令详解#

systemctl 是 Linux 系统中用于控制 systemd 系统和服务管理器的命令。它是现代 Linux 发行版（如 Ubuntu、CentOS、Fedora 等）中管理系统服务的主要工具，可以启动、停止、重启服务，管理系统状态，查看日志等。

入门#

基本用法#

# 启动服务
sudo systemctl start nginx

# 停止服务
sudo systemctl stop nginx

# 重启服务
sudo systemctl restart nginx

# 重新加载服务配置
sudo systemctl reload nginx

# 查看服务状态
systemctl status nginx

常用选项#

选项	说明
`start`	启动服务
`stop`	停止服务
`restart`	重启服务
`reload`	重新加载配置
`status`	查看服务状态
`enable`	开机自启动
`disable`	禁用开机自启动
`is-enabled`	检查是否开机自启动
`is-active`	检查服务是否运行

基本示例#

# 启动 Apache 服务
sudo systemctl start apache2

# 查看服务状态
systemctl status apache2

# 输出示例：
# ● apache2.service - The Apache HTTP Server
# Loaded: loaded (/lib/systemd/system/apache2.service; enabled; vendor preset: enabled)
# Active: active (running) since Mon 2024-01-15 10:00:00 CST; 1h ago
# Docs: https://httpd.apache.org/docs/2.4/
# Main PID: 1234 (apache2)
# Tasks: 55 (limit: 4915)
# Memory: 15.2M
# CPU: 123ms
# CGroup: /system.slice/apache2.service
# ├─1234 /usr/sbin/apache2 -k start
# ├─1235 /usr/sbin/apache2 -k start
# └─1236 /usr/sbin/apache2 -k start

中级#

服务管理#

# 设置开机自启动
sudo systemctl enable nginx

# 禁用开机自启动
sudo systemctl disable nginx

# 检查服务是否开机自启动
systemctl is-enabled nginx

# 检查服务是否运行
systemctl is-active nginx

# 重新加载 systemd 配置
sudo systemctl daemon-reload

# 查看所有服务
systemctl list-units --type=service

# 查看所有已启用的服务
systemctl list-unit-files --type=service --state=enabled

服务状态查询#

# 查看服务详细状态
systemctl status nginx

# 查看服务属性
systemctl show nginx

# 查看服务启动时间
systemctl show nginx --property=ActiveEnterTimestamp

# 查看服务进程 ID
systemctl show nginx --property=MainPID

# 查看服务内存使用
systemctl show nginx --property=MemoryCurrent

# 查看服务 CPU 使用
systemctl show nginx --property=CPUUsageNSec

服务依赖关系#

# 查看服务依赖
systemctl list-dependencies nginx

# 查看反向依赖（哪些服务依赖此服务）
systemctl list-dependencies --reverse nginx

# 查看所有依赖（包括间接依赖）
systemctl list-dependencies --all nginx

# 查看服务启动顺序
systemctl show nginx --property=After
systemctl show nginx --property=Before

高级#

日志管理#

# 查看服务日志
journalctl -u nginx

# 实时查看服务日志
journalctl -u nginx -f

# 查看最近 100 条日志
journalctl -u nginx -n 100

# 查看特定时间段的日志
journalctl -u nginx --since "2024-01-15 10:00:00" --until "2024-01-15 11:00:00"

# 查看服务启动日志
journalctl -u nginx -b

# 查看上次启动的日志
journalctl -u nginx -b -1

服务配置#

# 查看服务配置文件
systemctl cat nginx

# 编辑服务配置文件
sudo systemctl edit nginx

# 编辑服务配置文件（完整）
sudo systemctl edit --full nginx

# 查看服务配置文件路径
systemctl show nginx --property=FragmentPath

# 重置服务配置
sudo systemctl revert nginx

系统管理#

# 关机
sudo systemctl poweroff

# 重启
sudo systemctl reboot

# 挂起
sudo systemctl suspend

# 休眠
sudo systemctl hibernate

# 查看系统运行级别
systemctl get-default

# 设置系统运行级别
sudo systemctl set-default multi-user.target

# 切换到图形界面
sudo systemctl isolate graphical.target

# 切换到多用户模式
sudo systemctl isolate multi-user.target

大师#

服务监控脚本#

#!/bin/bash
# 服务监控脚本

SERVICES=("nginx" "mysql" "redis" "docker")
LOG_FILE="service_monitor.log"
ALERT_EMAIL="admin@example.com"

# 监控服务状态
monitor_services() {
 while true; do
 TIMESTAMP=$(date "+%Y-%m-%d %H:%M:%S")
 
 for SERVICE in "${SERVICES[@]}"; do
 STATUS=$(systemctl is-active $SERVICE)
 
 if [ "$STATUS" != "active" ]; then
 echo "$TIMESTAMP - ALERT: $SERVICE is $STATUS" >> $LOG_FILE
 echo "Service $SERVICE is $STATUS, attempting to restart..."
 
 sudo systemctl restart $SERVICE
 
 if [ $? -eq 0 ]; then
 echo "$TIMESTAMP - $SERVICE restarted successfully" >> $LOG_FILE
 else
 echo "$TIMESTAMP - ERROR: Failed to restart $SERVICE" >> $LOG_FILE
 echo "Service $SERVICE restart failed" | mail -s "Service Alert" $ALERT_EMAIL
 fi
 fi
 done
 
 sleep 300
 done
}

# 生成服务状态报告
generate_report() {
 local report_file="service_report_$(date +%Y%m%d_%H%M%S).txt"
 
 echo "Service Status Report - $(date)" > $report_file
 echo "=============================" >> $report_file
 echo "" >> $report_file
 
 for SERVICE in "${SERVICES[@]}"; do
 echo "=== $SERVICE ===" >> $report_file
 systemctl status $SERVICE >> $report_file
 echo "" >> $report_file
 done
 
 echo "Report saved to: $report_file"
}

# 主函数
main() {
 case "$1" in
 monitor)
 monitor_services
 ;;
 report)
 generate_report
 ;;
 *)
 echo "Usage: $0 {monitor|report}"
 exit 1
 ;;
 esac
}

main "$@"

批量服务管理#

#!/bin/bash
# 批量服务管理脚本

# 批量启动服务
batch_start() {
 local services=("$@")
 
 for service in "${services[@]}"; do
 echo "Starting $service..."
 sudo systemctl start $service
 
 if [ $? -eq 0 ]; then
 echo "✓ $service started"
 else
 echo "✗ Failed to start $service"
 fi
 done
}

# 批量停止服务
batch_stop() {
 local services=("$@")
 
 for service in "${services[@]}"; do
 echo "Stopping $service..."
 sudo systemctl stop $service
 
 if [ $? -eq 0 ]; then
 echo "✓ $service stopped"
 else
 echo "✗ Failed to stop $service"
 fi
 done
}

# 批量重启服务
batch_restart() {
 local services=("$@")
 
 for service in "${services[@]}"; do
 echo "Restarting $service..."
 sudo systemctl restart $service
 
 if [ $? -eq 0 ]; then
 echo "✓ $service restarted"
 else
 echo "✗ Failed to restart $service"
 fi
 done
}

# 批量启用开机自启动
batch_enable() {
 local services=("$@")
 
 for service in "${services[@]}"; do
 echo "Enabling $service..."
 sudo systemctl enable $service
 
 if [ $? -eq 0 ]; then
 echo "✓ $service enabled"
 else
 echo "✗ Failed to enable $service"
 fi
 done
}

# 批量禁用开机自启动
batch_disable() {
 local services=("$@")
 
 for service in "${services[@]}"; do
 echo "Disabling $service..."
 sudo systemctl disable $service
 
 if [ $? -eq 0 ]; then
 echo "✓ $service disabled"
 else
 echo "✗ Failed to disable $service"
 fi
 done
}

# 主函数
main() {
 case "$1" in
 start)
 batch_start "${@:2}"
 ;;
 stop)
 batch_stop "${@:2}"
 ;;
 restart)
 batch_restart "${@:2}"
 ;;
 enable)
 batch_enable "${@:2}"
 ;;
 disable)
 batch_disable "${@:2}"
 ;;
 *)
 echo "Usage: $0 {start|stop|restart|enable|disable} [service1 service2 ...]"
 exit 1
 ;;
 esac
}

main "$@"

服务性能分析#

#!/bin/bash
# 服务性能分析脚本

SERVICE=$1
ANALYSIS_DURATION=60

# 收集服务性能数据
collect_performance_data() {
 local service=$1
 local duration=$2
 local output_file="performance_${service}_$(date +%Y%m%d_%H%M%S).csv"
 
 echo "timestamp,cpu_usage,memory_usage,active_connections" > $output_file
 
 for ((i=0; i<duration; i++)); do
 local timestamp=$(date "+%Y-%m-%d %H:%M:%S")
 local cpu_usage=$(systemctl show $service --property=CPUUsageNSec | cut -d= -f2)
 local memory_usage=$(systemctl show $service --property=MemoryCurrent | cut -d= -f2)
 local active_connections=$(systemctl show $service --property=NConnections | cut -d= -f2)
 
 echo "$timestamp,$cpu_usage,$memory_usage,$active_connections" >> $output_file
 sleep 1
 done
 
 echo "Performance data collected: $output_file"
}

# 分析性能数据
analyze_performance() {
 local input_file=$1
 
 echo "=== Performance Analysis ==="
 echo ""
 
 # CPU 使用统计
 echo "CPU Usage:"
 awk -F, 'NR>1 {sum+=$2; count++} END {print "Average:", sum/count/1000000, "seconds"}' $input_file
 
 # 内存使用统计
 echo "Memory Usage:"
 awk -F, 'NR>1 {sum+=$3; count++} END {print "Average:", sum/count/1024/1024, "MB"}' $input_file
 
 # 连接数统计
 echo "Active Connections:"
 awk -F, 'NR>1 {sum+=$4; count++} END {print "Average:", sum/count}' $input_file
}

# 主函数
main() {
 if [ -z "$SERVICE" ]; then
 echo "Usage: $0 <service_name>"
 exit 1
 fi
 
 local output_file=$(collect_performance_data $SERVICE $ANALYSIS_DURATION)
 analyze_performance $output_file
}

main "$@"

无敌#

企业级服务管理系统#

#!/bin/bash
# 企业级服务管理系统

CONFIG_FILE="/etc/service_manager/config.conf"
LOG_DIR="/var/log/service_manager"
STATE_DIR="/var/run/service_manager"

mkdir -p $LOG_DIR $STATE_DIR

# 加载配置
source $CONFIG_FILE

# 初始化服务状态
init_service() {
 local service=$1
 local state_file="$STATE_DIR/${service}.state"
 
 if systemctl is-active $service > /dev/null 2>&1; then
 echo "active" > $state_file
 log_message "$service initialized as active"
 else
 echo "inactive" > $state_file
 log_message "$service initialized as inactive"
 fi
}

# 监控服务状态
monitor_service() {
 local service=$1
 local state_file="$STATE_DIR/${service}.state"
 
 while true; do
 local current_status=$(systemctl is-active $service 2>/dev/null)
 local saved_status=$(cat $state_file)
 
 if [ "$current_status" != "$saved_status" ]; then
 log_message "ALERT: $service status changed: $saved_status -> $current_status"
 
 if [ "$current_status" = "active" ]; then
 echo "active" > $state_file
 else
 echo "inactive" > $state_file
 
 # 尝试恢复服务
 if [ "$AUTO_RESTART" = "true" ]; then
 log_message "Attempting to restart $service..."
 systemctl restart $service
 
 if [ $? -eq 0 ]; then
 log_message "$service restarted successfully"
 echo "active" > $state_file
 else
 log_message "ERROR: Failed to restart $service"
 send_alert "Service $service failed to restart"
 fi
 fi
 fi
 fi
 
 sleep $MONITOR_INTERVAL
 done
}

# 记录日志
log_message() {
 local message=$1
 local timestamp=$(date "+%Y-%m-%d %H:%M:%S")
 echo "[$timestamp] $message" >> $LOG_DIR/manager.log
}

# 发送告警
send_alert() {
 local message=$1
 echo "$message" | mail -s "Service Manager Alert" $ALERT_EMAIL
}

# 生成服务报告
generate_service_report() {
 local report_file="$LOG_DIR/service_report_$(date +%Y%m%d).txt"
 
 echo "Service Manager Report - $(date +%Y-%m-%d)" > $report_file
 echo "=============================" >> $report_file
 echo "" >> $report_file
 
 for service in "${MANAGED_SERVICES[@]}"; do
 echo "=== $service ===" >> $report_file
 systemctl status $service >> $report_file
 echo "" >> $report_file
 done
 
 log_message "Service report generated: $report_file"
}

# 主程序
main() {
 log_message "Service Manager started"
 
 for service in "${MANAGED_SERVICES[@]}"; do
 init_service $service
 monitor_service $service &
 done
 
 while true; do
 if [ $(date +%H) -eq 0 ] && [ $(date +%M) -eq 0 ]; then
 generate_service_report
 fi
 
 sleep 60
 done
}

main

智能服务调度系统#

#!/bin/bash
# 智能服务调度系统

CONFIG_FILE="/etc/service_scheduler/config.conf"
LOG_FILE="/var/log/service_scheduler/scheduler.log"

mkdir -p $(dirname $LOG_FILE)

# 加载配置
source $CONFIG_FILE

# 检查系统负载
check_system_load() {
 local load=$(uptime | awk -F'load average:' '{print $2}' | awk '{print $1}' | cut -d',' -f1)
 local max_load=${MAX_LOAD:-2.0}
 
 if (( $(echo "$load < $max_load" | bc -l) )); then
 return 0
 else
 return 1
 fi
}

# 检查内存使用
check_memory_usage() {
 local memory_usage=$(free | awk '/Mem:/ {print $3/$2 * 100.0}')
 local max_memory=${MAX_MEMORY:-80}
 
 if (( $(echo "$memory_usage < $max_memory" | bc -l) )); then
 return 0
 else
 return 1
 fi
}

# 检查磁盘空间
check_disk_space() {
 local path=$1
 local min_space=${MIN_DISK_SPACE:-1073741824} # 1GB
 
 local available_space=$(df "$path" | awk 'NR==2 {print $4 * 1024}')
 
 if [ $available_space -gt $min_space ]; then
 return 0
 else
 return 1
 fi
}

# 检查时间窗口
check_time_window() {
 local current_hour=$(date +%H)
 local start_hour=${START_HOUR:-0}
 local end_hour=${END_HOUR:-6}
 
 if [ $current_hour -ge $start_hour ] && [ $current_hour -lt $end_hour ]; then
 return 0
 else
 return 1
 fi
}

# 调度服务操作
schedule_service_operation() {
 local service=$1
 local operation=$2
 
 log_message "Scheduling $operation for $service"
 
 # 检查系统条件
 if ! check_system_load; then
 log_message "System load too high, postponing $operation for $service"
 return 1
 fi
 
 if ! check_memory_usage; then
 log_message "Memory usage too high, postponing $operation for $service"
 return 1
 fi
 
 if ! check_time_window; then
 log_message "Outside allowed time window, postponing $operation for $service"
 return 1
 fi
 
 # 执行操作
 log_message "Executing $operation for $service"
 systemctl $operation $service
 
 if [ $? -eq 0 ]; then
 log_message "✓ $operation completed for $service"
 return 0
 else
 log_message "✗ $operation failed for $service"
 return 1
 fi
}

# 主调度循环
main_scheduler() {
 log_message "Service Scheduler started"
 
 while true; do
 # 从配置文件读取服务操作
 while IFS='|' read -r service operation; do
 if [ -n "$service" ] && [[ ! $service =~ ^# ]]; then
 schedule_service_operation "$service" "$operation"
 fi
 done < "$CONFIG_FILE"
 
 # 等待下次检查
 sleep $SCHEDULER_INTERVAL
 done
}

# 单次执行模式
single_run() {
 while IFS='|' read -r service operation; do
 if [ -n "$service" ] && [[ ! $service =~ ^# ]]; then
 schedule_service_operation "$service" "$operation"
 fi
 done < "$CONFIG_FILE"
}

# 记录日志
log_message() {
 local message=$1
 local timestamp=$(date "+%Y-%m-%d %H:%M:%S")
 echo "[$timestamp] $message" >> $LOG_FILE
}

# 主函数
main() {
 case "$1" in
 start)
 main_scheduler
 ;;
 run)
 single_run
 ;;
 *)
 echo "Usage: $0 {start|run}"
 exit 1
 ;;
 esac
}

main "$@"

服务健康检查系统#

#!/bin/bash
# 服务健康检查系统

CONFIG_FILE="/etc/health_check/config.conf"
LOG_FILE="/var/log/health_check/health.log"
HEALTH_DB="/var/lib/health_check/db"

mkdir -p $(dirname $LOG_FILE) $(dirname $HEALTH_DB)

# 加载配置
source $CONFIG_FILE

# 执行健康检查
perform_health_check() {
 local service=$1
 local check_type=$2
 
 case "$check_type" in
 "systemd")
 systemctl is-active $service > /dev/null 2>&1
 return $?
 ;;
 "http")
 local url=$3
 curl -f -s -o /dev/null "$url" > /dev/null 2>&1
 return $?
 ;;
 "tcp")
 local host=$3
 local port=$4
 nc -z -w 2 $host $port > /dev/null 2>&1
 return $?
 ;;
 "custom")
 local script=$3
 bash $script > /dev/null 2>&1
 return $?
 ;;
 *)
 return 1
 ;;
 esac
}

# 记录健康检查结果
record_health_result() {
 local service=$1
 local status=$2
 local timestamp=$(date +%s)
 
 echo "$timestamp,$status" >> "$HEALTH_DB/${service}.csv"
}

# 分析健康趋势
analyze_health_trend() {
 local service=$1
 local db_file="$HEALTH_DB/${service}.csv"
 
 if [ ! -f "$db_file" ]; then
 echo "No health data available for $service"
 return 1
 fi
 
 local total_checks=$(wc -l < $db_file)
 local failed_checks=$(awk -F, '$2 == "failed" {count++} END {print count+0}' $db_file)
 local success_rate=$(echo "scale=2; ($total_checks - $failed_checks) * 100 / $total_checks" | bc)
 
 echo "Health Trend for $service:"
 echo "Total checks: $total_checks"
 echo "Failed checks: $failed_checks"
 echo "Success rate: ${success_rate}%"
}

# 生成健康报告
generate_health_report() {
 local report_file="$LOG_DIR/health_report_$(date +%Y%m%d).txt"
 
 echo "Health Check Report - $(date +%Y-%m-%d)" > $report_file
 echo "=========================" >> $report_file
 echo "" >> $report_file
 
 for service in "${MONITORED_SERVICES[@]}"; do
 echo "=== $service ===" >> $report_file
 analyze_health_trend $service >> $report_file
 echo "" >> $report_file
 done
 
 log_message "Health report generated: $report_file"
}

# 主健康检查循环
main_health_check() {
 log_message "Health Check System started"
 
 while true; do
 for service in "${MONITORED_SERVICES[@]}"; do
 local check_type=$(eval echo \${${service}_check_type})
 local check_params=$(eval echo \${${service}_check_params})
 
 if perform_health_check $service $check_type $check_params; then
 record_health_result $service "success"
 log_message "Health check passed for $service"
 else
 record_health_result $service "failed"
 log_message "Health check failed for $service"
 
 if [ "$AUTO_RESTART" = "true" ]; then
 log_message "Attempting to restart $service..."
 systemctl restart $service
 fi
 fi
 done
 
 sleep $CHECK_INTERVAL
 done
}

# 记录日志
log_message() {
 local message=$1
 local timestamp=$(date "+%Y-%m-%d %H:%M:%S")
 echo "[$timestamp] $message" >> $LOG_FILE
}

# 主函数
main() {
 case "$1" in
 start)
 main_health_check
 ;;
 report)
 generate_health_report
 ;;
 analyze)
 analyze_health_trend "$2"
 ;;
 *)
 echo "Usage: $0 {start|report|analyze}"
 exit 1
 ;;
 esac
}

main "$@"

最佳实践#

使用 enable/disable 管理开机自启动：合理设置服务的开机自启动状态
定期检查服务状态：使用 systemctl status 定期检查关键服务状态
使用 journalctl 查看日志：结合 journalctl 查看服务日志
理解服务依赖关系：了解服务之间的依赖关系，避免启动顺序问题
备份服务配置：在修改服务配置前备份原始配置
使用 daemon-reload：修改服务配置后执行 daemon-reload 重新加载
监控服务性能：定期监控服务的 CPU、内存使用情况
设置合理的重启策略：在服务配置中设置合理的重启策略

注意事项#

systemctl 需要 root 权限来管理服务
修改系统级服务配置时要格外小心
某些服务可能不支持 reload 操作
服务重启可能导致短暂的服务中断
在生产环境中操作前先在测试环境验证
注意服务的依赖关系，避免启动失败
不同 Linux 发行版的 systemd 配置可能有所不同
对于关键服务，建议配置自动重启策略

top 命令详解

Mon, 01 Jan 0001 00:00:00 +0000

top 命令详解#

top 是 Linux 系统中用于实时显示系统进程和资源使用情况的命令行工具。它提供了动态的、实时的系统监控视图，可以查看 CPU、内存、进程等系统资源的使用情况，是系统管理员和开发人员进行性能分析和故障排查的重要工具。

入门#

基本用法#

# 启动 top
top

# 指定更新间隔（秒）
top -d 5

# 指定显示的进程数
top -n 10

# 指定用户
top -u username

# 指定 PID
top -p 1234

常用选项#

选项	说明
`-d`	指定更新间隔（秒）
`-n`	指定显示的进程数
`-u`	指定用户
`-p`	指定 PID
`-b`	批处理模式
`-H`	显示线程模式
`-c`	显示完整命令行
`-s`	安全模式

基本示例#

# 启动 top
top

# 输出示例：
# top - 10:00:00 up 1 day, 2:30, 2 users, load average: 0.15, 0.10, 0.05
# Tasks: 123 total, 1 running, 122 sleeping, 0 stopped, 0 zombie
# %Cpu(s): 5.0 us, 2.0 sy, 0.0 ni, 92.0 id, 1.0 wa, 0.0 hi, 0.0 si, 0.0 st
# MiB Mem: 8192.0 total, 4096.0 free, 2048.0 used, 2048.0 buff/cache
# MiB Swap: 2048.0 total, 2048.0 free, 0.0 used. 6144.0 avail Mem
#
# PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND
# 1234 root 20 0 123456 56789 1234 S 2.0 0.7 0:01.23 nginx
# 5678 mysql 20 0 234567 123456 5678 S 1.5 1.5 0:05.67 mysqld
# 9012 user 20 0 34567 23456 7890 R 0.5 0.3 0:00.89 python

中级#

交互式命令#

# 在 top 运行时使用以下快捷键：

# 排序
P - 按 CPU 使用率排序
M - 按内存使用排序
N - 按 PID 排序
T - 按运行时间排序

# 显示/隐藏
1 - 显示所有 CPU 核心
H - 显示线程
k - 杀死进程
r - 修改进程优先级
q - 退出 top

# 切换
z - 切换彩色/单色显示
l - 切换负载平均值显示
t - 切换任务和 CPU 状态显示
m - 切换内存信息显示

进程筛选#

# 显示特定用户的进程
top -u username

# 显示特定用户的进程（交互式）
top
u username

# 显示特定 PID
top -p 1234

# 显示多个 PID
top -p 1234,5678,9012

# 显示特定进程名的进程
top -p $(pgrep nginx | tr '\n' ',' | sed 's/,$//')

输出控制#

# 批处理模式（输出到文件）
top -b -n 1 > top_output.txt

# 指定更新次数
top -n 10

# 指定更新间隔
top -d 2

# 组合使用
top -b -d 5 -n 3 > top_batch.txt

# 显示完整命令行
top -c

# 不显示空闲进程
top -i

高级#

高级选项#

# 显示线程模式
top -H

# 显示特定用户的线程
top -H -u username

# 显示完整命令行
top -c

# 安全模式（禁用某些交互命令）
top -s

# 指定配置文件
top -c -b -n 1 > output.txt

# 显示累积模式
top -S

# 显示特定字段
top -o %CPU
top -o %MEM
top -o TIME+

自定义显示#

# 自定义显示字段
top -o PID,USER,%CPU,%MEM,TIME+,COMMAND

# 按多个字段排序
top -o %CPU,%MEM

# 显示特定数量的进程
top -n 20

# 显示特定列
top -o PID,USER,PR,NI,VIRT,RES,SHR,S,%CPU,%MEM,TIME+,COMMAND

# 保存配置
# 在 top 中按 W 保存当前配置

性能监控#

#!/bin/bash
# top 性能监控脚本

DURATION=60
INTERVAL=5
OUTPUT_FILE="top_monitor_$(date +%Y%m%d_%H%M%S).txt"

# 监控系统性能
monitor_performance() {
 echo "System Performance Monitor - $(date)" > $OUTPUT_FILE
 echo "=================================" >> $OUTPUT_FILE
 echo "" >> $OUTPUT_FILE
 
 local iterations=$((DURATION / INTERVAL))
 
 for ((i=1; i<=iterations; i++)); do
 echo "=== Snapshot $i - $(date '+%Y-%m-%d %H:%M:%S') ===" >> $OUTPUT_FILE
 top -b -n 1 | head -20 >> $OUTPUT_FILE
 echo "" >> $OUTPUT_FILE
 
 sleep $INTERVAL
 done
 
 echo "Monitoring completed. Results saved to: $OUTPUT_FILE"
}

# 分析性能数据
analyze_performance() {
 local input_file=$1
 
 echo "=== Performance Analysis ==="
 echo ""
 
 # CPU 使用率
 echo "CPU Usage:"
 grep "Cpu(s)" $input_file | awk '{sum+=$2; count++} END {print "Average:", sum/count, "%"}'
 echo ""
 
 # 内存使用
 echo "Memory Usage:"
 grep "MiB Mem" $input_file | awk '{sum+=$3; count++} END {print "Average:", sum/count, "MiB"}'
 echo ""
 
 # 负载平均值
 echo "Load Average:"
 grep "load average" $input_file | awk '{print $NF}'
}

# 主函数
main() {
 case "$1" in
 monitor)
 monitor_performance
 ;;
 analyze)
 analyze_performance "$2"
 ;;
 *)
 echo "Usage: $0 {monitor|analyze}"
 exit 1
 ;;
 esac
}

main "$@"

大师#

进程资源分析#

#!/bin/bash
# 进程资源分析脚本

PROCESS_NAME=$1
DURATION=60

# 分析进程资源使用
analyze_process() {
 local process_name=$1
 local duration=$2
 local output_file="process_${process_name}_$(date +%Y%m%d_%H%M%S).txt"
 
 echo "Process Analysis: $process_name" > $output_file
 echo "Analysis Time: $(date)" >> $output_file
 echo "" >> $output_file
 
 local iterations=$((duration / 5))
 
 for ((i=1; i<=iterations; i++)); do
 echo "=== Snapshot $i - $(date '+%Y-%m-%d %H:%M:%S') ===" >> $output_file
 top -b -n 1 | grep "$process_name" >> $output_file
 echo "" >> $output_file
 
 sleep 5
 done
 
 echo "Analysis completed: $output_file"
}

# 查找高资源使用进程
find_high_usage_processes() {
 local threshold=$1
 local metric=$2
 
 case "$metric" in
 cpu)
 top -b -n 1 | awk -v threshold=$threshold 'NR>7 && $9 > threshold {print $1, $12, $9"%"}'
 ;;
 mem)
 top -b -n 1 | awk -v threshold=$threshold 'NR>7 && $10 > threshold {print $1, $12, $10"%"}'
 ;;
 *)
 echo "Invalid metric: $metric"
 return 1
 ;;
 esac
}

# 生成进程报告
generate_process_report() {
 local report_file="process_report_$(date +%Y%m%d).txt"
 
 echo "Process Report - $(date +%Y-%m-%d)" > $report_file
 echo "====================" >> $report_file
 echo "" >> $report_file
 
 echo "Top 10 CPU consuming processes:" >> $report_file
 top -b -n 1 | head -17 | tail -10 >> $report_file
 echo "" >> $report_file
 
 echo "Top 10 Memory consuming processes:" >> $report_file
 top -b -n 1 -o %MEM | head -17 | tail -10 >> $report_file
 echo "" >> $report_file
 
 echo "Top 10 Longest running processes:" >> $report_file
 top -b -n 1 -o TIME+ | head -17 | tail -10 >> $report_file
 
 echo "Report saved to: $report_file"
}

# 主函数
main() {
 case "$1" in
 analyze)
 analyze_process "$2" "$3"
 ;;
 find)
 find_high_usage_processes "$2" "$3"
 ;;
 report)
 generate_process_report
 ;;
 *)
 echo "Usage: $0 {analyze|find|report}"
 exit 1
 ;;
 esac
}

main "$@"

系统健康监控#

#!/bin/bash
# 系统健康监控脚本

ALERT_CPU=80
ALERT_MEM=80
ALERT_LOAD=2.0
LOG_FILE="system_health_monitor.log"
ALERT_EMAIL="admin@example.com"

# 检查 CPU 使用率
check_cpu_usage() {
 local cpu_usage=$(top -b -n 1 | grep "Cpu(s)" | awk '{print $2}' | cut -d'%' -f1)
 
 echo "CPU Usage: ${cpu_usage}%"
 
 if (( $(echo "$cpu_usage > $ALERT_CPU" | bc -l) )); then
 echo "ALERT: High CPU usage: ${cpu_usage}%" >> $LOG_FILE
 echo "High CPU usage: ${cpu_usage}%" | mail -s "System Alert" $ALERT_EMAIL
 return 1
 else
 return 0
 fi
}

# 检查内存使用率
check_memory_usage() {
 local mem_usage=$(top -b -n 1 | grep "MiB Mem" | awk '{print $8}' | cut -d'%' -f1)
 
 echo "Memory Usage: ${mem_usage}%"
 
 if (( $(echo "$mem_usage > $ALERT_MEM" | bc -l) )); then
 echo "ALERT: High memory usage: ${mem_usage}%" >> $LOG_FILE
 echo "High memory usage: ${mem_usage}%" | mail -s "System Alert" $ALERT_EMAIL
 return 1
 else
 return 0
 fi
}

# 检查系统负载
check_system_load() {
 local load_avg=$(uptime | awk -F'load average:' '{print $2}' | awk '{print $1}' | cut -d',' -f1)
 
 echo "Load Average: $load_avg"
 
 if (( $(echo "$load_avg > $ALERT_LOAD" | bc -l) )); then
 echo "ALERT: High system load: $load_avg" >> $LOG_FILE
 echo "High system load: $load_avg" | mail -s "System Alert" $ALERT_EMAIL
 return 1
 else
 return 0
 fi
}

# 检查僵尸进程
check_zombie_processes() {
 local zombie_count=$(top -b -n 1 | grep "zombie" | awk '{print $8}')
 
 echo "Zombie Processes: $zombie_count"
 
 if [ $zombie_count -gt 0 ]; then
 echo "ALERT: $zombie_count zombie processes detected" >> $LOG_FILE
 echo "$zombie_count zombie processes detected" | mail -s "System Alert" $ALERT_EMAIL
 return 1
 else
 return 0
 fi
}

# 主监控循环
main_monitor() {
 echo "System Health Monitor started" >> $LOG_FILE
 
 while true; do
 local timestamp=$(date "+%Y-%m-%d %H:%M:%S")
 echo "=== $timestamp ===" >> $LOG_FILE
 
 check_cpu_usage
 check_memory_usage
 check_system_load
 check_zombie_processes
 
 echo "" >> $LOG_FILE
 sleep 300
 done
}

# 单次检查
single_check() {
 local timestamp=$(date "+%Y-%m-%d %H:%M:%S")
 echo "=== System Health Check - $timestamp ==="
 
 check_cpu_usage
 check_memory_usage
 check_system_load
 check_zombie_processes
}

# 主函数
main() {
 case "$1" in
 monitor)
 main_monitor
 ;;
 check)
 single_check
 ;;
 *)
 echo "Usage: $0 {monitor|check}"
 exit 1
 ;;
 esac
}

main "$@"

批量进程管理#

#!/bin/bash
# 批量进程管理脚本

# 查找并显示进程
find_processes() {
 local pattern=$1
 
 echo "Searching for processes matching: $pattern"
 top -b -n 1 | grep "$pattern"
}

# 查找高 CPU 使用进程
find_high_cpu_processes() {
 local threshold=$1
 
 echo "Finding processes with CPU usage > ${threshold}%"
 top -b -n 1 | awk -v threshold=$threshold 'NR>7 && $9 > threshold {print $0}'
}

# 查找高内存使用进程
find_high_memory_processes() {
 local threshold=$1
 
 echo "Finding processes with memory usage > ${threshold}%"
 top -b -n 1 | awk -v threshold=$threshold 'NR>7 && $10 > threshold {print $0}'
}

# 查找僵尸进程
find_zombie_processes() {
 echo "Finding zombie processes"
 top -b -n 1 | grep "Z"
}

# 查找特定用户的进程
find_user_processes() {
 local username=$1
 
 echo "Finding processes for user: $username"
 top -b -n 1 | grep "$username"
}

# 生成进程统计
generate_statistics() {
 echo "=== Process Statistics ==="
 echo ""
 
 # 总进程数
 local total_processes=$(top -b -n 1 | grep "Tasks:" | awk '{print $2}')
 echo "Total processes: $total_processes"
 
 # 运行中的进程
 local running_processes=$(top -b -n 1 | grep "Tasks:" | awk '{print $4}')
 echo "Running processes: $running_processes"
 
 # 睡眠进程
 local sleeping_processes=$(top -b -n 1 | grep "Tasks:" | awk '{print $6}')
 echo "Sleeping processes: $sleeping_processes"
 
 # 僵尸进程
 local zombie_processes=$(top -b -n 1 | grep "Tasks:" | awk '{print $10}')
 echo "Zombie processes: $zombie_processes"
 
 # CPU 使用率
 local cpu_usage=$(top -b -n 1 | grep "Cpu(s)" | awk '{print $2}' | cut -d'%' -f1)
 echo "CPU usage: ${cpu_usage}%"
 
 # 内存使用率
 local mem_usage=$(top -b -n 1 | grep "MiB Mem" | awk '{print $8}' | cut -d'%' -f1)
 echo "Memory usage: ${mem_usage}%"
}

# 主函数
main() {
 case "$1" in
 find)
 find_processes "$2"
 ;;
 high-cpu)
 find_high_cpu_processes "$2"
 ;;
 high-mem)
 find_high_memory_processes "$2"
 ;;
 zombie)
 find_zombie_processes
 ;;
 user)
 find_user_processes "$2"
 ;;
 stats)
 generate_statistics
 ;;
 *)
 echo "Usage: $0 {find|high-cpu|high-mem|zombie|user|stats}"
 exit 1
 ;;
 esac
}

main "$@"

无敌#

企业级性能监控系统#

#!/bin/bash
# 企业级性能监控系统

CONFIG_FILE="/etc/performance_monitor/config.conf"
LOG_DIR="/var/log/performance_monitor"
METRICS_DB="/var/lib/performance_monitor/metrics.db"

mkdir -p $LOG_DIR $(dirname $METRICS_DB)

# 加载配置
source $CONFIG_FILE

# 收集系统指标
collect_system_metrics() {
 local timestamp=$(date +%s)
 
 # CPU 使用率
 local cpu_usage=$(top -b -n 1 | grep "Cpu(s)" | awk '{print $2}' | cut -d'%' -f1)
 
 # 内存使用率
 local mem_usage=$(top -b -n 1 | grep "MiB Mem" | awk '{print $8}' | cut -d'%' -f1)
 
 # 系统负载
 local load_avg=$(uptime | awk -F'load average:' '{print $2}' | awk '{print $1}' | cut -d',' -f1)
 
 # 进程数
 local total_processes=$(top -b -n 1 | grep "Tasks:" | awk '{print $2}')
 local running_processes=$(top -b -n 1 | grep "Tasks:" | awk '{print $4}')
 
 # 保存到数据库
 echo "$timestamp,cpu,$cpu_usage" >> $METRICS_DB
 echo "$timestamp,memory,$mem_usage" >> $METRICS_DB
 echo "$timestamp,load,$load_avg" >> $METRICS_DB
 echo "$timestamp,processes,$total_processes" >> $METRICS_DB
 echo "$timestamp,running,$running_processes" >> $METRICS_DB
}

# 收集进程指标
collect_process_metrics() {
 local timestamp=$(date +%s)
 
 # 获取前 10 个进程的指标
 top -b -n 1 | head -17 | tail -10 | while read line; do
 local pid=$(echo $line | awk '{print $1}')
 local user=$(echo $line | awk '{print $2}')
 local cpu=$(echo $line | awk '{print $9}')
 local mem=$(echo $line | awk '{print $10}')
 local command=$(echo $line | awk '{print $12}')
 
 echo "$timestamp,pid_$pid,$cpu,$mem,$command" >> $METRICS_DB
 done
}

# 分析指标趋势
analyze_metric_trend() {
 local metric=$1
 local duration=$2
 
 local end_time=$(date +%s)
 local start_time=$((end_time - duration))
 
 echo "=== $metric Trend Analysis (last $duration seconds) ==="
 
 grep ",$metric," $METRICS_DB | awk -F, -v start=$start_time -v end=$end_time '$1 >= start && $1 <= end' | while read line; do
 local timestamp=$(echo $line | cut -d, -f1)
 local value=$(echo $line | cut -d, -f3)
 local formatted_time=$(date -d @$timestamp '+%Y-%m-%d %H:%M:%S')
 
 echo "$formatted_time: $value"
 done
}

# 生成性能报告
generate_performance_report() {
 local report_file="$LOG_DIR/performance_report_$(date +%Y%m%d).txt"
 
 echo "Performance Report - $(date +%Y-%m-%d)" > $report_file
 echo "=========================" >> $report_file
 echo "" >> $report_file
 
 # CPU 趋势
 echo "CPU Usage Trend:" >> $report_file
 analyze_metric_trend "cpu" 86400 >> $report_file
 echo "" >> $report_file
 
 # 内存趋势
 echo "Memory Usage Trend:" >> $report_file
 analyze_metric_trend "memory" 86400 >> $report_file
 echo "" >> $report_file
 
 # 负载趋势
 echo "Load Average Trend:" >> $report_file
 analyze_metric_trend "load" 86400 >> $report_file
 echo "" >> $report_file
 
 echo "Report saved to: $report_file"
}

# 主监控循环
main_monitor() {
 while true; do
 collect_system_metrics
 collect_process_metrics
 
 # 每天生成一次报告
 if [ $(date +%H) -eq 0 ] && [ $(date +%M) -eq 0 ]; then
 generate_performance_report
 fi
 
 sleep $COLLECT_INTERVAL
 done
}

# 主函数
main() {
 case "$1" in
 monitor)
 main_monitor
 ;;
 analyze)
 analyze_metric_trend "$2" "$3"
 ;;
 report)
 generate_performance_report
 ;;
 *)
 echo "Usage: $0 {monitor|analyze|report}"
 exit 1
 ;;
 esac
}

main "$@"

智能告警系统#

#!/bin/bash
# 智能告警系统

CONFIG_FILE="/etc/smart_alert/config.conf"
LOG_FILE="/var/log/smart_alert/alerts.log"
ALERT_HISTORY="/var/lib/smart_alert/history.db"

mkdir -p $(dirname $LOG_FILE) $(dirname $ALERT_HISTORY)

# 加载配置
source $CONFIG_FILE

# 检查 CPU 使用率
check_cpu_alert() {
 local cpu_usage=$(top -b -n 1 | grep "Cpu(s)" | awk '{print $2}' | cut -d'%' -f1)
 local threshold=$CPU_ALERT_THRESHOLD
 
 if (( $(echo "$cpu_usage > $threshold" | bc -l) )); then
 local timestamp=$(date +%s)
 local alert_id=$(date +%s%N)
 
 echo "$timestamp,$alert_id,cpu,${cpu_usage}%,High CPU usage detected" >> $ALERT_HISTORY
 log_alert "CPU ALERT: ${cpu_usage}% usage detected"
 send_alert "High CPU usage: ${cpu_usage}%"
 
 return 1
 else
 return 0
 fi
}

# 检查内存使用率
check_memory_alert() {
 local mem_usage=$(top -b -n 1 | grep "MiB Mem" | awk '{print $8}' | cut -d'%' -f1)
 local threshold=$MEMORY_ALERT_THRESHOLD
 
 if (( $(echo "$mem_usage > $threshold" | bc -l) )); then
 local timestamp=$(date +%s)
 local alert_id=$(date +%s%N)
 
 echo "$timestamp,$alert_id,memory,${mem_usage}%,High memory usage detected" >> $ALERT_HISTORY
 log_alert "MEMORY ALERT: ${mem_usage}% usage detected"
 send_alert "High memory usage: ${mem_usage}%"
 
 return 1
 else
 return 0
 fi
}

# 检查系统负载
check_load_alert() {
 local load_avg=$(uptime | awk -F'load average:' '{print $2}' | awk '{print $1}' | cut -d',' -f1)
 local threshold=$LOAD_ALERT_THRESHOLD
 
 if (( $(echo "$load_avg > $threshold" | bc -l) )); then
 local timestamp=$(date +%s)
 local alert_id=$(date +%s%N)
 
 echo "$timestamp,$alert_id,load,${load_avg},High system load detected" >> $ALERT_HISTORY
 log_alert "LOAD ALERT: ${load_avg} load detected"
 send_alert "High system load: $load_avg"
 
 return 1
 else
 return 0
 fi
}

# 检查僵尸进程
check_zombie_alert() {
 local zombie_count=$(top -b -n 1 | grep "Tasks:" | awk '{print $10}')
 local threshold=$ZOMBIE_ALERT_THRESHOLD
 
 if [ $zombie_count -gt $threshold ]; then
 local timestamp=$(date +%s)
 local alert_id=$(date +%s%N)
 
 echo "$timestamp,$alert_id,zombie,${zombie_count},Zombie processes detected" >> $ALERT_HISTORY
 log_alert "ZOMBIE ALERT: $zombie_count zombie processes detected"
 send_alert "$zombie_count zombie processes detected"
 
 return 1
 else
 return 0
 fi
}

# 检查告警频率
check_alert_frequency() {
 local metric=$1
 local time_window=$2
 local max_alerts=$3
 
 local current_time=$(date +%s)
 local start_time=$((current_time - time_window))
 
 local alert_count=$(grep ",$metric," $ALERT_HISTORY | awk -F, -v start=$start_time -v end=$current_time '$1 >= start && $1 <= end' | wc -l)
 
 if [ $alert_count -gt $max_alerts ]; then
 log_alert "ALERT FREQUENCY: Too many $metric alerts in last $time_window seconds: $alert_count"
 return 1
 else
 return 0
 fi
}

# 记录告警
log_alert() {
 local message=$1
 local timestamp=$(date "+%Y-%m-%d %H:%M:%S")
 echo "[$timestamp] $message" >> $LOG_FILE
}

# 发送告警
send_alert() {
 local message=$1
 
 if [ "$ENABLE_EMAIL_ALERTS" = "true" ]; then
 echo "$message" | mail -s "System Alert" $ALERT_EMAIL
 fi
 
 if [ "$ENABLE_SLACK_ALERTS" = "true" ]; then
 curl -X POST -H 'Content-type: application/json' --data "{\"text\":\"$message\"}" $SLACK_WEBHOOK
 fi
}

# 主监控循环
main_monitor() {
 log_alert "Smart Alert System started"
 
 while true; do
 # 检查各种告警条件
 check_cpu_alert
 check_memory_alert
 check_load_alert
 check_zombie_alert
 
 # 检查告警频率
 check_alert_frequency "cpu" 3600 10
 check_alert_frequency "memory" 3600 10
 check_alert_frequency "load" 3600 10
 
 sleep $CHECK_INTERVAL
 done
}

# 生成告警报告
generate_alert_report() {
 local report_file="$LOG_DIR/alert_report_$(date +%Y%m%d).txt"
 
 echo "Alert Report - $(date +%Y-%m-%d)" > $report_file
 echo "===============" >> $report_file
 echo "" >> $report_file
 
 # 统计告警数量
 echo "Alert Statistics:" >> $report_file
 echo "Total alerts: $(wc -l < $ALERT_HISTORY)" >> $report_file
 echo "CPU alerts: $(grep ",cpu," $ALERT_HISTORY | wc -l)" >> $report_file
 echo "Memory alerts: $(grep ",memory," $ALERT_HISTORY | wc -l)" >> $report_file
 echo "Load alerts: $(grep ",load," $ALERT_HISTORY | wc -l)" >> $report_file
 echo "Zombie alerts: $(grep ",zombie," $ALERT_HISTORY | wc -l)" >> $report_file
 echo "" >> $report_file
 
 # 最近的告警
 echo "Recent Alerts:" >> $report_file
 tail -20 $ALERT_HISTORY >> $report_file
 
 log_alert "Alert report generated: $report_file"
}

# 主函数
main() {
 case "$1" in
 monitor)
 main_monitor
 ;;
 report)
 generate_alert_report
 ;;
 *)
 echo "Usage: $0 {monitor|report}"
 exit 1
 ;;
 esac
}

main "$@"

最佳实践#

合理设置更新间隔：根据监控需求设置合适的更新间隔
使用批处理模式：在脚本中使用 -b 选项进行批处理
关注关键指标：重点监控 CPU、内存、负载等关键指标
定期检查僵尸进程：及时发现和处理僵尸进程
设置告警阈值：根据业务需求设置合理的告警阈值
记录监控数据：定期记录监控数据，便于分析趋势
分析性能趋势：定期分析性能数据，识别潜在问题
自动化监控：编写脚本实现自动化监控和告警

注意事项#

top 会消耗一定的系统资源，频繁使用可能影响性能
在高负载系统中，top 的更新可能不够及时
不同版本的 top 输出格式可能有所不同
在生产环境中监控时要谨慎，避免影响服务
注意僵尸进程的处理，避免资源泄漏
对于关键业务，建议使用专业的性能监控工具
注意系统负载的持续监控，及时发现性能瓶颈
在自动化脚本中使用 top 时，注意错误处理

ps 命令详解

Mon, 01 Jan 0001 00:00:00 +0000

ps 命令详解#

ps（Process Status）是 Linux 系统中用于查看当前运行进程状态的命令。它可以显示进程的详细信息，包括 PID、CPU 使用率、内存使用、运行时间等，是系统管理员和开发人员进行进程管理和故障排查的重要工具。

入门#

基本用法#

# 查看当前用户的进程
ps

# 查看所有进程
ps -e

# 查看所有进程（包括其他用户）
ps -a

# 查看所有进程的详细信息
ps -aux

# 查看特定进程
ps -p 1234

常用选项#

选项	说明
`-a`	显示所有终端的进程
`-e`	显示所有进程
`-f`	显示完整格式
`-u`	显示用户导向的格式
`-x`	显示没有控制终端的进程
`-p`	指定进程 ID
`-C`	指定命令名
`-t`	指定终端

基本示例#

# 查看当前用户的进程
ps

# 输出示例：
# PID TTY TIME CMD
# 1234 pts/0 00:00:01 bash
# 5678 pts/0 00:00:00 ps

# 查看所有进程
ps -e

# 查看所有进程的详细信息
ps -aux

# 输出示例：
# USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND
# root 1 0.0 0.1 21568 1234 ? Ss 10:00 0:01 /sbin/init
# root 1234 0.0 0.2 34567 2345 ? S 10:00 0:00 /usr/sbin/nginx
# mysql 5678 0.5 2.3 123456 56789 ? Sl 10:00 0:05 /usr/sbin/mysqld

中级#

进程筛选#

# 查看特定用户的进程
ps -u username

# 查看特定用户的进程（包括所有用户）
ps -u username -u root

# 查看特定进程名的进程
ps -C nginx

# 查看特定 PID 的进程
ps -p 1234

# 查看多个 PID 的进程
ps -p 1234,5678,9012

# 查看特定终端的进程
ps -t pts/0

进程排序#

# 按 CPU 使用率排序
ps -aux --sort=-%cpu

# 按内存使用排序
ps -aux --sort=-%mem

# 按运行时间排序
ps -aux --sort=-etime

# 按进程 ID 排序
ps -aux --sort=pid

# 组合排序（先按 CPU，再按内存）
ps -aux --sort=-%cpu,-%mem

进程状态#

# 查看所有进程的状态
ps -eo stat,cmd

# 查看特定状态的进程
ps -eo stat,cmd | grep "^R"

# 查看僵尸进程
ps -eo stat,cmd | grep "^Z"

# 查看睡眠进程
ps -eo stat,cmd | grep "^S"

# 查看停止的进程
ps -eo stat,cmd | grep "^T"

高级#

高级筛选#

# 查看特定用户的进程（完整格式）
ps -u username -f

# 查看特定进程的完整命令行
ps -p 1234 -f

# 查看所有进程的完整格式
ps -ef

# 查看进程树
ps -ejH

# 查看进程的线程
ps -eLf

# 查看进程的安全上下文
ps -eZ

自定义输出#

# 自定义输出字段
ps -eo pid,ppid,user,%cpu,%mem,cmd

# 查看进程的父进程
ps -eo pid,ppid,cmd

# 查看进程的启动时间
ps -eo pid,lstart,cmd

# 查看进程的运行时间
ps -eo pid,etime,cmd

# 查看进程的优先级
ps -eo pid,ni,pri,cmd

# 查看进程的内存使用
ps -eo pid,vsz,rss,%mem,cmd

进程树#

# 查看进程树
ps -ejH

# 查看进程树（ASCII 字符）
ps -ejH --forest

# 查看特定用户的进程树
ps -u username -ejH

# 查看特定进程的进程树
ps -p 1234 -ejH

# 查看进程树（完整格式）
ps -ef --forest

大师#

进程监控脚本#

#!/bin/bash
# 进程监控脚本

PROCESS_NAME=$1
LOG_FILE="process_monitor.log"

# 监控进程状态
monitor_process() {
 local process_name=$1
 
 while true; do
 local timestamp=$(date "+%Y-%m-%d %H:%M:%S")
 local pid=$(pgrep -o "$process_name")
 
 if [ -n "$pid" ]; then
 local cpu_usage=$(ps -p $pid -o %cpu --no-headers)
 local mem_usage=$(ps -p $pid -o %mem --no-headers)
 local runtime=$(ps -p $pid -o etime --no-headers)
 
 echo "$timestamp - PID: $pid, CPU: ${cpu_usage}%, MEM: ${mem_usage}%, Runtime: $runtime" >> $LOG_FILE
 else
 echo "$timestamp - Process $process_name not found" >> $LOG_FILE
 fi
 
 sleep 60
 done
}

# 查找高资源使用进程
find_high_usage_processes() {
 local metric=$1
 local threshold=$2
 
 case "$metric" in
 cpu)
 ps -eo pid,user,%cpu,cmd --sort=-%cpu | awk -v threshold=$threshold 'NR>1 && $3 > threshold {print $0}'
 ;;
 mem)
 ps -eo pid,user,%mem,cmd --sort=-%mem | awk -v threshold=$threshold 'NR>1 && $3 > threshold {print $0}'
 ;;
 *)
 echo "Invalid metric: $metric"
 return 1
 ;;
 esac
}

# 生成进程报告
generate_process_report() {
 local report_file="process_report_$(date +%Y%m%d_%H%M%S).txt"
 
 echo "Process Report - $(date)" > $report_file
 echo "==================" >> $report_file
 echo "" >> $report_file
 
 echo "Top 10 CPU consuming processes:" >> $report_file
 ps -eo pid,user,%cpu,%mem,cmd --sort=-%cpu | head -11 >> $report_file
 echo "" >> $report_file
 
 echo "Top 10 Memory consuming processes:" >> $report_file
 ps -eo pid,user,%cpu,%mem,cmd --sort=-%mem | head -11 >> $report_file
 echo "" >> $report_file
 
 echo "Top 10 Longest running processes:" >> $report_file
 ps -eo pid,user,etime,cmd --sort=-etime | head -11 >> $report_file
 
 echo "Report saved to: $report_file"
}

# 主函数
main() {
 case "$1" in
 monitor)
 monitor_process "$2"
 ;;
 find)
 find_high_usage_processes "$2" "$3"
 ;;
 report)
 generate_process_report
 ;;
 *)
 echo "Usage: $0 {monitor|find|report}"
 exit 1
 ;;
 esac
}

main "$@"

批量进程管理#

#!/bin/bash
# 批量进程管理脚本

# 查找并显示进程
find_processes() {
 local pattern=$1
 
 echo "Searching for processes matching: $pattern"
 ps -ef | grep "$pattern" | grep -v grep
}

# 查找特定用户的进程
find_user_processes() {
 local username=$1
 
 echo "Finding processes for user: $username"
 ps -u $username -f
}

# 查找特定进程名的进程
find_named_processes() {
 local process_name=$1
 
 echo "Finding processes with name: $process_name"
 ps -C $process_name -f
}

# 查找僵尸进程
find_zombie_processes() {
 echo "Finding zombie processes"
 ps -eo stat,pid,cmd | grep "^Z"
}

# 查找孤儿进程
find_orphan_processes() {
 echo "Finding orphan processes"
 ps -eo pid,ppid,cmd | awk '$2 == 1 {print $0}'
}

# 查找特定状态的进程
find_state_processes() {
 local state=$1
 
 echo "Finding processes in state: $state"
 ps -eo stat,pid,cmd | grep "^$state"
}

# 生成进程统计
generate_statistics() {
 echo "=== Process Statistics ==="
 echo ""
 
 # 总进程数
 local total_processes=$(ps -e | wc -l)
 echo "Total processes: $total_processes"
 
 # 运行中的进程
 local running_processes=$(ps -eo stat | grep "^R" | wc -l)
 echo "Running processes: $running_processes"
 
 # 睡眠进程
 local sleeping_processes=$(ps -eo stat | grep "^S" | wc -l)
 echo "Sleeping processes: $sleeping_processes"
 
 # 僵尸进程
 local zombie_processes=$(ps -eo stat | grep "^Z" | wc -l)
 echo "Zombie processes: $zombie_processes"
 
 # 停止的进程
 local stopped_processes=$(ps -eo stat | grep "^T" | wc -l)
 echo "Stopped processes: $stopped_processes"
}

# 主函数
main() {
 case "$1" in
 find)
 find_processes "$2"
 ;;
 user)
 find_user_processes "$2"
 ;;
 name)
 find_named_processes "$2"
 ;;
 zombie)
 find_zombie_processes
 ;;
 orphan)
 find_orphan_processes
 ;;
 state)
 find_state_processes "$2"
 ;;
 stats)
 generate_statistics
 ;;
 *)
 echo "Usage: $0 {find|user|name|zombie|orphan|state|stats}"
 exit 1
 ;;
 esac
}

main "$@"

进程关系分析#

#!/bin/bash
# 进程关系分析脚本

# 查看进程树
show_process_tree() {
 local pid=${1:-1}
 
 echo "Process Tree for PID: $pid"
 ps -p $pid -f
 
 echo ""
 echo "Child Processes:"
 ps -eo pid,ppid,cmd | awk -v parent=$pid '$2 == parent {print $0}'
}

# 查看进程的完整关系
show_full_process_tree() {
 local pid=${1:-1}
 
 echo "Full Process Tree for PID: $pid"
 ps -ejH | grep -A 100 " $pid "
}

# 查看进程的父进程
show_parent_process() {
 local pid=$1
 
 local ppid=$(ps -p $pid -o ppid --no-headers)
 
 echo "Parent Process of PID $pid:"
 ps -p $ppid -f
}

# 查看进程的所有子进程
show_child_processes() {
 local pid=$1
 
 echo "Child Processes of PID $pid:"
 ps -eo pid,ppid,cmd | awk -v parent=$pid '$2 == parent {print $0}'
}

# 查看进程的完整家族
show_process_family() {
 local pid=$1
 
 echo "=== Process Family for PID: $pid ==="
 echo ""
 
 # 父进程
 echo "Parent Process:"
 show_parent_process $pid
 echo ""
 
 # 子进程
 echo "Child Processes:"
 show_child_processes $pid
 echo ""
 
 # 进程树
 echo "Process Tree:"
 show_process_tree $pid
}

# 分析进程依赖
analyze_process_dependencies() {
 local pid=$1
 
 echo "=== Process Dependencies for PID: $pid ==="
 echo ""
 
 # 打开的文件
 echo "Open Files:"
 lsof -p $pid 2>/dev/null | head -10
 echo ""
 
 # 网络连接
 echo "Network Connections:"
 netstat -p 2>/dev/null | grep $pid | head -10
 echo ""
 
 # 内存映射
 echo "Memory Maps:"
 cat /proc/$pid/maps 2>/dev/null | head -10
}

# 主函数
main() {
 case "$1" in
 tree)
 show_process_tree "$2"
 ;;
 full-tree)
 show_full_process_tree "$2"
 ;;
 parent)
 show_parent_process "$2"
 ;;
 child)
 show_child_processes "$2"
 ;;
 family)
 show_process_family "$2"
 ;;
 dependencies)
 analyze_process_dependencies "$2"
 ;;
 *)
 echo "Usage: $0 {tree|full-tree|parent|child|family|dependencies}"
 exit 1
 ;;
 esac
}

main "$@"

无敌#

企业级进程管理系统#

#!/bin/bash
# 企业级进程管理系统

CONFIG_FILE="/etc/process_manager/config.conf"
LOG_DIR="/var/log/process_manager"
STATE_DIR="/var/run/process_manager"

mkdir -p $LOG_DIR $STATE_DIR

# 加载配置
source $CONFIG_FILE

# 初始化进程监控
init_process_monitor() {
 local process_name=$1
 local state_file="$STATE_DIR/${process_name}.state"
 
 local pid=$(pgrep -o "$process_name")
 
 if [ -n "$pid" ]; then
 echo "$pid" > $state_file
 log_message "$process_name initialized with PID: $pid"
 else
 echo "0" > $state_file
 log_message "$process_name not found"
 fi
}

# 监控进程状态
monitor_process() {
 local process_name=$1
 local state_file="$STATE_DIR/${process_name}.state"
 
 while true; do
 local current_pid=$(pgrep -o "$process_name")
 local saved_pid=$(cat $state_file)
 
 if [ "$current_pid" != "$saved_pid" ]; then
 log_message "Process $process_name PID changed: $saved_pid -> $current_pid"
 
 if [ -n "$current_pid" ]; then
 echo "$current_pid" > $state_file
 log_message "$process_name is now running with PID: $current_pid"
 else
 log_message "ALERT: Process $process_name stopped"
 
 # 尝试重启
 if [ "$AUTO_RESTART" = "true" ]; then
 log_message "Attempting to restart $process_name..."
 systemctl restart $process_name
 
 if [ $? -eq 0 ]; then
 local new_pid=$(pgrep -o "$process_name")
 echo "$new_pid" > $state_file
 log_message "$process_name restarted with PID: $new_pid"
 else
 log_message "ERROR: Failed to restart $process_name"
 send_alert "Process $process_name failed to restart"
 fi
 fi
 fi
 fi
 
 # 检查进程资源使用
 if [ -n "$current_pid" ]; then
 check_process_resources $process_name $current_pid
 fi
 
 sleep $MONITOR_INTERVAL
 done
}

# 检查进程资源使用
check_process_resources() {
 local process_name=$1
 local pid=$2
 
 local cpu_usage=$(ps -p $pid -o %cpu --no-headers)
 local mem_usage=$(ps -p $pid -o %mem --no-headers)
 
 if (( $(echo "$cpu_usage > $CPU_THRESHOLD" | bc -l) )); then
 log_message "ALERT: $process_name CPU usage high: ${cpu_usage}%"
 fi
 
 if (( $(echo "$mem_usage > $MEMORY_THRESHOLD" | bc -l) )); then
 log_message "ALERT: $process_name memory usage high: ${mem_usage}%"
 fi
}

# 记录日志
log_message() {
 local message=$1
 local timestamp=$(date "+%Y-%m-%d %H:%M:%S")
 echo "[$timestamp] $message" >> $LOG_DIR/manager.log
}

# 发送告警
send_alert() {
 local message=$1
 
 if [ "$ENABLE_EMAIL_ALERTS" = "true" ]; then
 echo "$message" | mail -s "Process Manager Alert" $ALERT_EMAIL
 fi
 
 if [ "$ENABLE_SLACK_ALERTS" = "true" ]; then
 curl -X POST -H 'Content-type: application/json' --data "{\"text\":\"$message\"}" $SLACK_WEBHOOK
 fi
}

# 生成监控报告
generate_monitor_report() {
 local report_file="$LOG_DIR/monitor_report_$(date +%Y%m%d).txt"
 
 echo "Process Monitor Report - $(date +%Y-%m-%d)" > $report_file
 echo "=========================" >> $report_file
 echo "" >> $report_file
 
 for process_name in "${MONITORED_PROCESSES[@]}"; do
 echo "=== $process_name ===" >> $report_file
 
 local pid=$(pgrep -o "$process_name")
 if [ -n "$pid" ]; then
 ps -p $pid -f >> $report_file
 else
 echo "Process not running" >> $report_file
 fi
 
 echo "" >> $report_file
 done
 
 log_message "Monitor report generated: $report_file"
}

# 主程序
main() {
 log_message "Process Manager started"
 
 for process_name in "${MONITORED_PROCESSES[@]}"; do
 init_process_monitor $process_name
 monitor_process $process_name &
 done
 
 while true; do
 if [ $(date +%H) -eq 0 ] && [ $(date +%M) -eq 0 ]; then
 generate_monitor_report
 fi
 
 sleep 60
 done
}

main

智能进程分析系统#

#!/bin/bash
# 智能进程分析系统

ANALYSIS_DB="/var/lib/process_analysis/db"
LOG_FILE="/var/log/process_analysis/analysis.log"

mkdir -p $ANALYSIS_DB $(dirname $LOG_FILE)

# 收集进程信息
collect_process_info() {
 local pid=$1
 local output_dir="$ANALYSIS_DB/$pid"
 
 mkdir -p $output_dir
 
 # 基本信息
 ps -p $pid -f > $output_dir/basic_info.txt
 
 # 内存信息
 ps -p $pid -o pid,vsz,rss,%mem,cmd > $output_dir/memory_info.txt
 
 # CPU 信息
 ps -p $pid -o pid,%cpu,etime,cmd > $output_dir/cpu_info.txt
 
 # 文件描述符
 ls -la /proc/$pid/fd/ > $output_dir/fd_info.txt 2>/dev/null
 
 # 网络连接
 netstat -p 2>/dev/null | grep $pid > $output_dir/network_info.txt
 
 # 保存元数据
 echo "pid=$pid" > $output_dir/metadata.txt
 echo "timestamp=$(date)" >> $output_dir/metadata.txt
 
 log_message "Process info collected for PID: $pid"
}

# 分析进程行为
analyze_process_behavior() {
 local pid=$1
 local output_dir="$ANALYSIS_DB/$pid"
 
 if [ ! -d "$output_dir" ]; then
 echo "Process info not found for PID: $pid"
 return 1
 fi
 
 echo "=== Process Behavior Analysis ==="
 echo "PID: $pid"
 echo "Timestamp: $(grep timestamp $output_dir/metadata.txt | cut -d= -f2)"
 echo ""
 
 # CPU 使用分析
 echo "CPU Usage:"
 cat $output_dir/cpu_info.txt
 echo ""
 
 # 内存使用分析
 echo "Memory Usage:"
 cat $output_dir/memory_info.txt
 echo ""
 
 # 文件描述符分析
 echo "File Descriptors:"
 echo "Total: $(wc -l < $output_dir/fd_info.txt)"
 echo ""
 
 # 网络连接分析
 echo "Network Connections:"
 cat $output_dir/network_info.txt
}

# 检测异常进程
detect_anomalous_processes() {
 echo "=== Anomalous Process Detection ==="
 echo ""
 
 # 高 CPU 使用
 echo "High CPU Usage Processes (>50%):"
 ps -eo pid,user,%cpu,cmd --sort=-%cpu | awk 'NR>1 && $3 > 50 {print $0}'
 echo ""
 
 # 高内存使用
 echo "High Memory Usage Processes (>50%):"
 ps -eo pid,user,%mem,cmd --sort=-%mem | awk 'NR>1 && $3 > 50 {print $0}'
 echo ""
 
 # 僵尸进程
 echo "Zombie Processes:"
 ps -eo stat,pid,cmd | grep "^Z"
 echo ""
 
 # 孤儿进程
 echo "Orphan Processes:"
 ps -eo pid,ppid,cmd | awk '$2 == 1 {print $0}'
}

# 进程性能基准测试
benchmark_process() {
 local process_name=$1
 local duration=$2
 local output_file="benchmark_${process_name}_$(date +%Y%m%d_%H%M%S).txt"
 
 echo "Benchmarking process: $process_name"
 echo "Duration: $duration seconds"
 echo ""
 
 local iterations=$((duration / 5))
 
 for ((i=1; i<=iterations; i++)); do
 local pid=$(pgrep -o "$process_name")
 
 if [ -n "$pid" ]; then
 local cpu=$(ps -p $pid -o %cpu --no-headers)
 local mem=$(ps -p $pid -o %mem --no-headers)
 local timestamp=$(date "+%Y-%m-%d %H:%M:%S")
 
 echo "$timestamp - CPU: ${cpu}%, MEM: ${mem}%" >> $output_file
 fi
 
 sleep 5
 done
 
 echo "Benchmark completed: $output_file"
}

# 记录日志
log_message() {
 local message=$1
 local timestamp=$(date "+%Y-%m-%d %H:%M:%S")
 echo "[$timestamp] $message" >> $LOG_FILE
}

# 主函数
main() {
 case "$1" in
 collect)
 collect_process_info "$2"
 ;;
 analyze)
 analyze_process_behavior "$2"
 ;;
 detect)
 detect_anomalous_processes
 ;;
 benchmark)
 benchmark_process "$2" "$3"
 ;;
 *)
 echo "Usage: $0 {collect|analyze|detect|benchmark}"
 exit 1
 ;;
 esac
}

main "$@"

进程安全审计系统#

#!/bin/bash
# 进程安全审计系统

AUDIT_LOG="/var/log/process_audit/audit.log"
ALERT_LOG="/var/log/process_audit/alerts.log"
WHITELIST="/etc/process_audit/whitelist.conf"

mkdir -p $(dirname $AUDIT_LOG) $(dirname $ALERT_LOG)

# 审计进程权限
audit_process_permissions() {
 echo "=== Process Permission Audit ===" >> $AUDIT_LOG
 echo "Audit Time: $(date)" >> $AUDIT_LOG
 echo "" >> $AUDIT_LOG
 
 # root 用户运行的进程
 echo "Root Processes:" >> $AUDIT_LOG
 ps -eo pid,user,cmd | awk '$2 == "root" {print $0}' >> $AUDIT_LOG
 echo "" >> $AUDIT_LOG
 
 # SUID 进程
 echo "SUID Processes:" >> $AUDIT_LOG
 ps -eo pid,user,cmd | awk '{print $0}' | xargs -I {} readlink -f /proc/{}/exe 2>/dev/null | while read exe; do
 if [ -n "$exe" ] && [ -u "$exe" ]; then
 echo "$exe" >> $AUDIT_LOG
 fi
 done
 echo "" >> $AUDIT_LOG
}

# 审计进程网络连接
audit_process_network() {
 echo "=== Process Network Audit ===" >> $AUDIT_LOG
 echo "Audit Time: $(date)" >> $AUDIT_LOG
 echo "" >> $AUDIT_LOG
 
 # 监听端口的进程
 echo "Listening Processes:" >> $AUDIT_LOG
 netstat -tlnp 2>/dev/null | grep LISTEN >> $AUDIT_LOG
 echo "" >> $AUDIT_LOG
 
 # 建立连接的进程
 echo "Connected Processes:" >> $AUDIT_LOG
 netstat -tnp 2>/dev/null | grep ESTABLISHED >> $AUDIT_LOG
 echo "" >> $AUDIT_LOG
}

# 审计进程文件访问
audit_process_files() {
 echo "=== Process File Access Audit ===" >> $AUDIT_LOG
 echo "Audit Time: $(date)" >> $AUDIT_LOG
 echo "" >> $AUDIT_LOG
 
 # 打开敏感文件的进程
 local sensitive_files=("/etc/passwd" "/etc/shadow" "/etc/hosts")
 
 for file in "${sensitive_files[@]}"; do
 echo "Processes accessing $file:" >> $AUDIT_LOG
 lsof $file 2>/dev/null >> $AUDIT_LOG
 echo "" >> $AUDIT_LOG
 done
}

# 检测可疑进程
detect_suspicious_processes() {
 echo "=== Suspicious Process Detection ===" >> $ALERT_LOG
 echo "Detection Time: $(date)" >> $ALERT_LOG
 echo "" >> $ALERT_LOG
 
 # 检查未知进程
 ps -eo pid,user,cmd | while read line; do
 local pid=$(echo $line | awk '{print $1}')
 local user=$(echo $line | awk '{print $2}')
 local cmd=$(echo $line | awk '{print $3}')
 
 # 检查是否在白名单中
 if [ -f "$WHITELIST" ]; then
 if ! grep -q "$cmd" $WHITELIST; then
 echo "Unknown process: $line" >> $ALERT_LOG
 fi
 fi
 done
 echo "" >> $ALERT_LOG
 
 # 检查隐藏进程
 echo "Hidden Processes:" >> $ALERT_LOG
 local ps_count=$(ps -e | wc -l)
 local proc_count=$(ls /proc | grep -E '^[0-9]+$' | wc -l)
 
 if [ $ps_count -lt $proc_count ]; then
 echo "Possible hidden processes detected" >> $ALERT_LOG
 echo "PS count: $ps_count, /proc count: $proc_count" >> $ALERT_LOG
 fi
 echo "" >> $ALERT_LOG
}

# 生成审计报告
generate_audit_report() {
 local report_file="/var/log/process_audit/audit_report_$(date +%Y%m%d).txt"
 
 echo "Process Security Audit Report - $(date +%Y-%m-%d)" > $report_file
 echo "===================================" >> $report_file
 echo "" >> $report_file
 
 # 权限审计
 echo "Permission Audit:" >> $report_file
 grep "Root Processes:" $AUDIT_LOG -A 100 | head -20 >> $report_file
 echo "" >> $report_file
 
 # 网络审计
 echo "Network Audit:" >> $report_file
 grep "Listening Processes:" $AUDIT_LOG -A 100 | head -20 >> $report_file
 echo "" >> $report_file
 
 # 可疑进程
 echo "Suspicious Processes:" >> $report_file
 tail -50 $ALERT_LOG >> $report_file
 
 echo "Audit report generated: $report_file"
}

# 主审计循环
main_audit() {
 while true; do
 audit_process_permissions
 audit_process_network
 audit_process_files
 detect_suspicious_processes
 
 # 每天生成一次报告
 if [ $(date +%H) -eq 0 ] && [ $(date +%M) -eq 0 ]; then
 generate_audit_report
 fi
 
 sleep $AUDIT_INTERVAL
 done
}

# 主函数
main() {
 case "$1" in
 audit)
 main_audit
 ;;
 report)
 generate_audit_report
 ;;
 *)
 echo "Usage: $0 {audit|report}"
 exit 1
 ;;
 esac
}

main "$@"

最佳实践#

结合 grep 使用：使用 ps | grep 筛选特定进程
使用 pgrep/pkill：对于简单的进程查找和终止，使用 pgrep/pkill
关注进程状态：注意进程的状态（R、S、Z、T 等）
监控资源使用：定期监控进程的 CPU 和内存使用
处理僵尸进程：及时发现和处理僵尸进程
理解进程关系：了解进程之间的父子关系
使用自定义输出：根据需要自定义输出字段
记录进程信息：定期记录进程信息，便于分析

注意事项#

ps 只显示瞬间的进程状态，不是实时监控
不同版本的 ps 选项可能有所不同
ps 的输出可能因系统而异
在高负载系统中，ps 的执行可能需要较长时间
注意僵尸进程的处理，避免资源泄漏
对于关键进程，建议使用专业的监控工具
在自动化脚本中使用 ps 时，注意错误处理
注意进程权限，某些进程信息可能无法查看
在生产环境中操作进程时要格外小心

kill 命令详解

Mon, 01 Jan 0001 00:00:00 +0000

kill 命令详解#

kill 是 Linux 系统中用于向进程发送信号的命令。它主要用于终止进程，但也可以发送其他信号来控制进程的行为。kill 命令是系统管理员和开发人员进行进程管理的重要工具。

入门#

基本用法#

# 终止进程
kill 1234

# 强制终止进程
kill -9 1234

# 查看可用信号
kill -l

# 发送特定信号
kill -TERM 1234

常用信号#

信号	编号	说明
`TERM`	15	终止信号（默认）
`KILL`	9	强制终止信号
`HUP`	1	挂起信号
`INT`	2	中断信号（Ctrl+C）
`QUIT`	3	退出信号
`STOP`	19	停止信号
`CONT`	18	继续信号

基本示例#

# 终止进程
kill 1234

# 强制终止进程
kill -9 1234

# 查看进程信息
ps -p 1234

# 发送挂起信号
kill -HUP 1234

中级#

信号管理#

# 查看所有可用信号
kill -l

# 查看特定信号编号
kill -l TERM

# 发送中断信号
kill -INT 1234

# 发送退出信号
kill -QUIT 1234

# 发送停止信号
kill -STOP 1234

# 发送继续信号
kill -CONT 1234

进程终止#

# 正常终止进程
kill 1234

# 强制终止进程
kill -9 1234

# 终止进程组
kill -1234

# 终止所有同名进程
killall nginx

# 强制终止所有同名进程
killall -9 nginx

进程控制#

# 暂停进程
kill -STOP 1234

# 恢复进程
kill -CONT 1234

# 重新加载配置
kill -HUP 1234

# 发送用户定义信号
kill -USR1 1234
kill -USR2 1234

高级#

批量进程管理#

# 终止特定用户的所有进程
kill -u username

# 终止特定进程名的所有进程
pkill nginx

# 终止匹配模式的进程
pkill -f "python script.py"

# 查找并终止进程
pgrep nginx | xargs kill

# 终止多个进程
kill 1234 5678 9012

高级信号#

# 发送 SIGUSR1
kill -USR1 1234

# 发送 SIGUSR2
kill -USR2 1234

# 发送 SIGALRM
kill -ALRM 1234

# 发送 SIGPIPE
kill -PIPE 1234

# 发送 SIGCHLD
kill -CHLD 1234

信号处理#

#!/bin/bash
# 信号处理示例

# 定义信号处理函数
handle_signal() {
 echo "Received signal: $1"
 exit 0
}

# 注册信号处理函数
trap handle_signal SIGTERM SIGINT

# 主循环
while true; do
 echo "Running..."
 sleep 1
done

大师#

进程管理脚本#

#!/bin/bash
# 进程管理脚本

PROCESS_NAME=$1
SIGNAL=${2:-TERM}

# 查找并终止进程
find_and_kill() {
 local process_name=$1
 local signal=$2
 
 local pids=$(pgrep "$process_name")
 
 if [ -z "$pids" ]; then
 echo "No processes found matching: $process_name"
 return 1
 fi
 
 echo "Found processes:"
 ps -p $pids -o pid,cmd
 
 read -p "Kill these processes? (y/n) " -n 1 -r
 echo
 
 if [[ $REPLY =~ ^[Yy]$ ]]; then
 kill -$signal $pids
 
 if [ $? -eq 0 ]; then
 echo "Processes terminated successfully"
 else
 echo "Failed to terminate processes"
 return 1
 fi
 fi
}

# 强制终止进程
force_kill() {
 local process_name=$1
 
 local pids=$(pgrep "$process_name")
 
 if [ -n "$pids" ]; then
 echo "Force killing processes: $process_name"
 kill -9 $pids
 
 if [ $? -eq 0 ]; then
 echo "Processes force killed successfully"
 else
 echo "Failed to force kill processes"
 return 1
 fi
 else
 echo "No processes found matching: $process_name"
 return 1
 fi
}

# 查找僵尸进程
find_zombie_processes() {
 echo "Finding zombie processes..."
 
 local zombie_pids=$(ps -eo stat,pid | grep "^Z" | awk '{print $2}')
 
 if [ -n "$zombie_pids" ]; then
 echo "Zombie processes found:"
 ps -p $zombie_pids -o pid,ppid,cmd
 
 read -p "Kill zombie processes? (y/n) " -n 1 -r
 echo
 
 if [[ $REPLY =~ ^[Yy]$ ]]; then
 # 僵尸进程需要杀死父进程
 local parent_pids=$(ps -p $zombie_pids -o ppid --no-headers | sort -u)
 
 if [ -n "$parent_pids" ]; then
 echo "Killing parent processes: $parent_pids"
 kill -9 $parent_pids
 fi
 fi
 else
 echo "No zombie processes found"
 fi
}

# 主函数
main() {
 case "$1" in
 find)
 find_and_kill "$2" "$3"
 ;;
 force)
 force_kill "$2"
 ;;
 zombie)
 find_zombie_processes
 ;;
 *)
 echo "Usage: $0 {find|force|zombie}"
 exit 1
 ;;
 esac
}

main "$@"

进程监控和自动终止#

#!/bin/bash
# 进程监控和自动终止脚本

PROCESS_NAME=$1
MAX_CPU=$2
MAX_MEMORY=$3
LOG_FILE="process_monitor.log"

# 监控进程资源使用
monitor_process() {
 local process_name=$1
 local max_cpu=$2
 local max_memory=$3
 
 while true; do
 local pid=$(pgrep -o "$process_name")
 
 if [ -n "$pid" ]; then
 local cpu_usage=$(ps -p $pid -o %cpu --no-headers)
 local mem_usage=$(ps -p $pid -o %mem --no-headers)
 
 echo "$(date '+%Y-%m-%d %H:%M:%S') - PID: $pid, CPU: ${cpu_usage}%, MEM: ${mem_usage}%" >> $LOG_FILE
 
 if (( $(echo "$cpu_usage > $max_cpu" | bc -l) )); then
 echo "ALERT: High CPU usage: ${cpu_usage}%" >> $LOG_FILE
 kill -TERM $pid
 sleep 5
 
 if ps -p $pid > /dev/null 2>&1; then
 echo "Force killing process..." >> $LOG_FILE
 kill -9 $pid
 fi
 fi
 
 if (( $(echo "$mem_usage > $max_memory" | bc -l) )); then
 echo "ALERT: High memory usage: ${mem_usage}%" >> $LOG_FILE
 kill -TERM $pid
 sleep 5
 
 if ps -p $pid > /dev/null 2>&1; then
 echo "Force killing process..." >> $LOG_FILE
 kill -9 $pid
 fi
 fi
 fi
 
 sleep 60
 done
}

# 主函数
main() {
 if [ -z "$PROCESS_NAME" ]; then
 echo "Usage: $0 <process_name> <max_cpu> <max_memory>"
 exit 1
 fi
 
 monitor_process $PROCESS_NAME $MAX_CPU $MAX_MEMORY
}

main "$@"

信号发送工具#

#!/bin/bash
# 信号发送工具

# 发送信号到进程
send_signal() {
 local pid=$1
 local signal=$2
 
 if ! ps -p $pid > /dev/null 2>&1; then
 echo "Process $pid not found"
 return 1
 fi
 
 echo "Sending $signal to process $pid..."
 kill -$signal $pid
 
 if [ $? -eq 0 ]; then
 echo "Signal sent successfully"
 
 # 等待进程响应
 sleep 2
 
 if ps -p $pid > /dev/null 2>&1; then
 echo "Process still running"
 else
 echo "Process terminated"
 fi
 else
 echo "Failed to send signal"
 return 1
 fi
}

# 发送信号到进程组
send_signal_to_group() {
 local pgid=$1
 local signal=$2
 
 echo "Sending $signal to process group $pgid..."
 kill -$signal -$pgid
 
 if [ $? -eq 0 ]; then
 echo "Signal sent successfully to process group"
 else
 echo "Failed to send signal to process group"
 return 1
 fi
}

# 发送信号到所有用户进程
send_signal_to_user() {
 local username=$1
 local signal=$2
 
 echo "Sending $signal to all processes of user $username..."
 kill -$signal -u $username
 
 if [ $? -eq 0 ]; then
 echo "Signal sent successfully to user processes"
 else
 echo "Failed to send signal to user processes"
 return 1
 fi
}

# 批量发送信号
batch_send_signal() {
 local pattern=$1
 local signal=$2
 
 local pids=$(pgrep "$pattern")
 
 if [ -z "$pids" ]; then
 echo "No processes found matching: $pattern"
 return 1
 fi
 
 echo "Found processes: $pids"
 echo "Sending $signal to all matching processes..."
 
 for pid in $pids; do
 kill -$signal $pid
 
 if [ $? -eq 0 ]; then
 echo "✓ Signal sent to $pid"
 else
 echo "✗ Failed to send signal to $pid"
 fi
 done
}

# 主函数
main() {
 case "$1" in
 send)
 send_signal "$2" "$3"
 ;;
 group)
 send_signal_to_group "$2" "$3"
 ;;
 user)
 send_signal_to_user "$2" "$3"
 ;;
 batch)
 batch_send_signal "$2" "$3"
 ;;
 *)
 echo "Usage: $0 {send|group|user|batch}"
 exit 1
 ;;
 esac
}

main "$@"

无敌#

企业级进程管理系统#

#!/bin/bash
# 企业级进程管理系统

CONFIG_FILE="/etc/process_manager/config.conf"
LOG_DIR="/var/log/process_manager"
STATE_DIR="/var/run/process_manager"

mkdir -p $LOG_DIR $STATE_DIR

# 加载配置
source $CONFIG_FILE

# 初始化进程监控
init_process_monitor() {
 local process_name=$1
 local state_file="$STATE_DIR/${process_name}.state"
 
 local pid=$(pgrep -o "$process_name")
 
 if [ -n "$pid" ]; then
 echo "$pid" > $state_file
 log_message "$process_name initialized with PID: $pid"
 else
 echo "0" > $state_file
 log_message "$process_name not found"
 fi
}

# 监控进程状态
monitor_process() {
 local process_name=$1
 local state_file="$STATE_DIR/${process_name}.state"
 
 while true; do
 local current_pid=$(pgrep -o "$process_name")
 local saved_pid=$(cat $state_file)
 
 if [ "$current_pid" != "$saved_pid" ]; then
 log_message "Process $process_name PID changed: $saved_pid -> $current_pid"
 
 if [ -n "$current_pid" ]; then
 echo "$current_pid" > $state_file
 log_message "$process_name is now running with PID: $current_pid"
 else
 log_message "ALERT: Process $process_name stopped"
 
 # 尝试重启
 if [ "$AUTO_RESTART" = "true" ]; then
 log_message "Attempting to restart $process_name..."
 systemctl restart $process_name
 
 if [ $? -eq 0 ]; then
 local new_pid=$(pgrep -o "$process_name")
 echo "$new_pid" > $state_file
 log_message "$process_name restarted with PID: $new_pid"
 else
 log_message "ERROR: Failed to restart $process_name"
 send_alert "Process $process_name failed to restart"
 fi
 fi
 fi
 fi
 
 # 检查进程资源使用
 if [ -n "$current_pid" ]; then
 check_process_resources $process_name $current_pid
 fi
 
 sleep $MONITOR_INTERVAL
 done
}

# 检查进程资源使用
check_process_resources() {
 local process_name=$1
 local pid=$2
 
 local cpu_usage=$(ps -p $pid -o %cpu --no-headers)
 local mem_usage=$(ps -p $pid -o %mem --no-headers)
 
 if (( $(echo "$cpu_usage > $CPU_THRESHOLD" | bc -l) )); then
 log_message "ALERT: $process_name CPU usage high: ${cpu_usage}%"
 
 if [ "$AUTO_KILL" = "true" ]; then
 log_message "Auto-killing $process_name..."
 kill -9 $pid
 fi
 fi
 
 if (( $(echo "$mem_usage > $MEMORY_THRESHOLD" | bc -l) )); then
 log_message "ALERT: $process_name memory usage high: ${mem_usage}%"
 
 if [ "$AUTO_KILL" = "true" ]; then
 log_message "Auto-killing $process_name..."
 kill -9 $pid
 fi
 fi
}

# 记录日志
log_message() {
 local message=$1
 local timestamp=$(date "+%Y-%m-%d %H:%M:%S")
 echo "[$timestamp] $message" >> $LOG_DIR/manager.log
}

# 发送告警
send_alert() {
 local message=$1
 
 if [ "$ENABLE_EMAIL_ALERTS" = "true" ]; then
 echo "$message" | mail -s "Process Manager Alert" $ALERT_EMAIL
 fi
 
 if [ "$ENABLE_SLACK_ALERTS" = "true" ]; then
 curl -X POST -H 'Content-type: application/json' --data "{\"text\":\"$message\"}" $SLACK_WEBHOOK
 fi
}

# 生成监控报告
generate_monitor_report() {
 local report_file="$LOG_DIR/monitor_report_$(date +%Y%m%d).txt"
 
 echo "Process Monitor Report - $(date +%Y-%m-%d)" > $report_file
 echo "=========================" >> $report_file
 echo "" >> $report_file
 
 for process_name in "${MANAGED_PROCESSES[@]}"; do
 echo "=== $process_name ===" >> $report_file
 
 local pid=$(pgrep -o "$process_name")
 if [ -n "$pid" ]; then
 ps -p $pid -f >> $report_file
 else
 echo "Process not running" >> $report_file
 fi
 
 echo "" >> $report_file
 done
 
 log_message "Monitor report generated: $report_file"
}

# 主程序
main() {
 log_message "Process Manager started"
 
 for process_name in "${MANAGED_PROCESSES[@]}"; do
 init_process_monitor $process_name
 monitor_process $process_name &
 done
 
 while true; do
 if [ $(date +%H) -eq 0 ] && [ $(date +%M) -eq 0 ]; then
 generate_monitor_report
 fi
 
 sleep 60
 done
}

main

智能进程调度系统#

#!/bin/bash
# 智能进程调度系统

CONFIG_FILE="/etc/process_scheduler/config.conf"
LOG_FILE="/var/log/process_scheduler/scheduler.log"

mkdir -p $(dirname $LOG_FILE)

# 加载配置
source $CONFIG_FILE

# 检查系统负载
check_system_load() {
 local load=$(uptime | awk -F'load average:' '{print $2}' | awk '{print $1}' | cut -d',' -f1)
 local max_load=${MAX_LOAD:-2.0}
 
 if (( $(echo "$load < $max_load" | bc -l) )); then
 return 0
 else
 return 1
 fi
}

# 检查内存使用
check_memory_usage() {
 local memory_usage=$(free | awk '/Mem:/ {print $3/$2 * 100.0}')
 local max_memory=${MAX_MEMORY:-80}
 
 if (( $(echo "$memory_usage < $max_memory" | bc -l) )); then
 return 0
 else
 return 1
 fi
}

# 检查时间窗口
check_time_window() {
 local current_hour=$(date +%H)
 local start_hour=${START_HOUR:-0}
 local end_hour=${END_HOUR:-6}
 
 if [ $current_hour -ge $start_hour ] && [ $current_hour -lt $end_hour ]; then
 return 0
 else
 return 1
 fi
}

# 调度进程操作
schedule_process_operation() {
 local process_name=$1
 local operation=$2
 
 echo "Scheduling $operation for $process_name"
 
 # 检查系统条件
 if ! check_system_load; then
 echo "System load too high, postponing $operation"
 return 1
 fi
 
 if ! check_memory_usage; then
 echo "Memory usage too high, postponing $operation"
 return 1
 fi
 
 if ! check_time_window; then
 echo "Outside allowed time window, postponing $operation"
 return 1
 fi
 
 # 执行操作
 echo "Executing $operation for $process_name"
 
 case "$operation" in
 start)
 systemctl start $process_name
 ;;
 stop)
 systemctl stop $process_name
 ;;
 restart)
 systemctl restart $process_name
 ;;
 kill)
 local pid=$(pgrep -o "$process_name")
 if [ -n "$pid" ]; then
 kill -TERM $pid
 sleep 5
 
 if ps -p $pid > /dev/null 2>&1; then
 kill -9 $pid
 fi
 fi
 ;;
 *)
 echo "Unknown operation: $operation"
 return 1
 ;;
 esac
 
 if [ $? -eq 0 ]; then
 echo "✓ $operation completed for $process_name"
 return 0
 else
 echo "✗ $operation failed for $process_name"
 return 1
 fi
}

# 主调度循环
main_scheduler() {
 log_message "Process Scheduler started"
 
 while true; do
 # 从配置文件读取进程操作
 while IFS='|' read -r process_name operation; do
 if [ -n "$process_name" ] && [[ ! $process_name =~ ^# ]]; then
 schedule_process_operation "$process_name" "$operation"
 fi
 done < "$CONFIG_FILE"
 
 # 等待下次检查
 sleep $SCHEDULER_INTERVAL
 done
}

# 单次执行模式
single_run() {
 while IFS='|' read -r process_name operation; do
 if [ -n "$process_name" ] && [[ ! $process_name =~ ^# ]]; then
 schedule_process_operation "$process_name" "$operation"
 fi
 done < "$CONFIG_FILE"
}

# 记录日志
log_message() {
 local message=$1
 local timestamp=$(date "+%Y-%m-%d %H:%M:%S")
 echo "[$timestamp] $message" >> $LOG_FILE
}

# 主函数
main() {
 case "$1" in
 start)
 main_scheduler
 ;;
 run)
 single_run
 ;;
 *)
 echo "Usage: $0 {start|run}"
 exit 1
 ;;
 esac
}

main "$@"

进程安全管理系统#

#!/bin/bash
# 进程安全管理系统

AUDIT_LOG="/var/log/process_security/audit.log"
ALERT_LOG="/var/log/process_security/alerts.log"
WHITELIST="/etc/process_security/whitelist.conf"

mkdir -p $(dirname $AUDIT_LOG) $(dirname $ALERT_LOG)

# 审计进程终止
audit_process_termination() {
 local pid=$1
 local signal=$2
 local user=$(whoami)
 
 echo "$(date '+%Y-%m-%d %H:%M:%S') - User: $user, PID: $pid, Signal: $signal" >> $AUDIT_LOG
 
 # 检查是否为关键进程
 local process_name=$(ps -p $pid -o comm --no-headers)
 
 if [ -f "$WHITELIST" ]; then
 if ! grep -q "$process_name" $WHITELIST; then
 echo "ALERT: Non-whitelisted process terminated: $process_name (PID: $pid)" >> $ALERT_LOG
 send_alert "Non-whitelisted process terminated: $process_name (PID: $pid)"
 fi
 fi
}

# 检测异常终止
detect_abnormal_termination() {
 local pid=$1
 local signal=$2
 
 case "$signal" in
 SIGKILL|9)
 echo "ALERT: Process $pid was force killed" >> $ALERT_LOG
 send_alert "Process $pid was force killed"
 ;;
 SIGSEGV|11)
 echo "ALERT: Process $pid crashed (SIGSEGV)" >> $ALERT_LOG
 send_alert "Process $pid crashed (SIGSEGV)"
 ;;
 SIGABRT|6)
 echo "ALERT: Process $pid aborted (SIGABRT)" >> $ALERT_LOG
 send_alert "Process $pid aborted (SIGABRT)"
 ;;
 esac
}

# 监控进程终止
monitor_process_termination() {
 while true; do
 # 检查最近终止的进程
 dmesg | grep "killed process" | tail -10 | while read line; do
 local pid=$(echo $line | grep -oP 'pid \K\d+')
 local signal=$(echo $line | grep -oP 'signal \K\d+')
 
 if [ -n "$pid" ] && [ -n "$signal" ]; then
 detect_abnormal_termination $pid $signal
 fi
 done
 
 sleep 60
 done
}

# 安全终止进程
safe_kill() {
 local pid=$1
 local signal=${2:-TERM}
 
 # 验证进程权限
 local current_user=$(whoami)
 local process_user=$(ps -p $pid -o user --no-headers)
 
 if [ "$current_user" != "root" ] && [ "$current_user" != "$process_user" ]; then
 echo "ERROR: Permission denied to kill process $pid"
 return 1
 fi
 
 # 验证进程存在
 if ! ps -p $pid > /dev/null 2>&1; then
 echo "ERROR: Process $pid not found"
 return 1
 fi
 
 # 记录审计日志
 audit_process_termination $pid $signal
 
 # 发送信号
 kill -$signal $pid
 
 if [ $? -eq 0 ]; then
 echo "Signal $signal sent to process $pid"
 return 0
 else
 echo "ERROR: Failed to send signal to process $pid"
 return 1
 fi
}

# 批量安全终止
batch_safe_kill() {
 local pattern=$1
 local signal=${2:-TERM}
 
 local pids=$(pgrep "$pattern")
 
 if [ -z "$pids" ]; then
 echo "No processes found matching: $pattern"
 return 1
 fi
 
 echo "Found processes: $pids"
 echo "Sending $signal to all matching processes..."
 
 for pid in $pids; do
 safe_kill $pid $signal
 done
}

# 发送告警
send_alert() {
 local message=$1
 
 if [ "$ENABLE_EMAIL_ALERTS" = "true" ]; then
 echo "$message" | mail -s "Process Security Alert" $ALERT_EMAIL
 fi
 
 if [ "$ENABLE_SLACK_ALERTS" = "true" ]; then
 curl -X POST -H 'Content-type: application/json' --data "{\"text\":\"$message\"}" $SLACK_WEBHOOK
 fi
}

# 主函数
main() {
 case "$1" in
 kill)
 safe_kill "$2" "$3"
 ;;
 batch)
 batch_safe_kill "$2" "$3"
 ;;
 monitor)
 monitor_process_termination
 ;;
 *)
 echo "Usage: $0 {kill|batch|monitor}"
 exit 1
 ;;
 esac
}

main "$@"

最佳实践#

优先使用 TERM 信号：先尝试正常终止进程
谨慎使用 KILL 信号：KILL 信号无法被捕获和处理
了解进程状态：在终止进程前了解其状态和重要性
使用 pgrep/pkill：对于简单的进程查找和终止，使用 pgrep/pkill
记录终止操作：记录重要的进程终止操作
处理僵尸进程：及时发现和处理僵尸进程
设置合理的信号：根据进程类型选择合适的信号
监控进程状态：定期监控进程状态，及时发现异常

注意事项#

kill 命令需要适当的权限才能终止进程
KILL 信号（-9）无法被进程捕获，强制终止
终止关键系统进程可能导致系统不稳定
在生产环境中终止进程时要格外小心
僵尸进程需要杀死父进程才能清理
不同信号的行为可能因进程而异
注意进程的父子关系，避免影响其他进程
对于关键业务，建议使用专业的进程管理工具
在自动化脚本中使用 kill 时，注意错误处理

df 命令详解

Mon, 01 Jan 0001 00:00:00 +0000

df 命令详解#

df（Disk Free）是 Linux 系统中用于显示文件系统磁盘空间使用情况的命令。它可以显示每个挂载点的总容量、已用空间、可用空间和使用百分比，是系统管理员进行磁盘空间管理的重要工具。

入门#

基本用法#

# 显示磁盘空间使用情况
df

# 以人类可读格式显示
df -h

# 显示特定文件系统
df /home

# 显示所有文件系统
df -a

常用选项#

选项	说明
`-h`	以人类可读格式显示（KB、MB、GB）
`-a`	显示所有文件系统
`-T`	显示文件系统类型
`-i`	显示 inode 使用情况
`-x`	排除特定文件系统类型
`-t`	显示特定文件系统类型

基本示例#

# 显示磁盘空间使用情况
df

# 输出示例：
# Filesystem 1K-blocks Used Available Use% Mounted on
# /dev/sda1 10240000 5123456 5116544 51% /
# /dev/sda2 20480000 10234567 10245433 51% /home
# /dev/sda3 5120000 2567890 2552110 51% /var

# 以人类可读格式显示
df -h

# 输出示例：
# Filesystem Size Used Avail Use% Mounted on
# /dev/sda1 10G 4.9G 4.9G 51% /
# /dev/sda2 20G 9.8G 9.8G 51% /home
# /dev/sda3 5.0G 2.5G 2.5G 51% /var

中级#

文件系统筛选#

# 显示特定文件系统类型
df -t ext4

# 排除特定文件系统类型
df -x tmpfs

# 显示多个文件系统类型
df -t ext4 -t xfs

# 显示特定挂载点
df /home

# 显示多个挂载点
df /home /var /tmp

inode 使用情况#

# 显示 inode 使用情况
df -i

# 以人类可读格式显示 inode
df -ih

# 显示特定文件系统的 inode
df -i /home

# 输出示例：
# Filesystem Inodes IUsed IFree IUse% Mounted on
# /dev/sda1 655360 123456 531904 19% /
# /dev/sda2 1310720 567890 742830 44% /home
# /dev/sda3 327680 234567 93113 72% /var

输出格式控制#

# 显示文件系统类型
df -T

# 显示特定字段
df -h --output=source,fstype,size,used,avail,pcent,target

# 显示完整路径
df -h --output=all

# 显示 POSIX 格式
df -P

# 显示总计
df -h --total

高级#

高级筛选和显示#

# 显示所有文件系统（包括虚拟文件系统）
df -a

# 显示本地文件系统
df -l

# 显示特定块大小
df --block-size=1M

# 显示同步状态
df --sync

# 显示无缓存状态
df --no-sync

# 组合使用
df -hT --total

磁盘空间监控#

#!/bin/bash
# 磁盘空间监控脚本

ALERT_THRESHOLD=80
ALERT_EMAIL="admin@example.com"

# 检查磁盘空间
check_disk_space() {
 local mount_point=$1
 local threshold=$2
 
 local usage=$(df -h $mount_point | awk 'NR==2 {print $5}' | cut -d'%' -f1)
 
 echo "Disk usage for $mount_point: ${usage}%"
 
 if [ $usage -gt $threshold ]; then
 echo "ALERT: Disk space low on $mount_point: ${usage}%"
 echo "Disk space low on $mount_point: ${usage}%" | mail -s "Disk Alert" $ALERT_EMAIL
 return 1
 else
 return 0
 fi
}

# 检查所有挂载点
check_all_mounts() {
 df -h | awk 'NR>1 {print $6}' | while read mount_point; do
 check_disk_space $mount_point $ALERT_THRESHOLD
 done
}

# 主函数
main() {
 case "$1" in
 check)
 check_disk_space "$2" "$3"
 ;;
 all)
 check_all_mounts
 ;;
 *)
 echo "Usage: $0 {check|all}"
 exit 1
 ;;
 esac
}

main "$@"

磁盘空间分析#

#!/bin/bash
# 磁盘空间分析脚本

# 生成磁盘空间报告
generate_disk_report() {
 local report_file="disk_report_$(date +%Y%m%d_%H%M%S).txt"
 
 echo "Disk Space Report - $(date)" > $report_file
 echo "=====================" >> $report_file
 echo "" >> $report_file
 
 # 总体磁盘使用情况
 echo "=== Overall Disk Usage ===" >> $report_file
 df -h >> $report_file
 echo "" >> $report_file
 
 # 文件系统类型
 echo "=== Filesystem Types ===" >> $report_file
 df -hT >> $report_file
 echo "" >> $report_file
 
 # inode 使用情况
 echo "=== Inode Usage ===" >> $report_file
 df -ih >> $report_file
 echo "" >> $report_file
 
 # 高使用率文件系统
 echo "=== High Usage Filesystems (>80%) ===" >> $report_file
 df -h | awk 'NR>1 && $5+0 > 80 {print $0}' >> $report_file
 
 echo "Report saved to: $report_file"
}

# 查找大文件
find_large_files() {
 local directory=$1
 local size=${2:-100M}
 
 echo "Finding files larger than $size in $directory..."
 find $directory -type f -size +$size -exec ls -lh {} \; | awk '{print $9, $5}'
}

# 分析磁盘增长
analyze_disk_growth() {
 local mount_point=$1
 local history_file="disk_history_${mount_point//\//_}.txt"
 
 local current_usage=$(df -h $mount_point | awk 'NR==2 {print $3}')
 local current_avail=$(df -h $mount_point | awk 'NR==2 {print $4}')
 local current_percent=$(df -h $mount_point | awk 'NR==2 {print $5}')
 
 echo "$(date '+%Y-%m-%d %H:%M:%S'),$current_usage,$current_avail,$current_percent" >> $history_file
 
 echo "Disk usage recorded for $mount_point"
 
 # 显示历史数据
 if [ -f "$history_file" ]; then
 echo ""
 echo "History:"
 tail -10 $history_file
 fi
}

# 主函数
main() {
 case "$1" in
 report)
 generate_disk_report
 ;;
 large)
 find_large_files "$2" "$3"
 ;;
 growth)
 analyze_disk_growth "$2"
 ;;
 *)
 echo "Usage: $0 {report|large|growth}"
 exit 1
 ;;
 esac
}

main "$@"

大师#

企业级磁盘监控系统#

#!/bin/bash
# 企业级磁盘监控系统

CONFIG_FILE="/etc/disk_monitor/config.conf"
LOG_DIR="/var/log/disk_monitor"
METRICS_DB="/var/lib/disk_monitor/metrics.db"

mkdir -p $LOG_DIR $(dirname $METRICS_DB)

# 加载配置
source $CONFIG_FILE

# 收集磁盘指标
collect_disk_metrics() {
 local timestamp=$(date +%s)
 
 df -h | awk 'NR>1 {print $6, $2, $3, $4, $5}' | while read mount_point size used avail percent; do
 local usage_percent=$(echo $percent | cut -d'%' -f1)
 
 echo "$timestamp,$mount_point,$size,$used,$avail,$usage_percent" >> $METRICS_DB
 
 # 检查告警阈值
 if [ $usage_percent -gt $ALERT_THRESHOLD ]; then
 log_message "ALERT: $mount_point usage: ${usage_percent}%"
 send_alert "Disk space low on $mount_point: ${usage_percent}%"
 fi
 done
}

# 收集 inode 指标
collect_inode_metrics() {
 local timestamp=$(date +%s)
 
 df -i | awk 'NR>1 {print $6, $2, $3, $4, $5}' | while read mount_point total used free percent; do
 local usage_percent=$(echo $percent | cut -d'%' -f1)
 
 echo "$timestamp,$mount_point,inodes,$total,$used,$free,$usage_percent" >> $METRICS_DB
 
 # 检查告警阈值
 if [ $usage_percent -gt $INODE_ALERT_THRESHOLD ]; then
 log_message "ALERT: $mount_point inode usage: ${usage_percent}%"
 send_alert "Inode space low on $mount_point: ${usage_percent}%"
 fi
 done
}

# 分析磁盘趋势
analyze_disk_trend() {
 local mount_point=$1
 local duration=$2
 
 local end_time=$(date +%s)
 local start_time=$((end_time - duration))
 
 echo "=== Disk Trend Analysis for $mount_point ==="
 echo "Duration: $duration seconds"
 echo ""
 
 grep ",$mount_point," $METRICS_DB | awk -F, -v start=$start_time -v end=$end_time '$1 >= start && $1 <= end' | while read line; do
 local timestamp=$(echo $line | cut -d, -f1)
 local used=$(echo $line | cut -d, -f4)
 local percent=$(echo $line | cut -d, -f6)
 local formatted_time=$(date -d @$timestamp '+%Y-%m-%d %H:%M:%S')
 
 echo "$formatted_time - Used: $used (${percent}%)"
 done
}

# 生成监控报告
generate_monitor_report() {
 local report_file="$LOG_DIR/monitor_report_$(date +%Y%m%d).txt"
 
 echo "Disk Monitor Report - $(date +%Y-%m-%d)" > $report_file
 echo "=====================" >> $report_file
 echo "" >> $report_file
 
 # 当前磁盘使用情况
 echo "=== Current Disk Usage ===" >> $report_file
 df -h >> $report_file
 echo "" >> $report_file
 
 # inode 使用情况
 echo "=== Inode Usage ===" >> $report_file
 df -ih >> $report_file
 echo "" >> $report_file
 
 # 高使用率文件系统
 echo "=== High Usage Filesystems ===" >> $report_file
 df -h | awk 'NR>1 && $5+0 > 80 {print $0}' >> $report_file
 echo "" >> $report_file
 
 # 趋势分析
 echo "=== Disk Trends (last 24 hours) ===" >> $report_file
 for mount_point in "${MONITORED_MOUNTS[@]}"; do
 analyze_disk_trend $mount_point 86400 >> $report_file
 echo "" >> $report_file
 done
 
 log_message "Monitor report generated: $report_file"
}

# 记录日志
log_message() {
 local message=$1
 local timestamp=$(date "+%Y-%m-%d %H:%M:%S")
 echo "[$timestamp] $message" >> $LOG_DIR/monitor.log
}

# 发送告警
send_alert() {
 local message=$1
 
 if [ "$ENABLE_EMAIL_ALERTS" = "true" ]; then
 echo "$message" | mail -s "Disk Monitor Alert" $ALERT_EMAIL
 fi
 
 if [ "$ENABLE_SLACK_ALERTS" = "true" ]; then
 curl -X POST -H 'Content-type: application/json' --data "{\"text\":\"$message\"}" $SLACK_WEBHOOK
 fi
}

# 主监控循环
main_monitor() {
 log_message "Disk Monitor started"
 
 while true; do
 collect_disk_metrics
 collect_inode_metrics
 
 # 每天生成一次报告
 if [ $(date +%H) -eq 0 ] && [ $(date +%M) -eq 0 ]; then
 generate_monitor_report
 fi
 
 sleep $COLLECT_INTERVAL
 done
}

# 主函数
main() {
 case "$1" in
 monitor)
 main_monitor
 ;;
 analyze)
 analyze_disk_trend "$2" "$3"
 ;;
 report)
 generate_monitor_report
 ;;
 *)
 echo "Usage: $0 {monitor|analyze|report}"
 exit 1
 ;;
 esac
}

main "$@"

智能磁盘清理系统#

#!/bin/bash
# 智能磁盘清理系统

CONFIG_FILE="/etc/disk_cleaner/config.conf"
LOG_FILE="/var/log/disk_cleaner/cleaner.log"

mkdir -p $(dirname $LOG_FILE)

# 加载配置
source $CONFIG_FILE

# 清理临时文件
clean_temp_files() {
 local temp_dirs=("/tmp" "/var/tmp" "/var/cache")
 
 echo "Cleaning temporary files..."
 
 for dir in "${temp_dirs[@]}"; do
 if [ -d "$dir" ]; then
 local size_before=$(du -sh $dir 2>/dev/null | awk '{print $1}')
 
 find $dir -type f -mtime +${TEMP_FILE_AGE:-7} -delete 2>/dev/null
 
 local size_after=$(du -sh $dir 2>/dev/null | awk '{print $1}')
 
 echo " $dir: $size_before -> $size_after"
 log_message "Cleaned $dir: $size_before -> $size_after"
 fi
 done
}

# 清理日志文件
clean_log_files() {
 local log_dirs=("/var/log" "/var/log/journal")
 
 echo "Cleaning log files..."
 
 for dir in "${log_dirs[@]}"; do
 if [ -d "$dir" ]; then
 local size_before=$(du -sh $dir 2>/dev/null | awk '{print $1}')
 
 find $dir -type f -name "*.log" -mtime +${LOG_FILE_AGE:-30} -delete 2>/dev/null
 find $dir -type f -name "*.gz" -mtime +${LOG_FILE_AGE:-30} -delete 2>/dev/null
 
 local size_after=$(du -sh $dir 2>/dev/null | awk '{print $1}')
 
 echo " $dir: $size_before -> $size_after"
 log_message "Cleaned $dir: $size_before -> $size_after"
 fi
 done
}

# 清理包管理器缓存
clean_package_cache() {
 echo "Cleaning package manager cache..."
 
 if command -v apt-get &> /dev/null; then
 local size_before=$(du -sh /var/cache/apt 2>/dev/null | awk '{print $1}')
 
 apt-get clean
 apt-get autoremove -y
 
 local size_after=$(du -sh /var/cache/apt 2>/dev/null | awk '{print $1}')
 
 echo " APT cache: $size_before -> $size_after"
 log_message "Cleaned APT cache: $size_before -> $size_after"
 fi
 
 if command -v yum &> /dev/null; then
 local size_before=$(du -sh /var/cache/yum 2>/dev/null | awk '{print $1}')
 
 yum clean all
 
 local size_after=$(du -sh /var/cache/yum 2>/dev/null | awk '{print $1}')
 
 echo " YUM cache: $size_before -> $size_after"
 log_message "Cleaned YUM cache: $size_before -> $size_after"
 fi
}

# 清理旧备份
clean_old_backups() {
 local backup_dir=$1
 local retention_days=${2:-30}
 
 if [ -d "$backup_dir" ]; then
 echo "Cleaning old backups in $backup_dir..."
 
 local size_before=$(du -sh $backup_dir 2>/dev/null | awk '{print $1}')
 
 find $backup_dir -type f -mtime +$retention_days -delete 2>/dev/null
 
 local size_after=$(du -sh $backup_dir 2>/dev/null | awk '{print $1}')
 
 echo " $backup_dir: $size_before -> $size_after"
 log_message "Cleaned $backup_dir: $size_before -> $size_after"
 fi
}

# 清理用户缓存
clean_user_cache() {
 local users=$(ls /home)
 
 echo "Cleaning user caches..."
 
 for user in $users; do
 local user_cache="/home/$user/.cache"
 
 if [ -d "$user_cache" ]; then
 local size_before=$(du -sh $user_cache 2>/dev/null | awk '{print $1}')
 
 find $user_cache -type f -mtime +${USER_CACHE_AGE:-7} -delete 2>/dev/null
 
 local size_after=$(du -sh $user_cache 2>/dev/null | awk '{print $1}')
 
 echo " $user cache: $size_before -> $size_after"
 log_message "Cleaned $user cache: $size_before -> $size_after"
 fi
 done
}

# 智能清理
smart_clean() {
 local mount_point=$1
 local threshold=${2:-80}
 
 local usage=$(df -h $mount_point | awk 'NR==2 {print $5}' | cut -d'%' -f1)
 
 if [ $usage -gt $threshold ]; then
 echo "Disk usage high (${usage}%), starting smart clean..."
 log_message "Smart clean triggered for $mount_point: ${usage}%"
 
 clean_temp_files
 clean_log_files
 clean_package_cache
 clean_user_cache
 
 local new_usage=$(df -h $mount_point | awk 'NR==2 {print $5}' | cut -d'%' -f1)
 echo "Disk usage after clean: ${new_usage}%"
 log_message "Disk usage after clean: ${new_usage}%"
 else
 echo "Disk usage normal (${usage}%), no clean needed"
 fi
}

# 记录日志
log_message() {
 local message=$1
 local timestamp=$(date "+%Y-%m-%d %H:%M:%S")
 echo "[$timestamp] $message" >> $LOG_FILE
}

# 主函数
main() {
 case "$1" in
 temp)
 clean_temp_files
 ;;
 logs)
 clean_log_files
 ;;
 packages)
 clean_package_cache
 ;;
 backups)
 clean_old_backups "$2" "$3"
 ;;
 cache)
 clean_user_cache
 ;;
 smart)
 smart_clean "$2" "$3"
 ;;
 all)
 clean_temp_files
 clean_log_files
 clean_package_cache
 clean_user_cache
 ;;
 *)
 echo "Usage: $0 {temp|logs|packages|backups|cache|smart|all}"
 exit 1
 ;;
 esac
}

main "$@"

无敌#

磁盘空间预测系统#

#!/bin/bash
# 磁盘空间预测系统

METRICS_DB="/var/lib/disk_predictor/metrics.db"
PREDICTION_DIR="/var/lib/disk_predictor/predictions"

mkdir -p $(dirname $METRICS_DB) $PREDICTION_DIR

# 收集磁盘使用数据
collect_disk_data() {
 local mount_point=$1
 
 local timestamp=$(date +%s)
 local total=$(df -h $mount_point | awk 'NR==2 {print $2}')
 local used=$(df -h $mount_point | awk 'NR==2 {print $3}')
 local avail=$(df -h $mount_point | awk 'NR==2 {print $4}')
 local percent=$(df -h $mount_point | awk 'NR==2 {print $5}' | cut -d'%' -f1)
 
 local data_file="$METRICS_DB/${mount_point//\//_}.csv"
 
 echo "$timestamp,$total,$used,$avail,$percent" >> $data_file
}

# 预测磁盘空间
predict_disk_space() {
 local mount_point=$1
 local days=${2:-30}
 
 local data_file="$METRICS_DB/${mount_point//\//_}.csv"
 
 if [ ! -f "$data_file" ]; then
 echo "No data available for $mount_point"
 return 1
 fi
 
 echo "=== Disk Space Prediction for $mount_point ==="
 echo "Prediction period: $days days"
 echo ""
 
 # 计算平均增长率
 local current_usage=$(tail -1 $data_file | cut -d, -f5)
 local start_usage=$(head -1 $data_file | cut -d, -f5)
 local data_points=$(wc -l < $data_file)
 
 local growth_rate=$(echo "scale=2; ($current_usage - $start_usage) / $data_points" | bc)
 
 echo "Current usage: ${current_usage}%"
 echo "Average growth rate: ${growth_rate}% per data point"
 echo ""
 
 # 预测未来使用情况
 echo "Future predictions:"
 for ((i=1; i<=$days; i++)); do
 local predicted_usage=$(echo "scale=2; $current_usage + ($growth_rate * $i)" | bc)
 local future_date=$(date -d "+$i days" '+%Y-%m-%d')
 
 echo " $future_date: ${predicted_usage}%"
 
 if (( $(echo "$predicted_usage >= 100" | bc -l) )); then
 echo " ⚠️ WARNING: Disk will be full!"
 fi
 done
 
 # 保存预测结果
 local prediction_file="$PREDICTION_DIR/${mount_point//\//_}_$(date +%Y%m%d).txt"
 {
 echo "Disk Space Prediction - $(date)"
 echo "Mount point: $mount_point"
 echo "Prediction period: $days days"
 echo ""
 echo "Current usage: ${current_usage}%"
 echo "Average growth rate: ${growth_rate}% per data point"
 echo ""
 echo "Future predictions:"
 for ((i=1; i<=$days; i++)); do
 local predicted_usage=$(echo "scale=2; $current_usage + ($growth_rate * $i)" | bc)
 local future_date=$(date -d "+$i days" '+%Y-%m-%d')
 
 echo " $future_date: ${predicted_usage}%"
 done
 } > $prediction_file
 
 echo ""
 echo "Prediction saved to: $prediction_file"
}

# 分析磁盘使用趋势
analyze_disk_trend() {
 local mount_point=$1
 local days=${2:-7}
 
 local data_file="$METRICS_DB/${mount_point//\//_}.csv"
 
 if [ ! -f "$data_file" ]; then
 echo "No data available for $mount_point"
 return 1
 fi
 
 echo "=== Disk Usage Trend for $mount_point ==="
 echo "Last $days days"
 echo ""
 
 local end_time=$(date +%s)
 local start_time=$((end_time - (days * 86400)))
 
 tail -100 $data_file | awk -F, -v start=$start_time -v end=$end_time '$1 >= start && $1 <= end' | while read line; do
 local timestamp=$(echo $line | cut -d, -f1)
 local used=$(echo $line | cut -d, -f3)
 local percent=$(echo $line | cut -d, -f5)
 local formatted_time=$(date -d @$timestamp '+%Y-%m-%d %H:%M:%S')
 
 echo "$formatted_time - Used: $used (${percent}%)"
 done
}

# 生成预测报告
generate_prediction_report() {
 local report_file="$PREDICTION_DIR/prediction_report_$(date +%Y%m%d).txt"
 
 echo "Disk Space Prediction Report - $(date +%Y-%m-%d)" > $report_file
 echo "=================================" >> $report_file
 echo "" >> $report_file
 
 # 当前磁盘使用情况
 echo "=== Current Disk Usage ===" >> $report_file
 df -h >> $report_file
 echo "" >> $report_file
 
 # 预测结果
 echo "=== Predictions ===" >> $report_file
 for mount_point in $(df | awk 'NR>1 {print $6}'); do
 predict_disk_space $mount_point 30 >> $report_file
 echo "" >> $report_file
 done
 
 echo "Prediction report saved to: $report_file"
}

# 主函数
main() {
 case "$1" in
 collect)
 collect_disk_data "$2"
 ;;
 predict)
 predict_disk_space "$2" "$3"
 ;;
 trend)
 analyze_disk_trend "$2" "$3"
 ;;
 report)
 generate_prediction_report
 ;;
 *)
 echo "Usage: $0 {collect|predict|trend|report}"
 exit 1
 ;;
 esac
}

main "$@"

磁盘容量规划系统#

#!/bin/bash
# 磁盘容量规划系统

CONFIG_FILE="/etc/disk_planner/config.conf"
PLAN_DIR="/var/lib/disk_planner/plans"

mkdir -p $PLAN_DIR

# 加载配置
source $CONFIG_FILE

# 分析磁盘使用模式
analyze_usage_pattern() {
 local mount_point=$1
 local days=${2:-30}
 
 local data_file="/var/lib/disk_predictor/metrics/${mount_point//\//_}.csv"
 
 if [ ! -f "$data_file" ]; then
 echo "No data available for $mount_point"
 return 1
 fi
 
 echo "=== Usage Pattern Analysis for $mount_point ==="
 echo "Analysis period: $days days"
 echo ""
 
 # 计算统计信息
 local min_usage=$(awk -F, 'NR>1 {print $5}' $data_file | sort -n | head -1)
 local max_usage=$(awk -F, 'NR>1 {print $5}' $data_file | sort -n | tail -1)
 local avg_usage=$(awk -F, 'NR>1 {sum+=$5; count++} END {print sum/count}' $data_file)
 
 echo "Minimum usage: ${min_usage}%"
 echo "Maximum usage: ${max_usage}%"
 echo "Average usage: ${avg_usage}%"
 echo ""
 
 # 计算增长率
 local current_usage=$(tail -1 $data_file | cut -d, -f5)
 local start_usage=$(head -1 $data_file | cut -d, -f5)
 local data_points=$(wc -l < $data_file)
 
 local growth_rate=$(echo "scale=2; ($current_usage - $start_usage) / $data_points" | bc)
 echo "Growth rate: ${growth_rate}% per data point"
 echo ""
 
 # 预测何时达到 100%
 if (( $(echo "$growth_rate > 0" | bc -l) )); then
 local days_to_full=$(echo "scale=0; (100 - $current_usage) / $growth_rate" | bc)
 local full_date=$(date -d "+$days_to_full days" '+%Y-%m-%d')
 
 echo "Predicted to be full in: $days_to_full days ($full_date)"
 else
 echo "Usage is stable or decreasing"
 fi
}

# 生成容量规划建议
generate_capacity_recommendations() {
 local mount_point=$1
 
 local data_file="/var/lib/disk_predictor/metrics/${mount_point//\//_}.csv"
 
 if [ ! -f "$data_file" ]; then
 echo "No data available for $mount_point"
 return 1
 fi
 
 echo "=== Capacity Recommendations for $mount_point ==="
 echo ""
 
 local current_usage=$(tail -1 $data_file | cut -d, -f5)
 local growth_rate=$(awk -F, 'NR>1 {sum+=$5; count++} END {print (sum/count)}' $data_file)
 
 # 基于当前使用情况给出建议
 if [ $current_usage -lt 50 ]; then
 echo "✓ Current usage is low (${current_usage}%)"
 echo " No immediate action required"
 elif [ $current_usage -lt 70 ]; then
 echo "⚠️ Current usage is moderate (${current_usage}%)"
 echo " Consider monitoring more closely"
 echo " Plan for capacity expansion in 3-6 months"
 elif [ $current_usage -lt 85 ]; then
 echo "⚠️ Current usage is high (${current_usage}%)"
 echo " Immediate action recommended:"
 echo " 1. Clean up unnecessary files"
 echo " 2. Implement data archiving"
 echo " 3. Plan for capacity expansion in 1-3 months"
 else
 echo "🚨 Current usage is critical (${current_usage}%)"
 echo " Urgent action required:"
 echo " 1. Clean up unnecessary files immediately"
 echo " 2. Implement data archiving immediately"
 echo " 3. Plan for capacity expansion immediately"
 fi
 
 echo ""
 
 # 基于增长率给出建议
 local predicted_usage=$(echo "scale=2; $current_usage + ($growth_rate * 30)" | bc)
 
 echo "Predicted usage in 30 days: ${predicted_usage}%"
 
 if (( $(echo "$predicted_usage > 90" | bc -l) )); then
 echo "⚠️ Disk will reach critical levels in 30 days"
 echo " Consider immediate capacity expansion"
 fi
}

# 生成容量规划报告
generate_capacity_plan() {
 local report_file="$PLAN_DIR/capacity_plan_$(date +%Y%m%d).txt"
 
 echo "Disk Capacity Plan - $(date +%Y-%m-%d)" > $report_file
 echo "=====================" >> $report_file
 echo "" >> $report_file
 
 # 当前磁盘使用情况
 echo "=== Current Disk Usage ===" >> $report_file
 df -h >> $report_file
 echo "" >> $report_file
 
 # 使用模式分析
 echo "=== Usage Pattern Analysis ===" >> $report_file
 for mount_point in $(df | awk 'NR>1 {print $6}'); do
 analyze_usage_pattern $mount_point 30 >> $report_file
 echo "" >> $report_file
 done
 
 # 容量建议
 echo "=== Capacity Recommendations ===" >> $report_file
 for mount_point in $(df | awk 'NR>1 {print $6}'); do
 generate_capacity_recommendations $mount_point >> $report_file
 echo "" >> $report_file
 done
 
 # 行动计划
 echo "=== Action Plan ===" >> $report_file
 echo "Immediate actions (0-7 days):" >> $report_file
 echo "- Review and clean up unnecessary files" >> $report_file
 echo "- Implement log rotation policies" >> $report_file
 echo "" >> $report_file
 echo "Short-term actions (7-30 days):" >> $report_file
 echo "- Implement data archiving" >> $report_file
 echo "- Review and optimize storage usage" >> $report_file
 echo "" >> $report_file
 echo "Long-term actions (30+ days):" >> $report_file
 echo "- Plan for capacity expansion" >> $report_file
 echo "- Implement storage tiering" >> $report_file
 
 echo "Capacity plan saved to: $report_file"
}

# 主函数
main() {
 case "$1" in
 analyze)
 analyze_usage_pattern "$2" "$3"
 ;;
 recommend)
 generate_capacity_recommendations "$2"
 ;;
 plan)
 generate_capacity_plan
 ;;
 *)
 echo "Usage: $0 {analyze|recommend|plan}"
 exit 1
 ;;
 esac
}

main "$@"

最佳实践#

定期检查磁盘空间：定期使用 df 检查磁盘空间使用情况
设置告警阈值：设置合理的告警阈值，及时发现问题
监控 inode 使用：不仅监控磁盘空间，还要监控 inode 使用情况
分析使用趋势：分析磁盘使用趋势，预测未来需求
及时清理：及时清理不必要的文件，释放磁盘空间
规划容量：根据使用趋势规划磁盘容量
使用人类可读格式：使用 -h 选项以人类可读格式显示
记录监控数据：定期记录监控数据，便于分析趋势

注意事项#

df 显示的是文件系统的使用情况，不是物理磁盘的使用情况
虚拟文件系统（如 tmpfs）也会显示在 df 输出中
inode 耗尽也会导致无法创建新文件
不同文件系统的使用情况可能不同
磁盘空间使用率接近 100% 时会影响系统性能
定期清理日志文件和临时文件
在生产环境中删除文件时要格外小心
注意备份重要数据后再进行清理
对于关键业务，建议使用专业的磁盘管理工具

du 命令详解

Mon, 01 Jan 0001 00:00:00 +0000

du 命令详解#

du（Disk Usage）是 Linux 系统中用于显示文件和目录磁盘使用情况的命令。它可以递归地显示目录及其子目录的磁盘使用量，帮助用户找出占用大量磁盘空间的文件和目录，是系统管理员进行磁盘空间管理的重要工具。

入门#

基本用法#

# 显示当前目录的磁盘使用情况
du

# 以人类可读格式显示
du -h

# 显示特定目录
du /home

# 显示总大小
du -s

常用选项#

选项	说明
`-h`	以人类可读格式显示（KB、MB、GB）
`-s`	显示总计
`-a`	显示所有文件
`-c`	显示总计
`-d`	限制显示深度
`--max-depth`	限制显示深度

基本示例#

# 显示当前目录的磁盘使用情况
du

# 输出示例：
# 1024 ./dir1
# 2048 ./dir2
# 3072 .

# 以人类可读格式显示
du -h

# 输出示例：
# 1.0K ./dir1
# 2.0K ./dir2
# 3.0K .

# 显示特定目录
du -h /home

# 输出示例：
# 1.0G /home/user1
# 2.0G /home/user2
# 3.0G /home

中级#

目录大小分析#

# 显示目录总大小
du -sh /home

# 显示所有子目录大小
du -h --max-depth=1 /home

# 显示特定深度
du -h --max-depth=2 /home

# 显示所有文件和目录
du -ah /home

# 按大小排序
du -h --max-depth=1 /home | sort -hr

文件大小分析#

# 查找大文件
du -ah /home | sort -hr | head -10

# 查找特定大小的文件
du -ah /home | grep 'G'

# 查找大于 100MB 的文件
du -ah /home | grep '[0-9]\+M' | awk '$1 > 100'

# 查找特定类型的文件
du -ah /home | grep '\.log$'

# 查找特定目录中的文件
du -ah /home/user1 | sort -hr | head -10

高级筛选#

# 排除特定目录
du -h --exclude='*.log' /home

# 排除多个目录
du -h --exclude='*.log' --exclude='*.tmp' /home

# 只包含特定类型
du -h --include='*.txt' /home

# 显示 inode 使用情况
du -i /home

# 显示块数量
du -B 1M /home

高级#

高级选项#

# 显示实际使用空间
du --apparent-size /home

# 显示硬链接计数
du -l /home

# 显示符号链接
du -L /home

# 显示所有文件（包括隐藏文件）
du -ah /home

# 显示总计
du -ch /home

# 限制显示深度
du -h --max-depth=3 /home

磁盘使用分析脚本#

#!/bin/bash
# 磁盘使用分析脚本

DIRECTORY=$1
SIZE_THRESHOLD=${2:-100M}

# 分析目录使用情况
analyze_directory() {
 local directory=$1
 
 echo "=== Directory Analysis: $directory ==="
 echo ""
 
 # 总大小
 local total_size=$(du -sh $directory | awk '{print $1}')
 echo "Total size: $total_size"
 echo ""
 
 # 前 10 个最大的子目录
 echo "Top 10 largest subdirectories:"
 du -h --max-depth=1 $directory | sort -hr | head -11 | tail -10
 echo ""
 
 # 前 10 个最大的文件
 echo "Top 10 largest files:"
 find $directory -type f -exec du -h {} + | sort -hr | head -10
}

# 查找大文件
find_large_files() {
 local directory=$1
 local threshold=$2
 
 echo "=== Finding files larger than $threshold in $directory ==="
 
 find $directory -type f -size +$threshold -exec ls -lh {} \; | awk '{print $9, $5}'
}

# 查找特定类型的文件
find_files_by_type() {
 local directory=$1
 local extension=$2
 
 echo "=== Finding $extension files in $directory ==="
 
 find $directory -type f -name "*$extension" -exec du -h {} + | sort -hr | head -20
}

# 生成目录报告
generate_directory_report() {
 local directory=$1
 local report_file="directory_report_$(date +%Y%m%d_%H%M%S).txt"
 
 echo "Directory Report - $(date)" > $report_file
 echo "===================" >> $report_file
 echo "Directory: $directory" >> $report_file
 echo "" >> $report_file
 
 # 总大小
 echo "Total size:" >> $report_file
 du -sh $directory >> $report_file
 echo "" >> $report_file
 
 # 子目录大小
 echo "Subdirectory sizes:" >> $report_file
 du -h --max-depth=1 $directory | sort -hr >> $report_file
 echo "" >> $report_file
 
 # 文件统计
 echo "File statistics:" >> $report_file
 echo "Total files: $(find $directory -type f | wc -l)" >> $report_file
 echo "Total directories: $(find $directory -type d | wc -l)" >> $report_file
 echo "" >> $report_file
 
 # 最大的文件
 echo "Largest files:" >> $report_file
 find $directory -type f -exec du -h {} + | sort -hr | head -20 >> $report_file
 
 echo "Report saved to: $report_file"
}

# 主函数
main() {
 case "$1" in
 analyze)
 analyze_directory "$2"
 ;;
 large)
 find_large_files "$2" "$3"
 ;;
 type)
 find_files_by_type "$2" "$3"
 ;;
 report)
 generate_directory_report "$2"
 ;;
 *)
 echo "Usage: $0 {analyze|large|type|report}"
 exit 1
 ;;
 esac
}

main "$@"

磁盘清理工具#

#!/bin/bash
# 磁盘清理工具

DIRECTORY=$1

# 查找重复文件
find_duplicate_files() {
 local directory=$1
 
 echo "=== Finding duplicate files in $directory ==="
 
 find $directory -type f -exec md5sum {} + | sort | uniq -w 32 -d
}

# 查找空目录
find_empty_directories() {
 local directory=$1
 
 echo "=== Finding empty directories in $directory ==="
 
 find $directory -type d -empty
}

# 查找旧文件
find_old_files() {
 local directory=$1
 local days=$2
 
 echo "=== Finding files older than $days days in $directory ==="
 
 find $directory -type f -mtime +$days -exec ls -lh {} \;
}

# 清理日志文件
clean_log_files() {
 local directory=$1
 local days=${2:-30}
 
 echo "=== Cleaning log files older than $days days in $directory ==="
 
 local size_before=$(du -sh $directory | awk '{print $1}')
 
 find $directory -type f -name "*.log" -mtime +$days -delete
 
 local size_after=$(du -sh $directory | awk '{print $1}')
 
 echo "Size before: $size_before"
 echo "Size after: $size_after"
}

# 清理临时文件
clean_temp_files() {
 local directory=$1
 local days=${2:-7}
 
 echo "=== Cleaning temporary files older than $days days in $directory ==="
 
 local size_before=$(du -sh $directory | awk '{print $1}')
 
 find $directory -type f \( -name "*.tmp" -o -name "*.temp" \) -mtime +$days -delete
 
 local size_after=$(du -sh $directory | awk '{print $1}')
 
 echo "Size before: $size_before"
 echo "Size after: $size_after"
}

# 主函数
main() {
 case "$1" in
 duplicates)
 find_duplicate_files "$2"
 ;;
 empty)
 find_empty_directories "$2"
 ;;
 old)
 find_old_files "$2" "$3"
 ;;
 logs)
 clean_log_files "$2" "$3"
 ;;
 temp)
 clean_temp_files "$2" "$3"
 ;;
 *)
 echo "Usage: $0 {duplicates|empty|old|logs|temp}"
 exit 1
 ;;
 esac
}

main "$@"

大师#

企业级磁盘分析系统#

#!/bin/bash
# 企业级磁盘分析系统

CONFIG_FILE="/etc/disk_analyzer/config.conf"
LOG_DIR="/var/log/disk_analyzer"
ANALYSIS_DIR="/var/lib/disk_analyzer/analyses"

mkdir -p $LOG_DIR $ANALYSIS_DIR

# 加载配置
source $CONFIG_FILE

# 分析目录结构
analyze_directory_structure() {
 local directory=$1
 local output_dir="$ANALYSIS_DIR/structure_$(date +%Y%m%d_%H%M%S)"
 
 mkdir -p $output_dir
 
 echo "=== Directory Structure Analysis ===" > $output_dir/structure.txt
 echo "Directory: $directory" >> $output_dir/structure.txt
 echo "Analysis Time: $(date)" >> $output_dir/structure.txt
 echo "" >> $output_dir/structure.txt
 
 # 目录树
 echo "Directory Tree:" >> $output_dir/structure.txt
 tree -L 3 -h $directory >> $output_dir/structure.txt 2>/dev/null || find $directory -type d | head -100 >> $output_dir/structure.txt
 echo "" >> $output_dir/structure.txt
 
 # 目录大小分布
 echo "Directory Size Distribution:" >> $output_dir/structure.txt
 du -h --max-depth=1 $directory | sort -hr >> $output_dir/structure.txt
 echo "" >> $output_dir/structure.txt
 
 # 文件类型分布
 echo "File Type Distribution:" >> $output_dir/structure.txt
 find $directory -type f | sed 's/.*\.//' | sort | uniq -c | sort -rn | head -20 >> $output_dir/structure.txt
 
 echo "Analysis saved to: $output_dir/structure.txt"
}

# 分析文件分布
analyze_file_distribution() {
 local directory=$1
 local output_dir="$ANALYSIS_DIR/files_$(date +%Y%m%d_%H%M%S)"
 
 mkdir -p $output_dir
 
 echo "=== File Distribution Analysis ===" > $output_dir/files.txt
 echo "Directory: $directory" >> $output_dir/files.txt
 echo "Analysis Time: $(date)" >> $output_dir/files.txt
 echo "" >> $output_dir/files.txt
 
 # 文件大小分布
 echo "File Size Distribution:" >> $output_dir/files.txt
 find $directory -type f -exec du -h {} + | sort -hr | head -100 >> $output_dir/files.txt
 echo "" >> $output_dir/files.txt
 
 # 大文件
 echo "Large Files (>100MB):" >> $output_dir/files.txt
 find $directory -type f -size +100M -exec ls -lh {} \; | awk '{print $9, $5}' >> $output_dir/files.txt
 echo "" >> $output_dir/files.txt
 
 # 文件类型统计
 echo "File Type Statistics:" >> $output_dir/files.txt
 find $directory -type f | sed 's/.*\.//' | sort | uniq -c | sort -rn >> $output_dir/files.txt
 echo "" >> $output_dir/files.txt
 
 # 文件修改时间分布
 echo "File Modification Time Distribution:" >> $output_dir/files.txt
 echo "Files modified in last 7 days: $(find $directory -type f -mtime -7 | wc -l)" >> $output_dir/files.txt
 echo "Files modified in last 30 days: $(find $directory -type f -mtime -30 | wc -l)" >> $output_dir/files.txt
 echo "Files modified in last 90 days: $(find $directory -type f -mtime -90 | wc -l)" >> $output_dir/files.txt
 
 echo "Analysis saved to: $output_dir/files.txt"
}

# 分析磁盘增长
analyze_disk_growth() {
 local directory=$1
 local days=${2:-30}
 local output_file="$ANALYSIS_DIR/growth_${directory//\//_}_$(date +%Y%m%d).txt"
 
 echo "=== Disk Growth Analysis ===" > $output_file
 echo "Directory: $directory" >> $output_file
 echo "Analysis Period: $days days" >> $output_file
 echo "Analysis Time: $(date)" >> $output_file
 echo "" >> $output_file
 
 # 当前大小
 local current_size=$(du -sh $directory | awk '{print $1}')
 echo "Current size: $current_size" >> $output_file
 echo "" >> $output_file
 
 # 记录历史数据
 local history_file="$ANALYSIS_DIR/history_${directory//\//_}.txt"
 echo "$(date '+%Y-%m-%d %H:%M:%S'),$current_size" >> $history_file
 
 # 显示历史趋势
 if [ -f "$history_file" ]; then
 echo "Historical Data:" >> $output_file
 tail -10 $history_file >> $output_file
 fi
 
 echo "Analysis saved to: $output_file"
}

# 生成分析报告
generate_analysis_report() {
 local directory=$1
 local report_file="$ANALYSIS_DIR/analysis_report_$(date +%Y%m%d).txt"
 
 echo "Disk Analysis Report - $(date +%Y-%m-%d)" > $report_file
 echo "=======================" >> $report_file
 echo "Directory: $directory" >> $report_file
 echo "" >> $report_file
 
 # 目录结构
 echo "=== Directory Structure ===" >> $report_file
 du -h --max-depth=2 $directory | sort -hr >> $report_file
 echo "" >> $report_file
 
 # 文件分布
 echo "=== File Distribution ===" >> $report_file
 find $directory -type f -exec du -h {} + | sort -hr | head -50 >> $report_file
 echo "" >> $report_file
 
 # 文件类型
 echo "=== File Types ===" >> $report_file
 find $directory -type f | sed 's/.*\.//' | sort | uniq -c | sort -rn | head -20 >> $report_file
 echo "" >> $report_file
 
 # 统计信息
 echo "=== Statistics ===" >> $report_file
 echo "Total files: $(find $directory -type f | wc -l)" >> $report_file
 echo "Total directories: $(find $directory -type d | wc -l)" >> $report_file
 echo "Total size: $(du -sh $directory | awk '{print $1}')" >> $report_file
 
 echo "Report saved to: $report_file"
}

# 主函数
main() {
 case "$1" in
 structure)
 analyze_directory_structure "$2"
 ;;
 files)
 analyze_file_distribution "$2"
 ;;
 growth)
 analyze_disk_growth "$2" "$3"
 ;;
 report)
 generate_analysis_report "$2"
 ;;
 *)
 echo "Usage: $0 {structure|files|growth|report}"
 exit 1
 ;;
 esac
}

main "$@"

智能磁盘清理系统#

#!/bin/bash
# 智能磁盘清理系统

CONFIG_FILE="/etc/disk_cleaner/config.conf"
LOG_FILE="/var/log/disk_cleaner/cleaner.log"

mkdir -p $(dirname $LOG_FILE)

# 加载配置
source $CONFIG_FILE

# 智能清理
smart_clean() {
 local directory=$1
 local threshold=${2:-80}
 
 local usage=$(df -h $directory | awk 'NR==2 {print $5}' | cut -d'%' -f1)
 
 if [ $usage -gt $threshold ]; then
 echo "Disk usage high (${usage}%), starting smart clean..."
 log_message "Smart clean triggered for $directory: ${usage}%"
 
 # 清理日志文件
 clean_logs $directory
 
 # 清理临时文件
 clean_temp $directory
 
 # 清理缓存文件
 clean_cache $directory
 
 # 清理备份文件
 clean_backups $directory
 
 local new_usage=$(df -h $directory | awk 'NR==2 {print $5}' | cut -d'%' -f1)
 echo "Disk usage after clean: ${new_usage}%"
 log_message "Disk usage after clean: ${new_usage}%"
 else
 echo "Disk usage normal (${usage}%), no clean needed"
 fi
}

# 清理日志文件
clean_logs() {
 local directory=$1
 local days=${LOG_RETENTION_DAYS:-30}
 
 echo "Cleaning log files older than $days days..."
 
 local size_before=$(du -sh $directory | awk '{print $1}')
 
 find $directory -type f -name "*.log" -mtime +$days -delete 2>/dev/null
 find $directory -type f -name "*.log.*" -mtime +$days -delete 2>/dev/null
 
 local size_after=$(du -sh $directory | awk '{print $1}')
 
 echo " Logs cleaned: $size_before -> $size_after"
 log_message "Logs cleaned in $directory: $size_before -> $size_after"
}

# 清理临时文件
clean_temp() {
 local directory=$1
 local days=${TEMP_RETENTION_DAYS:-7}
 
 echo "Cleaning temporary files older than $days days..."
 
 local size_before=$(du -sh $directory | awk '{print $1}')
 
 find $directory -type f \( -name "*.tmp" -o -name "*.temp" -o -name "*.swp" \) -mtime +$days -delete 2>/dev/null
 
 local size_after=$(du -sh $directory | awk '{print $1}')
 
 echo " Temp files cleaned: $size_before -> $size_after"
 log_message "Temp files cleaned in $directory: $size_before -> $size_after"
}

# 清理缓存文件
clean_cache() {
 local directory=$1
 local days=${CACHE_RETENTION_DAYS:-7}
 
 echo "Cleaning cache files older than $days days..."
 
 local size_before=$(du -sh $directory | awk '{print $1}')
 
 find $directory -type f -name "*.cache" -mtime +$days -delete 2>/dev/null
 find $directory -type d -name "cache" -mtime +$days -exec rm -rf {} + 2>/dev/null
 
 local size_after=$(du -sh $directory | awk '{print $1}')
 
 echo " Cache files cleaned: $size_before -> $size_after"
 log_message "Cache files cleaned in $directory: $size_before -> $size_after"
}

# 清理备份文件
clean_backups() {
 local directory=$1
 local days=${BACKUP_RETENTION_DAYS:-30}
 
 echo "Cleaning backup files older than $days days..."
 
 local size_before=$(du -sh $directory | awk '{print $1}')
 
 find $directory -type f \( -name "*.bak" -o -name "*.backup" -o -name "*~" \) -mtime +$days -delete 2>/dev/null
 
 local size_after=$(du -sh $directory | awk '{print $1}')
 
 echo " Backup files cleaned: $size_before -> $size_after"
 log_message "Backup files cleaned in $directory: $size_before -> $size_after"
}

# 查找并清理大文件
clean_large_files() {
 local directory=$1
 local size=${2:-100M}
 
 echo "Finding and cleaning files larger than $size..."
 
 local large_files=$(find $directory -type f -size +$size)
 
 if [ -n "$large_files" ]; then
 echo "Found large files:"
 echo "$large_files" | while read file; do
 ls -lh "$file" | awk '{print $9, $5}'
 done
 
 read -p "Delete these files? (y/n) " -n 1 -r
 echo
 
 if [[ $REPLY =~ ^[Yy]$ ]]; then
 local size_before=$(du -sh $directory | awk '{print $1}')
 
 echo "$large_files" | while read file; do
 rm -f "$file"
 echo " Deleted: $file"
 done
 
 local size_after=$(du -sh $directory | awk '{print $1}')
 
 echo " Large files cleaned: $size_before -> $size_after"
 log_message "Large files cleaned in $directory: $size_before -> $size_after"
 fi
 else
 echo "No files larger than $size found"
 fi
}

# 查找并清理重复文件
clean_duplicate_files() {
 local directory=$1
 
 echo "Finding duplicate files in $directory..."
 
 local duplicates=$(find $directory -type f -exec md5sum {} + | sort | uniq -w 32 -d)
 
 if [ -n "$duplicates" ]; then
 echo "Found duplicate files:"
 echo "$duplicates"
 
 read -p "Delete duplicate files? (y/n) " -n 1 -r
 echo
 
 if [[ $REPLY =~ ^[Yy]$ ]]; then
 local size_before=$(du -sh $directory | awk '{print $1}')
 
 echo "$duplicates" | awk '{print $2}' | while read file; do
 rm -f "$file"
 echo " Deleted: $file"
 done
 
 local size_after=$(du -sh $directory | awk '{print $1}')
 
 echo " Duplicate files cleaned: $size_before -> $size_after"
 log_message "Duplicate files cleaned in $directory: $size_before -> $size_after"
 fi
 else
 echo "No duplicate files found"
 fi
}

# 记录日志
log_message() {
 local message=$1
 local timestamp=$(date "+%Y-%m-%d %H:%M:%S")
 echo "[$timestamp] $message" >> $LOG_FILE
}

# 主函数
main() {
 case "$1" in
 smart)
 smart_clean "$2" "$3"
 ;;
 logs)
 clean_logs "$2"
 ;;
 temp)
 clean_temp "$2"
 ;;
 cache)
 clean_cache "$2"
 ;;
 backups)
 clean_backups "$2"
 ;;
 large)
 clean_large_files "$2" "$3"
 ;;
 duplicates)
 clean_duplicate_files "$2"
 ;;
 *)
 echo "Usage: $0 {smart|logs|temp|cache|backups|large|duplicates}"
 exit 1
 ;;
 esac
}

main "$@"

无敌#

磁盘空间优化系统#

#!/bin/bash
# 磁盘空间优化系统

CONFIG_FILE="/etc/disk_optimizer/config.conf"
LOG_DIR="/var/log/disk_optimizer"
OPTIMIZATION_DIR="/var/lib/disk_optimizer"

mkdir -p $LOG_DIR $OPTIMIZATION_DIR

# 加载配置
source $CONFIG_FILE

# 分析磁盘使用模式
analyze_usage_pattern() {
 local directory=$1
 local output_file="$OPTIMIZATION_DIR/usage_pattern_${directory//\//_}_$(date +%Y%m%d).txt"
 
 echo "=== Usage Pattern Analysis ===" > $output_file
 echo "Directory: $directory" >> $output_file
 echo "Analysis Time: $(date)" >> $output_file
 echo "" >> $output_file
 
 # 文件大小分布
 echo "File Size Distribution:" >> $output_file
 find $directory -type f -exec du -h {} + | awk '{print $1}' | sort | uniq -c | sort -rn >> $output_file
 echo "" >> $output_file
 
 # 文件类型分布
 echo "File Type Distribution:" >> $output_file
 find $directory -type f | sed 's/.*\.//' | sort | uniq -c | sort -rn >> $output_file
 echo "" >> $output_file
 
 # 文件修改时间分布
 echo "File Modification Time Distribution:" >> $output_file
 echo "Files modified in last 7 days: $(find $directory -type f -mtime -7 | wc -l)" >> $output_file
 echo "Files modified in last 30 days: $(find $directory -type f -mtime -30 | wc -l)" >> $output_file
 echo "Files modified in last 90 days: $(find $directory -type f -mtime -90 | wc -l)" >> $output_file
 echo "Files older than 90 days: $(find $directory -type f -mtime +90 | wc -l)" >> $output_file
 echo "" >> $output_file
 
 # 目录深度分析
 echo "Directory Depth Analysis:" >> $output_file
 find $directory -type d | while read dir; do
 local depth=$(echo $dir | tr -cd '/' | wc -c)
 echo "$depth: $dir"
 done | sort -rn | head -20 >> $output_file
 
 echo "Analysis saved to: $output_file"
}

# 生成优化建议
generate_optimization_recommendations() {
 local directory=$1
 local output_file="$OPTIMIZATION_DIR/optimization_recommendations_${directory//\//_}_$(date +%Y%m%d).txt"
 
 echo "=== Optimization Recommendations ===" > $output_file
 echo "Directory: $directory" >> $output_file
 echo "Analysis Time: $(date)" >> $output_file
 echo "" >> $output_file
 
 # 检查大文件
 local large_files=$(find $directory -type f -size +100M | wc -l)
 if [ $large_files -gt 0 ]; then
 echo "⚠️ Found $large_files large files (>100MB)" >> $output_file
 echo " Consider archiving or compressing these files" >> $output_file
 echo "" >> $output_file
 fi
 
 # 检查旧文件
 local old_files=$(find $directory -type f -mtime +365 | wc -l)
 if [ $old_files -gt 0 ]; then
 echo "⚠️ Found $old_files old files (>1 year)" >> $output_file
 echo " Consider archiving or deleting these files" >> $output_file
 echo "" >> $output_file
 fi
 
 # 检查重复文件
 local duplicate_files=$(find $directory -type f -exec md5sum {} + | sort | uniq -w 32 -d | wc -l)
 if [ $duplicate_files -gt 0 ]; then
 echo "⚠️ Found $duplicate_files duplicate files" >> $output_file
 echo " Consider removing duplicate files" >> $output_file
 echo "" >> $output_file
 fi
 
 # 检查临时文件
 local temp_files=$(find $directory -type f \( -name "*.tmp" -o -name "*.temp" \) | wc -l)
 if [ $temp_files -gt 0 ]; then
 echo "⚠️ Found $temp_files temporary files" >> $output_file
 echo " Consider cleaning temporary files regularly" >> $output_file
 echo "" >> $output_file
 fi
 
 # 检查日志文件
 local log_files=$(find $directory -type f -name "*.log" | wc -l)
 if [ $log_files -gt 0 ]; then
 echo "⚠️ Found $log_files log files" >> $output_file
 echo " Consider implementing log rotation" >> $output_file
 echo "" >> $output_file
 fi
 
 # 检查备份文件
 local backup_files=$(find $directory -type f \( -name "*.bak" -o -name "*.backup" \) | wc -l)
 if [ $backup_files -gt 0 ]; then
 echo "⚠️ Found $backup_files backup files" >> $output_file
 echo " Consider implementing backup retention policy" >> $output_file
 echo "" >> $output_file
 fi
 
 # 优化建议
 echo "=== Optimization Suggestions ===" >> $output_file
 echo "1. Implement regular cleanup schedules" >> $output_file
 echo "2. Use compression for large files" >> $output_file
 echo "3. Implement data archiving policies" >> $output_file
 echo "4. Use deduplication for duplicate files" >> $output_file
 echo "5. Implement log rotation" >> $output_file
 echo "6. Use disk quotas to prevent excessive usage" >> $output_file
 
 echo "Recommendations saved to: $output_file"
}

# 执行优化
perform_optimization() {
 local directory=$1
 
 echo "=== Performing Optimization for $directory ==="
 
 # 压缩大文件
 echo "Compressing large files..."
 find $directory -type f -size +100M ! -name "*.gz" ! -name "*.zip" -exec gzip {} \;
 
 # 清理临时文件
 echo "Cleaning temporary files..."
 find $directory -type f \( -name "*.tmp" -o -name "*.temp" \) -mtime +7 -delete
 
 # 清理旧文件
 echo "Cleaning old files..."
 find $directory -type f -mtime +365 -delete
 
 # 清理重复文件
 echo "Cleaning duplicate files..."
 find $directory -type f -exec md5sum {} + | sort | uniq -w 32 -d | awk '{print $2}' | xargs rm -f
 
 # 显示优化结果
 local size_before=$(cat $OPTIMIZATION_DIR/size_before_${directory//\//_}.txt 2>/dev/null || echo "N/A")
 local size_after=$(du -sh $directory | awk '{print $1}')
 
 echo "Optimization completed"
 echo "Size before: $size_before"
 echo "Size after: $size_after"
}

# 生成优化报告
generate_optimization_report() {
 local directory=$1
 local report_file="$OPTIMIZATION_DIR/optimization_report_$(date +%Y%m%d).txt"
 
 echo "Disk Optimization Report - $(date +%Y-%m-%d)" > $report_file
 echo "=========================" >> $report_file
 echo "Directory: $directory" >> $report_file
 echo "" >> $report_file
 
 # 当前使用情况
 echo "=== Current Usage ===" >> $report_file
 du -sh $directory >> $report_file
 echo "" >> $report_file
 
 # 使用模式分析
 echo "=== Usage Pattern ===" >> $report_file
 analyze_usage_pattern $directory >> $report_file
 echo "" >> $report_file
 
 # 优化建议
 echo "=== Optimization Recommendations ===" >> $report_file
 generate_optimization_recommendations $directory >> $report_file
 
 echo "Report saved to: $report_file"
}

# 主函数
main() {
 case "$1" in
 analyze)
 analyze_usage_pattern "$2"
 ;;
 recommend)
 generate_optimization_recommendations "$2"
 ;;
 optimize)
 perform_optimization "$2"
 ;;
 report)
 generate_optimization_report "$2"
 ;;
 *)
 echo "Usage: $0 {analyze|recommend|optimize|report}"
 exit 1
 ;;
 esac
}

main "$@"

磁盘空间预测系统#

#!/bin/bash
# 磁盘空间预测系统

METRICS_DB="/var/lib/disk_predictor/metrics.db"
PREDICTION_DIR="/var/lib/disk_predictor/predictions"

mkdir -p $(dirname $METRICS_DB) $PREDICTION_DIR

# 收集磁盘使用数据
collect_disk_data() {
 local directory=$1
 
 local timestamp=$(date +%s)
 local total_size=$(du -s $directory | awk '{print $1}')
 local file_count=$(find $directory -type f | wc -l)
 local dir_count=$(find $directory -type d | wc -l)
 
 local data_file="$METRICS_DB/${directory//\//_}.csv"
 
 echo "$timestamp,$total_size,$file_count,$dir_count" >> $data_file
}

# 预测磁盘使用
predict_disk_usage() {
 local directory=$1
 local days=${2:-30}
 
 local data_file="$METRICS_DB/${directory//\//_}.csv"
 
 if [ ! -f "$data_file" ]; then
 echo "No data available for $directory"
 return 1
 fi
 
 echo "=== Disk Usage Prediction for $directory ==="
 echo "Prediction period: $days days"
 echo ""
 
 # 计算平均增长率
 local current_size=$(tail -1 $data_file | cut -d, -f2)
 local start_size=$(head -1 $data_file | cut -d, -f2)
 local data_points=$(wc -l < $data_file)
 
 local growth_rate=$(echo "scale=2; ($current_size - $start_size) / $data_points" | bc)
 
 echo "Current size: $current_size KB"
 echo "Average growth rate: $growth_rate KB per data point"
 echo ""
 
 # 预测未来使用情况
 echo "Future predictions:"
 for ((i=1; i<=$days; i++)); do
 local predicted_size=$(echo "scale=2; $current_size + ($growth_rate * $i)" | bc)
 local predicted_size_mb=$(echo "scale=2; $predicted_size / 1024" | bc)
 local future_date=$(date -d "+$i days" '+%Y-%m-%d')
 
 echo " $future_date: ${predicted_size_mb} MB"
 done
 
 # 保存预测结果
 local prediction_file="$PREDICTION_DIR/${directory//\//_}_$(date +%Y%m%d).txt"
 {
 echo "Disk Usage Prediction - $(date)"
 echo "Directory: $directory"
 echo "Prediction period: $days days"
 echo ""
 echo "Current size: $current_size KB"
 echo "Average growth rate: $growth_rate KB per data point"
 echo ""
 echo "Future predictions:"
 for ((i=1; i<=$days; i++)); do
 local predicted_size=$(echo "scale=2; $current_size + ($growth_rate * $i)" | bc)
 local predicted_size_mb=$(echo "scale=2; $predicted_size / 1024" | bc)
 local future_date=$(date -d "+$i days" '+%Y-%m-%d')
 
 echo " $future_date: ${predicted_size_mb} MB"
 done
 } > $prediction_file
 
 echo ""
 echo "Prediction saved to: $prediction_file"
}

# 分析磁盘使用趋势
analyze_disk_trend() {
 local directory=$1
 local days=${2:-7}
 
 local data_file="$METRICS_DB/${directory//\//_}.csv"
 
 if [ ! -f "$data_file" ]; then
 echo "No data available for $directory"
 return 1
 fi
 
 echo "=== Disk Usage Trend for $directory ==="
 echo "Last $days days"
 echo ""
 
 local end_time=$(date +%s)
 local start_time=$((end_time - (days * 86400)))
 
 tail -100 $data_file | awk -F, -v start=$start_time -v end=$end_time '$1 >= start && $1 <= end' | while read line; do
 local timestamp=$(echo $line | cut -d, -f1)
 local size=$(echo $line | cut -d, -f2)
 local size_mb=$(echo "scale=2; $size / 1024" | bc)
 local formatted_time=$(date -d @$timestamp '+%Y-%m-%d %H:%M:%S')
 
 echo "$formatted_time - Size: ${size_mb} MB"
 done
}

# 生成预测报告
generate_prediction_report() {
 local report_file="$PREDICTION_DIR/prediction_report_$(date +%Y%m%d).txt"
 
 echo "Disk Usage Prediction Report - $(date +%Y-%m-%d)" > $report_file
 echo "=============================" >> $report_file
 echo "" >> $report_file
 
 # 当前磁盘使用情况
 echo "=== Current Disk Usage ===" >> $report_file
 du -sh * 2>/dev/null | sort -hr >> $report_file
 echo "" >> $report_file
 
 # 预测结果
 echo "=== Predictions ===" >> $report_file
 for directory in $(ls -d */ 2>/dev/null | cut -d'/' -f1); do
 predict_disk_usage $directory 30 >> $report_file
 echo "" >> $report_file
 done
 
 echo "Prediction report saved to: $report_file"
}

# 主函数
main() {
 case "$1" in
 collect)
 collect_disk_data "$2"
 ;;
 predict)
 predict_disk_usage "$2" "$3"
 ;;
 trend)
 analyze_disk_trend "$2" "$3"
 ;;
 report)
 generate_prediction_report
 ;;
 *)
 echo "Usage: $0 {collect|predict|trend|report}"
 exit 1
 ;;
 esac
}

main "$@"

最佳实践#

使用人类可读格式：使用 -h 选项以人类可读格式显示
限制显示深度：使用 –max-depth 选项限制显示深度
按大小排序：结合 sort -hr 按大小排序
定期分析磁盘使用：定期使用 du 分析磁盘使用情况
查找大文件：使用 find 和 du 组合查找大文件
清理不必要的文件：定期清理日志、临时文件等
监控磁盘增长：监控磁盘使用趋势，预测未来需求
使用排除选项：使用 –exclude 排除不需要的文件

注意事项#

du 显示的是磁盘使用量，不是文件大小
硬链接的文件只计算一次
符号链接默认不计算，使用 -L 选项计算
不同文件系统的 du 结果可能不同
du 需要遍历整个目录树，可能需要较长时间
在大型目录上运行 du 可能会消耗较多资源
注意权限问题，某些文件可能无法访问
在生产环境中删除文件时要格外小心
对于关键业务，建议使用专业的磁盘管理工具

free 命令详解

Mon, 01 Jan 0001 00:00:00 +0000

free 命令详解#

free 是 Linux 系统中用于显示内存使用情况的命令。它可以显示系统内存和交换空间的总量、已用量、可用量和使用百分比，是系统管理员和开发人员进行内存管理的重要工具。

入门#

基本用法#

# 显示内存使用情况
free

# 以人类可读格式显示
free -h

# 显示特定单位
free -m

# 持续显示
free -s 5

常用选项#

选项	说明
`-h`	以人类可读格式显示（KB、MB、GB）
`-b`	以字节为单位显示
`-k`	以 KB 为单位显示（默认）
`-m`	以 MB 为单位显示
`-g`	以 GB 为单位显示
`-s`	持续显示，指定间隔秒数
`-c`	指定显示次数

基本示例#

# 显示内存使用情况
free

# 输出示例：
# total used free shared buff/cache available
# Mem: 8192000 4096000 2048000 512000 2048000 3072000
# Swap: 2048000 0 2048000

# 以人类可读格式显示
free -h

# 输出示例：
# total used free shared buff/cache available
# Mem: 7.8G 3.9G 2.0G 500M 2.0G 2.9G
# Swap: 2.0G 0B 2.0G

中级#

内存监控#

# 以 MB 为单位显示
free -m

# 以 GB 为单位显示
free -g

# 持续显示（每 5 秒更新一次）
free -s 5

# 显示 10 次
free -c 10

# 组合使用
free -h -s 5 -c 10

内存分析#

# 显示详细信息
free -h -w

# 显示低内存信息
free -l

# 显示总计
free -t

# 显示旧格式
free -o

# 显示宽格式
free -w

交换空间监控#

# 显示交换空间使用情况
free -h | grep Swap

# 监控交换空间使用
watch -n 5 'free -h | grep Swap'

# 检查交换空间是否在使用
free -h | awk '/Swap/ {print $3}'

高级#

高级选项#

# 显示总计
free -h -t

# 显示宽格式
free -h -w

# 显示低内存信息
free -h -l

# 显示旧格式
free -h -o

# 持续监控
free -h -s 1 -c 60

内存监控脚本#

#!/bin/bash
# 内存监控脚本

ALERT_THRESHOLD=80
ALERT_EMAIL="admin@example.com"

# 检查内存使用
check_memory_usage() {
 local threshold=$1
 
 local mem_total=$(free -m | awk '/Mem:/ {print $2}')
 local mem_used=$(free -m | awk '/Mem:/ {print $3}')
 local mem_percent=$(echo "scale=2; $mem_used * 100 / $mem_total" | bc)
 
 echo "Memory usage: ${mem_percent}%"
 
 if (( $(echo "$mem_percent > $threshold" | bc -l) )); then
 echo "ALERT: Memory usage high: ${mem_percent}%"
 echo "Memory usage high: ${mem_percent}%" | mail -s "Memory Alert" $ALERT_EMAIL
 return 1
 else
 return 0
 fi
}

# 检查交换空间使用
check_swap_usage() {
 local threshold=$1
 
 local swap_total=$(free -m | awk '/Swap:/ {print $2}')
 local swap_used=$(free -m | awk '/Swap:/ {print $3}')
 
 if [ $swap_total -eq 0 ]; then
 echo "No swap space configured"
 return 0
 fi
 
 local swap_percent=$(echo "scale=2; $swap_used * 100 / $swap_total" | bc)
 
 echo "Swap usage: ${swap_percent}%"
 
 if (( $(echo "$swap_percent > $threshold" | bc -l) )); then
 echo "ALERT: Swap usage high: ${swap_percent}%"
 echo "Swap usage high: ${swap_percent}%" | mail -s "Swap Alert" $ALERT_EMAIL
 return 1
 else
 return 0
 fi
}

# 生成内存报告
generate_memory_report() {
 local report_file="memory_report_$(date +%Y%m%d_%H%M%S).txt"
 
 echo "Memory Report - $(date)" > $report_file
 echo "===============" >> $report_file
 echo "" >> $report_file
 
 # 内存使用情况
 echo "=== Memory Usage ===" >> $report_file
 free -h >> $report_file
 echo "" >> $report_file
 
 # 详细信息
 echo "=== Detailed Memory Info ===" >> $report_file
 free -h -w >> $report_file
 echo "" >> $report_file
 
 # 总计
 echo "=== Total Memory ===" >> $report_file
 free -h -t >> $report_file
 
 echo "Report saved to: $report_file"
}

# 主函数
main() {
 case "$1" in
 check)
 check_memory_usage "$2"
 ;;
 swap)
 check_swap_usage "$2"
 ;;
 report)
 generate_memory_report
 ;;
 *)
 echo "Usage: $0 {check|swap|report}"
 exit 1
 ;;
 esac
}

main "$@"

内存分析工具#

#!/bin/bash
# 内存分析工具

# 分析内存使用
analyze_memory() {
 echo "=== Memory Analysis ==="
 echo ""
 
 # 总内存
 local mem_total=$(free -m | awk '/Mem:/ {print $2}')
 echo "Total memory: ${mem_total} MB"
 
 # 已用内存
 local mem_used=$(free -m | awk '/Mem:/ {print $3}')
 echo "Used memory: ${mem_used} MB"
 
 # 可用内存
 local mem_avail=$(free -m | awk '/Mem:/ {print $7}')
 echo "Available memory: ${mem_avail} MB"
 
 # 缓存内存
 local mem_cache=$(free -m | awk '/Mem:/ {print $6}')
 echo "Cached memory: ${mem_cache} MB"
 
 # 共享内存
 local mem_shared=$(free -m | awk '/Mem:/ {print $5}')
 echo "Shared memory: ${mem_shared} MB"
 
 # 使用百分比
 local mem_percent=$(echo "scale=2; $mem_used * 100 / $mem_total" | bc)
 echo "Memory usage: ${mem_percent}%"
}

# 分析交换空间
analyze_swap() {
 echo "=== Swap Analysis ==="
 echo ""
 
 # 总交换空间
 local swap_total=$(free -m | awk '/Swap:/ {print $2}')
 
 if [ $swap_total -eq 0 ]; then
 echo "No swap space configured"
 return
 fi
 
 echo "Total swap: ${swap_total} MB"
 
 # 已用交换空间
 local swap_used=$(free -m | awk '/Swap:/ {print $3}')
 echo "Used swap: ${swap_used} MB"
 
 # 可用交换空间
 local swap_free=$(free -m | awk '/Swap:/ {print $4}')
 echo "Free swap: ${swap_free} MB"
 
 # 使用百分比
 local swap_percent=$(echo "scale=2; $swap_used * 100 / $swap_total" | bc)
 echo "Swap usage: ${swap_percent}%"
}

# 查找高内存使用进程
find_high_memory_processes() {
 local threshold=${1:-5}
 
 echo "=== High Memory Processes (> ${threshold}%) ==="
 ps -eo pid,user,%mem,cmd --sort=-%mem | awk -v threshold=$threshold 'NR>1 && $3 > threshold {print $0}'
}

# 主函数
main() {
 case "$1" in
 analyze)
 analyze_memory
 ;;
 swap)
 analyze_swap
 ;;
 processes)
 find_high_memory_processes "$2"
 ;;
 *)
 echo "Usage: $0 {analyze|swap|processes}"
 exit 1
 ;;
 esac
}

main "$@"

大师#

企业级内存监控系统#

#!/bin/bash
# 企业级内存监控系统

CONFIG_FILE="/etc/memory_monitor/config.conf"
LOG_DIR="/var/log/memory_monitor"
METRICS_DB="/var/lib/memory_monitor/metrics.db"

mkdir -p $LOG_DIR $(dirname $METRICS_DB)

# 加载配置
source $CONFIG_FILE

# 收集内存指标
collect_memory_metrics() {
 local timestamp=$(date +%s)
 
 # 内存使用率
 local mem_total=$(free -m | awk '/Mem:/ {print $2}')
 local mem_used=$(free -m | awk '/Mem:/ {print $3}')
 local mem_percent=$(echo "scale=2; $mem_used * 100 / $mem_total" | bc)
 
 # 交换空间使用率
 local swap_total=$(free -m | awk '/Swap:/ {print $2}')
 local swap_used=$(free -m | awk '/Swap:/ {print $3}')
 local swap_percent=0
 
 if [ $swap_total -gt 0 ]; then
 swap_percent=$(echo "scale=2; $swap_used * 100 / $swap_total" | bc)
 fi
 
 # 保存到数据库
 echo "$timestamp,memory,$mem_percent,$mem_used,$mem_total" >> $METRICS_DB
 echo "$timestamp,swap,$swap_percent,$swap_used,$swap_total" >> $METRICS_DB
 
 # 检查告警阈值
 if (( $(echo "$mem_percent > $MEMORY_ALERT_THRESHOLD" | bc -l) )); then
 log_message "ALERT: Memory usage high: ${mem_percent}%"
 send_alert "Memory usage high: ${mem_percent}%"
 fi
 
 if (( $(echo "$swap_percent > $SWAP_ALERT_THRESHOLD" | bc -l) )); then
 log_message "ALERT: Swap usage high: ${swap_percent}%"
 send_alert "Swap usage high: ${swap_percent}%"
 fi
}

# 分析内存趋势
analyze_memory_trend() {
 local duration=$1
 
 local end_time=$(date +%s)
 local start_time=$((end_time - duration))
 
 echo "=== Memory Trend Analysis (last $duration seconds) ==="
 echo ""
 
 # 内存趋势
 echo "Memory Usage Trend:"
 grep ",memory," $METRICS_DB | awk -F, -v start=$start_time -v end=$end_time '$1 >= start && $1 <= end' | while read line; do
 local timestamp=$(echo $line | cut -d, -f1)
 local percent=$(echo $line | cut -d, -f3)
 local used=$(echo $line | cut -d, -f4)
 local formatted_time=$(date -d @$timestamp '+%Y-%m-%d %H:%M:%S')
 
 echo "$formatted_time: ${percent}% (${used} MB)"
 done
 
 echo ""
 
 # 交换空间趋势
 echo "Swap Usage Trend:"
 grep ",swap," $METRICS_DB | awk -F, -v start=$start_time -v end=$end_time '$1 >= start && $1 <= end' | while read line; do
 local timestamp=$(echo $line | cut -d, -f1)
 local percent=$(echo $line | cut -d, -f3)
 local used=$(echo $line | cut -d, -f4)
 local formatted_time=$(date -d @$timestamp '+%Y-%m-%d %H:%M:%S')
 
 echo "$formatted_time: ${percent}% (${used} MB)"
 done
}

# 生成监控报告
generate_monitor_report() {
 local report_file="$LOG_DIR/monitor_report_$(date +%Y%m%d).txt"
 
 echo "Memory Monitor Report - $(date +%Y-%m-%d)" > $report_file
 echo "=====================" >> $report_file
 echo "" >> $report_file
 
 # 当前内存使用情况
 echo "=== Current Memory Usage ===" >> $report_file
 free -h >> $report_file
 echo "" >> $report_file
 
 # 详细信息
 echo "=== Detailed Memory Info ===" >> $report_file
 free -h -w >> $report_file
 echo "" >> $report_file
 
 # 内存趋势
 echo "=== Memory Trends (last 24 hours) ===" >> $report_file
 analyze_memory_trend 86400 >> $report_file
 
 log_message "Monitor report generated: $report_file"
}

# 记录日志
log_message() {
 local message=$1
 local timestamp=$(date "+%Y-%m-%d %H:%M:%S")
 echo "[$timestamp] $message" >> $LOG_DIR/monitor.log
}

# 发送告警
send_alert() {
 local message=$1
 
 if [ "$ENABLE_EMAIL_ALERTS" = "true" ]; then
 echo "$message" | mail -s "Memory Monitor Alert" $ALERT_EMAIL
 fi
 
 if [ "$ENABLE_SLACK_ALERTS" = "true" ]; then
 curl -X POST -H 'Content-type: application/json' --data "{\"text\":\"$message\"}" $SLACK_WEBHOOK
 fi
}

# 主监控循环
main_monitor() {
 log_message "Memory Monitor started"
 
 while true; do
 collect_memory_metrics
 
 # 每天生成一次报告
 if [ $(date +%H) -eq 0 ] && [ $(date +%M) -eq 0 ]; then
 generate_monitor_report
 fi
 
 sleep $COLLECT_INTERVAL
 done
}

# 主函数
main() {
 case "$1" in
 monitor)
 main_monitor
 ;;
 analyze)
 analyze_memory_trend "$2"
 ;;
 report)
 generate_monitor_report
 ;;
 *)
 echo "Usage: $0 {monitor|analyze|report}"
 exit 1
 ;;
 esac
}

main "$@"

智能内存优化系统#

#!/bin/bash
# 智能内存优化系统

CONFIG_FILE="/etc/memory_optimizer/config.conf"
LOG_FILE="/var/log/memory_optimizer/optimizer.log"

mkdir -p $(dirname $LOG_FILE)

# 加载配置
source $CONFIG_FILE

# 清理页面缓存
clean_page_cache() {
 echo "Cleaning page cache..."
 
 sync
 echo 1 > /proc/sys/vm/drop_caches
 
 log_message "Page cache cleaned"
}

# 清理目录项和 inode 缓存
clean_dentries_inode() {
 echo "Cleaning dentries and inode cache..."
 
 sync
 echo 2 > /proc/sys/vm/drop_caches
 
 log_message "Dentries and inode cache cleaned"
}

# 清理所有缓存
clean_all_cache() {
 echo "Cleaning all caches..."
 
 sync
 echo 3 > /proc/sys/vm/drop_caches
 
 log_message "All caches cleaned"
}

# 优化交换空间
optimize_swap() {
 echo "Optimizing swap..."
 
 local swap_used=$(free -m | awk '/Swap:/ {print $3}')
 
 if [ $swap_used -gt 0 ]; then
 echo "Swap is in use, disabling..."
 swapoff -a
 sleep 5
 swapon -a
 
 log_message "Swap optimized"
 else
 echo "Swap is not in use"
 fi
}

# 调整 swappiness
adjust_swappiness() {
 local value=$1
 
 echo "Adjusting swappiness to $value..."
 
 echo $value > /proc/sys/vm/swappiness
 
 log_message "Swappiness adjusted to $value"
}

# 智能优化
smart_optimize() {
 local mem_percent=$(free -m | awk '/Mem:/ {print $3 * 100 / $2}')
 
 echo "Current memory usage: ${mem_percent}%"
 
 if (( $(echo "$mem_percent > 90" | bc -l) )); then
 echo "Memory usage critical, performing full optimization..."
 clean_all_cache
 optimize_swap
 elif (( $(echo "$mem_percent > 80" | bc -l) )); then
 echo "Memory usage high, performing partial optimization..."
 clean_page_cache
 else
 echo "Memory usage normal, no optimization needed"
 fi
}

# 查找高内存使用进程
find_high_memory_processes() {
 local threshold=${1:-5}
 
 echo "=== High Memory Processes (> ${threshold}%) ==="
 ps -eo pid,user,%mem,cmd --sort=-%mem | awk -v threshold=$threshold 'NR>1 && $3 > threshold {print $0}'
}

# 生成优化报告
generate_optimization_report() {
 local report_file="/var/log/memory_optimizer/optimization_report_$(date +%Y%m%d).txt"
 
 echo "Memory Optimization Report - $(date +%Y-%m-%d)" > $report_file
 echo "============================" >> $report_file
 echo "" >> $report_file
 
 # 当前内存使用情况
 echo "=== Current Memory Usage ===" >> $report_file
 free -h >> $report_file
 echo "" >> $report_file
 
 # 高内存使用进程
 echo "=== High Memory Processes ===" >> $report_file
 find_high_memory_processes 5 >> $report_file
 echo "" >> $report_file
 
 # 优化建议
 echo "=== Optimization Recommendations ===" >> $report_file
 echo "1. Clean page cache periodically" >> $report_file
 echo "2. Adjust swappiness value" >> $report_file
 echo "3. Monitor swap usage" >> $report_file
 echo "4. Optimize application memory usage" >> $report_file
 
 log_message "Optimization report generated: $report_file"
}

# 记录日志
log_message() {
 local message=$1
 local timestamp=$(date "+%Y-%m-%d %H:%M:%S")
 echo "[$timestamp] $message" >> $LOG_FILE
}

# 主函数
main() {
 case "$1" in
 page-cache)
 clean_page_cache
 ;;
 dentries)
 clean_dentries_inode
 ;;
 all)
 clean_all_cache
 ;;
 swap)
 optimize_swap
 ;;
 swappiness)
 adjust_swappiness "$2"
 ;;
 smart)
 smart_optimize
 ;;
 processes)
 find_high_memory_processes "$2"
 ;;
 report)
 generate_optimization_report
 ;;
 *)
 echo "Usage: $0 {page-cache|dentries|all|swap|swappiness|smart|processes|report}"
 exit 1
 ;;
 esac
}

main "$@"

无敌#

内存预测系统#

#!/bin/bash
# 内存预测系统

METRICS_DB="/var/lib/memory_predictor/metrics.db"
PREDICTION_DIR="/var/lib/memory_predictor/predictions"

mkdir -p $(dirname $METRICS_DB) $PREDICTION_DIR

# 收集内存使用数据
collect_memory_data() {
 local timestamp=$(date +%s)
 
 local mem_total=$(free -m | awk '/Mem:/ {print $2}')
 local mem_used=$(free -m | awk '/Mem:/ {print $3}')
 local mem_percent=$(echo "scale=2; $mem_used * 100 / $mem_total" | bc)
 
 local swap_total=$(free -m | awk '/Swap:/ {print $2}')
 local swap_used=$(free -m | awk '/Swap:/ {print $3}')
 local swap_percent=0
 
 if [ $swap_total -gt 0 ]; then
 swap_percent=$(echo "scale=2; $swap_used * 100 / $swap_total" | bc)
 fi
 
 echo "$timestamp,$mem_percent,$mem_used,$mem_total,$swap_percent,$swap_used,$swap_total" >> $METRICS_DB
}

# 预测内存使用
predict_memory_usage() {
 local days=${1:-30}
 
 if [ ! -f "$METRICS_DB" ]; then
 echo "No data available for prediction"
 return 1
 fi
 
 echo "=== Memory Usage Prediction ==="
 echo "Prediction period: $days days"
 echo ""
 
 # 计算平均增长率
 local current_usage=$(tail -1 $METRICS_DB | cut -d, -f2)
 local start_usage=$(head -1 $METRICS_DB | cut -d, -f2)
 local data_points=$(wc -l < $METRICS_DB)
 
 local growth_rate=$(echo "scale=2; ($current_usage - $start_usage) / $data_points" | bc)
 
 echo "Current usage: ${current_usage}%"
 echo "Average growth rate: ${growth_rate}% per data point"
 echo ""
 
 # 预测未来使用情况
 echo "Future predictions:"
 for ((i=1; i<=$days; i++)); do
 local predicted_usage=$(echo "scale=2; $current_usage + ($growth_rate * $i)" | bc)
 local future_date=$(date -d "+$i days" '+%Y-%m-%d')
 
 echo " $future_date: ${predicted_usage}%"
 
 if (( $(echo "$predicted_usage >= 100" | bc -l) )); then
 echo " ⚠️ WARNING: Memory will be full!"
 fi
 done
 
 # 保存预测结果
 local prediction_file="$PREDICTION_DIR/memory_prediction_$(date +%Y%m%d).txt"
 {
 echo "Memory Usage Prediction - $(date)"
 echo "Prediction period: $days days"
 echo ""
 echo "Current usage: ${current_usage}%"
 echo "Average growth rate: ${growth_rate}% per data point"
 echo ""
 echo "Future predictions:"
 for ((i=1; i<=$days; i++)); do
 local predicted_usage=$(echo "scale=2; $current_usage + ($growth_rate * $i)" | bc)
 local future_date=$(date -d "+$i days" '+%Y-%m-%d')
 
 echo " $future_date: ${predicted_usage}%"
 done
 } > $prediction_file
 
 echo ""
 echo "Prediction saved to: $prediction_file"
}

# 分析内存使用趋势
analyze_memory_trend() {
 local days=${1:-7}
 
 if [ ! -f "$METRICS_DB" ]; then
 echo "No data available for analysis"
 return 1
 fi
 
 echo "=== Memory Usage Trend ==="
 echo "Last $days days"
 echo ""
 
 local end_time=$(date +%s)
 local start_time=$((end_time - (days * 86400)))
 
 tail -100 $METRICS_DB | awk -F, -v start=$start_time -v end=$end_time '$1 >= start && $1 <= end' | while read line; do
 local timestamp=$(echo $line | cut -d, -f1)
 local percent=$(echo $line | cut -d, -f2)
 local used=$(echo $line | cut -d, -f3)
 local formatted_time=$(date -d @$timestamp '+%Y-%m-%d %H:%M:%S')
 
 echo "$formatted_time - Usage: ${percent}% (${used} MB)"
 done
}

# 生成预测报告
generate_prediction_report() {
 local report_file="$PREDICTION_DIR/prediction_report_$(date +%Y%m%d).txt"
 
 echo "Memory Prediction Report - $(date +%Y-%m-%d)" > $report_file
 echo "=========================" >> $report_file
 echo "" >> $report_file
 
 # 当前内存使用情况
 echo "=== Current Memory Usage ===" >> $report_file
 free -h >> $report_file
 echo "" >> $report_file
 
 # 预测结果
 echo "=== Predictions ===" >> $report_file
 predict_memory_usage 30 >> $report_file
 echo "" >> $report_file
 
 # 趋势分析
 echo "=== Trend Analysis ===" >> $report_file
 analyze_memory_trend 7 >> $report_file
 
 echo "Prediction report saved to: $report_file"
}

# 主函数
main() {
 case "$1" in
 collect)
 collect_memory_data
 ;;
 predict)
 predict_memory_usage "$2"
 ;;
 trend)
 analyze_memory_trend "$2"
 ;;
 report)
 generate_prediction_report
 ;;
 *)
 echo "Usage: $0 {collect|predict|trend|report}"
 exit 1
 ;;
 esac
}

main "$@"

内存容量规划系统#

#!/bin/bash
# 内存容量规划系统

CONFIG_FILE="/etc/memory_planner/config.conf"
PLAN_DIR="/var/lib/memory_planner/plans"

mkdir -p $PLAN_DIR

# 加载配置
source $CONFIG_FILE

# 分析内存使用模式
analyze_usage_pattern() {
 local days=${1:-30}
 
 local data_file="/var/lib/memory_predictor/metrics.db"
 
 if [ ! -f "$data_file" ]; then
 echo "No data available for analysis"
 return 1
 fi
 
 echo "=== Memory Usage Pattern Analysis ==="
 echo "Analysis period: $days days"
 echo ""
 
 # 计算统计信息
 local min_usage=$(awk -F, 'NR>1 {print $2}' $data_file | sort -n | head -1)
 local max_usage=$(awk -F, 'NR>1 {print $2}' $data_file | sort -n | tail -1)
 local avg_usage=$(awk -F, 'NR>1 {sum+=$2; count++} END {print sum/count}' $data_file)
 
 echo "Minimum usage: ${min_usage}%"
 echo "Maximum usage: ${max_usage}%"
 echo "Average usage: ${avg_usage}%"
 echo ""
 
 # 计算增长率
 local current_usage=$(tail -1 $data_file | cut -d, -f2)
 local start_usage=$(head -1 $data_file | cut -d, -f2)
 local data_points=$(wc -l < $data_file)
 
 local growth_rate=$(echo "scale=2; ($current_usage - $start_usage) / $data_points" | bc)
 echo "Growth rate: ${growth_rate}% per data point"
 echo ""
 
 # 预测何时达到 100%
 if (( $(echo "$growth_rate > 0" | bc -l) )); then
 local days_to_full=$(echo "scale=0; (100 - $current_usage) / $growth_rate" | bc)
 local full_date=$(date -d "+$days_to_full days" '+%Y-%m-%d')
 
 echo "Predicted to be full in: $days_to_full days ($full_date)"
 else
 echo "Usage is stable or decreasing"
 fi
}

# 生成容量规划建议
generate_capacity_recommendations() {
 local data_file="/var/lib/memory_predictor/metrics.db"
 
 if [ ! -f "$data_file" ]; then
 echo "No data available for recommendations"
 return 1
 fi
 
 echo "=== Memory Capacity Recommendations ==="
 echo ""
 
 local current_usage=$(tail -1 $data_file | cut -d, -f2)
 local growth_rate=$(awk -F, 'NR>1 {sum+=$2; count++} END {print (sum/count)}' $data_file)
 
 # 基于当前使用情况给出建议
 if [ $current_usage -lt 50 ]; then
 echo "✓ Current usage is low (${current_usage}%)"
 echo " No immediate action required"
 elif [ $current_usage -lt 70 ]; then
 echo "⚠️ Current usage is moderate (${current_usage}%)"
 echo " Consider monitoring more closely"
 echo " Plan for memory expansion in 3-6 months"
 elif [ $current_usage -lt 85 ]; then
 echo "⚠️ Current usage is high (${current_usage}%)"
 echo " Immediate action recommended:"
 echo " 1. Optimize application memory usage"
 echo " 2. Clean up unnecessary processes"
 echo " 3. Plan for memory expansion in 1-3 months"
 else
 echo "🚨 Current usage is critical (${current_usage}%)"
 echo " Urgent action required:"
 echo " 1. Optimize application memory usage immediately"
 echo " 2. Clean up unnecessary processes immediately"
 echo " 3. Plan for memory expansion immediately"
 fi
 
 echo ""
 
 # 基于增长率给出建议
 local predicted_usage=$(echo "scale=2; $current_usage + ($growth_rate * 30)" | bc)
 
 echo "Predicted usage in 30 days: ${predicted_usage}%"
 
 if (( $(echo "$predicted_usage > 90" | bc -l) )); then
 echo "⚠️ Memory will reach critical levels in 30 days"
 echo " Consider immediate memory expansion"
 fi
}

# 生成容量规划报告
generate_capacity_plan() {
 local report_file="$PLAN_DIR/capacity_plan_$(date +%Y%m%d).txt"
 
 echo "Memory Capacity Plan - $(date +%Y-%m-%d)" > $report_file
 echo "=====================" >> $report_file
 echo "" >> $report_file
 
 # 当前内存使用情况
 echo "=== Current Memory Usage ===" >> $report_file
 free -h >> $report_file
 echo "" >> $report_file
 
 # 使用模式分析
 echo "=== Usage Pattern Analysis ===" >> $report_file
 analyze_usage_pattern 30 >> $report_file
 echo "" >> $report_file
 
 # 容量建议
 echo "=== Capacity Recommendations ===" >> $report_file
 generate_capacity_recommendations >> $report_file
 echo "" >> $report_file
 
 # 行动计划
 echo "=== Action Plan ===" >> $report_file
 echo "Immediate actions (0-7 days):" >> $report_file
 echo "- Review and optimize application memory usage" >> $report_file
 echo "- Clean up unnecessary processes" >> $report_file
 echo "" >> $report_file
 echo "Short-term actions (7-30 days):" >> $report_file
 echo "- Implement memory optimization policies" >> $report_file
 echo "- Review and optimize swap configuration" >> $report_file
 echo "" >> $report_file
 echo "Long-term actions (30+ days):" >> $report_file
 echo "- Plan for memory expansion" >> $report_file
 echo "- Implement memory monitoring and alerting" >> $report_file
 
 echo "Capacity plan saved to: $report_file"
}

# 主函数
main() {
 case "$1" in
 analyze)
 analyze_usage_pattern "$2"
 ;;
 recommend)
 generate_capacity_recommendations
 ;;
 plan)
 generate_capacity_plan
 ;;
 *)
 echo "Usage: $0 {analyze|recommend|plan}"
 exit 1
 ;;
 esac
}

main "$@"

最佳实践#

定期监控内存使用：定期使用 free 检查内存使用情况
设置告警阈值：设置合理的告警阈值，及时发现问题
关注交换空间使用：监控交换空间使用情况
分析内存趋势：分析内存使用趋势，预测未来需求
优化内存使用：优化应用程序的内存使用
合理配置 swappiness：根据系统需求调整 swappiness 值
使用人类可读格式：使用 -h 选项以人类可读格式显示
记录监控数据：定期记录监控数据，便于分析趋势

注意事项#

free 显示的内存使用情况包括缓存和缓冲区
Linux 系统会尽可能使用空闲内存作为缓存
可用内存（available）比空闲内存（free）更能反映实际可用内存
交换空间的使用通常表示内存不足
频繁的交换空间使用会影响系统性能
清理缓存可能会影响系统性能
在生产环境中调整内存参数时要格外小心
注意应用程序的内存使用情况
对于关键业务，建议使用专业的内存管理工具

journalctl 命令详解

Mon, 01 Jan 0001 00:00:00 +0000

journalctl 命令详解#

journalctl 是 Linux 系统中用于查询和显示 systemd 日志的命令。它可以查看系统日志、服务日志、内核日志等，支持多种过滤和格式化选项，是系统管理员进行日志管理和故障排查的重要工具。

入门#

基本用法#

# 显示所有日志
journalctl

# 显示最近的日志
journalctl -n

# 实时跟踪日志
journalctl -f

# 显示系统启动日志
journalctl -b

常用选项#

选项	说明
`-b`	显示当前启动的日志
`-f`	实时跟踪日志
`-n`	显示最近的日志
`-r`	反向显示日志
`-e`	跳转到日志末尾
`-k`	显示内核日志
`-u`	显示特定单元的日志

基本示例#

# 显示所有日志
journalctl

# 输出示例：
# -- Logs begin at Mon 2024-01-01 00:00:00 CST, end at Mon 2024-01-01 10:00:00 CST. --
# Jan 01 00:00:00 localhost systemd[1]: Started User Manager for UID 1000.
# Jan 01 00:00:01 localhost sshd[1234]: Accepted password for user from 192.168.1.100 port 22
# Jan 01 00:00:02 localhost nginx[5678]: worker process started

# 显示最近的 10 条日志
journalctl -n 10

# 实时跟踪日志
journalctl -f

# 显示系统启动日志
journalctl -b

中级#

日志过滤#

# 显示特定单元的日志
journalctl -u nginx

# 显示特定优先级的日志
journalctl -p err

# 显示特定时间范围的日志
journalctl --since "2024-01-01 00:00:00"
journalctl --until "2024-01-01 10:00:00"

# 显示特定用户的日志
journalctl _UID=1000

# 显示特定进程的日志
journalctl _PID=1234

日志格式化#

# 以 JSON 格式显示
journalctl -o json

# 以短格式显示
journalctl -o short

# 以详细格式显示
journalctl -o verbose

# 以 cat 格式显示（不显示时间戳）
journalctl -o cat

# 以 JSON-pretty 格式显示
journalctl -o json-pretty

日志搜索#

# 搜索包含特定关键词的日志
journalctl | grep "error"

# 搜索特定单元的日志
journalctl -u nginx | grep "error"

# 搜索特定优先级的日志
journalctl -p err | grep "nginx"

# 反向搜索
journalctl -r | grep "error"

# 搜索并显示上下文
journalctl -n 20 | grep -C 5 "error"

高级#

高级过滤#

# 组合过滤条件
journalctl -u nginx -p err --since "2024-01-01"

# 显示特定标识符的日志
journalctl _SYSTEMD_UNIT=nginx.service

# 显示特定优先级及以上的日志
journalctl -p err..alert

# 显示特定优先级范围的日志
journalctl -p 0..3

# 显示特定引导的日志
journalctl -b -1

日志管理#

# 显示日志大小
journalctl --disk-usage

# 清理旧日志
journalctl --vacuum-time=7d

# 清理到特定大小
journalctl --vacuum-size=1G

# 清理到特定条目数
journalctl --vacuum-files=10

# 显示日志配置
journalctl --header

日志导出#

# 导出日志到文件
journalctl > /tmp/journal.log

# 导出特定时间范围的日志
journalctl --since "2024-01-01" --until "2024-01-02" > /tmp/journal.log

# 导出特定单元的日志
journalctl -u nginx > /tmp/nginx.log

# 导出为 JSON 格式
journalctl -o json > /tmp/journal.json

# 导出为二进制格式
journalctl --output=export > /tmp/journal.export

大师#

日志分析脚本#

#!/bin/bash
# 日志分析脚本

UNIT=$1
LOG_FILE="log_analysis_$(date +%Y%m%d_%H%M%S).txt"

# 分析单元日志
analyze_unit_logs() {
 local unit=$1
 
 echo "=== Log Analysis for $unit ===" > $LOG_FILE
 echo "Analysis Time: $(date)" >> $LOG_FILE
 echo "" >> $LOG_FILE
 
 # 日志统计
 echo "=== Log Statistics ===" >> $LOG_FILE
 echo "Total entries: $(journalctl -u $unit --no-pager | wc -l)" >> $LOG_FILE
 echo "" >> $LOG_FILE
 
 # 错误日志
 echo "=== Error Logs ===" >> $LOG_FILE
 journalctl -u $unit -p err --no-pager >> $LOG_FILE
 echo "" >> $LOG_FILE
 
 # 警告日志
 echo "=== Warning Logs ===" >> $LOG_FILE
 journalctl -u $unit -p warning --no-pager >> $LOG_FILE
 echo "" >> $LOG_FILE
 
 # 最近的日志
 echo "=== Recent Logs (last 20) ===" >> $LOG_FILE
 journalctl -u $unit -n 20 --no-pager >> $LOG_FILE
 
 echo "Analysis saved to: $LOG_FILE"
}

# 分析错误日志
analyze_error_logs() {
 echo "=== Error Log Analysis ==="
 echo ""
 
 # 所有错误日志
 echo "All error logs:"
 journalctl -p err --no-pager
 echo ""
 
 # 按单元分组
 echo "Error logs by unit:"
 journalctl -p err --no-pager | awk '{print $5}' | sort | uniq -c | sort -rn
}

# 分析特定时间范围的日志
analyze_time_range() {
 local start_time=$1
 local end_time=$2
 
 echo "=== Log Analysis for Time Range ==="
 echo "Start: $start_time"
 echo "End: $end_time"
 echo ""
 
 journalctl --since "$start_time" --until "$end_time" --no-pager
}

# 主函数
main() {
 case "$1" in
 unit)
 analyze_unit_logs "$2"
 ;;
 errors)
 analyze_error_logs
 ;;
 time)
 analyze_time_range "$2" "$3"
 ;;
 *)
 echo "Usage: $0 {unit|errors|time}"
 exit 1
 ;;
 esac
}

main "$@"

日志监控脚本#

#!/bin/bash
# 日志监控脚本

UNIT=$1
ALERT_KEYWORD=$2
ALERT_EMAIL="admin@example.com"

# 监控单元日志
monitor_unit_logs() {
 local unit=$1
 local keyword=$2
 
 echo "Monitoring logs for $unit..."
 
 journalctl -u $unit -f | while read line; do
 if echo "$line" | grep -q "$keyword"; then
 echo "ALERT: Found keyword '$keyword' in logs"
 echo "$line" | mail -s "Log Alert" $ALERT_EMAIL
 fi
 done
}

# 监控错误日志
monitor_error_logs() {
 echo "Monitoring error logs..."
 
 journalctl -p err -f | while read line; do
 echo "ERROR: $line"
 echo "$line" | mail -s "Error Log Alert" $ALERT_EMAIL
 done
}

# 监控特定关键词
monitor_keyword() {
 local keyword=$1
 
 echo "Monitoring logs for keyword: $keyword"
 
 journalctl -f | while read line; do
 if echo "$line" | grep -q "$keyword"; then
 echo "ALERT: Found keyword '$keyword' in logs"
 echo "$line" | mail -s "Log Alert" $ALERT_EMAIL
 fi
 done
}

# 主函数
main() {
 case "$1" in
 unit)
 monitor_unit_logs "$2" "$3"
 ;;
 errors)
 monitor_error_logs
 ;;
 keyword)
 monitor_keyword "$2"
 ;;
 *)
 echo "Usage: $0 {unit|errors|keyword}"
 exit 1
 ;;
 esac
}

main "$@"

日志清理脚本#

#!/bin/bash
# 日志清理脚本

# 清理旧日志
clean_old_logs() {
 local days=$1
 
 echo "Cleaning logs older than $days days..."
 journalctl --vacuum-time=${days}d
}

# 清理到特定大小
clean_logs_by_size() {
 local size=$1
 
 echo "Cleaning logs to size $size..."
 journalctl --vacuum-size=$size
}

# 清理到特定文件数
clean_logs_by_files() {
 local files=$1
 
 echo "Cleaning logs to $files files..."
 journalctl --vacuum-files=$files
}

# 显示日志使用情况
show_log_usage() {
 echo "=== Journal Disk Usage ==="
 journalctl --disk-usage
}

# 主函数
main() {
 case "$1" in
 time)
 clean_old_logs "$2"
 ;;
 size)
 clean_logs_by_size "$2"
 ;;
 files)
 clean_logs_by_files "$2"
 ;;
 usage)
 show_log_usage
 ;;
 *)
 echo "Usage: $0 {time|size|files|usage}"
 exit 1
 ;;
 esac
}

main "$@"

无敌#

企业级日志管理系统#

#!/bin/bash
# 企业级日志管理系统

CONFIG_FILE="/etc/log_manager/config.conf"
LOG_DIR="/var/log/log_manager"
ARCHIVE_DIR="/var/log/log_manager/archives"

mkdir -p $LOG_DIR $ARCHIVE_DIR

# 加载配置
source $CONFIG_FILE

# 收集日志
collect_logs() {
 local timestamp=$(date +%Y%m%d_%H%M%S)
 local output_file="$LOG_DIR/journal_$timestamp.log"
 
 echo "Collecting logs to $output_file..."
 
 journalctl --since "yesterday" --no-pager > $output_file
 
 echo "Logs collected to: $output_file"
}

# 分析日志
analyze_logs() {
 local log_file=$1
 local analysis_file="$LOG_DIR/analysis_$(date +%Y%m%d_%H%M%S).txt"
 
 echo "=== Log Analysis ===" > $analysis_file
 echo "Log File: $log_file" >> $analysis_file
 echo "Analysis Time: $(date)" >> $analysis_file
 echo "" >> $analysis_file
 
 # 统计信息
 echo "=== Statistics ===" >> $analysis_file
 echo "Total entries: $(wc -l < $log_file)" >> $analysis_file
 echo "Error entries: $(grep -i error $log_file | wc -l)" >> $analysis_file
 echo "Warning entries: $(grep -i warning $log_file | wc -l)" >> $analysis_file
 echo "" >> $analysis_file
 
 # 错误日志
 echo "=== Error Logs ===" >> $analysis_file
 grep -i error $log_file >> $analysis_file
 echo "" >> $analysis_file
 
 # 警告日志
 echo "=== Warning Logs ===" >> $analysis_file
 grep -i warning $log_file >> $analysis_file
 
 echo "Analysis saved to: $analysis_file"
}

# 归档日志
archive_logs() {
 local archive_file="$ARCHIVE_DIR/journal_$(date +%Y%m%d).tar.gz"
 
 echo "Archiving logs to $archive_file..."
 
 tar -czf $archive_file $LOG_DIR/*.log
 
 echo "Logs archived to: $archive_file"
}

# 生成日志报告
generate_log_report() {
 local report_file="$LOG_DIR/log_report_$(date +%Y%m%d).txt"
 
 echo "Log Report - $(date +%Y-%m-%d)" > $report_file
 echo "=============" >> $report_file
 echo "" >> $report_file
 
 # 日志使用情况
 echo "=== Journal Disk Usage ===" >> $report_file
 journalctl --disk-usage >> $report_file
 echo "" >> $report_file
 
 # 错误日志统计
 echo "=== Error Log Statistics ===" >> $report_file
 echo "Total errors: $(journalctl -p err --no-pager | wc -l)" >> $report_file
 echo "" >> $report_file
 
 # 按单元分组的错误
 echo "=== Errors by Unit ===" >> $report_file
 journalctl -p err --no-pager | awk '{print $5}' | sort | uniq -c | sort -rn >> $report_file
 echo "" >> $report_file
 
 # 最近的错误
 echo "=== Recent Errors ===" >> $report_file
 journalctl -p err -n 20 --no-pager >> $report_file
 
 echo "Report saved to: $report_file"
}

# 主函数
main() {
 case "$1" in
 collect)
 collect_logs
 ;;
 analyze)
 analyze_logs "$2"
 ;;
 archive)
 archive_logs
 ;;
 report)
 generate_log_report
 ;;
 *)
 echo "Usage: $0 {collect|analyze|archive|report}"
 exit 1
 ;;
 esac
}

main "$@"

智能日志分析系统#

#!/bin/bash
# 智能日志分析系统

CONFIG_FILE="/etc/log_analyzer/config.conf"
LOG_DIR="/var/log/log_analyzer"
ALERT_LOG="/var/log/log_analyzer/alerts.log"

mkdir -p $LOG_DIR $(dirname $ALERT_LOG)

# 加载配置
source $CONFIG_FILE

# 分析日志模式
analyze_log_patterns() {
 local log_file=$1
 local pattern_file="$LOG_DIR/patterns_$(date +%Y%m%d_%H%M%S).txt"
 
 echo "=== Log Pattern Analysis ===" > $pattern_file
 echo "Log File: $log_file" >> $pattern_file
 echo "Analysis Time: $(date)" >> $pattern_file
 echo "" >> $pattern_file
 
 # 错误模式
 echo "=== Error Patterns ===" >> $pattern_file
 grep -i "error" $log_file | sed 's/.*error: //' | sort | uniq -c | sort -rn >> $pattern_file
 echo "" >> $pattern_file
 
 # 警告模式
 echo "=== Warning Patterns ===" >> $pattern_file
 grep -i "warning" $log_file | sed 's/.*warning: //' | sort | uniq -c | sort -rn >> $pattern_file
 echo "" >> $pattern_file
 
 # 失败模式
 echo "=== Failure Patterns ===" >> $pattern_file
 grep -i "failed" $log_file | sed 's/.*failed: //' | sort | uniq -c | sort -rn >> $pattern_file
 
 echo "Pattern analysis saved to: $pattern_file"
}

# 检测异常日志
detect_anomalies() {
 local log_file=$1
 local anomaly_file="$LOG_DIR/anomalies_$(date +%Y%m%d_%H%M%S).txt"
 
 echo "=== Anomaly Detection ===" > $anomaly_file
 echo "Log File: $log_file" >> $anomaly_file
 echo "Detection Time: $(date)" >> $anomaly_file
 echo "" >> $anomaly_file
 
 # 检测频繁错误
 echo "=== Frequent Errors ===" >> $anomaly_file
 grep -i "error" $log_file | sed 's/.*error: //' | sort | uniq -c | sort -rn | awk '$1 > 10 {print $0}' >> $anomaly_file
 echo "" >> $anomaly_file
 
 # 检测关键错误
 echo "=== Critical Errors ===" >> $anomaly_file
 grep -i "critical\|fatal\|panic" $log_file >> $anomaly_file
 echo "" >> $anomaly_file
 
 # 检测认证失败
 echo "=== Authentication Failures ===" >> $anomaly_file
 grep -i "authentication failed\|login failed" $log_file >> $anomaly_file
 
 echo "Anomaly detection saved to: $anomaly_file"
}

# 生成分析报告
generate_analysis_report() {
 local report_file="$LOG_DIR/analysis_report_$(date +%Y%m%d).txt"
 
 echo "Log Analysis Report - $(date +%Y-%m-%d)" > $report_file
 echo "=====================" >> $report_file
 echo "" >> $report_file
 
 # 日志统计
 echo "=== Log Statistics ===" >> $report_file
 echo "Total entries: $(journalctl --since yesterday --no-pager | wc -l)" >> $report_file
 echo "Error entries: $(journalctl -p err --since yesterday --no-pager | wc -l)" >> $report_file
 echo "Warning entries: $(journalctl -p warning --since yesterday --no-pager | wc -l)" >> $report_file
 echo "" >> $report_file
 
 # 错误模式
 echo "=== Error Patterns ===" >> $report_file
 journalctl -p err --since yesterday --no-pager | sed 's/.*error: //' | sort | uniq -c | sort -rn | head -20 >> $report_file
 echo "" >> $report_file
 
 # 异常检测
 echo "=== Anomalies ===" >> $report_file
 journalctl -p crit --since yesterday --no-pager >> $report_file
 
 echo "Analysis report saved to: $report_file"
}

# 主函数
main() {
 case "$1" in
 patterns)
 analyze_log_patterns "$2"
 ;;
 anomalies)
 detect_anomalies "$2"
 ;;
 report)
 generate_analysis_report
 ;;
 *)
 echo "Usage: $0 {patterns|anomalies|report}"
 exit 1
 ;;
 esac
}

main "$@"

日志安全审计系统#

#!/bin/bash
# 日志安全审计系统

AUDIT_LOG="/var/log/log_audit/audit.log"
ALERT_LOG="/var/log/log_audit/alerts.log"

mkdir -p $(dirname $AUDIT_LOG) $(dirname $ALERT_LOG)

# 审计安全事件
audit_security_events() {
 echo "=== Security Event Audit ===" >> $AUDIT_LOG
 echo "Audit Time: $(date)" >> $AUDIT_LOG
 echo "" >> $AUDIT_LOG
 
 # 认证失败
 echo "Authentication Failures:" >> $AUDIT_LOG
 journalctl --since yesterday -p err --no-pager | grep -i "authentication failed\|login failed" >> $AUDIT_LOG
 echo "" >> $AUDIT_LOG
 
 # 权限拒绝
 echo "Permission Denied:" >> $AUDIT_LOG
 journalctl --since yesterday -p err --no-pager | grep -i "permission denied" >> $AUDIT_LOG
 echo "" >> $AUDIT_LOG
 
 # 访问拒绝
 echo "Access Denied:" >> $AUDIT_LOG
 journalctl --since yesterday -p err --no-pager | grep -i "access denied" >> $AUDIT_LOG
}

# 审计系统事件
audit_system_events() {
 echo "=== System Event Audit ===" >> $AUDIT_LOG
 echo "Audit Time: $(date)" >> $AUDIT_LOG
 echo "" >> $AUDIT_LOG
 
 # 服务启动/停止
 echo "Service Start/Stop Events:" >> $AUDIT_LOG
 journalctl --since yesterday -p notice --no-pager | grep -i "started\|stopped" >> $AUDIT_LOG
 echo "" >> $AUDIT_LOG
 
 # 系统重启
 echo "System Reboot Events:" >> $AUDIT_LOG
 journalctl --since yesterday -p notice --no-pager | grep -i "reboot\|shutdown" >> $AUDIT_LOG
 echo "" >> $AUDIT_LOG
 
 # 内核事件
 echo "Kernel Events:" >> $AUDIT_LOG
 journalctl --since yesterday -k --no-pager >> $AUDIT_LOG
}

# 检测安全威胁
detect_security_threats() {
 echo "=== Security Threat Detection ===" >> $ALERT_LOG
 echo "Detection Time: $(date)" >> $ALERT_LOG
 echo "" >> $ALERT_LOG
 
 # 暴力破解
 echo "Potential Brute Force Attacks:" >> $ALERT_LOG
 journalctl --since yesterday -p err --no-pager | grep -i "authentication failed" | awk '{print $5}' | sort | uniq -c | sort -rn | awk '$1 > 10 {print $0}' >> $ALERT_LOG
 echo "" >> $ALERT_LOG
 
 # 异常登录
 echo "Suspicious Login Attempts:" >> $ALERT_LOG
 journalctl --since yesterday -p err --no-pager | grep -i "invalid user\|failed password" >> $ALERT_LOG
 echo "" >> $ALERT_LOG
 
 # 权限提升
 echo "Privilege Escalation Attempts:" >> $ALERT_LOG
 journalctl --since yesterday -p err --no-pager | grep -i "sudo\|su" | grep -i "failed" >> $ALERT_LOG
}

# 生成审计报告
generate_audit_report() {
 local report_file="/var/log/log_audit/audit_report_$(date +%Y%m%d).txt"
 
 echo "Security Audit Report - $(date +%Y-%m-%d)" > $report_file
 echo "=========================" >> $report_file
 echo "" >> $report_file
 
 # 安全事件
 echo "=== Security Events ===" >> $report_file
 journalctl --since yesterday -p err --no-pager | grep -i "authentication failed\|permission denied" | head -50 >> $report_file
 echo "" >> $report_file
 
 # 系统事件
 echo "=== System Events ===" >> $report_file
 journalctl --since yesterday -p notice --no-pager | grep -i "started\|stopped" | head -50 >> $report_file
 echo "" >> $report_file
 
 # 威胁检测
 echo "=== Security Threats ===" >> $report_file
 journalctl --since yesterday -p crit --no-pager >> $report_file
 
 echo "Audit report saved to: $report_file"
}

# 主函数
main() {
 case "$1" in
 security)
 audit_security_events
 ;;
 system)
 audit_system_events
 ;;
 threats)
 detect_security_threats
 ;;
 report)
 generate_audit_report
 ;;
 *)
 echo "Usage: $0 {security|system|threats|report}"
 exit 1
 ;;
 esac
}

main "$@"

最佳实践#

定期检查日志：定期使用 journalctl 检查系统日志
关注错误和警告：优先查看错误和警告级别的日志
使用过滤选项：使用过滤选项快速定位问题
实时监控日志：使用 -f 选项实时监控日志
定期清理日志：定期清理旧日志，避免占用过多磁盘空间
导出重要日志：导出重要日志以便长期保存
分析日志模式：分析日志模式，发现潜在问题
设置日志告警：设置日志告警，及时发现异常

注意事项#

journalctl 需要 root 权限才能查看所有日志
日志可能被配置为持久化或非持久化
旧的日志可能会被自动清理
实时监控日志会消耗系统资源
日志文件可能很大，需要合理使用过滤选项
在生产环境中清理日志时要格外小心
注意日志的敏感信息，避免泄露
对于关键业务，建议使用专业的日志管理工具
日志的时间戳可能受系统时间影响

crontab 命令详解

Mon, 01 Jan 0001 00:00:00 +0000

crontab 命令详解#

crontab 是 Linux 系统中用于设置定时任务的命令。它允许用户在指定的时间自动执行命令或脚本，是系统管理员和开发人员进行自动化任务管理的重要工具。

入门#

基本用法#

# 编辑当前用户的定时任务
crontab -e

# 列出当前用户的定时任务
crontab -l

# 删除当前用户的定时任务
crontab -r

# 查看其他用户的定时任务
sudo crontab -u username -l

常用选项#

选项	说明
`-e`	编辑定时任务
`-l`	列出定时任务
`-r`	删除定时任务
`-u`	指定用户
`-i`	删除前确认

基本示例#

# 编辑定时任务
crontab -e

# 输出示例：
# Edit this file to introduce tasks to be run by cron.
# 
# Each task to run has to be defined through a single line
# indicating with different fields when the task will be run
# and what command to run for the task
# 
# To define the time you can provide concrete values for
# minute (m), hour (h), day of month (dom), month (mon),
# and day of week (dow) or use '*' in these fields (for 'any').
# 
# Notice that tasks will be started based on the cron's system
# daemon's notion of time and timezones.
# 
# Output of the crontab jobs (including errors) is sent through
# email to the user the crontab file belongs to (unless redirected).
# 
# For example, you can run a backup of all your user accounts
# at 5 a.m every week with:
# 0 5 * * 1 tar -zcf /var/backups/home.tgz /home/
# 
# For more information see the manual pages of crontab(5) and cron(8)
# 
# m h dom mon dow command

中级#

Cron 表达式#

# Cron 表达式格式：分钟 小时 日 月 星期 命令
# * * * * * command
# │ │ │ │ │
# │ │ │ │ └─ 星期 (0-7, 0和7都表示星期日)
# │ │ │ └─── 月份 (1-12)
# │ │ └───── 日期 (1-31)
# │ └─────── 小时 (0-23)
# └───────── 分钟 (0-59)

# 示例：
# 每分钟执行一次
* * * * * /path/to/script.sh

# 每小时执行一次
0 * * * * /path/to/script.sh

# 每天凌晨 2 点执行
0 2 * * * /path/to/script.sh

# 每周一凌晨 2 点执行
0 2 * * 1 /path/to/script.sh

# 每月 1 号凌晨 2 点执行
0 2 1 * * /path/to/script.sh

特殊字符#

# * 表示任意值
* * * * * /path/to/script.sh

# , 表示多个值
0,30 * * * * /path/to/script.sh # 每小时的 0 分和 30 分执行

# - 表示范围
0 9-17 * * * /path/to/script.sh # 每天 9 点到 17 点每小时执行

# / 表示间隔
*/5 * * * * /path/to/script.sh # 每 5 分钟执行一次

# 组合使用
0 */2 * * * /path/to/script.sh # 每 2 小时执行一次
0 9-17/2 * * * /path/to/script.sh # 每天 9 点到 17 点每 2 小时执行一次

常用定时任务#

# 每天凌晨 2 点备份数据库
0 2 * * * /usr/bin/mysqldump -u root -p'password' database > /backup/db_$(date +\%Y\%m\%d).sql

# 每小时清理临时文件
0 * * * * find /tmp -type f -mtime +1 -delete

# 每天凌晨 3 点重启服务
0 3 * * * systemctl restart nginx

# 每周一凌晨 2 点更新系统
0 2 * * 1 apt-get update && apt-get upgrade -y

# 每 5 分钟检查服务状态
*/5 * * * * systemctl status nginx || systemctl start nginx

高级#

高级定时任务#

# 使用环境变量
PATH=/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin
MAILTO=admin@example.com

# 每天凌晨 2 点执行备份
0 2 * * * /path/to/backup.sh

# 每小时执行清理
0 * * * * /path/to/cleanup.sh

# 每天凌晨 3 点执行日志轮转
0 3 * * * /path/to/logrotate.sh

# 每周一凌晨 2 点执行系统更新
0 2 * * 1 /path/to/update.sh

定时任务管理#

# 编辑定时任务
crontab -e

# 列出定时任务
crontab -l

# 删除定时任务
crontab -r

# 删除前确认
crontab -i -r

# 编辑其他用户的定时任务
sudo crontab -u username -e

# 列出其他用户的定时任务
sudo crontab -u username -l

# 删除其他用户的定时任务
sudo crontab -u username -r

定时任务调试#

# 查看定时任务执行日志
grep CRON /var/log/syslog

# 查看特定用户的定时任务日志
grep CRON.*username /var/log/syslog

# 查看定时任务执行时间
grep "CRON.*command" /var/log/syslog

# 查看定时任务错误
grep "CRON.*error" /var/log/syslog

# 查看定时任务邮件
mail

大师#

定时任务管理脚本#

#!/bin/bash
# 定时任务管理脚本

# 添加定时任务
add_cron_job() {
 local cron_expression=$1
 local command=$2
 
 echo "Adding cron job: $cron_expression $command"
 
 (crontab -l 2>/dev/null; echo "$cron_expression $command") | crontab -
 
 if [ $? -eq 0 ]; then
 echo "Cron job added successfully"
 else
 echo "Failed to add cron job"
 return 1
 fi
}

# 删除定时任务
remove_cron_job() {
 local command=$1
 
 echo "Removing cron job: $command"
 
 crontab -l 2>/dev/null | grep -v "$command" | crontab -
 
 if [ $? -eq 0 ]; then
 echo "Cron job removed successfully"
 else
 echo "Failed to remove cron job"
 return 1
 fi
}

# 列出定时任务
list_cron_jobs() {
 echo "=== Current Cron Jobs ==="
 crontab -l 2>/dev/null || echo "No cron jobs found"
}

# 备份定时任务
backup_cron_jobs() {
 local backup_file="cron_backup_$(date +%Y%m%d_%H%M%S).txt"
 
 echo "Backing up cron jobs to $backup_file"
 
 crontab -l > $backup_file
 
 if [ $? -eq 0 ]; then
 echo "Cron jobs backed up to: $backup_file"
 else
 echo "Failed to backup cron jobs"
 return 1
 fi
}

# 恢复定时任务
restore_cron_jobs() {
 local backup_file=$1
 
 if [ ! -f "$backup_file" ]; then
 echo "Backup file not found: $backup_file"
 return 1
 fi
 
 echo "Restoring cron jobs from $backup_file"
 
 crontab $backup_file
 
 if [ $? -eq 0 ]; then
 echo "Cron jobs restored successfully"
 else
 echo "Failed to restore cron jobs"
 return 1
 fi
}

# 主函数
main() {
 case "$1" in
 add)
 add_cron_job "$2" "$3"
 ;;
 remove)
 remove_cron_job "$2"
 ;;
 list)
 list_cron_jobs
 ;;
 backup)
 backup_cron_jobs
 ;;
 restore)
 restore_cron_jobs "$2"
 ;;
 *)
 echo "Usage: $0 {add|remove|list|backup|restore}"
 exit 1
 ;;
 esac
}

main "$@"

定时任务监控脚本#

#!/bin/bash
# 定时任务监控脚本

LOG_FILE="/var/log/cron_monitor/monitor.log"
ALERT_EMAIL="admin@example.com"

mkdir -p $(dirname $LOG_FILE)

# 监控定时任务执行
monitor_cron_execution() {
 local command=$1
 
 echo "Monitoring cron job: $command"
 
 while true; do
 # 检查最近的执行
 local last_execution=$(grep "CRON.*$command" /var/log/syslog | tail -1)
 
 if [ -n "$last_execution" ]; then
 local timestamp=$(echo $last_execution | awk '{print $1, $2, $3}')
 echo "Last execution: $timestamp"
 
 # 检查是否执行成功
 if echo $last_execution | grep -q "error"; then
 echo "ERROR: Cron job failed"
 log_message "Cron job failed: $command"
 send_alert "Cron job failed: $command"
 fi
 fi
 
 sleep 60
 done
}

# 检查定时任务状态
check_cron_status() {
 echo "=== Cron Service Status ==="
 systemctl status cron
 echo ""
 
 echo "=== Cron Jobs ==="
 crontab -l
}

# 分析定时任务执行日志
analyze_cron_logs() {
 local days=${1:-7}
 
 echo "=== Cron Log Analysis (last $days days) ==="
 echo ""
 
 # 执行统计
 echo "Execution Statistics:"
 grep CRON /var/log/syslog | awk '{print $NF}' | sort | uniq -c | sort -rn
 echo ""
 
 # 错误统计
 echo "Error Statistics:"
 grep "CRON.*error" /var/log/syslog | awk '{print $NF}' | sort | uniq -c | sort -rn
}

# 生成监控报告
generate_monitor_report() {
 local report_file="/var/log/cron_monitor/monitor_report_$(date +%Y%m%d).txt"
 
 echo "Cron Monitor Report - $(date +%Y-%m-%d)" > $report_file
 echo "=====================" >> $report_file
 echo "" >> $report_file
 
 # Cron 服务状态
 echo "=== Cron Service Status ===" >> $report_file
 systemctl status cron >> $report_file
 echo "" >> $report_file
 
 # 定时任务列表
 echo "=== Cron Jobs ===" >> $report_file
 crontab -l >> $report_file
 echo "" >> $report_file
 
 # 执行统计
 echo "=== Execution Statistics ===" >> $report_file
 grep CRON /var/log/syslog | awk '{print $NF}' | sort | uniq -c | sort -rn >> $report_file
 
 log_message "Monitor report generated: $report_file"
}

# 记录日志
log_message() {
 local message=$1
 local timestamp=$(date "+%Y-%m-%d %H:%M:%S")
 echo "[$timestamp] $message" >> $LOG_FILE
}

# 发送告警
send_alert() {
 local message=$1
 
 echo "$message" | mail -s "Cron Monitor Alert" $ALERT_EMAIL
}

# 主函数
main() {
 case "$1" in
 monitor)
 monitor_cron_execution "$2"
 ;;
 status)
 check_cron_status
 ;;
 analyze)
 analyze_cron_logs "$2"
 ;;
 report)
 generate_monitor_report
 ;;
 *)
 echo "Usage: $0 {monitor|status|analyze|report}"
 exit 1
 ;;
 esac
}

main "$@"

定时任务优化脚本#

#!/bin/bash
# 定时任务优化脚本

# 优化定时任务时间分布
optimize_cron_schedule() {
 echo "=== Optimizing Cron Schedule ==="
 echo ""
 
 # 获取所有定时任务
 local cron_jobs=$(crontab -l 2>/dev/null)
 
 if [ -z "$cron_jobs" ]; then
 echo "No cron jobs found"
 return
 fi
 
 # 分析时间分布
 echo "Current Schedule:"
 echo "$cron_jobs" | awk '{print $1, $2, $6}' | sort
 echo ""
 
 # 检查冲突
 echo "Potential Conflicts:"
 echo "$cron_jobs" | awk '{print $1, $2}' | sort | uniq -c | sort -rn | awk '$1 > 1 {print $0}'
 echo ""
 
 # 优化建议
 echo "Optimization Suggestions:"
 echo "1. Distribute jobs evenly across the hour"
 echo "2. Avoid scheduling multiple jobs at the same time"
 echo "3. Consider using sleep to stagger job execution"
}

# 添加随机延迟
add_random_delay() {
 local command=$1
 local max_delay=${2:-300}
 
 local random_delay=$((RANDOM % max_delay))
 
 echo "Adding random delay of $random_delay seconds to: $command"
 
 local modified_command="sleep $random_delay && $command"
 
 # 更新定时任务
 crontab -l 2>/dev/null | sed "s|$command|$modified_command|g" | crontab -
}

# 检查定时任务性能
check_cron_performance() {
 echo "=== Checking Cron Performance ==="
 echo ""
 
 # 获取最近的执行时间
 grep CRON /var/log/syslog | tail -20 | while read line; do
 local timestamp=$(echo $line | awk '{print $1, $2, $3}')
 local command=$(echo $line | awk '{print $NF}')
 
 echo "$timestamp - $command"
 done
}

# 生成优化报告
generate_optimization_report() {
 local report_file="/var/log/cron_optimizer/optimization_report_$(date +%Y%m%d).txt"
 
 echo "Cron Optimization Report - $(date +%Y-%m-%d)" > $report_file
 echo "=============================" >> $report_file
 echo "" >> $report_file
 
 # 当前定时任务
 echo "=== Current Cron Jobs ===" >> $report_file
 crontab -l >> $report_file
 echo "" >> $report_file
 
 # 时间分布分析
 echo "=== Time Distribution ===" >> $report_file
 crontab -l 2>/dev/null | awk '{print $1, $2, $6}' | sort | uniq -c >> $report_file
 echo "" >> $report_file
 
 # 优化建议
 echo "=== Optimization Suggestions ===" >> $report_file
 echo "1. Distribute jobs evenly across the hour" >> $report_file
 echo "2. Avoid scheduling multiple jobs at the same time" >> $report_file
 echo "3. Consider using sleep to stagger job execution" >> $report_file
 echo "4. Monitor job execution time" >> $report_file
 echo "5. Optimize long-running jobs" >> $report_file
 
 echo "Optimization report saved to: $report_file"
}

# 主函数
main() {
 case "$1" in
 optimize)
 optimize_cron_schedule
 ;;
 delay)
 add_random_delay "$2" "$3"
 ;;
 performance)
 check_cron_performance
 ;;
 report)
 generate_optimization_report
 ;;
 *)
 echo "Usage: $0 {optimize|delay|performance|report}"
 exit 1
 ;;
 esac
}

main "$@"

无敌#

企业级定时任务管理系统#

#!/bin/bash
# 企业级定时任务管理系统

CONFIG_FILE="/etc/cron_manager/config.conf"
LOG_DIR="/var/log/cron_manager"
JOB_DIR="/etc/cron_manager/jobs"

mkdir -p $LOG_DIR $JOB_DIR

# 加载配置
source $CONFIG_FILE

# 添加定时任务
add_job() {
 local job_name=$1
 local cron_expression=$2
 local command=$3
 
 local job_file="$JOB_DIR/${job_name}.job"
 
 echo "Adding job: $job_name"
 
 # 保存任务配置
 cat > $job_file << EOF
name=$job_name
cron_expression=$cron_expression
command=$command
created=$(date)
EOF
 
 # 添加到 crontab
 (crontab -l 2>/dev/null; echo "$cron_expression $command") | crontab -
 
 if [ $? -eq 0 ]; then
 log_message "Job added: $job_name"
 echo "Job added successfully"
 else
 log_message "Failed to add job: $job_name"
 echo "Failed to add job"
 return 1
 fi
}

# 删除定时任务
remove_job() {
 local job_name=$1
 
 local job_file="$JOB_DIR/${job_name}.job"
 
 if [ ! -f "$job_file" ]; then
 echo "Job not found: $job_name"
 return 1
 fi
 
 echo "Removing job: $job_name"
 
 # 获取任务命令
 local command=$(grep "^command=" $job_file | cut -d= -f2)
 
 # 从 crontab 中删除
 crontab -l 2>/dev/null | grep -v "$command" | crontab -
 
 # 删除任务文件
 rm -f $job_file
 
 if [ $? -eq 0 ]; then
 log_message "Job removed: $job_name"
 echo "Job removed successfully"
 else
 log_message "Failed to remove job: $job_name"
 echo "Failed to remove job"
 return 1
 fi
}

# 列出所有任务
list_jobs() {
 echo "=== Cron Jobs ==="
 echo ""
 
 for job_file in $JOB_DIR/*.job; do
 if [ -f "$job_file" ]; then
 local job_name=$(basename $job_file .job)
 local cron_expression=$(grep "^cron_expression=" $job_file | cut -d= -f2)
 local command=$(grep "^command=" $job_file | cut -d= -f2)
 
 echo "Name: $job_name"
 echo "Schedule: $cron_expression"
 echo "Command: $command"
 echo ""
 fi
 done
}

# 监控任务执行
monitor_job() {
 local job_name=$1
 
 local job_file="$JOB_DIR/${job_name}.job"
 
 if [ ! -f "$job_file" ]; then
 echo "Job not found: $job_name"
 return 1
 fi
 
 local command=$(grep "^command=" $job_file | cut -d= -f2)
 
 echo "Monitoring job: $job_name"
 
 while true; do
 # 检查最近的执行
 local last_execution=$(grep "CRON.*$command" /var/log/syslog | tail -1)
 
 if [ -n "$last_execution" ]; then
 local timestamp=$(echo $last_execution | awk '{print $1, $2, $3}')
 echo "Last execution: $timestamp"
 
 # 检查是否执行成功
 if echo $last_execution | grep -q "error"; then
 echo "ERROR: Job failed"
 log_message "Job failed: $job_name"
 send_alert "Job failed: $job_name"
 fi
 fi
 
 sleep 60
 done
}

# 生成管理报告
generate_management_report() {
 local report_file="$LOG_DIR/management_report_$(date +%Y%m%d).txt"
 
 echo "Cron Management Report - $(date +%Y-%m-%d)" > $report_file
 echo "=========================" >> $report_file
 echo "" >> $report_file
 
 # Cron 服务状态
 echo "=== Cron Service Status ===" >> $report_file
 systemctl status cron >> $report_file
 echo "" >> $report_file
 
 # 任务列表
 echo "=== Job List ===" >> $report_file
 for job_file in $JOB_DIR/*.job; do
 if [ -f "$job_file" ]; then
 local job_name=$(basename $job_file .job)
 local cron_expression=$(grep "^cron_expression=" $job_file | cut -d= -f2)
 local command=$(grep "^command=" $job_file | cut -d= -f2)
 
 echo "Name: $job_name" >> $report_file
 echo "Schedule: $cron_expression" >> $report_file
 echo "Command: $command" >> $report_file
 echo "" >> $report_file
 fi
 done
 
 # 执行统计
 echo "=== Execution Statistics ===" >> $report_file
 grep CRON /var/log/syslog | awk '{print $NF}' | sort | uniq -c | sort -rn >> $report_file
 
 log_message "Management report generated: $report_file"
}

# 记录日志
log_message() {
 local message=$1
 local timestamp=$(date "+%Y-%m-%d %H:%M:%S")
 echo "[$timestamp] $message" >> $LOG_DIR/manager.log
}

# 发送告警
send_alert() {
 local message=$1
 
 if [ "$ENABLE_EMAIL_ALERTS" = "true" ]; then
 echo "$message" | mail -s "Cron Manager Alert" $ALERT_EMAIL
 fi
}

# 主函数
main() {
 case "$1" in
 add)
 add_job "$2" "$3" "$4"
 ;;
 remove)
 remove_job "$2"
 ;;
 list)
 list_jobs
 ;;
 monitor)
 monitor_job "$2"
 ;;
 report)
 generate_management_report
 ;;
 *)
 echo "Usage: $0 {add|remove|list|monitor|report}"
 exit 1
 ;;
 esac
}

main "$@"

智能定时任务调度系统#

#!/bin/bash
# 智能定时任务调度系统

CONFIG_FILE="/etc/cron_scheduler/config.conf"
LOG_FILE="/var/log/cron_scheduler/scheduler.log"

mkdir -p $(dirname $LOG_FILE)

# 加载配置
source $CONFIG_FILE

# 智能调度
smart_schedule() {
 local command=$1
 local frequency=$2
 
 echo "Smart scheduling: $command"
 echo "Frequency: $frequency"
 
 # 分析系统负载
 local load_avg=$(uptime | awk -F'load average:' '{print $2}' | awk '{print $1}' | cut -d',' -f1)
 
 if (( $(echo "$load_avg > 1.0" | bc -l) )); then
 echo "System load high, scheduling for off-peak hours"
 
 # 安排在凌晨 2-4 点执行
 local minute=$((RANDOM % 60))
 local hour=$((2 + RANDOM % 3))
 
 local cron_expression="$minute $hour * * *"
 else
 echo "System load normal, scheduling for immediate execution"
 
 # 根据频率安排
 case "$frequency" in
 hourly)
 local cron_expression="0 * * * *"
 ;;
 daily)
 local cron_expression="0 2 * * *"
 ;;
 weekly)
 local cron_expression="0 2 * * 0"
 ;;
 monthly)
 local cron_expression="0 2 1 * *"
 ;;
 *)
 echo "Unknown frequency: $frequency"
 return 1
 ;;
 esac
 fi
 
 # 添加到 crontab
 (crontab -l 2>/dev/null; echo "$cron_expression $command") | crontab -
 
 if [ $? -eq 0 ]; then
 log_message "Scheduled: $command at $cron_expression"
 echo "Scheduled successfully: $cron_expression"
 else
 log_message "Failed to schedule: $command"
 echo "Failed to schedule"
 return 1
 fi
}

# 负载均衡调度
load_balance_schedule() {
 local commands=$1
 local time_window=$2
 
 echo "Load balance scheduling"
 echo "Commands: $commands"
 echo "Time window: $time_window minutes"
 
 # 获取命令数量
 local command_count=$(echo $commands | wc -w)
 
 # 计算间隔
 local interval=$((time_window / command_count))
 
 # 安排命令
 local current_time=0
 for command in $commands; do
 local minute=$((current_time % 60))
 local hour=$((current_time / 60))
 
 local cron_expression="$minute $hour * * *"
 
 (crontab -l 2>/dev/null; echo "$cron_expression $command") | crontab -
 
 log_message "Scheduled: $command at $cron_expression"
 
 current_time=$((current_time + interval))
 done
 
 echo "Load balance scheduling completed"
}

# 优先级调度
priority_schedule() {
 local priority=$1
 local command=$2
 
 echo "Priority scheduling"
 echo "Priority: $priority"
 echo "Command: $command"
 
 # 根据优先级安排时间
 case "$priority" in
 high)
 local cron_expression="0 * * * *"
 ;;
 medium)
 local cron_expression="0 */2 * * *"
 ;;
 low)
 local cron_expression="0 */4 * * *"
 ;;
 *)
 echo "Unknown priority: $priority"
 return 1
 ;;
 esac
 
 # 添加到 crontab
 (crontab -l 2>/dev/null; echo "$cron_expression $command") | crontab -
 
 if [ $? -eq 0 ]; then
 log_message "Priority scheduled: $command at $cron_expression"
 echo "Scheduled successfully: $cron_expression"
 else
 log_message "Failed to priority schedule: $command"
 echo "Failed to schedule"
 return 1
 fi
}

# 生成调度报告
generate_schedule_report() {
 local report_file="/var/log/cron_scheduler/schedule_report_$(date +%Y%m%d).txt"
 
 echo "Cron Schedule Report - $(date +%Y-%m-%d)" > $report_file
 echo "=====================" >> $report_file
 echo "" >> $report_file
 
 # 当前定时任务
 echo "=== Current Schedule ===" >> $report_file
 crontab -l >> $report_file
 echo "" >> $report_file
 
 # 系统负载
 echo "=== System Load ===" >> $report_file
 uptime >> $report_file
 echo "" >> $report_file
 
 # 调度建议
 echo "=== Schedule Recommendations ===" >> $report_file
 echo "1. Distribute jobs evenly across the hour" >> $report_file
 echo "2. Schedule heavy jobs during off-peak hours" >> $report_file
 echo "3. Use load balancing for multiple jobs" >> $report_file
 echo "4. Monitor job execution time" >> $report_file
 
 log_message "Schedule report generated: $report_file"
}

# 记录日志
log_message() {
 local message=$1
 local timestamp=$(date "+%Y-%m-%d %H:%M:%S")
 echo "[$timestamp] $message" >> $LOG_FILE
}

# 主函数
main() {
 case "$1" in
 smart)
 smart_schedule "$2" "$3"
 ;;
 balance)
 load_balance_schedule "$2" "$3"
 ;;
 priority)
 priority_schedule "$2" "$3"
 ;;
 report)
 generate_schedule_report
 ;;
 *)
 echo "Usage: $0 {smart|balance|priority|report}"
 exit 1
 ;;
 esac
}

main "$@"

最佳实践#

使用注释：在 crontab 文件中添加注释说明每个任务的作用
设置环境变量：在 crontab 文件中设置必要的环境变量
重定向输出：将任务输出重定向到日志文件
使用绝对路径：在命令中使用绝对路径
测试任务：在添加到 crontab 前先手动测试任务
监控任务执行：定期检查任务执行日志
备份定时任务：定期备份 crontab 文件
优化任务时间：合理安排任务执行时间，避免冲突

注意事项#

crontab 文件中的命令会在用户的 home 目录下执行
环境变量可能与交互式 shell 不同
定时任务执行时没有交互式终端
需要确保命令有执行权限
定时任务的输出会通过邮件发送给用户
注意时区问题，确保时间设置正确
定时任务可能会因为系统时间变化而跳过执行
在生产环境中修改定时任务时要格外小心
对于关键任务，建议添加错误处理和重试机制

useradd 命令详解

Mon, 01 Jan 0001 00:00:00 +0000

useradd 命令详解#

useradd 是 Linux 系统中用于创建新用户的命令。它可以创建用户账号、设置用户主目录、指定用户组等，是系统管理员进行用户管理的重要工具。

入门#

基本用法#

# 创建新用户
useradd username

# 创建用户并指定主目录
useradd -d /home/custom username

# 创建用户并指定用户组
useradd -g groupname username

# 创建用户并指定用户 ID
useradd -u 1001 username

常用选项#

选项	说明
`-d`	指定用户主目录
`-g`	指定初始用户组
`-G`	指定附加用户组
`-m`	创建用户主目录
`-s`	指定用户 shell
`-u`	指定用户 ID
`-p`	指定密码（加密）

基本示例#

# 创建新用户
useradd testuser

# 创建用户并设置密码
useradd testuser
passwd testuser

# 创建用户并创建主目录
useradd -m testuser

# 创建用户并指定 shell
useradd -s /bin/bash testuser

中级#

用户创建选项#

# 创建用户并创建主目录
useradd -m username

# 创建用户并指定主目录
useradd -d /custom/home username

# 创建用户并指定 shell
useradd -s /bin/bash username

# 创建用户并指定用户 ID
useradd -u 1001 username

# 创建用户并指定用户组
useradd -g groupname username

# 创建用户并指定附加组
useradd -G group1,group2 username

用户属性设置#

# 创建用户并设置注释
useradd -c "Full Name" username

# 创建用户并设置过期日期
useradd -e 2024-12-31 username

# 创建用户并设置密码过期天数
useradd -f 30 username

# 创建系统用户
useradd -r username

# 创建用户但不创建主目录
useradd -M username

用户管理#

# 查看用户信息
id username

# 查看用户详细信息
finger username

# 查看用户主目录
echo ~username

# 查看用户 shell
grep username /etc/passwd | cut -d: -f7

# 查看用户组
groups username

高级#

高级用户创建#

# 创建用户并复制骨架文件
useradd -m -k /etc/skel username

# 创建用户并指定 UID 和 GID
useradd -u 1001 -g 1001 username

# 创建用户并指定多个附加组
useradd -G group1,group2,group3 username

# 创建用户并设置登录 shell
useradd -s /bin/zsh username

# 创建用户并设置家目录权限
useradd -m -k /etc/skel -K HOME_MODE=0700 username

批量用户创建#

#!/bin/bash
# 批量创建用户脚本

# 从文件创建用户
create_users_from_file() {
 local user_file=$1
 
 while IFS=',' read -r username password; do
 if [ -n "$username" ]; then
 echo "Creating user: $username"
 
 useradd -m $username
 
 if [ $? -eq 0 ]; then
 echo "$username:$password" | chpasswd
 echo "User $username created successfully"
 else
 echo "Failed to create user $username"
 fi
 fi
 done < $user_file
}

# 批量创建用户
batch_create_users() {
 local user_list=$1
 
 for username in $user_list; do
 echo "Creating user: $username"
 
 useradd -m $username
 
 if [ $? -eq 0 ]; then
 echo "User $username created successfully"
 else
 echo "Failed to create user $username"
 fi
 done
}

# 主函数
main() {
 case "$1" in
 file)
 create_users_from_file "$2"
 ;;
 batch)
 batch_create_users "$2"
 ;;
 *)
 echo "Usage: $0 {file|batch}"
 exit 1
 ;;
 esac
}

main "$@"

用户模板#

#!/bin/bash
# 用户模板脚本

# 创建用户模板
create_user_template() {
 local username=$1
 local template=$2
 
 echo "Creating user from template: $template"
 
 case "$template" in
 developer)
 useradd -m -s /bin/bash -G developers,docker $username
 ;;
 admin)
 useradd -m -s /bin/bash -G sudo,adm $username
 ;;
 web)
 useradd -m -s /bin/bash -G www-data,ftp $username
 ;;
 *)
 echo "Unknown template: $template"
 return 1
 ;;
 esac
 
 if [ $? -eq 0 ]; then
 echo "User $username created from template $template"
 else
 echo "Failed to create user $username"
 return 1
 fi
}

# 自定义用户模板
create_custom_template() {
 local username=$1
 local shell=$2
 local groups=$3
 
 echo "Creating user with custom template"
 
 useradd -m -s $shell -G $groups $username
 
 if [ $? -eq 0 ]; then
 echo "User $username created successfully"
 else
 echo "Failed to create user $username"
 return 1
 fi
}

# 主函数
main() {
 case "$1" in
 template)
 create_user_template "$2" "$3"
 ;;
 custom)
 create_custom_template "$2" "$3" "$4"
 ;;
 *)
 echo "Usage: $0 {template|custom}"
 exit 1
 ;;
 esac
}

main "$@"

大师#

用户管理系统#

#!/bin/bash
# 用户管理系统

CONFIG_FILE="/etc/user_manager/config.conf"
LOG_FILE="/var/log/user_manager/manager.log"

mkdir -p $(dirname $LOG_FILE)

# 加载配置
source $CONFIG_FILE

# 创建用户
create_user() {
 local username=$1
 local password=$2
 local groups=$3
 local shell=${4:-/bin/bash}
 
 echo "Creating user: $username"
 
 # 检查用户是否已存在
 if id $username &>/dev/null; then
 echo "User $username already exists"
 return 1
 fi
 
 # 创建用户
 useradd -m -s $shell $username
 
 if [ $? -ne 0 ]; then
 echo "Failed to create user $username"
 log_message "Failed to create user $username"
 return 1
 fi
 
 # 设置密码
 if [ -n "$password" ]; then
 echo "$username:$password" | chpasswd
 
 if [ $? -ne 0 ]; then
 echo "Failed to set password for $username"
 log_message "Failed to set password for $username"
 return 1
 fi
 fi
 
 # 添加到附加组
 if [ -n "$groups" ]; then
 usermod -aG $groups $username
 
 if [ $? -ne 0 ]; then
 echo "Failed to add user $username to groups"
 log_message "Failed to add user $username to groups"
 return 1
 fi
 fi
 
 echo "User $username created successfully"
 log_message "User $username created successfully"
 
 # 发送通知
 send_notification "User $username created successfully"
}

# 删除用户
delete_user() {
 local username=$1
 local remove_home=${2:-false}
 
 echo "Deleting user: $username"
 
 # 检查用户是否存在
 if ! id $username &>/dev/null; then
 echo "User $username does not exist"
 return 1
 fi
 
 # 删除用户
 if [ "$remove_home" = "true" ]; then
 userdel -r $username
 else
 userdel $username
 fi
 
 if [ $? -ne 0 ]; then
 echo "Failed to delete user $username"
 log_message "Failed to delete user $username"
 return 1
 fi
 
 echo "User $username deleted successfully"
 log_message "User $username deleted successfully"
 
 # 发送通知
 send_notification "User $username deleted successfully"
}

# 修改用户
modify_user() {
 local username=$1
 local option=$2
 local value=$3
 
 echo "Modifying user: $username"
 
 # 检查用户是否存在
 if ! id $username &>/dev/null; then
 echo "User $username does not exist"
 return 1
 fi
 
 # 修改用户属性
 case "$option" in
 shell)
 usermod -s $value $username
 ;;
 groups)
 usermod -aG $value $username
 ;;
 home)
 usermod -d $value $username
 ;;
 password)
 echo "$username:$value" | chpasswd
 ;;
 *)
 echo "Unknown option: $option"
 return 1
 ;;
 esac
 
 if [ $? -ne 0 ]; then
 echo "Failed to modify user $username"
 log_message "Failed to modify user $username"
 return 1
 fi
 
 echo "User $username modified successfully"
 log_message "User $username modified successfully"
}

# 列出用户
list_users() {
 echo "=== User List ==="
 
 # 获取所有普通用户
 awk -F: '$3 >= 1000 {print $1}' /etc/passwd
 
 echo ""
 echo "Total users: $(awk -F: '$3 >= 1000' /etc/passwd | wc -l)"
}

# 查看用户详细信息
show_user_info() {
 local username=$1
 
 echo "=== User Information: $username ==="
 echo ""
 
 # 基本信息
 echo "Basic Information:"
 id $username
 echo ""
 
 # 详细信息
 echo "Detailed Information:"
 finger $username 2>/dev/null || echo "Finger not available"
 echo ""
 
 # 用户组
 echo "Groups:"
 groups $username
 echo ""
 
 # 登录历史
 echo "Login History:"
 last $username | head -10
}

# 记录日志
log_message() {
 local message=$1
 local timestamp=$(date "+%Y-%m-%d %H:%M:%S")
 echo "[$timestamp] $message" >> $LOG_FILE
}

# 发送通知
send_notification() {
 local message=$1
 
 if [ "$ENABLE_EMAIL_NOTIFICATIONS" = "true" ]; then
 echo "$message" | mail -s "User Manager Notification" $ADMIN_EMAIL
 fi
}

# 主函数
main() {
 case "$1" in
 create)
 create_user "$2" "$3" "$4" "$5"
 ;;
 delete)
 delete_user "$2" "$3"
 ;;
 modify)
 modify_user "$2" "$3" "$4"
 ;;
 list)
 list_users
 ;;
 info)
 show_user_info "$2"
 ;;
 *)
 echo "Usage: $0 {create|delete|modify|list|info}"
 exit 1
 ;;
 esac
}

main "$@"

用户审计系统#

#!/bin/bash
# 用户审计系统

AUDIT_LOG="/var/log/user_audit/audit.log"
REPORT_DIR="/var/log/user_audit/reports"

mkdir -p $(dirname $AUDIT_LOG) $REPORT_DIR

# 审计用户创建
audit_user_creation() {
 local username=$1
 
 echo "=== User Creation Audit ===" >> $AUDIT_LOG
 echo "Username: $username" >> $AUDIT_LOG
 echo "Timestamp: $(date)" >> $AUDIT_LOG
 echo "Created by: $(whoami)" >> $AUDIT_LOG
 echo "From: $(who am i | awk '{print $5}')" >> $AUDIT_LOG
 echo "" >> $AUDIT_LOG
 
 # 用户信息
 echo "User Information:" >> $AUDIT_LOG
 id $username >> $AUDIT_LOG
 echo "" >> $AUDIT_LOG
 
 # 用户组
 echo "User Groups:" >> $AUDIT_LOG
 groups $username >> $AUDIT_LOG
 echo "" >> $AUDIT_LOG
}

# 审计用户删除
audit_user_deletion() {
 local username=$1
 
 echo "=== User Deletion Audit ===" >> $AUDIT_LOG
 echo "Username: $username" >> $AUDIT_LOG
 echo "Timestamp: $(date)" >> $AUDIT_LOG
 echo "Deleted by: $(whoami)" >> $AUDIT_LOG
 echo "From: $(who am i | awk '{print $5}')" >> $AUDIT_LOG
 echo "" >> $AUDIT_LOG
}

# 审计用户修改
audit_user_modification() {
 local username=$1
 local modification=$2
 
 echo "=== User Modification Audit ===" >> $AUDIT_LOG
 echo "Username: $username" >> $AUDIT_LOG
 echo "Modification: $modification" >> $AUDIT_LOG
 echo "Timestamp: $(date)" >> $AUDIT_LOG
 echo "Modified by: $(whoami)" >> $AUDIT_LOG
 echo "From: $(who am i | awk '{print $5}')" >> $AUDIT_LOG
 echo "" >> $AUDIT_LOG
}

# 检测异常用户活动
detect_abnormal_activity() {
 echo "=== Abnormal User Activity Detection ===" >> $AUDIT_LOG
 echo "Detection Time: $(date)" >> $AUDIT_LOG
 echo "" >> $AUDIT_LOG
 
 # 检测最近创建的用户
 echo "Recently Created Users (last 7 days):" >> $AUDIT_LOG
 find /home -type d -mtime -7 -exec basename {} \; | while read user; do
 if id $user &>/dev/null; then
 echo "$user" >> $AUDIT_LOG
 fi
 done
 echo "" >> $AUDIT_LOG
 
 # 检测无密码用户
 echo "Users Without Password:" >> $AUDIT_LOG
 awk -F: '($2 == "" || $2 == "!") {print $1}' /etc/shadow >> $AUDIT_LOG
 echo "" >> $AUDIT_LOG
 
 # 检测 UID 异常
 echo "Users with UID < 1000:" >> $AUDIT_LOG
 awk -F: '$3 < 1000 && $3 >= 500 {print $1}' /etc/passwd >> $AUDIT_LOG
 echo "" >> $AUDIT_LOG
}

# 生成审计报告
generate_audit_report() {
 local report_file="$REPORT_DIR/audit_report_$(date +%Y%m%d).txt"
 
 echo "User Audit Report - $(date +%Y-%m-%d)" > $report_file
 echo "==================" >> $report_file
 echo "" >> $report_file
 
 # 用户统计
 echo "=== User Statistics ===" >> $report_file
 echo "Total users: $(awk -F: '$3 >= 1000' /etc/passwd | wc -l)" >> $report_file
 echo "System users: $(awk -F: '$3 < 1000' /etc/passwd | wc -l)" >> $report_file
 echo "" >> $report_file
 
 # 用户列表
 echo "=== User List ===" >> $report_file
 awk -F: '$3 >= 1000 {print $1}' /etc/passwd >> $report_file
 echo "" >> $report_file
 
 # 最近活动
 echo "=== Recent Activity ===" >> $report_file
 tail -50 $AUDIT_LOG >> $report_file
 
 echo "Audit report saved to: $report_file"
}

# 主函数
main() {
 case "$1" in
 create)
 audit_user_creation "$2"
 ;;
 delete)
 audit_user_deletion "$2"
 ;;
 modify)
 audit_user_modification "$2" "$3"
 ;;
 detect)
 detect_abnormal_activity
 ;;
 report)
 generate_audit_report
 ;;
 *)
 echo "Usage: $0 {create|delete|modify|detect|report}"
 exit 1
 ;;
 esac
}

main "$@"

无敌#

企业级用户管理系统#

#!/bin/bash
# 企业级用户管理系统

CONFIG_FILE="/etc/enterprise_user_manager/config.conf"
LOG_DIR="/var/log/enterprise_user_manager"
USER_DIR="/etc/enterprise_user_manager/users"

mkdir -p $LOG_DIR $USER_DIR

# 加载配置
source $CONFIG_FILE

# 创建企业用户
create_enterprise_user() {
 local username=$1
 local full_name=$2
 local email=$3
 local department=$4
 local role=$5
 
 echo "Creating enterprise user: $username"
 
 # 检查用户是否已存在
 if id $username &>/dev/null; then
 echo "User $username already exists"
 return 1
 fi
 
 # 创建用户
 useradd -m -s /bin/bash -c "$full_name" $username
 
 if [ $? -ne 0 ]; then
 echo "Failed to create user $username"
 log_message "Failed to create enterprise user $username"
 return 1
 fi
 
 # 设置临时密码
 local temp_password=$(openssl rand -base64 12)
 echo "$username:$temp_password" | chpasswd
 
 # 设置用户属性
 chage -d 0 $username # 强制首次登录修改密码
 
 # 添加到部门组
 if [ -n "$department" ]; then
 usermod -aG $department $username
 fi
 
 # 添加到角色组
 if [ -n "$role" ]; then
 usermod -aG $role $username
 fi
 
 # 保存用户信息
 local user_file="$USER_DIR/${username}.info"
 cat > $user_file << EOF
username=$username
full_name=$full_name
email=$email
department=$department
role=$role
created=$(date)
created_by=$(whoami)
temp_password=$temp_password
EOF
 
 echo "Enterprise user $username created successfully"
 echo "Temporary password: $temp_password"
 log_message "Enterprise user $username created successfully"
 
 # 发送欢迎邮件
 send_welcome_email $username $email $temp_password
}

# 删除企业用户
delete_enterprise_user() {
 local username=$1
 local archive=${2:-true}
 
 echo "Deleting enterprise user: $username"
 
 # 检查用户是否存在
 if ! id $username &>/dev/null; then
 echo "User $username does not exist"
 return 1
 fi
 
 # 归档用户数据
 if [ "$archive" = "true" ]; then
 local archive_dir="$USER_DIR/archives"
 mkdir -p $archive_dir
 
 local archive_file="$archive_dir/${username}_$(date +%Y%m%d).tar.gz"
 tar -czf $archive_file /home/$username
 
 echo "User data archived to: $archive_file"
 fi
 
 # 删除用户
 userdel -r $username
 
 if [ $? -ne 0 ]; then
 echo "Failed to delete user $username"
 log_message "Failed to delete enterprise user $username"
 return 1
 fi
 
 # 归档用户信息
 local user_file="$USER_DIR/${username}.info"
 if [ -f "$user_file" ]; then
 mv $user_file $USER_DIR/archives/
 fi
 
 echo "Enterprise user $username deleted successfully"
 log_message "Enterprise user $username deleted successfully"
}

# 修改企业用户
modify_enterprise_user() {
 local username=$1
 local option=$2
 local value=$3
 
 echo "Modifying enterprise user: $username"
 
 # 检查用户是否存在
 if ! id $username &>/dev/null; then
 echo "User $username does not exist"
 return 1
 fi
 
 # 修改用户属性
 case "$option" in
 full_name)
 usermod -c "$value" $username
 ;;
 email)
 local user_file="$USER_DIR/${username}.info"
 sed -i "s/^email=.*/email=$value/" $user_file
 ;;
 department)
 # 从旧组中移除
 local old_department=$(grep "^department=" $USER_DIR/${username}.info | cut -d= -f2)
 if [ -n "$old_department" ]; then
 gpasswd -d $username $old_department
 fi
 # 添加到新组
 usermod -aG $value $username
 ;;
 role)
 # 从旧角色组中移除
 local old_role=$(grep "^role=" $USER_DIR/${username}.info | cut -d= -f2)
 if [ -n "$old_role" ]; then
 gpasswd -d $username $old_role
 fi
 # 添加到新角色组
 usermod -aG $value $username
 ;;
 *)
 echo "Unknown option: $option"
 return 1
 ;;
 esac
 
 if [ $? -ne 0 ]; then
 echo "Failed to modify user $username"
 log_message "Failed to modify enterprise user $username"
 return 1
 fi
 
 # 更新用户信息文件
 local user_file="$USER_DIR/${username}.info"
 case "$option" in
 full_name)
 sed -i "s/^full_name=.*/full_name=$value/" $user_file
 ;;
 department)
 sed -i "s/^department=.*/department=$value/" $user_file
 ;;
 role)
 sed -i "s/^role=.*/role=$value/" $user_file
 ;;
 esac
 
 echo "Enterprise user $username modified successfully"
 log_message "Enterprise user $username modified successfully"
}

# 查看企业用户信息
show_enterprise_user() {
 local username=$1
 
 local user_file="$USER_DIR/${username}.info"
 
 if [ ! -f "$user_file" ]; then
 echo "User information not found for: $username"
 return 1
 fi
 
 echo "=== Enterprise User Information ==="
 cat $user_file
}

# 生成用户报告
generate_user_report() {
 local report_file="$LOG_DIR/user_report_$(date +%Y%m%d).txt"
 
 echo "Enterprise User Report - $(date +%Y-%m-%d)" > $report_file
 echo "===========================" >> $report_file
 echo "" >> $report_file
 
 # 用户统计
 echo "=== User Statistics ===" >> $report_file
 echo "Total users: $(ls $USER_DIR/*.info 2>/dev/null | wc -l)" >> $report_file
 echo "" >> $report_file
 
 # 按部门统计
 echo "=== Users by Department ===" >> $report_file
 grep "^department=" $USER_DIR/*.info 2>/dev/null | cut -d= -f2 | sort | uniq -c >> $report_file
 echo "" >> $report_file
 
 # 按角色统计
 echo "=== Users by Role ===" >> $report_file
 grep "^role=" $USER_DIR/*.info 2>/dev/null | cut -d= -f2 | sort | uniq -c >> $report_file
 echo "" >> $report_file
 
 # 最近创建的用户
 echo "=== Recently Created Users (last 30 days) ===" >> $report_file
 find $USER_DIR -name "*.info" -mtime -30 -exec basename {} .info \; >> $report_file
 
 log_message "User report generated: $report_file"
}

# 记录日志
log_message() {
 local message=$1
 local timestamp=$(date "+%Y-%m-%d %H:%M:%S")
 echo "[$timestamp] $message" >> $LOG_DIR/manager.log
}

# 发送欢迎邮件
send_welcome_email() {
 local username=$1
 local email=$2
 local password=$3
 
 local welcome_message="Welcome to our organization!

Your account has been created with the following details:
Username: $username
Email: $email
Temporary Password: $password

Please log in and change your password immediately.

Best regards,
System Administrator"
 
 echo "$welcome_message" | mail -s "Welcome to Our Organization" $email
}

# 主函数
main() {
 case "$1" in
 create)
 create_enterprise_user "$2" "$3" "$4" "$5" "$6"
 ;;
 delete)
 delete_enterprise_user "$2" "$3"
 ;;
 modify)
 modify_enterprise_user "$2" "$3" "$4"
 ;;
 show)
 show_enterprise_user "$2"
 ;;
 report)
 generate_user_report
 ;;
 *)
 echo "Usage: $0 {create|delete|modify|show|report}"
 exit 1
 ;;
 esac
}

main "$@"

用户权限管理系统#

#!/bin/bash
# 用户权限管理系统

CONFIG_FILE="/etc/permission_manager/config.conf"
LOG_FILE="/var/log/permission_manager/manager.log"

mkdir -p $(dirname $LOG_FILE)

# 加载配置
source $CONFIG_FILE

# 创建角色
create_role() {
 local role_name=$1
 local description=$2
 
 echo "Creating role: $role_name"
 
 # 创建用户组
 groupadd $role_name
 
 if [ $? -ne 0 ]; then
 echo "Failed to create role $role_name"
 log_message "Failed to create role $role_name"
 return 1
 fi
 
 # 保存角色信息
 local role_file="/etc/permission_manager/roles/${role_name}.role"
 cat > $role_file << EOF
role_name=$role_name
description=$description
created=$(date)
created_by=$(whoami)
EOF
 
 echo "Role $role_name created successfully"
 log_message "Role $role_name created successfully"
}

# 删除角色
delete_role() {
 local role_name=$1
 
 echo "Deleting role: $role_name"
 
 # 检查角色是否存在
 if ! getent group $role_name &>/dev/null; then
 echo "Role $role_name does not exist"
 return 1
 fi
 
 # 删除用户组
 groupdel $role_name
 
 if [ $? -ne 0 ]; then
 echo "Failed to delete role $role_name"
 log_message "Failed to delete role $role_name"
 return 1
 fi
 
 # 删除角色文件
 rm -f "/etc/permission_manager/roles/${role_name}.role"
 
 echo "Role $role_name deleted successfully"
 log_message "Role $role_name deleted successfully"
}

# 分配角色
assign_role() {
 local username=$1
 local role_name=$2
 
 echo "Assigning role $role_name to user $username"
 
 # 检查用户是否存在
 if ! id $username &>/dev/null; then
 echo "User $username does not exist"
 return 1
 fi
 
 # 检查角色是否存在
 if ! getent group $role_name &>/dev/null; then
 echo "Role $role_name does not exist"
 return 1
 fi
 
 # 添加用户到角色组
 usermod -aG $role_name $username
 
 if [ $? -ne 0 ]; then
 echo "Failed to assign role $role_name to user $username"
 log_message "Failed to assign role $role_name to user $username"
 return 1
 fi
 
 echo "Role $role_name assigned to user $username successfully"
 log_message "Role $role_name assigned to user $username successfully"
}

# 撤销角色
revoke_role() {
 local username=$1
 local role_name=$2
 
 echo "Revoking role $role_name from user $username"
 
 # 检查用户是否存在
 if ! id $username &>/dev/null; then
 echo "User $username does not exist"
 return 1
 fi
 
 # 检查角色是否存在
 if ! getent group $role_name &>/dev/null; then
 echo "Role $role_name does not exist"
 return 1
 fi
 
 # 从角色组中移除用户
 gpasswd -d $username $role_name
 
 if [ $? -ne 0 ]; then
 echo "Failed to revoke role $role_name from user $username"
 log_message "Failed to revoke role $role_name from user $username"
 return 1
 fi
 
 echo "Role $role_name revoked from user $username successfully"
 log_message "Role $role_name revoked from user $username successfully"
}

# 查看用户角色
show_user_roles() {
 local username=$1
 
 echo "=== Roles for User: $username ==="
 
 # 获取用户的所有组
 groups $username
}

# 查看角色成员
show_role_members() {
 local role_name=$1
 
 echo "=== Members of Role: $role_name ==="
 
 # 获取组的所有成员
 getent group $role_name | cut -d: -f4 | tr ',' '\n'
}

# 生成权限报告
generate_permission_report() {
 local report_file="/var/log/permission_manager/permission_report_$(date +%Y%m%d).txt"
 
 echo "Permission Report - $(date +%Y-%m-%d)" > $report_file
 echo "==================" >> $report_file
 echo "" >> $report_file
 
 # 角色统计
 echo "=== Role Statistics ===" >> $report_file
 echo "Total roles: $(ls /etc/permission_manager/roles/*.role 2>/dev/null | wc -l)" >> $report_file
 echo "" >> $report_file
 
 # 角色列表
 echo "=== Role List ===" >> $report_file
 ls /etc/permission_manager/roles/*.role 2>/dev/null | while read role_file; do
 local role_name=$(basename $role_file .role)
 local description=$(grep "^description=" $role_file | cut -d= -f2)
 echo "$role_name: $description" >> $report_file
 done
 echo "" >> $report_file
 
 # 用户角色映射
 echo "=== User-Role Mapping ===" >> $report_file
 awk -F: '$3 >= 1000 {print $1}' /etc/passwd | while read username; do
 echo "$username: $(groups $username | cut -d: -f2)" >> $report_file
 done
 
 log_message "Permission report generated: $report_file"
}

# 记录日志
log_message() {
 local message=$1
 local timestamp=$(date "+%Y-%m-%d %H:%M:%S")
 echo "[$timestamp] $message" >> $LOG_FILE
}

# 主函数
main() {
 case "$1" in
 create-role)
 create_role "$2" "$3"
 ;;
 delete-role)
 delete_role "$2"
 ;;
 assign)
 assign_role "$2" "$3"
 ;;
 revoke)
 revoke_role "$2" "$3"
 ;;
 user-roles)
 show_user_roles "$2"
 ;;
 role-members)
 show_role_members "$2"
 ;;
 report)
 generate_permission_report
 ;;
 *)
 echo "Usage: $0 {create-role|delete-role|assign|revoke|user-roles|role-members|report}"
 exit 1
 ;;
 esac
}

main "$@"

最佳实践#

使用 -m 选项：创建用户时使用 -m 选项创建主目录
设置强密码：为用户设置强密码或强制首次登录修改密码
使用用户组：合理使用用户组进行权限管理
记录用户操作：记录用户的创建、修改和删除操作
定期审计用户：定期审计用户账号，删除不必要的用户
使用模板：使用用户模板创建标准化的用户
设置过期策略：设置密码过期策略，增强安全性
备份用户数据：删除用户前备份用户数据

注意事项#

useradd 需要 root 权限
用户名必须唯一
用户 ID 必须唯一
主目录必须存在或使用 -m 选项创建
密码应该使用 chpasswd 命令设置，而不是 useradd -p
删除用户前应该备份用户数据
注意用户的登录 shell 和主目录权限
在生产环境中管理用户时要格外小心
对于关键系统，建议使用专业的用户管理工具
注意用户的权限和安全设置