Arhitektūra asinhronai un rindas
Šajā lapā
Kāpēc nekad nebloķēt uz LLM izsaukumu
API izsaukums uz valodu modeli ilgst no vienas līdz trīsdesmit sekundēm atkarībā no modeļa un pieprasījuma sarežģītības. Trīsdesmit sekundes servera procesam ir mūžība: šajā laikā gaidošais pavediens nedara neko, taču joprojām aizņem slotu. Reizini to ar simtu vienlaicīgiem pieprasījumiem, un tava lietotne sabrūk nevis tāpēc, ka tā aprēķina pārāk daudz, bet gan tāpēc, ka tā pārāk ilgi gaida.
Asinhrona arhitektūra, ko atbalsta rinda, atrisina trīs problēmas vienlaikus. Tā absorbē satiksmes pīķus, jo rinda aug, nevis noraida pieprasījumus. Tā centralizē atkārtotu mēģinājumu loģiku, jo neizdevies uzdevums atgriežas rindā, nevis pazūd kopā ar HTTP pieprasījumu, kas to izraisīja. Un tā atsaista tavus servisus: komponents, kas saņem pieprasījumus, vairs nedrīkst zināt, cik ilgi izpildošajam komponentam nepieciešams to apstrādei.
Ražotāja / patērētāja raksts
Pamata struktūra balstās uz diviem objektiem. Uzdevums apraksta, kas jādara, un pašreizējo apstrādes statusu; rinda izplata šos uzdevumus strādnieku baseinam, kas tos patērē paralēli. Statusa modelēšana kā enumerācija, nevis brīvas formas virkne, novērš visbiežāk sastopamo kļūdu klasi šāda veida kodā: divas programmas daļas raksta "terminee" un "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 rinda LLM izsaukumiem."""
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:
"""Pievieno uzdevumu rindai."""
self.results[task.id] = task
await self.queue.put(task)
return task.id
async def worker(self, worker_id: int):
"""Strādnieks, kas apstrādā uzdevumus no rindas."""
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):
"""Sāk strādniekus."""
workers = [
asyncio.create_task(self.worker(i))
for i in range(self.num_workers)
]
return workers
async def wait_completion(self):
"""Gaida, līdz visi uzdevumi ir apstrādāti."""
await self.queue.join()
Divas detaļas šajā strādniekā ir pelnījušas tavu uzmanību, jo tās parādās katrā reālā implementācijā. Skaitītājs attempts dzīvo pašā uzdevumā, nevis strādniekā, ļaujot jebkuram citam strādniekam paņemt atkārtoti rindotu uzdevumu, nezaudējot tā vēsturi. Izsaukums task_done() atrodas blokā finally, lai garantētu, ka rinda nekad neiekarsēs uz nenoteiktu laiku, ja negaidīts izņēmums apej bloku except: bez tā simptoms ir join(), kas nekad neatgriežas, un to ir sāpīgi diagnosticēt.
Izsaucošajā pusē lietojums ir vienkāršs: sāc strādniekus, ievieto uzdevumus rindā, pagaidi, savāc rezultātus un apturi.
async def process_documents(documents: list[str]):
queue = ProcessingQueue(num_workers=10)
workers = await queue.start()
# Pievieno uzdevumus
for i, doc in enumerate(documents):
task = Task(
id=f"doc-{i}",
prompt=f"Summarize this document: {doc}",
)
await queue.add(task)
# Gaida pabeigšanu
await queue.wait_completion()
# Savāc rezultātus
for task_id, task in queue.results.items():
print(f"{task_id}: {task.status.value}")
# Aptur strādniekus
for w in workers:
w.cancel()
Ievēro kvotas, nevis sasniedz tās
OpenAI piemēro divus vienlaicīgus limitus: pieprasījumi minūtē un tokeni minūtē. Desmit strādnieku baseins, kas sūta visu, ko spēj, sasniegs vienu vai otru, saņems ātruma limita kļūdas, mēģinās vēlreiz un pasliktinās sastrēgumu. Labāk ir brīvprātīgi palēnināties augšupplūsmā, nekā tikt noraidītam lejupplūsmā.
Zemāk esošais limitētājs pielieto tokena spaini slīdošā vienas minūtes logā. Tas uztur divas vēstures — nesenos pieprasījumus laika zīmogus un laika zīmoga/tokenu pārus —, attīra ierakstus, kas ir izkrituši no loga, un tad gaida, ja tiktu pārsniegts kāds no limitiem. Bloķēšana asyncio ir būtiska: bez tās desmit strādnieki vienlaikus novērtētu to pašu situāciju, un visi desmit izlemtu, ka vēl ir vieta.
import asyncio
import time
class RateLimiter:
"""Ātruma limitētājs, kas balstīts uz tokena spaini."""
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):
"""Gaida, ja nepieciešams, lai ievērotu limitus."""
async with self.lock:
now = time.time()
window = 60.0
# Attīra ierakstus ārpus loga
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
]
# Pārbauda RPM
if len(self.recent_requests) >= self.rpm:
wait_time = self.recent_requests[0] + window - now
await asyncio.sleep(wait_time)
# Pārbauda 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))
Parametrs estimated_tokens ir pelnījis piezīmi: tu nezini faktiskās izmaksas, kamēr neatnāk atbilde, tāpēc strādā ar aplēsi. Padari to dāsnu, nevis precīzu. Sistemātiska nepietiekama novērtēšana nozīmē aizsardzības atslēgšanu tieši tad, kad tā būtu noderīga.
Tūlītēja kontroles atgriešana
Apstrādei, kas ilgst vairākas minūtes, HTTP klienta gaidīšana vairs nav iespējama: starpniekservera, pārlūka un slodzes līdzsvarotāja noilgumi iedarbosies, pirms tu būsi pabeidzis. Webhook raksts apgriež atbildību. Tavs galapunkts pieņem pieprasījumu, nekavējoties atgriež uzdevuma ID un paziņo izsaucošajai pusei, kad rezultāts ir pieejams, neprasa periodisku aptauju.
from fastapi import FastAPI, BackgroundTasks
app = FastAPI()
@app.post("/api/analyze")
async def start_analysis(
request: dict,
background_tasks: BackgroundTasks,
):
"""Sāk fona analīzi un paziņo, izmantojot 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,
):
"""Veic analīzi un nosūta rezultātu, izmantojot 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,
})
Vienmēr glabā atgriezto ID un saistīto stāvokli kaut kur ilgtspējīgā vietā. Webhook var pazust, un izsaucošajai pusei ir jāsaglabā iespēja pašai iegūt rezultātu.
Galvenās atziņas
- Izmanto asinhronas rindas, lai atsaistu uzņemšanu no apstrādes
- Implementē ātruma limitētāju, lai ievērotu OpenAI kvotas
- Apstrādā atkārtotus mēģinājumus ar eksponenciālu atkāpšanos savos strādniekos
- Ilgstošiem uzdevumiem dod priekšroku webhook rakstam, nevis aptaujai