Léim go dtí an príomhábhar
Gaeilge— Roghnaigh teanga
Roghchlár

Ailtireacht táirgeachta: monatóireacht, foláirimh, scálú

Ceacht 20 as 20 Nuashonraithe 3 Samhain 2026 Ardleibhéal
Ar an leathanach seo
  1. Do chuid feidhmchlár i dtáirgeadh: na trí phillír
  2. Breathnaigh: cad le tomhas
  3. Freagair: foláirimh céimnithe
  4. Ionsú: trí mheicníocht athléimneachta
  5. Seicliosta imlonnaithe táirgeachta
  6. Príomhphointí
  7. Tástáil do chuid eolais

Do chuid feidhmchlár i dtáirgeadh: na trí phillír

Ní hamháin faoin gcód atá sé nuair a chuireann tú feidhmchlár LLM i dtáirgeadh. Is iad na trí phillír a ráthaíonn iontaofacht ná: monatóireacht chun breathnú, foláirimh chun freagairt, agus scálú chun ualach a ionsú. Is slabhra iad seo, agus níl slabhra níos láidre ná an nasc is laige: is ábhar gan mhaith iad méadrachtaí nach mbreathnaíonn aon duine orthu, is torann iad foláirimh gan nós imeachta freagartha, agus is briseadh seirbhíse amháin é scálú a thosaíonn ró-dhéanach. Tugann an ceacht deireanach seo gach coincheap ón gcúrsa le chéile in ailtireacht táirgeachta iomlán.

Breathnaigh: cad le tomhas

Clúdaíonn ceithre theaghlach méadrachtaí na bunriachtanais: toirt glaonna, moill, earráidí, agus costas, briste síos de réir samhaltóra. Is é an briseadh síos de réir samhaltóra a dhéanann an deais inbhéartaithe – ní insíonn ráta earráide domhanda de 3% duit faic, ach léiríonn an figiúr céanna dírithe ar shamhail amháin láithreach cé is cúis leis.

Carnann an rang thíos na méadrachtaí seo sa chuimhne, ag úsáid fuinneoige sleamhnáin de 10,000 moill chun cosc a chur ar an bpróiseas fás go deo. Tabhair faoi deara úsáid na gcéatadáin seachas meánluachanna: beagnach i gcónaí is míthreorach é meánmhoill seirbhíse LLM toisc go n-imíonn roinnt glaonna an-mhall isteach sa mheán, ach is iad sin na cinn a bhíonn do chuid úsáideoirí ag gearán fúthu.

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

Ar ndóigh, caithfidh an bailiú a bheith córasach. Ráthaíonn ionstraimiú láimhe ar gach glao go ndéanfaidh tú dearmad ar cheann amháin – agus is dócha gurb é an ceann sin a chruthóidh trioblóid. Aistríonn an maiscín thíos an tomhas go dtí leibhéal na feidhme glaonna: taifeadann an bloc finally an mhoill agus an rath gan beann ar aon rud, fiú nuair a scaipeann eisceacht.

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

Fanann comhairitheoirí tocain agus costais ar nialas sa leagan seo toisc nach bhfuil an freagra oibiacht ar fáil ag am an taifeadta. Líon iad trí na réimsí úsáide a thugtar ar ais ag an API a léamh: gan an t-eolas seo, taispeánfaidh do dheais colún de chostais nialasacha go dílis.

Freagair: foláirimh céimnithe

Níl luach ar bith ag foláireamh mura n-iarrann sé gníomh. Sin an fáth a ndéanann an córas idirdhealú idir dhá thairseach in aghaidh gach méadraice: tairseach rabhaidh, a chuireann in iúl claonadh le scrúdú le linn an lae, agus tairseach chriticiúil, a thugann údar le duine a dhúiseacht. Is é an toradh is measa a chruthaíonn meascadh na ndá rud ná foireann a d’fhoghlaim neamhaird a dhéanamh de na fógraí.

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

Is iad foláirimh costais uair an chloig na cinn is minice a dhéantar dearmad orthu, agus is trua é sin: cruthaíonn lúb athiarrtha gan teorainn nó post baisce a seoladh faoi dhó bille, ní earráid. Is é an t-aon líon sábháilteachta a bhrathann an cineál seo teagmhais agus é ag tarlú.

Ionsú: trí mheicníocht athléimneachta

Nuair a thugann an API earráid ar ais, déanann athiarracht an scéal níos measa: cuireann tú ualach le seirbhís atá i dtrioblóid cheana féin agus fágann tú do chuid úsáideoirí ag fanacht ar son faic. Aistríonn an briseoir ciorcaid an loighic seo. Tar éis líon sainithe de theipeanna leantacha, osclaíonn sé an ciorcad agus diúltaíonn sé glaonna ina dhiaidh sin láithreach, ansin déanann sé iarracht arís tar éis moill athshocraithe.

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

