Asinhrona arhitektura in čakalne vrste
Na tej strani
Zakaj nikoli ne blokiraš klica LLM
Klic API-ja jezikovnega modela traja med eno in trideset sekund, odvisno od modela in zahtevnosti poizvedbe. Trideset sekund je za proces strežnika večnost: v tem času čakajoča nit ne naredi ničesar, kljub temu pa zaseda mesto. Pomnoži to s sto hkratnimi zahtevami in tvoja aplikacija se bo zrušila ne zato, ker bi preveč računala, ampak zato, ker preveč čaka.
Asinhrona arhitektura, podprta s čakalno vrsto, reši tri težave hkrati. Blaži konice prometa, saj čakalna vrsta raste, namesto da bi zavračala zahteve. Centralizira logiko poskusov ponovnega izvajanja, saj se neuspešna naloga vrne v vrsto, namesto da bi izginila skupaj z zahtevo HTTP, ki jo je sprožila. In ločuje tvoje storitve: komponenta, ki prejema zahteve, ne potrebuje več informacij o tem, koliko časa potrebuje izvajajoča komponenta za njihovo obdelavo.
Vzorec proizvajalec / potrošnik
Osnovna struktura temelji na dveh objektih. Naloga opisuje, kaj je treba storiti, in trenutni status obdelave; čakalna vrsta porazdeli te naloge v skupino delavcev, ki jih porabljajo vzporedno. Modeliranje statusa kot naštevanja namesto kot niza poljubne oblike preprečuje najpogostejši razred napak v tovrstni kodi: ko dva dela programa zapišeta "terminee" in "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:
"""Asinhrona čakalna vrsta za klice 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:
"""Doda nalogo v čakalno vrsto."""
self.results[task.id] = task
await self.queue.put(task)
return task.id
async def worker(self, worker_id: int):
"""Delavec, ki obdeluje naloge iz čakalne vrste."""
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):
"""Zažene delavce."""
workers = [
asyncio.create_task(self.worker(i))
for i in range(self.num_workers)
]
return workers
async def wait_completion(self):
"""Čaka, dokler niso obdelane vse naloge."""
await self.queue.join()
Dve podrobnosti v tem delavcu si zaslužita tvojo pozornost, saj se pojavljata v vsaki implementaciji v realnem svetu. Števec attempts živi v sami nalogi, ne v delavcu, kar omogoča, da kateri koli drug delavec prevzame ponovno uvrščeno nalogo, ne da bi izgubil njeno zgodovino. Klic task_done() se nahaja znotraj bloka finally, da se zagotovi, da se čakalna vrsta nikoli ne zatakne za nedoločen čas, če nepričakovana izjema obide blok except: brez tega je simptom join(), ki se nikoli ne vrne, in to je boleče diagnosticirati.
Na strani klicatelja je uporaba preprosta: zaženi delavce, dodaj naloge v vrsto, počakaj, zberi rezultate in ustavi proces.
async def process_documents(documents: list[str]):
queue = ProcessingQueue(num_workers=10)
workers = await queue.start()
# Dodaj naloge
for i, doc in enumerate(documents):
task = Task(
id=f"doc-{i}",
prompt=f"Summarize this document: {doc}",
)
await queue.add(task)
# Počakaj na zaključek
await queue.wait_completion()
# Zberi rezultate
for task_id, task in queue.results.items():
print(f"{task_id}: {task.status.value}")
# Ustavi delavce
for w in workers:
w.cancel()
Spoštovanje kvot namesto trčenja ob njih
OpenAI uveljavlja dve hkratni omejitvi: število zahtev na minuto in število žetonov na minuto. Skupina desetih delavcev, ki pošiljajo vse, kar zmorejo, bo trčila ob eno ali drugo omejitev, prejela napake omejitve hitrosti, poskusila znova in poslabšala zastoje. Bolje je prostovoljno upočasniti pretok navzgor, kot pa biti zavrnjen navzdol.
Spodnji omejevalnik uporablja vedro žetonov (token bucket) nad drsečim enominutnim oknom. Vzdržuje dve zgodovini – časovne žige nedavnih zahtev in pare časovni žig/žetoni – počisti vnose, ki so padli izven okna, nato pa čaka, če bi bila presežena katerakoli omejitev. Zaklep asyncio je bistven: brez njega bi deset delavcev hkrati ocenjevalo isto situacijo in vseh deset bi se odločilo, da je še vedno prostora.
import asyncio
import time
class RateLimiter:
"""Omejevalnik hitrosti na osnovi vedra žetonov."""
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):
"""Čaka, če je potrebno, da se spoštujejo omejitve."""
async with self.lock:
now = time.time()
window = 60.0
# Počisti vnose izven okna
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
]
# Preveri RPM
if len(self.recent_requests) >= self.rpm:
wait_time = self.recent_requests[0] + window - now
await asyncio.sleep(wait_time)
# Preveri 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))
Parameter estimated_tokens si zasluži besedo: dejanskih stroškov ne poznaš, dokler ne prispe odgovor, zato delaš z oceno. Naj bo velikodušna in ne natančna. Sistematično podcenjevanje pomeni onemogočanje zaščite točno takrat, ko bi bila koristna.
Takojšnje vračilo nadzora
Pri obdelavi, ki traja več minut, čakanje odjemalca HTTP ni več izvedljivo: časovne omejitve posrednika, brskalnika in uravnotežilnika obremenitve bodo sprožene, preden končaš. Vzorec spletnega trnka (webhook) obrne odgovornost. Tvoja končna točka sprejme zahtevo, takoj vrne ID naloge in obvesti klicatelja, ko je rezultat na voljo, ne da bi zahtevala periodično anketiranje.
from fastapi import FastAPI, BackgroundTasks
app = FastAPI()
@app.post("/api/analyze")
async def start_analysis(
request: dict,
background_tasks: BackgroundTasks,
):
"""Začne ozadnjo analizo in obvesti prek spletnega trnka."""
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,
):
"""Izvede analizo in pošlje rezultat prek spletnega trnka."""
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,
})
Vrnjeni ID in povezano stanje vedno shrani kamor koli trajno. Spletni trnek se lahko izgubi, klicatelj pa mora ohraniti možnost, da rezultat pridobi sam.
Ključne ugotovitve
- Uporabi asinhrone čakalne vrste za ločevanje vnosa od obdelave
- Implementiraj omejevalnik hitrosti za spoštovanje kvot OpenAI
- Obravnavaj ponovne poskuse z eksponentnim zamikom v svojih delavcih
- Pri dolgih opravilih daj prednost vzorcu spletnega trnka pred anketiranjem