Премини към основното съдържание
Български— Изберете език
Меню

Асинхронна архитектура и опашки

Урок 7 от 20 Обновен 28 юли 2026 г. Напреднало
На тази страница
  1. Защо никога не трябва да блокирате при извикване на LLM
  2. Моделът Producer / Consumer
  3. Спазване на квоти вместо достигането им
  4. Незабавно връщане на контрола
  5. Ключови изводи

Защо никога не трябва да блокирате при извикване на 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
  • Обработвайте повторните опити с експоненциално забавяне във Вашите работници
  • За дълготрайни задачи предпочитайте модел с уебхук пред периодично допитване