SenseVoice-small实战教程：Prometheus+Grafana监控WebUI服务健康度

大数据无毛兽

408人浏览 · 2026-03-08 05:03:14

大数据无毛兽 · 2026-03-08 05:03:14 发布

SenseVoice-small实战教程：Prometheus+Grafana监控WebUI服务健康度

1. 引言：为什么需要监控语音识别服务？

想象一下，你部署了一个非常棒的语音识别服务，用户可以通过网页上传录音，系统就能快速转成文字。但某天早上，用户反馈说网页打不开了，或者识别速度变得特别慢。你登录服务器一看，发现服务已经悄悄崩溃了几个小时，期间所有用户的请求都失败了。

这种情况在线上服务中并不少见。SenseVoice-small作为一个轻量级多任务语音模型，虽然部署简单、资源占用低，但只要是服务，就可能遇到各种问题：内存泄漏、CPU跑满、网络波动，或者只是简单的进程挂掉。等到用户投诉才发现问题，往往已经造成了不好的体验。

这就是服务监控的价值所在。它就像给服务装上了“健康监测仪”，能实时告诉你：

服务还活着吗？
响应速度正常吗？
资源使用情况如何？
有没有异常错误？

今天，我们就来实战搭建一套专业的监控系统，用Prometheus采集数据，用Grafana展示仪表盘，7x24小时守护你的SenseVoice-small WebUI服务。无论你是用在手机平板的离线语音助手，还是边缘计算的会议纪要系统，这套监控方案都能让你对服务状态了如指掌。

2. 监控方案设计：Prometheus + Grafana 黄金组合

在开始动手之前，我们先了解一下这套监控方案的整体设计。它由三个核心组件组成，各司其职，共同构建了一个完整的监控体系。

2.1 监控架构概览

┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
│                 │    │                 │    │                 │
│  SenseVoice     │───▶│   Prometheus    │───▶│    Grafana      │
│  WebUI 服务     │    │   (数据采集)    │    │   (数据展示)    │
│                 │    │                 │    │                 │
└─────────────────┘    └─────────────────┘    └─────────────────┘
        │                       │                       │
        │ 暴露/metrics端点      │ 定时抓取数据         │ 查询数据并可视化
        │                       │                       │
        ▼                       ▼                       ▼
┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
│  Prometheus     │    │   Alertmanager  │    │   邮件/钉钉     │
│  Client库       │    │   (告警管理)    │    │   告警通知      │
│  (Python)       │    │                 │    │                 │
└─────────────────┘    └─────────────────┘    └─────────────────┘

各组件分工明确：

SenseVoice WebUI服务：通过Prometheus Client库暴露监控指标
Prometheus：定时抓取这些指标并存储到时序数据库
Grafana：从Prometheus查询数据，用漂亮的图表展示出来
Alertmanager（可选）：管理告警规则，发送通知

2.2 我们要监控什么？

对于SenseVoice-small WebUI服务，我们主要关注以下几个维度的健康度：

监控维度	具体指标	为什么重要
服务可用性	服务是否运行、HTTP接口是否可达	最基本的要求，服务挂了什么都白搭
性能表现	请求响应时间、识别耗时、QPS（每秒查询数）	直接影响用户体验，慢了用户会流失
资源使用	CPU使用率、内存占用、磁盘IO	资源不足会导致服务变慢或崩溃
业务指标	识别成功率、各语言使用比例、情感分析分布	了解业务运行情况，优化服务
错误监控	HTTP错误码、异常堆栈、识别失败次数	及时发现并修复问题

2.3 环境准备

在开始之前，请确保你的服务器已经部署了SenseVoice-small WebUI服务。如果你还没有部署，可以参考之前的教程先完成部署。

系统要求：

Linux服务器（Ubuntu/CentOS等）
Docker和Docker Compose（推荐方式）
或者直接安装Python环境
至少1GB可用内存（监控组件本身占用不大）

3. 第一步：为SenseVoice WebUI添加监控端点

监控的第一步是让我们的服务能够“说出”自己的健康状况。我们需要在现有的SenseVoice WebUI服务中集成Prometheus Client，暴露一个/metrics端点，供Prometheus抓取数据。

