Skip to main content

🌐 Network & Automation Scripts

Các scripts trong phần này giúp bạn kiểm tra kết nối mạng, tự động hóa các tác vụ và quản lý cron job một cách hiệu quả.

📡 1. Script Kiểm Tra Kết Nối Mạng​

Kiểm Tra Kết Nối Và Cảnh Báo​

#!/bin/bash
# network_monitor.sh - Kiểm tra kết nối mạng và gửi cảnh báo

# Cấu hình
LOG_FILE="/var/log/network_monitor.log"
ALERT_EMAIL="[email protected]"
HOSTS_TO_CHECK=("google.com" "cloudflare.com" "github.com" "192.168.1.1")
PORT_TO_CHECK=("80" "443" "22")
CHECK_INTERVAL=300  # Kiểm tra mỗi 5 phút
MAX_PACKET_LOSS=20  # Cảnh báo khi mất gói > 20%
MAX_LATENCY=100     # Cảnh báo khi độ trễ > 100ms

# Hàm ghi log
log_message() {
    echo "$(date '+%Y-%m-%d %H:%M:%S') - $1" | tee -a "$LOG_FILE"
}

# Hàm gửi cảnh báo email
send_alert() {
    local subject="$1"
    local message="$2"
    echo "$message" | mail -s "[ALERT] $subject" "$ALERT_EMAIL"
    log_message "ALERT SENT: $subject"
}

# Hàm kiểm tra kết nối ping
check_ping() {
    local host=$1
    local ping_result
    local packet_loss
    local avg_latency
    
    log_message "Kiểm tra kết nối tới $host"
    
    # Thực hiện ping test
    ping_result=$(ping -c 5 "$host" 2>&1)
    
    # Kiểm tra host có tồn tại không
    if [[ $ping_result == *"unknown host"* ]]; then
        send_alert "Host không tồn tại" "Không thể phân giải tên miền: $host\nServer: $(hostname)\nTime: $(date)"
        return 1
    fi
    
    # Tính toán tỷ lệ mất gói
    packet_loss=$(echo "$ping_result" | grep -oP '\d+(?=% packet loss)')
    
    # Tính toán độ trễ trung bình
    avg_latency=$(echo "$ping_result" | grep -oP 'rtt min/avg/max/mdev = \d+\.\d+/\K\d+\.\d+(?=/\d+\.\d+/\d+\.\d+)')
    avg_latency=${avg_latency%.*}  # Loại bỏ phần thập phân
    
    log_message "Kết quả ping $host: Mất gói ${packet_loss}%, Độ trễ ${avg_latency}ms"
    
    # Kiểm tra và gửi cảnh báo nếu cần
    if [ "$packet_loss" -gt "$MAX_PACKET_LOSS" ]; then
        local message="Tỷ lệ mất gói cao khi kết nối tới $host: ${packet_loss}%\nNgưỡng cảnh báo: ${MAX_PACKET_LOSS}%\nServer: $(hostname)\nTime: $(date)"
        send_alert "Mất gói cao - $host" "$message"
    fi
    
    if [ "$avg_latency" -gt "$MAX_LATENCY" ]; then
        local message="Độ trễ cao khi kết nối tới $host: ${avg_latency}ms\nNgưỡng cảnh báo: ${MAX_LATENCY}ms\nServer: $(hostname)\nTime: $(date)"
        send_alert "Độ trễ cao - $host" "$message"
    fi
    
    return 0
}

# Hàm kiểm tra port
check_port() {
    local host=$1
    local port=$2
    
    log_message "Kiểm tra port $port trên $host"
    
    # Sử dụng nc để kiểm tra port
    if nc -z -w 5 "$host" "$port" &>/dev/null; then
        log_message "Port $port trên $host: OPEN"
        return 0
    else
        log_message "Port $port trên $host: CLOSED"
        local message="Port $port trên $host không thể kết nối\nServer: $(hostname)\nTime: $(date)"
        send_alert "Port không phản hồi - $host:$port" "$message"
        return 1
    fi
}

