DAMO-YOLO手机检测WebUI性能监控：Prometheus+Grafana看板

1. 项目简介：从“能用”到“好用”的跨越

你已经部署了那个基于DAMO-YOLO的手机检测WebUI，它确实很酷——上传图片，几毫秒就能标出手机位置，准确率接近90%。但作为开发者或运维人员，你心里可能一直有个疑问：这系统到底跑得怎么样？

• 现在每分钟有多少人在用？
• 平均每张图片处理要多久？
• 内存占用稳定吗？会不会悄悄涨上去？
• 如果突然来了很多请求，系统能扛得住吗？

这些问题，光靠“感觉”是回答不了的。我们需要数据，需要看得见的指标，需要实时的监控。这就是为什么要在你的手机检测系统上，加上Prometheus和Grafana这套监控组合拳。

简单来说，我们要做的就是把系统从“能用”升级到“好用且可观测”。你会得到一个像汽车仪表盘一样的监控看板，所有关键指标一目了然：请求量、响应时间、成功率、资源使用……一切尽在掌握。

2. 为什么需要性能监控？

2.1 看不见的问题才是真问题

你的手机检测系统可能正在悄悄“生病”，而你却不知道：

场景一：性能缓慢但无感知 用户上传了一张图片，等了5秒才出结果。用户觉得“这系统有点慢”，但不会告诉你。如果没有监控，你根本不知道用户体验已经变差了。

场景二：内存泄漏的定时炸弹 系统运行了三天，内存从2GB悄悄涨到了8GB。某天晚上，内存爆了，服务崩溃，第二天早上你才发现。如果有监控，你会在内存涨到4GB时就收到警报。

场景三：流量突增措手不及 突然有1000个用户同时上传图片，系统响应时间从3.83ms飙升到300ms，大量请求超时。等你知道的时候，用户已经流失了。

2.2 Prometheus+Grafana能给你什么？

Prometheus 负责收集数据。它会定时“问”你的系统：“嘿，你现在处理了多少请求？用了多少内存？CPU忙不忙？”然后把答案存起来。

Grafana 负责展示数据。它把Prometheus收集的那些数字，变成漂亮的图表和仪表盘，让你一眼就能看懂系统状态。

这套组合能帮你：

1. 实时看到系统状态：就像汽车的仪表盘，速度、油量、水温一目了然
2. 快速定位问题：系统慢了？看看是CPU满了还是内存不够
3. 预测容量需求：根据历史数据，预测什么时候需要升级服务器
4. 证明系统价值：用数据说话，告诉老板这系统处理了多少图片，节省了多少人力

3. 监控方案设计

3.1 我们要监控什么？

对于手机检测WebUI，我们需要关注四个维度的指标：

1. 业务指标（用户最关心的）

• 每分钟处理的图片数量
• 检测成功率（成功返回结果的请求比例）
• 平均检测时间
• 不同置信度区间的分布

2. 性能指标（系统健康度）

• 请求响应时间（P50、P95、P99）
• 并发请求数
• 错误率（失败请求的比例）

3. 资源指标（硬件使用情况）

• CPU使用率
• 内存使用量
• GPU使用率（如果有的话）
• 磁盘I/O

4. 服务质量指标（SLA相关）

• 服务可用性（uptime）
• 最大响应时间
• 吞吐量上限

3.2 技术架构

┌─────────────────────────────────────────────────────────────┐
│                   用户浏览器                                 │
│                   访问 http://IP:7860                       │
└──────────────────────┬──────────────────────────────────────┘
                       │
                       ▼
┌─────────────────────────────────────────────────────────────┐
│               DAMO-YOLO手机检测WebUI                        │
│               (Gradio应用，端口7860)                        │
└──────────────────────┬──────────────────────────────────────┘
                       │ 暴露/metrics端点
                       ▼
