Qwen-Image-2512-SDNQ Web服务部署：Prometheus指标暴露+Grafana监控看板

你有没有遇到过这种情况？部署了一个AI图片生成服务，用户反馈说“生成太慢了”，或者“服务好像卡住了”。你打开服务器一看，CPU、内存、GPU使用率都正常，但就是不知道问题出在哪里。更头疼的是，你无法提前知道服务什么时候会出问题，只能等用户抱怨了再去救火。

今天，我要分享一个完整的解决方案：为你的Qwen-Image-2512-SDNQ图片生成Web服务，加上专业的监控系统。通过Prometheus收集指标，用Grafana制作可视化看板，让你能实时看到服务的运行状态，提前发现问题，优化性能。

1. 为什么你的AI服务需要监控？

在深入技术细节之前，我们先聊聊为什么监控如此重要。想象一下，你开了一家餐厅，但不知道厨房里发生了什么——厨师忙不忙？食材够不够？出菜速度快不快？这样的餐厅很难运营好。

AI服务也是一样。Qwen-Image-2512-SDNQ是一个强大的图片生成模型，但作为Web服务运行时，有很多“看不见”的东西：

• 生成队列有多长？ 用户请求是不是在排队等待？
• 每次生成要多久？ 是30秒还是3分钟？
• GPU利用率怎么样？ 是闲置还是过载？
• 内存使用情况如何？ 会不会因为内存泄漏导致服务崩溃？
• 错误率有多高？ 哪些提示词容易导致生成失败？

没有监控，你就像在黑暗中开车——不知道前面有没有坑，只能等撞上了才知道。有了监控，你就能：

• 实时了解服务健康状况
• 快速定位性能瓶颈
• 预测和预防故障
• 基于数据优化服务配置

2. 监控方案整体架构

我们的监控方案基于三个核心组件，它们像流水线一样协同工作：

用户请求 → Flask Web服务 → 生成指标数据 → Prometheus收集 → Grafana展示

让我用更简单的方式解释每个组件的作用：

Flask Web服务：这是你的图片生成服务本身。我们需要在代码里“埋点”，记录各种数据，比如“开始生成图片”、“生成完成”、“生成失败”等事件。

Prometheus：想象成一个专门收集数据的“会计”。它每隔一段时间（比如15秒）就去问Flask服务：“最近有什么新数据吗？”然后把数据记录下来，存到自己的数据库里。

Grafana：这是数据的“展示墙”。它从Prometheus那里读取数据，然后用漂亮的图表展示出来，让你一眼就能看懂服务的运行状况。

这个架构的好处是：

• 实时性：数据几乎实时更新
• 可视化：复杂数据变成直观图表
• 可扩展：可以监控多个服务实例
• 开源免费：全部使用开源工具

3. 改造你的Flask服务：添加指标暴露

首先，我们需要修改原来的Flask应用，让它能够提供监控数据。别担心，改动不大，主要是添加一些“计数器”和“计时器”。

3.1 安装必要的Python包

在你的项目目录下，更新requirements.txt文件，添加监控相关的依赖：

Flask>=2.3.0
torch>=2.0.0
transformers>=4.35.0
diffusers>=0.24.0
accelerate>=0.24.0
prometheus-client>=0.19.0

然后安装它们：

pip install -r requirements.txt

prometheus-client这个包特别重要，它提供了我们需要的所有监控工具。

3.2 修改app.py：添加监控代码

现在打开你的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

然后，在模型加载代码之后，定义我们要监控的指标：

# 监控指标定义
# 计数器：记录各种事件发生的次数
REQUEST_COUNTER = Counter('image_generation_requests_total', 'Total image generation requests', ['status'])
ERROR_COUNTER = Counter('image_generation_errors_total', 'Total image generation errors', ['error_type'])

# 直方图：记录生成时间的分布
GENERATION_TIME = Histogram('image_generation_duration_seconds', 'Image generation duration in seconds')

# 仪表盘：记录当前状态
QUEUE_SIZE = Gauge('image_generation_queue_size', 'Current queue size')
ACTIVE_REQUESTS = Gauge('image_generation_active_requests', 'Number of active generation requests')
GPU_MEMORY_USAGE = Gauge('gpu_memory_usage_mb', 'GPU memory usage in MB')

让我解释一下这些指标是什么意思：

