Arkitektur asynkron och köer
På denna sida
Varför du aldrig ska blockera på ett LLM-anrop
Ett API-anrop till en språkmodell tar mellan en och trettio sekunder, beroende på vilken modell det är och hur komplex begäran är. Trettio sekunder är en evighet för en serverprocess: under den tiden gör den väntande tråden ingenting, men den upptar ändå en plats. Multiplicera detta med hundra samtidiga begäranden, så kraschar din applikation inte för att den beräknar för mycket, utan för att den väntar för mycket.
En asynkron arkitektur backed av en kö löser tre problem på en gång. Den absorberar trafiktoppar eftersom kön växer istället för att neka begäranden. Den centraliserar logiken för återförsök, eftersom en misslyckad uppgift returnerar till kön istället för att försvinna tillsammans med HTTP-begäran som utlöste den. Och den kopplar bort dina tjänster: komponenten som tar emot begäranden behöver inte längre veta hur länge den exekverande komponenten tar på sig att bearbeta dem.
Mönstret Producent / Konsument
Den grundläggande strukturen bygger på två objekt. En uppgift beskriver vad som behöver göras och den aktuella bearbetningsstatusen; en kö distribuerar dessa uppgifter till en pool av arbetare som konsumerar dem parallellt. Att modellera status som en enumeration istället för en fri textsträng undviker den vanligaste klassen av buggar i denna typ av kod: två delar av programmet som skriver "terminee" respektive "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:
"""Asynkron kö för LLM-anrop."""
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:
"""Lägger till en uppgift i kön."""
self.results[task.id] = task
await self.queue.put(task)
return task.id
async def worker(self, worker_id: int):
"""Arbetare som bearbetar uppgifter från kön."""
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):
"""Startar arbetarna."""
workers = [
asyncio.create_task(self.worker(i))
for i in range(self.num_workers)
]
return workers
async def wait_completion(self):
"""Väntar tills alla uppgifter är bearbetade."""
await self.queue.join()
Två detaljer i denna arbetare förtjänar din uppmärksamhet eftersom de förekommer i varje implementation i verkliga scenarier. Räknaren attempts lever på själva uppgiften, inte på arbetaren, vilket gör att vilken annan arbetare som helst kan plocka upp en återköad uppgift utan att förlora dess historik. Anropet task_done() sitter inuti ett finally-block för att garantera att kön aldrig hänger sig på obestämd tid om ett oväntat undantag kringgår except-blocket: utan detta är ett join() som aldrig returnerar symptomet, och det är smärtsamt att diagnostisera.
På anroparsidan är användningen enkel: starta arbetarna, köa upp uppgifter, vänta, samla in resultat och stoppa.
async def process_documents(documents: list[str]):
queue = ProcessingQueue(num_workers=10)
workers = await queue.start()
# Lägg till uppgifter
for i, doc in enumerate(documents):
task = Task(
id=f"doc-{i}",
prompt=f"Sammanfatta detta dokument: {doc}",
)
await queue.add(task)
# Vänta på slutförande
await queue.wait_completion()
# Samla in resultat
for task_id, task in queue.results.items():
print(f"{task_id}: {task.status.value}")
# Stoppa arbetare
for w in workers:
w.cancel()
Att respektera kvoter istället för att träffa dem
OpenAI tillämpar två samtidiga gränser: begäranden per minut och tokens per minut. En pool på tio arbetare som skickar allt de kan kommer att träffa den ena eller den andra, få felmeddelanden om hastighetsbegränsning, försöka igen och förvärra trängseln. Det är bättre att frivilligt drossla uppströms än att bli nekad nedströms.
Begränsaren nedan tillämpar en token bucket över ett glidande fönster på en minut. Den underhåller två historiker – tidsstämplar för senaste begäranden och par av tidsstämpel/token – rensar poster som fallit ur fönstret, och väntar sedan om någon av gränserna skulle överskridas. Låset asyncio är avgörande: utan det skulle tio arbetare utvärdera samma situation samtidigt och alla tio skulle besluta att det fortfarande finns utrymme.
import asyncio
import time
class RateLimiter:
"""Hastighetsbegränsare baserad på en token bucket."""
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äntar om det behövs för att respektera gränser."""
async with self.lock:
now = time.time()
window = 60.0
# Rensa poster utanför fönstret
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
]
# Kontrollera RPM
if len(self.recent_requests) >= self.rpm:
wait_time = self.recent_requests[0] + window - now
await asyncio.sleep(wait_time)
# Kontrollera 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))
Parametern estimated_tokens förtjänar ett ord: du känner inte den faktiska kostnaden förrän svaret kommer, så du arbetar med en uppskattning. Gör den generös snarare än precis. Att systematiskt underskatta mängder motsvarar att inaktivera skyddet exakt när det skulle vara användbart.
Att returnera kontrollen omedelbart
För bearbetning som tar flera minuter är det inte längre genomförbart att få en HTTP-klient att vänta: proxy, webbläsare och load balancer-timeouts kommer att kicka in innan du är klar. Webhook-mönstret vänder på ansvaret. Din endpoint accepterar begäran, returnerar omedelbart ett uppgifts-ID och notifierar anroparen när resultatet finns, utan att kräva periodisk polling.
from fastapi import FastAPI, BackgroundTasks
app = FastAPI()
@app.post("/api/analyze")
async def start_analysis(
request: dict,
background_tasks: BackgroundTasks,
):
"""Startar en bakgrundsanalys och notifierar via 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,
):
"""Kör analysen och skickar resultatet via 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,
})
Spara alltid det returnerade ID:t och tillhörande tillstånd någonstans beständigt. En webhook kan gå förlorad, och anroparen måste behålla möjligheten att hämta resultatet själva.
Viktiga punkter
- Använd asynkrona köer för att koppla bort intag från bearbetning
- Implementera en hastighetsbegränsare för att respektera OpenAI:s kvoter
- Hantera återförsök med exponentiell backoff i dina arbetare
- För långvariga uppgifter, föredra ett webhook-mönster framför polling