Μετάβαση στο κύριο περιεχόμενο
Ελληνικά— Επιλέξτε γλώσσα
Μενού

Ασύγχρονη Αρχιτεκτονική και Ουρές

Μάθημα 7 / 20 Ενημερώθηκε 28 Ιουλίου 2026 Προχωρημένος
Σε αυτήν τη σελίδα
  1. Γιατί δεν μπλοκάρετε ποτέ σε μια κλήση LLM
  2. Το Πρότυπο Producer / Consumer
  3. Σεβασμός των Ποσοστώσεων Αντί για Παραβίασή τους
  4. Άμεση Επιστροφή Ελέγχου
  5. Βασικά σημεία

Γιατί δεν μπλοκάρετε ποτέ σε μια κλήση LLM

Μια κλήση API σε ένα γλωσσικό μοντέλο διαρκεί μεταξύ ενός και τριάντα δευτερολέπτων, ανάλογα με το μοντέλο και την πολυπλοκότητα του αιτήματος. Τα τριάντα δευτερόλεπτα είναι μια αιωνιότητα για μια διαδικασία διακομιστή: κατά τη διάρκεια αυτού του χρόνου, το νήμα που περιμένει δεν κάνει τίποτα, παρόλα αυτά καταλαμβάνει ακόμα μια υποδοχή. Πολλαπλασιάστε το με εκατό ταυτόχρονα αιτήματα και η εφαρμογή σας θα καταρρεύσει όχι επειδή υπολογίζει πάρα πολλά, αλλά επειδή περιμένει πάρα πολύ.

Μια ασύγχρονη αρχιτεκτονική που υποστηρίζεται από μια ουρά λύνει τρία προβλήματα ταυτόχρονα. Απορροφά τις αιχμές της κίνησης, καθώς η ουρά μεγαλώνει αντί να απορρίπτει αιτήματα. Κεντρικοποιεί τη λογική επαναλήψεων (retry), επειδή μια αποτυχημένη εργασία επιστρέφει στην ουρά αντί να εξαφανίζεται μαζί με το HTTP αίτημα που την προκάλεσε. Και αποσυνδέει τις υπηρεσίες σας: το στοιχείο που λαμβάνει αιτήματα δεν χρειάζεται πλέον να γνωρίζει πόσο χρόνο χρειάζεται το στοιχείο εκτέλεσης για να τα επεξεργαστεί.

Το Πρότυπο Producer / Consumer

