ในโลกของ AI API Gateway การมี SLO (Service Level Objective) ที่แข็งแกร่ง ไม่ใช่ทางเลือกอีกต่อไป แต่เป็นความจำเป็นที่ทุกองค์กรต้องมี โดยเฉพาะเมื่อเราพูดถึง AI API ที่มี latency ต่ำกว่า 50ms และ uptime ที่ต้องการระดับ 99.9% ขึ้นไป

บทความนี้จะพาคุณสร้างระบบ Monitoring และ Alerting ที่ครบวงจร สำหรับ AI API Gateway โดยเน้นกรณีศึกษาจริงจากระบบ E-commerce ที่ประสบปัญหา AI Response พุ่งสูงในช่วง Flash Sale

ทำไม SLO ถึงสำคัญกับ AI API Gateway?

AI API ที่ดีไม่ได้วัดจากความเร็วอย่างเดียว แต่ต้องวัดจาก 4 มิติหลัก:

สำหรับระบบ E-commerce ที่ใช้ AI จัดการลูกค้า การ downtime แม้เพียง 5 นาที อาจหมายถึง การสูญเสียยอดขายหลายแสนบาท และทำลายความไว้วางใจของลูกค้า

กรณีศึกษา: ระบบ E-commerce ที่ประสบปัญหา AI Response พุ่งสูง

ปัญหาที่พบ

บริษัท E-commerce แห่งหนึ่งใช้ HolySheep AI เป็น AI API Gateway สำหรับระบบ Customer Service Bot พบปัญหาดังนี้:

สาเหตุหลัก

หลังจากวิเคราะห์พบว่า ระบบไม่มี Proactive Monitoring และ alert ที่ตั้งไว้ไม่เหมาะกับ pattern ของ AI API traffic

สร้าง Prometheus Exporter สำหรับ AI API Gateway

ขั้นตอนแรกคือการสร้าง custom metrics exporter ที่ดึงข้อมูลจาก HolySheep AI API และ expose ให้ Prometheus ดึงไปเก็บ

# prometheus_exporter.py
import asyncio
import httpx
from prometheus_client import Counter, Histogram, Gauge, start_http_server
import time
from datetime import datetime


กำหนด Metrics

REQUEST_COUNT = Counter(
    'ai_api_requests_total',
    'Total AI API requests',
    ['status', 'model', 'endpoint']
)

REQUEST_LATENCY = Histogram(
    'ai_api_request_duration_seconds',
    'AI API request latency',
    ['model', 'endpoint'],
    buckets=[0.05, 0.1, 0.25, 0.5, 1.0, 2.5, 5.0]
)

ACTIVE_REQUESTS = Gauge(
    'ai_api_active_requests',
    'Number of active requests',
    ['model']
)

MODEL_COST = Counter(
    'ai_api_cost_total_usd',
    'Total API cost in USD',
    ['model']
)


กำหนดค่า config

HOLYSHEEP_BASE_URL = "https://api.holysheep.ai/v1"
API_KEY = "YOUR_HOLYSHEEP_API_KEY"

async def call_ai_api(prompt: str, model: str = "gpt-4.1") -> dict:
    """เรียกใช้ HolySheep AI API พร้อมเก็บ metrics"""
    ACTIVE_REQUESTS.labels(model=model).inc()
    start_time = time.time()
    
    headers = {
        "Authorization": f"Bearer {API_KEY}",
        "Content-Type": "application/json"
    }
    
    payload = {
        "model": model,
        "messages": [{"role": "user", "content": prompt}],
        "temperature": 0.7
    }
    
    try:
        async with httpx.AsyncClient(timeout=30.0) as client:
            response = await client.post(
                f"{HOLYSHEEP_BASE_URL}/chat/completions",
                headers=headers,
                json=payload
            )
            
            elapsed = time.time() - start_time
            
            if response.status_code == 200:
                REQUEST_COUNT.labels(status="success", model=model, endpoint="chat").inc()
                data = response.json()
                
                # คำนวณค่าใช้จ่าย (ตามราคา 2026)
                tokens = data.get("usage", {}).get("total_tokens", 0)
                cost_per_mtok = {
                    "gpt-4.1": 8.0,
                    "claude-sonnet-4.5": 15.0,
                    "gemini-2.5-flash": 2.50,
                    "deepseek-v3.2": 0.42
                }
                cost = (tokens / 1_000_000) * cost_per_mtok.get(model, 8.0)
                MODEL_COST.labels(model=model).inc(cost)
            else:
                REQUEST_COUNT.labels(status="error", model=model, endpoint="chat").inc()
                
            REQUEST_LATENCY.labels(model=model, endpoint="chat").observe(elapsed)
            return response.json()
            
    except Exception as e:
        REQUEST_COUNT.labels(status="exception", model=model, endpoint="chat").inc()
        raise
    finally:
        ACTIVE_REQUESTS.labels(model=model).dec()

