crontab 命令详解#

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

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

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

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

# 编辑定时任务
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 表达式格式：分钟 小时 日 月 星期 命令
# * * * * * 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 "$@"