3.1 安装Prometheus Client库

首先，进入你的SenseVoice-small项目目录。如果你按照标准方式部署，路径应该是/root/sensevoice-small-语音识别-onnx。

cd /root/sensevoice-small-语音识别-onnx

激活你的Python虚拟环境（如果使用了的话），然后安装必要的依赖：

# 如果你使用了conda环境
conda activate torch29

# 安装Prometheus Python客户端
pip install prometheus-client==0.20.0

这个库非常轻量，不会对现有服务造成明显影响。

3.2 修改WebUI代码添加监控

我们需要修改WebUI的主文件来添加监控功能。找到你的WebUI入口文件，通常是app.py或webui.py。

备份原始文件（重要！）：

cp webui.py webui.py.backup

然后编辑文件，在合适的位置添加监控代码。以下是完整的修改示例：

#!/usr/bin/env python3
"""
SenseVoice-small WebUI with Prometheus Monitoring
"""

import os
import time
import logging
from datetime import datetime
from flask import Flask, request, jsonify, render_template
from prometheus_client import make_wsgi_app, Counter, Histogram, Gauge
from werkzeug.middleware.dispatcher import DispatcherMiddleware

# 创建Flask应用
app = Flask(__name__)

# ==================== Prometheus Metrics 定义 ====================

# 计数器：总请求数
REQUEST_COUNT = Counter(
    'sensevoice_http_requests_total',
    'Total HTTP requests',
    ['method', 'endpoint', 'status']
)

# 直方图：请求耗时分布
REQUEST_LATENCY = Histogram(
    'sensevoice_http_request_duration_seconds',
    'HTTP request latency in seconds',
    ['method', 'endpoint']
)

# 仪表盘：当前正在处理的请求数
IN_PROGRESS = Gauge(
    'sensevoice_http_requests_in_progress',
    'Number of in-progress HTTP requests',
    ['method', 'endpoint']
)

# 计数器：语音识别请求数
RECOGNITION_REQUESTS = Counter(
    'sensevoice_recognition_requests_total',
    'Total speech recognition requests',
    ['language', 'status']
)

# 直方图：识别耗时分布
RECOGNITION_LATENCY = Histogram(
    'sensevoice_recognition_duration_seconds',
    'Speech recognition latency in seconds',
    ['language']
)

# 仪表盘：服务运行时间
SERVICE_UPTIME = Gauge(
    'sensevoice_service_uptime_seconds',
    'Service uptime in seconds'
)

# 仪表盘：内存使用量（MB）
MEMORY_USAGE = Gauge(
    'sensevoice_memory_usage_mb',
    'Memory usage in MB'
)

# 记录服务启动时间
start_time = time.time()

# ==================== 监控中间件 ====================

@app.before_request
def before_request():
    """记录请求开始时间"""
    request.start_time = time.time()
    IN_PROGRESS.labels(request.method, request.path).inc()

@app.after_request
def after_request(response):
    """记录请求完成信息"""
    # 计算请求耗时
    latency = time.time() - request.start_time
    REQUEST_LATENCY.labels(request.method, request.path).observe(latency)
    
    # 记录请求计数
    REQUEST_COUNT.labels(request.method, request.path, response.status_code).inc()
    
    # 减少正在处理的请求数
    IN_PROGRESS.labels(request.method, request.path).dec()
    
    # 更新运行时间
    SERVICE_UPTIME.set(time.time() - start_time)
    
    # 更新内存使用（示例，实际需要根据情况调整）
    try:
        import psutil
        process = psutil.Process()
        memory_mb = process.memory_info().rss / 1024 / 1024
        MEMORY_USAGE.set(memory_mb)
    except:
        pass  # 如果无法获取内存信息，忽略
    
    return response

# ==================== 原有路由处理 ====================

@app.route('/')
def index():
    """主页"""
    return render_template('index.html')