Cosnaíonn an briseoir ciorcaid do chuid feidhmchlár; ní dhéanann sé obair air, áfach. Sin ról an mhaolaithe samhaltóra, a dhéanann iarracht ar roghanna malartacha in ord, ag scipeáil na cinn a bhfuil a gciorcaid oscailte cheana féin. Pointe dearaidh le cuimhneamh air: is cinneadh táirge é ord an liosta, ní cinneadh teicniúil. Cuir ar dtús an tsamhail a sholáthraíonn an tseirbhís a bhfuiltear ag súil léi, agus ina dhiaidh sin iad siúd a sholáthraíonn seirbhís íslithe ach inghlactha – tá freagra beagán níos lú géar níos fearr ná teachtaireacht nach bhfuil ar fáil.

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

Baineann an tríú meicníocht le méidú. Is é an frithghníomh ceart do sheirbhís a chaitheann an chuid is mó dá chuid ama ag fanacht le freagairtí líonra ná líon na n-oibrithe a stiúradh bunaithe ar mhéid an chiú seachas ar ualach an LAP: fanann an LAP díomhaoin agus fásann an ciú. Tabhair faoi deara an neamhshiméadracht sa riail a chuirtear i bhfeidhm – déanaimid dúbailt ar scálú suas agus leathú ar scálú síos, le tairseacha atá scartha go forleathan (100 vs 10). Coscaíonn an bhearna seo ascailleadh: gan é, chaithfeadh an córas a chuid ama ag cruthú agus ag scriosadh oibrithe timpeall an phointe tipping.

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

Seicliosta imlonnaithe táirgeachta

Tagann an cúrsa seo chun críche leis an seicliosta le dul tríd sula n-osclaíonn tú do chuid feidhmchlár don phobal. Tagraíonn gach mír do cheacht a chlúdaigh tú; má tá aon cheann dóibh doiléir, athléigh an ceacht sin sula ndéanann tú imlonnú.

  • Monatóireacht moille (p50, p95, p99) agus rátaí earráide
  • Foláirimh cumraithe ar thairseacha criticiúla
  • Briseoir ciorcaid chun cosaint a thabhairt i gcoinne teipeanna API
  • Maolú samhaltóra cumraithe
  • Measaracht ionchuir agus aschuir cumasaithe
  • Teorannú ráta taobh an chliaint curtha i bhfeidhm
  • Logaí struchtúrtha le haghaidh dífhabhtaithe
  • Meastóireachtaí uathoibrithe i CI/CD
  • Buiséad costais le foláirimh
  • Doiciméadú leideanna leaganaithe

Príomhphointí

  • Clúdaíonn monatóireacht moill, earráidí, costais, agus cáilíocht freagartha
  • Rianaigh céatadáin moille, riamh an meán amháin
  • Caithfidh foláirimh a bheith céimnithe: rabhadh ansin criticiúil
  • Cosnaíonn briseoir ciorcaid i gcoinne eascairte teipe; cinntíonn maolú infhaighteacht
  • Cuireann seicliosta táirgeachta cosc ar dhearmad criticiúil

Tástáil do chuid eolais

Moill, costais, meastóireachtaí: frithghníomhartha táirgeachta i gcúig cheist.

1. Cad iad na príomhghiótha chun moill a laghdú?

Freagra: Sruthú (moill mhothaithe), taisceáil leideanna (réamhleaganacha cobhsaí), Aschuir Rhéamh-mheasta nuair atá an freagra intuartha go mór (Comhlánuithe Comhrá, ar shamhlacha a cuireadh ar scor an 14 Eanáir 2027), agus an leid féin a optamú – tomhaiste ó cheann go ceann.

2. Cathin ba chóir duit an Batch API a úsáid?

Freagra: Le haghaidh próiseála ollmhór gan srianta fíor-ama: baisc neamhshioncrónacha ar chostas laghdaithe – níl áit ag rangú, saibhriú, nó giniúint toirte ar an gcosán sioncrónach.

3. Cad a dhéanann comhbhrú comhrá?

Freagra: Déanann sé comhbhrú ar stair fhada (achoimrí, prúnáil) chun oiriúnú laistigh den chomhthéacs agus costais a rialú – riachtanach d’ghníomhairí agus do sheisiúin fhada.

4. Cad é cuspóir an chreata Evals i CI/CD?

Freagra: Chun do chuid meastóireachtaí a rith go huathoibríoch ar gach athrú leide nó samhaltóra: braitear cúlú ag an gcuir isteach, ní i dtáirgeadh.

5. Cad a áirítear in ailtireacht táirgeachta iomlán?

Freagra: Monatóireacht (moill, costais, cáilíocht), foláirimh, ciúnna neamhshioncrónacha, measaracht ar scála, agus plean scálaithe – is córas é AI i dtáirgeadh, ní glao API.

Tomhais, taisc, baisc, déan meastóireacht go leanúnach: ceithre nós a dhéanann feidhmchláir tapa, caol, agus iontaofa.