Aqbeż għall-kontenut ewlieni
Malti— Agħżel lingwa
Menu

Arkitettura tal-produzzjoni: monitoraġġ, twissijiet, skalabbiltà

Lezzjoni 20 / 20 Aġġornat 3 ta’ Novembru 2026 Avvanzat
F'din il-paġna
  1. L-applikazzjoni tiegħek fil-produzzjoni: it-tliet pilastri
  2. Osserva: x’għandek tkejjel
  3. Irreaġixxi: twissijiet gradwati
  4. Assorbi: tliet mekkaniżmi ta’ reżiljenza
  5. Lista ta’ verifika għad-distribuzzjoni fil-produzzjoni
  6. Punti Ewlenin
  7. Ittestja l-għarfien tiegħek

L-applikazzjoni tiegħek fil-produzzjoni: it-tliet pilastri

Id-distribuzzjoni ta’ applikazzjoni LLM fil-produzzjoni mhix biss kwistjoni ta’ kodiċi. Tliet pilastri jiggarantixxu l-affidabbiltà: il-monitoraġġ biex tosserva, it-twissijiet biex tirreaġixxi, u l-iskalabbiltà biex tassorbi t-tagħbija. Dawn jiffurmaw katina, u katina tkun b’saħħitha daqs l-aktar ħolqa dgħajfa tagħha: metrika li ħadd ma jħares lejha hija inutili, twissijiet mingħajr proċedura ta’ rispons huma storbju, u skalabbiltà li tidħol fis-seħħ tard wisq hija sempliċiment interruzzjoni. Din il-lezzjoni finali tiġbor flimkien kull kunċett mill-kors f’arkitettura sħiħa tal-produzzjoni.

Osserva: x’għandek tkejjel

Erba’ familji ta’ metrika jkopru l-essenzjali: il-volum tas-sejħiet, il-latency, l-iżbalji, u l-ispiża, maqsuma skont il-mudell. Li taqsam skont il-mudell huwa dak li jagħmel id-dashboard azzjonabbli—rata ta’ żball globali ta’ 3% ma tgħidlek xejn, filwaqt li l-istess ċifra kkonċentrata fuq mudell wieħed turi minnufih il-ħati.

Il-klassi hawn taħt takkumula dawn il-metriċi fil-memorja, billi tuża tieqa li tiżżerżaq ta’ 10,000 latency biex tevita li l-proċess jikber bla waqfien. Innota l-użu tal-perċentili minflok il-medji: il-latency medja ta’ servizz LLM hija kważi dejjem qarrieqa għax ftit sejħiet bil-mod ħafna jisparixxu fil-medja, madankollu dawn huma dawk li l-utenti tiegħek jilmentaw dwarhom.

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

Ovvjament, il-ġbir irid ikun sistematiku. Li tistrumenta manwalment kull sejħa jiggarantixxi li se tinsa waħda—u probabbilment dik li tikkawża l-problemi. Id-dekoratur hawn taħt iċaqlaq il-kejl fil-livell tal-funzjoni tas-sejħa: il-blokk finally jirreġistra l-latency u s-suċċess irrispettivament minn x’jiġri, anke meta eċċezzjoni tippropaga.

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

Il-kontaturi tat-tokens u l-ispiża jibqgħu żero f’din il-verżjoni għax l-oġġett tar-rispons mhuwiex disponibbli fil-ħin tar-reġistrazzjoni. Ikkumplihom billi taqra l-oqsma tal-użu rritornati mill-API: mingħajr din l-informazzjoni, id-dashboard tiegħek se juri b’mod fidil kolonna ta’ spejjeż żero.

Irreaġixxi: twissijiet gradwati

Twissija hija utli biss jekk issejħu għal azzjoni. Għalhekk is-sistema tiddistingwi żewġ limiti għal kull metrika: limitu ta’ twissija, li jissinjala devjazzjoni li trid tiġi eżaminata matul il-jum, u limitu kritiku, li jiġġustifika li tqajjem lil xi ħadd. Li tħawwad iż-żewġ affarijiet jipproduċi l-agħar riżultat possibbli—tim li tgħallem jinjora n-notifiki.

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"],
                        },
                    )

It-twissijiet tal-ispiża kull siegħa huma dawk li spiss jintesew, u dan huwa ħażin: ċiklu ta’ provi mill-ġdid mingħajr limitu jew xogħol bil-lotti mnedija darbtejn jirriżulta f’kont, mhux f’żball. Hija l-unika netwerk ta’ sigurtà li jiskopri dan it-tip ta’ inċident waqt li qed iseħħ.

Assorbi: tliet mekkaniżmi ta’ reżiljenza

Meta l-API tirritorna żball, il-prova mill-ġdid tagħmel l-affarijiet agħar: iżżid tagħbija fuq servizz li diġà qiegħed f’diffikultà u tagħmel lill-utenti tiegħek jistennew għal xejn. Iċ-ċirkwit breaker (circuit breaker) jreġġa’ lura din il-loġika. Wara numru definit ta’ fallimenti konsekuttivi, jiftaħ iċ-ċirkwit u jirrifjuta minnufih is-sejħiet sussegwenti, imbagħad jipprova mill-ġdid wara dewmien ta’ reset.

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