# Hàm kiểm tra tốc độ mạng
check_network_speed() {
    log_message "Kiểm tra tốc độ mạng"
    
    # Sử dụng speedtest-cli nếu đã cài đặt
    if command -v speedtest-cli &>/dev/null; then
        local speed_result=$(speedtest-cli --simple)
        local download_speed=$(echo "$speed_result" | grep "Download" | awk '{print $2}')
        local upload_speed=$(echo "$speed_result" | grep "Upload" | awk '{print $2}')
        
        log_message "Tốc độ mạng: Download ${download_speed} Mbit/s, Upload ${upload_speed} Mbit/s"
        
        # Có thể thêm logic cảnh báo nếu tốc độ quá thấp
    else
        log_message "speedtest-cli không được cài đặt. Bỏ qua kiểm tra tốc độ mạng."
    fi
}

# Hàm kiểm tra DNS
check_dns() {
    local domain=$1
    
    log_message "Kiểm tra DNS cho $domain"
    
    # Sử dụng dig để kiểm tra DNS
    if ! dig +short "$domain" &>/dev/null; then
        local message="Không thể phân giải DNS cho $domain\nServer: $(hostname)\nTime: $(date)"
        send_alert "Lỗi DNS - $domain" "$message"
        return 1
    fi
    
    return 0
}

# Hàm chính
main() {
    log_message "Bắt đầu kiểm tra kết nối mạng"
    
    # Kiểm tra ping tới các host
    for host in "${HOSTS_TO_CHECK[@]}"; do
        check_ping "$host"
    done
    
    # Kiểm tra các port
    for host in "${HOSTS_TO_CHECK[@]}"; do
        for port in "${PORT_TO_CHECK[@]}"; do
            check_port "$host" "$port"
        done
    done
    
    # Kiểm tra DNS
    for host in "${HOSTS_TO_CHECK[@]}"; do
        # Chỉ kiểm tra DNS cho tên miền, không phải IP
        if [[ ! "$host" =~ ^[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
            check_dns "$host"
        fi
    done
    
    # Kiểm tra tốc độ mạng (tùy chọn)
    # check_network_speed
    
    log_message "Hoàn thành kiểm tra kết nối mạng"
}

# Chạy hàm chính
main

Sử Dụng Script​

  1. Cấp quyền thực thi: chmod +x network_monitor.sh
  2. Chạy script: ./network_monitor.sh
  3. Thêm vào crontab để chạy định kỳ: */5 * * * * /path/to/network_monitor.sh

Tùy Chỉnh​

  • Thay đổi danh sách HOSTS_TO_CHECK và PORT_TO_CHECK theo nhu cầu
  • Điều chỉnh ngưỡng cảnh báo MAX_PACKET_LOSS và MAX_LATENCY
  • Thêm các kiểm tra khác như traceroute, MTU, v.v.

🔑 2. Script Tạo Password Tự Động​

Tạo Password An Toàn​

#!/bin/bash
# password_generator.sh - Tạo password an toàn tự động

# Cấu hình
PASSWORD_LENGTH=16
INCLUDE_SPECIAL_CHARS=true
OUTPUT_FILE="/path/to/passwords.txt"
ENCRYPT_OUTPUT=false
GENERATE_COUNT=1

# Hàm tạo password
generate_password() {
    local length=$1
    local include_special=$2
    local charset="A-Za-z0-9"
    
    if [ "$include_special" = true ]; then
        charset="${charset}!@#$%^&*()_+-=[]{}|;:,.<>?"
    fi
    
    # Tạo password ngẫu nhiên
    local password=$(tr -dc "$charset" < /dev/urandom | head -c "$length")
    
    # Đảm bảo password có ít nhất 1 chữ hoa, 1 chữ thường, 1 số và 1 ký tự đặc biệt
    while [[ ! "$password" =~ [A-Z] ]] || [[ ! "$password" =~ [a-z] ]] || [[ ! "$password" =~ [0-9] ]]; do
        password=$(tr -dc "$charset" < /dev/urandom | head -c "$length")
    done
    
    if [ "$include_special" = true ]; then
        while [[ ! "$password" =~ [\!\@\#\$\%\^\&\*\(\)\_\+\-\=\[\]\{\}\|\;\:\,\.\<\>\?] ]]; do
            password=$(tr -dc "$charset" < /dev/urandom | head -c "$length")
        done
    fi
    
    echo "$password"
}

# Hàm mã hóa password
encrypt_password() {
    local password=$1
    local encrypted=$(echo "$password" | openssl enc -aes-256-cbc -a -salt -pass pass:"$ENCRYPTION_KEY")
    echo "$encrypted"
}

# Hàm chính
main() {
    echo "Tạo $GENERATE_COUNT password an toàn"
    
    # Tạo thư mục chứa file output nếu chưa tồn tại
    mkdir -p "$(dirname "$OUTPUT_FILE")"
    
    # Xóa file cũ nếu tồn tại
    > "$OUTPUT_FILE"
    
    for ((i=1; i<=GENERATE_COUNT; i++)); do
        local password=$(generate_password "$PASSWORD_LENGTH" "$INCLUDE_SPECIAL_CHARS")
        
        if [ "$ENCRYPT_OUTPUT" = true ]; then
            # Yêu cầu khóa mã hóa nếu cần
            if [ -z "$ENCRYPTION_KEY" ]; then
                read -s -p "Nhập khóa mã hóa: " ENCRYPTION_KEY
                echo
            fi
            
            local encrypted=$(encrypt_password "$password")
            echo "Password $i (đã mã hóa): $encrypted" >> "$OUTPUT_FILE"
        else
            echo "Password $i: $password" >> "$OUTPUT_FILE"
        fi
        
        # Hiển thị password ra màn hình
        echo "Password $i: $password"
    done
    
    echo "Đã lưu passwords vào $OUTPUT_FILE"
}

# Xử lý tham số dòng lệnh
while [[ $# -gt 0 ]]; do
    case $1 in
        -l|--length)
            PASSWORD_LENGTH="$2"
            shift 2
            ;;
        -n|--count)
            GENERATE_COUNT="$2"
            shift 2
            ;;
        -s|--special)
            INCLUDE_SPECIAL_CHARS=true
            shift
            ;;
        -ns|--no-special)
            INCLUDE_SPECIAL_CHARS=false
            shift
            ;;
        -o|--output)
            OUTPUT_FILE="$2"
            shift 2
            ;;
        -e|--encrypt)
            ENCRYPT_OUTPUT=true
            shift
            ;;
        -h|--help)
            echo "Sử dụng: $0 [options]"
            echo "Options:"
            echo "  -l, --length LENGTH    Độ dài password (mặc định: 16)"
            echo "  -n, --count COUNT      Số lượng password cần tạo (mặc định: 1)"
            echo "  -s, --special          Bao gồm ký tự đặc biệt (mặc định: true)"
            echo "  -ns, --no-special      Không bao gồm ký tự đặc biệt"
            echo "  -o, --output FILE      File lưu passwords (mặc định: /path/to/passwords.txt)"
            echo "  -e, --encrypt          Mã hóa passwords trong file output"
            echo "  -h, --help             Hiển thị trợ giúp này"
            exit 0
            ;;
        *)
            echo "Tham số không hợp lệ: $1"
            exit 1
            ;;
    esac