async def health_check():
    """ตรวจสอบสถานะ API ทุก 10 วินาที"""
    headers = {"Authorization": f"Bearer {API_KEY}"}
    
    async with httpx.AsyncClient(timeout=10.0) as client:
        try:
            response = await client.get(
                f"{HOLYSHEEP_BASE_URL}/models",
                headers=headers
            )
            if response.status_code == 200:
                print(f"[{datetime.now()}] ✓ API Health: OK")
            else:
                print(f"[{datetime.now()}] ✗ API Health: {response.status_code}")
        except Exception as e:
            print(f"[{datetime.now()}] ✗ API Health: {str(e)}")

async def main():
    # เริ่ม HTTP server สำหรับ Prometheus scrape
    start_http_server(9090)
    print("Prometheus exporter started on :9090")
    
    # Health check loop
    while True:
        await health_check()
        await asyncio.sleep(10)

if __name__ == "__main__":
    asyncio.run(main())

Exporter นี้จะเก็บ metrics สำคัญ 4 ตัว ได้แก่ จำนวน request ทั้งหมด, latency distribution, จำนวน request ที่กำลังทำงาน และค่าใช้จ่ายสะสม ซึ่งทำให้เรามองเห็นภาพรวมของ API ได้อย่างชัดเจน

ตั้งค่า Prometheus Configuration สำหรับ SLO Monitoring

# prometheus.yml
global:
  scrape_interval: 15s
  evaluation_interval: 15s

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

rule_files:
  - "slo_rules.yml"
  - "alert_rules.yml"

scrape_configs:
  - job_name: 'ai-api-gateway'
    static_configs:
      - targets: ['ai-exporter:9090']
    metrics_path: '/metrics'
    scrape_interval: 10s
    
  - job_name: 'ai-api-health'
    static_configs:
      - targets: ['ai-exporter:9091']
    scrape_interval: 30s


--- slo_rules.yml ---

groups:
  - name: ai_slo_metrics
    interval: 30s
    rules:
      # SLO: Availability 99.9%
      - record: job:ai_api_requests_total:rate5m
        expr: |
          sum(rate(ai_api_requests_total{status="success"}[5m])) 
          / 
          sum(rate(ai_api_requests_total[5m]))
      
      # SLO: Latency P99 < 200ms
      - record: job:ai_api_latency_p99:rate5m
        expr: |
          histogram_quantile(0.99, 
            sum(rate(ai_api_request_duration_seconds_bucket[5m])) by (le)
          )
      
      # SLO: Latency P50 < 50ms
      - record: job:ai_api_latency_p50:rate5m
        expr: |
          histogram_quantile(0.50, 
            sum(rate(ai_api_request_duration_seconds_bucket[5m])) by (le)
          )
      
      # Error Budget (100% - SLO Target)
      - record: job:ai_slo_error_budget_remaining
        expr: |
          1 - (
            (1 - job:ai_api_requests_total:rate5m) 
            * 43200  # 12 ชั่วโมงในนาที
          )
      
      # Cost per minute
      - record: job:ai_api_cost_per_minute
        expr: |
          sum(rate(ai_api_cost_total_usd[5m])) * 60

  - name: ai_slo_alerts
    interval: 30s
    rules:
      # Alert: Availability ต่ำกว่า 99.5% (Warning)
      - alert: AIAvailabilityWarning
        expr: job:ai_api_requests_total:rate5m < 0.995
        for: 5m
        labels:
          severity: warning
          slo: availability
        annotations:
          summary: "AI API Availability ต่ำกว่า 99.5%"
          description: "Availability ปัจจุบัน {{ $value | humanizePercentage }} (SLO: 99.9%)"
          runbook_url: "https://docs.example.com/runbooks/ai-availability"
      
      # Alert: Availability ต่ำกว่า 99% (Critical)
      - alert: AIAvailabilityCritical
        expr: job:ai_api_requests_total:rate5m < 0.99
        for: 2m
        labels:
          severity: critical
          slo: availability
        annotations:
          summary: "AI API Availability วิกฤต! ต่ำกว่า 99%"
          description: "Availability ปัจจุบัน {{ $value | humanizePercentage }}"
      
      # Alert: Latency P99 สูงกว่า 500ms
      - alert: AILatencyHigh
        expr: job:ai_api_latency_p99:rate5m > 0.5
        for: 5m
        labels:
          severity: warning
          slo: latency
        annotations:
          summary: "AI API Latency สูงผิดปกติ"
          description: "P99 Latency ปัจจุบัน {{ $value | humanizeDuration }}"
      
      # Alert: Error Rate สูง
      - alert: AIErrorRateHigh
        expr: |
          sum(rate(ai_api_requests_total{status=~"error|exception"}[5m])) 
          / 
          sum(rate(ai_api_requests_total[5m])) > 0.01
        for: 3m
        labels:
          severity: critical
          slo: errors
        annotations:
          summary: "AI API Error Rate สูงเกิน 1%"
          description: "Error Rate ปัจจุบัน {{ $value | humanizePercentage }}"
      
      # Alert: Cost Spike (เพิ่มขึ้น 50% จากค่าเฉลี่ย)
      - alert: AICostSpike
        expr: |
          job:ai_api_cost_per_minute > 
          avg_over_time(job:ai_api_cost_per_minute[1h]) * 1.5
        for: 10m
        labels:
          severity: warning
        annotations:
          summary: "AI API Cost พุ่งสูงผิดปกติ"
          description: "Cost ปัจจุบัน ${{ $value | printf \"%.2f\" }}/min (เพิ่มขึ้น 50% จากค่าเฉลี่ย)"

