Best Practices til Produktion
På denne side
Lektion opdateret 3. november 2026 baseret på OpenAI-dokumentation:
temperatureogtop_paccepteres kun med en ræsonneringsindsats pånone, hvorimod GPT-5.6-modeller ræsonnerer som standard (medium). Kald, der sætter disse parametre, skal derfor specificerereasoning={"effort": "none"}(Responses API) ellerreasoning_effort="none"(Chat Completions). Kilder: Brug af GPT-6 · GPT-5.6 Terra.
Best Practices til Produktion
Denne lektion dækker de essentielle best practices til at deploye en applikation baseret på OpenAI API til produktion. Betragt dette som din tjekliste før lancering. Tidligere lektioner har givet dig byggestenene – fejlhåndtering, rate limits, robusthed, observerbarhed og omkostninger. Nu er det tid til at samle dem til en applikation, som en kollega kan overtage og drive uden dig.
1. Klientarkitektur
Singleton med centraliseret konfiguration
At instantiere en OpenAI-klient ved hvert kald spilder den underliggende HTTP-forbindelse og, hvad der er værre, spreder din konfiguration. Du ender med et timeout på 30 sekunder her og standardværdien der, uden mulighed for at vide, hvilken der gælder i produktion. Dekoratøren lru_cache garanterer én enkelt instans, konfigureret ét sted.
from openai import OpenAI
from functools import lru_cache
@lru_cache(maxsize=1)
def get_client() -> OpenAI:
"""Singleton-klient med produktionskonfiguration."""
return OpenAI(
max_retries=3,
timeout=30.0,
)
# Overalt i din kode:
client = get_client()
Miljøvariabler
Samme princip gælder for indstillinger, der varierer mellem miljøer. Tjek for påkrævede variabler ved opstart: det er bedre, at en tjeneste nægter at starte med en klar besked, end at den starter og fejler ved første brugerkald. Dette gør modellen, token-grænsen og temperaturen justerbare uden gen-deployment.
import os
# PÅKRÆVET: hardcod aldrig nøgler
REQUIRED_ENV = ["OPENAI_API_KEY"]
for var in REQUIRED_ENV:
if not os.environ.get(var):
raise RuntimeError(f"Manglende variabel {var}")
# Miljøspecifik konfiguration
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. Prompt-styring
Adskil prompts fra kode
En prompt er en forretningsmæssig aktiv, ligesom en forretningsregel. At begrave den i en f-string inde i en funktion gør det umuligt for nogen, der kender forretningen men ikke Python, at gennemgå den. Isolér den som en parametriseret skabelon: funktionen reduceres derefter til formatering og kald, og en temperatur på 0,0 gør klassificeringen reproducerbar.
# prompts/classification.txt
PROMPT_CLASSIFICATION = """Du er en tekstklassificator.
Klassificér følgende tekst i én af disse kategorier:
{categories}
Tekst: {texte}
Svar kun med kategorinavnet."""
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"}, # temperatur kræver indsats none
input=prompt,
temperature=0.0
)
return response.output_text.strip()
Versionér dine prompts
At ændre en prompt ændrer systemadfærd lige så sikkert som at ændre kode, men uden at nogen unit-test opdager det. Behold successive versioner og vælg den aktive via konfiguration. Dette lader dig sammenligne to formuleringer på rigtig trafik og rulle tilbage til den tidligere med en miljøvariabel, hvis den nye forringer resultaterne.
PROMPTS = {
"classification_v1": "Klassificér: {texte}",
"classification_v2": "Analysér og klassificér præcist: {texte}",
}
# I produktion, brug en specifik version
ACTIVE_PROMPT = os.environ.get("PROMPT_VERSION", "classification_v2")
3. Timeouts og grænser
Begræns al input udefra, før det når API’et. En bruger, der indsætter en PDF på 200 sider i dit inputfelt, må ikke kunne udløse et kald til flere dollars eller få forespørgslen til at fejle på grund af kontekst-overløb. Forebyggende trunkering, kombineret med output-loftet og temperaturen fra konfigurationen, gør omkostningerne og latensen for hvert kald forudsigelige.
def appel_avec_garde_fous(prompt: str) -> str:
"""API-kald med alle sikkerhedsforanstaltninger."""
# Begræns prompt-størrelse
MAX_PROMPT_CHARS = 50000
if len(prompt) > MAX_PROMPT_CHARS:
prompt = prompt[:MAX_PROMPT_CHARS]
print(f"Prompt trunkeret til {MAX_PROMPT_CHARS} tegn")
response = get_client().responses.create(
model=MODEL,
reasoning={"effort": "none"}, # temperatur kræver indsats none
input=prompt,
max_output_tokens=MAX_TOKENS,
temperature=TEMPERATURE,
)
return response.output_text
4. Model Fallback
Når en model er mættet eller midlertidigt utilgængelig, er returnering af en fejl ikke din eneste mulighed. At skifte til en sekundær model forringer kvaliteten, men bevarer tjenesten – et kompromis, der ofte er at foretrække for en supportassistent, mindre så for kontraktsanalyse. Løkken itererer gennem modeller i præferencerækkefølge og rejser kun en undtagelse, hvis alle fejler.
from openai import RateLimitError, InternalServerError
def appel_avec_fallback(prompt: str) -> str:
"""Prøver Terra og falder tilbage til Luna ved fejl."""
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} utilgængelig: {e}")
continue
raise RuntimeError("Alle modeller er utilgængelige")
5. Batch-behandling
For at behandle tusind dokumenter er sekventielle kald for langsomme, og samtidige kald sprænger dine rate limits. En semaphore rammer den rette balance. To detaljer gør denne implementering robust: return_exceptions=True forhindrer, at én enkelt fejl annullerer hele batchet, og sortering efter indeks genopretter den oprindelige rækkefølge, hvilket asyncio.gather ikke garanterer i eksekveringstid.
import asyncio
from openai import AsyncOpenAI
async def traiter_batch(prompts: list[str], max_concurrent: int = 5) -> list:
"""Behandler et batch af prompts med begrænset samtidighed."""
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)
# Sortér efter indeks for at bevare rækkefølgen
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 = ["Spørgsmål 1", "Spørgsmål 2", "Spørgsmål 3"]
# résultats = asyncio.run(traiter_batch(prompts))
6. Test og validering
Du har brug for to forskellige typer tests. Den første tjekker rørledningerne – nøglen virker, netværket passerer, modellen svarer – og passer godt ind i en sundhedstjek ved opstart. Den anden, mere originale, tester selve prompt-kvaliteten: du indsender et tilfælde, hvor du kender det korrekte svar, og verificerer, at det vises. Disse assertioner er dit sikkerhedsnet mod regressioner, når du omformulerer en skabelon.
def test_api_disponible():
"""Verificerer, at API'et er tilgængeligt."""
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:
"""Verificerer, at en prompt returnerer et konsistent resultat."""
response = get_client().responses.create(
model="gpt-5.6-terra",
reasoning={"effort": "none"}, # temperatur kræver indsats none
input=prompt,
temperature=0.0
)
resultat = response.output_text.lower()
return attendu.lower() in resultat
# Prompt regressionstests
assert test_prompt_quality(
"Klassificér 'fremragende produkt': positiv eller negativ?",
"positiv"
)
Byg et dusin testtilfælde som dette, repræsentative for dine rigtige brugstilfælde, og kør dem hver gang, du modificerer en prompt. En testsuite på ti minutter vil spare dig for ugers tvivl om den oplevede kvalitet.
7. Tjekliste til produktionsdeployment
Før deployment, verificér hvert punkt:
Infrastruktur
- Miljøvariabler konfigureret (OPENAI_API_KEY osv.)
- Timeouts og max_retries konfigureret
- Struktureret logging på plads
- Omkostningsovervågning aktiveret
Robusthed
- Komplet fejlhåndtering (alle HTTP-koder)
- Eksponentiel backoff for genforsøg
- Circuit breaker ved langvarige udfald
- Fallback til en alternativ model
Sikkerhed
- API-nøgle aldrig eksponeret i kode eller logs
- Validering af brugerinput
- Rate limiting på klientsiden
- Ingen følsomme data i prompts
Ydeevne
- Streaming aktiveret til brugergrænseflader
- Batch-behandling til opgaver med højt volumen
- Caching til gentagne forespørgsler
- Modelvalg tilpasset hver opgave
Omkostninger
- Dagligt budget defineret
- Alarmer konfigureret
- max_output_tokens sat hvor muligt
- Mest omkostningseffektive model valgt per opgave
Vigtige pointer
- Centralisér klientkonfiguration med en singleton
- Adskil og versionér dine prompts uden for koden
- Implementér model-fallback for høj tilgængelighed
- Brug batch-behandling med begrænset samtidighed til volumen
- Test dine prompts med kvalitetsassertioner
- Følg den komplette tjekliste før hvert produktionsdeployment