AI API 监控仪表盘：Grafana 面板完整配置 playbook

Tôi là Minh, kiến trúc sư hạ tầng tại một startup AI tại Việt Nam. Hành trình xây dựng hệ thống monitor cho API AI của chúng tôi bắt đầu từ những tháng ngày "mù mờ" về chi phí — đến cuối tháng nhận bill từ OpenAI $2,400, đội ngũ không hiểu tiền đi đâu. Sau 6 tháng triển khai HolySheep AI và xây dựng dashboard Grafana hoàn chỉnh, chúng tôi tiết kiệm 85% chi phí và có full visibility về mọi request. Bài viết này là playbook đầy đủ, có code chạy thật, có số liệu thật.

Vì sao chúng tôi chuyển sang HolySheep AI

Quay lại tháng 3/2024, đội ngũ 8 người dùng GPT-4 qua API chính thức. Mỗi tháng bill dao động $1,800-$3,200 — không ai kiểm soát được. Chúng tôi đã thử:
• Rate limiter tự viết → miss 40% request
• Proxy relay khác → thêm latency 200ms+
• Budget alert đơn giản → alert trễ, không có context

Sau khi thử nghiệm HolySheep AI, kết quả thay đổi hoàn toàn:

• Tỷ giá ¥1=$1 (tương đương tiết kiệm 85%+ so với pricing gốc)
• Hỗ trợ WeChat/Alipay thanh toán — thuận tiện cho team có thành viên Trung Quốc
• Latency trung bình <50ms (so với 150-300ms qua proxy)
• Tín dụng miễn phí khi đăng ký — test trước khi cam kết
• Đầy đủ model: GPT-4.1 ($8/MTok), Claude Sonnet 4.5 ($15/MTok), Gemini 2.5 Flash ($2.50/MTok), DeepSeek V3.2 ($0.42/MTok)

Kiến trúc tổng thể

Trước khi vào code, hiểu rõ luồng dữ liệu:

┌─────────────────────────────────────────────────────────────────────┐
│                        ARCHITECTURE OVERVIEW                        │
├─────────────────────────────────────────────────────────────────────┤
│                                                                     │
│   Client App                                                       │
│       │                                                             │
│       ▼                                                             │
│   ┌─────────────────┐    ┌─────────────────────────────────────┐   │
│   │  Your Service   │───▶│  HolySheep AI  (base_url)           │   │
│   │  Python/Node.js │    │  https://api.holysheep.ai/v1         │   │
│   └────────┬────────┘    └─────────────────────────────────────┘   │
│            │                                                             │
│            │ metrics push                                              │
│            ▼                                                             │
│   ┌─────────────────┐    ┌─────────────────────────────────────┐   │
│   │  Prometheus     │───▶│  Grafana Dashboard                  │   │
│   │  (port 9090)    │    │  Real-time monitoring               │   │
│   └─────────────────┘    └─────────────────────────────────────┘   │
│                                                                     │
└─────────────────────────────────────────────────────────────────────┘

Bước 1: Client SDK với metrics collection

Chúng tôi cần wrapper để capture mọi request, response, latency và cost. Dưới đây là implementation hoàn chỉnh:

#!/usr/bin/env python3
"""
HolySheep AI Client with Prometheus metrics
Author: Minh - Infrastructure Architect
Setup: pip install requests prometheus-client
"""

import requests
import time
import json
from datetime import datetime
from prometheus_client import Counter, Histogram, Gauge, start_http_server

=== HOLYSHEEP CONFIGURATION ===
IMPORTANT: Use HolySheep API - NEVER use api.openai.com or api.anthropic.com
HOLYSHEEP_CONFIG = {
    "base_url": "https://api.holysheep.ai/v1",
    "api_key": "YOUR_HOLYSHEEP_API_KEY",  # Replace with your key
    "default_model": "gpt-4.1"
}

=== METRICS DEFINITIONS ===
Counters - chỉ tăng, không giảm
request_total = Counter(
    'ai_api_requests_total',
    'Total AI API requests',
    ['model', 'status', 'endpoint']
)

Histograms - phân phối latency
request_latency = Histogram(
    'ai_api_request_duration_seconds',
    'Request latency in seconds',
    ['model', 'endpoint'],
    buckets=[0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1.0, 2.5, 5.0]
)