done

# Chạy hàm chính
main

Sử Dụng Script​

  1. Cấp quyền thực thi: chmod +x password_generator.sh
  2. Tạo password mặc định: ./password_generator.sh
  3. Tùy chỉnh tham số:
    • Tạo 5 password dài 20 ký tự: ./password_generator.sh -l 20 -n 5
    • Tạo password không có ký tự đặc biệt: ./password_generator.sh -ns
    • Lưu vào file cụ thể: ./password_generator.sh -o /path/to/secure_passwords.txt

🤖 3. Script Automation Tasks​

Tự Động Hóa Các Tác Vụ Thường Xuyên​

#!/bin/bash
# automation_tasks.sh - Tự động hóa các tác vụ thường xuyên

# Cấu hình
LOG_FILE="/var/log/automation_tasks.log"
TASK_LIST_FILE="/etc/automation/tasks.conf"
LOCK_FILE="/tmp/automation_tasks.lock"
EMAIL_REPORT="[email protected]"
RUN_TASKS=("update" "cleanup" "backup" "report")

# Hàm ghi log
log_message() {
    echo "$(date '+%Y-%m-%d %H:%M:%S') - $1" | tee -a "$LOG_FILE"
}

# Hàm kiểm tra và tạo lock file
check_lock() {
    if [ -f "$LOCK_FILE" ]; then
        local pid=$(cat "$LOCK_FILE")
        if ps -p "$pid" > /dev/null; then
            log_message "Script đang chạy với PID $pid. Thoát."
            exit 1
        else
            log_message "Lock file tồn tại nhưng process không chạy. Xóa lock file."
            rm -f "$LOCK_FILE"
        fi
    fi
    
    echo $$ > "$LOCK_FILE"
    trap "rm -f $LOCK_FILE; exit" EXIT INT TERM
}