┌─────────────────────────────────────────────────────────────┐
│               Prometheus监控服务器                          │
│               每15秒抓取一次指标数据                        │
└──────────────────────┬──────────────────────────────────────┘
                       │ 存储到时序数据库
                       ▼
┌─────────────────────────────────────────────────────────────┐
│               Grafana可视化平台                             │
│               从Prometheus读取数据并展示                    │
└──────────────────────┬──────────────────────────────────────┘
                       │
                       ▼
┌─────────────────────────────────────────────────────────────┐
│               管理员看到的漂亮仪表盘                        │
└─────────────────────────────────────────────────────────────┘

这个架构的核心思想是：应用暴露指标 → Prometheus收集存储 → Grafana展示分析。

4. 实战部署：一步步搭建监控系统

4.1 环境准备

首先，确保你的系统已经安装了Docker和Docker Compose。如果没有，可以这样安装：

# 安装Docker
curl -fsSL https://get.docker.com -o get-docker.sh
sudo sh get-docker.sh

# 安装Docker Compose
sudo curl -L "https://github.com/docker/compose/releases/latest/download/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
sudo chmod +x /usr/local/bin/docker-compose

# 验证安装
docker --version
docker-compose --version

4.2 第一步：改造你的手机检测应用

要让Prometheus能监控你的Gradio应用，需要在应用代码中添加指标暴露功能。修改你的app.py：

# 在文件开头添加导入
from prometheus_client import Counter, Histogram, Gauge, generate_latest, CONTENT_TYPE_LATEST
from prometheus_client.exposition import make_wsgi_app
from werkzeug.middleware.dispatcher import DispatcherMiddleware
import time

# 创建Prometheus指标
# 计数器：统计总请求数
REQUEST_COUNT = Counter(
    'phone_detection_requests_total',
    'Total number of phone detection requests',
    ['method', 'endpoint', 'status']
)

# 直方图：统计响应时间分布
REQUEST_LATENCY = Histogram(
    'phone_detection_request_duration_seconds',
    'Request latency in seconds',
    ['method', 'endpoint'],
    buckets=[0.1, 0.5, 1.0, 2.0, 5.0, 10.0]
)

# 仪表：实时并发请求数
CONCURRENT_REQUESTS = Gauge(
    'phone_detection_concurrent_requests',
    'Number of concurrent requests being processed'
)

# 计数器：检测结果统计
DETECTION_RESULTS = Counter(
    'phone_detection_results_total',
    'Total number of phones detected',
    ['confidence_level']  # 按置信度分级
)

# 修改你的检测函数，添加监控
def detect_phone_with_metrics(image):
    """带监控的手机检测函数"""
    start_time = time.time()
    CONCURRENT_REQUESTS.inc()  # 增加并发计数
    
    try:
        # 原有的检测逻辑
        results = detect_phone(image)  # 假设这是你的检测函数
        
        # 记录检测结果
        for result in results:
            confidence = result['confidence']
            if confidence > 0.9:
                DETECTION_RESULTS.labels(confidence_level='high').inc()
            elif confidence > 0.7:
                DETECTION_RESULTS.labels(confidence_level='medium').inc()
            else:
                DETECTION_RESULTS.labels(confidence_level='low').inc()
        
        # 记录请求成功
        REQUEST_COUNT.labels(method='POST', endpoint='/detect', status='200').inc()
        return results
        
    except Exception as e:
        # 记录请求失败
        REQUEST_COUNT.labels(method='POST', endpoint='/detect', status='500').inc()
        raise e
        
    finally:
        # 记录响应时间
        duration = time.time() - start_time
        REQUEST_LATENCY.labels(method='POST', endpoint='/detect').observe(duration)
        CONCURRENT_REQUESTS.dec()  # 减少并发计数

# 创建Gradio应用
with gr.Blocks() as demo:
    # ... 你的Gradio界面代码 ...
    
    # 修改检测按钮的调用函数
    detect_btn.click(
        detect_phone_with_metrics,  # 使用带监控的函数
        inputs=[image_input],
        outputs=[output_image, result_text]
    )