Configuration นี้กำหนด 4 SLO หลัก ได้แก่ Availability 99.9%, Latency P99 น้อยกว่า 500ms, Error Rate ต่ำกว่า 1% และ Cost Alert ที่จะแจ้งเมื่อค่าใช้จ่ายพุ่งสูงผิดปกติ โดยมี warning และ critical level แยกกันชัดเจน

ตั้งค่า Alertmanager สำหรับ Multi-Channel Alerting

# alertmanager.yml
global:
  resolve_timeout: 5m
  smtp_smarthost: 'smtp.gmail.com:587'
  smtp_from: '[email protected]'
  smtp_auth_username: '[email protected]'

route:
  group_by: ['alertname', 'severity', 'slo']
  group_wait: 30s
  group_interval: 5m
  repeat_interval: 4h
  receiver: 'default-receiver'
  routes:
    # Critical alerts ไป Slack Emergency และ PagerDuty
    - match:
        severity: critical
      receiver: 'critical-receiver'
      continue: true
    
    # Cost alerts ไป Finance team
    - match:
        alertname: AICostSpike
      receiver: 'finance-receiver'
    
    # SLO budget alerts ไป SRE team
    - match:
        slo: availability
      receiver: 'sre-receiver'

receivers:
  - name: 'default-receiver'
    slack_configs:
      - api_url: 'https://hooks.slack.com/services/YOUR/SLACK/WEBHOOK'
        channel: '#ai-alerts'
        title: |
          {{ if eq .Status "firing" }}🔥 {{ else }}✅ {{ end }}
          {{ .GroupLabels.alertname }}
        text: |
          {{ range .Alerts }}
          *{{ .Annotations.summary }}*
          {{ .Annotations.description }}
          
          📊 Current: {{ .Labels.value }}
          ⏰ Started: {{ .StartsAt.Format "15:04:05 MST" }}
          👤 {{ .Labels.team }}
          {{ end }}
        color: |
          {{ if eq .Status "firing" }}
            {{ if eq .CommonLabels.severity "critical" }}danger{{ else }}warning{{ end }}
          {{ else }}good{{ end }}

  - name: 'critical-receiver'
    pagerduty_configs:
      - service_key: 'YOUR_PAGERDUTY_KEY'
        severity: critical
        custom_details:
          - name: 'SLO'
            value: '{{ .Labels.slo }}'
          - name: 'Metric'
            value: '{{ .Labels.value }}'
    
    slack_configs:
      - api_url: 'https://hooks.slack.com/services/YOUR/SLACK/WEBHOOK'
        channel: '#ai-emergency'
        title: '🚨 CRITICAL: AI API Alert!'
        text: |
          *SLO:* {{ .Labels.slo }}
          *Description:* {{ .Annotations.summary }}
          *Action Required:* ดู Runbook {{ .Annotations.runbook_url }}
        slack_configs:
          - send_resolved: true

  - name: 'finance-receiver'
    email_configs:
      - to: '[email protected],[email protected]'
        headers:
          subject: '⚠️ AI API Cost Alert - Action Required'
        html: |
          