@app.route('/api/recognize', methods=['POST'])
def recognize():
    """语音识别接口"""
    start_time = time.time()
    
    try:
        # 获取请求参数
        audio_file = request.files.get('audio')
        language = request.form.get('language', 'auto')
        
        if not audio_file:
            RECOGNITION_REQUESTS.labels(language=language, status='error').inc()
            return jsonify({'error': 'No audio file provided'}), 400
        
        # 这里调用实际的识别逻辑
        # result = your_recognition_function(audio_file, language)
        
        # 模拟识别结果
        result = {
            'text': '这是一个测试识别结果',
            'language': 'zh',
            'emotion': 'neutral',
            'confidence': 0.95
        }
        
        # 计算识别耗时
        recognition_time = time.time() - start_time
        RECOGNITION_LATENCY.labels(language=language).observe(recognition_time)
        RECOGNITION_REQUESTS.labels(language=language, status='success').inc()
        
        return jsonify(result)
        
    except Exception as e:
        RECOGNITION_REQUESTS.labels(language=language or 'unknown', status='error').inc()
        logging.error(f"Recognition error: {str(e)}")
        return jsonify({'error': str(e)}), 500

@app.route('/health')
def health_check():
    """健康检查端点"""
    return jsonify({
        'status': 'healthy',
        'timestamp': datetime.now().isoformat(),
        'uptime': time.time() - start_time
    })

# ==================== 主程序 ====================

if __name__ == '__main__':
    # 创建DispatcherMiddleware，将/metrics路由交给Prometheus
    app.wsgi_app = DispatcherMiddleware(app.wsgi_app, {
        '/metrics': make_wsgi_app()
    })
    
    # 启动服务
    app.run(host='0.0.0.0', port=7860, debug=False)

关键修改说明：

导入Prometheus客户端库：from prometheus_client import make_wsgi_app, Counter, Histogram, Gauge
定义监控指标：创建了7个核心指标，覆盖请求、识别、资源等维度
添加监控中间件：@app.before_request和@app.after_request装饰器自动记录每个请求
集成/metrics端点：通过DispatcherMiddleware将/metrics路由交给Prometheus
在识别接口中添加监控：记录识别请求的成功/失败、耗时等信息

3.3 安装额外依赖

修改后的代码需要额外的依赖，创建或更新requirements.txt文件：

# 创建requirements.txt
cat > requirements.txt << EOF
flask>=2.0.0
prometheus-client==0.20.0
werkzeug==2.0.0
psutil==5.9.0
EOF

# 安装依赖
pip install -r requirements.txt

3.4 测试监控端点

重启WebUI服务，然后测试监控端点是否正常工作：

# 重启服务（根据你的部署方式）
supervisorctl restart sensevoice:sensevoice-webui

# 等待几秒后测试
curl http://localhost:7860/health
curl http://localhost:7860/metrics

如果一切正常，访问/metrics应该能看到类似这样的输出：

# HELP sensevoice_http_requests_total Total HTTP requests
# TYPE sensevoice_http_requests_total counter
sensevoice_http_requests_total{method="GET",endpoint="/",status="200"} 1.0

# HELP sensevoice_http_request_duration_seconds HTTP request latency in seconds
# TYPE sensevoice_http_request_duration_seconds histogram
sensevoice_http_request_duration_seconds_bucket{method="GET",endpoint="/",le="0.005"} 0.0
sensevoice_http_request_duration_seconds_bucket{method="GET",endpoint="/",le="0.01"} 1.0
sensevoice_http_request_duration_seconds_bucket{method="GET",endpoint="/",le="0.025"} 1.0
...

看到这些指标数据，说明监控端点已经成功集成了！

4. 第二步：部署Prometheus数据采集器

现在我们的服务已经能够“说出”自己的状态了，接下来需要部署一个“听众”——Prometheus，来定期收集这些指标数据。

4.1 使用Docker快速部署Prometheus

最简单的方式是使用Docker Compose。创建一个docker-compose.yml文件：

version: '3.8'

services:
  prometheus:
    image: prom/prometheus:latest
    container_name: prometheus
    restart: unless-stopped
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml
      - prometheus_data:/prometheus
    command:
      - '--config.file=/etc/prometheus/prometheus.yml'
      - '--storage.tsdb.path=/prometheus'
      - '--web.console.libraries=/etc/prometheus/console_libraries'
      - '--web.console.templates=/etc/prometheus/consoles'
      - '--storage.tsdb.retention.time=30d'
      - '--web.enable-lifecycle'
    ports:
      - "9090:9090"
    networks:
      - monitoring

