Performanță în producție
Pe această pagină
Dincolo de cache: performanța globală
Cache-ul reduce costurile, dar integrarea în producție depinde de mai mult decât simpla factură: latența percepută de utilizator, throughput-ul susținut, fiabilitatea în fața erorilor tranzitorii și capacitatea de a diagnostica degradările. O aplicație ieftină, care răspunde în 12 secunde sau eșuează o dată din 50, nu este performantă. Această lecție acoperă cele patru dimensiuni esențiale odată ce ați stăpânit costul.
Streaming: economisirea timpului fără a-l economisi realmente
Pentru orice interfață în care un om așteaptă un răspuns, streaming-ul prin SSE (Server-Sent Events) schimbă radical percepția. Fără el, utilizatorul se uită la cursor în timp ce modelul generează 500 de tokeni; cu el, primele cuvinte apar după câteva sute de milisecunde, iar citirea începe în timpul generării. Timpul total rămâne același, dar timpul perceput se reduce de câteva ori.
import requests
import json
def appel_streaming(messages, model="grok-4.20"):
reponse = requests.post(
"https://api.x.ai/v1/chat/completions",
headers={
"Authorization": f"Bearer {api_key}",
"Content-Type": "application/json"
},
json={
"model": model,
"messages": messages,
"stream": True
},
stream=True
)
for ligne in reponse.iter_lines():
if ligne and ligne.startswith(b"data: "):
donnees = ligne[6:]
if donnees == b"[DONE]":
break
chunk = json.loads(donnees)
token = chunk["choices"][0]["delta"].get("content", "")
yield token
Parametrul stream: True nu modifică nici numărul de tokeni facturați, nici tariful acestora. Ce îmbunătățiți este TTFT – time to first token (timpul până la primul token). Rețineți că funcția este un generator: cedează controlul token cu token, permițându-vă să scrieți direct în răspunsul HTTP al serverului fără a menține întreaga generare în memorie.
Alegerea modelului pentru latență
A doua pârghie de latență este alegerea modelului, care depinde în principal de efortul de raționament. Un model de raționament produce tokeni de raționament invizibili înainte de a-și schița răspunsul: calitatea crește, dar și întârzierea. La extreme, grok-build-0.1 este cel mai rapid din catalog, fiind potrivit pentru utilizări în timp real, cum ar fi clasificarea din zbor sau autocompletarea; grok-4.20-0309 în varianta non-raționament și grok-4.3 oferă un compromis rezonabil între calitate și viteză; grok-4.5 cu raționament profund se situează la celălalt capăt, rezervat sarcinilor care îl cer cu adevărat.
Consecința practică este că nu alegeți un model pentru o aplicație întreagă, ci pentru o etapă specifică. Un model comun constă într-un apel inițial rapid care decide: este această cerere trivială, ambiguă sau complexă? Apoi trimiteți către un model de raționament doar fracțiunea de cazuri care o justifică. Divideți astfel atât latența medie, cât și costul mediu, fără a degrada cazurile dificile.
Gestionarea erorilor fără a agrava situația
Codul 429 abordat în Lecția 3 nu este singurul pe care îl veți întâlni. Distincția cheie constă între erorile care merită o reîncercare și cele pentru care reîncercarea adaugă doar trafic inutil.
| Cod | Natură | Acțiune |
|---|---|---|
| 429 Too Many Requests | Recuperabilă | Backoff exponențial (Lecția 3) |
| 500 Internal Server Error | Recuperabilă | Reîncercare cu backoff; eroare latoare server |
| 502 / 503 Service Unavailable | Recuperabilă | Reîncercare după câteva secunde |
| 400 Bad Request | Finală | Cerere malformată; corectați payload-ul |
| 401 Unauthorized | Finală | Cheie API invalidă sau expirată |
| 413 Payload Too Large | Finală | Promptul depășește limita de context |
Puteți codifica această regulă în trei linii și merită să o izolați într-o funcție, în loc să împrăștiați instrucțiuni if peste tot:
def classifier_erreur(status_code):
recuperable = {429, 500, 502, 503}
return status_code in recuperable
Timeout-uri și reziliență
Un timeout setat necorespunzător creează două probleme opuse: dacă este prea scurt, abandonează cereri care ar fi reușit; dacă este prea lung, blochează workerii în timp ce coada se lungeste. Setați trei valori distincte. Conexiunea trebuie stabilită în 10 secunde; dincolo de acest prag, problema este de rețea. Citirea în mod non-streaming scalează cu modelul: 120 de secunde pentru un model de raționament, 60 de secunde pentru grok-build-0.1. În streaming, pragul relevant nu este durata totală, ci intervalul dintre chunk-uri, setat la aproximativ 30 de secunde.
Un punct necesită o atenție deosebită: când un timeout expiră în timpul unei generări lungi, nu reporniți automat. Modelul poate fi consumat deja tokeni de raționament pentru care veți plăti din nou, iar nimic nu garantează că prima cerere nu a reușit latoare server. Un mecanism de idempotență – o cheie de cerere pe care o păstrați pentru a recunoaște un duplicat – sau o reluare explicită funcționează mai bine decât o reîncercare oarbă.
Ce să instrumentați
Patru familii de metrici sunt suficiente pentru a diagnostica majoritatea incidentelor.
| Metrică | Ce dezvăluie | Țintă |
|---|---|---|
| TTFT | Latența inițială percepută | Monitorizare per model |
| Rata de succes | Fiabilitatea integrării | Mai mare de 99,5% |
| Rata de cache | Calitatea structurii promptului | Mai mare de 50% |
| Cost per cerere | Deriva bugetară, medie mobilă | Stabil în timp |
Adăugați latența la percentila 95. Media maschează întotdeauna cazurile extreme, iar acelea sunt cele care declanșează tichete de suport: un P95 de 8 secunde înseamnă că un utilizator din 20 așteaptă 8 secunde, lucru pe care nicio medie de 1,2 secunde nu l-ar revela.
Puncte cheie
- Streaming-ul SSE reduce latența percepută fără a afecta costul
- Alegeți un model rapid pentru timp real și un model de raționament pentru calitate
- Distingeți erorile recuperabile (429, 500, 502/503) de erorile finale (400, 401)
- Configurați timeout-uri adaptate modelului utilizat
- Monitorizați TTFT, rata de succes, rata de cache și costul mediu per cerere