Η βασική δομή βασίζεται σε δύο αντικείμενα. Μια εργασία (task) περιγράφει τι πρέπει να γίνει και την τρέχουσα κατάσταση επεξεργασίας· μια ουρά διανέμει αυτές τις εργασίες σε ένα pool εργαζομένων (workers) που τις καταναλώνουν παράλληλα. Η μοντελοποίηση της κατάστασης ως απαρίθμηση (enumeration) αντί για συμβολοσειρά ελεύθερης μορφής αποφεύγει την πιο κοινή κατηγορία σφαλμάτων σε αυτόν τον τύπο κώδικα: δύο μέρη του προγράμματος να γράφουν "terminee" και "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:
    """Ασύγχρονη ουρά για κλήσεις 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:
        """Προσθέτει μια εργασία στην ουρά."""
        self.results[task.id] = task
        await self.queue.put(task)
        return task.id

    async def worker(self, worker_id: int):
        """Εργαζόμενος που επεξεργάζεται εργασίες από την ουρά."""
        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):
        """Ξεκινά τους εργαζόμενους."""
        workers = [
            asyncio.create_task(self.worker(i))
            for i in range(self.num_workers)
        ]
        return workers

    async def wait_completion(self):
        """Περιμένει μέχρι να επεξεργαστούν όλες οι εργασίες."""
        await self.queue.join()

Δύο λεπτομέρειες σε αυτόν τον εργαζόμενο αξίζουν την προσοχή σας επειδή εμφανίζονται σε κάθε υλοποίηση στον πραγματικό κόσμο. Ο μετρητής attempts βρίσκεται στην ίδια την εργασία, όχι στον εργαζόμενο, επιτρέποντας σε οποιονδήποτε άλλο εργαζόμενο να παραλάβει μια εργασία που έχει ξαναμπεί στην ουρά χωρίς να χάσει το ιστορικό της. Η κλήση task_done() βρίσκεται μέσα σε ένα μπλοκ finally για να εγγυηθεί ότι η ουρά δεν θα μπλοκάρει επ’ αόριστον εάν μια απροσδόκητη εξαίρεση παρακάμψει το μπλοκ except: χωρίς αυτό, ένα join() που δεν επιστρέφει ποτέ είναι το σύμπτωμα και είναι οδυνηρό να διαγνωστεί.

Στην πλευρά του καλούντος, η χρήση είναι απλή: ξεκινήστε τους εργαζόμενους, βάλτε τις εργασίες στην ουρά, περιμένετε, συλλέξτε τα αποτελέσματα και σταματήστε.

async def process_documents(documents: list[str]):
    queue = ProcessingQueue(num_workers=10)
    workers = await queue.start()

    # Προσθήκη εργασιών
    for i, doc in enumerate(documents):
        task = Task(
            id=f"doc-{i}",
            prompt=f"Summarize this document: {doc}",
        )
        await queue.add(task)

    # Αναμονή ολοκλήρωσης
    await queue.wait_completion()

    # Συλλογή αποτελεσμάτων
    for task_id, task in queue.results.items():
        print(f"{task_id}: {task.status.value}")

    # Διακοπή εργαζομένων
    for w in workers:
        w.cancel()

Σεβασμός των Ποσοστώσεων Αντί για Παραβίασή τους

Το OpenAI επιβάλλει δύο ταυτόχρονα όρια: αιτήματα ανά λεπτό και tokens ανά λεπτό. Ένα pool δέκα εργαζομένων που στέλνουν ό,τι μπορούν θα χτυπήσει το ένα ή το άλλο όριο, θα λάβει σφάλματα ορίου ρυθμού (rate limit errors), θα κάνει επανάληψη και θα επιδεινώσει τον συμφόρηση. Είναι καλύτερο να επιβραδύνετε εθελοντικά ανάντη (upstream) παρά να απορριφθείτε κατάντη (downstream).

Ο περιοριστής παρακάτω εφαρμόζει έναν κάδο tokens (token bucket) σε ένα ολισθαίνον παράθυρο ενός λεπτού. Διατηρεί δύο ιστορικά—χρονικές σφραγίδες πρόσφατων αιτημάτων και ζεύγη χρονικής σφραγίδας/token—καθαρίζει τις εγγραφές που έχουν βγει εκτός παραθύρου και μετά περιμένει εάν θα παραβιαζόταν οποιοδήποτε από τα όρια. Το κλείδωμα asyncio είναι απαραίτητο: χωρίς αυτό, δέκα εργαζόμενοι θα αξιολογούσαν την ίδια κατάσταση ταυτόχρονα και και οι δέκα θα αποφάσιζαν ότι υπάρχει ακόμα χώρος.

import asyncio
import time

class RateLimiter:
    """Περιοριστής ρυθμού βασισμένος σε κάδο tokens."""

    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):
        """Περιμένει εάν είναι απαραίτητο για τον σεβασμό των ορίων."""
        async with self.lock:
            now = time.time()
            window = 60.0

            # Καθαρισμός εγγραφών εκτός παραθύρου
            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
            ]

            # Έλεγχος RPM
            if len(self.recent_requests) >= self.rpm:
                wait_time = self.recent_requests[0] + window - now
                await asyncio.sleep(wait_time)

            # Έλεγχος 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))

Η παράμετρος estimated_tokens αξίζει μια αναφορά: δεν γνωρίζετε το πραγματικό κόστος μέχρι να φτάσει η απάντηση, οπότε εργάζεστε με μια εκτίμηση. Κάντε την γενναιόδωρη αντί για ακριβή. Η συστηματική υποεκτίμηση ισοδυναμεί με απενεργοποίηση της προστασίας ακριβώς όταν θα ήταν χρήσιμη.

Άμεση Επιστροφή Ελέγχου

Για επεξεργασία που διαρκεί αρκετά λεπτά, το να κάνετε έναν HTTP πελάτη να περιμένει δεν είναι πλέον βιώσιμο: τα χρονικά όρια (timeouts) του proxy, του browser και του load balancer θα ενεργοποιηθούν πριν τελειώσετε. Το πρότυπο webhook αντιστρέφει την ευθύνη. Το endpoint σας δέχεται το αίτημα, επιστρέφει αμέσως ένα ID εργασίας και ειδοποιεί τον καλούντα όταν υπάρχει το αποτέλεσμα, χωρίς να απαιτείται περιοδική polling.

from fastapi import FastAPI, BackgroundTasks

app = FastAPI()

@app.post("/api/analyze")
async def start_analysis(
    request: dict,
    background_tasks: BackgroundTasks,
):
    """Ξεκινά μια ανάλυση στο παρασκήνιο και ειδοποιεί μέσω 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,
):
    """Εκτελεί την ανάλυση και στέλνει το αποτέλεσμα μέσω 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,
            })

Αποθηκεύετε πάντα το επιστρεφόμενο ID και την associated κατάσταση κάπου ανθεκτικά (durable). Ένα webhook μπορεί να χαθεί και ο καλών πρέπει να διατηρήσει τη δυνατότητα να ανακτήσει ο ίδιος το αποτέλεσμα.

Βασικά σημεία

  • Χρησιμοποιήστε ασύγχρονες ουρές για να αποσυνδέσετε την εισαγωγή δεδομένων από την επεξεργασία
  • Υλοποιήστε έναν περιοριστή ρυθμού για να σεβαστείτε τις ποσοστώσεις του OpenAI
  • Διαχειριστείτε τις επαναλήψεις με εκθετική καθυστέρηση (exponential backoff) στους εργαζόμενούς σας
  • Για εργασίες μεγάλης διάρκειας, προτιμήστε το πρότυπο webhook αντί της polling