volumes:
  prometheus_data:

networks:
  monitoring:
    driver: bridge

4.2 配置Prometheus抓取规则

创建Prometheus配置文件prometheus.yml：

global:
  scrape_interval: 15s  # 每15秒抓取一次数据
  evaluation_interval: 15s  # 每15秒评估一次告警规则
  scrape_timeout: 10s  # 抓取超时时间

# 告警规则配置
rule_files:
  # - "alert_rules.yml"

# 抓取配置
scrape_configs:
  # Prometheus自身监控
  - job_name: 'prometheus'
    static_configs:
      - targets: ['localhost:9090']
    scrape_interval: 15s

  # SenseVoice WebUI服务监控
  - job_name: 'sensevoice-webui'
    static_configs:
      - targets: ['host.docker.internal:7860']  # Docker内部访问宿主机
        labels:
          service: 'sensevoice-webui'
          environment: 'production'
    scrape_interval: 15s
    metrics_path: '/metrics'
    
  # 节点监控（系统资源）
  - job_name: 'node-exporter'
    static_configs:
      - targets: ['host.docker.internal:9100']
        labels:
          service: 'node-exporter'
          environment: 'production'
    scrape_interval: 15s

# 告警管理器配置
alerting:
  alertmanagers:
    - static_configs:
        - targets: []
      # - targets: ['alertmanager:9093']

重要配置说明：

scrape_interval: 15s：每15秒抓取一次数据，这个频率对大多数场景都合适
targets: ['host.docker.internal:7860']：Docker容器内访问宿主机服务的特殊地址
metrics_path: '/metrics'：指定抓取的端点路径
labels：为监控目标添加标签，方便后续筛选和分组

4.3 启动Prometheus

创建好配置文件后，启动Prometheus服务：

# 创建配置目录
mkdir -p /root/monitoring/prometheus
cd /root/monitoring

# 将上面的docker-compose.yml和prometheus.yml放到这个目录
# 启动服务
docker-compose up -d

# 查看运行状态
docker-compose ps

# 查看日志
docker-compose logs -f prometheus

4.4 验证Prometheus是否正常工作

等待几秒钟后，访问Prometheus的Web界面：

地址：http://你的服务器IP:9090
或者本地访问：http://localhost:9090

在Prometheus界面中，点击顶部菜单的"Status" → "Targets"，应该能看到类似这样的状态：

Endpoint                    State     Labels                                   Last Scrape
http://host.docker.internal:7860/metrics  UP       environment="production",job="sensevoice-webui",service="sensevoice-webui"  3.456s ago
http://localhost:9090/metrics             UP       job="prometheus"                                           3.123s ago

如果状态显示为"UP"（绿色），说明Prometheus已经成功连接到SenseVoice WebUI服务并开始采集数据了。

4.5 添加系统监控（可选但推荐）

为了监控服务器的CPU、内存、磁盘等系统资源，我们可以部署Node Exporter。创建docker-compose.node.yml文件：

version: '3.8'

services:
  node-exporter:
    image: prom/node-exporter:latest
    container_name: node-exporter
    restart: unless-stopped
    volumes:
      - /proc:/host/proc:ro
      - /sys:/host/sys:ro
      - /:/rootfs:ro
    command:
      - '--path.procfs=/host/proc'
      - '--path.rootfs=/rootfs'
      - '--path.sysfs=/host/sys'
      - '--collector.filesystem.mount-points-exclude=^/(sys|proc|dev|host|etc)($$|/)'
    ports:
      - "9100:9100"
    networks:
      - monitoring

networks:
  monitoring:
    external: true
    name: monitoring_default

启动Node Exporter：

# 创建网络（如果不存在）
docker network create monitoring_default 2>/dev/null || true

# 启动Node Exporter
docker-compose -f docker-compose.node.yml up -d

# 验证
curl http://localhost:9100/metrics | head -20

现在Prometheus会同时监控SenseVoice服务和服务器系统资源。

