实时手机检测-通用部署监控：Prometheus+Grafana实时跟踪GPU利用率与QPS

1. 引言：为什么我们需要监控AI模型服务？

想象一下，你刚刚部署了一个强大的实时手机检测模型，它基于先进的DAMOYOLO框架，能够快速准确地识别图片中的手机。用户通过一个简洁的Gradio界面上传图片，模型在后台默默工作，几秒钟内就能返回检测结果。一切看起来都很完美。

但很快，你可能会遇到一些“看不见”的问题：

• 为什么有时候响应变慢了？是模型处理不过来，还是GPU“偷懒”了？
• 同时有10个用户上传图片时，服务还能保持流畅吗？
• GPU的利用率到底是多少？它是不是大部分时间都在“待机”？
• 我们的服务每秒能处理多少请求（QPS）？瓶颈在哪里？

这些问题就像汽车仪表盘上的指示灯——没有它们，你永远不知道引擎是在全速运转还是即将过热。对于AI模型服务来说，监控就是我们的仪表盘。

本文将带你搭建一套完整的监控系统，使用Prometheus收集指标，用Grafana可视化展示，实时监控你的“实时手机检测-通用”模型的GPU利用率和请求处理能力。这不是一个复杂的运维教程，而是一个让每个开发者都能轻松上手的实用指南。

2. 监控系统整体架构：三分钟搞懂核心组件

在开始动手之前，我们先花三分钟了解一下整个监控系统是怎么工作的。别担心，我用最直白的方式解释：

你的手机检测服务 → 暴露指标 → Prometheus收集 → Grafana展示

1. 你的模型服务（指标生产者）

• 就是你现在运行的实时手机检测服务
• 我们需要让它“暴露”一些数据，比如：处理了多少图片、花了多少时间、GPU用了多少

2. Prometheus（指标收集器）

• 一个专门收集和存储监控数据的工具
• 它会定期（比如每15秒）去你的服务那里“问一下”：现在什么情况？
• 然后把数据存起来，方便后续查询和分析

3. Grafana（仪表盘展示）

• 一个漂亮的数据可视化工具
• 从Prometheus读取数据，然后生成各种图表：折线图、仪表盘、热力图等
• 让你一眼就能看出服务的运行状态

为什么选择这个组合？

• Prometheus：现在是监控领域的“标准答案”，社区活跃，集成简单
• Grafana：颜值高、功能强，几乎成了数据可视化的代名词
• 两者配合：一个负责收集存储，一个负责展示分析，完美搭档

这套系统不仅能监控GPU和QPS，未来还可以扩展监控内存使用、温度、错误率等几乎所有你能想到的指标。

3. 第一步：为你的模型服务添加监控指标

现在我们的模型服务就像一个“黑盒子”——我们知道它能检测手机，但不知道内部运行情况。第一步就是打开这个盒子，让它告诉我们一些关键信息。

3.1 理解需要监控什么指标

对于AI模型服务，我们最关心这几类指标：

性能指标（做得好不好）

• QPS（每秒查询数）：服务每秒能处理多少请求
• 延迟（Latency）：处理一个请求需要多少时间
• 成功率：请求成功的比例

资源指标（累不累）

• GPU利用率：GPU有多忙？0%表示闲置，100%表示满负荷
• GPU内存使用：用了多少显存
• CPU使用率：CPU的忙碌程度
• 内存使用：系统内存用了多少

业务指标（干什么了）

• 总处理图片数：从启动到现在处理了多少张图片
• 检测到的手机数：总共找到了多少部手机

今天我们先聚焦两个核心指标：GPU利用率和QPS。

3.2 修改Gradio应用代码暴露指标

你的实时手机检测服务基于Gradio，我们需要稍微修改一下代码，让它能够提供监控数据。别担心，改动很小。

首先，确保安装了必要的Python包：

pip install prometheus-client psutil pynvml

• prometheus-client：用来创建和暴露监控指标
• psutil：获取系统信息（CPU、内存等）
• pynvml：NVIDIA的管理库，获取GPU信息

现在，修改你的webui.py文件（或者创建一个新的监控模块）。关键部分如下：

