Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Best Practices til Produktion

Lektion 17 af 22 Opdateret 3. november 2026 Udvikler
På denne side
  1. Best Practices til Produktion
  2. 1. Klientarkitektur
  3. 2. Prompt-styring
  4. 3. Timeouts og grænser
  5. 4. Model Fallback
  6. 5. Batch-behandling
  7. 6. Test og validering
  8. 7. Tjekliste til produktionsdeployment
  9. Vigtige pointer

Lektion opdateret 3. november 2026 baseret på OpenAI-dokumentation: temperature og top_p accepteres 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 specificere reasoning={"effort": "none"} (Responses API) eller reasoning_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