• REQUEST_COUNTER：记录总共处理了多少个请求，成功多少，失败多少
• ERROR_COUNTER：记录各种类型的错误发生了多少次
• GENERATION_TIME：记录每次生成图片花了多少时间（这个特别有用！）
• QUEUE_SIZE：当前有多少请求在排队等待
• ACTIVE_REQUESTS：正在处理中的请求数量
• GPU_MEMORY_USAGE：GPU内存使用了多少

接下来，修改图片生成函数，在关键位置添加监控代码：

@app.route('/api/generate', methods=['POST'])
def generate_image():
    # 增加活跃请求计数
    ACTIVE_REQUESTS.inc()
    
    try:
        # 解析请求参数
        data = request.json
        prompt = data.get('prompt', '')
        
        if not prompt:
            ERROR_COUNTER.labels(error_type='empty_prompt').inc()
            ACTIVE_REQUESTS.dec()
            return jsonify({'error': 'Prompt is required'}), 400
        
        # 记录开始时间
        start_time = time.time()
        
        # 使用线程锁防止并发
        with generation_lock:
            QUEUE_SIZE.inc()
            
            # 这里是你原来的生成代码
            # 调用模型生成图片...
            
            QUEUE_SIZE.dec()
        
        # 记录生成耗时
        duration = time.time() - start_time
        GENERATION_TIME.observe(duration)
        
        # 记录成功请求
        REQUEST_COUNTER.labels(status='success').inc()
        
        # 返回生成的图片
        # ... 原来的返回代码 ...
        
    except Exception as e:
        # 记录错误
        ERROR_COUNTER.labels(error_type=str(type(e).__name__)).inc()
        REQUEST_COUNTER.labels(status='error').inc()
        logger.error(f"Generation error: {str(e)}")
        
        ACTIVE_REQUESTS.dec()
        return jsonify({'error': str(e)}), 500
    
    finally:
        ACTIVE_REQUESTS.dec()

注意看，我们在几个关键位置添加了监控：

1. 请求开始时，增加活跃请求计数
2. 进入队列时，增加队列大小
3. 离开队列时，减少队列大小
4. 生成完成后，记录耗时
5. 成功或失败时，记录相应状态
6. 发生错误时，记录错误类型
7. 最后确保减少活跃请求计数

3.3 添加Prometheus指标端点

最后，我们需要添加一个专门的URL，让Prometheus能够获取这些指标数据：

# 添加Prometheus指标端点
@app.route('/metrics')
def metrics():
    """Prometheus metrics endpoint"""
    # 更新GPU内存使用情况（如果有GPU的话）
    if torch.cuda.is_available():
        gpu_memory = torch.cuda.memory_allocated() / 1024 / 1024  # 转换为MB
        GPU_MEMORY_USAGE.set(gpu_memory)
    
    return generate_latest(), 200, {'Content-Type': CONTENT_TYPE_LATEST}

# 健康检查端点（保留原来的）
@app.route('/api/health')
def health():
    return jsonify({'status': 'ok'})

这个/metrics端点会返回所有监控指标的当前值，格式是Prometheus能理解的文本格式。

3.4 完整的修改示例

为了让修改更清晰，这里是一个完整的修改示例。你可以在原来的app.py基础上，按照这个模式添加监控代码：

"""
Qwen-Image-2512-SDNQ Web服务 - 带监控版本
"""

import os
import threading
import time
import logging
from flask import Flask, request, jsonify, render_template, send_file
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer
from diffusers import DiffusionPipeline
import io
from prometheus_client import Counter, Histogram, Gauge, generate_latest, CONTENT_TYPE_LATEST

# 设置日志
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

app = Flask(__name__)

# 线程锁，防止并发请求冲突
generation_lock = threading.Lock()

# ========== 监控指标定义 ==========
# 计数器
REQUEST_COUNTER = Counter('image_generation_requests_total', 
                         'Total image generation requests', 
                         ['status'])  # status: success, error

ERROR_COUNTER = Counter('image_generation_errors_total',
                       'Total image generation errors',
                       ['error_type'])

# 直方图（记录耗时分布）
GENERATION_TIME = Histogram('image_generation_duration_seconds',
                           'Image generation duration in seconds',
                           buckets=[10, 30, 60, 120, 300, 600])  # 10秒到10分钟的分桶

# 仪表盘（记录当前值）
QUEUE_SIZE = Gauge('image_generation_queue_size', 'Current queue size')
ACTIVE_REQUESTS = Gauge('image_generation_active_requests', 
                       'Number of active generation requests')