# 在webui.py开头添加
from prometheus_client import start_http_server, Counter, Gauge, Histogram
import psutil
import time
import threading
from pynvml import *

# 初始化Prometheus指标
# QPS相关指标
REQUEST_COUNT = Counter('model_requests_total', 'Total number of requests')
REQUEST_LATENCY = Histogram('model_request_latency_seconds', 'Request latency in seconds')

# GPU相关指标
GPU_UTILIZATION = Gauge('gpu_utilization_percent', 'GPU utilization percentage')
GPU_MEMORY_USED = Gauge('gpu_memory_used_mb', 'GPU memory used in MB')
GPU_MEMORY_TOTAL = Gauge('gpu_memory_total_mb', 'GPU total memory in MB')

# 系统资源指标
CPU_USAGE = Gauge('cpu_usage_percent', 'CPU usage percentage')
MEMORY_USAGE = Gauge('memory_usage_percent', 'Memory usage percentage')

# 启动一个独立的HTTP服务器来提供监控指标
# 默认在端口8000上提供/metrics端点
start_http_server(8000)

# GPU监控线程函数
def monitor_gpu():
    """定期更新GPU监控指标"""
    try:
        nvmlInit()
        device_count = nvmlDeviceGetCount()
        
        while True:
            for i in range(device_count):
                handle = nvmlDeviceGetHandleByIndex(i)
                
                # 获取GPU利用率
                utilization = nvmlDeviceGetUtilizationRates(handle)
                GPU_UTILIZATION.set(utilization.gpu)
                
                # 获取GPU内存信息
                memory_info = nvmlDeviceGetMemoryInfo(handle)
                GPU_MEMORY_USED.set(memory_info.used / 1024 / 1024)  # 转换为MB
                GPU_MEMORY_TOTAL.set(memory_info.total / 1024 / 1024)  # 转换为MB
            
            # 获取CPU和内存使用率
            CPU_USAGE.set(psutil.cpu_percent(interval=1))
            MEMORY_USAGE.set(psutil.virtual_memory().percent)
            
            time.sleep(5)  # 每5秒更新一次
    except Exception as e:
        print(f"GPU监控出错: {e}")

# 启动GPU监控线程
gpu_monitor_thread = threading.Thread(target=monitor_gpu, daemon=True)
gpu_monitor_thread.start()

# 修改你的检测函数，添加监控
def detect_phones(image):
    """包装原有的检测函数，添加监控"""
    start_time = time.time()
    
    # 调用原有的检测逻辑
    # 这里假设你原有的检测函数是 detect_phones_original(image)
    result = detect_phones_original(image)
    
    # 计算处理时间
    latency = time.time() - start_time
    
    # 更新监控指标
    REQUEST_COUNT.inc()  # 请求计数+1
    REQUEST_LATENCY.observe(latency)  # 记录延迟
    
    return result

这段代码做了什么？

1. 创建了各种监控指标（计数器、仪表盘、直方图）
2. 启动了一个HTTP服务器（端口8000），提供/metrics端点
3. 启动了一个后台线程，每5秒更新一次GPU和系统指标
4. 包装了你的检测函数，自动记录每次请求的计数和延迟

怎么验证是否生效？

1. 启动你的Gradio应用
2. 打开浏览器，访问 http://你的服务器IP:8000/metrics
3. 你应该能看到一堆以model_、gpu_、cpu_开头的指标

现在你的服务已经“开口说话”了，它会定期报告自己的状态。下一步，我们需要一个“听众”来收集这些话。

4. 第二步：部署Prometheus收集指标

Prometheus就像是一个勤快的秘书，它会定期访问你的服务，记录下所有指标数据。我们来部署它。

4.1 安装和配置Prometheus

方法一：使用Docker（推荐） 如果你已经在使用Docker环境，这是最简单的方式：

# 创建 prometheus.yml 配置文件
mkdir -p /opt/prometheus
cd /opt/prometheus

# 创建配置文件
cat > prometheus.yml << 'EOF'
global:
  scrape_interval: 15s  # 每15秒收集一次数据
  evaluation_interval: 15s

