Nunchaku FLUX.1-dev生产环境监控：Prometheus+Grafana指标可视化

1. 引言

当你把Nunchaku FLUX.1-dev模型部署到生产环境，让它7x24小时为你的应用生成高质量图片时，一个现实的问题就摆在了面前：我怎么知道它运行得怎么样？

是CPU跑满了还是GPU在摸鱼？显存有没有爆掉？生成一张图到底花了多长时间？有没有请求在排队等待？这些问题如果全靠人工去查日志、看终端，不仅效率低下，还容易遗漏关键问题。

今天，我们就来解决这个问题。我将带你为ComfyUI中的Nunchaku FLUX.1-dev模型搭建一套完整的生产环境监控系统，使用业界标准的Prometheus+Grafana组合，让你能够：

• 实时监控：一眼看清系统当前的运行状态
• 历史回溯：随时查看过去任意时间点的性能数据
• 智能告警：在问题发生前就收到预警通知
• 性能优化：基于数据做出科学的调优决策

无论你是个人开发者管理自己的AI创作工具，还是团队负责人维护企业级的AI服务，这套监控方案都能让你对系统的掌控力提升一个档次。

2. 为什么需要监控FLUX.1-dev生产环境

在深入技术实现之前，我们先来聊聊为什么监控如此重要。很多人觉得“我的模型能跑起来就行了”，但生产环境的要求远不止于此。

2.1 生产环境的特殊挑战

资源消耗不可预测 Nunchaku FLUX.1-dev模型在生成不同复杂度、不同分辨率的图片时，资源消耗差异巨大。一张简单的风景图可能只需要几秒，而一张包含多个角色、复杂场景的插画可能需要几分钟。没有监控，你根本不知道系统什么时候会过载。

服务质量需要保障 如果你的应用面向用户提供服务，那么响应时间、成功率就是关键指标。用户可不会理解“GPU显存不够了”这种技术原因，他们只关心“为什么我的图片生成得这么慢”或者“为什么生成失败了”。

成本控制很重要 云服务器的GPU实例可不便宜。监控能帮你发现资源浪费的地方——比如GPU利用率长期低于30%，那可能就需要考虑调整实例规格，或者优化批处理策略。

2.2 监控能帮你解决的具体问题

让我举几个实际的例子：

问题一：显存泄漏 有一次，我们的服务运行了三天后突然崩溃。查看监控发现，虽然每次请求的显存都会释放，但总有几十MB的“残留”。累积到一定程度，显存就爆了。没有监控的话，这种缓慢的泄漏很难被发现。

问题二：性能瓶颈定位 用户反馈“晚上生成图片特别慢”。通过监控数据对比，我们发现晚上7-10点GPU利用率接近100%，而CPU利用率只有30%。这说明瓶颈在GPU，而不是CPU或者内存。

问题三：容量规划 业务量在增长，但该什么时候扩容？监控数据给了我们答案：当GPU平均利用率连续一周超过70%，就该考虑加机器了。

3. 监控方案整体架构

我们的监控系统基于Prometheus+Grafana这套经典组合，下面是整体架构图：

┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
│                 │    │                 │    │                 │
│  ComfyUI with   │────▶│   Prometheus    │────▶│    Grafana      │
│  Nunchaku模型   │    │   数据采集与存储  │    │   数据可视化     │
│                 │    │                 │    │                 │
└─────────────────┘    └─────────────────┘    └─────────────────┘
         │                        │                        │
         │                        │                        │
         ▼                        ▼                        ▼
┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
│  自定义指标      │    │   Alertmanager  │    │   告警通知      │
│  (GPU/显存/耗时) │    │   告警管理      │    │   (邮件/钉钉)   │
└─────────────────┘    └─────────────────┘    └─────────────────┘

3.1 各组件职责

ComfyUI + 自定义指标导出器 这是数据的源头。我们需要在ComfyUI中集成一个指标导出器，把GPU利用率、显存使用、请求耗时等关键指标暴露出来。

Prometheus 负责定时抓取（scrape）ComfyUI暴露的指标数据，并存储到时序数据库中。它还会根据我们设定的规则计算新的指标（比如成功率、平均响应时间）。

Grafana 数据可视化平台。我们从Prometheus查询数据，在Grafana中创建各种图表和仪表盘，让数据变得直观易懂。

