Асинхронна архитектура и опашки
На тази страница
Защо никога не трябва да блокирате при извикване на LLM
Извикването на API към езиков модел отнема между една и тридесет секунди, в зависимост от модела и сложността на заявката. Тридесет секунди са вечност за сървърен процес: през това време изчакващият нишка не прави нищо, но все пак заема слот. Умножете това по сто едновременни заявки и Вашето приложение ще се срине не защото извършва твърде много изчисления, а защото чака твърде много.
Асинхронната архитектура, подкрепена от опашка, решава три проблема едновременно. Тя абсорбира пикове в трафика, тъй като опашката расте, вместо да отхвърля заявки. Тя централизира логиката за повторни опити, защото неуспешната задача се връща в опашката, вместо да изчезне заедно с HTTP заявката, която я е задействала. И тя развързва Вашите услуги: компонентът, получаващ заявки, вече не трябва да знае колко време отнема на изпълняващия компонент да ги обработи.
Моделът Producer / Consumer
Основната структура разчита на два обекта. Задачата описва какво трябва да се направи и текущия статус на обработката; опашката разпределя тези задачи към пул от работници, които ги консумират паралелно. Моделирането на статуса като изброение (enum), вместо като низ в свободен формат, избягва най-честия клас бъгове в този тип код: две части на програмата да записват "terminee" и "terminée".
import asyncio
from dataclasses import dataclass, field
from enum import Enum
class TaskStatus(Enum):
PENDING = "pending"
IN_PROGRESS = "in_progress"
COMPLETED = "completed"
FAILED = "failed"
@dataclass
class Task:
id: str
prompt: str
model: str = "gpt-5.6-terra"
status: TaskStatus = TaskStatus.PENDING
result: str | None = None
attempts: int = 0
max_attempts: int = 3
class ProcessingQueue:
"""Асинхронна опашка за извиквания на LLM."""
def __init__(self, num_workers: int = 5):
self.queue: asyncio.Queue[Task] = asyncio.Queue()
self.results: dict[str, Task] = {}
self.num_workers = num_workers
async def add(self, task: Task) -> str:
"""Добавя задача към опашката."""
self.results[task.id] = task
await self.queue.put(task)
return task.id
async def worker(self, worker_id: int):
"""Работник, който обработва задачи от опашката."""
import openai
client = openai.AsyncOpenAI()
while True:
task = await self.queue.get()
task.status = TaskStatus.IN_PROGRESS
task.attempts += 1
try:
response = await client.responses.create(
model=task.model,
input=task.prompt,
)
task.result = response.output_text
task.status = TaskStatus.COMPLETED
except Exception as e:
if task.attempts < task.max_attempts:
task.status = TaskStatus.PENDING
await self.queue.put(task)
else:
task.status = TaskStatus.FAILED
task.result = str(e)
finally:
self.queue.task_done()
async def start(self):
"""Стартира работниците."""
workers = [
asyncio.create_task(self.worker(i))
for i in range(self.num_workers)
]
return workers
async def wait_completion(self):
"""Изчаква докато всички задачи бъдат обработени."""
await self.queue.join()
Два детайла в този работник заслужават вниманието Ви, защото се появяват във всяка реализация в реални условия. Броячът attempts живее в самата задача, а не в работника, което позволява на всеки друг работник да поеме задача, върната в опашката, без да губи историята ѝ. Извикването task_done() се намира в блок finally, за да гарантира, че опашката никога няма да увисне безкрайно, ако неочаквано изключение заобиколи блока except: без него, join(), който никога не се връща, е симптомът и е болезнено за диагностициране.
От страната на извикващия, употребата е проста: стартирайте работниците, поставете задачите в опашката, изчакайте, съберете резултатите и спрете.
async def process_documents(documents: list[str]):
queue = ProcessingQueue(num_workers=10)
workers = await queue.start()
# Добавяне на задачи
for i, doc in enumerate(documents):
task = Task(
id=f"doc-{i}",
prompt=f"Обобщи този документ: {doc}",
)
await queue.add(task)
# Изчакване за приключване
await queue.wait_completion()
# Събиране на резултатите
for task_id, task in queue.results.items():
print(f"{task_id}: {task.status.value}")
# Спиране на работниците
for w in workers:
w.cancel()
Спазване на квоти вместо достигането им
OpenAI налага два едновременни лимита: заявки в минута и токени в минута. Пул от десет работници, изпращащи всичко, което могат, ще удари единия или другия лимит, ще получи грешки за ограничаване на скоростта (rate limit), ще опита отново и ще влоши задръстването. По-добре е доброволно да забавите темпото в началото, отколкото да бъдете отхвърлени в края.
Лимитерът по-долу прилага кофа с токени върху плъзгащ се прозорец от една минута. Той поддържа две истории – времеви марки на скорошни заявки и двойки времеви марки/токени – изчиства записи, които са излезли от прозореца, след което чака, ако някой от лимитите бъде надвишен. Блокировката asyncio е от съществено значение: без нея десет работници биха оценили една и съща ситуация едновременно и всички десет биха решили, че все още има място.
import asyncio
import time
class RateLimiter:
"""Лимитер на скоростта, базиран на кофа с токени."""
def __init__(self, rpm: int = 500, tpm: int = 200_000):
self.rpm = rpm
self.tpm = tpm
self.recent_requests: list[float] = []
self.recent_tokens: list[tuple[float, int]] = []
self.lock = asyncio.Lock()
async def wait(self, estimated_tokens: int = 1000):
"""Изчаква, ако е необходимо, за да се спазят лимитите."""
async with self.lock:
now = time.time()
window = 60.0
# Изчистване на записи извън прозореца
self.recent_requests = [
t for t in self.recent_requests
if now - t < window
]
self.recent_tokens = [
(t, n) for t, n in self.recent_tokens
if now - t < window
]
# Проверка на RPM (заявки в минута)
if len(self.recent_requests) >= self.rpm:
wait_time = self.recent_requests[0] + window - now
await asyncio.sleep(wait_time)
# Проверка на TPM (токени в минута)
tokens_used = sum(n for _, n in self.recent_tokens)
if tokens_used + estimated_tokens > self.tpm:
wait_time = self.recent_tokens[0][0] + window - now
await asyncio.sleep(wait_time)
self.recent_requests.append(time.time())
self.recent_tokens.append((time.time(), estimated_tokens))
Параметърът estimated_tokens заслужава дума: Вие не знаете действителната цена, докато отговорът не пристигне, затова работите с оценка. Направете я щедра, а не прецизна. Систематичното подценяване е равносилно на изключване на защитата точно когато би била полезна.
Незабавно връщане на контрола
За обработка, която отнема няколко минути, карането на HTTP клиент да чака вече не е жизнеспособно: таймаутите на прокси, браузъра и балансировчика на натоварване ще се задействат, преди да приключите. Моделът с уебхук обръща отговорността. Вашият крайна точка приема заявката, незабавно връща ID на задача и уведомява извикващия, когато резултатът съществува, без да изисква периодично допитване (polling).
from fastapi import FastAPI, BackgroundTasks
app = FastAPI()
@app.post("/api/analyze")
async def start_analysis(
request: dict,
background_tasks: BackgroundTasks,
):
"""Стартира фонов анализ и уведомява чрез уебхук."""
task_id = generate_id()
background_tasks.add_task(
run_analysis,
task_id=task_id,
document=request["document"],
webhook_url=request.get("webhook_url"),
)
return {"task_id": task_id, "status": "in_progress"}
async def run_analysis(
task_id: str,
document: str,
webhook_url: str | None,
):
"""Изпълнява анализа и изпраща резултата чрез уебхук."""
import httpx
result = await call_llm(document)
if webhook_url:
async with httpx.AsyncClient() as http:
await http.post(webhook_url, json={
"task_id": task_id,
"status": "completed",
"result": result,
})
Винаги съхранявайте върнатото ID и свързаното състояние някъде в трайно хранилище. Един уебхук може да се загуби и извикващият трябва да запази възможността сам да извлече резултата.
Ключови изводи
- Използвайте асинхронни опашки, за да развържете поглъщането от обработката
- Внедрете лимитер на скоростта, за да спазвате квотите на OpenAI
- Обработвайте повторните опити с експоненциално забавяне във Вашите работници
- За дълготрайни задачи предпочитайте модел с уебхук пред периодично допитване