scrape_configs:
  # 监控Prometheus自己
  - job_name: 'prometheus'
    static_configs:
      - targets: ['localhost:9090']
  
  # 监控你的手机检测服务
  - job_name: 'phone-detection-service'
    static_configs:
      - targets: ['你的服务IP:8000']  # 修改为你的实际IP和端口
    metrics_path: '/metrics'
    scrape_interval: 10s  # 对这个服务每10秒收集一次
EOF

# 使用Docker运行Prometheus
docker run -d \
  --name=prometheus \
  -p 9090:9090 \
  -v /opt/prometheus/prometheus.yml:/etc/prometheus/prometheus.yml \
  prom/prometheus

方法二：直接安装（如果没有Docker）

# 下载Prometheus
wget https://github.com/prometheus/prometheus/releases/download/v2.45.0/prometheus-2.45.0.linux-amd64.tar.gz
tar xvfz prometheus-2.45.0.linux-amd64.tar.gz
cd prometheus-2.45.0.linux-amd64

# 创建配置文件
cat > prometheus.yml << 'EOF'
global:
  scrape_interval: 15s

scrape_configs:
  - job_name: 'prometheus'
    static_configs:
      - targets: ['localhost:9090']
  
  - job_name: 'phone-detection-service'
    static_configs:
      - targets: ['localhost:8000']  # 如果你的服务在同一台机器
EOF

# 启动Prometheus
./prometheus --config.file=prometheus.yml &

4.2 验证Prometheus是否正常工作

1. 访问Prometheus Web界面

   • 打开浏览器，访问 http://你的服务器IP:9090
   • 你应该能看到Prometheus的界面

2. 检查是否收集到数据

   • 在Prometheus界面的“Graph”标签页
   • 在查询框中输入 model_requests_total
   • 点击“Execute”，你应该能看到这个指标
   • 如果没有数据，检查：
     • 你的模型服务是否运行且端口8000可访问
     • Prometheus配置中的IP和端口是否正确
     • 防火墙是否开放了相关端口

3. 执行一些测试查询

   # 查看GPU利用率
   gpu_utilization_percent
   
   # 查看最近5分钟的QPS（每秒请求数）
   rate(model_requests_total[5m])
   
   # 查看平均请求延迟
   rate(model_request_latency_seconds_sum[5m]) / rate(model_request_latency_seconds_count[5m])
   

如果能看到数据，恭喜你！Prometheus已经成功收集到监控指标了。不过，Prometheus的界面比较“工程师向”，接下来我们请出颜值担当——Grafana。

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

Grafana能把Prometheus中枯燥的数字变成直观的图表。我们来看看怎么搭建一个专业的监控仪表盘。

5.1 安装和配置Grafana

使用Docker安装（推荐）

docker run -d \
  --name=grafana \
  -p 3000:3000 \
  grafana/grafana

直接安装

# Ubuntu/Debian
sudo apt-get install -y software-properties-common
sudo add-apt-repository "deb https://packages.grafana.com/oss/deb stable main"
sudo apt-get update
sudo apt-get install grafana

# 启动Grafana
sudo systemctl start grafana-server
sudo systemctl enable grafana-server

5.2 配置数据源和创建仪表盘

1. 访问Grafana

   • 打开浏览器，访问 http://你的服务器IP:3000
   • 默认用户名/密码：admin / admin
   • 首次登录会要求修改密码

2. 添加Prometheus数据源

   • 点击左侧齿轮图标 → "Data Sources"
   • 点击"Add data source"
   • 选择"Prometheus"
   • 在URL处填写：http://你的PrometheusIP:9090
   • 点击"Save & Test"，应该显示"Data source is working"

3. 导入预制的仪表盘模板（最简单的方法）

Grafana社区有成千上万的仪表盘模板，我们找一个适合监控AI模型服务的：

• 点击左侧"+"号 → "Import"
• 在"Import via grafana.com"框中输入：1860
• 点击"Load"
• 选择Prometheus数据源，点击"Import"

这个仪表盘（ID: 1860）是Node Exporter Full，虽然名字是监控节点的，但包含了我们需要的CPU、内存、GPU等所有系统指标。