Gauges - giá trị hiện tại
tokens_used = Gauge(
    'ai_api_tokens_used',
    'Tokens used in current window',
    ['model', 'type']  # type: prompt/completion
)

Cost tracking
cost_accumulated = Gauge(
    'ai_api_cost_usd',
    'Accumulated cost in USD',
    ['model']
)

class HolySheepAIClient:
    """Wrapper client với metrics collection cho HolySheep API"""
    
    def __init__(self, api_key: str, base_url: str = "https://api.holysheep.ai/v1"):
        self.base_url = base_url
        self.session = requests.Session()
        self.session.headers.update({
            "Authorization": f"Bearer {api_key}",
            "Content-Type": "application/json"
        })
        
        # Pricing: GPT-4.1 $8/MTok, Claude Sonnet 4.5 $15/MTok, 
        # Gemini 2.5 Flash $2.50/MTok, DeepSeek V3.2 $0.42/MTok
        self.pricing_per_mtok = {
            "gpt-4.1": 8.0,
            "claude-sonnet-4.5": 15.0,
            "gemini-2.5-flash": 2.50,
            "deepseek-v3.2": 0.42,
            "gpt-4o-mini": 0.15,  # fallback model
        }
    
    def chat_completion(self, model: str, messages: list, 
                        temperature: float = 0.7, max_tokens: int = 2048) -> dict:
        """
        Gọi chat completion API với full metrics tracking
        """
        endpoint = f"{self.base_url}/chat/completions"
        start_time = time.perf_counter()
        status = "success"
        error_msg = None
        
        try:
            payload = {
                "model": model,
                "messages": messages,
                "temperature": temperature,
                "max_tokens": max_tokens
            }
            
            response = self.session.post(endpoint, json=payload, timeout=30)
            response.raise_for_status()
            result = response.json()
            
            # Extract usage metrics
            usage = result.get("usage", {})
            prompt_tokens = usage.get("prompt_tokens", 0)
            completion_tokens = usage.get("completion_tokens", 0)
            total_tokens = usage.get("total_tokens", 0)
            
            # Update Prometheus metrics
            request_total.labels(model=model, status="success", endpoint="chat").inc()
            tokens_used.labels(model=model, type="prompt").inc(prompt_tokens)
            tokens_used.labels(model=model, type="completion").inc(completion_tokens)
            
            # Calculate cost: (tokens / 1,000,000) * price_per_mtok
            if model in self.pricing_per_mtok:
                cost = (total_tokens / 1_000_000) * self.pricing_per_mtok[model]
                cost_accumulated.labels(model=model).set(cost)
            
            # Real-time log for debugging
            latency = time.perf_counter() - start_time
            print(f"[{datetime.now().isoformat()}] {model} | "
                  f"tokens:{total_tokens} | cost:${cost:.4f} | "
                  f"latency:{latency*1000:.1f}ms")
            
            return result
            
        except requests.exceptions.Timeout:
            status = "timeout"
            request_total.labels(model=model, status="timeout", endpoint="chat").inc()
            raise Exception("Request timeout after 30s")
            
        except requests.exceptions.HTTPError as e:
            status = f"http_{e.response.status_code}"
            request_total.labels(model=model, status=status, endpoint="chat").inc()
            raise
            
        finally:
            # Always record latency
            latency = time.perf_counter() - start_time
            request_latency.labels(model=model, endpoint="chat").observe(latency)


=== STARTUP ===
if __name__ == "__main__":
    # Start Prometheus metrics server on port 9090
    start_http_server(9090)
    print("✅ Prometheus metrics server started on http://localhost:9090")
    
    # Initialize client
    client = HolySheepAIClient(
        api_key=HOLYSHEEP_CONFIG["api_key"],
        base_url=HOLYSHEEP_CONFIG["base_url"]
    )
    
    # Test request - dùng model DeepSeek V3.2 ($0.42/MTok - rẻ nhất)
    test_messages = [
        {"role": "user", "content": "Explain Grafana monitoring in 2 sentences"}
    ]
    
    result = client.chat_completion(
        model="deepseek-v3.2",  # Most cost-effective model
        messages=test_messages,
        temperature=0.7
    )
    
    print(f"\n📊 Response: {result['choices'][0]['message']['content']}")

Bước 2: Prometheus Configuration

Prometheus cần scrape metrics từ client. Config dưới đây setup hoàn chỉnh:

# prometheus.yml
Author: Minh - Infrastructure Architect
Location: /etc/prometheus/prometheus.yml

global:
  scrape_interval: 15s
  evaluation_interval: 15s
  external_labels:
    cluster: 'ai-production'
    environment: 'production'

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

rule_files:
  - "ai_api_alerts.yml"
  - "ai_cost_alerts.yml"

scrape_configs:
  # Scrape Prometheus itself
  - job_name: 'prometheus'
    static_configs:
      - targets: ['localhost:9090']
        labels:
          service: 'prometheus'

  # Scrape AI API clients - mỗi instance một target
  - job_name: 'ai-api-clients'
    static_configs:
      - targets:
          - 'ai-service-1:9090'  # Primary service
          - 'ai-service-2:9090'  # Secondary service (HA)
          - 'ai-worker:9090'     # Background worker
        labels:
          service: 'ai-api'
          team: 'platform'

    relabel_configs:
      # Extract instance name từ DNS
      - source_labels: [__address__]
        regex: '([^:]+):.*'
        target_label: instance
        replacement: '${1}'

  # Scrape from Kubernetes pods
  - job_name: 'kubernetes-pods'
    kubernetes_sd_configs:
      - role: pod
    relabel_configs:
      - source_labels: [__meta_kubernetes_pod_annotation_prometheus_io_scrape]
        action: keep
        regex: true
      - source_labels: [__meta_kubernetes_pod_annotation_prometheus_io_path]
        action: replace
        target_label: __metrics_path__
        regex: (.+)
      - source_labels: [__address__, __meta_kubernetes_pod_annotation_prometheus_io_port]
        action: replace
        regex: '([^:]+):(\d+)'
        replacement: '$1:$2'
        target_label: __address__

Bước 3: Grafana Dashboard JSON

Dashboard hoàn chỉnh với 6 panel chính. Import JSON này vào Grafana:

{
  "dashboard": {
    "title": "AI API Monitoring - HolySheep Production",
    "uid": "ai-api-holysheep-prod",
    "version": 1,
    "timezone": "Asia/Ho_Chi_Minh",
    "refresh": "10s",
    "panels": [
      {
        "id": 1,
        "title": "Request Rate (req/s)",
        "type": "graph",
        "gridPos": {"x": 0, "y": 0, "w": 12, "h": 8},
        "targets": [
          {
            "expr": "rate(ai_api_requests_total[5m])",
            "legendFormat": "{{model}} - {{status}}",
            "refId": "A"
          }
        ],
        "yaxes": [
          {"format": "reqps", "label": "Requests/sec"},
          {"format": "short"}
        ]
      },
      {
        "id": 2,
        "title": "Latency Distribution (ms)",
        "type": "heatmap",
        "gridPos": {"x": 12, "y": 0, "w": 12, "h": 8},
        "targets": [
          {
            "expr": "histogram_quantile(0.50, rate(ai_api_request_duration_seconds_bucket[5m])) * 1000",
            "legendFormat": "p50",
            "refId": "A"
          },
          {
            "expr": "histogram_quantile(0.95, rate(ai_api_request_duration_seconds_bucket[5m])) * 1000",
            "legendFormat": "p95",
            "refId": "B"
          },
          {
            "expr": "histogram_quantile(0.99, rate(ai_api_request_duration_seconds_bucket[5m])) * 1000",
            "legendFormat": "p99",
            "refId": "C"
          }
        ]
      },
      {
        "id": 3,
        "title": "Token Usage by Model",
        "type": "graph",
        "gridPos": {"x": 0, "y": 8, "w": 12, "h": 8},
        "targets": [
          {
            "expr": "sum(increase(ai_api_tokens_used[1h])) by (model, type)",
            "legendFormat": "{{model}} - {{type}}",
            "refId": "A"
          }
        ],
        "stack": true,
        "fill": 10,
        "colors": ["#7EB26D", "#EAB839", "#6ED0E0", "#EF843C", "#E24D42"]
      },
      {
        "id": 4,
        "title": "Cost per Hour ($)",
        "type": "graph",
        "gridPos": {"x": 12, "y": 8, "w": 12, "h": 8},
        "targets": [
          {
            "expr": "sum(increase(ai_api_cost_usd[1h])) by (model)",
            "legendFormat": "{{model}}",
            "refId": "A"
          }
        ],
        "yaxes": [
          {"format": "currencyUSD", "label": "USD/hour", "min": 0},
          {"format": "short"}
        ],
        "thresholds": {
          "mode": "absolute",
          "steps": [
            {"color": "green", "value": null},
            {"color": "yellow", "value": 50},
            {"color": "red", "value": 100}
          ]
        }
      },
      {
        "id": 5,
        "title": "Error Rate (%)",
        "type": "gauge",
        "gridPos": {"x": 0, "y": 16, "w": 6, "h": 6},
        "targets": [
          {
            "expr": "100 * sum(rate(ai_api_requests_total{status!='success'}[5m])) / sum(rate(ai_api_requests_total[5m]))",
            "refId": "A"
          }
        ],
        "options": {
          "showThresholdLabels": false,
          "showThresholdMarkers": true,
          "minValue": 0,
          "maxValue": 10
        },
        "fieldConfig": {
          "defaults": {
            "thresholds": {
              "steps": [
                {"color": "green", "value": null},
                {"color": "yellow", "value": 1},
                {"color": "red", "value": 5}
              ]
            },
            "unit": "percent",
            "min": 0,
            "max": 10
          }
        }
      },
      {
        "id": 6,
        "title": "Cost Forecast (Monthly)",
        "type": "stat",
        "gridPos": {"x": 6, "y": 16, "w": 6, "h": 6},
        "targets": [
          {
            "expr": "sum(ai_api_cost_usd) * 720 / 24", 
            "legendFormat": "Monthly Forecast",
            "refId": "A"
          }
        ],
        "options": {
          "colorMode": "value",
          "graphMode": "none"
        },
        "fieldConfig": {
          "defaults": {
            "unit": "currencyUSD",
            "decimals": 2,
            "thresholds": {
              "steps": [
                {"color": "green", "value": null},
                {"color": "yellow", "value": 1000},
                {"color": "red", "value": 5000}
              ]
            }
          }
        }
      },
      {
        "id": 7,
        "title": "Model Distribution",
        "type": "piechart",
        "gridPos": {"x": 12, "y": 16, "w": 6, "h": 6},
        "targets": [
          {
            "expr": "sum(increase(ai_api_requests_total[24h])) by (model)",
            "refId": "A"
          }
        ]
      },
      {
        "id": 8,
        "title": "Latency SLO Compliance",
        "type": "gauge",
        "gridPos": {"x": 18, "y": 16, "w": 6, "h": 6},
        "targets": [
          {
            "expr": "100 * sum(rate(ai_api_request_duration_seconds_bucket{le='0.1'}[5m])) / sum(rate(ai_api_request_duration_seconds_count[5m]))",
            "refId": "A"
          }
        ],
        "fieldConfig": {
          "defaults": {
            "unit": "percent",
            "min": 0,
            "max": 100,
            "thresholds": {
              "steps": [
                {"color": "red", "value": null},
                {"color": "yellow", "value": 90},
                {"color": "green", "value": 99}
              ]
            }
          }
        }
      }
    ]
  }
}

Bước 4: Alerting Rules cho chi phí và latency

# ai_cost_alerts.yml
Author: Minh - Alerting for HolySheep AI usage
Location: /etc/prometheus/rules/ai_cost_alerts.yml

groups:
  - name: ai_api_cost_alerts
    rules:
      # Alert khi chi phí hàng giờ vượt $50
      - alert: HighHourlyCost
        expr: sum(increase(ai_api_cost_usd[1h])) > 50
        for: 5m
        labels:
          severity: warning
          team: platform
        annotations:
          summary: "Chi phí AI API cao bất thường"
          description: "Chi phí hàng giờ đạt ${{ $value }}, vượt ngưỡng $50"
          runbook_url: "https://wiki.company/runbooks/high-ai-cost"

      # Alert khi chi phí hàng giờ vượt $100 (CRITICAL)
      - alert:
Tài nguyên liên quan
📚 Hướng dẫn AI API
💰 Xem giá
📖 Tài liệu nhà phát triển
🚀 Đăng ký miễn phí
Bài viết liên quan
AI 功能灰度发布：Feature Flag 控制 AI 模型切换 — Playbook Di Chuyển Toàn 
OpenAI Compatible API 适配：一套代码调用多家模型 — Playbook di chuyển toà
AI 应用国际化：多语言 Prompt 与响应处理 — Hướng Dẫn Toàn Diện