Redis应用监控指标大盘点

马哥Linux运维 2026-04-09 146
加入交流群

马哥Linux运维

1579 文章 549w阅读 61粉丝

描述

背景与目的

Redis作为高性能内存数据库，广泛应用于缓存、会话存储、消息队列等场景。对Redis运行状况的有效监控，是保障业务稳定性的关键。本文的目的是帮助运维工程师建立完整的Redis监控知识体系，讲解需要监控哪些指标、如何采集这些指标、以及如何设置合理的告警阈值。

前置知识：本文假设你具备基本的Linux操作能力，了解Redis的基本概念和常用命令，有过Redis实际维护经验。

环境说明：本文基于Redis 7.4.x，Prometheus 2.50.x，Grafana 11.x。

1. Redis监控的重要性

1.1 监控不足的常见问题

性能问题：

内存接近上限，淘汰策略生效导致命中率下降

CPU单核瓶颈，请求处理变慢

网络带宽打满，请求超时

可用性问题：

主从复制中断，数据不一致

持久化失败，数据丢失风险

客户端连接耗尽，新请求被拒绝

容量问题：

内存规划不足，无法承载数据增长

bigkey导致内存分配失败

键数量接近上限（内存碎片）

1.2 监控体系架构

 

┌─────────────┐     ┌─────────────┐     ┌─────────────┐
│  应用层     │────│  Redis      │────│  监控层     │
│  (业务代码) │     │  (被监控)   │     │  (采集/存储)│
└─────────────┘     └─────────────┘     └─────────────┘
                           │                   │
                           │                   ▼
                           │            ┌─────────────┐
                           └───────────│  告警层     │
                                        │  (Alertmanager)│
                                        └─────────────┘

 

2. 基础运行指标

2.1 版本和进程信息

 

# 查看Redis版本
redis-cli INFO server | grep redis_version

# redis_version: 7.4.0
# redis_mode: standalone
# os: Linux 6.8.5 x86_64
# arch_bits: 64
# process_id: 12345
# tcp_port: 6379

 

2.2 uptime指标

 

# 查看运行时长
redis-cli INFO server | grep uptime_in

# uptime_in_seconds: 864000
# uptime_in_days: 10

# 监控脚本
#!/bin/bash
uptime_seconds=$(redis-cli INFO server | grep uptime_in_seconds | cut -d: -f2)
uptime_days=$(echo "scale=2; $uptime_seconds/86400" | bc)
echo "Redis运行时间：${uptime_days}天"

# 如果uptime过短（比如<1小时），可能是刚重启，需要告警

 

2.3 基础健康检查脚本

 

#!/bin/bash
# script: redis_health_check.sh
# 用途：Redis基础健康检查

echo "=== Redis健康检查 ==="

# 1. 检查进程是否存活
if redis-cli PING 2>/dev/null | grep -q PONG; then
    echo "✓ Redis进程存活"
else
    echo "✗ Redis进程不可用"
    exit 1
fi