5. 第三步：使用Grafana创建监控仪表盘

数据采集好了，接下来我们需要一个漂亮的界面来展示这些数据。Grafana就是专门做这个的——它可以从Prometheus读取数据，然后用各种图表展示出来。

5.1 部署Grafana

创建docker-compose.grafana.yml文件：

version: '3.8'

services:
  grafana:
    image: grafana/grafana:latest
    container_name: grafana
    restart: unless-stopped
    environment:
      - GF_SECURITY_ADMIN_PASSWORD=admin123  # 初始密码，请修改！
      - GF_INSTALL_PLUGINS=grafana-piechart-panel
    volumes:
      - grafana_data:/var/lib/grafana
      - ./grafana/provisioning:/etc/grafana/provisioning
    ports:
      - "3000:3000"
    networks:
      - monitoring

volumes:
  grafana_data:

networks:
  monitoring:
    external: true
    name: monitoring_default

启动Grafana：

# 创建配置目录
mkdir -p /root/monitoring/grafana/provisioning/datasources
mkdir -p /root/monitoring/grafana/provisioning/dashboards

# 创建数据源配置文件
cat > /root/monitoring/grafana/provisioning/datasources/prometheus.yml << EOF
apiVersion: 1

datasources:
  - name: Prometheus
    type: prometheus
    access: proxy
    url: http://prometheus:9090
    isDefault: true
    editable: true
EOF

# 启动Grafana
docker-compose -f docker-compose.grafana.yml up -d

# 查看状态
docker-compose -f docker-compose.grafana.yml ps

5.2 配置Grafana数据源

访问Grafana：http://你的服务器IP:3000
使用默认账号登录：
- 用户名：admin
- 密码：admin123（你刚才在配置里设置的）
首次登录会要求修改密码，建议修改一个强密码
数据源应该已经自动配置好了（通过provisioning配置），可以在"Configuration" → "Data Sources"中查看

5.3 导入SenseVoice监控仪表盘

Grafana支持导入现成的仪表盘配置。这里我为你准备了一个专门为SenseVoice WebUI设计的监控仪表盘。

创建仪表盘配置文件/root/monitoring/grafana/provisioning/dashboards/sensevoice-dashboard.yml：

apiVersion: 1

providers:
  - name: 'SenseVoice Dashboards'
    orgId: 1
    folder: ''
    type: file
    disableDeletion: false
    updateIntervalSeconds: 10
    allowUiUpdates: true
    options:
      path: /etc/grafana/provisioning/dashboards

然后创建仪表盘JSON文件。由于内容较长，我提供一个精简版的配置，你可以在Grafana界面中手动创建或导入完整版：

{
  "dashboard": {
    "title": "SenseVoice WebUI 服务监控",
    "description": "SenseVoice-small语音识别服务健康度监控",
    "tags": ["sensevoice", "monitoring", "speech-recognition"],
    "style": "dark",
    "timezone": "browser",
    "panels": [
      {
        "id": 1,
        "title": "服务概览",
        "type": "stat",
        "gridPos": {"h": 3, "w": 12, "x": 0, "y": 0},
        "targets": [{
          "expr": "up{service=\"sensevoice-webui\"}",
          "legendFormat": "服务状态"
        }],
        "fieldConfig": {
          "defaults": {
            "color": {"mode": "thresholds"},
            "mappings": [
              {"type": "value", "options": {"0": {"text": "❌ 离线"}, "1": {"text": "✅ 在线"}}}
            ],
            "thresholds": {"steps": [{"value": null, "color": "red"}, {"value": 1, "color": "green"}]}
          }
        }
      }
    ],
    "time": {"from": "now-1h", "to": "now"},
    "refresh": "10s"
  }
}

实际上，一个完整的监控仪表盘应该包含多个面板。我建议通过Grafana界面手动创建，这样更直观：

5.4 手动创建监控仪表盘

在Grafana中点击"+" → "Dashboard"，然后依次添加以下面板：

面板1：服务状态概览

类型：Stat（状态）
查询：up{service="sensevoice-webui"}
设置：值映射，1=在线，0=离线
位置：顶部，显示服务是否正常运行