# Hàm cập nhật hệ thống
task_update() {
    log_message "Bắt đầu cập nhật hệ thống"
    
    # Kiểm tra loại hệ thống
    if [ -f /etc/debian_version ]; then
        # Debian/Ubuntu
        apt-get update && apt-get -y upgrade
    elif [ -f /etc/redhat-release ]; then
        # CentOS/RHEL
        if command -v dnf &>/dev/null; then
            dnf -y update
        else
            yum -y update
        fi
    else
        log_message "Không xác định được loại hệ thống. Bỏ qua cập nhật."
        return 1
    fi
    
    log_message "Hoàn thành cập nhật hệ thống"
    return 0
}

# Hàm dọn dẹp hệ thống
task_cleanup() {
    log_message "Bắt đầu dọn dẹp hệ thống"
    
    # Xóa các file tạm
    find /tmp -type f -atime +7 -delete
    
    # Xóa các file log cũ
    find /var/log -name "*.gz" -type f -mtime +30 -delete
    
    # Dọn dẹp package cache
    if [ -f /etc/debian_version ]; then
        apt-get clean
        apt-get autoclean
    elif [ -f /etc/redhat-release ]; then
        if command -v dnf &>/dev/null; then
            dnf clean all
        else
            yum clean all
        fi
    fi
    
    log_message "Hoàn thành dọn dẹp hệ thống"
    return 0
}

# Hàm backup dữ liệu
task_backup() {
    log_message "Bắt đầu backup dữ liệu"
    
    # Kiểm tra file cấu hình backup
    local backup_config="/etc/automation/backup.conf"
    if [ ! -f "$backup_config" ]; then
        log_message "Không tìm thấy file cấu hình backup: $backup_config"
        return 1
    fi
    
    # Đọc cấu hình backup
    source "$backup_config"
    
    # Tạo thư mục backup
    local backup_date=$(date +"%Y%m%d_%H%M%S")
    local backup_dir="${BACKUP_ROOT:-/backup}/$backup_date"
    mkdir -p "$backup_dir"
    
    # Backup các thư mục được cấu hình
    if [ -n "${BACKUP_DIRS[*]}" ]; then
        for dir in "${BACKUP_DIRS[@]}"; do
            if [ -d "$dir" ]; then
                log_message "Backup thư mục: $dir"
                tar -czf "$backup_dir/$(basename "$dir").tar.gz" -C "$(dirname "$dir")" "$(basename "$dir")"
            else
                log_message "Thư mục không tồn tại: $dir"
            fi
        done
    fi
    
    # Backup database nếu được cấu hình
    if [ "${BACKUP_MYSQL:-false}" = true ]; then
        log_message "Backup MySQL databases"
        if [ -x "/usr/bin/mysqldump" ] && [ -n "$MYSQL_USER" ] && [ -n "$MYSQL_PASS" ]; then
            mkdir -p "$backup_dir/mysql"
            mysql -u"$MYSQL_USER" -p"$MYSQL_PASS" -e "SHOW DATABASES" | grep -v "Database\|information_schema\|performance_schema" | while read db; do
                mysqldump -u"$MYSQL_USER" -p"$MYSQL_PASS" "$db" | gzip > "$backup_dir/mysql/$db.sql.gz"
            done
        else
            log_message "Thiếu thông tin cấu hình MySQL backup"
        fi
    fi
    
    log_message "Hoàn thành backup dữ liệu: $backup_dir"
    return 0
}

