Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Asinhrona arhitektura in čakalne vrste

Lekcija 7 od 20 Posodobljeno 28. julij 2026 Napredni
Na tej strani
  1. Zakaj nikoli ne blokiraš klica LLM
  2. Vzorec proizvajalec / potrošnik
  3. Spoštovanje kvot namesto trčenja ob njih
  4. Takojšnje vračilo nadzora
  5. Ključne ugotovitve

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