Khi triển khai AI API vào môi trường production, câu lệnh ConnectionError: timeout after 30s xuất hiện lúc 3 giờ sáng là cơn ác mộng của mọi developer. Bài viết này chia sẻ chiến lược vận hành AI API thực chiến, giúp bạn xây dựng hệ thống ổn định từ prototype đến production với chi phí tối ưu.
Kịch bản lỗi thực tế: Khi 10,000 request đồng thời đánh sập hệ thống
Tháng 11/2025, một startup AI tại Việt Nam gặp sự cố nghiêm trọng khi triển khai chatbot hỗ trợ khách hàng. Sau 2 tuần chạy thử nghiệm với 500 người dùng, họ mở rộng lên 10,000 người dùng đồng thời và hệ thống sụp đổ hoàn toàn.
# Log lỗi từ hệ thống cũ
ERROR - ConnectionError: HTTPSConnectionPool(host='api.openai.com', port=443):
Max retries exceeded with url: /v1/chat/completions
ERROR - 401 Unauthorized: Incorrect API key provided
ERROR - RateLimitError: Too many requests in 1 minute
Thời gian phục hồi: 4 giờ
Chi phí thiệt hại: ~$2,300 do downtime và rate limit
Ảnh hưởng: 8,500 người dùng không thể truy cập
Sau khi chuyển sang HolyShehe AI với latency trung bình dưới 50ms và chi phí chỉ từ $0.42/MTok với DeepSeek V3.2, họ giảm 85% chi phí vận hành và đạt uptime 99.97%.
1. Retry Strategy với Exponential Backoff
Kịch bản lỗi mạng và rate limit là phổ biến. Exponential backoff giúp hệ thống tự phục hồi mà không gây overload.
import requests
import time
import logging
from typing import Optional, Dict, Any
class HolySheepAIClient:
"""Client với retry strategy thông minh cho HolySheep AI API"""
def __init__(
self,
api_key: str,
base_url: str = "https://api.holysheep.ai/v1",
max_retries: int = 3,
timeout: int = 60
):
self.api_key = api_key
self.base_url = base_url
self.max_retries = max_retries
self.timeout = timeout
self.session = requests.Session()
self.session.headers.update({
"Authorization": f"Bearer {api_key}",
"Content-Type": "application/json"
})
self.logger = logging.getLogger(__name__)
def _calculate_backoff(self, attempt: int, base_delay: float = 1.0) -> float:
"""Tính toán delay với exponential backoff + jitter"""
delay = base_delay * (2 ** attempt)
jitter = delay * 0.1 * (hash(str(time.time())) % 10) / 10
return min(delay + jitter, 32.0) # Cap tại 32 giây
def chat_completions(
self,
model: str,
messages: list,
temperature: float = 0.7,
max_tokens: int = 1000
) -> Dict[str, Any]:
"""
Gọi API với retry strategy
Model pricing (2026):
- gpt-4.1: $8.00/MTok (đầu vào), $24.00/MTok (đầu ra)
- claude-sonnet-4.5: $15.00/MTok (đầu vào), $75.00/MTok (đầu ra)
- gemini-2.5-flash: $2.50/MTok (đầu vào), $10.00/MTok (đầu ra)
- deepseek-v3.2: $0.42/MTok (đầu vào), $1.68/MTok (đầu ra)
"""
endpoint = f"{self.base_url}/chat/completions"
payload = {
"model": model,
"messages": messages,
"temperature": temperature,
"max_tokens": max_tokens
}
last_error = None
for attempt in range(self.max_retries + 1):
try:
response = self.session.post(
endpoint,
json=payload,
timeout=self.timeout
)
if response.status_code == 200:
return response.json()
elif response.status_code == 429:
# Rate limit - retry với backoff
retry_after = int(response.headers.get("Retry-After", 60))
wait_time = retry_after if retry_after > 0 else self._calculate_backoff(attempt)
self.logger.warning(f"Rate limit hit. Waiting {wait_time}s before retry...")
time.sleep(wait_time)
elif response.status_code == 401:
raise ValueError("API key không hợp lệ. Kiểm tra YOUR_HOLYSHEEP_API_KEY")
elif response.status_code >= 500:
# Server error - retry
wait_time = self._calculate_backoff(attempt)
self.logger.warning(f"Server error {response.status_code}. Retry {attempt + 1}/{self.max_retries} sau {wait_time}s")
time.sleep(wait_time)
else:
error_detail = response.json() if response.content else {}
raise ValueError(f"API error: {response.status_code} - {error_detail}")
except requests.exceptions.Timeout:
wait_time = self._calculate_backoff(attempt)
self.logger.warning(f"Timeout. Retry {attempt + 1}/{self.max_retries} sau {wait_time}s")
time.sleep(wait_time)
except requests.exceptions.ConnectionError as e:
wait_time = self._calculate_backoff(attempt)
self.logger.warning(f"Connection error: {e}. Retry sau {wait_time}s")
time.sleep(wait_time)
last_error = e
except Exception as e:
self.logger.error(f"Lỗi không xác định: {e}")
raise
raise ConnectionError(f"Thất bại sau {self.max_retries + 1} lần thử: {last_error}")
Sử dụng
client = HolySheepAIClient(
api_key="YOUR_HOLYSHEEP_API_KEY",
max_retries=3,
timeout=60
)
response = client.chat_completions(
model="deepseek-v3.2", # $0.42/MTok - tiết kiệm 85% so với GPT-4
messages=[{"role": "user", "content": "Phân tích xu hướng AI 2026"}]
)
print(f"Response time: {response.get('usage', {}).get('total_tokens', 0)} tokens")2. Circuit Breaker Pattern - Ngăn chặn Cascade Failure
Khi API provider gặp sự cố, request liên tục gửi đến sẽ gây timeout và làm hệ thống của bạn cũng sập theo. Circuit breaker giúp "ngắt mạch" khi tỷ lệ lỗi vượt ngưỡng.
import time
from enum import Enum
from threading import Lock
from dataclasses import dataclass, field
from typing import Callable, Any
class CircuitState(Enum):
CLOSED = "closed" # Bình thường
OPEN = "open" # Ngắt mạch
HALF_OPEN = "half_open" # Thử phục hồi
@dataclass
class CircuitBreaker:
"""Circuit breaker cho AI API calls"""
failure_threshold: int = 5 # Số lỗi để mở circuit
success_threshold: int = 3 # Số thành công để đóng circuit
timeout: float = 30.0 # Thời gian chờ trước khi thử lại (giây)
half_open_max_calls: int = 3 # Số call trong trạng thái half-open
state: CircuitState = field(default=CircuitState.CLOSED, init=False)
failure_count: int = field(default=0, init=False)
success_count: int = field(default=0, init=False)
last_failure_time: float = field(default=0.0, init=False)
half_open_calls: int = field(default=0, init=False)
lock: Lock = field(default_factory=Lock, init=False)
def call(self, func: Callable, *args, **kwargs) -> Any:
"""Execute function với circuit breaker protection"""
with self.lock:
if self.state == CircuitState.OPEN:
if time.time() - self.last_failure_time >= self.timeout:
self._transition_to_half_open()
else:
raise CircuitBreakerOpenError(
f"Circuit breaker OPEN. Retry sau {self.timeout}s"
)
if self.state == CircuitState.HALF_OPEN:
if self.half_open_calls >= self.half_open_max_calls:
raise CircuitBreakerOpenError(
"Circuit breaker: Đã đạt max calls trong half-open state"
)
self.half_open_calls += 1
try:
result = func(*args, **kwargs)
self._on_success()
return result
except Exception as e:
self._on_failure()
raise
def _on_success(self):
with self.lock:
if self.state == CircuitState.HALF_OPEN:
self.success_count += 1
if self.success_count >= self.success_threshold:
self._transition_to_closed()
else:
self.failure_count = 0
def _on_failure(self):
with self.lock:
self.failure_count += 1
self.last_failure_time = time.time()
if self.state == CircuitState.HALF_OPEN:
self._transition_to_open()
elif self.failure_count >= self.failure_threshold:
self._transition_to_open()
def _transition_to_open(self):
print(f"⚠️ Circuit breaker chuyển sang OPEN sau {self.failure_count} lỗi")
self.state = CircuitState.OPEN
self.half_open_calls = 0
def _transition_to_half_open(self):
print(f"🔄 Circuit breaker chuyển sang HALF_OPEN - thử phục hồi")
self.state = CircuitState.HALF_OPEN
self.success_count = 0
self.half_open_calls = 0
def _transition_to_closed(self):
print(f"✅ Circuit breaker chuyển sang CLOSED - phục hồi thành công")
self.state = CircuitState.CLOSED
self.failure_count = 0
self.success_count = 0
class CircuitBreakerOpenError(Exception):
pass
Sử dụng với HolySheep client
cb = CircuitBreaker(
failure_threshold=5,
success_threshold=2,
timeout=30.0
)
try:
result = cb.call(client.chat_completions, model="gemini-2.5-flash", messages=[...])
except CircuitBreakerOpenError as e:
print(f"⚠️ {e}")
# Fallback sang cached response hoặc alternative model
result = get_cached_response() if use_cache else fallback_to_rule_based()
Monitoring circuit breaker state
print(f"Circuit state: {cb.state.value}") # closed/open/half_open3. Rate Limiter và Cost Control
Với chi phí chỉ từ $0.42/MTok (DeepSeek V3.2), việc kiểm soát rate limit và chi phí giúp tối ưu ngân sách đáng kể.
import time
from collections import defaultdict
from threading import Lock
from dataclasses import dataclass
from typing import Dict, Optional
@dataclass
class CostTracker:
"""Theo dõi chi phí theo thời gian thực"""
# Pricing từ HolySheep AI (2026)
MODEL_PRICING = {
"gpt-4.1": {"input": 8.00, "output": 24.00},
"claude-sonnet-4.5": {"input": 15.00, "output": 75.00},
"gemini-2.5-flash": {"input": 2.50, "output": 10.00},
"deepseek-v3.2": {"input": 0.42, "output": 1.68}
}
daily_limit_usd: float = 100.0 # Giới hạn $100/ngày
def __post_init__(self):
self.daily_spent: Dict[str, float] = defaultdict(float)
self.daily_start: float = time.time()
self.lock = Lock()
def calculate_cost(self, model: str, usage: dict) -> float:
"""Tính chi phí theo token usage (USD/MTok)"""
pricing = self.MODEL_PRICING.get(model, {"input": 0, "output": 0})
input_cost = (usage.get("prompt_tokens", 0) / 1_000_000) * pricing["input"]
output_cost = (usage.get("completion_tokens", 0) / 1_000_000) * pricing["output"]
return input_cost + output_cost
def track_and_check(
self,
model: str,
usage: dict,
include_cost_in_response: bool = True
) -> Optional[dict]:
"""Track chi phí và kiểm tra limit"""
cost = self.calculate_cost(model, usage)
# Reset daily counter nếu qua ngày mới
if time.time() - self.daily_start > 86400:
self.daily_spent.clear()
self.daily_start = time.time()
with self.lock:
self.daily_spent[model] += cost
total_today = sum(self.daily_spent.values())
response = {
"cost_usd": round(cost, 4), # Chính xác đến 0.0001
"daily_spent_usd": round(total_today, 4),
"daily_limit_usd": self.daily_limit_usd,
"remaining_usd": round(self.daily_limit_usd - total_today, 4),
"can_proceed": total_today < self.daily_limit_usd
}
if total_today >= self.daily_limit_usd:
print(f"⚠️ Vượt giới hạn! Đã chi ${total_today:.2f}/${self.daily_limit_usd}")
return None
return response
Usage tracking
tracker = CostTracker(daily_limit_usd=100.0)
Ví dụ: Gọi DeepSeek V3.2 - chỉ $0.42/MTok
usage_example = {
"prompt_tokens": 5000,
"completion_tokens": 2000
}
cost_info = tracker.track_and_check("deepseek-v3.2", usage_example)
if cost_info:
print(f"Chi phí: ${cost_info['cost_usd']}")
print(f"Hôm nay đã chi: ${cost_info['daily_spent_usd']}")
print(f"Còn lại: ${cost_info['remaining_usd']}")
else:
print("❌ Vượt giới hạn ngân sách - sử dụng cached response")
So sánh chi phí giữa các model cho cùng 1 task
print("\n=== So sánh chi phí ===")
for model in ["deepseek-v3.2", "gemini-2.5-flash", "gpt-4.1"]:
cost = tracker.calculate_cost(model, usage_example)
print(f"{model}: ${cost:.4f}")4. Monitoring và Alerting
Để đạt uptime 99.97% như HolySheep AI, cần monitoring toàn diện với metrics thực tế.
import time
from dataclasses import dataclass, field
from typing import List, Dict
from collections import deque
import statistics
@dataclass
class APIMetrics:
"""Metrics collector cho AI API monitoring"""
# Lưu trữ 1000 request gần nhất
window_size: int = 1000
latency_history: deque = field(default_factory=lambda: deque(maxlen=1000))
error_history: deque = field(default_factory=lambda: deque(maxlen=100))
request_count: int = 0
error_count: int = 0
total_tokens: int = 0
start_time: float = field(default_factory=time.time)
def record_request(
self,
latency_ms: float,
success: bool,
tokens: int = 0,
model: str = "",
error_type: str = ""
):
"""Ghi nhận metrics cho mỗi request"""
self.request_count += 1
self.latency_history.append(latency_ms)
if success:
self.total_tokens += tokens
else:
self.error_count += 1
self.error_history.append({
"time": time.time(),
"type": error_type,
"model": model,
"latency_ms": latency_ms
})
def get_stats(self) -> Dict:
"""Lấy statistics hiện tại"""
latencies = list(self.latency_history)
stats = {
"uptime_seconds": int(time.time() - self.start_time),
"total_requests": self.request_count,
"success_rate": round(
(self.request_count - self.error_count) / max(self.request_count, 1) * 100, 2
),
"avg_latency_ms": round(statistics.mean(latencies), 2) if latencies else 0,
"p50_latency_ms": round(statistics.median(latencies), 2) if latencies else 0,
"p95_latency_ms": round(
statistics.quantiles(latencies, n=20)[18], 2
) if len(latencies) >= 20 else 0,
"p99_latency_ms": round(
statistics.quantiles(latencies, n=100)[98], 2
) if len(latencies) >= 100 else 0,
"total_tokens": self.total_tokens,
"error_count": self.error_count,
"requests_per_minute": round(
self.request_count / max((time.time() - self.start_time) / 60, 1), 2
)
}
return stats
def get_error_rate(self) -> float:
"""Tính error rate %"""
if self.request_count == 0:
return 0.0
return round(self.error_count / self.request_count * 100, 3)
def is_healthy(self, max_error_rate: float = 1.0) -> bool:
"""Kiểm tra health status"""
return self.get_error_rate() <= max_error_rate
Sử dụng metrics collector
metrics = APIMetrics()
Giả lập monitoring
metrics.record_request(latency_ms=45.2, success=True, tokens=150, model="deepseek-v3.2")
metrics.record_request(latency_ms=120.5, success=False, error_type="Timeout", model="gpt-4.1")
metrics.record_request(latency_ms=38.7, success=True, tokens=200, model="deepseek-v3.2")
stats = metrics.get_stats()
print(f"=== API Health Dashboard ===")
print(f"Uptime: {stats['uptime_seconds']}s")
print(f"Tổng requests: {stats['total_requests']}")
print(f"Success rate: {stats['success_rate']}%")
print(f"Latency trung bình: {stats['avg_latency_ms']}ms")
print(f"P99 latency: {stats['p99_latency_ms']}ms")
print(f"Tổng tokens: {stats['total_tokens']:,}")
print(f"Requests/phút: {stats['requests_per_minute']}")
print(f"Health check: {'✅ OK' if metrics.is_healthy() else '❌ CRITICAL'}")
Alerting khi error rate > 5%
if metrics.get_error_rate() > 5.0:
print("🚨 ALERT: Error rate vượt ngưỡng 5%!")Lỗi thường gặp và cách khắc phục
1. Lỗi 401 Unauthorized - API Key không hợp lệ
Mô tả: Request bị từ chối với lỗi xác thực.
# ❌ Sai - dùng API key sai định dạng
headers = {
"Authorization": "Bearer YOUR_HOLYSHEEP_API_KEY" # Key chưa được set
}
✅ Đúng - kiểm tra và validate key
import os
def get_api_key() -> str:
api_key = os.environ.get("HOLYSHEEP_API_KEY")
if not api_key:
raise ValueError(
"HOLYSHEEP_API_KEY chưa được set. "
"Đăng ký tại: https://www.holysheep.ai/register"
)
if not api_key.startswith("sk-"):
raise ValueError("API key không đúng định dạng. HolySheep key bắt đầu bằng 'sk-'")
return api_key
Verify key bằng cách gọi models endpoint
def verify_api_key(api_key: str) -> bool:
import requests
try:
response = requests.get(
"https://api.holysheep.ai/v1/models",
headers={"Authorization": f"Bearer {api_key}"},
timeout=10
)
return response.status_code == 200
except:
return False
api_key = get_api_key()
if not verify_api_key(api_key):
raise ValueError("API key không hợp lệ hoặc đã hết hạn")2. Lỗi ConnectionError - Timeout khi kết nối
Mô tả: Request timeout sau 30 giây mà không nhận được response.
# ❌ Cấu hình timeout quá ngắn
response = requests.post(url, json=payload, timeout=5) # 5s quá ngắn cho AI API
✅ Cấu hình timeout phù hợp với retry logic
import requests
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry
def create_session_with_retry(retries: int = 3, backoff_factor: float = 1.0):
session = requests.Session()
retry_strategy = Retry(
total=retries,
backoff_factor=backoff_factor,
status_forcelist=[429, 500, 502, 503, 504],
allowed_methods=["HEAD", "GET", "OPTIONS", "POST"]
)
adapter = HTTPAdapter(max_retries=retry_strategy)
session.mount("https://", adapter)
session.mount("http://", adapter)
return session
Sử dụng với timeout riêng cho connect và read
session = create_session_with_retry()
try:
response = session.post(
"https://api.holysheep.ai/v1/chat/completions",
json=payload,
timeout=(10, 60) # 10s connect timeout, 60s read timeout
)
except requests.exceptions.Timeout:
# Fallback sang cached response
cached = get_fallback_response(prompt)
print(f"Using cached response (latency: {cache_age}s old)")
except requests.exceptions.ConnectionError:
# Retry với exponential backoff
for attempt in range(3):
time.sleep(2 ** attempt)
try:
response = session.post(url, json=payload, timeout=60)
break
except:
continue
else:
raise ConnectionError("Không thể kết nối sau 3 lần thử")3. Lỗi 429 Rate Limit Exceeded
Môi trường: Khi số request vượt quota cho phép.
# ❌ Không xử lý rate limit - crash ngay
response = requests.post(url, json=payload) # 429 -> Exception
✅ Xử lý rate limit với queue và backoff
import time
from queue import Queue
from threading import Thread, Event
class RateLimitedClient:
def __init__(self, api_key: str, requests_per_minute: int = 60):
self.api_key = api_key
self.rpm_limit = requests_per_minute
self.request_interval = 60.0 / requests_per_minute
self.last_request_time = 0
self.queue = Queue()
self.stop_event = Event()
# Worker thread để process queue
self.worker = Thread(target=self._process_queue, daemon=True)
self.worker.start()
def _process_queue(self):
while not self.stop_event.is_set():
try:
item = self.queue.get(timeout=1)
if item is None:
break
callback, args, kwargs = item
# Rate limiting - đợi đủ interval
elapsed = time.time() - self.last_request_time
if elapsed < self.request_interval:
time.sleep(self.request_interval - elapsed)
try:
result = self._make_request(*args, **kwargs)
callback(result=result, error=None)
except Exception as e:
callback(result=None, error=e)
self.last_request_time = time.time()
self.queue.task_done()
except:
continue
def _make_request(self, model: str, messages: list) -> dict:
import requests
response = requests.post(
"https://api.holysheep.ai/v1/chat/completions",
headers={"Authorization": f"Bearer {self.api_key}"},
json={"model": model, "messages": messages},
timeout=60
)
if response.status_code == 429:
retry_after = int(response.headers.get("Retry-After", 60))
print(f"Rate limited. Waiting {retry_after}s...")
time.sleep(retry_after)
# Retry sau khi đợi
return self._make_request(model, messages)
response.raise_for_status()
return response.json()
def async_chat(self, model: str, messages: list, callback):
"""Gửi request bất đồng bộ - không bị block"""
self.queue.put((callback, (model, messages), {}))
def close(self):
self.stop_event.set()
self.queue.put(None)
self.worker.join()
Sử dụng
client = RateLimitedClient(
api_key="YOUR_HOLYSHEEP_API_KEY",
requests_per_minute=60 # 60 RPM
)
def handle_response(result, error):
if error:
print(f"Error: {error}")
else:
print(f"Response: {result['choices'][0]['message']['content']}")
Batch 100 requests - tất cả được queue và xử lý tuần tự
for i in range(100):
client.async_chat(
model="deepseek-v3.2",
messages=[{"role": "user", "content": f"Tính toán {i}"}],
callback=handle_response
)
time.sleep(120) # Đợi queue xử lý xong
client.close()4. Lỗi 500 Server Error - Provider downtime
Mô tả: API provider gặp sự cố, trả về 500/502/503.
# ❌ Không có fallback - hệ thống chết hoàn toàn
def get_ai_response(prompt):
return requests.post(url, json=payload).json()
✅ Multi-provider fallback với automatic failover
class MultiProviderClient:
PROVIDERS = {
"primary": {
"name": "HolySheep",
"base_url": "https://api.holysheep.ai/v1",
"api_key": os.environ.get("HOLYSHEEP_API_KEY"),
"latency_sla": 50 # <50ms
},
"fallback_1": {
"name": "Local",
"base_url": "http://localhost:11434/v1", # Ollama local
"api_key": "local",
"latency_sla": 5000
}
}
def __init__(self):
self.current_provider = "primary"
self.failure_count = 0
self.max_failures = 3
def call(self, model: str, messages: list, temperature: float = 0.7):
"""Tự động failover khi primary provider lỗi"""
for provider_key in [self.current_provider, "fallback_1"]:
provider = self.PROVIDERS[provider_key]
try:
start = time.time()
response = self._make_request(
provider["base_url"],
provider["api_key"],
model,
messages,
temperature
)
latency = (time.time() - start) * 1000
# Reset failure count khi thành công
self.failure_count = 0
return {
"content": response["choices"][0]["message"]["content"],
"provider": provider["name"],
"latency_ms": round(latency, 2),
"model": model
}
except Exception as e:
self.failure_count += 1
print(f"⚠️ {provider['name']} failed: {e}")
if self.failure_count >= self.max_failures:
self.current_provider = "fallback_1"
print(f"🔄 Failover sang {self.PROVIDERS['fallback_1']['name']}")
continue
# Fallback cuối cùng - trả về cached response
return self._get_cached_or_sorry_message()
def _make_request(self, base_url: str, api_key: str, model: str, messages: list, temperature: float) -> dict:
import requests
response = requests.post(
f"{base_url}/chat/completions",
headers={"Authorization": f"Bearer {api_key}"},
json={
"model": model,
"messages": messages,
"temperature": temperature
},
timeout=30
)
response.raise_for_status()
return response.json()
def _get_cached_or_sorry_message(self):
return {
"content": "Xin lỗi, hệ thống đang bận. Vui lòng thử lại sau.",
"provider": "fallback",
"latency_ms": 0,
"cached": True
}
Sử dụng
multi_client = MultiProviderClient()
result = multi_client.call(
model="deepseek-v3.2",
messages=[{"role": "user", "content": "Hello"}]
)
print(f"Từ {result['provider']} - Latency: {result['latency_ms']}ms")
print(f"Response: {result['content']}")Tổng kết: Checklist triển khai Production
Dựa trên kinh nghiệm vận hành AI API cho hơn 50 doanh nghiệp, đây là checklist từ development đến production:
- Authentication: Sử dụng environment variable, never hardcode API key
- Retry Logic: Exponential backoff với jitter, max 3-5 retries
- Circuit Breaker: Ngăn cascade failure khi provider downtime
- Rate Limiting: Tôn trọng RPM limit, sử dụng queue nếu cần
- Timeout: 60s cho read timeout, 10s cho connect timeout
- Cost Control: Track chi phí theo ngày, set alert khi vượt budget
- Monitoring: P50/P95/P99 latency, error rate, token usage
- Fallback: Cached response hoặc alternative provider
Với HolySheep AI, tôi đã tiết kiệm được 85% chi phí (từ $8/MTok xuống $0.42/MTok với DeepSeek V3.2), đồng thời latency giảm từ 200-500ms xuống dưới 50ms. Hệ thống hỗ trợ thanh toán qua WeChat/Alipay, thanh toán bằng CNY với tỷ giá ¥1=$1, và tín dụng miễn phí khi đăng ký.
👉