Aszinkron architektúra és sorok
Ezen az oldalon
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