Giới Thiệu Từ Kinh Nghiệm Thực Chiến
Trong 3 năm vận hành các hệ thống AI production phục vụ hơn 500K request/ngày, tôi đã đối mặt với vô số lỗi 504 Gateway Timeout từ các API relay. Điều đáng nói là 90% các trường hợp không phải do upstream server quá tải — mà do cấu hình proxy không phù hợp với workload thực tế.
Bài viết này tôi sẽ chia sẻ cách debug, fix triệt để, và tối ưu chi phí khi sử dụng
HolySheep AI relay — nền tảng với độ trễ trung bình dưới 50ms và chi phí thấp hơn 85% so với direct API.
504 Gateway Timeout Là Gì?
Cơ chế sinh ra lỗi
504 xảy ra khi gateway/proxy không nhận được response từ upstream trong timeout window. Với HolySheep relay, timeline như sau:
Client Request → HolySheep Gateway (Nginx/Envoy)
↓ (timeout default: 30s)
Upstream API (OpenAI/Anthropic)
↓ (response delayed > 30s)
504 Gateway Timeout
Phân biệt các lỗi tương tự
| Mã lỗi | Ý nghĩa | Nguyên nhân phổ biến |
|---|
| 504 | Gateway Timeout | Upstream chậm, không phản hồi |
| 502 | Bad Gateway | Upstream crash hoặc không accessible |
| 503 | Service Unavailable | Quá tải hoàn toàn |
| 408 | Request Timeout | Client gửi quá chậm |
Kiến Trúc HolySheep Relay
Data flow chi tiết
┌─────────────────────────────────────────────────────────────────┐
│ HOLYSHEEP RELAY ARCHITECTURE │
├─────────────────────────────────────────────────────────────────┤
│ │
│ Your Server │
│ │ │
│ ▼ │
│ ┌──────────────────┐ │
│ │ Nginx Layer │ ◄── Rate Limiting, SSL Termination │
│ │ (30s timeout) │ │
│ └────────┬─────────┘ │
│ │ │
│ ▼ │
│ ┌──────────────────┐ │
│ │ Connection Pool │ ◄── Keep-alive, HTTP/2 multiplexing │
│ │ (100 conns) │ │
│ └────────┬─────────┘ │
│ │ │
│ ▼ │
│ ┌──────────────────┐ │
│ │ Upstream Router │ ◄── Intelligent routing, failover │
│ │ │ │
│ └────────┬─────────┘ │
│ │ │
│ ┌─────┴─────┐ │
│ ▼ ▼ │
│ ┌──────┐ ┌──────┐ ┌──────┐ │
│ │OpenAI│ │Anthro│ │Azure │ ... │
│ │Proxy │ │Proxy │ │Proxy │ │
│ └──────┘ └──────┘ └──────┘ │
│ │
└─────────────────────────────────────────────────────────────────┘
Code Mẫu Production Với Error Handling
1. Python SDK Với Retry Logic
import requests
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry
import time
class HolySheepClient:
"""Production-ready client với exponential backoff"""
BASE_URL = "https://api.holysheep.ai/v1"
def __init__(self, api_key: str):
self.api_key = api_key
self.session = self._create_session()
def _create_session(self) -> requests.Session:
"""Tạo session với retry strategy tối ưu"""
session = requests.Session()
# Retry strategy: 3 retries với exponential backoff
retry_strategy = Retry(
total=3,
backoff_factor=1, # 1s, 2s, 4s
status_forcelist=[502, 503, 504],
allowed_methods=["GET", "POST"]
)
adapter = HTTPAdapter(
max_retries=retry_strategy,
pool_connections=10,
pool_maxsize=100
)
session.mount("https://", adapter)
session.headers.update({
"Authorization": f"Bearer {self.api_key}",
"Content-Type": "application/json"
})
return session
def chat_completions(self, messages: list, model: str = "gpt-4o",
timeout: int = 120) -> dict:
"""Gọi Chat Completions API với timeout linh hoạt"""
payload = {
"model": model,
"messages": messages,
"max_tokens": 4096,
"temperature": 0.7
}
try:
response = self.session.post(
f"{self.BASE_URL}/chat/completions",
json=payload,
timeout=timeout # Tăng timeout cho long task
)
response.raise_for_status()
return response.json()
except requests.exceptions.Timeout:
# 504 thường xảy ra ở đây
raise HolySheepTimeoutError(
f"Request timeout sau {timeout}s. "
"Thử tăng timeout hoặc giảm max_tokens."
)
except requests.exceptions.HTTPError as e:
if e.response.status_code == 504:
raise HolySheep504Error(
"Gateway Timeout: Upstream quá chậm. "
"Kiểm tra model status hoặc thử model khác."
)
raise
class HolySheepTimeoutError(Exception):
"""Custom exception cho timeout errors"""
pass
class HolySheep504Error(Exception):
"""Custom exception cho 504 errors"""
pass
Sử dụng
client = HolySheepClient("YOUR_HOLYSHEEP_API_KEY")
try:
result = client.chat_completions(
messages=[{"role": "user", "content": "Hello!"}],
model="gpt-4o",
timeout=90
)
print(result["choices"][0]["message"]["content"])
except HolySheep504Error as e:
print(f"Lỗi 504: {e}")
# Fallback sang model khác
2. Node.js Với Circuit Breaker Pattern
const axios = require('axios');
const CircuitBreaker = require('opossum');
class HolySheepNodeClient {
constructor(apiKey) {
this.baseURL = 'https://api.holysheep.ai/v1';
this.apiKey = apiKey;
// Circuit breaker options
const breakerOptions = {
timeout: 60000, // 60s timeout
errorThresholdPercentage: 50, // Mở circuit sau 50% errors
resetTimeout: 30000, // Thử lại sau 30s
volumeThreshold: 10 // Cần ít nhất 10 requests
};
this.breaker = new CircuitBreaker(
this.makeRequest.bind(this),
breakerOptions
);
// Fallback handler
this.breaker.fallback((params) => ({
error: true,
message: 'Fallback activated - service degraded',
fallback_response: 'Xin lỗi, hệ thống đang bận. Vui lòng thử lại sau.'
}));
// Event listeners
this.breaker.on('open', () => {
console.log('🔴 Circuit breaker OPENED - Too many failures');
});
this.breaker.on('close', () => {
console.log('🟢 Circuit breaker CLOSED - Service restored');
});
}
async makeRequest(payload, model = 'gpt-4o') {
const controller = new AbortController();
const timeoutId = setTimeout(() => controller.abort(), 90000);
try {
const response = await axios.post(
${this.baseURL}/chat/completions,
{
model,
messages: payload.messages,
max_tokens: payload.max_tokens || 4096,
temperature: payload.temperature || 0.7
},
{
headers: {
'Authorization': Bearer ${this.apiKey},
'Content-Type': 'application/json'
},
signal: controller.signal
}
);
return response.data;
} catch (error) {
if (error.code === 'ETIMEDOUT' || error.code === 'ECONNABORTED') {
const err = new Error('504 Gateway Timeout');
err.code = 504;
throw err;
}
throw error;
} finally {
clearTimeout(timeoutId);
}
}
async chat(messages, options = {}) {
const payload = { messages, ...options };
try {
const result = await this.breaker.fire(payload, options.model);
if (result.error) {
return { content: result.fallback_response, degraded: true };
}
return {
content: result.choices[0].message.content,
usage: result.usage,
degraded: false
};
} catch (error) {
console.error('Circuit breaker error:', error.message);
throw error;
}
}
// Multi-model fallback strategy
async chatWithFallback(messages) {
const models = ['gpt-4o', 'claude-sonnet-4.5', 'gemini-2.5-flash'];
for (const model of models) {
try {
console.log(Trying model: ${model});
return await this.chat(messages, { model });
} catch (error) {
console.error(${model} failed:, error.message);
continue;
}
}
throw new Error('All models failed');
}
}
// Sử dụng
const client = new HolySheepNodeClient('YOUR_HOLYSHEEP_API_KEY');
// Request đơn lẻ
client.chat([
{ role: 'user', content: 'Phân tích code này giúp tôi' }
]).then(result => {
console.log(result.content);
}).catch(err => {
console.error('Error:', err.message);
});
// Request với fallback tự động
client.chatWithFallback([
{ role: 'user', content: 'Viết hàm sort' }
]).then(result => {
console.log('Success:', result.content.substring(0, 100));
}).catch(err => {
console.error('All failed:', err.message);
});
3. Go Client Với Context Timeout
package holysheep
import (
"context"
"encoding/json"
"fmt"
"net/http"
"time"
)
// HolySheepClient - Go client cho HolySheep API
type HolySheepClient struct {
BaseURL string
APIKey string
HTTPClient *http.Client
}
// Configurable timeout
type RequestConfig struct {
Timeout time.Duration
MaxTokens int
Temperature float64
Model string
}
var DefaultConfig = RequestConfig{
Timeout: 60 * time.Second,
MaxTokens: 4096,
Temperature: 0.7,
Model: "gpt-4o",
}
// NewClient khởi tạo client
func NewClient(apiKey string) *HolySheepClient {
return &HolySheepClient{
BaseURL: "https://api.holysheep.ai/v1",
APIKey: apiKey,
HTTPClient: &http.Client{
Timeout: 120 * time.Second, // Global timeout
Transport: &http.Transport{
MaxIdleConns: 100,
MaxIdleConnsPerHost: 10,
IdleConnTimeout: 90 * time.Second,
},
},
}
}
// ChatRequest / ChatResponse structs
type ChatMessage struct {
Role string json:"role"
Content string json:"content"
}
type ChatRequest struct {
Model string json:"model"
Messages []ChatMessage json:"messages"
MaxTokens int json:"max_tokens"
Temperature float64 json:"temperature"
}
type ChatResponse struct {
ID string json:"id"
Choices []Choice json:"choices"
Usage Usage json:"usage"
}
type Choice struct {
Message ChatMessage json:"message"
}
type Usage struct {
PromptTokens int json:"prompt_tokens"
CompletionTokens int json:"completion_tokens"
TotalTokens int json:"total_tokens"
}
// Chat - Gọi API với context cho timeout control
func (c *HolySheepClient) Chat(ctx context.Context, messages []ChatMessage,
cfg *RequestConfig) (*ChatResponse, error) {
if cfg == nil {
cfg = &DefaultConfig
}
// Tạo context với timeout cụ thể cho request này
requestCtx, cancel := context.WithTimeout(ctx, cfg.Timeout)
defer cancel()
reqBody := ChatRequest{
Model: cfg.Model,
Messages: messages,
MaxTokens: cfg.MaxTokens,
Temperature: cfg.Temperature,
}
jsonData, err := json.Marshal(reqBody)
if err != nil {
return nil, fmt.Errorf("JSON marshal error: %w", err)
}
req, err := http.NewRequestWithContext(requestCtx, "POST",
c.BaseURL+"/chat/completions",
bytes.NewBuffer(jsonData))
if err != nil {
return nil, fmt.Errorf("request creation error: %w", err)
}
req.Header.Set("Authorization", "Bearer "+c.APIKey)
req.Header.Set("Content-Type", "application/json")
// Execute request
resp, err := c.HTTPClient.Do(req)
if err != nil {
if requestCtx.Err() == context.DeadlineExceeded {
return nil, fmt.Errorf("504 Gateway Timeout: request exceeded %v", cfg.Timeout)
}
return nil, fmt.Errorf("request failed: %w", err)
}
defer resp.Body.Close()
if resp.StatusCode == http.StatusGatewayTimeout {
return nil, fmt.Errorf("504 Gateway Timeout from upstream")
}
if resp.StatusCode != http.StatusOK {
return nil, fmt.Errorf("HTTP %d: %s", resp.StatusCode, resp.Status)
}
var result ChatResponse
if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
return nil, fmt.Errorf("response decode error: %w", err)
}
return &result, nil
}
// RetryChat - Chat với automatic retry
func (c *HolySheepClient) RetryChat(ctx context.Context, messages []ChatMessage,
cfg *RequestConfig, maxRetries int) (*ChatResponse, error) {
var lastErr error
for i := 0; i < maxRetries; i++ {
resp, err := c.Chat(ctx, messages, cfg)
if err == nil {
return resp, nil
}
lastErr = err
// Chỉ retry 504 và transient errors
if !isRetryable(err) {
return nil, err
}
// Exponential backoff
backoff := time.Duration(1< 30*time.Second {
backoff = 30 * time.Second
}
fmt.Printf("Retry %d/%d sau %v: %v\n", i+1, maxRetries, backoff, err)
select {
case <-ctx.Done():
return nil, ctx.Err()
case <-time.After(backoff):
}
}
return nil, fmt.Errorf("max retries exceeded: %w", lastErr)
}
func isRetryable(err error) bool {
errStr := err.Error()
return contains(errStr, "504") ||
contains(errStr, "timeout") ||
contains(errStr, "connection")
}
func contains(s, substr string) bool {
return len(s) >= len(substr) && (s == substr ||
len(s) > 0 && containsHelper(s, substr))
}
func containsHelper(s, substr string) bool {
for i := 0; i <= len(s)-len(substr); i++ {
if s[i:i+len(substr)] == substr {
return true
}
}
return false
}
// Ví dụ sử dụng
func Example() {
client := NewClient("YOUR_HOLYSHEEP_API_KEY")
ctx := context.Background()
messages := []ChatMessage{
{Role: "user", Content: "Xin chào"},
}
cfg := &RequestConfig{
Timeout: 90 * time.Second,
MaxTokens: 2048,
Temperature: 0.7,
Model: "gpt-4o",
}
resp, err := client.RetryChat(ctx, messages, cfg, 3)
if err != nil {
fmt.Printf("Error: %v\n", err)
return
}
fmt.Printf("Response: %s\n", resp.Choices[0].Message.Content)
fmt.Printf("Tokens used: %d\n", resp.Usage.TotalTokens)
}
Benchmark Hiệu Suất Thực Tế
Đo lường với wrk
# Benchmark script cho HolySheep relay
Chạy: ./benchmark.sh
#!/bin/bash
API_KEY="YOUR_HOLYSHEEP_API_KEY"
BASE_URL="https://api.holysheep.ai/v1"
echo "=============================================="
echo "HolySheep Relay Benchmark - $(date)"
echo "=============================================="
Test 1: Concurrent requests (100 connections)
echo ""
echo "Test 1: 100 concurrent connections, 30s duration"
wrk -t10 -c100 -d30s \
-H "Authorization: Bearer $API_KEY" \
-H "Content-Type: application/json" \
-s post_body.lua \
"$BASE_URL/chat/completions" 2>/dev/null | grep -E "(Requests|Latency|Req/Sec)"
Test 2: Long streaming requests
echo ""
echo "Test 2: Streaming requests với 50 concurrent"
wrk -t5 -c50 -d20s \
-H "Authorization: Bearer $API_KEY" \
-H "Content-Type: application/json" \
--latency \
"$BASE_URL/chat/completions" 2>/dev/null
Test 3: Timeout scenarios
echo ""
echo "Test 3: Testing timeout behavior"
for i in {1..5}; do
START=$(date +%s%N)
curl -s -X POST "$BASE_URL/chat/completions" \
-H "Authorization: Bearer $API_KEY" \
-H "Content-Type: application/json" \
-d '{"model":"gpt-4o","messages":[{"role":"user","content":"Count to 100"}],"max_tokens":100}' \
-m 30 \
-w "\nHTTP: %{http_code}, Time: %{time_total}s\n" \
-o /dev/null
done
echo ""
echo "Benchmark hoàn tất!"
Kết quả benchmark mong đợi
| Metric | Giá trị | So sánh Direct API |
|---|
| Latency P50 | ~45ms | Tương đương |
| Latency P99 | ~180ms | Thấp hơn 20% |
| Throughput | ~850 req/s | Cao hơn 30% |
| Error rate | <0.1% | Ổn định hơn |
| 504 occurrences | <0.05% | Ít hơn 80% |
Lỗi Thường Gặp Và Cách Khắc Phục
1. Lỗi 504 Timeout Khi Streaming
Nguyên nhân: Stream response bị interrupt do network hiccup hoặc proxy timeout quá ngắn.
# Giải pháp: Sử dụng chunked transfer và retry logic
import requests
import json
def stream_chat_with_retry(api_key, messages, model="gpt-4o"):
"""Streaming với automatic retry cho chunk failures"""
url = "https://api.holysheep.ai/v1/chat/completions"
headers = {
"Authorization": f"Bearer {api_key}",
"Content-Type": "application/json"
}
payload = {
"model": model,
"messages": messages,
"max_tokens": 4096,
"stream": True
}
max_retries = 3
for attempt in range(max_retries):
try:
response = requests.post(
url,
headers=headers,
json=payload,
stream=True,
timeout=(10, 120)) # (connect, read) timeout
response.raise_for_status()
full_content = ""
for line in response.iter_lines():
if line:
line = line.decode('utf-8')
if line.startswith('data: '):
data = line[6:]
if data == '[DONE]':
break
chunk = json.loads(data)
if 'choices' in chunk and len(chunk['choices']) > 0:
delta = chunk['choices'][0].get('delta', {})
if 'content' in delta:
full_content += delta['content']
yield delta['content'] # Stream từng phần
return full_content
except requests.exceptions.Timeout:
print(f"Timeout attempt {attempt + 1}/{max_retries}")
if attempt < max_retries - 1:
import time
time.sleep(2 ** attempt) # Exponential backoff
continue
raise
except requests.exceptions.HTTPError as e:
if e.response.status_code == 504:
print(f"504 Error - Retry {attempt + 1}/{max_retries}")
continue
raise
Sử dụng
for chunk in stream_chat_with_retry("YOUR_HOLYSHEEP_API_KEY",
[{"role": "user", "content": "Viết code"}]):
print(chunk, end='', flush=True)
2. Lỗi 502/504 Với Batch Processing
Nguyên nhân: Batch quá lớn, upstream timeout trước khi xử lý xong.
# Giải pháp: Chunk batch và xử lý song song có giới hạn
import asyncio
import aiohttp
from typing import List, Dict
class BatchProcessor:
"""Xử lý batch lớn với concurrency limit"""
def __init__(self, api_key: str, max_concurrent: int = 5):
self.api_key = api_key
self.base_url = "https://api.holysheep.ai/v1"
self.max_concurrent = max_concurrent
self.semaphore = asyncio.Semaphore(max_concurrent)
async def process_single(self, session: aiohttp.ClientSession,
prompt: str) -> str:
"""Xử lý một prompt đơn lẻ"""
async with self.semaphore: # Giới hạn concurrent
payload = {
"model": "gpt-4o",
"messages": [{"role": "user", "content": prompt}],
"max_tokens": 2048
}
try:
async with session.post(
f"{self.base_url}/chat/completions",
json=payload,
headers={"Authorization": f"Bearer {self.api_key}"},
timeout=aiohttp.ClientTimeout(total=60)
) as resp:
if resp.status == 504:
# Retry với exponential backoff
for attempt in range(3):
await asyncio.sleep(2 ** attempt)
async with session.post(
f"{self.base_url}/chat/completions",
json=payload,
headers={"Authorization": f"Bearer {self.api_key}"},
timeout=aiohttp.ClientTimeout(total=90)
) as retry_resp:
if retry_resp.status == 200:
data = await retry_resp.json()
return data['choices'][0]['message']['content']
raise Exception("504 retry failed")
data = await resp.json()
return data['choices'][0]['message']['content']
except asyncio.TimeoutError:
return f"[TIMEOUT] {prompt[:50]}..."
async def process_batch(self, prompts: List[str]) -> List[str]:
"""Xử lý batch với controlled concurrency"""
timeout = aiohttp.ClientTimeout(total=120)
async with aiohttp.ClientSession(timeout=timeout) as session:
tasks = [self.process_single(session, p) for p in prompts]
results = await asyncio.gather(*tasks, return_exceptions=True)
# Handle exceptions
return [
str(r) if isinstance(r, Exception) else r
for r in results
]
Sử dụng
async def main():
processor = BatchProcessor("YOUR_HOLYSHEEP_API_KEY", max_concurrent=5)
prompts = [
f"Task {i}: Phân tích dữ liệu #{i}"
for i in range(100)
]
results = await processor.process_batch(prompts)
print(f"Hoàn thành: {len([r for r in results if not r.startswith('[TIMEOUT]')])}/100")
print(f"Timeout: {len([r for r in results if r.startswith('[TIMEOUT]')])}")
asyncio.run(main())
3. Connection Pool Exhaustion
Nguyên nhân: Tạo quá nhiều connections không được reuse, dẫn đến resource exhaustion.
# Giải pháp: Connection pooling với proper lifecycle management
import requests
from contextlib import contextmanager
class ConnectionPoolManager:
"""Quản lý connection pool hiệu quả"""
_session = None
_lock = __import__('threading').Lock()
@classmethod
def get_session(cls) -> requests.Session:
"""Get singleton session với optimized pool settings"""
if cls._session is None:
with cls._lock:
if cls._session is None:
session = requests.Session()
# Connection pool settings
adapter = requests.adapters.HTTPAdapter(
pool_connections=20, # Số lượng connection pools
pool_maxsize=100, # Connections per pool
max_retries=3,
pool_block=False
)
session.mount('https://', adapter)
session.headers.update({
'User-Agent': 'HolySheep-Client/1.0',
'Connection': 'keep-alive'
})
cls._session = session
return cls._session
@classmethod
@contextmanager
def session_scope(cls):
"""Context manager cho session access an toàn"""
session = cls.get_session()
try:
yield session
finally:
# Không đóng session ở đây - reuse!
pass
@classmethod
def close_all(cls):
"""Đóng tất cả connections khi shutdown app"""
if cls._session:
cls._session.close()
cls._session = None
Decorator cho automatic session handling
from functools import wraps
def with_session(func):
@wraps(func)
def wrapper(*args, **kwargs):
with ConnectionPoolManager.session_scope() as session:
kwargs['session'] = session
return func(*args, **kwargs)
return wrapper
Sử dụng
@with_session
def call_api(prompt: str, session=None) -> str:
"""Function sử dụng shared session"""
response = session.post(
"https://api.holysheep.ai/v1/chat/completions",
json={
"model": "gpt-4o",
"messages": [{"role": "user", "content": prompt}]
},
headers={"Authorization": "Bearer YOUR_HOLYSHEEP_API_KEY"},
timeout=60
)
return response.json()['choices'][0]['message']['content']
Shutdown handler (gọi khi app terminate)
import atexit
atexit.register(ConnectionPoolManager.close_all)
Giá Và ROI
| Model | HolySheep ($/MTok) | Direct API ($/MTok) | Tiết kiệm |
|---|
| GPT-4.1 | $8.00 | $60.00 | 87% |
| Claude Sonnet 4.5 | $15.00 | $90.00 | 83% |
| Gemini 2.5 Flash | $2.50 | $17.50 | 86% |
| DeepSeek V3.2 | $0.42 | $2.80 | 85% |
Tính toán ROI thực tế
# Script tính ROI khi migrate sang HolySheep
def calculate_roi(monthly_tokens_m: float, model: str):
"""Tính ROI khi sử dụng HolySheep thay vì Direct API"""
pricing = {
"gpt-4o": {"direct": 15.00, "holy": 8.00},
"claude-sonnet-4.5": {"direct": 15.00, "holy": 15.00},
"gemini-2.5-flash": {"direct": 17.50, "holy": 2.50},
"deepseek-v3": {"direct": 2.80, "holy": 0.42}
}
if model not in pricing:
return None
direct_cost = monthly_tokens_m * pricing[model]["direct"]
holy_cost = monthly_tokens_m * pricing[model]["holy"]
annual_savings = (direct_cost - holy_cost) * 12
return {
"monthly_tokens_m": monthly_tokens_m,
"model": model,
"direct_monthly": f"${direct_cost:.2f}",
"holy_monthly": f"${holy_cost:.2f}",
"monthly_savings": f"${direct_cost - holy_cost:.2f}",
"annual_savings": f"${annual_savings:.2f}",
"roi_percentage": f"{((direct_cost - holy_cost) / holy_cost) * 100:.0f}%"
}
Ví dụ: 10 triệu tokens/tháng với GPT-4o
result = calculate_roi(10, "gpt-4o")
print(f"""
========================================
ROI ANALYSIS - HolySheep
========================================
Model: {result['model']}
Monthly tokens: {result['monthly_tokens_m']}M
Chi phí Direct API: {result['direct_monthly']}/tháng
Chi phí HolySheep: {result['holy_monthly']}/tháng
Tiết kiệm hàng tháng: {result['monthly_savings']}
Tiết kiệm hàng năm: {result['annual_savings']}
ROI: {result['roi_percentage']}
========================================
""")
Phù Hợp / Không Phù Hợp Với Ai
Nên dùng HolySheep khi:
- Startup và indie developers — Ngân sách hạn chế, cần tối ưu chi phí AI
- High-volume applications — Xử lý hàng triệu requests/tháng
- Production systems — Cần SLA và uptime đáng tin cậ
Tài nguyên liên quan
Bài viết liên quan