GPU_MEMORY_USAGE = Gauge('gpu_memory_usage_mb', 'GPU memory usage in MB')
# ========== 监控指标定义结束 ==========

# 模型路径配置
LOCAL_PATH = "/root/ai-models/Disty0/Qwen-Image-2512-SDNQ-uint4-svd-r32"

# 加载模型（这里是你原来的模型加载代码）
# ...

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

@app.route('/api/generate', methods=['POST'])
def generate_image():
    """生成图片的API端点 - 带监控版本"""
    # 记录请求开始
    request_start_time = time.time()
    ACTIVE_REQUESTS.inc()
    
    try:
        data = request.json
        prompt = data.get('prompt', '')
        
        # 参数验证
        if not prompt:
            ERROR_COUNTER.labels(error_type='empty_prompt').inc()
            return jsonify({'error': 'Prompt is required'}), 400
        
        # 获取其他参数
        negative_prompt = data.get('negative_prompt', '')
        aspect_ratio = data.get('aspect_ratio', '1:1')
        num_steps = int(data.get('num_steps', 50))
        cfg_scale = float(data.get('cfg_scale', 4.0))
        seed = data.get('seed')
        
        # 记录生成开始时间
        generation_start_time = time.time()
        
        # 使用线程锁，防止并发
        with generation_lock:
            QUEUE_SIZE.inc()  # 进入队列
            
            # 这里是你原来的图片生成代码
            # 调用模型，生成图片
            # ...
            
            QUEUE_SIZE.dec()  # 离开队列
        
        # 计算生成耗时
        generation_duration = time.time() - generation_start_time
        GENERATION_TIME.observe(generation_duration)
        
        # 记录成功
        REQUEST_COUNTER.labels(status='success').inc()
        
        # 计算总耗时
        total_duration = time.time() - request_start_time
        
        # 返回图片
        # ... 原来的返回代码 ...
        
        return send_file(
            img_io,
            mimetype='image/png',
            as_attachment=True,
            download_name=f'generated_image_{int(time.time())}.png'
        )
        
    except ValueError as e:
        ERROR_COUNTER.labels(error_type='value_error').inc()
        REQUEST_COUNTER.labels(status='error').inc()
        logger.error(f"Value error: {str(e)}")
        return jsonify({'error': str(e)}), 400
        
    except Exception as e:
        ERROR_COUNTER.labels(error_type='internal_error').inc()
        REQUEST_COUNTER.labels(status='error').inc()
        logger.error(f"Generation error: {str(e)}")
        return jsonify({'error': 'Internal server error'}), 500
        
    finally:
        # 确保减少活跃请求计数
        ACTIVE_REQUESTS.dec()

@app.route('/metrics')
def metrics():
    """Prometheus指标端点"""
    # 更新GPU内存使用情况
    if torch.cuda.is_available():
        try:
            gpu_memory = torch.cuda.memory_allocated() / 1024 / 1024  # 转换为MB
            GPU_MEMORY_USAGE.set(gpu_memory)
        except Exception as e:
            logger.warning(f"Failed to get GPU memory: {str(e)}")
    
    return generate_latest(), 200, {'Content-Type': CONTENT_TYPE_LATEST}

@app.route('/api/health')
def health():
    """健康检查端点"""
    return jsonify({
        'status': 'ok',
        'model_loaded': model is not None,
        'gpu_available': torch.cuda.is_available()
    })

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=7860, debug=False)

4. 部署Prometheus：配置数据收集

现在我们的Flask服务已经能提供指标数据了，接下来需要部署Prometheus来收集这些数据。

4.1 创建Prometheus配置文件

在你的服务器上创建一个目录存放Prometheus配置：

mkdir -p /opt/prometheus
cd /opt/prometheus

创建配置文件prometheus.yml：

# prometheus.yml
global:
  scrape_interval: 15s  # 每15秒收集一次数据
  evaluation_interval: 15s  # 每15秒评估一次规则

# 告警规则配置（可选，后续可以添加）
rule_files:
  # - "alert.rules"

