Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Håndtering af fejl og HTTP-koder

Lektion 12 af 22 Opdateret 3. november 2026 Udvikler
På denne side
  1. Håndtering af fejl og HTTP-koder
  2. HTTP-koder i OpenAI API
  3. Omfattende fejlhåndtering
  4. Specifikke fejl i Responses API
  5. Struktureret fejllogging
  6. Oversigtstabel
  7. Vigtige pointer

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.

Præciseret 3. november 2026 baseret på OpenAIs side om udfasede funktioner: eksemplet på en fjernet model brugte tidligere gpt-4o, som stadig er tilgængelig indtil 14. januar 2027; det bruger nu gpt-4-turbo, som blev udfaset den 23. oktober 2026 (angivet erstatning: gpt-5.6-sol). Kilde: Udfasede funktioner.

Håndtering af fejl og HTTP-koder

I produktion er fejl uundgåelige. Netværket dratter, en API-nøgle udløber, en kollega deployer en ugyldig parameter, eller selve API’et oplever et tre minutters nedbrud. Det er afgørende at forstå de HTTP-koder, som API’et returnerer, og håndtere dem korrekt for at bygge robuste applikationer. Hele udfordringen koges ned til ét spørgsmål, du skal stille for hver undtagelse: Forsvinder dette, hvis jeg prøver igen, eller ender jeg i en uendelig løkke med et problem, som kun et menneske kan løse?

HTTP-koder i OpenAI API

API’et returnerer standard HTTP-koder for at indikere resultatet af hver anmodning. Python SDK’et lader dig ikke håndtere disse koder manuelt; i stedet oversætter det hver enkelt til en typet undtagelse, som du kan fange separat. Dette giver dig mulighed for at skrive præcise except-blokke i stedet for en generisk except Exception, der ville sløre problemets art.

from openai import OpenAI
from openai import (
    APIError,
    AuthenticationError,
    BadRequestError,
    RateLimitError,
    APIConnectionError,
    InternalServerError,
    PermissionDeniedError,
    NotFoundError,
    UnprocessableEntityError,
)

client = OpenAI()

401 — AuthenticationError

En 401 indikerer, at API-nøglen er ugyldig eller mangler. Du ser typisk dette ved første deployment, når miljøvariablen ikke er blevet propageret til containeren. Det er nytteløst at prøve igen: nøglen vil være lige så ugyldig om ti sekunder.

try:
    # Ugyldig eller manglende API-nøgle
    bad_client = OpenAI(api_key="sk-invalid")
    bad_client.responses.create(
        model="gpt-5.6-terra",
        input="Test"
    )
except AuthenticationError as e:
    print(f"Kode: {e.status_code}")  # 401
    print(f"Besked: {e.message}")
    # Handling: verificér API-nøglen, generér om nødvendigt

400 — BadRequestError

En 400 fortæller dig, at anmodningen er misdannet. Her angives en temperatur på 5,0, hvor den maksimalt accepterede værdi er 2,0. Fejlmeddelelsen nævner næsten altid den fejlbehæftede parameter, hvilket gør dette til den hurtigste fejl at rette – forudsat at du logger den korrekt i stedet for at synke den i stilhed.

try:
    # Ugyldige parametre
    client.responses.create(
        model="gpt-5.6-terra",
        reasoning={"effort": "none"},  # temperatur kræver indsats none
        input="Test",
        temperature=5.0  # Ugyldig værdi (maks 2,0)
    )
except BadRequestError as e:
    print(f"Kode: {e.status_code}")  # 400
    print(f"Besked: {e.message}")
    # Handling: ret anmodningsparametrene

429 — RateLimitError

En 429 indikerer, at du sender for mange anmodninger, eller at du har overskredet din kvote. I modsætning til de to foregående er denne fejl midlertidig af natur: tælleren nulstilles. Dette er skoleeksemplet på et genforsøg, men et genforsøg der venter – og venter længere for hvert forsøg.

try:
    # For mange anmodninger eller overskredet kvote
    client.responses.create(
        model="gpt-5.6-terra",
        input="Test"
    )
except RateLimitError as e:
    print(f"Kode: {e.status_code}")  # 429
    print(f"Besked: {e.message}")
    # Handling: vent og prøv igen med eksponentiel backoff

500/503 — InternalServerError

500- og 503-fejl kommer fra OpenAI, ikke fra dig. Din anmodning var gyldig; infrastrukturen kunne blot ikke behandle den. Prøv igen efter en forsinkelse: i langt de fleste tilfælde lykkes det andet eller tredje forsøg.

try:
    client.responses.create(
        model="gpt-5.6-terra",
        input="Test"
    )
except InternalServerError as e:
    print(f"Kode: {e.status_code}")  # 500 eller 503
    print(f"Besked: {e.message}")
    # Handling: prøv igen efter en forsinkelse; fejlen ligger hos OpenAI

Omfattende fejlhåndtering

Lad os samle disse adfærdsmønstre i én enkelt funktion. Logikken er triage: fatale fejl konverteres til RuntimeError og kastes øjeblikkeligt, midlertidige fejl udløser et ventetidspunkt, der fordobles for hver omgang, og hvis forsøgsbudgettet er opbrugt, mislykkes kaldet rent i stedet for at returnere en tom værdi, som kalderen måske fortolker forkert.

