Phi-4-mini-reasoning模型服务监控方案：Prometheus+Grafana实战

IYA1738

304人浏览 · 2026-02-09 01:12:14

IYA1738 · 2026-02-09 01:12:14 发布

Phi-4-mini-reasoning模型服务监控方案：Prometheus+Grafana实战

如果你正在用Phi-4-mini-reasoning这类推理模型做实际应用，有没有遇到过这样的场景：半夜突然收到用户反馈说服务响应变慢了，但你完全不知道是什么时候开始的，也不知道是哪个环节出了问题。或者更糟，服务直接挂了，你只能凭感觉去猜是GPU内存不够了，还是推理请求太多了。

这种“盲人摸象”的感觉，相信很多做模型部署的朋友都经历过。模型跑起来只是第一步，真正让它稳定可靠地服务用户，才是更大的挑战。今天我就来分享一套完整的监控方案，用Prometheus+Grafana这两个开源工具，帮你把Phi-4-mini-reasoning服务的运行状态看得清清楚楚。

1. 为什么模型服务需要监控？

你可能觉得，模型能正常返回结果不就行了吗？干嘛还要搞监控这么麻烦。但实际情况是，没有监控的服务就像没有仪表盘的汽车——你只知道车在跑，但不知道油还剩多少、发动机温度多高、车速是多少。

对于Phi-4-mini-reasoning这样的推理服务，有几个关键指标你肯定想知道：

推理延迟：用户等一个回答要多久？是稳定的几秒钟，还是偶尔会飙到几十秒？
GPU利用率：你的显卡真的在全力工作吗？还是大部分时间在“摸鱼”？
内存使用：模型加载后占了多少显存？会不会因为内存泄漏导致服务崩溃？
请求量：现在有多少人在用你的服务？高峰期是什么时候？
错误率：有多少请求失败了？失败的原因是什么？

有了这些数据，你就能提前发现问题。比如看到GPU利用率持续在90%以上，就知道该考虑扩容了；看到错误率突然升高，就能立刻排查是不是模型文件损坏了。

2. 监控方案整体设计

我们的方案很简单，就三个核心组件：

数据采集：在Phi-4-mini-reasoning服务里埋点，收集各种指标数据
数据存储：用Prometheus定时拉取并存储这些指标
数据展示：用Grafana把数据变成直观的图表和仪表盘

整个流程就像工厂的生产线监控：传感器（埋点）收集数据，记录仪（Prometheus）存储数据，监控大屏（Grafana）展示数据。

2.1 需要监控哪些指标？

针对Phi-4-mini-reasoning服务，我建议重点关注这几类指标：

性能指标

推理延迟（从收到请求到返回结果的时间）
每秒处理的请求数（QPS）
并发请求数

资源指标

GPU利用率（百分比）
GPU内存使用量
系统内存使用量
CPU使用率

业务指标

总请求数
成功/失败请求数
各错误类型的数量

模型特定指标

输入token数量
输出token数量
推理步数（对于多步推理特别有用）

3. 环境准备与部署

3.1 安装Prometheus

Prometheus的安装很简单，我们直接用Docker来跑：

# 创建配置文件目录
mkdir -p /opt/prometheus/config

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

scrape_configs:
  - job_name: 'phi4-mini-reasoning'
    static_configs:
      - targets: ['host.docker.internal:8000']  # 你的模型服务地址
    metrics_path: '/metrics'  # 指标暴露的路径

  - job_name: 'node-exporter'
    static_configs:
      - targets: ['host.docker.internal:9100']  # 系统指标采集器

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

# 启动Prometheus容器
docker run -d \
  --name=prometheus \
  -p 9090:9090 \
  -v /opt/prometheus/config:/etc/prometheus \
  prom/prometheus

启动后，访问 http://你的服务器IP:9090 就能看到Prometheus的界面了。

3.2 安装Grafana

Grafana同样用Docker部署：

# 创建数据目录
mkdir -p /opt/grafana/data

# 启动Grafana容器
docker run -d \
  --name=grafana \
  -p 3000:3000 \
  -v /opt/grafana/data:/var/lib/grafana \
  grafana/grafana

默认账号密码都是 admin，第一次登录会要求修改密码。

3.3 安装Node Exporter（可选）

如果你想监控服务器本身的资源使用情况（CPU、内存、磁盘等），可以安装Node Exporter：

docker run -d \
  --name=node-exporter \
  -p 9100:9100 \
  --net="host" \
  --pid="host" \
  quay.io/prometheus/node-exporter

4. 为Phi-4-mini-reasoning服务添加监控

假设你的Phi-4-mini-reasoning服务是用Python Flask写的，下面是一个简单的示例，展示如何添加监控埋点。

4.1 安装必要的Python库

pip install prometheus-client psutil pynvml

prometheus-client 是用来暴露指标的，psutil 用来获取系统资源信息，pynvml 用来获取GPU信息。

4.2 创建监控中间件

在你的Flask应用里添加一个监控模块：

# monitoring.py
from prometheus_client import Counter, Gauge, Histogram, generate_latest, REGISTRY
from prometheus_client.exposition import make_wsgi_app
from werkzeug.middleware.dispatcher import DispatcherMiddleware
import psutil
import pynvml
import time
from threading import Thread
import time as time_module

# 初始化GPU监控（如果有GPU的话）
try:
    pynvml.nvmlInit()
    gpu_count = pynvml.nvmlDeviceGetCount()
    HAS_GPU = True
except:
    HAS_GPU = False
    gpu_count = 0