# 添加/metrics端点
app = demo.app
app = DispatcherMiddleware(app, {
    '/metrics': make_wsgi_app()
})

# 修改启动方式
if __name__ == "__main__":
    from werkzeug.serving import run_simple
    run_simple('0.0.0.0', 7860, app)

4.3 第二步：创建Docker Compose配置

在手机检测项目根目录创建docker-compose.yml：

version: '3.8'

services:
  # 手机检测应用
  phone-detection:
    build: .
    ports:
      - "7860:7860"    # WebUI端口
      - "8000:8000"    # 监控指标端口（新添加）
    volumes:
      - ./models:/app/models
      - ./logs:/app/logs
    environment:
      - PYTHONUNBUFFERED=1
    restart: unless-stopped
    networks:
      - monitoring-net

  # Prometheus监控服务器
  prometheus:
    image: prom/prometheus:latest
    container_name: prometheus
    ports:
      - "9090:9090"
    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=200h'
      - '--web.enable-lifecycle'
    restart: unless-stopped
    networks:
      - monitoring-net

  # Grafana可视化平台
  grafana:
    image: grafana/grafana:latest
    container_name: grafana
    ports:
      - "3000:3000"
    volumes:
      - grafana_data:/var/lib/grafana
      - ./grafana/provisioning:/etc/grafana/provisioning
    environment:
      - GF_SECURITY_ADMIN_PASSWORD=admin123
      - GF_USERS_ALLOW_SIGN_UP=false
    restart: unless-stopped
    networks:
      - monitoring-net

  # Node Exporter（可选，监控服务器资源）
  node-exporter:
    image: prom/node-exporter:latest
    container_name: node-exporter
    ports:
      - "9100:9100"
    volumes:
      - /proc:/host/proc:ro
      - /sys:/host/sys:ro
      - /:/rootfs:ro
    command:
      - '--path.procfs=/host/proc'
      - '--path.sysfs=/host/sys'
      - '--collector.filesystem.mount-points-exclude=^/(sys|proc|dev|host|etc)($$|/)'
    restart: unless-stopped
    networks:
      - monitoring-net

networks:
  monitoring-net:
    driver: bridge

volumes:
  prometheus_data:
  grafana_data:

4.4 第三步：配置Prometheus

创建prometheus.yml配置文件：

global:
  scrape_interval: 15s  # 每15秒抓取一次数据
  evaluation_interval: 15s  # 每15秒评估一次规则

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

# 抓取目标配置
scrape_configs:
  # 监控手机检测应用
  - job_name: 'phone-detection'
    static_configs:
      - targets: ['phone-detection:8000']  # 应用的服务名和端口
    metrics_path: '/metrics'
    scrape_interval: 10s  # 应用指标抓取间隔更短

  # 监控Prometheus自己
  - job_name: 'prometheus'
    static_configs:
      - targets: ['localhost:9090']

  # 监控服务器资源（通过Node Exporter）
  - job_name: 'node-exporter'
    static_configs:
      - targets: ['node-exporter:9100']
    scrape_interval: 30s

  # 监控Grafana
  - job_name: 'grafana'
    static_configs:
      - targets: ['grafana:3000']
    scrape_interval: 30s

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

创建告警规则文件alert.rules.yml：

