Labākā prakse ražošanas vidē
Šajā lapā
Nodarbība atjaunināta 2026. gada 3. novembrī, pamatojoties uz OpenAI dokumentāciju: parametri
temperatureuntop_ptiek pieņemti tikai tad, ja spriešanas piepūle (reasoning effort) ir iestatīta uznone, savukārt GPT-5.6 modeļi pēc noklusējuma veic spriešanu (medium). Tādēļ izsaukumos, kuros tiek iestatīti šie parametri, ir jānorādareasoning={"effort": "none"}(Responses API) vaireasoning_effort="none"(Chat Completions). Avoti: Using GPT-6 · GPT-5.6 Terra.
Labākā prakse ražošanas vidē
Šajā nodarbībā aplūkotas būtiskākās labās prakses, lai izvietotu uz OpenAI API balstītu lietotni ražošanas vidē. Uztver to kā savu pirmspalaišanas kontrolsarakstu. Iepriekšējās nodarbībās tu ieguvi būvblokus — kļūdu apstrādi, ātruma ierobežojumus, noturību, novērojamību un izmaksu kontroli. Tagad ir laiks tos apvienot lietotnē, ko tavs kolēģis var pārņemt un darbināt bez tavas klātbūtnes.
1. Klienta arhitektūra
Vieninieks ar centralizētu konfigurāciju
OpenAI klienta实例ēšana katrā izsaukumā izšķiež pamatā esošo HTTP savienojumu un, kas ir vēl nopietnāk, izklīdina tavu konfigurāciju. Rezultātā tev vienur ir 30 sekunžu noildze, bet citur — noklusējuma vērtība, un nav iespējams noteikt, kas attiecas ražošanas vidē. Dekorators lru_cache garantē vienu instanci, kas konfigurēta vienā vietā.
from openai import OpenAI
from functools import lru_cache
@lru_cache(maxsize=1)
def get_client() -> OpenAI:
"""Vieninieka klients ar ražošanas konfigurāciju."""
return OpenAI(
max_retries=3,
timeout=30.0,
)
# Visur savā kodā:
client = get_client()
Vides mainīgie
Tas pats princips attiecas uz iestatījumiem, kas atšķiras starp vidēm. Pārbaudi nepieciešamos mainīgos startēšanas brīdī: serviss, kas atsakās startēt ar skaidru ziņojumu, ir labāks risinājums nekā tāds, kas startē un izgāžas pie pirmā lietotāja izsaukuma. Tas ļauj pielāgot modeli, tokena limitu un temperatūru, nepārdeployējot lietotni.
import os
# OBLIGĀTI: nekad neiekodē atslēgas
REQUIRED_ENV = ["OPENAI_API_KEY"]
for var in REQUIRED_ENV:
if not os.environ.get(var):
raise RuntimeError(f"Trūkst mainīgā {var}")
# Videi specifiska konfigurācija
MODEL = os.environ.get("OPENAI_MODEL", "gpt-5.6-terra")
MAX_TOKENS = int(os.environ.get("OPENAI_MAX_TOKENS", "4096"))
TEMPERATURE = float(os.environ.get("OPENAI_TEMPERATURE", "0.7"))
2. Uzvedņu (Prompt) pārvaldība
Atdali uzvednes no koda
Uzvedne ir biznesa aktīvs tikpat lielā mērā kā biznesa noteikums. Tās aprakšana f-stringā funkcijas iekšienē padara to neiespējamu pārskatīt personai, kas pārzina biznesu, bet neprot Python. Izolē to kā parametrizētu veidni: funkcija tad reducējas līdz formatēšanai un izsaukumam, un temperatūra 0.0 nodrošina klasifikācijas reproducējamību.
# prompts/classification.txt
PROMPT_CLASSIFICATION = """You are a text classifier.
Classify the following text into one of these categories:
{categories}
Text: {texte}
Reply only with the category name."""
def classifier(texte: str, categories: list[str]) -> str:
prompt = PROMPT_CLASSIFICATION.format(
categories=", ".join(categories),
texte=texte
)
response = get_client().responses.create(
model=MODEL,
reasoning={"effort": "none"}, # temperature requires effort none
input=prompt,
temperature=0.0
)
return response.output_text.strip()
Versionē savas uzvednes
Uzvednes maiņa maina sistēmas uzvedību tikpat droši kā koda maiņa, taču bez neviena vienības testa, kas to pamanītu. Glabā secīgas versijas un izvēlies aktīvo versiju, izmantojot konfigurāciju. Tas ļauj salīdzināt divas formulējumus reālā satiksmē un atgriezties pie iepriekšējās, izmantojot vides mainīgo, ja jaunā pasliktina rezultātus.
PROMPTS = {
"classification_v1": "Classify: {texte}",
"classification_v2": "Analyze and classify precisely: {texte}",
}
# Ražošanas vidē izmanto konkrētu versiju
ACTIVE_PROMPT = os.environ.get("PROMPT_VERSION", "classification_v2")
3. Noildzes un limiti
Ierobežo jebkuru ievadi no ārpuses, pirms tā sasniedz API. Lietotājam, kas ielīmē 200 lappušu PDF failu tavā ievades laukā, nevajadzētu būt iespējai izraisīt vairāku dolāru vērtu izsaukumu vai likt pieprasījumam izgāzties konteksta pārplūdes dēļ. Preventīva apgriešana kopā ar izvades limitu un temperatūru no konfigurācijas padara katra izsaukuma izmaksas un latentumu paredzamus.
def appel_avec_garde_fous(prompt: str) -> str:
"""API izsaukums ar visiem drošības mehānismiem."""
# Ierobežo uzvednes garumu
MAX_PROMPT_CHARS = 50000
if len(prompt) > MAX_PROMPT_CHARS:
prompt = prompt[:MAX_PROMPT_CHARS]
print(f"Prompt truncated to {MAX_PROMPT_CHARS} characters")
response = get_client().responses.create(
model=MODEL,
reasoning={"effort": "none"}, # temperature requires effort none
input=prompt,
max_output_tokens=MAX_TOKENS,
temperature=TEMPERATURE,
)
return response.output_text
4. Modeļa rezerves variants (Fallback)
Kad modelis ir pārslogots vai uz laiku nepieejams, kļūdas atgriešana nav tava vienīgā opcija. Pāreja uz sekundāro modeli pasliktina kvalitāti, bet saglabā servisa darbību — kompromiss, kas bieži vien ir vēlams atbalsta asistentam, mazākā mērā līgumu analīzei. Cilps iterē caur modeļiem prioritātes secībā un izraisa izņēmumu tikai tad, ja visi izgāžas.
from openai import RateLimitError, InternalServerError
def appel_avec_fallback(prompt: str) -> str:
"""Mēģina Terra, tad kļūdas gadījumā pāriet uz Luna."""
modeles = ["gpt-5.6-terra", "gpt-5.6-luna"]
for modele in modeles:
try:
response = get_client().responses.create(
model=modele,
input=prompt
)
return response.output_text
except (RateLimitError, InternalServerError) as e:
print(f"{modele} unavailable: {e}")
continue
raise RuntimeError("All models are unavailable")
5. Apstrāde partijās (Batch Processing)
Lai apstrādātu tūkstoš dokumentu, secīgi izsaukumi ir pārāk lēni, bet vienlaicīgi izsaukumi pārkāpj tavus ātruma ierobežojumus. Semafors nodrošina pareizo līdzsvaru. Divas detaļas padara šo implementāciju robustu: return_exceptions=True novērš vienas kļūmes atcelšanu visai partijai, un kārtošana pēc indeksa atjauno sākotnējo secību, ko asyncio.gather izpildes laikā negarantē.
import asyncio
from openai import AsyncOpenAI
async def traiter_batch(prompts: list[str], max_concurrent: int = 5) -> list:
"""Apstrādā uzvedņu partiju ar ierobežotu vienlaicīgumu."""
client = AsyncOpenAI()
semaphore = asyncio.Semaphore(max_concurrent)
resultats = []
async def traiter_un(index: int, prompt: str):
async with semaphore:
response = await client.responses.create(
model="gpt-5.6-terra",
input=prompt
)
return index, response.output_text
tasks = [traiter_un(i, p) for i, p in enumerate(prompts)]
results = await asyncio.gather(*tasks, return_exceptions=True)
# Kārto pēc indeksa, lai saglabātu secību
sorted_results = sorted(
[(idx, res) for idx, res in results if not isinstance(res, Exception)],
key=lambda x: x[0]
)
return [res for _, res in sorted_results]
# prompts = ["Question 1", "Question 2", "Question 3"]
# résultats = asyncio.run(traiter_batch(prompts))
6. Testēšana un validācija
Tev ir nepieciešami divu veidu testi. Pirmais pārbauda infrastruktūru — atslēga strādā, tīkls iet, modelis atbild — un labi iekļaujas startēšanas veselības pārbaudē. Otrais, oriģinālāks, testē pašas uzvednes kvalitāti: tu iesniedz gadījumu, kurā zini pareizo atbildi, un pārbaudi, vai tā parādās. Šie apgalvojumi ir tavs drošības tīkls pret regresijām, kad pārraksti veidni.
def test_api_disponible():
"""Pārbauda, vai API ir pieejams."""
try:
response = get_client().responses.create(
model="gpt-5.6-terra",
input="test",
max_output_tokens=5
)
assert response.output_text is not None
print("API OK")
return True
except Exception as e:
print(f"API KO: {e}")
return False
def test_prompt_quality(prompt: str, attendu: str) -> bool:
"""Pārbauda, vai uzvedne atgriež konsekventu rezultātu."""
response = get_client().responses.create(
model="gpt-5.6-terra",
reasoning={"effort": "none"}, # temperature requires effort none
input=prompt,
temperature=0.0
)
resultat = response.output_text.lower()
return attendu.lower() in resultat
# Uzvedņu regresijas testi
assert test_prompt_quality(
"Classify 'excellent product': positive or negative?",
"positive"
)
Izveido duci šādu testa gadījumu, kas ir reprezentatīvi taviem reālajiem lietojumiem, un palaid tos katru reizi, kad modificē uzvedni. Desmit minūšu ilgs testu komplekts ietaupīs tev nedēļas šaubu par uztverto kvalitāti.
7. Kontrolsaraksts izvietošanai ražošanas vidē
Pirms izvietošanas pārbaudi katru punktu:
Infrastruktūra
- Konfigurēti vides mainīgie (OPENAI_API_KEY u.c.)
- Konfigurētas noildzes un
max_retries - Ieviesta strukturēta žurnālēšana
- Iespējota izmaksu uzraudzība
Noturība
- Pilnīga kļūdu apstrāde (visi HTTP kodi)
- Eksponenciāla atkārtota mēģinājuma aizture (backoff)
- Ķēdes pārtraucējs (circuit breaker) ilgstošiem pārtraukumiem
- Rezerves variants uz alternatīvu modeli
Drošība
- API atslēga nekad nav eksponēta kodā vai žurnālos
- Lietotāja ievades validācija
- Klienta puses ātruma ierobežošana
- Nav sensitīvu datu uzvednēs
Veiktspēja
- Straumēšana iespējota lietotāja saskarnēm
- Apstrāde partijās liela apjoma uzdevumiem
- Kešošana atkārtojošiem pieprasījumiem
- Modeļa izvēle pielāgota katram uzdevumam
Izmaksas
- Definēts dienas budžets
- Konfigurēti brīdinājumi
- Iestatīts
max_output_tokens, kur iespējams - Katram uzdevumam izvēlēts izdevīgākais modelis
Galvenās atziņas
- Centralizē klienta konfigurāciju, izmantojot vieninieku
- Atdali un versionē savas uzvednes ārpus koda
- Ievies modeļa rezerves variantu augstai pieejamībai
- Izmanto apstrādi partijās ar ierobežotu vienlaicīgumu lieliem apjomiem
- Testē savas uzvednes ar kvalitātes apgalvojumiem
- Ievēro pilno kontrolsarakstu pirms katras izvietošanas ražošanas vidē