# 抓取配置 - 定义要监控的目标
scrape_configs:
  # Prometheus自身监控
  - job_name: 'prometheus'
    static_configs:
      - targets: ['localhost:9090']
    
  # Qwen图片生成服务监控
  - job_name: 'qwen-image-service'
    static_configs:
      - targets: ['localhost:7860']  # 你的Flask服务地址
    metrics_path: '/metrics'  # 指标端点路径
    scrape_interval: 10s  # 对这个服务10秒收集一次
    
  # 系统监控（需要安装node_exporter）
  - job_name: 'node'
    static_configs:
      - targets: ['localhost:9100']

这个配置文件告诉Prometheus：

• 每15秒收集一次数据（全局设置）
• 特别关注我们的图片生成服务，每10秒收集一次
• 从localhost:7860/metrics这个地址获取数据

4.2 使用Docker运行Prometheus

最简单的方式是用Docker运行Prometheus：

docker run -d \
  --name=prometheus \
  -p 9090:9090 \
  -v /opt/prometheus/prometheus.yml:/etc/prometheus/prometheus.yml \
  prom/prometheus

运行后，打开浏览器访问http://你的服务器IP:9090，就能看到Prometheus的Web界面了。

4.3 验证数据收集

在Prometheus的Web界面，你可以验证是否成功收集到数据：

1. 点击顶部菜单的"Status" → "Targets"

2. 你应该能看到qwen-image-service这个job的状态是"UP"

3. 如果状态是"DOWN"，检查：

   • Flask服务是否在运行
   • 端口7860是否可访问
   • /metrics端点是否能正常返回数据

4. 回到"Graph"页面，在查询框输入image_generation_requests_total，点击"Execute"

5. 如果能看到数据，说明监控系统工作正常！

5. 部署Grafana：创建可视化看板

数据收集好了，现在我们需要一个漂亮的面板来展示这些数据。这就是Grafana的作用。

5.1 使用Docker运行Grafana

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

默认登录信息：

• 地址：http://你的服务器IP:3000
• 用户名：admin
• 密码：admin（首次登录后会要求修改）

5.2 配置数据源

登录Grafana后，需要告诉它从哪里获取数据：

1. 点击左侧菜单的"Configuration"（小齿轮图标）→ "Data Sources"
2. 点击"Add data source"
3. 选择"Prometheus"
4. 配置：
   • URL: http://你的Prometheus服务器IP:9090
   • 其他保持默认
5. 点击"Save & Test"，应该显示"Data source is working"

5.3 创建监控看板

现在可以创建我们的监控看板了。我会带你创建一个包含6个关键面板的看板：

面板1：请求概览（计数器）

这个面板显示总请求数、成功率和错误分布。

配置步骤：

1. 点击"Create" → "Dashboard" → "Add new panel"
2. 在查询框输入：rate(image_generation_requests_total[5m])
3. 点击"Query inspector"查看数据，确认有数据返回
4. 设置面板标题："请求速率（5分钟平均）"
5. 可视化类型选择"Stat"
6. 在"Field"选项卡，设置单位："req/s"
7. 重复以上步骤，添加：
   • 成功请求：rate(image_generation_requests_total{status="success"}[5m])
   • 错误请求：rate(image_generation_requests_total{status="error"}[5m])
   • 错误率：rate(image_generation_errors_total[5m]) / rate(image_generation_requests_total[5m])

面板2：生成时间分布（直方图）

这个面板显示图片生成耗时的分布情况，帮你了解性能表现。

配置步骤：

1. 新建面板
2. 查询：histogram_quantile(0.95, rate(image_generation_duration_seconds_bucket[5m]))
3. 标题："95%请求生成时间"
4. 单位："s"（秒）
5. 再添加几个查询：
   • 中位数（50%）：histogram_quantile(0.50, rate(image_generation_duration_seconds_bucket[5m]))
   • 最大时间：histogram_quantile(0.99, rate(image_generation_duration_seconds_bucket[5m]))

面板3：当前状态（仪表盘）

实时显示当前队列大小和活跃请求数。

配置步骤：

1. 新建面板
2. 查询：image_generation_queue_size
3. 标题："当前队列大小"
4. 可视化类型："Gauge"
5. 设置阈值：绿色0-2，黄色3-5，红色>5
6. 同样添加"活跃请求数"：image_generation_active_requests

面板4：错误分析

分析各种错误类型的分布。

配置步骤：

1. 新建面板
2. 查询：rate(image_generation_errors_total[5m])
3. 标题："错误类型分布"
4. 可视化类型："Pie chart"
5. 按error_type标签分组

面板5：GPU内存使用

监控GPU内存使用情况。

配置步骤：

