Khi xây dựng hệ thống AI production, điều tôi đã học được sau nhiều năm vận hành: không có API nào đáng tin 100%. OpenAI từng downtime 3 lần trong tháng, Anthropic gặp incident kéo dài 6 giờ, và Google AI Studio đôi khi trả về timeout không rõ lý do. Trong bài viết này, tôi sẽ chia sẻ cách triển khai multi-vendor routing với automatic failover — giải pháp giúp hệ thống của bạn sống sót qua mọi cơn bão API.

Mở đầu: So sánh các giải pháp API AI hiện nay

Trước khi đi vào chi tiết kỹ thuật, hãy cùng xem bảng so sánh toàn diện giữa các lựa chọn:

Tiêu chí HolySheep AI API chính hãng Relay service khác
Chi phí GPT-4.1 $8/MTok $60/MTok $45-55/MTok
Chi phí Claude Sonnet 4.5 $15/MTok $108/MTok $80-95/MTok
Chi phí Gemini 2.5 Flash $2.50/MTok $17.50/MTok $12-15/MTok
Chi phí DeepSeek V3.2 $0.42/MTok Không có Không có
Độ trễ trung bình <50ms 80-150ms 100-200ms
Tỷ giá ¥1 = $1 (tiết kiệm 85%+) USD trực tiếp USD hoặc tỷ giá cao
Thanh toán WeChat/Alipay Thẻ quốc tế Đa dạng
Tín dụng miễn phí ✅ Có ❌ Không ⚠️ Ít khi
Multi-vendor routing ✅ Tích hợp sẵn ❌ Cần tự build ⚠️ Hạn chế

Trong thực tế triển khai cho 15+ dự án production, tôi nhận thấy HolySheep AI không chỉ tiết kiệm chi phí mà còn cung cấp hạ tầng routing tốt hơn nhiều relay service khác trên thị trường.

Tại sao cần Multi-Vendor Routing?

Trong 3 năm vận hành hệ thống AI, tôi đã chứng kiến:

Với kiến trúc single-source, mỗi lần provider gặp sự cố, hệ thống của bạn sẽ:

Kiến trúc Multi-Vendor Router

Sơ đồ hoạt động


┌─────────────────────────────────────────────────────────────┐
│                    CLIENT APPLICATION                        │
└─────────────────────────────────────────────────────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────┐
│                   AI API ROUTER                              │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐          │
│  │  Health     │  │  Rate       │  │  Cost       │          │
│  │  Checker    │  │  Limiter    │  │  Optimizer  │          │
│  └─────────────┘  └─────────────┘  └─────────────┘          │
│         │                │                │                   │
│         └────────────────┼────────────────┘                   │
│                          ▼                                    │
│  ┌─────────────────────────────────────────────────────┐     │
│  │              PROVIDER SELECTOR                        │     │
│  │  Priority Queue: HolySheep > Anthropic > OpenAI     │     │
│  └─────────────────────────────────────────────────────┘     │
└─────────────────────────────────────────────────────────────┘
         │                    │                    │
         ▼                    ▼                    ▼
┌─────────────┐     ┌─────────────┐     ┌─────────────┐
│ HolySheep   │     │ Anthropic   │     │ OpenAI      │
│ (Primary)   │     │ (Backup 1)  │     │ (Backup 2)  │
│ <50ms       │     │ 80ms        │     │ 100ms       │
│ $0.42-15    │     │ $15         │     │ $8-60       │
└─────────────┘     └─────────────┘     └─────────────┘

Triển khai Python: Smart Router với Fallback

import asyncio
import time
from typing import Optional, Dict, List
from dataclasses import dataclass
from enum import Enum
import httpx

class ProviderStatus(Enum):
    HEALTHY = "healthy"
    DEGRADED = "degraded"
    DOWN = "down"

@dataclass
class Provider:
    name: str
    base_url: str
    api_key: str
    status: ProviderStatus = ProviderStatus.HEALTHY
    latency_ms: float = 0.0
    failure_count: int = 0
    last_success: float = 0.0

