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

Αρχιτεκτονική παραγωγής: παρακολούθηση, ειδοποιήσεις, κλιμάκωση

Μάθημα 20 / 20 Ενημερώθηκε 3 Νοεμβρίου 2026 Προχωρημένος
Σε αυτήν τη σελίδα
  1. Η εφαρμογή σας σε παραγωγή: οι τρεις πυλώνες
  2. Παρατηρήστε: τι να μετράτε
  3. Αντιδράστε: βαθμιδωτές ειδοποιήσεις
  4. Απορροφήστε: τρεις μηχανισμοί ανθεκτικότητας
  5. Λίστα ελέγχου ανάπτυξης σε παραγωγή
  6. Βασικά σημεία
  7. Δοκιμάστε τις γνώσεις σας

Η εφαρμογή σας σε παραγωγή: οι τρεις πυλώνες

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

Παρατηρήστε: τι να μετράτε

Τέσσερις οικογένειες μετρικών καλύπτουν τα βασικά: όγκος κλήσεων, λανθάνουσα χρόνος (latency), σφάλματα και κόστος, αναλυόμενα ανά μοντέλο. Η ανάλυση ανά μοντέλο είναι αυτό που καθιστά τον πίνακα ελέγχου (dashboard) actionable—ένα γενικό ποσοστό σφάλματος 3% δεν σας λέει τίποτα, ενώ το ίδιο νούμερο συγκεντρωμένο σε ένα μόνο μοντέλο δείχνει αμέσως τον υπαίτιο.

Η παρακάτω κλάση συσσωρεύει αυτές τις μετρικές στη μνήμη, χρησιμοποιώντας ένα ολισθαίνον παράθυρο 10.000 τιμών λανθάνοντος χρόνου για να αποτρέψει την ατέρμονη ανάπτυξη της διαδικασίας. Σημειώστε τη χρήση των εκατοστημορίων (percentiles) αντί των μέσων όρων: ο μέσος όρος λανθάνοντος χρόνου μιας υπηρεσίας LLM είναι σχεδόν πάντα παραπλανητικός, επειδή μια χούφτα πολύ αργές κλήσεις «χάνονται» στον μέσο όρο, παρόλο που αυτές είναι ακριβώς εκείνες για τις οποίες παραπονιούνται οι χρήστες σας.

import time
from dataclasses import dataclass, field
from collections import defaultdict

@dataclass
class ProductionMetrics:
    """Collects essential production metrics."""

    counters: dict = field(default_factory=lambda: defaultdict(int))
    latencies: dict = field(default_factory=lambda: defaultdict(list))
    errors: dict = field(default_factory=lambda: defaultdict(int))
    costs: dict = field(default_factory=lambda: defaultdict(float))

    def record_call(
        self,
        model: str,
        latency: float,
        input_tokens: int,
        output_tokens: int,
        cost: float,
        success: bool,
    ):
        self.counters[model] += 1
        self.latencies[model].append(latency)
        self.costs[model] += cost

        if not success:
            self.errors[model] += 1

        # Keep only the last 10,000 latencies
        if len(self.latencies[model]) > 10_000:
            self.latencies[model] = self.latencies[model][-10_000:]

    def percentile(self, model: str, p: float) -> float:
        """Calculates a latency percentile."""
        values = sorted(self.latencies.get(model, []))
        if not values:
            return 0.0
        idx = int(len(values) * p / 100)
        return values[min(idx, len(values) - 1)]

    def error_rate(self, model: str) -> float:
        total = self.counters.get(model, 0)
        if total == 0:
            return 0.0
        return self.errors.get(model, 0) / total

    def dashboard(self) -> dict:
        """Generates a complete dashboard."""
        dashboard = {}
        for model in self.counters:
            dashboard[model] = {
                "calls": self.counters[model],
                "latency_p50": f"{self.percentile(model, 50):.2f}s",
                "latency_p99": f"{self.percentile(model, 99):.2f}s",
                "error_rate": f"{self.error_rate(model):.2%}",
                "total_cost": f"${self.costs[model]:.2f}",
            }
        return dashboard

Φυσικά, η συλλογή πρέπει να είναι συστηματική. Η χειροκίνητη instrumentation κάθε κλήσης εγγυάται ότι θα ξεχάσετε μία—και πιθανότατα αυτή που θα προκαλέσει προβλήματα. Ο διακοσμητής (decorator) παρακάτω μεταφέρει τη μέτρηση στο επίπεδο της συνάρτησης κλήσης: το μπλοκ finally καταγράφει τον λανθάνοντα χρόνο και την επιτυχία ανεξάρτητα από το τι συμβαίνει, ακόμα και όταν μια εξαίρεση διαδίδεται.