# Hàm tạo báo cáo
task_report() {
    log_message "Bắt đầu tạo báo cáo hệ thống"
    
    local report_file="/tmp/system_report_$(date +"%Y%m%d").txt"
    
    # Tạo báo cáo
    {
        echo "=== BÁO CÁO HỆ THỐNG ==="
        echo "Thời gian: $(date)"
        echo "Hostname: $(hostname)"
        echo "Uptime: $(uptime)"
        echo
        
        echo "=== THÔNG TIN CPU ==="
        lscpu | grep -E "^Architecture|^CPU\(s\)|^Thread\(s\) per core|^Core\(s\) per socket|^Socket\(s\)|^Model name"
        echo
        
        echo "=== THÔNG TIN BỘ NHỚ ==="
        free -h
        echo
        
        echo "=== THÔNG TIN Ổ CỨNG ==="
        df -h
        echo
        
        echo "=== PROCESS SỬ DỤNG NHIỀU TÀI NGUYÊN ==="
        echo "Top 5 process sử dụng CPU:"
        ps aux --sort=-%cpu | head -6
        echo
        echo "Top 5 process sử dụng RAM:"
        ps aux --sort=-%mem | head -6
        echo
        
        echo "=== THÔNG TIN MẠNG ==="
        ip -br addr
        echo
        
        echo "=== THÔNG TIN DỊCH VỤ ==="
        systemctl list-units --type=service --state=running | head -20
        echo
        
        echo "=== THÔNG TIN NGƯỜI DÙNG ==="
        who
        echo
        
        echo "=== THÔNG TIN LOGIN GẦN ĐÂY ==="
        last | head -10
        echo
    } > "$report_file"
    
    # Gửi báo cáo qua email
    if [ -n "$EMAIL_REPORT" ]; then
        mail -s "Báo cáo hệ thống $(hostname) - $(date +"%Y-%m-%d")" "$EMAIL_REPORT" < "$report_file"
    fi
    
    log_message "Hoàn thành tạo báo cáo hệ thống: $report_file"
    return 0
}

# Hàm chính
main() {
    check_lock
    
    log_message "Bắt đầu chạy automation tasks"
    
    # Chạy các task được cấu hình
    for task in "${RUN_TASKS[@]}"; do
        case "$task" in
            update)
                task_update
                ;;
            cleanup)
                task_cleanup
                ;;
            backup)
                task_backup
                ;;
            report)
                task_report
                ;;
            *)
                log_message "Task không xác định: $task"
                ;;
        esac
    done
    
    log_message "Hoàn thành tất cả automation tasks"
}

# Xử lý tham số dòng lệnh
if [ "$1" = "--task" ] && [ -n "$2" ]; then
    # Chạy một task cụ thể
    check_lock
    log_message "Chạy task: $2"
    
    case "$2" in
        update)
            task_update
            ;;
        cleanup)
            task_cleanup
            ;;
        backup)
            task_backup
            ;;
        report)
            task_report
            ;;
        *)
            log_message "Task không xác định: $2"
            exit 1
            ;;
    esac
else
    # Chạy tất cả các task được cấu hình
    main
fi

Sử Dụng Script​

  1. Cấp quyền thực thi: chmod +x automation_tasks.sh
  2. Chạy tất cả các task: ./automation_tasks.sh
  3. Chạy một task cụ thể: ./automation_tasks.sh --task backup

Tùy Chỉnh​

  • Thêm hoặc xóa các task trong mảng RUN_TASKS
  • Tạo file cấu hình /etc/automation/backup.conf với nội dung: 
    BACKUP_ROOT="/backup"
    BACKUP_DIRS=("/etc" "/home" "/var/www")
    BACKUP_MYSQL=true
    MYSQL_USER="backup"
    MYSQL_PASS="your_password"

⏱️ 4. Script Quản Lý Cron Job​

Quản Lý Và Giám Sát Cron Job​

#!/bin/bash
# cron_manager.sh - Quản lý và giám sát cron job

# Cấu hình
LOG_FILE="/var/log/cron_manager.log"
CRON_DIR="/etc/cron.d"
CRON_HISTORY_FILE="/var/log/cron_history.log"
EMAIL_ALERT="[email protected]"
MAX_RUNTIME=3600  # Thời gian chạy tối đa (giây)