Alertmanager 告警管理器。当某个指标超过阈值（比如GPU温度超过85度），Prometheus会发送告警给Alertmanager，再由它分发给不同的接收渠道。

4. 环境准备与部署

4.1 基础环境要求

在开始之前，确保你的环境满足以下要求：

硬件要求

• NVIDIA显卡（已经能运行FLUX.1-dev的机器）
• 至少4GB空闲内存（给监控组件用）
• 至少20GB磁盘空间（存储监控数据）

软件要求

• Docker和Docker Compose（推荐方式）
• 或者直接安装Prometheus、Grafana
• Python 3.10+（ComfyUI本身的要求）

4.2 使用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

  grafana:
    image: grafana/grafana:latest
    container_name: grafana
    restart: unless-stopped
    volumes:
      - grafana_data:/var/lib/grafana
      - ./grafana/provisioning:/etc/grafana/provisioning
    environment:
      - GF_SECURITY_ADMIN_PASSWORD=admin123
      - GF_USERS_ALLOW_SIGN_UP=false
    ports:
      - "3000:3000"
    networks:
      - monitoring

  alertmanager:
    image: prom/alertmanager:latest
    container_name: alertmanager
    restart: unless-stopped
    volumes:
      - ./alertmanager.yml:/etc/alertmanager/alertmanager.yml
      - alertmanager_data:/alertmanager
    command:
      - '--config.file=/etc/alertmanager/alertmanager.yml'
      - '--storage.path=/alertmanager'
    ports:
      - "9093:9093"
    networks:
      - monitoring

  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

volumes:
  prometheus_data:
  grafana_data:
  alertmanager_data:

networks:
  monitoring:
    driver: bridge

创建Prometheus配置文件prometheus.yml：

global:
  scrape_interval: 15s
  evaluation_interval: 15s

alerting:
  alertmanagers:
    - static_configs:
        - targets:
          - alertmanager:9093

rule_files:
  - "alert_rules.yml"

scrape_configs:
  - job_name: 'prometheus'
    static_configs:
      - targets: ['localhost:9090']

  - job_name: 'node-exporter'
    static_configs:
      - targets: ['node-exporter:9100']

  - job_name: 'comfyui-metrics'
    static_configs:
      - targets: ['host.docker.internal:8000']  # ComfyUI的指标端点
    metrics_path: '/metrics'
    scrape_interval: 10s

然后启动所有服务：

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

# 启动服务
docker-compose up -d

# 查看服务状态
docker-compose ps

服务启动后，你可以通过以下地址访问：

• Prometheus: http://localhost:9090
• Grafana: http://localhost:3000 (用户名admin，密码admin123)
• Alertmanager: http://localhost:9093

5. 为ComfyUI添加指标导出

现在监控平台准备好了，我们需要让ComfyUI能够暴露监控指标。

5.1 创建自定义指标导出器

在ComfyUI的custom_nodes目录下创建一个新的节点，专门用于收集和暴露指标：

创建文件custom_nodes/comfyui_metrics_exporter/metrics_exporter.py：

import time
import psutil
import threading
from prometheus_client import start_http_server, Gauge, Counter, Histogram
import torch
import comfy.utils