面板2：请求QPS（每秒查询数）

类型：Graph（图表）
查询：rate(sensevoice_http_requests_total[1m])
设置：线图，显示每分钟请求量变化
用途：观察服务负载情况

面板3：请求延迟分布

类型：Heatmap（热图）
查询：sensevoice_http_request_duration_seconds_bucket
设置：显示请求延迟的分布情况
用途：了解大多数请求的响应时间

面板4：识别成功率

类型：Pie chart（饼图）
查询：sum by (status)(rate(sensevoice_recognition_requests_total[5m]))
设置：显示成功和失败的比例
用途：监控识别服务的稳定性

面板5：各语言识别请求分布

类型：Bar gauge（条形图）
查询：sum by (language)(rate(sensevoice_recognition_requests_total[5m]))
设置：按语言分类显示请求量
用途：了解用户使用哪种语言最多

面板6：识别耗时P95

类型：Graph（图表）
查询：histogram_quantile(0.95, sum(rate(sensevoice_recognition_duration_seconds_bucket[5m])) by (le, language))
设置：显示95%的识别请求在多少时间内完成
用途：监控识别性能，确保用户体验

面板7：系统资源监控

类型：Row（行），包含多个子面板
CPU使用率：rate(node_cpu_seconds_total{mode!="idle"}[1m]) * 100
内存使用率：(node_memory_MemTotal_bytes - node_memory_MemAvailable_bytes) / node_memory_MemTotal_bytes * 100
磁盘使用率：(node_filesystem_size_bytes{fstype!="tmpfs"} - node_filesystem_free_bytes{fstype!="tmpfs"}) / node_filesystem_size_bytes{fstype!="tmpfs"} * 100

面板8：错误率监控

类型：Graph（图表）
查询：rate(sensevoice_http_requests_total{status=~"5.."}[5m]) / rate(sensevoice_http_requests_total[5m]) * 100
设置：显示HTTP 5xx错误的比例
告警：当错误率超过1%时触发告警

5.5 仪表盘布局建议

一个合理的仪表盘布局应该让重要信息一目了然。我建议这样排列：

┌─────────────────┬─────────────────┬─────────────────┐
│  服务状态概览   │   请求QPS       │   识别成功率    │
│  (在线/离线)    │  (实时流量)     │  (成功比例)     │
├─────────────────┼─────────────────┼─────────────────┤
│                请求延迟热图                        │
│              (响应时间分布)                        │
├─────────────────┬─────────────────┬─────────────────┤
│  各语言分布     │ 识别耗时P95     │  系统CPU        │
│  (使用情况)     │ (性能指标)      │  (使用率)       │
├─────────────────┼─────────────────┼─────────────────┤
│  系统内存       │  系统磁盘       │  错误率         │
│  (使用率)       │  (使用率)       │  (5xx比例)      │
└─────────────────┴─────────────────┴─────────────────┘

这样的布局让运维人员一眼就能看到：

服务是否正常（左上角）
当前负载如何（右上角）
性能表现怎样（中间）
系统资源是否充足（下方）

6. 第四步：设置告警规则

监控仪表盘能让我们看到问题，但更好的方式是让系统主动通知我们。这就是告警的作用——当某些指标异常时，自动发送通知。

6.1 配置Prometheus告警规则

创建告警规则文件alert_rules.yml：