groups:
  - name: phone_detection_alerts
    rules:
      # 高错误率告警
      - alert: HighErrorRate
        expr: rate(phone_detection_requests_total{status="500"}[5m]) / rate(phone_detection_requests_total[5m]) > 0.05
        for: 2m
        labels:
          severity: warning
        annotations:
          summary: "手机检测服务错误率过高"
          description: "错误率超过5%，当前值为 {{ $value }}"
          
      # 高延迟告警
      - alert: HighLatency
        expr: histogram_quantile(0.95, rate(phone_detection_request_duration_seconds_bucket[5m])) > 5
        for: 2m
        labels:
          severity: warning
        annotations:
          summary: "手机检测服务延迟过高"
          description: "95%的请求延迟超过5秒，当前值为 {{ $value }}秒"
          
      # 高并发告警
      - alert: HighConcurrency
        expr: phone_detection_concurrent_requests > 10
        for: 1m
        labels:
          severity: warning
        annotations:
          summary: "手机检测服务并发过高"
          description: "并发请求数超过10，当前值为 {{ $value }}"
          
      # 服务宕机告警
      - alert: ServiceDown
        expr: up{job="phone-detection"} == 0
        for: 1m
        labels:
          severity: critical
        annotations:
          summary: "手机检测服务不可用"
          description: "服务已宕机超过1分钟"

4.5 第四步：启动所有服务

# 进入项目目录
cd /root/phone-detection

# 创建必要的目录
mkdir -p grafana/provisioning/datasources
mkdir -p grafana/provisioning/dashboards

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

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

# 启动所有服务
docker-compose up -d

# 查看服务状态
docker-compose ps

4.6 第五步：验证监控是否生效

# 1. 检查手机检测应用的/metrics端点
curl http://localhost:8000/metrics

# 应该能看到类似这样的输出：
# phone_detection_requests_total{method="POST",endpoint="/detect",status="200"} 42
# phone_detection_request_duration_seconds_bucket{method="POST",endpoint="/detect",le="0.1"} 35
# phone_detection_concurrent_requests 2

# 2. 检查Prometheus是否正常
# 浏览器访问 http://你的服务器IP:9090
# 点击Status -> Targets，应该能看到所有监控目标都是UP状态

# 3. 检查Grafana是否正常
# 浏览器访问 http://你的服务器IP:3000
# 用户名：admin，密码：admin123

5. 创建Grafana监控看板

5.1 配置数据源

1. 登录Grafana（http://IP:3000，用户名admin，密码admin123）
2. 点击左侧齿轮图标 → Data Sources → Add data source
3. 选择Prometheus
4. URL填写：http://prometheus:9090
5. 点击Save & Test，应该显示"Data source is working"

5.2 导入预制的手机检测看板

Grafana支持导入JSON格式的看板配置。创建一个phone-detection-dashboard.json文件：