Iċ-ċirkwit breaker jipproteġi l-applikazzjoni tiegħek; madankollu, ma jagħmilhiex taħdem. Dak hu r-rwol tal-fallbak tal-mudell (model fallback), li jipprova alternattivi f’ordni, u jaqbeż dawk li ċ-ċirkwiti tagħhom diġà miftuħa. Punt tad-disinn li għandek iżżomm f’moħħok: l-ordni tal-lista hija deċiżjoni tal-prodott, mhix waħda teknika. Poġġi l-ewwel il-mudell li jwassal is-servizz mistenni, segwit minn dawk li jwasslu servizz degradat iżda aċċettabbli—risposta ftit inqas preċiża hija aħjar minn messaġġ mhux disponibbli.

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.")

It-tielet mekkaniżmu jikkonċerna d-daqs. Li tmexxi n-numru ta’ ħaddiema (workers) ibbażat fuq id-daqs tal-kju (queue) minflok it-tagħbija tal-CPU huwa r-rifless it-tajjeb għal servizz li jqatta’ ħafna mill-ħin jistenna risponsi tan-network: iċ-ċ-ĊPU jibqa’ wieqaf filwaqt li l-kju jikber. Innota l-asimetrija fir-regola applikata—nirdoppjaw meta nkabbru u naqsmu bin-nofs meta nnaqqsu, b’limiti separati ħafna (100 vs 10). Din il-lakuna tevita l-oċċillazzjoni: mingħajrha, is-sistema tonfoq ħinha toħloq u teqred il-ħaddiema madwar il-punt tat-tidwir.

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

Lista ta’ verifika għad-distribuzzjoni fil-produzzjoni

Dan il-kors jispiċċa bil-lista ta’ verifika li għandek tgħaddi minnha qabel ma tiftaħ l-applikazzjoni tiegħek għall-pubbliku. Kull oġġett jirreferi għal lezzjoni li għamilt; jekk xi waħda tidher mhux ċara, erġa’ aqra dik il-lezzjoni qabel ma tiddistribwixxi.

  • Monitoraġġ tal-latency (p50, p95, p99) u rati ta’ żball
  • Twissijiet ikkonfigurati fuq limiti kritiċi
  • Ċirkwit breaker biex tipproteġi kontra fallimenti tal-API
  • Fallbak tal-mudell ikkonfigurat
  • Moderazzjoni tal-input u l-output attivata
  • Limitazzjoni tar-rata (rate limiting) fuq in-naħa tal-klijent implimentata
  • Logs strutturati għad-debugging
  • Evalwazzjonijiet awtomatizzati fiċ-ĊI/ĊD
  • Baġit tal-ispiża b’twissijiet
  • Dokumentazzjoni tal-prompt b’verżjonijiet

Punti Ewlenin

  • Il-monitoraġġ jkopri l-latency, l-iżbalji, l-ispejjeż, u l-kwalità tar-rispons
  • Segwi l-perċentili tal-latency, qatt biss il-medja
  • It-twissijiet iridu jkunu gradwati: twissija imbagħad kritika
  • Iċ-ċirkwit breaker jipproteġi kontra kaskati ta’ falliment; il-fallbak jiżgura d-disponibbiltà
  • Lista ta’ verifika tal-produzzjoni tevita żbalji kritiċi

Ittestja l-għarfien tiegħek

Latency, spejjeż, evalwazzjonijiet: riflessi tal-produzzjoni f’ħames mistoqsijiet.

1. X'inhuma l-leva prinċipali biex tnaqqas il-latency?

Tweġiba: Streaming (latency perċepita), caching tal-prompt (prefissi stabbli), Outputs Ippredetti meta r-rispons huwa l-aktar prevedibbli (Chat Completions, fuq mudelli irtirati fl-14 ta’ Jannar, 2027), u l-ottimizzazzjoni tal-prompt innifsu—imkejjel minn tarf għal tarf.

2. Meta għandek tuża l-Batch API?

Tweġiba: Għal ipproċessar massiv mingħajr restrizzjonijiet ta’ ħin reali: lottijiet asinkroni bi spiża mnaqqsa—klassifikazzjoni, arrikkiment, jew ġenerazzjoni ta’ volum m’għandhomx posthom fil-mogħdija sinkrona.

3. X'tagħmel il-kompattazzjoni tal-konversazzjoni?

Tweġiba: Tikkumpressa storja twila (sommarji, tneħħija) biex tidħol fil-kuntest u tikkontrolla l-ispejjeż—essenzjali għall-aġenti u sessjonijiet twal.

4. X'inhu l-għan tal-qafas tal-Evals fiċ-ĊI/ĊD?

Tweġiba: Biex tmexxi l-evalwazzjonijiet tiegħek awtomatikament fuq kull bidla fil-prompt jew fil-mudell: ir-regressjoni tiġi skoperta fil-commit, mhux fil-produzzjoni.

5. X'jinkludi arkitettura sħiħa tal-produzzjoni?

Tweġiba: Monitoraġġ (latency, spejjeż, kwalità), twissijiet, kjuwijiet asinkroni, moderazzjoni fuq skala kbira, u pjan ta’ skalabbiltà—l-AI fil-produzzjoni huwa sistema, mhux sejħa API.

Kejjel, ikkaxxja, agħmel lottijiet, evalwa kontinwament: erba’ drawwiet li jagħmlu l-applikazzjonijiet mgħaġġla, ħfief u affidabbli.