4. 创建自定义的模型监控面板

社区模板可能没有专门针对AI模型服务的面板，我们需要自己创建几个：

创建QPS监控面板

• 点击"Create" → "Dashboard" → "Add new panel"
• 在查询框中输入：rate(model_requests_total[5m])
• 设置面板标题："实时QPS（请求/秒）"
• 选择可视化类型："Stat" 或 "Graph"
• 点击"Apply"

创建GPU利用率面板

• 点击"Add new panel"
• 查询框输入：gpu_utilization_percent
• 标题："GPU利用率 (%)"
• 可视化类型："Gauge"（仪表盘样式）
• 设置阈值：0-30（绿色），30-70（黄色），70-100（红色）
• 点击"Apply"

创建请求延迟面板

• 点击"Add new panel"
• 查询框输入：

  rate(model_request_latency_seconds_sum[5m]) / 
  rate(model_request_latency_seconds_count[5m])
  

• 标题："平均请求延迟 (秒)"
• 可视化类型："Graph"
• 点击"Apply"

创建总处理量面板

• 点击"Add new panel"
• 查询框输入：model_requests_total
• 标题："总处理图片数"
• 可视化类型："Stat"
• 点击"Apply"

5.3 组织你的监控仪表盘

一个好的仪表盘应该让信息一目了然。我建议这样组织：

第一行：核心业务指标
  - 实时QPS
  - 总处理图片数
  - 当前在线用户数（如果有的话）

第二行：性能指标
  - 平均请求延迟
  - 95分位延迟（更严格的延迟指标）
  - 错误率（如果有错误监控）

第三行：资源使用情况
  - GPU利用率
  - GPU内存使用
  - CPU使用率
  - 系统内存使用

第四行：历史趋势
  - QPS趋势图（最近1小时）
  - 延迟趋势图（最近1小时）
  - GPU使用趋势图（最近1小时）

调整每个面板的大小和位置，让重要的指标更突出。最后别忘了点击保存，给你的仪表盘起个名字，比如"实时手机检测服务监控"。

6. 实战：监控你的手机检测服务

现在让我们实际运行一下，看看监控系统能告诉我们什么。

6.1 模拟真实负载测试

为了看到监控效果，我们需要模拟一些请求。创建一个简单的测试脚本：

# test_load.py
import requests
import time
import random
import threading
from PIL import Image
import io

def send_request(image_path, server_url):
    """发送检测请求"""
    try:
        with open(image_path, 'rb') as f:
            files = {'image': f}
            start_time = time.time()
            response = requests.post(server_url, files=files)
            latency = time.time() - start_time
            
            if response.status_code == 200:
                print(f"请求成功，延迟: {latency:.2f}秒")
                return True, latency
            else:
                print(f"请求失败: {response.status_code}")
                return False, latency
    except Exception as e:
        print(f"请求异常: {e}")
        return False, 0

def load_test(server_url, image_path, duration=60, max_threads=5):
    """负载测试"""
    print(f"开始负载测试，持续时间: {duration}秒")
    
    request_count = 0
    successful_requests = 0
    total_latency = 0
    
    end_time = time.time() + duration
    
    def worker():
        nonlocal request_count, successful_requests, total_latency
        while time.time() < end_time:
            success, latency = send_request(image_path, server_url)
            request_count += 1
            if success:
                successful_requests += 1
                total_latency += latency
            
            # 随机间隔，模拟真实用户请求
            time.sleep(random.uniform(0.5, 2.0))
    
    # 启动多个线程模拟并发用户
    threads = []
    for i in range(max_threads):
        t = threading.Thread(target=worker)
        t.start()
        threads.append(t)
    
    for t in threads:
        t.join()
    
    # 打印测试结果
    print(f"\n测试结果:")
    print(f"总请求数: {request_count}")
    print(f"成功请求: {successful_requests}")
    print(f"成功率: {(successful_requests/request_count*100):.1f}%")
    if successful_requests > 0:
        print(f"平均延迟: {(total_latency/successful_requests):.2f}秒")
    print(f"QPS: {successful_requests/duration:.2f}")