groups:
  - name: sensevoice_alerts
    rules:
      # 规则1：服务下线告警
      - alert: SenseVoiceServiceDown
        expr: up{service="sensevoice-webui"} == 0
        for: 1m  # 持续1分钟才触发
        labels:
          severity: critical
          service: sensevoice-webui
        annotations:
          summary: "SenseVoice WebUI服务已下线"
          description: "{{ $labels.instance }} 上的SenseVoice服务已经停止响应超过1分钟"
          value: "{{ $value }}"
          
      # 规则2：高错误率告警
      - alert: HighErrorRate
        expr: |
          (
            rate(sensevoice_http_requests_total{status=~"5.."}[5m])
            /
            rate(sensevoice_http_requests_total[5m])
          ) * 100 > 5
        for: 2m
        labels:
          severity: warning
          service: sensevoice-webui
        annotations:
          summary: "SenseVoice服务错误率过高"
          description: "{{ $labels.instance }} 的错误率超过5%，当前值为 {{ $value | humanize }}%"
          
      # 规则3：识别性能下降告警
      - alert: RecognitionSlow
        expr: |
          histogram_quantile(0.95, rate(sensevoice_recognition_duration_seconds_bucket[5m])) > 10
        for: 3m
        labels:
          severity: warning
          service: sensevoice-webui
        annotations:
          summary: "语音识别性能下降"
          description: "{{ $labels.instance }} 的P95识别耗时超过10秒，当前值为 {{ $value | humanize }}秒"
          
      # 规则4：系统内存不足告警
      - alert: HighMemoryUsage
        expr: |
          (node_memory_MemTotal_bytes - node_memory_MemAvailable_bytes)
          / node_memory_MemTotal_bytes * 100 > 85
        for: 5m
        labels:
          severity: warning
          service: system
        annotations:
          summary: "系统内存使用率过高"
          description: "内存使用率超过85%，当前值为 {{ $value | humanize }}%"
          
      # 规则5：磁盘空间不足告警
      - alert: LowDiskSpace
        expr: |
          (node_filesystem_size_bytes{fstype!="tmpfs"} - node_filesystem_free_bytes{fstype!="tmpfs"})
          / node_filesystem_size_bytes{fstype!="tmpfs"} * 100 > 90
        for: 10m
        labels:
          severity: critical
          service: system
        annotations:
          summary: "磁盘空间不足"
          description: "{{ $labels.mountpoint }} 磁盘使用率超过90%，当前值为 {{ $value | humanize }}%"

6.2 更新Prometheus配置

修改prometheus.yml，取消注释告警规则配置：

rule_files:
  - "alert_rules.yml"  # 取消这行的注释

然后将告警规则文件放到正确的位置：

# 复制告警规则文件到Prometheus配置目录
cp alert_rules.yml /root/monitoring/prometheus/

# 重启Prometheus使配置生效
docker-compose restart prometheus

6.3 验证告警规则

在Prometheus的Web界面中，点击"Alerts"菜单，应该能看到我们刚刚配置的告警规则：

Name                    State    Active Since    Value
SenseVoiceServiceDown   inactive -              -
HighErrorRate           inactive -              -
RecognitionSlow         inactive -              -
HighMemoryUsage         inactive -              -
LowDiskSpace            inactive -              -

状态显示为"inactive"表示当前没有触发告警，这是正常的。

6.4 测试告警（可选）

如果你想测试告警是否正常工作，可以临时停止SenseVoice服务：

# 停止服务
supervisorctl stop sensevoice:sensevoice-webui

# 等待1-2分钟
sleep 120

# 查看Prometheus告警页面
# 应该能看到SenseVoiceServiceDown告警状态变为"pending"，然后"firing"

测试完成后记得重启服务：

supervisorctl start sensevoice:sensevoice-webui

7. 第五步：配置告警通知（邮件示例）

告警触发后，我们需要收到通知。这里以邮件通知为例，展示如何配置。

7.1 部署Alertmanager

创建docker-compose.alertmanager.yml：

version: '3.8'

services:
  alertmanager:
    image: prom/alertmanager:latest
    container_name: alertmanager
    restart: unless-stopped
    volumes:
      - ./alertmanager.yml:/etc/alertmanager/alertmanager.yml
    ports:
      - "9093:9093"
    networks:
      - monitoring

networks:
  monitoring:
    external: true
    name: monitoring_default

7.2 配置Alertmanager

创建alertmanager.yml配置文件：

global:
  smtp_smarthost: 'smtp.qq.com:587'  # QQ邮箱SMTP服务器，根据你的邮箱修改
  smtp_from: 'your-email@qq.com'     # 发件人邮箱
  smtp_auth_username: 'your-email@qq.com'  # 邮箱账号
  smtp_auth_password: 'your-auth-code'     # 授权码，不是密码！
  smtp_require_tls: true

route:
  group_by: ['alertname', 'service']
  group_wait: 10s
  group_interval: 10s
  repeat_interval: 1h
  receiver: 'email-notifications'

