Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Arkitektur asynkron och köer

Lektion 7 av 20 Uppdaterad 28 juli 2026 Avancerad
På denna sida
  1. Varför du aldrig ska blockera på ett LLM-anrop
  2. Mönstret Producent / Konsument
  3. Att respektera kvoter istället för att träffa dem
  4. Att returnera kontrollen omedelbart
  5. Viktiga punkter

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