if __name__ == "__main__":
    # 配置你的服务地址
    SERVER_URL = "http://你的服务器地址:7860/run/predict"  # Gradio默认地址
    TEST_IMAGE = "test_phone.jpg"  # 准备一张测试图片
    
    # 运行1分钟负载测试，最大5个并发
    load_test(SERVER_URL, TEST_IMAGE, duration=60, max_threads=5)

运行这个测试脚本：

python test_load.py

6.2 观察监控仪表盘的变化

在测试运行的同时，打开Grafana仪表盘，你会看到：

实时变化

1. QPS面板：数字开始跳动，从0逐渐上升到某个值
2. GPU利用率面板：指针从绿色区域向黄色甚至红色区域移动
3. 延迟面板：折线图开始绘制，显示每个请求的处理时间
4. 总处理数面板：数字持续增加

关键观察点

• QPS稳定值：当测试运行一段时间后，QPS会稳定在某个值，这就是你服务在当前配置下的最大处理能力
• GPU利用率峰值：观察GPU最高被用到多少，如果一直很低（比如<30%），说明GPU没被充分利用
• 延迟分布：大部分请求的延迟是多少？有没有异常的高延迟点？
• 资源瓶颈：是GPU先到100%还是CPU先到100%？这告诉你扩展方向

6.3 分析监控数据，优化服务

根据监控数据，我们可以做出有针对性的优化：

情况一：GPU利用率低，但QPS上不去

• 可能原因：CPU或IO成为瓶颈，GPU在等数据
• 优化建议：
  • 使用异步处理，让GPU不间断工作
  • 增加批处理（batch processing），一次处理多张图片
  • 优化数据加载和预处理流程

情况二：GPU利用率高，QPS也高，但延迟大

• 可能原因：请求排队，GPU处理不过来
• 优化建议：
  • 考虑模型优化（量化、剪枝）
  • 升级GPU硬件
  • 部署多个实例做负载均衡

情况三：GPU利用率波动大

• 可能原因：请求不均匀，GPU一会儿忙一会儿闲
• 优化建议：
  • 实现请求队列，平滑请求流量
  • 考虑使用GPU共享技术，让多个服务共用GPU

7. 高级监控技巧与告警设置

基础监控搭建好了，我们再来看看一些高级功能，让监控系统更智能。

7.1 设置关键指标告警

监控不仅要“看得见”，还要“叫得响”。当出现问题时，系统应该主动通知我们。

在Grafana中设置告警：

1. 为QPS设置告警

   • 打开QPS面板，点击"Alert" → "Create alert"
   • 规则名称："QPS过低告警"
   • 条件：rate(model_requests_total[5m]) < 1 （5分钟内平均QPS低于1）
   • 评估间隔：1分钟
   • 添加通知渠道（需要先配置）

2. 为GPU利用率设置告警

   • 打开GPU利用率面板，创建告警
   • 规则名称："GPU过载告警"
   • 条件：gpu_utilization_percent > 90 （GPU利用率超过90%）
   • 持续时间：2分钟（持续2分钟超过阈值才告警）

3. 为延迟设置告警

   • 打开延迟面板，创建告警
   • 规则名称："延迟过高告警"
   • 条件：model_request_latency_seconds > 3 （单个请求延迟超过3秒）
   • 或者用百分位：histogram_quantile(0.95, rate(model_request_latency_seconds_bucket[5m])) > 2 （95%的请求延迟超过2秒）

7.2 配置通知渠道

Grafana支持多种通知方式：

配置邮件通知

1. 点击"Alerting" → "Notification channels" → "New channel"
2. 类型选择"Email"
3. 填写SMTP服务器信息
4. 填写接收邮箱

配置Slack/钉钉/企业微信

• 同样在"Notification channels"中添加
• 需要对应的Webhook URL

配置PagerDuty/OpsGenie

• 用于更专业的告警管理
• 支持升级策略、值班表等

7.3 创建自定义指标

除了基础指标，你还可以创建更有业务意义的指标：

# 在webui.py中添加
from prometheus_client import Summary