class AIMultiVendorRouter:
    """
    Router thông minh với automatic failover
    Priority: HolySheep > Anthropic > OpenAI
    """
    
    def __init__(self):
        # HolySheep - Provider chính với chi phí thấp nhất
        self.holysheep = Provider(
            name="HolySheep",
            base_url="https://api.holysheep.ai/v1",
            api_key="YOUR_HOLYSHEEP_API_KEY"
        )
        
        # Backup providers
        self.providers: List[Provider] = [
            self.holysheep,
            Provider(
                name="Anthropic",
                base_url="https://api.anthropic.com/v1",
                api_key="YOUR_ANTHROPIC_KEY"
            ),
            Provider(
                name="OpenAI",
                base_url="https://api.openai.com/v1",
                api_key="YOUR_OPENAI_KEY"
            )
        ]
        
        self.health_check_interval = 30  # seconds
        self.failure_threshold = 3
        self.recovery_threshold = 5
        self.max_retries = 2
        
    async def check_provider_health(self, provider: Provider) -> ProviderStatus:
        """Kiểm tra health của provider với timeout 5 giây"""
        start = time.time()
        
        try:
            async with httpx.AsyncClient(timeout=5.0) as client:
                response = await client.get(
                    f"{provider.base_url}/models",
                    headers={"Authorization": f"Bearer {provider.api_key}"}
                )
                
                provider.latency_ms = (time.time() - start) * 1000
                
                if response.status_code == 200:
                    provider.status = ProviderStatus.HEALTHY
                    provider.failure_count = 0
                    provider.last_success = time.time()
                    return ProviderStatus.HEALTHY
                else:
                    provider.failure_count += 1
                    return self._evaluate_status(provider)
                    
        except httpx.TimeoutException:
            provider.failure_count += 2
            provider.latency_ms = 5000
            return self._evaluate_status(provider)
            
        except Exception as e:
            provider.failure_count += 3
            return self._evaluate_status(provider)
    
    def _evaluate_status(self, provider: Provider) -> ProviderStatus:
        if provider.failure_count >= self.failure_threshold:
            provider.status = ProviderStatus.DOWN
        elif provider.failure_count > 0:
            provider.status = ProviderStatus.DEGRADED
        return provider.status
    
    async def select_provider(self) -> Provider:
        """Chọn provider tốt nhất dựa trên health và latency"""
        await asyncio.gather(
            *[self.check_provider_health(p) for p in self.providers]
        )
        
        # Ưu tiên HolySheep nếu healthy
        for provider in self.providers:
            if provider.status == ProviderStatus.HEALTHY:
                if provider.name == "HolySheep":
                    print(f"✅ Selected: {provider.name} ({provider.latency_ms:.1f}ms)")
                return provider
        
        # Fallback to degraded provider
        for provider in self.providers:
            if provider.status == ProviderStatus.DEGRADED:
                print(f"⚠️ Fallback: {provider.name} (degraded)")
                return provider
        
        # Emergency: return first available
        return self.providers[0]
    
    async def chat_completion(
        self,
        messages: List[Dict],
        model: str = "gpt-4.1",
        temperature: float = 0.7
    ) -> Dict:
        """Gọi API với automatic failover"""
        
        for attempt in range(self.max_retries + 1):
            provider = await self.select_provider()
            
            try:
                start_time = time.time()
                
                async with httpx.AsyncClient(timeout=30.0) as client:
                    response = await client.post(
                        f"{provider.base_url}/chat/completions",
                        headers={
                            "Authorization": f"Bearer {provider.api_key}",
                            "Content-Type": "application/json"
                        },
                        json={
                            "model": model,
                            "messages": messages,
                            "temperature": temperature
                        }
                    )
                    
                    latency = (time.time() - start_time) * 1000
                    
                    if response.status_code == 200:
                        result = response.json()
                        result["_meta"] = {
                            "provider": provider.name,
                            "latency_ms": round(latency, 2),
                            "cost_optimized": provider.name == "HolySheep"
                        }
                        return result
                        
                    elif response.status_code == 429:
                        # Rate limit - thử provider khác
                        provider.failure_count += 1
                        await self.check_provider_health(provider)
                        continue
                        
                    else:
                        provider.failure_count += 1
                        continue
                        
            except Exception as e:
                print(f"❌ Error with {provider.name}: {str(e)}")
                provider.failure_count += 1
                continue
        
        raise Exception("All providers failed after retries")


Khởi tạo router

router = AIMultiVendorRouter()


Ví dụ sử dụng

