Asinchroninė architektūra ir eilės
Šiame puslapyje
Kodėl niekada neturėtum blokuoti kviesdamas LLM
API užklausa kalbos modeliui trunka nuo vienos iki trisdešimties sekundžių, priklausomai nuo modelio ir užklausos sudėtingumo. Serverio procesui trisdešimt sekundžių yra amžinybė: tuo metu laukiantis gijas nieko neveikia, tačiau vis tiek užima vietą. Padaugink tai iš šimto vienu metu vykdomų užklausų ir tavo programa žlugs ne todėl, kad atlieka per daug skaičiavimų, o todėl, kad per daug laukia.
Asinchroninė architektūra, paremta eile, vienu metu išsprendžia tris problemas. Ji sugeria srauto šuolius, nes eilė auga vietoj to, kad atmestų užklausas. Ji centralizuoja kartojimo logiką, nes nepavykęs uždavinys grįžta į eilę vietoj to, kad dingtų kartu su jį sukėlusia HTTP užklausa. Be to, ji atskiria tavo servisus: komponentas, gaunantis užklausas, nebeturi žinoti, kiek laiko vykdančiam komponentui prireiks joms apdoroti.
Gamintojo / Vartotojo šablonas
Pagrindinė struktūra remiasi dviem objektais. Uždavinys aprašo, ką reikia atlikti, ir dabartinę apdorojimo būseną; eilė paskirsto šiuos uždavinius darbuotojų baseinui, kuris juos vykdo lygiagrečiai. Būsenos modeliavimas kaip enumeracija, o ne laisvos formos eilutė, padeda išvengti dažniausiai pasitaikančių klaidų tokio tipo kode: kai dvi programos dalys rašo "terminee" ir "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:
"""Asinchroninė eilė LLM užklausoms."""
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:
"""Prideda uždavinį į eilę."""
self.results[task.id] = task
await self.queue.put(task)
return task.id
async def worker(self, worker_id: int):
"""Darbuotojas, apdorojantis uždavinius iš eilės."""
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):
"""Paleidžia darbuotojus."""
workers = [
asyncio.create_task(self.worker(i))
for i in range(self.num_workers)
]
return workers
async def wait_completion(self):
"""Laukia, kol visi uždaviniai bus apdoroti."""
await self.queue.join()
Du šio darbuotojo aspektai nusipelno tavo dėmesio, nes jie pasitaiko kiekviename realiame įgyvendinime. Skaitiklis attempts saugomas pačiame uždavinyje, o ne darbuotojo atmintyje, todėl bet kuris kitas darbuotojas gali perimti iš naujo į eilę įdėtą uždavinį neprarandant jo istorijos. Kvietimas task_done() yra finally bloke, kad būtų garantuota, jog eilė niekada neužstrigs neribotam laikui, jei netikėta išimtis apeitų except bloką: be jo, niekada negrįžtantis join() būtų simptomas, kurį diagnozuoti yra labai sunku.
Kviečiančiojo pusėje naudojimas yra paprastas: paleisk darbuotojus, įdėk uždavinius į eilę, palauk, surink rezultatus ir sustabdyk.
async def process_documents(documents: list[str]):
queue = ProcessingQueue(num_workers=10)
workers = await queue.start()
# Pridėti uždavinius
for i, doc in enumerate(documents):
task = Task(
id=f"doc-{i}",
prompt=f"Apibendrink šį dokumentą: {doc}",
)
await queue.add(task)
# Laukti pabaigos
await queue.wait_completion()
# Surinkti rezultatus
for task_id, task in queue.results.items():
print(f"{task_id}: {task.status.value}")
# Sustabdyti darbuotojus
for w in workers:
w.cancel()
Kvotų laikymasis vietoj jų viršijimo
OpenAI taiko dvi vienu metu galiojančias ribas: užklausų skaičių per minutę ir tokenų skaičių per minutę. Dešimties darbuotojų baseinas, siunčiantis viską, ką gali, greitai pasieks vieną iš šių ribų, gaus ribojimo klaidas, bandys kartoti ir tik dar labiau padidins spūstis. Geriau savanoriškai sulėtinti veiksmą pirminėje grandyje, nei būti atmestam galutinėje.
Toliau pateiktas ribotuvas taiko tokenų kibirą slenkančio vienos minutės lango principu. Jis saugo dvi istorijas – neseniai atliktų užklausų laiko žymas ir laiko žymų bei tokenų poras – išvalo įrašus, kurie iškrito iš lango, ir laukia, jei būtų viršyta bet kuri riba. asyncio užraktas yra būtinas: be jo dešimt darbuotojų vienu metu įvertintų tą pačią situaciją ir visi dešimt nuspręstų, kad dar yra vietos.
import asyncio
import time
class RateLimiter:
"""Ribotuvas, pagrįstas tokenų kibiru."""
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):
"""Laukia, jei reikia, kad būtų laikomasi ribų."""
async with self.lock:
now = time.time()
window = 60.0
# Išvalyti įrašus už lango ribų
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
]
# Tikrinti RPM (užklausos per minutę)
if len(self.recent_requests) >= self.rpm:
wait_time = self.recent_requests[0] + window - now
await asyncio.sleep(wait_time)
# Tikrinti TPM (tokenai per minutę)
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))
Parametras estimated_tokens nusipelno komentarų: tikrosios kainos nežinai, kol negauni atsakymo, todėl dirbi su įverčiu. Geriau jį nustatyti dosniau nei tiksliai. Sistemingas įverčių mažinimas reiškia apsaugos išjungimą būtent tada, kai ji būtų naudingiausia.
Momentinis valdymo grąžinimas
Kai apdorojimas trunka kelias minutes, HTTP kliento laukimas tampa nebeįmanomas: proxy, naršyklės ir apkrovos balansuotojo laiko limitai suveiks anksčiau, nei baigsi darbą. „Webhook“ šablonas apverčia atsakomybę. Tavo galinis taškas priima užklausą, iškart grąžina uždavinio ID ir praneša kvietėjui, kai rezultatas yra paruoštas, nereikalaujant periodinio apklausimo.
from fastapi import FastAPI, BackgroundTasks
app = FastAPI()
@app.post("/api/analyze")
async def start_analysis(
request: dict,
background_tasks: BackgroundTasks,
):
"""Pradeda foninę analizę ir praneša per webhook."""
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,
):
"""Vykdo analizę ir siunčia rezultatą per webhook."""
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,
})
Visada saugok grąžintą ID ir susijusią būseną patikimoje saugykloje. Webhook gali pasimesti, o kvietėjas privalo išlaikyti galimybę pats gauti rezultatą.
Svarbiausi punktai
- Naudok asinchronines eiles, kad atskirtum duomenų priėmimą nuo apdorojimo
- Įgyvendink ribotuvą, kad laikytumeisi OpenAI kvotų
- Darbuotojuose tvarkyk kartojimus naudodamas eksponentinį delsą
- Ilgai trunkantiems uždaviniams vietoj apklausimo rinkis webhook šabloną