from openai import OpenAI, APIError, AuthenticationError, RateLimitError
from openai import BadRequestError, APIConnectionError, InternalServerError
import time

client = OpenAI()

def robust_api_call(prompt: str, model: str = "gpt-5.6-terra",
                    max_retries: int = 3) -> str:
    """API-kald med omfattende fejlhåndtering."""

    for attempt in range(max_retries):
        try:
            response = client.responses.create(
                model=model,
                input=prompt
            )
            return response.output_text

        except AuthenticationError:
            # Prøv ikke igen — nøglen er ugyldig
            raise RuntimeError("Ugyldig API-nøgle. Tjek OPENAI_API_KEY.")

        except BadRequestError as e:
            # Prøv ikke igen — anmodningen er misdannet
            raise RuntimeError(f"Ugyldig anmodning: {e.message}")

        except RateLimitError:
            # Prøv igen med eksponentiel backoff
            delay = 2 ** attempt
            print(f"Ratelimit nået. Venter {delay}s...")
            time.sleep(delay)

        except InternalServerError:
            # Prøv igen — server-side fejl
            delay = 2 ** attempt
            print(f"Serverfejl. Forsøg {attempt + 1}/{max_retries}...")
            time.sleep(delay)

        except APIConnectionError:
            # Prøv igen — netværksproblem
            delay = 2 ** attempt
            print(f"Forbindelsesfejl. Forsøg {attempt + 1}/{max_retries}...")
            time.sleep(delay)

    raise RuntimeError(f"Mislykkedes efter {max_retries} forsøg")

# Brug
try:
    result = robust_api_call("Hej!")
    print(result)
except RuntimeError as e:
    print(f"Fatal fejl: {e}")

Specifikke fejl i Responses API

To situationer fortjener separat behandling, fordi de optræder under en generisk kode, men kræver en meget specifik løsning.

Kontekst for lang

En prompt, der overskrider kontekstvinduet, returnerer en 400, ligesom en tastefejl i en parameter. For at skelne mellem de to skal du inspicere meddelelsen: tilstedeværelsen af context_length_exceeded peger dig i retning af at trunkere teksten eller skifte til en model med et større kontekstvindue, i stedet for at gennemgå dine parametre.

try:
    response = client.responses.create(
        model="gpt-5.6-terra",
        input="x " * 300000  # Overskrider kontekstvindue
    )
except BadRequestError as e:
    if "context_length_exceeded" in str(e.message):
        print("Prompten er for lang til denne model.")
        print("Løsninger: trunkér teksten, eller skift til en model")
        print("med et større kontekstvindue.")

Model ikke tilgængelig

Modelidentifikatorer er ikke evige. En deployment, der stadig refererer til en udfaset model, fejler med en 404, hvilket får hele applikationen til at crashe, selvom den virkede dagen før. Håndtér dette tilfælde eksplicit: det er en automatisk påmindelse om at opdatere din konfiguration.

try:
    response = client.responses.create(
        model="gpt-4-turbo",  # udfaset fra API'et den 23. oktober 2026
        input="Test"
    )
except NotFoundError as e:
    print(f"Model ikke fundet: {e.message}")
    print("Brug gpt-5.6-sol, erstatningen angivet af OpenAI, eller en nyere model.")

Struktureret fejllogging

En fejl, der ikke logges, er en fejl, du vil opdage via en kundebillet. Logging i JSON i stedet for fri tekst ændrer alt, når du skal aggregere: du kan tælle 429’er per time, filtrere efter response_id eller spore drift i forbruget, hvilket er umuligt med manuelt skrevne loglinjer.

import logging
import json
from datetime import datetime

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger("openai_client")

def call_with_log(prompt: str) -> str:
    """API-kald med struktureret logging."""
    request_id = None

    try:
        response = client.responses.create(
            model="gpt-5.6-terra",
            input=prompt
        )

        logger.info(json.dumps({
            "event": "api_success",
            "model": response.model,
            "tokens": response.usage.total_tokens,
            "response_id": response.id,
            "timestamp": datetime.now().isoformat()
        }))

        return response.output_text

    except APIError as e:
        logger.error(json.dumps({
            "event": "api_error",
            "status_code": e.status_code,
            "message": e.message,
            "timestamp": datetime.now().isoformat()
        }))
        raise

result = call_with_log("Hej!")

Oversigtstabel

Hold dette skema ved hånden: det opsummerer den beslutning, du skal træffe for hver kode.

KodeUndtagelseGenforsøg?Handling
400BadRequestErrorNejRet anmodningen
401AuthenticationErrorNejVerificér API-nøgle
403PermissionDeniedErrorNejVerificér tilladelser
404NotFoundErrorNejVerificér model/endepunkt
422UnprocessableEntityErrorNejRet formatet
429RateLimitErrorJaEksponentiel backoff
500InternalServerErrorJaVent og prøv igen
503InternalServerErrorJaTjenesten midlertidigt utilgængelig

Vigtige pointer

  • Kategorisér fejl: genforsøgbare (429, 500, 503) vs fatale (400, 401, 403)
  • Brug eksponentiel backoff til genforsøgbare fejl
  • Prøv aldrig igen ved autentificeringsfejl eller ugyldige anmodninger
  • Log hver fejl med kontekst (kode, besked, tidsstempel)
  • SDK’et håndterer automatisk 2 genforsøg – konfigurér max_retries om nødvendigt