receivers:
  - name: 'email-notifications'
    email_configs:
      - to: 'admin@your-company.com'  # 收件人邮箱
        send_resolved: true  # 问题解决时也发送通知
        headers:
          subject: '{{ template "email.default.subject" . }}'
        html: '{{ template "email.default.html" . }}'

templates:
  - '/etc/alertmanager/templates/*.tmpl'

重要提示：

你需要使用真实的邮箱配置
对于QQ邮箱，需要在设置中开启SMTP服务并获取授权码
生产环境建议使用企业邮箱或专业的邮件服务

7.3 创建邮件模板（可选）

创建模板文件email.tmpl：

{{ define "email.default.subject" }}[{{ .Status | toUpper }}] {{ .GroupLabels.alertname }} on {{ .GroupLabels.service }}{{ end }}

{{ define "email.default.html" }}
<!DOCTYPE html>
<html>
<head>
    <style>
        body { font-family: Arial, sans-serif; }
        .critical { color: #d9534f; }
        .warning { color: #f0ad4e; }
        .info { color: #5bc0de; }
        .resolved { color: #5cb85c; }
    </style>
</head>
<body>
    <h2>{{ .GroupLabels.alertname }}</h2>
    
    <p><strong>状态:</strong> 
    {{ if eq .Status "firing" }}
        <span class="critical">⚠️ 告警中</span>
    {{ else }}
        <span class="resolved">✅ 已恢复</span>
    {{ end }}
    </p>
    
    <p><strong>服务:</strong> {{ .GroupLabels.service }}</p>
    <p><strong>时间:</strong> {{ .StartsAt.Format "2006-01-02 15:04:05" }}</p>
    
    {{ if eq .Status "firing" }}
    <p><strong>持续时间:</strong> {{ .Duration }}</p>
    {{ else }}
    <p><strong>恢复时间:</strong> {{ .EndsAt.Format "2006-01-02 15:04:05" }}</p>
    {{ end }}
    
    <h3>告警详情</h3>
    <ul>
    {{ range .Annotations }}
        <li><strong>{{ .Name }}:</strong> {{ .Value }}</li>
    {{ end }}
    </ul>
    
    <h3>标签</h3>
    <ul>
    {{ range .Labels }}
        <li><strong>{{ .Name }}:</strong> {{ .Value }}</li>
    {{ end }}
    </ul>
    
    <hr>
    <p><small>此邮件由 Prometheus Alertmanager 自动发送</small></p>
</body>
</html>
{{ end }}

7.4 更新Prometheus配置

修改prometheus.yml中的alerting部分：

alerting:
  alertmanagers:
    - static_configs:
        - targets: ['alertmanager:9093']

7.5 启动Alertmanager

# 启动Alertmanager
docker-compose -f docker-compose.alertmanager.yml up -d

# 重启Prometheus
docker-compose restart prometheus

现在，当告警触发时，你就会收到邮件通知了。

8. 总结：从监控到洞察

通过以上五个步骤，我们成功为SenseVoice-small WebUI服务搭建了一套完整的监控系统。让我们回顾一下这个系统能为我们带来什么价值：

8.1 监控系统的核心价值

实时可见性：7x24小时监控服务状态，随时了解服务健康度
快速定位：出现问题时有详细的数据支持，快速定位问题根源
性能优化：通过历史数据发现性能瓶颈，针对性优化
容量规划：基于资源使用趋势，合理规划服务器扩容
主动告警：问题发生前预警，减少服务中断时间

8.2 针对不同场景的监控重点

根据你使用SenseVoice-small的不同场景，监控的重点可以有所调整：

使用场景	监控重点	建议告警阈值
离线语音助手	服务可用性、响应速度	响应时间>2秒触发告警
实时字幕系统	识别延迟、成功率	识别延迟>1秒或成功率<95%告警
客服质检	识别准确率、系统稳定性	错误率>3%或服务中断立即告警
会议纪要	多语言支持、长时间运行稳定性	内存泄漏检测、各语言识别成功率
医疗/金融隐私场景	数据安全性、服务可靠性	任何异常立即告警，加强日志审计