{
  "dashboard": {
    "title": "手机检测系统监控看板",
    "description": "实时监控DAMO-YOLO手机检测WebUI的性能指标",
    "tags": ["phone-detection", "yolo", "monitoring"],
    "style": "dark",
    "timezone": "browser",
    "panels": [
      {
        "id": 1,
        "title": "请求概览",
        "type": "stat",
        "gridPos": {"h": 3, "w": 6, "x": 0, "y": 0},
        "targets": [{
          "expr": "rate(phone_detection_requests_total[5m])",
          "legendFormat": "请求速率",
          "refId": "A"
        }],
        "fieldConfig": {
          "defaults": {
            "unit": "req/s",
            "color": {"mode": "thresholds"},
            "thresholds": {
              "steps": [
                {"color": "green", "value": null},
                {"color": "red", "value": 10}
              ]
            }
          }
        }
      },
      {
        "id": 2,
        "title": "平均响应时间",
        "type": "stat",
        "gridPos": {"h": 3, "w": 6, "x": 6, "y": 0},
        "targets": [{
          "expr": "histogram_quantile(0.5, rate(phone_detection_request_duration_seconds_bucket[5m]))",
          "legendFormat": "中位数响应时间",
          "refId": "A"
        }],
        "fieldConfig": {
          "defaults": {
            "unit": "s",
            "decimals": 3,
            "color": {"mode": "thresholds"},
            "thresholds": {
              "steps": [
                {"color": "green", "value": null},
                {"color": "yellow", "value": 1},
                {"color": "red", "value": 3}
              ]
            }
          }
        }
      },
      {
        "id": 3,
        "title": "当前并发数",
        "type": "stat",
        "gridPos": {"h": 3, "w": 6, "x": 12, "y": 0},
        "targets": [{
          "expr": "phone_detection_concurrent_requests",
          "legendFormat": "并发请求数",
          "refId": "A"
        }],
        "fieldConfig": {
          "defaults": {
            "color": {"mode": "thresholds"},
            "thresholds": {
              "steps": [
                {"color": "green", "value": null},
                {"color": "yellow", "value": 5},
                {"color": "red", "value": 10}
              ]
            }
          }
        }
      },
      {
        "id": 4,
        "title": "错误率",
        "type": "stat",
        "gridPos": {"h": 3, "w": 6, "x": 18, "y": 0},
        "targets": [{
          "expr": "rate(phone_detection_requests_total{status=\"500\"}[5m]) / rate(phone_detection_requests_total[5m])",
          "legendFormat": "错误率",
          "refId": "A"
        }],
        "fieldConfig": {
          "defaults": {
            "unit": "percentunit",
            "decimals": 2,
            "color": {"mode": "thresholds"},
            "thresholds": {
              "steps": [
                {"color": "green", "value": null},
                {"color": "yellow", "value": 0.01},
                {"color": "red", "value": 0.05}
              ]
            }
          }
        }
      },
      {
        "id": 5,
        "title": "请求响应时间分布",
        "type": "heatmap",
        "gridPos": {"h": 8, "w": 12, "x": 0, "y": 3},
        "targets": [{
          "expr": "rate(phone_detection_request_duration_seconds_bucket[5m])",
          "legendFormat": "{{le}}",
          "refId": "A"
        }]
      },
      {
        "id": 6,
        "title": "请求量趋势",
        "type": "graph",
        "gridPos": {"h": 8, "w": 12, "x": 12, "y": 3},
        "targets": [
          {
            "expr": "rate(phone_detection_requests_total{status=\"200\"}[5m])",
            "legendFormat": "成功请求",
            "refId": "A"
          },
          {
            "expr": "rate(phone_detection_requests_total{status=\"500\"}[5m])",
            "legendFormat": "失败请求",
            "refId": "B"
          }
        ]
      },
      {
        "id": 7,
        "title": "检测结果分布",
        "type": "piechart",
        "gridPos": {"h": 8, "w": 12, "x": 0, "y": 11},
        "targets": [{
          "expr": "phone_detection_results_total",
          "legendFormat": "{{confidence_level}}",
          "refId": "A"
        }]
      },
      {
        "id": 8,
        "title": "系统资源使用",
        "type": "graph",
        "gridPos": {"h": 8, "w": 12, "x": 12, "y": 11},
        "targets": [
          {
            "expr": "rate(node_cpu_seconds_total{mode=\"user\"}[5m]) * 100",
            "legendFormat": "CPU使用率",
            "refId": "A"
          },
          {
            "expr": "node_memory_MemTotal_bytes - node_memory_MemAvailable_bytes",
            "legendFormat": "内存使用",
            "refId": "B"
          }
        ]
      }
    ],
    "time": {
      "from": "now-6h",
      "to": "now"
    },
    "timepicker": {
      "refresh_intervals": ["5s", "10s", "30s", "1m", "5m", "15m", "30m", "1h", "2h", "1d"]
    }
  },
  "overwrite": true
}

然后在Grafana中导入这个看板：

1. 点击左侧"+"图标 → Import
2. 将上面的JSON内容粘贴到"Import via panel json"文本框
3. 点击Load
4. 选择Prometheus数据源
5. 点击Import

5.3 看板功能介绍

导入成功后，你会看到一个包含8个面板的监控看板：

顶部状态栏（4个统计面板）：