1. 新建面板
2. 查询：gpu_memory_usage_mb
3. 标题："GPU内存使用"
4. 单位："MB"
5. 可视化类型："Graph"

面板6：请求时间序列

显示请求量随时间的变化。

配置步骤：

1. 新建面板
2. 查询：rate(image_generation_requests_total[5m])
3. 标题："请求量趋势"
4. 可视化类型："Time series"
5. 按status标签拆分

5.4 完整的Grafana看板配置

如果你不想一个个手动创建，可以直接导入这个完整的看板配置：

1. 点击"Create" → "Import"
2. 输入看板ID：1860（这是一个通用的Node Exporter看板，我们可以基于它修改）
3. 或者，创建JSON配置文件导入

这里是一个简化版的看板配置示例，你可以保存为JSON文件然后导入：

{
  "dashboard": {
    "title": "Qwen图片生成服务监控",
    "panels": [
      {
        "title": "请求概览",
        "type": "stat",
        "targets": [
          {
            "expr": "rate(image_generation_requests_total[5m])",
            "legendFormat": "总请求"
          }
        ]
      },
      {
        "title": "生成时间（P95）",
        "type": "stat",
        "targets": [
          {
            "expr": "histogram_quantile(0.95, rate(image_generation_duration_seconds_bucket[5m]))",
            "legendFormat": "95%请求"
          }
        ],
        "fieldConfig": {
          "defaults": {
            "unit": "s"
          }
        }
      }
      // ... 其他面板配置
    ]
  }
}

6. 使用Supervisor管理所有服务

现在我们有三个服务需要管理：Flask应用、Prometheus、Grafana。用Supervisor可以方便地管理它们。

6.1 安装Supervisor

sudo apt-get update
sudo apt-get install supervisor

6.2 配置Flask应用

创建配置文件/etc/supervisor/conf.d/qwen-image.conf：

[program:qwen-image-sdnq-webui]
command=python /root/Qwen-Image-2512-SDNQ-uint4-svd-r32/app.py
directory=/root/Qwen-Image-2512-SDNQ-uint4-svd-r32
user=root
autostart=true
autorestart=true
redirect_stderr=true
stdout_logfile=/root/workspace/qwen-image-sdnq-webui.log
environment=PYTHONUNBUFFERED=1

6.3 配置Prometheus

创建配置文件/etc/supervisor/conf.d/prometheus.conf：

[program:prometheus]
command=docker run --name=prometheus -p 9090:9090 -v /opt/prometheus/prometheus.yml:/etc/prometheus/prometheus.yml prom/prometheus
directory=/opt/prometheus
user=root
autostart=true
autorestart=true
redirect_stderr=true
stdout_logfile=/var/log/prometheus.log

6.4 配置Grafana

创建配置文件/etc/supervisor/conf.d/grafana.conf：

[program:grafana]
command=docker run --name=grafana -p 3000:3000 grafana/grafana
user=root
autostart=true
autorestart=true
redirect_stderr=true
stdout_logfile=/var/log/grafana.log

6.5 启动所有服务

# 重新加载Supervisor配置
sudo supervisorctl reread
sudo supervisorctl update

# 启动所有服务
sudo supervisorctl start all

# 查看状态
sudo supervisorctl status

你应该看到三个服务都是RUNNING状态。

7. 实际使用：从监控数据中获取价值

监控系统搭建好了，现在来看看怎么用它解决实际问题。

7.1 场景一：发现性能瓶颈

问题：用户反馈生成图片越来越慢。

排查步骤：

1. 打开Grafana看板，查看"生成时间（P95）"面板
2. 如果发现生成时间从30秒增加到了60秒
3. 查看"GPU内存使用"面板，如果内存使用率持续很高（比如>90%）
4. 查看"当前队列大小"，如果经常有排队

解决方案：

• 如果GPU内存不足，考虑优化模型或升级硬件
• 如果队列经常有积压，考虑增加服务实例或优化生成逻辑
• 调整生成参数（如减少推理步数）

7.2 场景二：诊断错误原因

问题：服务偶尔返回错误，但不知道原因。

排查步骤：

1. 查看"错误类型分布"面板
2. 如果发现value_error错误很多，可能是用户输入了非法参数
3. 如果internal_error错误很多，可能是模型或代码问题

解决方案：

• 针对value_error，在前端添加输入验证
• 针对internal_error，查看服务日志，定位具体问题

7.3 场景三：容量规划