# 定义监控指标
# 请求相关指标
REQUEST_COUNT = Counter(
    'phi4_requests_total',
    'Total number of requests',
    ['method', 'endpoint', 'status']
)

REQUEST_LATENCY = Histogram(
    'phi4_request_duration_seconds',
    'Request latency in seconds',
    ['endpoint']
)

# 资源使用指标
GPU_UTILIZATION = Gauge('phi4_gpu_utilization_percent', 'GPU utilization percentage', ['gpu_id'])
GPU_MEMORY_USED = Gauge('phi4_gpu_memory_used_mb', 'GPU memory used in MB', ['gpu_id'])
GPU_MEMORY_TOTAL = Gauge('phi4_gpu_memory_total_mb', 'GPU total memory in MB', ['gpu_id'])

# 模型推理指标
INPUT_TOKENS = Counter('phi4_input_tokens_total', 'Total input tokens processed')
OUTPUT_TOKENS = Counter('phi4_output_tokens_total', 'Total output tokens generated')
INFERENCE_STEPS = Counter('phi4_inference_steps_total', 'Total inference steps')

# 错误指标
ERROR_COUNT = Counter('phi4_errors_total', 'Total number of errors', ['error_type'])

class ResourceMonitor(Thread):
    """后台线程，定期收集资源使用情况"""
    def __init__(self, interval=5):
        super().__init__(daemon=True)
        self.interval = interval
        
    def run(self):
        while True:
            try:
                # 收集系统资源
                cpu_percent = psutil.cpu_percent(interval=None)
                memory = psutil.virtual_memory()
                
                # 如果有GPU，收集GPU信息
                if HAS_GPU:
                    for i in range(gpu_count):
                        handle = pynvml.nvmlDeviceGetHandleByIndex(i)
                        util = pynvml.nvmlDeviceGetUtilizationRates(handle)
                        memory_info = pynvml.nvmlDeviceGetMemoryInfo(handle)
                        
                        GPU_UTILIZATION.labels(gpu_id=str(i)).set(util.gpu)
                        GPU_MEMORY_USED.labels(gpu_id=str(i)).set(memory_info.used / 1024 / 1024)
                        GPU_MEMORY_TOTAL.labels(gpu_id=str(i)).set(memory_info.total / 1024 / 1024)
                
            except Exception as e:
                print(f"Error collecting resource metrics: {e}")
            
            time_module.sleep(self.interval)

def setup_monitoring(app):
    """设置应用监控"""
    
    # 启动资源监控线程
    monitor = ResourceMonitor()
    monitor.start()
    
    # 添加请求监控中间件
    @app.before_request
    def before_request():
        request.start_time = time.time()
    
    @app.after_request
    def after_request(response):
        # 记录请求延迟
        if hasattr(request, 'start_time'):
            latency = time.time() - request.start_time
            REQUEST_LATENCY.labels(endpoint=request.path).observe(latency)
        
        # 记录请求计数
        REQUEST_COUNT.labels(
            method=request.method,
            endpoint=request.path,
            status=response.status_code
        ).inc()
        
        return response
    
    # 添加/metrics端点
    @app.route('/metrics')
    def metrics():
        return generate_latest(REGISTRY)
    
    return app

def record_inference_metrics(input_tokens=0, output_tokens=0, steps=0):
    """记录推理相关的指标"""
    if input_tokens > 0:
        INPUT_TOKENS.inc(input_tokens)
    if output_tokens > 0:
        OUTPUT_TOKENS.inc(output_tokens)
    if steps > 0:
        INFERENCE_STEPS.inc(steps)

def record_error(error_type):
    """记录错误"""
    ERROR_COUNT.labels(error_type=error_type).inc()

4.3 在模型服务中使用监控

在你的主应用文件中这样使用：

# app.py
from flask import Flask, request, jsonify
from monitoring import setup_monitoring, record_inference_metrics, record_error
import ollama
import time

app = Flask(__name__)

# 设置监控
app = setup_monitoring(app)

@app.route('/api/chat', methods=['POST'])
def chat():
    try:
        data = request.json
        prompt = data.get('prompt', '')
        
        # 记录输入token数（这里需要根据实际tokenizer计算）
        # 简单估算：英文大约1个token对应0.75个单词
        input_tokens = len(prompt.split()) * 0.75
        
        start_time = time.time()
        
        # 调用Phi-4-mini-reasoning模型
        response = ollama.chat(
            model='phi4-mini-reasoning',
            messages=[{'role': 'user', 'content': prompt}],
        )
        
        latency = time.time() - start_time
        
        # 记录输出token数
        output_text = response['message']['content']
        output_tokens = len(output_text.split()) * 0.75
        
        # 记录推理指标
        # 注意：实际推理步数需要从模型返回中获取，这里用1作为示例
        record_inference_metrics(
            input_tokens=int(input_tokens),
            output_tokens=int(output_tokens),
            steps=1
        )
        
        return jsonify({
            'response': output_text,
            'latency': latency,
            'input_tokens': int(input_tokens),
            'output_tokens': int(output_tokens)
        })
        
    except Exception as e:
        # 记录错误
        record_error(str(type(e).__name__))
        return jsonify({'error': str(e)}), 500

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

4.4 配置Prometheus抓取

修改之前创建的Prometheus配置文件，确保它能找到你的服务：

# /opt/prometheus/config/prometheus.yml
scrape_configs:
  - job_name: 'phi4-mini-reasoning'
    static_configs:
      - targets: ['你的服务器IP:8000']  # 改成实际IP
    scrape_interval: 10s  # 每10秒采集一次
    metrics_path: '/metrics'

重启Prometheus容器让配置生效：