• 请求概览：实时显示每秒请求数
• 平均响应时间：显示中位数响应时间，超过1秒变黄，超过3秒变红
• 当前并发数：显示正在处理的请求数
• 错误率：显示失败请求的比例

中间区域（4个图表面板）：

1. 请求响应时间分布热图：用颜色深浅显示不同响应时间的请求分布
2. 请求量趋势图：显示成功和失败请求随时间的变化
3. 检测结果分布饼图：显示高、中、低置信度检测结果的占比
4. 系统资源使用图：显示CPU和内存的使用情况

6. 实际使用：从数据中发现问题

6.1 场景分析：如何看懂监控数据

正常情况下的监控看板：

• 请求速率：平稳，根据使用时间有规律波动
• 响应时间：大部分在100ms以内，偶尔有波动
• 错误率：接近0%，偶尔有零星错误
• 并发数：一般1-3个，高峰时段可能到5-8个

发现问题示例：

问题1：内存泄漏

• 现象：内存使用曲线持续上升，重启后下降，然后又持续上升
• 可能原因：代码中有未释放的资源，如图像缓存未清理
• 解决方法：检查代码中的资源释放逻辑，添加内存监控告警

问题2：响应时间变慢

• 现象：响应时间热图中，红色区域（>5秒）增多
• 可能原因：服务器负载过高，或某张图片特别复杂
• 解决方法：查看同时段的并发数，如果并发数也高，考虑扩容

问题3：错误率飙升

• 现象：错误率从0%突然跳到10%
• 可能原因：模型文件损坏，或依赖包版本冲突
• 解决方法：查看错误日志，检查最近是否有更新操作

6.2 设置告警通知

Grafana支持多种告警通知方式，这里以邮件告警为例：

1. 在Grafana中配置SMTP服务器：

   • 点击左侧齿轮图标 → Alerting → Contact points
   • 点击"New contact point"
   • 选择Email，填写SMTP服务器信息

2. 为关键指标设置告警规则：

   • 在监控看板中，点击任意面板标题 → Edit
   • 切换到Alert标签页
   • 点击"Create alert rule from this panel"
   • 设置条件，如：当错误率 > 5%持续2分钟时触发告警
   • 选择通知方式为Email

3. 测试告警：

   # 模拟大量请求，触发告警
   ab -n 1000 -c 50 http://localhost:7860/
   

6.3 日常运维检查清单

每天花5分钟看看监控看板，就能掌握系统健康状态：

早上第一件事：

1. 查看过去24小时的错误率曲线，有没有异常峰值
2. 查看响应时间分布，确认用户体验是否正常
3. 查看系统资源使用，确认没有资源泄漏

发现问题时：

1. 先看错误率和响应时间，定位问题类型
2. 查看同时段的请求量和并发数，判断是否流量问题
3. 查看系统资源，判断是否硬件问题
4. 结合日志分析具体原因

每周回顾：

1. 导出本周的性能报告
2. 分析高峰时段和低谷时段的模式
3. 根据趋势预测下周的容量需求
4. 优化告警阈值，减少误报

7. 高级功能与优化建议

7.1 自定义指标扩展

除了基础监控，你还可以添加业务特定的指标：

# 添加检测质量指标
DETECTION_QUALITY = Histogram(
    'phone_detection_confidence_distribution',
    'Distribution of detection confidence scores',
    buckets=[0.1, 0.3, 0.5, 0.7, 0.9, 1.0]
)

# 添加图片大小指标
IMAGE_SIZE = Histogram(
    'phone_detection_image_size_bytes',
    'Size of uploaded images in bytes',
    buckets=[10240, 102400, 1048576, 5242880, 10485760]  # 10KB, 100KB, 1MB, 5MB, 10MB
)

# 在检测函数中记录这些指标
def detect_phone_with_metrics(image):
    # ... 原有代码 ...
    
    # 记录图片大小
    if hasattr(image, 'size'):
        IMAGE_SIZE.observe(image.size)
    
    # 记录检测置信度
    for result in results:
        DETECTION_QUALITY.observe(result['confidence'])
    
    # ... 其余代码 ...