import openai
import functools

metrics = ProductionMetrics()

def monitor(func):
    """Decorator that monitors every API call."""
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        model = kwargs.get("model", args[0] if args else "unknown")
        start = time.perf_counter()
        success = True

        try:
            result = func(*args, **kwargs)
            return result
        except Exception as e:
            success = False
            raise
        finally:
            latency = time.perf_counter() - start
            metrics.record_call(
                model=model,
                latency=latency,
                input_tokens=0,
                output_tokens=0,
                cost=0,
                success=success,
            )

    return wrapper

Οι μετρητές token και το κόστος παραμένουν μηδέν σε αυτή την έκδοση, επειδή το αντικείμενο απόκρισης δεν είναι διαθέσιμο κατά τη στιγμή της εγγραφής. Συμπληρώστε τα διαβάζοντας τα πεδία χρήσης (usage) που επιστρέφει το API: χωρίς αυτές τις πληροφορίες, ο πίνακας ελέγχου σας θα εμφανίζει πιστά μια στήλη με μηδενικά κόστη.

Αντιδράστε: βαθμιδωτές ειδοποιήσεις

Μια ειδοποίηση έχει αξία μόνο αν απαιτεί δράση. Γι’ αυτό το σύστημα διακρίνει δύο κατώφλια ανά μετρική: ένα κατώφλι προειδοποίησης, που σηματοδοτεί μια απόκλιση προς εξέταση κατά τη διάρκεια της ημέρας, και ένα κατώφλι κρίσιμου σφάλματος, που δικαιολογεί το ξύπνημα κάποιου. Η σύγχυση μεταξύ των δύο παράγει το χειρότερο δυνατό αποτέλεσμα—μια ομάδα που έχει μάθει να αγνοεί τις ειδοποιήσεις.

from enum import Enum

class AlertLevel(Enum):
    INFO = "info"
    WARNING = "warning"
    CRITICAL = "critical"

class AlertSystem:
    """Triggers alerts based on metrics."""

    def __init__(self):
        self.thresholds = {
            "error_rate": {"warning": 0.05, "critical": 0.15},
            "latency_p99": {"warning": 10.0, "critical": 30.0},
            "hourly_cost": {"warning": 50.0, "critical": 200.0},
        }
        self.sent_alerts: list[dict] = []

    def check(self, metrics: ProductionMetrics) -> list[dict]:
        """Checks metrics and generates alerts."""
        alerts = []

        for model in metrics.counters:
            # Error rate
            rate = metrics.error_rate(model)
            if rate >= self.thresholds["error_rate"]["critical"]:
                alerts.append({
                    "level": AlertLevel.CRITICAL,
                    "message": (
                        f"CRITICAL error rate for {model}: "
                        f"{rate:.1%}"
                    ),
                    "model": model,
                })
            elif rate >= self.thresholds["error_rate"]["warning"]:
                alerts.append({
                    "level": AlertLevel.WARNING,
                    "message": (
                        f"High error rate for {model}: "
                        f"{rate:.1%}"
                    ),
                    "model": model,
                })

            # Latency
            p99 = metrics.percentile(model, 99)
            if p99 >= self.thresholds["latency_p99"]["critical"]:
                alerts.append({
                    "level": AlertLevel.CRITICAL,
                    "message": (
                        f"CRITICAL p99 latency for {model}: "
                        f"{p99:.1f}s"
                    ),
                    "model": model,
                })

        self.sent_alerts.extend(alerts)
        return alerts

    async def notify(self, alerts: list[dict]):
        """Sends notifications (webhook, email, Slack)."""
        import httpx

        for alert in alerts:
            if alert["level"] == AlertLevel.CRITICAL:
                # Immediate notification
                async with httpx.AsyncClient() as http:
                    await http.post(
                        "https://your-webhook.example.com/alerts",
                        json={
                            "level": alert["level"].value,
                            "message": alert["message"],
                        },
                    )

Οι ειδοποιήσεις για το ωριαίο κόστος είναι αυτές που συχνά ξεχνιούνται, και αυτό είναι κρίμα: ένας βρόχος επανάληψης (retry loop) χωρίς όρια ή μια εργασία batch που εκτελείται δύο φορές καταλήγει σε λογαριασμό, όχι σε σφάλμα. Είναι το μόνο δίχτυ ασφαλείας που εντοπίζει αυτόν τον τύπο incident ενώ συμβαίνει.

Απορροφήστε: τρεις μηχανισμοί ανθεκτικότητας

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