class ComfyUIMetricsCollector:
    def __init__(self, port=8000):
        self.port = port
        
        # 定义Prometheus指标
        self.gpu_utilization = Gauge(
            'comfyui_gpu_utilization_percent', 
            'GPU utilization percentage', 
            ['gpu_id']
        )
        
        self.gpu_memory_used = Gauge(
            'comfyui_gpu_memory_used_bytes', 
            'GPU memory used in bytes', 
            ['gpu_id']
        )
        
        self.gpu_memory_total = Gauge(
            'comfyui_gpu_memory_total_bytes', 
            'GPU total memory in bytes', 
            ['gpu_id']
        )
        
        self.gpu_temperature = Gauge(
            'comfyui_gpu_temperature_celsius', 
            'GPU temperature in Celsius', 
            ['gpu_id']
        )
        
        self.request_duration = Histogram(
            'comfyui_request_duration_seconds',
            'Time spent processing request',
            ['model_name', 'resolution']
        )
        
        self.requests_total = Counter(
            'comfyui_requests_total',
            'Total number of requests',
            ['model_name', 'status']
        )
        
        self.images_generated = Counter(
            'comfyui_images_generated_total',
            'Total number of images generated',
            ['model_name']
        )
        
        self.cpu_usage = Gauge(
            'comfyui_cpu_usage_percent',
            'CPU usage percentage'
        )
        
        self.memory_usage = Gauge(
            'comfyui_memory_used_bytes',
            'Memory used in bytes'
        )
        
        # 启动指标服务器
        start_http_server(self.port)
        print(f"Metrics server started on port {self.port}")
        
        # 启动后台收集线程
        self.collector_thread = threading.Thread(target=self._collect_metrics, daemon=True)
        self.collector_thread.start()
    
    def _collect_metrics(self):
        """后台收集系统指标"""
        while True:
            try:
                # 收集CPU和内存使用情况
                self.cpu_usage.set(psutil.cpu_percent())
                self.memory_usage.set(psutil.virtual_memory().used)
                
                # 收集GPU指标（如果可用）
                if torch.cuda.is_available():
                    for i in range(torch.cuda.device_count()):
                        gpu_id = str(i)
                        device = torch.cuda.device(i)
                        
                        # GPU利用率
                        utilization = torch.cuda.utilization(i)
                        self.gpu_utilization.labels(gpu_id=gpu_id).set(utilization)
                        
                        # GPU内存
                        memory_used = torch.cuda.memory_allocated(i)
                        memory_total = torch.cuda.get_device_properties(i).total_memory
                        self.gpu_memory_used.labels(gpu_id=gpu_id).set(memory_used)
                        self.gpu_memory_total.labels(gpu_id=gpu_id).set(memory_total)
                        
                        # GPU温度（需要nvidia-smi）
                        try:
                            import subprocess
                            result = subprocess.run(
                                ['nvidia-smi', '--query-gpu=temperature.gpu', '--format=csv,noheader,nounits'],
                                capture_output=True, text=True
                            )
                            if result.returncode == 0:
                                temperatures = result.stdout.strip().split('\n')
                                if i < len(temperatures):
                                    temp = float(temperatures[i])
                                    self.gpu_temperature.labels(gpu_id=gpu_id).set(temp)
                        except:
                            pass
                
            except Exception as e:
                print(f"Error collecting metrics: {e}")
            
            time.sleep(5)  # 每5秒收集一次
    
    def record_request(self, model_name, resolution, duration_seconds, success=True):
        """记录请求指标"""
        status = 'success' if success else 'error'
        
        # 记录请求耗时
        self.request_duration.labels(
            model_name=model_name, 
            resolution=resolution
        ).observe(duration_seconds)
        
        # 记录请求总数
        self.requests_total.labels(
            model_name=model_name,
            status=status
        ).inc()
        
        # 如果成功，记录生成的图片数
        if success:
            self.images_generated.labels(model_name=model_name).inc()

# 全局指标收集器实例
metrics_collector = None

def setup_metrics(port=8000):
    """设置指标收集器"""
    global metrics_collector
    if metrics_collector is None:
        metrics_collector = ComfyUIMetricsCollector(port=port)
    return metrics_collector

5.2 集成到Nunchaku工作流

我们需要修改Nunchaku的工作流，在关键节点添加指标记录。创建一个新的节点文件custom_nodes/comfyui_metrics_exporter/nunchaku_monitor.py：

import time
from .metrics_exporter import metrics_collector

class NunchakuMonitor:
    @classmethod
    def INPUT_TYPES(cls):
        return {
            "required": {
                "model_name": ("STRING", {"default": "nunchaku-flux.1-dev"}),
                "resolution": (["512x512", "768x768", "1024x1024", "custom"], {"default": "1024x1024"}),
            },
            "optional": {
                "custom_resolution": ("STRING", {"default": ""}),
            }
        }
    
    RETURN_TYPES = ()
    FUNCTION = "monitor"
    OUTPUT_NODE = True
    CATEGORY = "monitoring"
    
    def monitor(self, model_name, resolution, custom_resolution=""):
        # 记录请求开始时间
        start_time = time.time()
        
        # 这里我们只是记录指标，实际生成由后续节点完成
        # 在实际集成中，这里会调用原始的生成逻辑
        
        # 计算实际使用的分辨率
        actual_resolution = resolution
        if resolution == "custom" and custom_resolution:
            actual_resolution = custom_resolution
        
        # 返回一个特殊的信号，让后续节点知道要记录指标
        return {
            "model_name": model_name,
            "resolution": actual_resolution,
            "start_time": start_time
        }