async def main():
    messages = [
        {"role": "user", "content": "Giải thích về multi-vendor routing"}
    ]
    
    result = await router.chat_completion(
        messages=messages,
        model="gpt-4.1"
    )
    
    print(f"Response from: {result['_meta']['provider']}")
    print(f"Latency: {result['_meta']['latency_ms']}ms")
    print(f"Cost optimized: {result['_meta']['cost_optimized']}")

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

Triển khai Node.js: Production-Ready Router

const axios = require('axios');

// Cấu hình provider - HolySheep làm primary
const PROVIDERS = [
  {
    name: 'HolySheep',
    baseURL: 'https://api.holysheep.ai/v1',
    apiKey: process.env.HOLYSHEEP_API_KEY,
    priority: 1,
    isHealthy: true,
    latencyMs: 0,
    failureCount: 0
  },
  {
    name: 'Anthropic',
    baseURL: 'https://api.anthropic.com/v1',
    apiKey: process.env.ANTHROPIC_API_KEY,
    priority: 2,
    isHealthy: true,
    latencyMs: 0,
    failureCount: 0
  },
  {
    name: 'OpenAI',
    baseURL: 'https://api.openai.com/v1',
    apiKey: process.env.OPENAI_API_KEY,
    priority: 3,
    isHealthy: true,
    latencyMs: 0,
    failureCount: 0
  }
];

const FAILURE_THRESHOLD = 3;
const HEALTH_CHECK_INTERVAL = 30000; // 30 giây
const REQUEST_TIMEOUT = 30000; // 30 giây

class AIMultiVendorRouter {
  constructor() {
    this.providers = PROVIDERS;
    this.currentProviderIndex = 0;
    
    // Bắt đầu health check định kỳ
    this.startHealthChecks();
  }

  startHealthChecks() {
    setInterval(async () => {
      console.log('🔄 Running health checks...');
      await this.checkAllProviders();
    }, HEALTH_CHECK_INTERVAL);
  }

  async checkAllProviders() {
    const checks = this.providers.map(provider => 
      this.checkProviderHealth(provider)
    );
    await Promise.all(checks);
  }

  async checkProviderHealth(provider) {
    const start = Date.now();
    
    try {
      await axios.get(${provider.baseURL}/models, {
        headers: { 'Authorization': Bearer ${provider.apiKey} },
        timeout: 5000
      });
      
      provider.latencyMs = Date.now() - start;
      provider.isHealthy = true;
      provider.failureCount = 0;
      
      console.log(✅ ${provider.name}: Healthy (${provider.latencyMs}ms));
      
    } catch (error) {
      provider.failureCount++;
      provider.isHealthy = provider.failureCount < FAILURE_THRESHOLD;
      
      console.log(❌ ${provider.name}: Unhealthy (failures: ${provider.failureCount}));
    }
  }

  selectProvider() {
    // Ưu tiên HolySheep nếu healthy
    const sorted = [...this.providers].sort((a, b) => a.priority - b.priority);
    
    for (const provider of sorted) {
      if (provider.isHealthy) {
        console.log(📡 Selected: ${provider.name} (${provider.latencyMs}ms));
        return provider;
      }
    }
    
    // Fallback: trả về HolySheep dù có thể degraded
    return this.providers[0];
  }

  async chatCompletion({ messages, model = 'gpt-4.1', temperature = 0.7 }) {
    const maxRetries = 2;
    
    for (let attempt = 0; attempt <= maxRetries; attempt++) {
      const provider = this.selectProvider();
      
      try {
        const startTime = Date.now();
        
        const response = await axios.post(
          ${provider.baseURL}/chat/completions,
          {
            model: model,
            messages: messages,
            temperature: temperature
          },
          {
            headers: {
              'Authorization': Bearer ${provider.apiKey},
              'Content-Type': 'application/json'
            },
            timeout: REQUEST_TIMEOUT
          }
        );
        
        const latencyMs = Date.now() - startTime;
        
        return {
          data: response.data,
          meta: {
            provider: provider.name,
            latencyMs: latencyMs,
            costOptimized: provider.name === 'HolySheep',
            attempt: attempt + 1
          }
        };
        
      } catch (error) {
        console.error(⚠️ ${provider.name} failed (attempt ${attempt + 1}):, 
          error.response?.status || error.message);
        
        provider.failureCount++;
        provider.isHealthy = provider.failureCount < FAILURE_THRESHOLD;
        
        if (attempt < maxRetries) {
          await this.checkAllProviders();
        }
      }
    }
    
    throw new Error('All providers failed after maximum retries');
  }
}