# Hàm ghi log
log_message() {
    echo "$(date '+%Y-%m-%d %H:%M:%S') - $1" | tee -a "$LOG_FILE"
}

# Hàm gửi cảnh báo
send_alert() {
    local subject="$1"
    local message="$2"
    echo "$message" | mail -s "[CRON ALERT] $subject" "$EMAIL_ALERT"
    log_message "ALERT SENT: $subject"
}

# Hàm liệt kê tất cả cron job
list_all_cron_jobs() {
    log_message "Liệt kê tất cả cron job"
    
    echo "=== Cron Jobs của Người Dùng ==="
    for user in $(cut -f1 -d: /etc/passwd); do
        crontab -l -u "$user" 2>/dev/null | grep -v "^#" | while read line; do
            if [ -n "$line" ]; then
                echo "[$user] $line"
            fi
        done
    done
    
    echo "\n=== Cron Jobs trong /etc/cron.* ==="
    for crondir in /etc/cron.d /etc/cron.daily /etc/cron.hourly /etc/cron.monthly /etc/cron.weekly; do
        if [ -d "$crondir" ]; then
            for cronfile in "$crondir"/*; do
                if [ -f "$cronfile" ] && [ -x "$cronfile" ] || [[ "$crondir" == "/etc/cron.d" ]]; then
                    echo "[$crondir] $(basename "$cronfile")"
                    if [[ "$crondir" == "/etc/cron.d" ]]; then
                        grep -v "^#" "$cronfile" | while read line; do
                            if [ -n "$line" ]; then
                                echo "  $line"
                            fi
                        done
                    fi
                fi
            done
        fi
    done
    
    echo "\n=== Cron Jobs trong /etc/crontab ==="
    grep -v "^#" /etc/crontab | while read line; do
        if [ -n "$line" ]; then
            echo "$line"
        fi
    done
}

# Hàm thêm cron job mới
add_cron_job() {
    local user=$1
    local schedule=$2
    local command=$3
    local description=$4
    
    log_message "Thêm cron job mới cho user $user: '$command'"
    
    # Kiểm tra user có tồn tại không
    if ! id "$user" &>/dev/null; then
        log_message "User không tồn tại: $user"
        return 1
    fi
    
    # Kiểm tra định dạng schedule
    if ! [[ "$schedule" =~ ^[0-9*,-/]+[[:space:]]+[0-9*,-/]+[[:space:]]+[0-9*,-/]+[[:space:]]+[0-9*,-/]+[[:space:]]+[0-9*,-/]+$ ]]; then
        log_message "Định dạng schedule không hợp lệ: $schedule"
        return 1
    fi
    
    # Thêm cron job
    (crontab -l -u "$user" 2>/dev/null; echo "# $description"; echo "$schedule $command") | crontab -u "$user" -
    
    log_message "Đã thêm cron job thành công"
    return 0
}

# Hàm xóa cron job
remove_cron_job() {
    local user=$1
    local pattern=$2
    
    log_message "Xóa cron job cho user $user với pattern: '$pattern'"
    
    # Kiểm tra user có tồn tại không
    if ! id "$user" &>/dev/null; then
        log_message "User không tồn tại: $user"
        return 1
    fi
    
    # Lấy crontab hiện tại
    local current_crontab=$(crontab -l -u "$user" 2>/dev/null)
    if [ -z "$current_crontab" ]; then
        log_message "User $user không có cron job nào"
        return 0
    fi
    
    # Xóa cron job khớp với pattern
    local new_crontab=$(echo "$current_crontab" | grep -v "$pattern")
    
    # Cập nhật crontab
    echo "$new_crontab" | crontab -u "$user" -
    
    log_message "Đã xóa cron job thành công"
    return 0
}

# Hàm kiểm tra cron job đang chạy
check_running_cron_jobs() {
    log_message "Kiểm tra cron job đang chạy"
    
    # Lấy danh sách process có tên là cron
    local cron_pids=$(pgrep -f "CRON" | grep -v "$$")
    
    if [ -z "$cron_pids" ]; then
        log_message "Không có cron job nào đang chạy"
        return 0
    fi
    
    echo "=== Cron Jobs Đang Chạy ==="
    for pid in $cron_pids; do
        local cmd=$(ps -p "$pid" -o cmd= | grep -v "cron_manager")
        local start_time=$(ps -p "$pid" -o lstart=)
        local elapsed=$(($(date +%s) - $(date -d "$start_time" +%s)))
        
        echo "PID: $pid"
        echo "Command: $cmd"
        echo "Start Time: $start_time"
        echo "Running for: $elapsed seconds"
        echo
        
        # Kiểm tra thời gian chạy
        if [ "$elapsed" -gt "$MAX_RUNTIME" ]; then
            local message="Cron job chạy quá lâu:\nPID: $pid\nCommand: $cmd\nStart Time: $start_time\nRunning for: $elapsed seconds\nServer: $(hostname)"
            send_alert "Cron Job Chạy Quá Lâu" "$message"
        fi
    done
}

# Hàm kiểm tra lịch sử cron job
check_cron_history() {
    log_message "Kiểm tra lịch sử cron job"
    
    # Kiểm tra file lịch sử cron
    if [ ! -f "$CRON_HISTORY_FILE" ]; then
        log_message "File lịch sử cron không tồn tại: $CRON_HISTORY_FILE"
        return 1
    fi
    
    # Hiển thị lịch sử cron job
    echo "=== Lịch Sử Cron Job (24h Gần Đây) ==="
    grep "CRON" /var/log/syslog | grep -v "cron_manager" | tail -100
}

# Hàm kiểm tra lỗi cron job
check_cron_errors() {
    log_message "Kiểm tra lỗi cron job"
    
    # Tìm các lỗi trong log
    local errors=$(grep "CRON.*ERROR\|CRON.*FAILURE" /var/log/syslog | grep -v "cron_manager" | tail -50)
    
    if [ -n "$errors" ]; then
        echo "=== Lỗi Cron Job Gần Đây ==="
        echo "$errors"
        
        # Gửi cảnh báo nếu có lỗi mới
        local recent_errors=$(echo "$errors" | grep "$(date +"%b %e")")
        if [ -n "$recent_errors" ]; then
            local message="Phát hiện lỗi cron job mới:\n\n$recent_errors\n\nServer: $(hostname)"
            send_alert "Lỗi Cron Job Mới" "$message"
        fi
    else
        echo "Không tìm thấy lỗi cron job nào gần đây"
    fi
}

# Hàm chính
main() {
    # Kiểm tra quyền root
    if [ "$(id -u)" -ne 0 ]; then
        echo "Script này cần chạy với quyền root"
        exit 1
    fi
    
    # Xử lý tham số dòng lệnh
    case "$1" in
        list)
            list_all_cron_jobs
            ;;
        add)
            if [ -z "$2" ] || [ -z "$3" ] || [ -z "$4" ]; then
                echo "Sử dụng: $0 add <user> '<schedule>' '<command>' '<description>'"
                exit 1
            fi
            add_cron_job "$2" "$3" "$4" "${5:-No description}"
            ;;
        remove)
            if [ -z "$2" ] || [ -z "$3" ]; then
                echo "Sử dụng: $0 remove <user> '<pattern>'"
                exit 1
            fi
            remove_cron_job "$2" "$3"
            ;;
        running)
            check_running_cron_jobs
            ;;
        history)
            check_cron_history
            ;;
        errors)
            check_cron_errors
            ;;
        monitor)
            # Chế độ giám sát liên tục
            while true; do
                clear
                echo "=== GIÁM SÁT CRON JOB ===\n"
                check_running_cron_jobs
                echo "\n"
                check_cron_errors
                echo "\n\nĐang giám sát... Nhấn Ctrl+C để thoát."
                sleep 60
            done
            ;;
        *)
            echo "Sử dụng: $0 {list|add|remove|running|history|errors|monitor}"
            echo "  list                   - Liệt kê tất cả cron job"
            echo "  add <user> '<schedule>' '<command>' '<description>'  - Thêm cron job mới"
            echo "  remove <user> '<pattern>'  - Xóa cron job"
            echo "  running                - Kiểm tra cron job đang chạy"
            echo "  history                - Xem lịch sử cron job"
            echo "  errors                 - Kiểm tra lỗi cron job"
            echo "  monitor                - Giám sát cron job liên tục"
            exit 1
            ;;
    esac
}

# Chạy hàm chính
main "$@"

Sử Dụng Script​

  1. Cấp quyền thực thi: chmod +x cron_manager.sh
  2. Liệt kê tất cả cron job: sudo ./cron_manager.sh list
  3. Thêm cron job mới: sudo ./cron_manager.sh add username '0 2 * * *' '/path/to/script.sh' 'Daily backup at 2 AM'
  4. Xóa cron job: sudo ./cron_manager.sh remove username 'backup.sh'
  5. Kiểm tra cron job đang chạy: sudo ./cron_manager.sh running
  6. Xem lịch sử cron job: sudo ./cron_manager.sh history
  7. Kiểm tra lỗi cron job: sudo ./cron_manager.sh errors
  8. Giám sát cron job liên tục: sudo ./cron_manager.sh monitor

⚙️ Cấu Hình Cron Job​

Ví Dụ Cron Job Cho Các Scripts​

# Kiểm tra kết nối mạng mỗi 15 phút
*/15 * * * * /path/to/network_monitor.sh > /dev/null 2>&1

# Tạo password mới mỗi tháng vào ngày 1 lúc 3 giờ sáng
0 3 1 * * /path/to/password_generator.sh -l 20 -n 10 -o /secure/monthly_passwords.txt > /dev/null 2>&1

# Chạy automation tasks hàng ngày lúc 2 giờ sáng
0 2 * * * /path/to/automation_tasks.sh > /dev/null 2>&1

# Chạy task backup riêng vào Chủ Nhật lúc 1 giờ sáng
0 1 * * 0 /path/to/automation_tasks.sh --task backup > /dev/null 2>&1

# Kiểm tra cron job đang chạy mỗi giờ
0 * * * * /path/to/cron_manager.sh running > /var/log/cron_check.log 2>&1

# Kiểm tra lỗi cron job mỗi ngày lúc 7 giờ sáng
0 7 * * * /path/to/cron_manager.sh errors > /var/log/cron_errors.log 2>&1

🔒 Permissions & Security​

Bảo Mật Cho Scripts​

  1. Quyền File

    • Đặt quyền thích hợp: chmod 700 /path/to/script.sh
    • Chỉ cho phép root hoặc user cụ thể chạy script

  2. Bảo Vệ Credentials

    • Không lưu password trực tiếp trong script
    • Sử dụng file cấu hình riêng với quyền hạn chế: chmod 600 /path/to/config.conf
    • Sử dụng biến môi trường hoặc vault service

  3. Logging & Monitoring

    • Luôn ghi log đầy đủ cho mọi hoạt động
    • Thiết lập cảnh báo cho các lỗi quan trọng
    • Kiểm tra log thường xuyên

⚠️ Lưu Ý Quan Trọng​

Cảnh báo bảo mật
  • Luôn kiểm tra kỹ script trước khi chạy
  • Không chạy script với quyền root nếu không cần thiết
  • Sử dụng tường lửa để bảo vệ các port quan trọng
  • Cập nhật scripts thường xuyên để đảm bảo an toàn
  • Kiểm tra kỹ các cron job trước khi thiết lập
  • Sử dụng mật khẩu mạnh và thay đổi định kỳ
  • Mã hóa dữ liệu nhạy cảm khi lưu trữ hoặc truyền tải

  1. Network Monitoring

    • Điều chỉnh ngưỡng cảnh báo phù hợp với môi trường
    • Tránh gửi quá nhiều cảnh báo gây nhiễu
    • Kiểm tra các host quan trọng nhất trước

  2. Password Generation

    • Không lưu password ở dạng plain text
    • Sử dụng kênh an toàn để chia sẻ password
    • Xóa file password sau khi sử dụng

  3. Automation Tasks

    • Test kỹ trước khi triển khai tự động
    • Luôn có cơ chế rollback
    • Giới hạn tài nguyên sử dụng

  4. Cron Management

    • Tránh chạy quá nhiều cron job cùng lúc
    • Đặt thời gian chạy hợp lý tránh tải cao
    • Kiểm tra xung đột giữa các cron job