class NunchakuGenerationWithMetrics:
    @classmethod
    def INPUT_TYPES(cls):
        return {
            "required": {
                "monitor_data": ("MONITOR_DATA",),
                "prompt": ("STRING", {"multiline": True}),
                "steps": ("INT", {"default": 20, "min": 1, "max": 100}),
            }
        }
    
    RETURN_TYPES = ("IMAGE",)
    FUNCTION = "generate"
    CATEGORY = "nunchaku"
    
    def generate(self, monitor_data, prompt, steps):
        model_name = monitor_data["model_name"]
        resolution = monitor_data["resolution"]
        start_time = monitor_data["start_time"]
        
        try:
            # 这里调用实际的Nunchaku生成逻辑
            # 为了示例，我们模拟一个生成过程
            print(f"Generating image with model {model_name}, resolution {resolution}")
            print(f"Prompt: {prompt}")
            print(f"Steps: {steps}")
            
            # 模拟生成耗时
            time.sleep(2)  # 实际中这里会是真正的生成时间
            
            # 计算总耗时
            duration = time.time() - start_time
            
            # 记录成功的指标
            if metrics_collector:
                metrics_collector.record_request(
                    model_name=model_name,
                    resolution=resolution,
                    duration_seconds=duration,
                    success=True
                )
            
            # 返回一个空的图像（实际中返回生成的图像）
            # 这里需要根据实际生成逻辑调整
            return (torch.zeros(1, 512, 512, 3),)
            
        except Exception as e:
            # 记录失败的指标
            if metrics_collector:
                duration = time.time() - start_time
                metrics_collector.record_request(
                    model_name=model_name,
                    resolution=resolution,
                    duration_seconds=duration,
                    success=False
                )
            raise e

# 注册节点
NODE_CLASS_MAPPINGS = {
    "NunchakuMonitor": NunchakuMonitor,
    "NunchakuGenerationWithMetrics": NunchakuGenerationWithMetrics
}

NODE_DISPLAY_NAME_MAPPINGS = {
    "NunchakuMonitor": "Nunchaku Monitor",
    "NunchakuGenerationWithMetrics": "Nunchaku Generation with Metrics"
}

5.3 修改ComfyUI启动脚本

为了让指标收集器随ComfyUI一起启动，我们需要修改启动脚本。创建或修改custom_nodes/comfyui_metrics_exporter/__init__.py：

from .metrics_exporter import setup_metrics

# 在ComfyUI启动时设置指标收集器
def setup():
    print("Setting up ComfyUI metrics exporter...")
    # 使用8000端口，确保不与ComfyUI的默认端口冲突
    setup_metrics(port=8000)

# 注册设置函数
WEB_DIRECTORY = "./web"
__all__ = ["NODE_CLASS_MAPPINGS", "NODE_DISPLAY_NAME_MAPPINGS", "WEB_DIRECTORY"]

然后在ComfyUI的配置中确保这个节点被加载。修改config.yaml或相应的配置文件。

6. 配置Grafana监控仪表盘

现在指标数据已经能够被Prometheus收集了，接下来我们在Grafana中创建直观的监控仪表盘。

6.1 添加Prometheus数据源

首先登录Grafana（http://localhost:3000），然后：

1. 点击左侧菜单的"Configuration"（齿轮图标）
2. 选择"Data Sources"
3. 点击"Add data source"
4. 选择"Prometheus"
5. 配置URL为：http://prometheus:9090
6. 点击"Save & Test"，应该显示"Data source is working"

6.2 创建Nunchaku FLUX.1-dev专属仪表盘

我们将创建一个包含多个面板的仪表盘，全面监控模型运行状态。

创建仪表盘JSON文件 grafana/provisioning/dashboards/nunchaku_dashboard.json：

