Shell脚本如何设置告警依赖关系

本文目录导读：

1. 基于返回值的依赖检查
2. 时间窗口依赖
3. 状态文件依赖
4. 带优先级的依赖管理
5. 完整的依赖告警系统示例
6. 关键要点：

在Shell脚本中设置告警依赖关系,通常有几种常见方式：

基于返回值的依赖检查

#!/bin/bash
# 检查前置告警是否已触发
check_prerequisite_alarm() {
    local prereq_alarm="$1"
    # 检查告警文件或日志是否存在
    if [ -f "/tmp/alarms/${prereq_alarm}.triggered" ]; then
        return 0  # 前置告警已触发
    else
        return 1  # 前置告警未触发
    fi
}
# 主告警逻辑
main_alarm() {
    # 检查依赖
    if check_prerequisite_alarm "cpu_high"; then
        echo "CPU高告警已触发，可以发送关联告警"
        # 发送告警逻辑
        send_alarm "内存使用率过高"
    else
        echo "前置条件未满足，跳过告警"
    fi
}

时间窗口依赖

#!/bin/bash
# 检查在指定时间窗口内是否发生过告警
check_time_window_dependency() {
    local alarm_type="$1"
    local window_minutes="$2"
    local alarm_log="/var/log/alarms.log"
    # 获取当前时间
    current_time=$(date +%s)
    # 检查最近window_minutes分钟内是否有相关告警
    recent_alarm=$(awk -v alarm="$alarm_type" -v current="$current_time" -v window="$window_minutes" '
        $1 ~ alarm {
            alarm_time = $2
            if ((current - alarm_time) < (window * 60)) {
                print $0
                exit
            }
        }
    ' "$alarm_log")
    if [ -n "$recent_alarm" ]; then
        return 0  # 找到匹配的告警
    else
        return 1  # 未找到
    fi
}
# 使用示例
if check_time_window_dependency "CPU_ALARM" 30; then
    # 30分钟内有CPU告警，执行内存告警
    trigger_alarm "MEMORY_ALARM"
fi

状态文件依赖

#!/bin/bash
STATE_DIR="/var/run/alarm_states"
DEPENDENCY_FILE="${STATE_DIR}/dependency_chain.conf"
# 检查依赖链
check_dependency_chain() {
    local current_alarm="$1"
    # 从配置文件读取依赖关系
    while IFS=':' read -r alarm depends_on; do
        if [ "$alarm" = "$current_alarm" ]; then
            # 检查依赖的告警状态
            for dep in $(echo "$depends_on" | tr ',' ' '); do
                dep_state_file="${STATE_DIR}/${dep}.state"
                if [ ! -f "$dep_state_file" ]; then
                    return 1  # 依赖不满足
                fi
                # 检查状态是否为已触发
                state=$(cat "$dep_state_file")
                if [ "$state" != "TRIGGERED" ]; then
                    return 1
                fi
            done
            return 0  # 所有依赖满足
        fi
    done < "$DEPENDENCY_FILE"
    return 1  # 未找到依赖配置
}
# 设置告警状态
set_alarm_state() {
    local alarm="$1"
    local state="$2"
    mkdir -p "$STATE_DIR"
    echo "$state" > "${STATE_DIR}/${alarm}.state"
}
# 使用示例
if check_dependency_chain "HIGH_MEMORY_ALARM"; then
    echo "依赖满足，触发告警"
    set_alarm_state "HIGH_MEMORY_ALARM" "TRIGGERED"
fi

带优先级的依赖管理

#!/bin/bash
# 告警优先级和依赖配置
declare -A ALARM_PRIORITY
declare -A ALARM_DEPENDENCIES
# 初始化配置
init_alarm_config() {
    ALARM_PRIORITY["CRITICAL"]=1
    ALARM_PRIORITY["HIGH"]=2
    ALARM_PRIORITY["MEDIUM"]=3
    ALARM_PRIORITY["LOW"]=4
    ALARM_DEPENDENCIES["HIGH_MEMORY"]="HIGH_CPU,SWAP_USAGE"
    ALARM_DEPENDENCIES["CRITICAL_DISK"]="HIGH_DISK,WARNING_DISK"
}
# 检查告警优先级
check_alarm_priority() {
    local alarm_type="$1"
    local required_priority="$2"
    if [ "${ALARM_PRIORITY[$alarm_type]}" -le "$required_priority" ]; then
        return 0  # 优先级满足
    else
        return 1  # 优先级不够
    fi
}
# 执行依赖检查
execute_alarm_with_dependencies() {
    local alarm_type="$1"
    local alarm_message="$2"
    init_alarm_config
    # 检查是否存在依赖
    if [ -n "${ALARM_DEPENDENCIES[$alarm_type]}" ]; then
        echo "告警 $alarm_type 存在依赖: ${ALARM_DEPENDENCIES[$alarm_type]}"
        # 将依赖字符串转为数组
        IFS=',' read -ra dependencies <<< "${ALARM_DEPENDENCIES[$alarm_type]}"
        for dep in "${dependencies[@]}"; do
            dep=$(echo "$dep" | tr -d ' ')
            echo "检查依赖: $dep"
            if ! check_alarm_priority "$dep" 2; then
                echo "依赖 $dep 优先级未满足"
                return 1
            fi
            # 检查依赖告警状态
            if [ ! -f "/tmp/alarms/${dep}.triggered" ]; then
                echo "依赖告警 $dep 未触发"
                return 1
            fi
        done
    fi
    # 所有依赖满足，执行告警
    echo "所有依赖检查通过，触发告警: $alarm_type - $alarm_message"
    touch "/tmp/alarms/${alarm_type}.triggered"
    return 0
}
# 使用示例
execute_alarm_with_dependencies "HIGH_MEMORY" "内存使用率超过90%"

完整的依赖告警系统示例

#!/bin/bash
# 告警依赖管理系统
ALARM_CONFIG="/etc/alarm_dependencies.conf"
ALARM_STATE_DIR="/var/run/alarms"
LOG_FILE="/var/log/alarm_dependency.log"
# 初始化
init_alarm_system() {
    mkdir -p "$ALARM_STATE_DIR"
    touch "$LOG_FILE"
    # 创建默认依赖配置
    if [ ! -f "$ALARM_CONFIG" ]; then
        cat > "$ALARM_CONFIG" << EOF
# 告警依赖配置
# 格式:告警名称:依赖告警:超时时间(秒)
HIGH_CPU:CRITICAL_CPU:300
HIGH_MEMORY:HIGH_CPU,SWAP_USAGE:600
CRITICAL_DISK:HIGH_DISK:120
EOF
    fi
}
# 记录日志
log_message() {
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1" >> "$LOG_FILE"
}
# 读取依赖配置
get_dependencies() {
    local alarm_name="$1"
    grep -w "^${alarm_name}:" "$ALARM_CONFIG" | cut -d: -f2
}
# 获取超时时间
get_timeout() {
    local alarm_name="$1"
    grep -w "^${alarm_name}:" "$ALARM_CONFIG" | cut -d: -f3
}
# 检查单个依赖
check_single_dependency() {
    local dependency="$1"
    local timeout="$2"
    local dep_state_file="${ALARM_STATE_DIR}/${dependency}.state"
    if [ ! -f "$dep_state_file" ]; then
        log_message "依赖告警 $dependency 状态文件不存在"
        return 1
    fi
    # 获取依赖告警的状态和时间
    read -r state timestamp < "$dep_state_file"
    current_time=$(date +%s)
    # 检查是否在超时时间内
    if [ "$state" = "TRIGGERED" ] && [ $((current_time - timestamp)) -le "$timeout" ]; then
        return 0  # 依赖满足
    else
        log_message "依赖告警 $dependency 不满足（状态: $state, 时间: $timestamp）"
        return 1
    fi
}
# 更新告警状态
update_alarm_state() {
    local alarm_name="$1"
    local state="$2"
    local state_file="${ALARM_STATE_DIR}/${alarm_name}.state"
    echo "$state $(date +%s)" > "$state_file"
    log_message "更新告警 $alarm_name 状态为 $state"
}
# 主告警处理函数
process_alarm() {
    local alarm_name="$1"
    local alarm_message="$2"
    local alarm_severity="$3"
    log_message "处理告警: $alarm_name ($alarm_severity)"
    # 获取依赖
    dependencies=$(get_dependencies "$alarm_name")
    if [ -n "$dependencies" ]; then
        timeout=$(get_timeout "$alarm_name")
        timeout=${timeout:-300}  # 默认300秒
        log_message "检查依赖: $dependencies"
        IFS=',' read -ra dep_list <<< "$dependencies"
        for dep in "${dep_list[@]}"; do
            dep=$(echo "$dep" | tr -d ' ')
            if ! check_single_dependency "$dep" "$timeout"; then
                log_message "依赖检查失败，跳过告警 $alarm_name"
                return 1
            fi
        done
    fi
    # 执行告警
    log_message "触发告警: $alarm_name - $alarm_message"
    update_alarm_state "$alarm_name" "TRIGGERED"
    # 执行告警动作
    case "$alarm_severity" in
        CRITICAL)
            # 发送紧急通知
            echo "紧急告警: $alarm_message" | mail -s "CRITICAL: $alarm_name" admin@example.com
            ;;
        HIGH)
            # 发送邮件
            echo "高级告警: $alarm_message" | mail -s "HIGH: $alarm_name" team@example.com
            ;;
        MEDIUM)
            # 记录日志
            logger -t alarm "MEDIUM: $alarm_name - $alarm_message"
            ;;
    esac
    return 0
}
# 主程序
init_alarm_system
# 处理命令行参数
case "${1:-}" in
    trigger)
        process_alarm "$2" "$3" "${4:-MEDIUM}"
        ;;
    status)
        if [ -n "$2" ]; then
            cat "${ALARM_STATE_DIR}/${2}.state" 2>/dev/null || echo "未找到告警状态"
        else
            ls -la "$ALARM_STATE_DIR"
        fi
        ;;
    *)
        echo "用法: $0 {trigger|status} [alarm_name] [message] [severity]"
        exit 1
        ;;
esac

关键要点：

1. 使用状态文件：维持告警状态的持久化
2. 超时机制：避免依赖长期不满足
3. 日志记录：便于问题排查
4. 配置分离：依赖关系独立管理
5. 优先级控制：允许设置告警级别

这种设计可以有效管理复杂的告警依赖关系,确保告警触发的准确性和合理性。