// Khởi tạo singleton
const aiRouter = new AIMultiVendorRouter();

// Middleware cho Express
const aiMiddleware = async (req, res, next) => {
  req.aiRouter = aiRouter;
  next();
};

// Route example
app.post('/api/chat', aiMiddleware, async (req, res) => {
  try {
    const { messages, model, temperature } = req.body;
    
    const result = await req.aiRouter.chatCompletion({
      messages,
      model: model || 'gpt-4.1',
      temperature: temperature || 0.7
    });
    
    res.json({
      success: true,
      data: result.data,
      meta: result.meta
    });
    
  } catch (error) {
    res.status(500).json({
      success: false,
      error: error.message
    });
  }
});

module.exports = { AIMultiVendorRouter, aiMiddleware };

Tối ưu chi phí với Smart Model Routing

// Chi phí theo model (USD per 1M tokens)
const MODEL_COSTS = {
  // HolySheep - Tiết kiệm 85%+
  'gpt-4.1': 8,                    // vs $60 chính hãng
  'claude-sonnet-4.5': 15,         // vs $108 chính hãng
  'gemini-2.5-flash': 2.50,        // vs $17.50 chính hãng
  'deepseek-v3.2': 0.42,          // Không có ở nhà cung cấp khác
  
  // Backup - khi HolySheep down
  'gpt-4': 30,
  'claude-3-opus': 75,
  'gemini-pro': 7
};

// Task routing logic
const TASK_ROUTING = {
  'simple_classification': {
    preferred_model: 'deepseek-v3.2',
    fallback: 'gemini-2.5-flash',
    max_cost_per_1k: 0.10
  },
  'code_generation': {
    preferred_model: 'gpt-4.1',
    fallback: 'claude-sonnet-4.5',
    max_cost_per_1k: 2.00
  },
  'complex_reasoning': {
    preferred_model: 'claude-sonnet-4.5',
    fallback: 'gpt-4.1',
    max_cost_per_1k: 3.00
  },
  'fast_response': {
    preferred_model: 'gemini-2.5-flash',
    fallback: 'deepseek-v3.2',
    max_cost_per_1k: 0.50
  }
};

class CostOptimizingRouter extends AIMultiVendorRouter {
  selectModelForTask(taskType, estimatedTokens) {
    const routing = TASK_ROUTING[taskType];
    if (!routing) {
      return { model: 'gpt-4.1', provider: 'HolySheep' };
    }
    
    // Kiểm tra HolySheep có model không
    const primaryModel = routing.preferred_model;
    const estimatedCost = (estimatedTokens / 1000) * MODEL_COSTS[primaryModel];
    
    if (estimatedCost <= routing.max_cost_per_1k) {
      return {
        model: primaryModel,
        provider: 'HolySheep',
        estimatedCost: estimatedCost
      };
    }
    
    // Fallback to cheaper model
    return {
      model: routing.fallback,
      provider: 'HolySheep',
      estimatedCost: (estimatedTokens / 1000) * MODEL_COSTS[routing.fallback]
    };
  }
  
  calculateSavings(actualCost, originalCost) {
    const savings = ((originalCost - actualCost) / originalCost * 100).toFixed(1);
    return ${savings}%;
  }
}

// Ví dụ sử dụng
const costRouter = new CostOptimizingRouter();

async function processTask(taskType, messages, estimatedTokens = 500) {
  const modelConfig = costRouter.selectModelForTask(taskType, estimatedTokens);
  
  console.log(Task: ${taskType});
  console.log(Model: ${modelConfig.model});
  console.log(Provider: ${modelConfig.provider});
  console.log(Estimated cost: $${modelConfig.estimatedCost.toFixed(4)});
  
  const result = await costRouter.chatCompletion({
    messages,
    model: modelConfig.model
  });
  
  // Tính toán savings
  const originalCost = (estimatedTokens / 1000) * 60; // GPT-4.1 chính hãng
  console.log(`Actual savings: ${costRouter.calculateSavings(
    modelConfig.estimatedCost, 
    originalCost
  )}`);
  
  return result;
}