{
  "dashboard": {
    "title": "Nunchaku FLUX.1-dev 生产监控",
    "tags": ["nunchaku", "flux", "ai", "monitoring"],
    "timezone": "browser",
    "panels": [
      {
        "id": 1,
        "title": "GPU利用率",
        "type": "stat",
        "gridPos": {"h": 8, "w": 12, "x": 0, "y": 0},
        "targets": [{
          "expr": "avg(comfyui_gpu_utilization_percent)",
          "legendFormat": "GPU {{gpu_id}}",
          "refId": "A"
        }],
        "fieldConfig": {
          "defaults": {
            "unit": "percent",
            "thresholds": {
              "steps": [
                {"color": "green", "value": null},
                {"color": "yellow", "value": 70},
                {"color": "red", "value": 90}
              ]
            }
          }
        }
      },
      {
        "id": 2,
        "title": "GPU显存使用",
        "type": "timeseries",
        "gridPos": {"h": 8, "w": 12, "x": 12, "y": 0},
        "targets": [{
          "expr": "comfyui_gpu_memory_used_bytes",
          "legendFormat": "GPU {{gpu_id}} 已使用",
          "refId": "A"
        }, {
          "expr": "comfyui_gpu_memory_total_bytes",
          "legendFormat": "GPU {{gpu_id}} 总量",
          "refId": "B"
        }],
        "fieldConfig": {
          "defaults": {
            "unit": "bytes",
            "min": 0
          }
        }
      },
      {
        "id": 3,
        "title": "请求响应时间",
        "type": "heatmap",
        "gridPos": {"h": 8, "w": 12, "x": 0, "y": 8},
        "targets": [{
          "expr": "histogram_quantile(0.95, sum(rate(comfyui_request_duration_seconds_bucket[5m])) by (le, model_name))",
          "legendFormat": "{{model_name}} P95",
          "refId": "A"
        }, {
          "expr": "histogram_quantile(0.50, sum(rate(comfyui_request_duration_seconds_bucket[5m])) by (le, model_name))",
          "legendFormat": "{{model_name}} P50",
          "refId": "B"
        }],
        "fieldConfig": {
          "defaults": {
            "unit": "s",
            "decimals": 2
          }
        }
      },
      {
        "id": 4,
        "title": "请求成功率",
        "type": "piechart",
        "gridPos": {"h": 8, "w": 12, "x": 12, "y": 8},
        "targets": [{
          "expr": "sum(rate(comfyui_requests_total[5m])) by (status)",
          "refId": "A"
        }]
      },
      {
        "id": 5,
        "title": "图片生成数量",
        "type": "barchart",
        "gridPos": {"h": 8, "w": 12, "x": 0, "y": 16},
        "targets": [{
          "expr": "sum(increase(comfyui_images_generated_total[1h])) by (model_name)",
          "refId": "A"
        }],
        "fieldConfig": {
          "defaults": {
            "unit": "short"
          }
        }
      },
      {
        "id": 6,
        "title": "系统资源使用",
        "type": "timeseries",
        "gridPos": {"h": 8, "w": 12, "x": 12, "y": 16},
        "targets": [{
          "expr": "comfyui_cpu_usage_percent",
          "legendFormat": "CPU使用率",
          "refId": "A"
        }, {
          "expr": "comfyui_memory_used_bytes / 1024 / 1024 / 1024",
          "legendFormat": "内存使用(GB)",
          "refId": "B"
        }],
        "fieldConfig": {
          "defaults": {
            "unit": "percent",
            "decimals": 1
          }
        }
      }
    ],
    "time": {
      "from": "now-6h",
      "to": "now"
    },
    "refresh": "30s"
  }
}

6.3 配置仪表盘自动加载

为了让Grafana自动加载我们的仪表盘，需要创建配置文件。创建grafana/provisioning/dashboards/dashboard.yml：

apiVersion: 1

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

创建grafana/provisioning/datasources/datasource.yml：

apiVersion: 1

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

重启Grafana服务使配置生效：

docker-compose restart grafana

现在访问Grafana，你应该能看到名为"Nunchaku FLUX.1-dev 生产监控"的仪表盘。

7. 设置告警规则

监控不仅要能看，还要能在出问题时及时通知我们。我们来配置一些关键的告警规则。

7.1 创建告警规则文件

创建alert_rules.yml：