AI API Cost Spike Detected

          
Cost ปัจจุบัน: ${{ "$value" }}/min

          
กรุณาตรวจสอบและดำเนินการ


  - name: 'sre-receiver'
    slack_configs:
      - api_url: 'https://hooks.slack.com/services/YOUR/SLACK/WEBHOOK'
        channel: '#sre-alerts'
        send_resolved: true

Alertmanager จะส่ง alert ไปยังหลายช่องทางตามความรุนแรง โดย Critical alerts จะไปถึง PagerDuty และ Slack Emergency ทันที ส่วน Cost alerts จะไปที่ Finance team ผ่าน Email ทำให้ทีมที่เกี่ยวข้องได้รับข้อมูลที่ต้องการโดยไม่ต้อง filter เอง

สร้าง Grafana Dashboard สำหรับ AI API SLO

Dashboard นี้จะแสดงภาพรวม SLO ทั้งหมดในหน้าเดียว ทำให้ทีมสามารถ monitor ได้อย่างมีประสิทธิภาพ

{
  "dashboard": {
    "title": "AI API SLO Dashboard - HolySheep",
    "tags": ["ai", "slo", "production"],
    "timezone": "Asia/Bangkok",
    "panels": [
      {
        "title": "SLO Status - Availability",
        "type": "stat",
        "gridPos": {"x": 0, "y": 0, "w": 6, "h": 4},
        "targets": [{
          "expr": "job:ai_api_requests_total:rate5m * 100",
          "legendFormat": "Availability %"
        }],
        "fieldConfig": {
          "defaults": {
            "unit": "percent",
            "thresholds": {
              "mode": "absolute",
              "steps": [
                {"value": 0, "color": "red"},
                {"value": 99, "color": "orange"},
                {"value": 99.5, "color": "yellow"},
                {"value": 99.9, "color": "green"}
              ]
            }
          }
        }
      },
      {
        "title": "Latency Distribution",
        "type": "timeseries",
        "gridPos": {"x": 6, "y": 0, "w": 12, "h": 8},
        "targets": [
          {
            "expr": "histogram_quantile(0.50, sum(rate(ai_api_request_duration_seconds_bucket[5m])) by (le)) * 1000",
            "legendFormat": "P50"
          },
          {
            "expr": "histogram_quantile(0.95, sum(rate(ai_api_request_duration_seconds_bucket[5m])) by (le)) * 1000",
            "legendFormat": "P95"
          },
          {
            "expr": "histogram_quantile(0.99, sum(rate(ai_api_request_duration_seconds_bucket[5m])) by (le)) * 1000",
            "legendFormat": "P99"
          }
        ],
        "fieldConfig": {
          "defaults": {
            "unit": "ms",
            "custom": {
              "drawStyle": "Line",
              "lineWidth": 2,
              "fillOpacity": 10
            }
          }
        }
      },
      {
        "title": "Error Rate by Model",
        "type": "timeseries",
        "gridPos": {"x": 18, "y": 0, "w": 6, "h": 8},
        "targets": [{
          "expr": "sum(rate(ai_api_requests_total{status=~\"error|exception\"}[5m])) by (model) / sum(rate(ai_api_requests_total[5m])) by (model) * 100",
          "legendFormat": "{{ model }}"
        }],
        "fieldConfig": {
          "defaults": {
            "unit": "percent",
            "custom": {
              "drawStyle": "Bars",
              "fillOpacity": 80
            }
          }
        }
      },
      {
        "title": "API Cost Overview",
        "type": "timeseries",
        "gridPos": {"x": 0, "y": 8, "w": 12, "h": 8},
        "targets": [
          {
            "expr": "sum(rate(ai_api_cost_total_usd[5m])) by (model) * 60",
            "legendFormat": "{{ model }} ($/min)"
          },
          {
            "expr": "sum(rate(ai_api_cost_total_usd[5m])) * 60 * 24",
            "legendFormat": "Total Est. Daily ($)"
          }
        ],
        "fieldConfig": {
          "defaults": {
            "unit": "currencyUSD",
            "custom": {
              "drawStyle": "Line",
              "lineWidth": 2
            }
          }
        }
      },
      {
        "title": "Request Volume by Model",
        "type": "timeseries",
        "gridPos": {"x": 12, "y": 8, "w": 12, "h": 8},
        "targets": [{
          "expr": "sum(rate(ai_api_requests_total[5m])) by (model)",
          "legendFormat": "{{ model }}"
        }],
        "fieldConfig": {
          "defaults": {
            "unit": "reqps",
            "custom": {
              "drawStyle": "Area",
              "fillOpacity": 30
            }
          }
        }
      }
    ],
    "templating": {
      "list": [{
        "name": "slo_target",
        "type": "constant",
        "query": "99.9",
        "hide": 2
      }]
    }
  }
}

