Tác giả: 5 năm kinh nghiệm triển khai hệ thống AI cho doanh nghiệp thương mại điện tử, từng xử lý 50,000+ requests/giờ
Mở Đầu: Ký Ức Đêm Triển Khai Hệ Thống RAG Doanh Nghiệp
Tôi vẫn nhớ rõ đêm tháng 3 năm 2024, khi đội ngũ của tôi đang triển khai hệ thống RAG (Retrieval-Augmented Generation) cho một doanh nghiệp thương mại điện tử lớn tại Việt Nam. Hệ thống chatbot chăm sóc khách hàng của họ phục vụ 10,000 người dùng đồng thời vào giờ cao điểm.
Đêm hôm đó, ngay khi vừa deploy lên production, tôi nhận được hàng chục notification về lỗi HTTP 429 Too Many Requests. Toàn bộ API calls đến OpenAI bị rate limit. Khách hàng không thể truy vấn sản phẩm, đội ngũ CSKH không thể trả lời tự động. Đó là khoảnh khắc tôi quyết định xây dựng một giải pháp multi-account pooling hoàn chỉnh.
Tại Sao Lỗi 429 Xảy Ra?
Lỗi 429 Too Many Requests là cơ chế bảo vệ của API provider nhằm ngăn chặn việc lạm dụng tài nguyên. Với OpenAI, các giới hạn phổ biến bao gồm:
- Rate Limit theo Token/Minute: Giới hạn số token được xử lý trong mỗi phút
- Rate Limit theo Requests/Minute: Giới hạn số lượng request API
- Organization-level Limit: Giới hạn tổng thể cho toàn bộ tài khoản
- Model-specific Limit: Mỗi model có giới hạn riêng biệt
Giải Pháp 1: Multi-Account Pooling
Multi-account pooling là kỹ thuật sử dụng nhiều tài khoản API đồng thời, phân phối tải request một cách thông minh. Thay vì dồn tất cả requests vào một tài khoản, hệ thống sẽ luân chuyển giữa các tài khoản.
Cài Đặt Connection Pool Manager
"""
Multi-Account Pooling Manager cho HolySheep AI API
Giải pháp xử lý rate limit 429 hiệu quả
"""
import asyncio
import aiohttp
import time
from typing import List, Dict, Optional
from dataclasses import dataclass, field
from collections import deque
import logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
@dataclass
class AccountConfig:
"""Cấu hình cho mỗi tài khoản API"""
api_key: str
name: str
rpm_limit: int = 500 # Requests per minute
tpm_limit: int = 150000 # Tokens per minute
current_rpm: int = 0
current_tpm: int = 0
last_reset: float = field(default_factory=time.time)
is_healthy: bool = True
consecutive_failures: int = 0
# Rate limit tracking
request_timestamps: deque = field(default_factory=lambda: deque(maxlen=1000))
token_usage_history: deque = field(default_factory=lambda: deque(maxlen=1000))
class HolySheepPoolManager:
"""
Connection Pool Manager với intelligent routing
Sử dụng HolySheep AI API thay thế cho OpenAI
Tiết kiệm 85%+ chi phí với tỷ giá ¥1 = $1
"""
BASE_URL = "https://api.holysheep.ai/v1"
def __init__(
self,
accounts: List[AccountConfig],
strategy: str = "least_loaded",
enable_fallback: bool = True
):
self.accounts = {acc.name: acc for acc in accounts}
self.strategy = strategy
self.enable_fallback = enable_fallback
self._lock = asyncio.Lock()
self._semaphore = asyncio.Semaphore(len(accounts) * 3)
# Statistics
self.stats = {
"total_requests": 0,
"successful_requests": 0,
"failed_requests": 0,
"rate_limit_retries": 0,
"average_latency_ms": 0
}
logger.info(f"Khởi tạo Pool với {len(accounts)} tài khoản")
logger.info(f"Chiến lược routing: {strategy}")
logger.info("Đăng ký HolySheep AI tại: https://www.holysheep.ai/register")
def _reset_counters_if_needed(self, account: AccountConfig):
"""Reset bộ đếm mỗi 60 giây"""
current_time = time.time()
if current_time - account.last_reset >= 60:
account.current_rpm = 0
account.current_tpm = 0
account.last_reset = current_time
account.request_timestamps.clear()
account.token_usage_history.clear()
def _calculate_account_score(self, account: AccountConfig) -> float:
"""Tính điểm ưu tiên cho tài khoản (điểm càng thấp = càng tốt)"""
self._reset_counters_if_needed(account)
if not account.is_healthy:
return float('inf')
# Base score: tổng hợp RPM và TPM utilization
rpm_score = account.current_rpm / account.rpm_limit
tpm_score = account.current_tpm / account.tpm_limit
# Penalty cho consecutive failures
failure_penalty = account.consecutive_failures * 0.5
return rpm_score + tpm_score + failure_penalty
def _select_best_account(self, estimated_tokens: int = 1000) -> Optional[AccountConfig]:
"""Chọn tài khoản tốt nhất dựa trên chiến lược"""
available_accounts = [
acc for acc in self.accounts.values()
if acc.is_healthy and acc.consecutive_failures < 5
]
if not available_accounts:
return None
if self.strategy == "least_loaded":
# Chọn account có điểm thấp nhất
return min(available_accounts, key=self._calculate_account_score)
elif self.strategy == "round_robin":
# Round-robin đơn giản
return next(iter(available_accounts.values()))
elif self.strategy == "random":
import random
return random.choice(list(available_accounts.values()))
return list(available_accounts.values())[0]
async def _make_request(
self,
session: aiohttp.ClientSession,
account: AccountConfig,
payload: dict,
max_retries: int = 3
) -> dict:
"""Thực hiện request với retry logic"""
headers = {
"Authorization": f"Bearer {account.api_key}",
"Content-Type": "application/json"
}
for attempt in range(max_retries):
try:
async with self._semaphore:
start_time = time.time()
async with session.post(
f"{self.BASE_URL}/chat/completions",
json=payload,
headers=headers,
timeout=aiohttp.ClientTimeout(total=60)
) as response:
response_data = await response.json()
# Update counters ngay cả khi thành công
tokens_used = response_data.get("usage", {}).get("total_tokens", 0)
account.current_rpm += 1
account.current_tpm += tokens_used
account.request_timestamps.append(time.time())
account.token_usage_history.append(tokens_used)
if response.status == 200:
account.consecutive_failures = 0
latency_ms = (time.time() - start_time) * 1000
self.stats["average_latency_ms"] = (
self.stats["average_latency_ms"] * 0.9 + latency_ms * 0.1
)
return {
"success": True,
"data": response_data,
"account": account.name,
"latency_ms": latency_ms
}
elif response.status == 429:
# Rate limit - đánh dấu account tạm thời
wait_time = 2 ** attempt
logger.warning(
f"Rate limit từ {account.name}, chờ {wait_time}s"
)
await asyncio.sleep(wait_time)
self.stats["rate_limit_retries"] += 1
elif response.status == 401:
# Invalid API key
account.is_healthy = False
logger.error(f"API Key không hợp lệ: {account.name}")
raise Exception("Invalid API Key")
else:
logger.error(f"Lỗi {response.status}: {response_data}")
except asyncio.TimeoutError:
logger.warning(f"Timeout khi gọi {account.name}, attempt {attempt + 1}")
except Exception as e:
logger.error(f"Lỗi request {account.name}: {str(e)}")
account.consecutive_failures += 1
if account.consecutive_failures >= 5:
account.is_healthy = False
logger.error(f"Tài khoản {account.name} bị vô hiệu hóa")
return {"success": False, "error": "Max retries exceeded"}
async def chat_completion(
self,
messages: List[dict],
model: str = "gpt-4.1",
temperature: float = 0.7,
max_tokens: int = 2000,
**kwargs
) -> dict:
"""
Gửi chat completion request với intelligent routing
Tự động chọn tài khoản tốt nhất và retry khi cần
"""
self.stats["total_requests"] += 1
payload = {
"model": model,
"messages": messages,
"temperature": temperature,
"max_tokens": max_tokens,
**kwargs
}
# Ước tính tokens cho việc chọn account
estimated_tokens = sum(
len(str(m.get("content", ""))) // 4 for m in messages
) + max_tokens
async with aiohttp.ClientSession() as session:
# Thử lần lượt các tài khoản
for _ in range(len(self.accounts)):
account = self._select_best_account(estimated_tokens)
if not account:
logger.error("Không có tài khoản khả dụng")
self.stats["failed_requests"] += 1
return {"success": False, "error": "No available accounts"}
result = await self._make_request(session, account, payload)
if result["success"]:
self.stats["successful_requests"] += 1
return result
# Nếu account bị vô hiệu hóa, chọn account khác
if not self.accounts[account.name].is_healthy:
continue
self.stats["failed_requests"] += 1
return {"success": False, "error": "All accounts failed"}
def get_stats(self) -> dict:
"""Lấy thống kê sử dụng"""
return {
**self.stats,
"active_accounts": sum(1 for a in self.accounts.values() if a.is_healthy),
"total_accounts": len(self.accounts)
}
==================== SỬ DỤNG MẪU ====================
async def main():
"""Ví dụ sử dụng Multi-Account Pooling"""
# Cấu hình nhiều tài khoản HolySheep AI
accounts = [
AccountConfig(
api_key="YOUR_HOLYSHEEP_API_KEY_1",
name="account_primary",
rpm_limit=500,
tpm_limit=150000
),
AccountConfig(
api_key="YOUR_HOLYSHEEP_API_KEY_2",
name="account_backup",
rpm_limit=500,
tpm_limit=150000
),
AccountConfig(
api_key="YOUR_HOLYSHEEP_API_KEY_3",
name="account_secondary",
rpm_limit=500,
tpm_limit=150000
),
]
# Khởi tạo Pool Manager
pool = HolySheepPoolManager(
accounts=accounts,
strategy="least_loaded",
enable_fallback=True
)
# Gửi request
messages = [
{"role": "system", "content": "Bạn là trợ lý AI chuyên nghiệp"},
{"role": "user", "content": "Giải thích về RAG system trong 3 câu"}
]
result = await pool.chat_completion(
messages=messages,
model="gpt-4.1",
temperature=0.7,
max_tokens=500
)
if result["success"]:
print(f"Thành công! Account: {result['account']}")
print(f"Latency: {result['latency_ms']:.2f}ms")
print(f"Response: {result['data']['choices'][0]['message']['content']}")
# In thống kê
print("\n=== Thống Kê ===")
for key, value in pool.get_stats().items():
print(f"{key}: {value}")
if __name__ == "__main__":
asyncio.run(main())Giải Pháp 2: Intelligent Request Routing
Bên cạnh multi-account pooling, intelligent routing còn bao gồm việc điều hướng request dựa trên loại query, độ ưu tiên, và tình trạng hệ thống.
Smart Router với Priority Queue
"""
Intelligent Request Router với Priority Queue
Hỗ trợ batch processing và real-time requests
"""
import asyncio
import heapq
import time
from enum import IntEnum
from typing import List, Optional, Callable
from dataclasses import dataclass, field
from collections import defaultdict
import hashlib
class RequestPriority(IntEnum):
"""Mức ưu tiên request"""
LOW = 0
NORMAL = 1
HIGH = 2
CRITICAL = 3
EMERGENCY = 4
@dataclass(order=True)
class PrioritizedRequest:
"""Request với mức ưu tiên"""
priority: int = field(compare=True, repr=False)
timestamp: float = field(compare=True, default_factory=time.time)
request_id: str = field(compare=False, default="")
payload: dict = field(compare=False, default_factory=dict)
callback: Optional[Callable] = field(compare=False, default=None)
retry_count: int = field(compare=False, default=0)
estimated_cost: float = field(compare=False, default=0.0)
model: str = field(compare=False, default="gpt-4.1")
class IntelligentRouter:
"""
Intelligent Request Router
- Priority-based queue
- Model selection thông minh
- Cost optimization
- Fallback logic
"""
# Map model với tier và chi phí (2026 pricing)
MODEL_TIER = {
# Tier 1: Premium models
"gpt-4.1": {"tier": 1, "cost_per_1k": 8.0, "latency_ms": 800},
"claude-sonnet-4.5": {"tier": 1, "cost_per_1k": 15.0, "latency_ms": 900},
# Tier 2: Standard models
"gemini-2.5-flash": {"tier": 2, "cost_per_1k": 2.50, "latency_ms": 300},
"deepseek-v3.2": {"tier": 2, "cost_per_1k": 0.42, "latency_ms": 400},
# Tier 3: Budget models
"gpt-4o-mini": {"tier": 3, "cost_per_1k": 0.15, "latency_ms": 200},
}
def __init__(
self,
pool_manager, # HolySheepPoolManager instance
max_concurrent: int = 50,
enable_cost_optimization: bool = True
):
self.pool = pool_manager
self.max_concurrent = max_concurrent
self.enable_cost_optimization = enable_cost_optimization
self._request_queue: List[PrioritizedRequest] = []
self._processing: int = 0
self._lock = asyncio.Lock()
self._running = False
# Statistics
self.metrics = {
"requests_received": 0,
"requests_completed": 0,
"requests_failed": 0,
"total_cost": 0.0,
"average_wait_time_ms": 0,
"priority_distribution": defaultdict(int)
}
def _estimate_cost(self, model: str, max_tokens: int) -> float:
"""Ước tính chi phí request"""
model_info = self.MODEL_TIER.get(model, self.MODEL_TIER["gpt-4.1"])
return (max_tokens / 1000) * model_info["cost_per_1k"]
def _generate_request_id(self, payload: dict) -> str:
"""Tạo request ID duy nhất"""
content = str(payload)
return hashlib.md5(f"{content}{time.time()}".encode()).hexdigest()[:12]
async def enqueue(
self,
messages: List[dict],
priority: RequestPriority = RequestPriority.NORMAL,
model: str = "gpt-4.1",
max_tokens: int = 1000,
callback: Optional[Callable] = None,
auto_select_model: bool = True
) -> str:
"""
Thêm request vào queue với mức ưu tiên
Args:
messages: Danh sách messages cho chat completion
priority: Mức ưu tiên (LOW → EMERGENCY)
model: Model sử dụng
max_tokens: Số token tối đa
callback: Function được gọi khi hoàn thành
auto_select_model: Tự động chọn model tối ưu chi phí
"""
request_id = self._generate_request_id(messages)
# Auto-select model nếu được kích hoạt
if auto_select_model and self.enable_cost_optimization:
model = self._select_cost_effective_model(messages, priority)
# Tính chi phí ước tính
estimated_cost = self._estimate_cost(model, max_tokens)
request = PrioritizedRequest(
priority=priority,
timestamp=time.time(),
request_id=request_id,
payload={
"messages": messages,
"model": model,
"max_tokens": max_tokens
},
callback=callback,
estimated_cost=estimated_cost,
model=model
)
async with self._lock:
heapq.heappush(self._request_queue, request)
self.metrics["requests_received"] += 1
self.metrics["priority_distribution"][priority.name] += 1
return request_id
def _select_cost_effective_model(
self,
messages: List[dict],
priority: RequestPriority
) -> str:
"""
Chọn model tối ưu chi phí dựa trên loại request
Chiến lược:
- CRITICAL/EMERGENCY: Luôn dùng GPT-4.1
- HIGH: Gemini 2.5 Flash cho simple queries
- NORMAL: DeepSeek V3.2 cho general tasks
- LOW: DeepSeek V3.2 cho batch processing
"""
# Kiểm tra độ phức tạp của query
user_message = next(
(m["content"] for m in reversed(messages) if m["role"] == "user"),
""
)
query_length = len(user_message)
is_complex = any(
keyword in user_message.lower()
for keyword in ["phân tích", "so sánh", "đánh giá", "explain", "analyze"]
)
if priority in [RequestPriority.CRITICAL, RequestPriority.EMERGENCY]:
return "gpt-4.1"
elif priority == RequestPriority.HIGH:
return "gemini-2.5-flash" if query_length < 500 else "gpt-4.1"
elif priority == RequestPriority.NORMAL:
if is_complex:
return "gemini-2.5-flash"
return "deepseek-v3.2"
else: # LOW
return "deepseek-v3.2"
async def _process_request(self, request: PrioritizedRequest):
"""Xử lý một request"""
try:
start_time = time.time()
# Gọi pool manager
result = await self.pool.chat_completion(
messages=request.payload["messages"],
model=request.payload["model"],
max_tokens=request.payload["max_tokens"]
)
wait_time = (time.time() - start_time) * 1000
self.metrics["average_wait_time_ms"] = (
self.metrics["average_wait_time_ms"] * 0.9 + wait_time * 0.1
)
if result["success"]:
self.metrics["requests_completed"] += 1
self.metrics["total_cost"] += request.estimated_cost
else:
self.metrics["requests_failed"] += 1
# Gọi callback nếu có
if request.callback:
await request.callback(result)
return result
except Exception as e:
self.metrics["requests_failed"] += 1
logger.error(f"Request {request.request_id} failed: {e}")
return {"success": False, "error": str(e)}
finally:
async with self._lock:
self._processing -= 1
async def _worker(self):
"""Worker xử lý queue"""
while self._running:
request = None
async with self._lock:
# Lấy request có priority cao nhất
if self._processing < self.max_concurrent and self._request_queue:
request = heapq.heappop(self._request_queue)
self._processing += 1
if request:
asyncio.create_task(self._process_request(request))
else:
await asyncio.sleep(0.1) # Tránh busy-waiting
async def start(self):
"""Khởi động router"""
self._running = True
self._worker_task = asyncio.create_task(self._worker())
logger.info("Intelligent Router đã khởi động")
async def stop(self):
"""Dừng router"""
self._running = False
if hasattr(self, "_worker_task"):
self._worker_task.cancel()
logger.info("Intelligent Router đã dừng")
def get_metrics(self) -> dict:
"""Lấy metrics"""
return {
**dict(self.metrics),
"queue_size": len(self._request_queue),
"processing": self._processing,
"total_cost_usd": self.metrics["total_cost"],
"total_cost_vnd": self.metrics["total_cost"] * 25000 # Tỷ giá tham khảo
}
==================== VÍ DỤ SỬ DỤNG ====================
async def example_usage():
"""Ví dụ sử dụng Intelligent Router"""
# Khởi tạo pool manager (sử dụng code từ phần trước)
accounts = [
AccountConfig(
api_key="YOUR_HOLYSHEEP_API_KEY",
name="main",
rpm_limit=500,
tpm_limit=150000
)
]
pool = HolySheepPoolManager(accounts=accounts)
# Khởi tạo router
router = IntelligentRouter(
pool_manager=pool,
max_concurrent=20,
enable_cost_optimization=True
)
await router.start()
# Callback function
def handle_response(result):
print(f"Response nhận được: {result}")
# Enqueue các request với priority khác nhau
await router.enqueue(
messages=[
{"role": "user", "content": "Tóm tắt sản phẩm này"}
],
priority=RequestPriority.HIGH,
max_tokens=200,
callback=handle_response
)
await router.enqueue(
messages=[
{"role": "user", "content": "Phân tích chi tiết đánh giá khách hàng"}
],
priority=RequestPriority.CRITICAL,
max_tokens=1000,
callback=handle_response
)
# Batch processing cho query đơn giản
for i in range(10):
await router.enqueue(
messages=[
{"role": "user", "content": f"Câu hỏi #{i}: Thời tiết hôm nay thế nào?"}
],
priority=RequestPriority.LOW,
max_tokens=100
)
# Đợi một chút và in metrics
await asyncio.sleep(5)
print("\n=== Router Metrics ===")
for key, value in router.get_metrics().items():
print(f"{key}: {value}")
await router.stop()
if __name__ == "__main__":
asyncio.run(example_usage())Giải Pháp 3: Exponential Backoff với Jitter
Khi request bị rate limit, việc retry ngay lập tức sẽ làm tình hình tệ hơn. Exponential backoff với jitter là chiến lược được khuyến nghị.
"""
Advanced Retry Logic với Exponential Backoff và Jitter
Thread-safe, production-ready implementation
"""
import asyncio
import random
import time
from typing import Callable, Any, Optional, TypeVar, Union
from functools import wraps
from dataclasses import dataclass
import logging
logger = logging.getLogger(__name__)
T = TypeVar('T')
@dataclass
class RetryConfig:
"""Cấu hình retry strategy"""
max_retries: int = 5
base_delay: float = 1.0 # Delay ban đầu (giây)
max_delay: float = 60.0 # Delay tối đa (giây)
exponential_base: float = 2.0 # Cơ số exponential
jitter: bool = True # Bật/tắt jitter
jitter_range: tuple = (0.8, 1.2) # Range cho jitter
retryable_exceptions: tuple = (
Exception, # Retry tất cả exception mặc định
)
retryable_status_codes: tuple = (429, 500, 502, 503, 504)
def calculate_delay(
attempt: int,
config: RetryConfig,
retry_after: Optional[float] = None
) -> float:
"""
Tính toán delay với exponential backoff và jitter
Công thức: min(max_delay, base_delay * (exponential_base ^ attempt)) * jitter
Ví dụ:
- Attempt 0: 1.0s * 2^0 = 1.0s
- Attempt 1: 1.0s * 2^1 = 2.0s
- Attempt 2: 1.0s * 2^2 = 4.0s
- Attempt 3: 1.0s * 2^3 = 8.0s
- Attempt 4: 1.0s * 2^4 = 16.0s
"""
# Ưu tiên retry_after header từ server
if retry_after and retry_after > 0:
return min(retry_after, config.max_delay)
# Exponential backoff
delay = config.base_delay * (config.exponential_base ** attempt)
# Áp dụng jitter nếu được bật
if config.jitter:
jitter_factor = random.uniform(*config.jitter_range)
delay *= jitter_factor
# Đảm bảo không vượt quá max_delay
return min(delay, config.max_delay)
async def retry_with_backoff(
func: Callable[..., Any],
*args,
config: Optional[RetryConfig] = None,
**kwargs
) -> Any:
"""
Retry function với exponential backoff
Args:
func: Function cần retry
*args: Arguments cho function
config: RetryConfig object
**kwargs: Keyword arguments
Returns:
Kết quả từ function thành công
"""
if config is None:
config = RetryConfig()
last_exception = None
for attempt in range(config.max_retries + 1):
try:
# Gọi function (hỗ trợ cả sync và async)
if asyncio.iscoroutinefunction(func):
result = await func(*args, **kwargs)
else:
result = func(*args, **kwargs)
if attempt > 0:
logger.info(f"Thành công sau {attempt} retries")
return result
except Exception as e:
last_exception = e
# Kiểm tra có phải retryable error không
should_retry = False
retry_after = None
# Kiểm tra status code nếu có
if hasattr(e, 'response') and hasattr(e.response, 'status'):
status = e.response.status
if status in config.retryable_status_codes:
should_retry = True
# Parse Retry-After header
retry_after_header = e.response.headers.get('Retry-After')
if retry_after_header:
try:
retry_after = float(retry_after_header)
except ValueError:
pass
# Kiểm tra exception type
if isinstance(e, config.retryable_exceptions):
should_retry = True
if not should_retry or attempt >= config.max_retries:
logger.error(
f"Đã đạt max retries ({attempt}/{config.max_retries}): {e}"
)
raise
# Tính delay
delay = calculate_delay(attempt, config, retry_after)
logger.warning(
f"Attempt {attempt + 1}/{config.max_retries + 1} thất bại. "
f"Retry sau {delay:.2f}s. Error: {str(e)}"
)
await asyncio.sleep(delay)
raise last_exception
def async_retry_decorator(config: Optional[RetryConfig] = None):
"""
Decorator cho async functions
Usage:
@async_retry_decorator(config=RetryConfig(max_retries=3))
async def my_function():
...
"""
if config is None:
config = RetryConfig()
def decorator(func: Callable) -> Callable:
@wraps(func)
async def wrapper(*args, **kwargs):
return await retry_with_backoff(func, *args, config=config, **kwargs)
return wrapper
return decorator
class HolySheepAPIClient:
"""
HolySheep AI API Client với built-in retry logic
Xử lý 429 error một cách tự động
"""
BASE_URL = "https://api.holysheep.ai/v1"
def __init__(self, api_key: str):
self.api_key = api_key
self.retry_config = RetryConfig(
max_retries=5,
base_delay=1.0,
max_delay=30.0,
exponential_base=2.0,
jitter=True
)
@async_retry_decorator()
async def chat_completion(
self,
messages: List[dict],
model: str = "gpt-4.1",
**kwargs
) -> dict:
"""
Gửi chat completion request với automatic retry
"""
import aiohttp
headers = {
"Authorization": f"Bearer {self.api_key}",
"Content-Type": "application/json"
}
payload = {
"model": model,
"messages": messages,
**kwargs
}
async with aiohttp.ClientSession() as session:
async with session.post(
f"{self.BASE_URL}/chat/completions",
json=payload,
headers=headers,
timeout=aiohttp.ClientTimeout(total=60)
) as response:
if response.status == 200:
return await