# 2. 检查版本
VERSION=$(redis-cli INFO server | grep redis_version | cut -d: -f2 | tr -d '
')
echo "✓ 版本：$VERSION"

# 3. 检查运行时间
UPTIME=$(redis-cli INFO server | grep uptime_in_days | cut -d: -f2 | tr -d '
')
echo "✓ 运行天数：${UPTIME}天"

# 4. 检查是否可写
if redis-cli SET test_key test_value EX 10 > /dev/null; then
    redis-cli DEL test_key > /dev/null
    echo "✓ 可写"
else
    echo "✗ 不可写（可能内存已满）"
fi

# 5. 检查复制状态
ROLE=$(redis-cli INFO replication | grep role: | cut -d: -f2 | tr -d '
')
echo "✓ 角色：$ROLE"

 

3. 内存指标详解

3.1 核心内存指标

 

redis-cli INFO memory

# used_memory: 104857600          # Redis申请的总内存（字节）
# used_memory_human: 100.00M      # 人类可读格式
# used_memory_rss: 115673600      # 操作系统报告的物理内存占用
# used_memory_rss_human: 110.32M
# used_memory_peak: 209715200      # 历史峰值
# used_memory_peak_human: 200.00M
# used_memory_peak_perc: 100.00%  # 使用率百分比
# used_memory_lua: 33792          # Lua引擎内存
# used_memory_lua_human: 33.00K
# maxmemory: 1073741824           # 配置的最大内存
# maxmemory_human: 1.00G
# maxmemory_policy: allkeys-lru    # 淘汰策略
# memory_frag_ratio: 1.10         # 内存碎片率
# memory_frag_bytes:10737418      # 碎片字节数

 

3.2 内存告警脚本

 

#!/bin/bash
# script: redis_memory_alert.sh
# 用途：Redis内存告警检查

WARNING_THRESHOLD=80
CRITICAL_THRESHOLD=90

INFO=$(redis-cli INFO memory)
USED=$(echo "$INFO" | grep "^used_memory:" | cut -d: -f2 | tr -d '
')
MAX=$(echo "$INFO" | grep "^maxmemory:" | cut -d: -f2 | tr -d '
')
RSS=$(echo "$INFO" | grep "^used_memory_rss:" | cut -d: -f2 | tr -d '
')
FRAG=$(echo "$INFO" | grep "^mem_fragment_ratio:" | cut -d: -f2 | tr -d '
')

# 计算使用率
if [ "$MAX" != "0" ]; then
    USAGE=$(echo "scale=2; $USED * 100 / $MAX" | bc)

    echo "内存使用率：${USAGE}%"
    echo "已使用：$(echo "scale=2; $USED/1024/1024" | bc)MB"
    echo "最大限制：$(echo "scale=2; $MAX/1024/1024" | bc)MB"
    echo "物理占用：$(echo "scale=2; $RSS/1024/1024" | bc)MB"
    echo "碎片率：$FRAG"

    # 告警判断
    USAGE_INT=$(echo "$USAGE" | cut -d. -f1)

    if [ "$USAGE_INT" -ge "$CRITICAL_THRESHOLD" ]; then
        echo "ALERT: 内存使用率${USAGE}%，超过${CRITICAL_THRESHOLD}%，请立即处理！"
        # 发送告警
    elif [ "$USAGE_INT" -ge "$WARNING_THRESHOLD" ]; then
        echo "WARNING: 内存使用率${USAGE}%，超过${WARNING_THRESHOLD}%"
    fi
else
    echo "maxmemory未设置"
fi

 

3.3 内存指标详细说明

指标 说明 正常范围 异常处理
used_memory Redis申请的内存 - -
used_memory_rss 物理内存占用 - -
mem_fragment_ratio 碎片率 1.0-1.5 >2.0需优化
maxmemory 配置的最大内存 - -
mem_not_counted_for_evict 淘汰时不计入的内存 - -

4. 持久化指标

4.1 RDB持久化

 

redis-cli INFO persistence

# rdb_changes_since_last_save: 0          # 距上次保存后的变化次数
# rdb_bgsave_in_progress: 0              # bgsave是否进行中
# rdb_last_save_time: 1743619200         # 上次保存的Unix时间戳
# rdb_last_bgsave_status: ok             # 上次bgsave状态
# rdb_last_bgsave_time_sec: -1           # 上次bgsave耗时（秒）
# rdb_current_bgsave_time_sec: -1        # 当前bgsave已执行时间
# rdb_saves: 100                         # 累计保存次数

 

4.2 AOF持久化

 

redis-cli INFO persistence

# aof_enabled: 1                        # AOF是否启用
# aof_rewrite_in_progress: 0            # AOF重写是否进行中
# aof_rewrite_scheduled: 0              # 是否计划AOF重写
# aof_last_rewrite_time_sec: -1         # 上次AOF重写耗时
# aof_current_rewrite_time_sec: -1     # 当前AOF重写已执行时间
# aof_last_bgrewrite_status: ok         # 上次AOF重写状态
# aof_last_write_status: ok             # 上次AOF写入状态
# aof_delayed_fsync: 0                  # 延迟fsync次数

 

4.3 持久化监控脚本

 

#!/bin/bash
# script: redis_persistence_check.sh
# 用途：检查持久化健康状态

echo "=== Redis持久化检查 ==="

INFO=$(redis-cli INFO persistence)

# RDB检查
rdb_status=$(echo "$INFO" | grep "^rdb_last_bgsave_status:" | cut -d: -f2 | tr -d '
')
rdb_in_progress=$(echo "$INFO" | grep "^rdb_bgsave_in_progress:" | cut -d: -f2 | tr -d '
')
rdb_time=$(echo "$INFO" | grep "^rdb_last_bgsave_time_sec:" | cut -d: -f2 | tr -d '
')

echo "RDB状态："
echo "  上次保存状态：$rdb_status"
echo "  保存中：$rdb_in_progress"

if [ "$rdb_time" != "-1" ]; then
    echo "  耗时：${rdb_time}秒"
fi

# AOF检查
aof_enabled=$(echo "$INFO" | grep "^aof_enabled:" | cut -d: -f2 | tr -d '
')
aof_status=$(echo "$INFO" | grep "^aof_last_write_status:" | cut -d: -f2 | tr -d '
')

echo "AOF状态："
echo "  启用：$aof_enabled"
echo "  上次写入状态：$aof_status"

# 检查异常
if [ "$rdb_status" != "ok" ]; then
    echo "  RDB保存失败！"
fi

if [ "$aof_status" != "ok" ]; then
    echo "  AOF写入失败！"
fi

 

5. 主从复制指标

5.1 复制状态查看

 

# 主节点
redis-cli INFO replication

# role: master
# connected_slaves: 2
# slave0:ip=192.168.1.101,port=6379,state=online,offset=123456
# slave1:ip=192.168.1.102,port=6379,state=online,offset=123456
# master_repl_offset: 123456

# 从节点
redis-cli INFO replication

# role: slave
# master_host: 192.168.1.100
# master_port: 6379
# master_link_status: up
# master_repl_offset: 123456
# slave_repl_offset: 123456

 

5.2 复制延迟

 

#!/bin/bash
# script: check_replication_lag.sh
# 用途：检查主从复制延迟

INFO=$(redis-cli INFO replication)

echo "=== 复制状态检查 ==="

role=$(echo "$INFO" | grep "^role:" | cut -d: -f2 | tr -d '
')

if [ "$role" = "master" ]; then
    echo "角色：主节点"
    slaves=$(echo "$INFO" | grep "^slave" | wc -l)
    echo "从节点数量：$slaves"

    # 检查每个从节点的延迟
    echo "$INFO" | grep "^slave" | while IFS=, read -ra slave; do
        echo "  ${slave[0]}"
    done

elif [ "$role" = "slave" ]; then
    echo "角色：从节点"
    master=$(echo "$INFO" | grep "^master_host:" | cut -d: -f2 | tr -d '
')
    link_status=$(echo "$INFO" | grep "^master_link_status:" | cut -d: -f2 | tr -d '
')

    echo "主节点：$master"
    echo "连接状态：$link_status"

    if [ "$link_status" != "up" ]; then
        echo "  主从连接中断！"
    fi
fi

 

5.3 复制相关指标说明

指标 说明 正常值 告警阈值
connected_slaves 连接的从节点数 - 与预期不符
master_link_status 主从连接状态 up down
slave_repl_offset 从节点复制偏移量 - 与主节点差异大
master_repl_offset 主节点复制偏移量 - -
replication_lag 复制延迟（秒） 0 >10秒

6. 客户端连接指标

6.1 连接统计

 

redis-cli INFO clients

# connected_clients: 50               # 当前连接的客户端数
# cluster_connections: 0              # 集群连接数
# maxclients: 10000                   # 最大客户端数限制
# blocked_clients: 0                  # 阻塞中的客户端数（BLPOP等）
# tracking_clients: 0                # 客户端追踪数

 

6.2 客户端列表

 

# 查看所有客户端
redis-cli CLIENT LIST

# 输出格式：
# id=1 addr=192.168.1.100:12345 fd=8 name= age=100 idle=0 flags=N db=0 sub=0 pub=0 multi=-1 cmd=ping

# 字段说明：
# id: 客户端ID
# addr: IP和端口
# fd: 文件描述符
# idle: 空闲时间（秒）
# flags: 客户端类型（N=普通，M=master，S=slave）
# cmd: 最近执行的命令

 

6.3 连接监控脚本

 

#!/bin/bash
# script: redis_clients_check.sh
# 用途：检查客户端连接状态

echo "=== Redis客户端检查 ==="

INFO=$(redis-cli INFO clients)
CLIENTS=$(echo "$INFO" | grep "^connected_clients:" | cut -d: -f2 | tr -d '
')
MAX=$(echo "$INFO" | grep "^maxclients:" | cut -d: -f2 | tr -d '
')
BLOCKED=$(echo "$INFO" | grep "^blocked_clients:" | cut -d: -f2 | tr -d '
')

echo "当前连接数：$CLIENTS"
echo "最大限制：$MAX"
echo "阻塞客户端：$BLOCKED"

# 计算使用率
if [ "$MAX" != "0" ]; then
    USAGE=$(echo "scale=2; $CLIENTS * 100 / $MAX" | bc)
    echo "连接使用率：${USAGE}%"

    # 告警阈值
    if (( $(echo "$USAGE > 80" | bc -l) )); then
        echo "  连接数接近上限！"
    fi
fi

# 查找空闲连接
echo ""
echo "空闲超过1小时的连接："
redis-cli CLIENT LIST | awk -F'[,=]' '$5>3600 {print $2, $5"秒"}'

 

6.4 连接异常检测

 

#!/bin/bash
# script: detect_client_issues.sh
# 用途：检测客户端连接异常

echo "=== 客户端异常检测 ==="

# 1. 检测长期空闲连接
echo "【1】空闲连接（>1小时）："
redis-cli CLIENT LIST | while IFS=, read -ra fields; do
    idle=$(echo "${fields[@]}" | grep -oP 'idle=Kd+')
    if [ -n "$idle" ] && [ "$idle" -gt 3600 ]; then
        addr=$(echo "${fields[@]}" | grep -oP 'addr=K[w.:]+')
        echo "  $addr idle=${idle}s"
    fi
done

# 2. 检测异常IP连接
echo ""
echo "【2】连接数最多的IP："
redis-cli CLIENT LIST | awk -F'[=, ]' '{print $4}' | sort | uniq -c | sort -rn | head -5

# 3. 杀掉空闲连接
read -p "是否关闭空闲超过6小时的连接？(y/N): " confirm
if [ "$confirm" = "y" ]; then
    redis-cli CLIENT LIST | while IFS=, read -ra fields; do
        idle=$(echo "${fields[@]}" | grep -oP 'idle=Kd+')
        id=$(echo "${fields[@]}" | grep -oP '^id=Kd+')
        if [ -n "$idle" ] && [ "$idle" -gt 21600 ]; then
            echo "关闭连接: $id (idle=${idle}s)"
            redis-cli CLIENT KILL ID "$id"
        fi
    done
fi

 

7. 键空间统计

7.1 keyspace信息

 

redis-cli INFO keyspace

# db0:keys=1000000,expires=500000,avg_ttl=3600000000
# db1:keys=0,expires=0,avg_ttl=0

# 字段说明：
# keys: 键数量
# expires: 有过期时间的键数量
# avg_ttl: 平均TTL（纳秒）

 

7.2 键统计脚本

 

#!/bin/bash
# script: redis_keyspace_stats.sh
# 用途：键空间统计分析

echo "=== Redis键空间统计 ==="

# 查看每个数据库
redis-cli INFO keyspace

echo ""

# 键数量变化趋势
echo "【键数量历史记录】"
if [ -f /tmp/redis_keys_history.txt ]; then
    tail -20 /tmp/redis_keys_history.txt
else
    echo "无历史记录"
fi

# 记录当前数据
DBINFO=$(redis-cli INFO keyspace | grep "^db0:")
KEYS=$(echo "$DBINFO" | cut -d: -f2 | cut -d, -f1 | cut -d= -f2)
DATE=$(date +%Y-%m-%d %H:%M:%S)
echo "$DATE $KEYS" >> /tmp/redis_keys_history.txt

# 计算增长率
if [ -f /tmp/redis_keys_prev.txt ]; then
    PREV=$(cat /tmp/redis_keys_prev.txt)
    PREV_KEYS=$(echo "$PREV" | awk '{print $2}')
    PREV_TIME=$(echo "$PREV" | awk '{print $1}')
    PREV_TS=$(date -d "$PREV_TIME" +%s 2>/dev/null || echo "0")
    CUR_TS=$(date +%s)

    DIFF=$((KEYS - PREV_KEYS))
    TIME_DIFF=$((CUR_TS - PREV_TS))

    if [ "$TIME_DIFF" -gt 0 ]; then
        RATE=$(echo "scale=2; $DIFF / $TIME_DIFF" | bc)
        echo "键增长率：$RATE 键/秒"
    fi
fi

echo "$DATE $KEYS" > /tmp/redis_keys_prev.txt

# 大键统计
echo ""
echo "【键大小分布】"
redis-cli --scan --pattern '*' | head -1000 | while read key; do
    type=$(redis-cli TYPE "$key" 2>/dev/null)
    if [ "$type" = "string" ]; then
        len=$(redis-cli STRLEN "$key" 2>/dev/null)
    elif [ "$type" = "list" ]; then
        len=$(redis-cli LLEN "$key" 2>/dev/null)
    elif [ "$type" = "set" ]; then
        len=$(redis-cli SCARD "$key" 2>/dev/null)
    elif [ "$type" = "zset" ]; then
        len=$(redis-cli ZCARD "$key" 2>/dev/null)
    elif [ "$type" = "hash" ]; then
        len=$(redis-cli HLEN "$key" 2>/dev/null)
    fi
    echo "$key|$type|$len"
done | awk -F'|' '{print $2,$3}' | sort | uniq -c | sort -rn | head -10

 

8. 命令统计

8.1 commandstats

 

redis-cli INFO commandstats

# cmdstat_get:calls=1000000,usec=5000000,usec_per_call=5.00
# cmdstat_set:calls=500000,usec=3000000,usec_per_call=6.00
# cmdstat_del:calls=100000,usec=1000000,usec_per_call=10.00

 

8.2 慢命令分析

 

#!/bin/bash
# script: analyze_slow_commands.sh
# 用途：分析执行最慢的命令

echo "=== 慢命令分析 ==="

redis-cli INFO commandstats | grep "^cmdstat" | while IFS=: read -ra line; do
    cmd=${line[0]#cmdstat_}
    stats=${line[1]}

    calls=$(echo "$stats" | grep -oP 'calls=Kd+')
    usec=$(echo "$stats" | grep -oP 'usec=Kd+')

    if [ -n "$calls" ] && [ -n "$usec" ]; then
        avg_usec=$(echo "scale=2; $usec / $calls" | bc)
        echo "$cmd: $calls次, 平均${avg_usec}微秒"
    fi
done | sort -t: -k4 -rn | head -10

 

9. 吞吐指标

9.1 QPS计算

 

# 查看统计数据
redis-cli INFO stats

# instantaneous_ops_per_sec: 5000    # 每秒操作数
# total_commands_processed: 10000000 # 累计处理命令数
# rejected_commands: 0               # 被拒绝的命令数

 

9.2 QPS监控脚本

 

#!/bin/bash
# script: redis_qps_monitor.sh
# 用途：监控Redis QPS

echo "=== Redis QPS监控 ==="

INFO=$(redis-cli INFO stats)

OPS=$(echo "$INFO" | grep "^instantaneous_ops_per_sec:" | cut -d: -f2 | tr -d '
')
TOTAL=$(echo "$INFO" | grep "^total_commands_processed:" | cut -d: -f2 | tr -d '
')
REJECTED=$(echo "$INFO" | grep "^rejected_commands:" | cut -d: -f2 | tr -d '
')
CONNECTIONS=$(echo "$INFO" | grep "^total_connections_received:" | cut -d: -f2 | tr -d '
')

echo "当前QPS：$OPS"
echo "累计处理命令：$TOTAL"
echo "被拒绝命令：$REJECTED"
echo "累计连接数：$CONNECTIONS"

# 记录QPS历史
echo "$(date +%Y-%m-%d %H:%M:%S) $OPS" >> /tmp/redis_qps_history.txt

# 计算平均QPS
if [ -f /tmp/redis_qps_history.txt ]; then
    echo ""
    echo "【QPS趋势（最近10分钟）】"
    tail -10 /tmp/redis_qps_history.txt
fi

 

9.3 延迟监控

 

#!/bin/bash
# script: redis_latency_monitor.sh
# 用途：监控Redis延迟

echo "=== Redis延迟监控 ==="

# 基准延迟测试
echo "【Redis延迟基准测试】"
for i in {1..5}; do
    start=$(date +%s%N)
    redis-cli PING > /dev/null
    end=$(date +%s%N)
    latency=$(( (end - start) / 1000000 ))
    echo "  测试$i: ${latency}ms"
done

# 使用redis-cli内置延迟测试
if command -v redis-cli &> /dev/null; then
    echo ""
    echo "【延迟分布】"
    redis-cli --latency-history
fi

 

10. Sentinel/Cluster状态

10.1 Redis Sentinel监控

 

# 查看Sentinel状态
redis-cli SENTINEL masters

# 查看特定master
redis-cli SENTINEL master mymaster

# 查看从节点
redis-cli SENTINEL slaves mymaster

# 查看Sentinel实例
redis-cli SENTINEL sentinels mymaster

 

10.2 Sentinel监控脚本

 

#!/bin/bash
# script: redis_sentinel_monitor.sh
# 用途：监控Redis Sentinel状态

echo "=== Redis Sentinel监控 ==="

MASTER_NAME="mymaster"

# 获取主节点信息
MASTER=$(redis-cli SENTINEL get-master-addr-by-name "$MASTER_NAME")
echo "主节点：$MASTER"

# 检查主节点状态
MASTER_STATUS=$(redis-cli SENTINEL master "$MASTER_NAME" | grep -E "^status$" | awk '{print $2}')
echo "主节点状态：$MASTER_STATUS"

# 获取从节点列表
echo ""
echo "从节点："
redis-cli SENTINEL slaves "$MASTER_NAME" | while read line; do
    echo "  $line"
done

# 检查主观下线
SDOWN=$(redis-cli SENTINEL masters | grep -A1 "name" | head -2)
echo ""
echo "主观下线状态：$SDOWN"

 

10.3 Redis Cluster状态

 

# 查看集群状态
redis-cli cluster info

# 输出：
# cluster_state: ok
# cluster_slots_assigned: 16384
# cluster_slots_ok: 16384
# cluster_nodes: 6

 

10.4 Cluster监控脚本

 

#!/bin/bash
# script: redis_cluster_monitor.sh
# 用途：监控Redis Cluster状态

echo "=== Redis Cluster监控 ==="

INFO=$(redis-cli cluster info)

STATE=$(echo "$INFO" | grep "^cluster_state:" | cut -d: -f2 | tr -d '
')
SLOTS=$(echo "$INFO" | grep "^cluster_slots_assigned:" | cut -d: -f2 | tr -d '
')
SLOTS_OK=$(echo "$INFO" | grep "^cluster_slots_ok:" | cut -d: -f2 | tr -d '
')
NODES=$(echo "$INFO" | grep "^cluster_nodes:" | cut -d: -f2 | tr -d '
')

echo "集群状态：$STATE"
echo "已分配槽：$SLOTS"
echo "正常槽：$SLOTS_OK"
echo "节点数：$NODES"

# 检查槽分配
if [ "$SLOTS" != "16384" ]; then
    echo "  槽分配不完整！"
fi

if [ "$SLOTS" != "$SLOTS_OK" ]; then
    echo "  存在故障槽！"
fi

# 检查节点状态
echo ""
echo "节点详情："
redis-cli cluster nodes | while read line; do
    echo "  $line"
done

 

11. 监控工具对比

11.1 redis-cli内置工具

 

# 实时监控
redis-cli MONITOR

# 实时统计
redis-cli INFO

# 大键扫描
redis-cli --bigkeys

# 延迟测试
redis-cli --latency
redis-cli --latency-history

# 慢查询
redis-cli SLOWLOG GET 10

# 内存分析
redis-cli MEMORY STATS
redis-cli MEMORY USAGE key

 

11.2 Prometheus + Grafana

 

# prometheus.yml
scrape_configs:
  - job_name: 'redis'
    static_configs:
      - targets: ['localhost:6379']
    metrics_path: /metrics

 

关键指标：

 

# redis_exporter采集的指标
redis_memory_used_bytes
redis_memory_max_bytes
redis_connected_clients
redis_commands_total
redis_command_duration_seconds_total
redis_up

 

11.3 Grafana仪表盘

推荐使用社区仪表盘：

Redis Dashboard (ID: 763)

Redis / Prometheus (ID: 14091)

11.4 监控工具对比

工具 优点 缺点 适用场景
redis-cli 无需安装，功能全面 无法长期存储 临时诊断
Prometheus 时序存储，告警 需要额外组件 生产监控
Grafana 可视化丰富 依赖其他数据源 数据展示
redis_exporter 标准化采集 有资源开销 Prometheus生态
Supervisor 进程管理 非监控工具 进程保活

12. 告警阈值设置参考

12.1 内存告警

 

# Prometheus告警规则
groups:
  - name: redis
    rules:
      # 内存使用率警告
      - alert: RedisMemoryUsageHigh
        expr: redis_memory_used_bytes / redis_memory_max_bytes > 0.8
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "Redis内存使用率高"
          description: "实例{{ $labels.instance }}内存使用率{{ $value | humanizePercentage }}"

      # 内存使用率危急
      - alert: RedisMemoryUsageCritical
        expr: redis_memory_used_bytes / redis_memory_max_bytes > 0.9
        for: 1m
        labels:
          severity: critical
        annotations:
          summary: "Redis内存使用率危急"
          description: "实例{{ $labels.instance }}内存即将耗尽，请立即处理！"

      # 内存碎片过高
      - alert: RedisHighFragmentation
        expr: redis_mem_fragmentation_ratio > 1.5
        for: 10m
        labels:
          severity: warning

 

12.2 连接告警

 

      # 连接数过高
      - alert: RedisHighConnections
        expr: redis_connected_clients / redis_config_maxclients > 0.8
        for: 5m
        labels:
          severity: warning

 

12.3 复制告警

 

      # 主从复制中断
      - alert: RedisReplicationDown
        expr: redis_connected_slaves < 1
        for: 1m
        labels:
          severity: critical
        for: 1m

 

12.4 性能告警

 

      # 内存驱逐过多
      - alert: RedisHighEviction
        expr: rate(redis_evicted_keys_total[5m]) > 10
        for: 5m
        labels:
          severity: warning

      # 命令拒绝
      - alert: RedisCommandRejected
        expr: redis_rejected_commands_total > 0
        for: 1m
        labels:
          severity: critical

 

13. 总结：监控大盘设计

13.1 核心监控指标

必选指标（Critical）：

内存使用率 used_memory / maxmemory

客户端连接数 connected_clients

主从复制状态 master_link_status

持久化状态 last_bgsave_status

重要指标（Important）：

QPS instantaneous_ops_per_sec

复制延迟 slave_repl_offset

内存碎片率 mem_fragmentation_ratio

淘汰键数量 evicted_keys

命令执行时间 commandstats

可选指标（Optional）：

Lua脚本内存 used_memory_lua

客户端追踪数 tracking_clients

阻塞客户端数 blocked_clients

13.2 监控Checklist

 

【基础设施层】
□ 进程存活 (redis-cli PING)
□ 进程重启次数
□ 运行时间 (uptime)

【内存层】
□ 内存使用率
□ 内存碎片率
□ 淘汰策略生效次数
□ maxmemory配置

【连接层】
□ 客户端连接数
□ 阻塞客户端数
□ 最大连接数限制

【持久化层】
□ RDB最后保存状态
□ AOF最后写入状态
□ BGSAVE执行情况

【复制层】
□ 主从连接状态
□ 复制延迟
□ 从节点数量

【性能层】
□ QPS
□ 命令执行时间
□ 慢查询数量

 

13.3 告警处理流程

 

【告警触发】
    │
    ▼
【确认告警有效性】
    │
    ▼
【初步判断】
    - 内存告警 → 检查数据增长、淘汰策略
    - 连接告警 → 检查连接泄漏、空闲连接
    - 复制告警 → 检查网络、从节点状态
    - 性能告警 → 检查慢查询、大键
    │
    ▼
【快速处理】
    - 扩容内存
    - 清理连接
    - 重启复制
    │
    ▼
【根因分析】
    - 分析数据增长原因
    - 检查代码逻辑
    - 优化配置参数
    │
    ▼
【长效机制】
    - 调整监控阈值
    - 优化容量规划
    - 完善告警规则

 

13.4 监控命令速查

指标 查看命令 监控脚本函数
内存 INFO memory grep used_memory
连接 INFO clients grep connected_clients
持久化 INFO persistence grep rdb/aof
复制 INFO replication grep slave/master
键空间 INFO keyspace grep db0
命令 INFO commandstats cmdstat_*
性能 INFO stats instantaneous_ops_per_sec

参考信息

版本信息：

Redis：7.4.x

Prometheus：2.50.x

Grafana：11.x

redis_exporter：最新稳定版

操作系统：Rocky Linux 9.4

相关文档：

Redis官方文档：Monitoring

Prometheus redis_exporter

Grafana Redis Dashboard

延伸阅读：

《Redis in Action》

Redis University: Redis for Operations

 

打开APP阅读更多精彩内容
声明：本文内容及配图由入驻作者撰写或者入驻合作网站授权转载。文章观点仅代表作者本人，不代表电子发烧友网立场。文章及其配图仅供工程师学习之用，如有内容侵权或者其他违规问题，请联系本站处理。 举报投诉

全部0条评论

快来发表一下你的评论吧 !

下载APP
|投诉反馈|电子发烧友网
© 2021 elecfans.com
湘ICP备2023036445号-105
×
20
完善资料，
赚取积分