Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Arhitektūra asinhronai un rindas

Nodarbība 7 no 20 Atjaunota 2026. gada 28. jūlijs Augstākais
Šajā lapā
  1. Kāpēc nekad nebloķēt uz LLM izsaukumu
  2. Ražotāja / patērētāja raksts
  3. Ievēro kvotas, nevis sasniedz tās
  4. Tūlītēja kontroles atgriešana
  5. Galvenās atziņas

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