// Chạy test
(async () => {
  const messages = [{ role: 'user', content: 'Phân loại văn bản này' }];
  
  await processTask('simple_classification', messages, 200);
  await processTask('code_generation', messages, 1000);
  await processTask('fast_response', messages, 100);
})();

Lỗi thường gặp và cách khắc phục

1. Lỗi "Connection timeout" khi HolySheep down

# Vấn đề: Request bị timeout sau 30 giây dù đã có fallback

Nguyên nhân: Health check không chạy đúng lúc



Khắc phục: Implement circuit breaker pattern

class CircuitBreaker:
    def __init__(self, provider, threshold=5, timeout=60):
        self.provider = provider
        self.threshold = threshold
        self.timeout = timeout
        self.failures = 0
        self.last_failure_time = 0
        self.state = "CLOSED"  # CLOSED, OPEN, HALF_OPEN
        
    def call(self, func):
        if self.state == "OPEN":
            if time.time() - self.last_failure_time > self.timeout:
                self.state = "HALF_OPEN"
            else:
                raise Exception(f"Circuit OPEN for {self.provider.name}")
        
        try:
            result = func()
            if self.state == "HALF_OPEN":
                self.state = "CLOSED"
                self.failures = 0
            return result
        except Exception as e:
            self.failures += 1
            self.last_failure_time = time.time()
            
            if self.failures >= self.threshold:
                self.state = "OPEN"
                print(f"🔴 Circuit OPENED for {self.provider.name}")
            
            raise e


Sử dụng circuit breaker

circuit = CircuitBreaker(holysheep_provider, threshold=3, timeout=30)
try:
    result = circuit.call(lambda: call_holysheep_api())
except:
    # Tự động failover sang provider khác
    result = call_backup_provider()

2. Lỗi "Rate limit exceeded" liên tục

# Vấn đề: Bị rate limit dù đã có nhiều provider

Nguyên nhân: Không theo dõi quota riêng cho mỗi provider



Khắc phục: Implement per-provider rate limiter

from collections import defaultdict
import time

class PerProviderRateLimiter:
    def __init__(self):
        self.limits = {
            'HolySheep': {'requests_per_min': 1000, 'tokens_per_min': 100000},
            'Anthropic': {'requests_per_min': 500, 'tokens_per_min': 50000},
            'OpenAI': {'requests_per_min': 500, 'tokens_per_min': 50000}
        }
        self.usage = defaultdict(lambda: {'requests': [], 'tokens': []})
        
    def check_limit(self, provider_name, estimated_tokens=1000):
        now = time.time()
        provider_limits = self.limits[provider_name]
        usage = self.usage[provider_name]
        
        # Clean old entries (trước 1 phút)
        usage['requests'] = [t for t in usage['requests'] if now - t < 60]
        usage['tokens'] = [t for t in usage['tokens'] if now - t < 60]
        
        # Check requests limit
        if len(usage['requests']) >= provider_limits['requests_per_min']:
            return False, f"Request limit reached for {provider_name}"
        
        # Check tokens limit
        total_tokens = sum(usage['tokens'])
        if total_tokens + estimated_tokens > provider_limits['tokens_per_min']:
            return False, f"Token limit reached for {provider_name}"
        
        return True, "OK"
    
    def record_usage(self, provider_name, tokens):
        now = time.time()
        self.usage[provider_name]['requests'].append(now)
        self.usage[provider_name]['tokens'].append(tokens)
        
    async def call_with_limit(self, provider, func, tokens=1000):
        allowed, msg = self.check_limit(provider.name, tokens)
        
        if not allowed:
            print(f"⏳ Rate limit: {msg}")
            raise Exception(msg)
        
        result = await func()
        self.record_usage(provider.name, tokens)
        return result


Sử dụng

rate_limiter = PerProviderRateLimiter()

async def safe_call(provider, messages):
    await rate_limiter.call_with_limit(
        provider,
        lambda: call_api(provider, messages),
        estimated_tokens=500
    )

3. Lỗi "Inconsistent responses" khi failover nhanh

# Vấn đề: User nhận được response khác nhau khi failover

Nguyên nhân: Mỗi model có cách interpret khác nhau



Khắc phục: Implement response normalization