Dashboard นี้แสดง 5 panels หลัก ได้แก่ SLO Status ที่แสดงสถานะ availability แบบ real-time, Latency Distribution ที่แสดง P50, P95, P99, Error Rate แยกตาม model, Cost Overview และ Request Volume ทำให้เห็นภาพรวมทั้งหมดในครั้งเดียว

ผลลัพธ์หลังการ implement

หลังจาก implement ระบบ monitoring นี้กับระบบ E-commerce ที่กล่าวถึง:

สิ่งสำคัญที่สุดคือ ทีมสามารถ predict issue ก่อนที่จะเกิดปัญหา โดยเฉพาะในช่วง Flash Sale ที่ traffic พุ่งสูงผิดปกติ

ข้อผิดพลาดที่พบบ่อยและวิธีแก้ไข

1. Prometheus ไม่ scrape metrics หลังจาก restart

อาการ: Prometheus ขึ้น Error "connection refused" เมื่อ scrape ai-exporter

# วิธีแก้ไข: ตรวจสอบ network policy และ service definition


1. ตรวจสอบว่า exporter ทำงานอยู่

docker ps | grep ai-exporter

หรือ

kubectl get pods -n monitoring


2. ตรวจสอบ logs

docker logs ai-exporter

หรือ

kubectl logs -n monitoring deployment/ai-exporter


3. ถ้าใช้ Kubernetes ให้เพิ่ม ServiceMonitor


service-monitor.yml

apiVersion: monitoring.coreos.com/v1
kind: ServiceMonitor
metadata:
  name: ai-exporter
  namespace: monitoring
  labels:
    release: prometheus  # ต้อง match กับ prometheus config
spec:
  selector:
    matchLabels:
      app: ai-exporter
  endpoints:
    - port: metrics
      interval: 10s
      path: /metrics


4. ถ้าใช้ Docker Compose ให้ตรวจสอบ network


docker-compose.yml

services:
  prometheus:
    networks:
      - ai-network
  ai-exporter:
    networks:
      - ai-network

networks:
  ai-network:
    driver: bridge

สาเหตุหลักมักเกิดจาก network isolation ระหว่าง containers หรือ label ไม่ match กับ Prometheus selector ในกรณีของ Kubernetes

2. Alert ไม่ trigger แม้ว่า metrics สูงเกินกว่าค่า threshold

อาการ: Latency สูงเกิน 500ms แต่ไม่มี alert ขึ้น

# วิธีแก้ไข: ตรวจสอบ alert rule และ evaluation


1. ตรวจสอบว่า rule ถูก load แล้ว

curl -s http://prometheus:9090/api/v1/rules | jq '.data.groups[].rules[] | select(.name == "AILatencyHigh")'


2. ตรวจสอบค่า metrics จริง

curl -s 'http://prometheus:9090/api/v1/query?query=job:ai_api_latency_p99:rate5m' | jq


3. ถ้าค่าเป็น null แสดงว่า histogram ไม่มี data


ให้ตรวจสอบว่า exporter ส่ง histogram metrics ถูกต้องหรือไม่

curl -s http://ai-exporter:9090/metrics | grep ai_api_request_duration


ควรเห็น metrics ประมาณนี้:


ai_api_request_duration_seconds_bucket{model="gpt-4.1",endpoint="chat",le="0.05"} 123


ai_api_request_duration_seconds_bucket{model="gpt-4.1",endpoint="chat",le="0.1"} 456



4. Reload Prometheus rules

curl -X POST http://prometheus:9090/-/reload


5. ถ้าใช้ Prometheus Operator ให้ apply rule ใหม่

kubectl apply -f slo_rules.yml -n monitoring

ปัญหานี้มักเกิดจาก การใช้ rate() กับ metrics ที่ไม่มี data หรือ rule ไม่ถูก load เข้า Prometheus การใช้ curl ตรวจสอบ metrics จริงจะช่วยวินิจฉัยไ

แหล่งข้อมูลที่เกี่ยวข้อง

บทความที่เกี่ยวข้อง