groups:
  - name: nunchaku_alerts
    rules:
      # GPU相关告警
      - alert: HighGPUUsage
        expr: avg(comfyui_gpu_utilization_percent) > 90
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "GPU使用率过高"
          description: "GPU使用率持续5分钟超过90%，当前值 {{ $value }}%"
          
      - alert: HighGPUTemperature
        expr: comfyui_gpu_temperature_celsius > 85
        for: 2m
        labels:
          severity: critical
        annotations:
          summary: "GPU温度过高"
          description: "GPU温度持续2分钟超过85°C，当前值 {{ $value }}°C"
          
      - alert: HighGPUMemoryUsage
        expr: (comfyui_gpu_memory_used_bytes / comfyui_gpu_memory_total_bytes) * 100 > 95
        for: 3m
        labels:
          severity: warning
        annotations:
          summary: "GPU显存使用率过高"
          description: "GPU显存使用率持续3分钟超过95%，当前值 {{ $value }}%"
      
      # 请求相关告警
      - alert: HighRequestLatency
        expr: histogram_quantile(0.95, rate(comfyui_request_duration_seconds_bucket[5m])) > 30
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "请求延迟过高"
          description: "95%的请求延迟超过30秒，当前P95延迟 {{ $value }}秒"
          
      - alert: HighErrorRate
        expr: rate(comfyui_requests_total{status="error"}[5m]) / rate(comfyui_requests_total[5m]) > 0.05
        for: 5m
        labels:
          severity: critical
        annotations:
          summary: "请求错误率过高"
          description: "请求错误率持续5分钟超过5%，当前错误率 {{ $value }}"
          
      # 系统资源告警
      - alert: HighCPUUsage
        expr: comfyui_cpu_usage_percent > 80
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "CPU使用率过高"
          description: "CPU使用率持续5分钟超过80%，当前值 {{ $value }}%"
          
      - alert: HighMemoryUsage
        expr: (comfyui_memory_used_bytes / node_memory_MemTotal_bytes) * 100 > 90
        for: 5m
        labels:
          severity: critical
        annotations:
          summary: "内存使用率过高"
          description: "内存使用率持续5分钟超过90%，当前值 {{ $value }}%"

7.2 配置Alertmanager

创建alertmanager.yml配置告警通知：

global:
  smtp_smarthost: 'smtp.gmail.com:587'
  smtp_from: 'your-email@gmail.com'
  smtp_auth_username: 'your-email@gmail.com'
  smtp_auth_password: 'your-app-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@yourcompany.com'
        send_resolved: true
        
  - name: 'webhook-notifications'
    webhook_configs:
      - url: 'http://your-webhook-url/alert'
        send_resolved: true

inhibit_rules:
  - source_match:
      severity: 'critical'
    target_match:
      severity: 'warning'
    equal: ['alertname', 'dev', 'instance']

7.3 更新Prometheus配置

更新prometheus.yml，添加告警规则文件的引用：

global:
  scrape_interval: 15s
  evaluation_interval: 15s

alerting:
  alertmanagers:
    - static_configs:
        - targets:
          - alertmanager:9093

rule_files:
  - "alert_rules.yml"  # 添加这一行

scrape_configs:
  # ... 其他配置保持不变

重启Prometheus和Alertmanager：

docker-compose restart prometheus alertmanager

8. 实际监控场景分析

有了完整的监控系统，我们来看看在实际生产环境中，这些数据能告诉我们什么。

8.1 性能瓶颈分析

假设你发现图片生成速度变慢了，通过监控仪表盘可以快速定位问题：

场景一：GPU瓶颈

• GPU利用率持续在95%以上
• GPU温度正常
• CPU利用率较低（比如30%）
• 内存使用正常

结论：瓶颈在GPU，可能是并发请求太多，或者单个请求的复杂度太高。解决方案：限制并发数，或者升级GPU。

场景二：内存瓶颈

• GPU利用率正常
• 系统内存使用率超过90%
• 有大量的swap使用

结论：内存不足，系统在使用swap，导致性能下降。解决方案：增加内存，或者优化内存使用。

8.2 容量规划

通过长期监控数据，你可以做出科学的容量规划决策：

什么时候需要扩容？

• GPU平均利用率连续一周超过70%
• 95%的请求延迟超过服务级别协议（SLA）
• 错误率持续上升

扩容多少合适？

• 根据QPS（每秒查询数）增长趋势预测
• 考虑业务增长计划
• 留出20-30%的缓冲空间

8.3 成本优化

监控数据也能帮你节省成本：

发现资源浪费

• GPU在夜间利用率低于10%？考虑使用竞价实例
• 某些模型使用频率很低？考虑按需加载
• 显存分配不合理？优化批处理大小

9. 高级监控技巧

9.1 自定义业务指标

除了系统指标，你还可以添加业务相关的自定义指标：