class CircuitBreaker:
    """Cuts off calls when too many errors occur."""

    def __init__(
        self,
        open_threshold: int = 5,
        reset_delay: float = 60.0,
    ):
        self.threshold = open_threshold
        self.reset_delay = reset_delay
        self.consecutive_failures = 0
        self.opened_at: float | None = None

    @property
    def is_open(self) -> bool:
        if self.opened_at is None:
            return False
        if time.time() - self.opened_at > self.reset_delay:
            # Attempt to close the circuit
            self.opened_at = None
            self.consecutive_failures = 0
            return False
        return True

    def record_success(self):
        self.consecutive_failures = 0
        self.opened_at = None

    def record_failure(self):
        self.consecutive_failures += 1
        if self.consecutive_failures >= self.threshold:
            self.opened_at = time.time()

    def call(self, func, *args, **kwargs):
        """Executes the function if the circuit is closed."""
        if self.is_open:
            raise RuntimeError(
                "Circuit open — API unavailable. "
                f"Retry in {self.reset_delay}s."
            )
        try:
            result = func(*args, **kwargs)
            self.record_success()
            return result
        except Exception as e:
            self.record_failure()
            raise

Ο διακόπτης κυκλώματος προστατεύει την εφαρμογή σας· δεν την κάνει όμως να λειτουργήσει. Αυτός είναι ο ρόλος της εναλλαγής μοντέλου (model fallback), η οποία δοκιμάζει εναλλακτικές λύσεις με σειρά, παρακάμπτοντας εκείνες των οποίων τα κυκλώματα είναι ήδη ανοιχτά. Ένα σημείο σχεδιασμού που πρέπει να θυμάστε: η σειρά της λίστας είναι επιχειρηματική απόφαση, όχι τεχνική. Τοποθετήστε πρώτα το μοντέλο που παρέχει την αναμενόμενη υπηρεσία, ακολουθούμενο από εκείνα που παρέχουν μια υποβαθμισμένη αλλά αποδεκτή υπηρεσία—μια ελαφρώς λιγότερο οξεία απόκριση είναι προτιμότερη από ένα μήνυμα μη διαθεσιμότητας.

class ModelFallback:
    """Switches to a backup model in case of failure."""

    def __init__(self):
        self.models = ["gpt-5.6-terra", "gpt-5.6-sol", "gpt-5.6-luna"]
        self.circuits = {
            m: CircuitBreaker() for m in self.models
        }

    def call(self, prompt: str) -> str:
        """Tries each model until a response is obtained."""
        client = openai.OpenAI()

        for model in self.models:
            circuit = self.circuits[model]
            if circuit.is_open:
                continue

            try:
                response = circuit.call(
                    client.responses.create,
                    model=model,
                    input=prompt,
                )
                return response.output_text
            except Exception:
                continue

        raise RuntimeError("All models are unavailable.")

Ο τρίτος μηχανισμός αφορά τη διαστασιολόγηση. Η οδήγηση του αριθμού των workers βάσει του μεγέθους της ουράς και όχι του φορτίου CPU είναι ο σωστός αντανακλασμός για μια υπηρεσία που περνάει τον περισσότερο χρόνο της περιμένοντας αποκρίσεις δικτύου: η CPU μένει αδρανής ενώ η ουρά μεγαλώνει. Σημειώστε την ασυμμετρία στον εφαρμοζόμενο κανόνα—διπλασιάζουμε κατά την κλιμάκωση προς τα πάνω και μειώνουμε στο μισό κατά την κλιμάκωση προς τα κάτω, με ευρέως διαχωρισμένα κατώφλια (100 έναντι 10). Αυτό το κενό αποτρέπει την ταλάντωση: χωρίς αυτό, το σύστημα θα περνούσε τον χρόνο του δημιουργώντας και καταστρέφοντας workers γύρω από το σημείο καμπής.

class AutoScaler:
    """Adjusts the number of workers based on load."""

    def __init__(
        self,
        min_workers: int = 2,
        max_workers: int = 50,
        scale_up_threshold: int = 100,
        scale_down_threshold: int = 10,
    ):
        self.min_workers = min_workers
        self.max_workers = max_workers
        self.up_threshold = scale_up_threshold
        self.down_threshold = scale_down_threshold
        self.active_workers = min_workers

    def adjust(self, queue_size: int) -> int:
        """Returns the recommended number of workers."""
        if queue_size > self.up_threshold:
            self.active_workers = min(
                self.active_workers * 2,
                self.max_workers,
            )
        elif queue_size < self.down_threshold:
            self.active_workers = max(
                self.active_workers // 2,
                self.min_workers,
            )

        return self.active_workers

Λίστα ελέγχου ανάπτυξης σε παραγωγή