问题：需要决定是否要扩容服务器。

排查步骤：

1. 查看"请求量趋势"面板，了解业务增长情况
2. 查看"GPU内存使用"面板，了解资源使用趋势
3. 查看"生成时间"面板，了解性能变化

解决方案：

• 如果请求量每月增长20%，GPU使用率已达80%，需要考虑扩容
• 如果生成时间稳定，但请求量增加，可以考虑水平扩展（增加实例）

7.4 场景四：优化用户体验

问题：用户不知道生成要等多久。

解决方案：

1. 基于历史数据，计算平均生成时间
2. 在前端显示预计等待时间："当前有X人在排队，预计等待Y分钟"
3. 如果队列太长，提示用户稍后再试

8. 高级监控技巧

8.1 添加业务指标

除了技术指标，还可以添加业务指标：

# 记录不同宽高比的使用情况
ASPECT_RATIO_COUNTER = Counter('image_generation_aspect_ratio_total',
                              'Image generation by aspect ratio',
                              ['aspect_ratio'])

# 在生成函数中记录
ASPECT_RATIO_COUNTER.labels(aspect_ratio=aspect_ratio).inc()

# 记录提示词长度（了解用户输入习惯）
PROMPT_LENGTH = Histogram('prompt_length_chars',
                         'Prompt length in characters',
                         buckets=[10, 50, 100, 200, 500])
PROMPT_LENGTH.observe(len(prompt))

8.2 设置告警规则

在Prometheus中添加告警规则，当出现问题时自动通知：

创建/opt/prometheus/alert.rules：

groups:
  - name: qwen_alerts
    rules:
      # 错误率过高告警
      - alert: HighErrorRate
        expr: rate(image_generation_errors_total[5m]) / rate(image_generation_requests_total[5m]) > 0.05
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "高错误率"
          description: "错误率超过5%，当前值 {{ $value }}"
      
      # 生成时间过长告警
      - alert: SlowGeneration
        expr: histogram_quantile(0.95, rate(image_generation_duration_seconds_bucket[5m])) > 120
        for: 10m
        labels:
          severity: warning
        annotations:
          summary: "生成时间过长"
          description: "95%的请求生成时间超过120秒"
      
      # 队列积压告警
      - alert: QueueBacklog
        expr: image_generation_queue_size > 5
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "队列积压"
          description: "当前队列大小 {{ $value }}，超过阈值5"

在prometheus.yml中启用告警规则：

rule_files:
  - "alert.rules"

8.3 集成Alertmanager发送通知

配置Alertmanager，当触发告警时发送邮件、Slack或微信通知：

# 下载Alertmanager
wget https://github.com/prometheus/alertmanager/releases/download/v0.25.0/alertmanager-0.25.0.linux-amd64.tar.gz
tar xvf alertmanager-0.25.0.linux-amd64.tar.gz
cd alertmanager-0.25.0.linux-amd64

# 配置alertmanager.yml
cat > alertmanager.yml << EOF
global:
  smtp_smarthost: 'smtp.example.com:587'
  smtp_from: 'alertmanager@example.com'
  smtp_auth_username: 'username'
  smtp_auth_password: 'password'

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

receivers:
  - name: 'email-notifications'
    email_configs:
      - to: 'admin@example.com'
EOF

# 启动Alertmanager
./alertmanager --config.file=alertmanager.yml

9. 总结

通过为Qwen-Image-2512-SDNQ Web服务添加Prometheus和Grafana监控，我们实现了：

1. 实时可视化监控

• 请求量、成功率、错误率一目了然
• 生成时间分布清晰可见
• 队列状态实时掌握
• GPU资源使用情况随时可查

2. 问题快速定位

• 性能瓶颈一眼就能发现
• 错误原因分类统计
• 趋势变化提前预警

3. 数据驱动决策

• 基于实际数据优化服务配置
• 容量规划有据可依
• 用户体验可量化改进

4. 自动化运维

• 异常情况自动告警
• 历史数据对比分析
• 服务健康度量化评估

这个监控方案不仅适用于Qwen图片生成服务，任何AI服务都可以参考这个模式。关键是要想清楚：你需要监控什么？用户关心什么？业务需要什么数据？

监控不是目的，而是手段。好的监控能让你从被动的"救火队员"变成主动的"服务管家"，提前发现问题，优化体验，让服务更稳定、更高效。

---

获取更多AI镜像

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