Ailtireacht táirgeachta: monatóireacht, foláirimh, scálú
Ar an leathanach seo
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.