# 创建检测结果相关的指标
PHONES_DETECTED = Counter('phones_detected_total', 'Total number of phones detected')
DETECTION_CONFIDENCE = Histogram('detection_confidence', 'Detection confidence distribution', buckets=[0.5, 0.6, 0.7, 0.8, 0.9, 1.0])

def detect_phones_with_metrics(image):
    """增强的检测函数，记录更多业务指标"""
    start_time = time.time()
    
    # 原有的检测逻辑
    result = detect_phones_original(image)
    
    # 计算延迟
    latency = time.time() - start_time
    REQUEST_COUNT.inc()
    REQUEST_LATENCY.observe(latency)
    
    # 记录业务指标
    if result and 'detections' in result:
        num_phones = len(result['detections'])
        PHONES_DETECTED.inc(num_phones)
        
        # 记录每个检测的置信度
        for detection in result['detections']:
            if 'confidence' in detection:
                DETECTION_CONFIDENCE.observe(detection['confidence'])
    
    return result

这些业务指标能告诉你：

• 平均每张图片检测到多少部手机
• 检测的置信度分布如何
• 有没有误检或漏检的趋势

7.4 长期数据保留与趋势分析

默认情况下，Prometheus只保留15天数据。对于长期趋势分析，你可能需要：

调整数据保留时间

# 在prometheus.yml中添加
global:
  scrape_interval: 15s
  evaluation_interval: 15s
  retention: 90d  # 保留90天数据

使用远程存储 对于更长期的数据，可以考虑：

• Thanos：Prometheus的高可用解决方案，支持长期存储
• Cortex：云原生的Prometheus即服务
• M3DB： Uber开源的时序数据库

8. 总结：从监控到洞察

通过本文的步骤，你已经成功搭建了一套完整的AI模型服务监控系统。让我们回顾一下关键收获：

8.1 监控带来的价值

问题发现与定位

• 不再是“感觉慢了”，而是知道“慢了50%，因为GPU利用率达到95%”
• 快速定位瓶颈：是GPU、CPU、内存还是网络？
• 发现异常模式：为什么每天下午3点延迟会升高？

容量规划与优化

• 基于真实数据做决策：需要升级GPU吗？需要增加实例吗？
• 优化资源配置：批处理大小设为多少最合适？
• 成本控制：在性能和成本间找到最佳平衡点

服务质量保障

• SLA（服务等级协议）监控：确保99.9%的请求延迟<2秒
• 用户体验保障：主动发现问题，而不是等用户投诉
• 业务连续性：预警潜在风险，避免服务中断

8.2 后续扩展建议

你的监控系统已经可以工作了，但还有更多可以做的事情：

更细粒度的监控

• 监控每个模型层的处理时间
• 监控输入输出数据的大小和格式
• 监控缓存命中率（如果有缓存的话）

业务指标监控

• 用户行为分析：什么时间段使用最多？
• 检测结果质量监控：置信度趋势如何？
• 地域分析：不同地区用户的延迟差异

自动化与智能化

• 基于监控数据的自动扩缩容
• 异常检测与自动修复
• 预测性维护：在问题发生前预警

8.3 最后的建议

1. 监控不是一次性工作：随着业务发展，不断调整和优化监控指标
2. 避免监控过度：只监控真正重要的指标，太多告警等于没有告警
3. 建立监控文化：让团队每个人都习惯看监控数据做决策
4. 定期回顾：每周/每月回顾监控数据，发现趋势和模式

记住，好的监控系统就像给你的AI服务装上了“眼睛”和“耳朵”。它不能直接让服务变得更快更好，但它能告诉你哪里需要改进，让你的优化工作有的放矢。

现在，你的实时手机检测服务不再是一个“黑盒子”。你知道它的每一个心跳，每一次呼吸。当用户上传图片时，你不仅能返回检测结果，还能清楚地知道：这个请求花了多少时间，消耗了多少资源，服务是否健康。

这就是监控的力量——让不可见变为可见，让不确定变为可控。

---

获取更多AI镜像

想探索更多AI镜像和应用场景？访问 CSDN星图镜像广场，提供丰富的预置镜像，覆盖大模型推理、图像生成、视频生成、模型微调等多个领域，支持一键部署。