Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Aszinkron architektúra és sorok

7. lecke 20 közül Frissítve 2026. július 28. Haladó
Ezen az oldalon
  1. Miért soha ne blokkolj egy LLM-hívás miatt
  2. Producer / Consumer minta
  3. Kvóták betartása a túllépés helyett
  4. Az irányítás azonnali visszaadása
  5. Főbb megállapítások

Miért soha ne blokkolj egy LLM-hívás miatt

Egy nyelvi modellnek küldött API-hívás egy és harminc másodperc közötti időt vesz igénybe, modelltől és a kérés összetettségétől függően. Harminc másodperc egy örökkévalóság egy szerverfolyamat számára: ezalatt a várakozó szál semmit sem csinál, mégis foglal egy helyet. Szorozd ezt meg száz egyidejű kéréssel, és az alkalmazásod összeomlik, nem azért, mert túl sokat számít, hanem mert túl sokat vár.

Egy sorral támogatott aszinkron architektúra egyszerre három problémát old meg. Elnyeli a forgalmi csúcsokat, mivel a sor növekszik a kérések elutasítása helyett. Centralizálja az újrapróbálkozási logikát, mert egy sikertelen feladat visszakerül a sorba, ahelyett, hogy eltűne azzal a HTTP-kéréssel együtt, amely kiváltotta. És leválasztja a szolgáltatásaidat: a kéréseket fogadó komponensnek többé nem kell tudnia, mennyi ideig tart a végrehajtó komponensnek a feldolgozás.

Producer / Consumer minta

Az alapvető struktúra két objektumra épül. Egy feladat (task) leírja, mit kell csinálni és a jelenlegi feldolgozási állapotot; egy sor osztja szét ezeket a feladatokat egy munkásokból álló poolnak, amelyek párhuzamosan fogyasztják el azokat. Ha az állapotot felsorolásként (enumeration) modellezed szabad formátumú sztring helyett, elkerülöd az ilyen típusú kódok leggyakoribb hibaosztályát: amikor a program két része eltérően írja ugyanazt, például "terminee" és "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:
    """Aszinkron sor LLM-hívásokhoz."""

    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:
        """Hozzáad egy feladatot a sorhoz."""
        self.results[task.id] = task
        await self.queue.put(task)
        return task.id

    async def worker(self, worker_id: int):
        """Munkás, amely feldolgozza a sorban lévő feladatokat."""
        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):
        """Elindítja a munkásokat."""
        workers = [
            asyncio.create_task(self.worker(i))
            for i in range(self.num_workers)
        ]
        return workers

    async def wait_completion(self):
        """Megvárja, amíg az összes feladat feldolgozásra kerül."""
        await self.queue.join()

Ebben a munkásban két részlet érdemel figyelmet, mivel minden valós implementációban megjelennek. Az attempts számláló magán a feladaton él, nem a munkáson, így lehetővé téve, hogy bármely másik munkás felvegyen egy újra sorba tett feladatot anélkül, hogy elveszítené annak előzményeit. A task_done() hívás egy finally blokkban helyezkedik el, hogy garantálja: a sor sosem akad meg véglegesen, ha egy váratlan kivétel megkerüli az except blokkot: enélkül egy soha vissza nem térő join() a tünet, és fájdalmas diagnosztizálni.

A hívó oldalán a használat egyszerű: indítsd el a munkásokat, tedd sorba a feladatokat, várj, gyűjtsd össze az eredményeket, majd állítsd le őket.

async def process_documents(documents: list[str]):
    queue = ProcessingQueue(num_workers=10)
    workers = await queue.start()

    # Feladatok hozzáadása
    for i, doc in enumerate(documents):
        task = Task(
            id=f"doc-{i}",
            prompt=f"Summarize this document: {doc}",
        )
        await queue.add(task)

    # Befejezés megvárása
    await queue.wait_completion()

    # Eredmények összegyűjtése
    for task_id, task in queue.results.items():
        print(f"{task_id}: {task.status.value}")

    # Munkások leállítása
    for w in workers:
        w.cancel()

Kvóták betartása a túllépés helyett

Az OpenAI két egyidejű korlátot érvényesít: percenkénti kérésszámot és percenkénti tokenszámot. Tíz munkásból álló pool, amely mindent elküld, amire képes, elérni az egyiket vagy a másikat, sebességkorlátozási hibákat kap, újrapróbálkozik, és tovább rontja a torlódást. Jobb önkéntesen lassítani upstream, mint downstream elutasítást kapni.

Az alábbi korlátozó egy csúszó egyperces ablakon alapuló token-vödröt alkalmaz. Két előzményt tart fenn – a közelmúltbeli kérések időbélyegzőit és az időbélyegző/token párokat –, törli az ablakon kívül eső bejegyzéseket, majd vár, ha bármelyik korlátot túllépné. Az asyncio lock elengedhetetlen: enélkül tíz munkás egyszerre értékelné ugyanazt a helyzetet, és mind a tíz úgy döntené, hogy még van hely.

import asyncio
import time

class RateLimiter:
    """Token-vödör alapú sebességkorlátozó."""

    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):
        """Vár, ha szükséges a korlátok betartásához."""
        async with self.lock:
            now = time.time()
            window = 60.0

            # Ablakon kívüli bejegyzések tisztítása
            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 ellenőrzése
            if len(self.recent_requests) >= self.rpm:
                wait_time = self.recent_requests[0] + window - now
                await asyncio.sleep(wait_time)

            # TPM ellenőrzése
            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))

Az estimated_tokens paraméter megérdemel egy szót: a tényleges költséget csak a válasz megérkezése után ismered, így becsléssel dolgozol. Legyen inkább bőkezű, mint precíz. A szisztematikus alábecslés egyenlő a védelem kikapcsolásával pontosan akkor, amikor hasznos lenne.

Az irányítás azonnali visszaadása

Több percig tartó feldolgozás esetén nem életképes, ha egy HTTP-kliens várakozik: a proxy, a böngésző és a terheléselosztó időtúllépései bekapcsolnak, mielőtt befejeznéd. A webhook minta megfordítja a felelősséget. A végpontod elfogadja a kérést, azonnal visszaad egy feladatazonosítót, és értesíti a hívót, amikor az eredmény elkészül, anélkül, hogy periodikus lekérdezést (polling) igényelne.

from fastapi import FastAPI, BackgroundTasks

app = FastAPI()

@app.post("/api/analyze")
async def start_analysis(
    request: dict,
    background_tasks: BackgroundTasks,
):
    """Elindít egy háttérelemzést és webhookon keresztül értesít."""
    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,
):
    """Lefuttatja az elemzést és webhookon keresztül elküldi az eredményt."""
    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,
            })

Mindig tárold el a visszaadott azonosítót és a hozzá tartozó állapotot valahol tartósan. Egy webhook elveszhet, és a hívónak meg kell őriznie a képességet, hogy maga kérdezze le az eredményt.

Főbb megállapítások

  • Használj aszinkron sorokat a bevitel és a feldolgozás szétválasztására
  • Implementálj sebességkorlátozót az OpenAI kvóták betartásához
  • Kezeld az újrapróbálkozásokat exponenciális visszalépéssel a munkásaidban
  • Hosszú ideig futó feladatoknál részesítsd előnyben a webhook mintát a lekérdezéssel szemben