# 在metrics_exporter.py中添加
class BusinessMetrics:
    def __init__(self):
        self.image_quality_score = Gauge(
            'comfyui_image_quality_score',
            'Average quality score of generated images',
            ['model_name', 'resolution']
        )
        
        self.user_satisfaction = Gauge(
            'comfyui_user_satisfaction_score',
            'User satisfaction score based on feedback',
            ['user_segment']
        )
        
        self.cost_per_image = Gauge(
            'comfyui_cost_per_image_usd',
            'Average cost per generated image in USD',
            ['model_name']
        )
    
    def record_quality_score(self, model_name, resolution, score):
        """记录图片质量评分"""
        self.image_quality_score.labels(
            model_name=model_name,
            resolution=resolution
        ).set(score)
    
    def record_user_feedback(self, user_id, rating):
        """记录用户反馈"""
        # 根据用户ID确定用户分段
        user_segment = self._get_user_segment(user_id)
        self.user_satisfaction.labels(
            user_segment=user_segment
        ).set(rating)
    
    def update_cost_metrics(self, model_name, electricity_cost, cloud_cost):
        """更新成本指标"""
        total_cost = electricity_cost + cloud_cost
        self.cost_per_image.labels(model_name=model_name).set(total_cost)

9.2 集成日志监控

将日志也纳入监控体系，可以更全面地了解系统状态：

import logging
from prometheus_client import Counter

class LogMetricsHandler(logging.Handler):
    def __init__(self):
        super().__init__()
        self.error_counter = Counter(
            'comfyui_log_errors_total',
            'Total number of error logs',
            ['logger_name']
        )
        self.warning_counter = Counter(
            'comfyui_log_warnings_total',
            'Total number of warning logs',
            ['logger_name']
        )
    
    def emit(self, record):
        if record.levelno >= logging.ERROR:
            self.error_counter.labels(logger_name=record.name).inc()
        elif record.levelno >= logging.WARNING:
            self.warning_counter.labels(logger_name=record.name).inc()

# 在ComfyUI中设置日志处理器
log_handler = LogMetricsHandler()
logging.getLogger('comfy').addHandler(log_handler)

9.3 实时性能分析

使用PyTorch Profiler进行更深入的性能分析：

import torch.profiler as profiler

def profile_generation():
    """分析图片生成性能"""
    with profiler.profile(
        activities=[
            profiler.ProfilerActivity.CPU,
            profiler.ProfilerActivity.CUDA,
        ],
        schedule=profiler.schedule(
            wait=1,
            warmup=1,
            active=3,
            repeat=2
        ),
        on_trace_ready=profiler.tensorboard_trace_handler('./logs'),
        record_shapes=True,
        profile_memory=True,
        with_stack=True
    ) as prof:
        # 在这里执行生成操作
        generate_image()
        
        prof.step()
    
    # 将性能数据导出到Prometheus
    export_profiler_metrics(prof)

10. 总结

通过本文的步骤，你已经为Nunchaku FLUX.1-dev模型搭建了一套完整的生产环境监控系统。让我们回顾一下关键收获：

监控的价值远不止"看看数据"

• 问题预警：在用户投诉之前发现问题
• 性能优化：基于数据做出科学的优化决策
• 成本控制：发现并消除资源浪费
• 容量规划：为业务增长做好准备

这套方案的特点

1. 全面性：覆盖了从硬件资源到业务指标的全方位监控
2. 实时性：数据每10秒更新一次，告警能在几分钟内发出
3. 可扩展性：可以轻松添加新的监控指标
4. 可视化：通过Grafana仪表盘，数据一目了然

实际部署建议

1. 从小开始：先部署核心指标监控，再逐步完善
2. 定期审查：每周花10分钟看看监控仪表盘，了解系统运行状况
3. 持续优化：根据实际使用情况调整告警阈值和监控指标
4. 团队共享：让整个团队都能看到监控数据，培养数据驱动的文化

监控不是一次性的工作，而是一个持续的过程。随着你对系统了解的深入，你会不断发现新的需要监控的指标，不断优化告警规则，让系统运行得更加稳定高效。

记住，好的监控系统就像给系统装上了"眼睛"和"耳朵"，让你能够实时了解系统的健康状况，及时发现问题，快速响应变化。现在，你的Nunchaku FLUX.1-dev模型已经具备了这样的能力，可以更加自信地服务于生产环境了。

---

获取更多AI镜像

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