7.2 性能优化建议

基于监控数据，你可以做这些优化：

1. 根据流量模式调整资源

# 查看历史流量模式
# 在Prometheus中查询：
# rate(phone_detection_requests_total[1h])

# 如果发现每天上午10点是高峰，可以设置定时任务扩容
0 9 * * * docker-compose scale phone-detection=3  # 上午9点扩容到3个实例
0 18 * * * docker-compose scale phone-detection=1  # 下午6点缩容到1个实例

2. 优化模型加载

# 添加模型加载时间监控
MODEL_LOAD_TIME = Gauge(
    'phone_detection_model_load_seconds',
    'Time taken to load the model'
)

# 记录模型加载时间
start_time = time.time()
model = load_model()
MODEL_LOAD_TIME.set(time.time() - start_time)

3. 实现自动扩缩容

# 简单的自动扩缩容逻辑
def check_and_scale():
    # 查询当前并发数
    concurrent_requests = get_current_concurrency()
    
    if concurrent_requests > 10:
        # 并发过高，扩容
        scale_up()
    elif concurrent_requests < 2:
        # 并发过低，缩容
        scale_down()

7.3 安全考虑

1. 保护监控端点

# Nginx配置，限制/metrics端点的访问
location /metrics {
    allow 127.0.0.1;  # 只允许本地访问
    allow 172.18.0.0/16;  # Docker网络
    deny all;
    
    # 或者使用HTTP Basic认证
    auth_basic "Prometheus metrics";
    auth_basic_user_file /etc/nginx/.htpasswd;
}

2. 监控数据保留策略

# prometheus.yml中调整数据保留时间
storage:
  tsdb:
    retention: 15d  # 保留15天数据
    
# 对于长期趋势分析，可以设置不同的保留策略
# - 原始数据：保留15天
# - 5分钟聚合数据：保留30天
# - 1小时聚合数据：保留1年

8. 总结

8.1 监控带来的价值

通过为DAMO-YOLO手机检测WebUI添加Prometheus+Grafana监控，你获得了：

1. 系统可见性

• 实时看到系统运行状态
• 快速定位性能瓶颈
• 及时发现潜在问题

2. 数据驱动的决策

• 基于实际数据做扩容决策
• 优化资源配置，降低成本
• 用数据证明系统价值

3. 主动运维能力

• 问题发生前收到告警
• 趋势分析预测未来需求
• 自动化运维的基础

8.2 后续优化方向

短期优化（1个月内）：

1. 完善告警规则，减少误报
2. 添加更多业务指标，如检测准确率统计
3. 优化监控看板布局，提升可读性

中期规划（3个月内）：

1. 实现自动化扩缩容
2. 添加用户行为分析
3. 建立性能基线，设置SLA

长期目标（6个月内）：

1. 构建完整的可观测性体系（日志+指标+追踪）
2. 实现A/B测试框架，对比不同模型版本
3. 建立容量规划模型，预测未来需求

8.3 开始行动的建议

如果你还没有开始监控，建议按这个顺序实施：

1. 第一周：部署基础监控（Prometheus+Grafana），添加核心指标
2. 第二周：创建监控看板，设置基础告警
3. 第三周：分析监控数据，优化系统配置
4. 第四周：扩展业务指标，完善监控体系

记住，监控不是一次性的工作，而是一个持续的过程。从最简单的"系统是否活着"开始，逐步添加"系统是否健康"、"用户体验如何"、"业务价值多少"等维度的监控。

现在，你的手机检测系统不再是一个黑盒。每一次检测、每一个请求、每一份资源使用，都变成了可视化的数据。你可以自信地回答："系统运行良好，过去24小时处理了1.2万张图片，平均响应时间85ms，错误率0.3%。"

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

---

获取更多AI镜像

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