Αυτό το μάθημα ολοκληρώνεται με τη λίστα ελέγχου που πρέπει να περάσετε πριν ανοίξετε την εφαρμογή σας στο κοινό. Κάθε στοιχείο αναφέρεται σε ένα μάθημα που καλύψατε· αν κάποιο φαίνεται ασαφές, ξαναδιαβάστε εκείνο το μάθημα πριν την ανάπτυξη.

  • Παρακολούθηση λανθάνοντος χρόνου (p50, p95, p99) και ποσοστών σφάλματος
  • Ειδοποιήσεις ρυθμισμένες σε κρίσιμα κατώφλια
  • Διακόπτης κυκλώματος για προστασία από αποτυχίες API
  • Ρυθμισμένη εναλλαγή μοντέλου (fallback)
  • Ενεργοποιημένος έλεγχος εισόδου και εξόδου (moderation)
  • Υλοποιημένος περιορισμός ρυθμού (rate limiting) στην πλευρά του πελάτη
  • Δομημένα αρχεία καταγραφής (logs) για αποσφαλμάτωση
  • Αυτοματοποιημένες αξιολογήσεις (evals) στο CI/CD
  • Προϋπολογισμός κόστους με ειδοποιήσεις
  • Τεκμηρίωση prompts με εκδόσεις

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

  • Η παρακολούθηση καλύπτει τον λανθάνοντα χρόνο, τα σφάλματα, το κόστος και την ποιότητα απόκρισης
  • Παρακολουθείτε τα εκατοστημόρια του λανθάνοντος χρόνου, ποτέ μόνο τον μέσο όρο
  • Οι ειδοποιήσεις πρέπει να είναι βαθμιδωτές: προειδοποίηση και μετά κρίσιμο σφάλμα
  • Ο διακόπτης κυκλώματος προστατεύει από καταρράκτες αποτυχιών· η εναλλαγή (fallback) εξασφαλίζει τη διαθεσιμότητα
  • Μια λίστα ελέγχου παραγωγής αποτρέπει κρίσιμες παραλείψεις

Δοκιμάστε τις γνώσεις σας

Λανθάνων χρόνος, κόστος, αξιολογήσεις: αντανακλαστικά παραγωγής σε πέντε ερωτήσεις.

1. Ποιοι είναι οι κύριοι μοχλοί για τη μείωση του λανθάνοντος χρόνου;

Απάντηση: Ροή δεδομένων (streaming) (αντιλαμβανόμενος λανθάνων χρόνος), caching prompts (σταθερά προθέματα), Προβλεπόμενες Έξοδοι όταν η απόκριση είναι σε μεγάλο βαθμό προβλέψιμη (Chat Completions, σε μοντέλα που αποσύρθηκαν στις 14 Ιανουαρίου 2027), και βελτιστοποίηση του ίδιου του prompt—μετρημένο από άκρο σε άκρο.

2. Πότε πρέπει να χρησιμοποιείτε το Batch API;

Απάντηση: Για μαζική επεξεργασία χωρίς περιορισμούς πραγματικού χρόνου: ασύγχρονα batches με μειωμένο κόστος—η κατάταξη, ο εμπλουτισμός ή η παραγωγή όγκου δεν έχουν θέση στη σύγχρονη διαδρομή.

3. Τι κάνει η συμπίεση συνομιλίας;

Απάντηση: Συμπιέζει το μακρύ ιστορικό (περιλήψεις, περικοπές) για να χωρέσει στο πλαίσιο συμφραζομένων (context) και να ελέγξει το κόστος—απαραίτητο για πράκτορες και μακρές συνεδρίες.

4. Ποιος είναι ο σκοπός του πλαισίου Evals στο CI/CD;

Απάντηση: Να εκτελεί αυτόματα τις αξιολογήσεις σας σε κάθε αλλαγή prompt ή μοντέλου: η υποβάθμιση εντοπίζεται κατά την υποβολή (commit), όχι στην παραγωγή.

5. Τι περιλαμβάνει μια πλήρης αρχιτεκτονική παραγωγής;

Απάντηση: Παρακολούθηση (λανθάνων χρόνος, κόστος, ποιότητα), ειδοποιήσεις, ασύγχρονες ουρές, moderation σε κλίμακα και ένα σχέδιο κλιμάκωσης—το AI σε παραγωγή είναι ένα σύστημα, όχι μια κλήση API.

Μετρήστε, κάντε cache, ομαδοποιήστε (batch), αξιολογήστε συνεχώς: τέσσερις συνήθειες που καθιστούν τις εφαρμογές γρήγορες, λιτές και αξιόπιστες.