class ResponseNormalizer:
    @staticmethod
    def normalize(response, target_format='standard'):
        if target_format == 'standard':
            return ResponseNormalizer._to_openai_format(response)
        return response
    
    @staticmethod
    def _to_openai_format(response):
        # Convert từ nhiều format về OpenAI standard
        if 'content' in response:
            # Anthropic format
            return {
                'id': response.get('id', 'unknown'),
                'object': 'chat.completion',
                'created': response.get('created', int(time.time())),
                'model': response.get('model', 'unknown'),
                'choices': [{
                    'index': 0,
                    'message': {
                        'role': 'assistant',
                        'content': response['content']
                    },
                    'finish_reason': 'stop'
                }],
                'usage': response.get('usage', {})
            }
        return response


Implement retry với exponential backoff

class RetryHandler:
    @staticmethod
    async def with_retry(func, max_attempts=3, base_delay=1):
        for attempt in range(max_attempts):
            try:
                return await func()
            except Exception as e:
                if attempt == max_attempts - 1:
                    raise
                
                delay = base_delay * (2 ** attempt)  # 1s, 2s, 4s
                print(f"⏳ Retry in {delay}s (attempt {attempt + 1}/{max_attempts})")
                await asyncio.sleep(delay)

4. Lỗi "Stale health status" gây chọn provider đã down

# Vấn đề: Health check cache quá lâu, chọn provider đã down

Nguyên nhân: Không invalidate cache khi request fail



Khắc phục: Implement real-time health tracking

class RealTimeHealthTracker:
    def __init__(self):
        self.provider_health = {}
        self.request_history = defaultdict(list)
        
    def record_request(self, provider_name, success, latency_ms):
        now = time.time()
        self.request_history[provider_name].append({
            'time': now,
            'success': success,
            'latency': latency_ms
        })
        
        # Tính health score thời gian thực
        recent = self.request_history[provider_name][-10:]
        success_rate = sum(1 for r in recent if r['success']) / len(recent)
        avg_latency = sum(r['latency'] for r in recent) / len(recent)
        
        # Health score: 0-100
        health_score = success_rate * 100 - (avg_latency / 10)
        self.provider_health[provider_name] = max(0, health_score)
        
    def get_best_provider(self):
        if not self.provider_health:
            return None
        
        # Chọn provider có health score cao nhất
        best = max(self.provider_health.items(), key=lambda x: x[1])
        
        # Chỉ chọn nếu health score > 50
        if best[1] < 50:
            return None  # Tất cả đều không tốt
        
        return best[0]


Integration

health_tracker = RealTimeHealthTracker()

async def smart_request(provider, messages):
    try:
        result = await call_api(provider, messages)
        health_tracker.record_request(provider.name, True, result['latency'])
        return result
    except Exception as e:
        health_tracker.record_request(provider.name, False, 0)
        raise

Monitoring và Alerting

# Prometheus metrics cho monitoring
from prometheus_client import Counter, Histogram, Gauge


Metrics

request_total = Counter('ai_request_total', 'Total AI requests', ['provider', 'status'])
request_latency = Histogram('ai_request_latency_seconds', 'Request latency', ['provider'])
provider_health = Gauge('ai_provider_health_score', 'Provider health score', ['provider'])
cost_savings = Gauge('ai_cost_savings_percent', 'Cost savings vs official API')


Middleware logging

async def log_request(provider_name, status, latency_ms, tokens, model):
    request_total.labels(provider=provider_name, status=status).inc()
    request_latency.labels(provider=provider_name).observe(latency_ms / 1000)
    
    # Tính savings nếu dùng HolySheep
    if provider_name == 'HolySheep':
        official_cost = get_official_price(model)
        our_cost = get_holysheep_price(model)
        savings = ((official_cost - our_cost) / official_cost * 100)
        cost_savings.set(savings)
        
        print(f"💰 Savings for {model}: {savings:.1f}%")
        

Alerting rules

ALERT_RULES = """
groups:
- name: ai-api-alerts
  rules:
  - alert: ProviderDown
    expr: ai_provider_health_score < 30
    for: 1m
    labels:
      severity: critical
    annotations:
      summary: "Provider {{ $labels.provider }} is down"
      
  - alert: HighLatency
    expr: ai_request_latency_seconds

Tài nguyên liên quan
Bài viết liên quan