Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Osvědčené postupy pro nasazení do produkce

Lekce 17 z 22 Aktualizováno 3. listopadu 2026 Vývojář
Na této stránce
  1. Osvědčené postupy pro nasazení do produkce
  2. 1. Architektura klienta
  3. 2. Správa promptů
  4. 3. Časové limity a omezení
  5. 4. Záložní model (Fallback)
  6. 5. Dávkové zpracování
  7. 6. Testování a validace
  8. 7. Kontrolní seznam pro nasazení do produkce
  9. Klíčové poznatky

Lekce aktualizována 3. listopadu 2026 na základě dokumentace OpenAI: parametry temperature a top_p jsou přijímány pouze při úsilí o uvažování (reasoning effort) nastaveném na none, zatímco modely GPT-5.6 ve výchozím nastavení uvažují (medium). Volání, která tyto parametry nastavují, musí proto specifikovat reasoning={"effort": "none"} (Responses API) nebo reasoning_effort="none" (Chat Completions). Zdroje: Using GPT-6 · GPT-5.6 Terra.

Osvědčené postupy pro nasazení do produkce

Tato lekce pokrývá zásadní osvědčené postupy pro nasazení aplikace založené na OpenAI API do produkčního prostředí. Ber to jako svůj kontrolní seznam před spuštěním. Předchozí lekce ti poskytly stavební kameny – zpracování chyb, limity rychlosti, odolnost, pozorovatelnost a náklady. Nyní je čas je sestavit do aplikace, kterou může převzít a provozovat tvůj kolega i bez tebe.

1. Architektura klienta

Singleton s centralizovanou konfigurací

Vytváření instance klienta OpenAI při každém volání plýtvá underlying HTTP spojením a, což je vážnější, roztříští vaši konfiguraci. Nakonec máte zde 30sekundový timeout a tam výchozí hodnotu, bez možnosti zjistit, která platí v produkci. Dekorátor lru_cache zaručuje jednu instanci nakonfigurovanou na jednom místě.

from openai import OpenAI
from functools import lru_cache

@lru_cache(maxsize=1)
def get_client() -> OpenAI:
    """Singleton klient s produkční konfigurací."""
    return OpenAI(
        max_retries=3,
        timeout=30.0,
    )

# Všude ve vašem kódu:
client = get_client()

Proměnné prostředí

Stejný princip platí pro nastavení, která se liší mezi prostředími. Zkontrolujte požadované proměnné při spuštění: je lepší, aby služba odmítla start s jasnou zprávou, než aby startovala a selhala při prvním volání uživatele. To umožňuje upravovat model, limit tokenů a teplotu bez opětovného nasazení.

import os

# POVINNÉ: nikdy neukládejte klíče natvrdo
REQUIRED_ENV = ["OPENAI_API_KEY"]

for var in REQUIRED_ENV:
    if not os.environ.get(var):
        raise RuntimeError(f"Chybí proměnná {var}")

# Konfigurace specifická pro prostředí
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. Správa promptů

Oddělte prompty od kódu

Prompt je obchodní aktivum, stejně jako obchodní pravidlo. Pokud jej zakopete do f-stringu uvnitř funkce, znemožníte jeho revizi někým, kdo zná byznys, ale neumí Python. Izolujte jej jako šablonu s parametry: funkce se pak zredukuje na formátování a volání, přičemž teplota 0,0 zajistí reprodukovatelnost klasifikace.

# 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()

Verzujte své prompty

Změna promptu mění chování systému stejně jistě jako změna kódu, ale žádný unit test si toho nemusí všimnout. Uchovávejte postupné verze a aktivní vybírejte prostřednictvím konfigurace. To vám umožní porovnat dvě formulace na reálném provozu a v případě zhoršení výsledků se vrátit k předchozí verzi pomocí proměnné prostředí.

PROMPTS = {
    "classification_v1": "Classify: {texte}",
    "classification_v2": "Analyze and classify precisely: {texte}",
}

# V produkci použijte konkrétní verzi
ACTIVE_PROMPT = os.environ.get("PROMPT_VERSION", "classification_v2")

3. Časové limity a omezení

Omezte jakýkoli vstup zvenčí, než dorazí k API. Uživatel, který vloží 200stránkové PDF do vašeho vstupního pole, nesmí mít možnost spustit volání za několik dolarů nebo způsobit selhání požadavku kvůli přeplnění kontextu. Preventivní zkrácení v kombinaci s omezením výstupu a teplotou z konfigurace činí náklady a latenci každého volání předvídatelnými.

def appel_avec_garde_fous(prompt: str) -> str:
    """Volání API se všemi pojistkami."""
    # Omezení velikosti promptu
    MAX_PROMPT_CHARS = 50000
    if len(prompt) > MAX_PROMPT_CHARS:
        prompt = prompt[:MAX_PROMPT_CHARS]
        print(f"Prompt zkrácen na {MAX_PROMPT_CHARS} znaků")

    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. Záložní model (Fallback)

Když je model přetížen nebo dočasně nedostupný, vrácení chyby není jedinou možností. Přepnutí na sekundární model sníží kvalitu, ale zachová službu – kompromis, který je často výhodnější pro asistenta podpory, méně již pro analýzu smluv. Smyčka iteruje modely v pořadí podle preference a výjimku vyhodí pouze v případě, že selžou všechny.

from openai import RateLimitError, InternalServerError

def appel_avec_fallback(prompt: str) -> str:
    """Zkusí Terra a v případě chyby přejde na 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} nedostupný: {e}")
            continue

    raise RuntimeError("Všechny modely jsou nedostupné")

5. Dávkové zpracování

Pro zpracování tisíce dokumentů jsou sekvenční volání příliš pomalá a simultánní volání vystřelí vaše limity rychlosti. Semafory dosahují správné rovnováhy. Dva detaily činí tuto implementaci robustní: return_exceptions=True zabrání tomu, aby jediné selhání zrušilo celou dávku, a seřazení podle indexu obnoví původní pořadí, které asyncio.gather v době provádění nezaručuje.

import asyncio
from openai import AsyncOpenAI

async def traiter_batch(prompts: list[str], max_concurrent: int = 5) -> list:
    """Zpracuje dávku promptů s omezenou souběžností."""
    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)

    # Seřazení podle indexu pro zachování pořadí
    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. Testování a validace

Potřebujete dva různé typy testů. První kontroluje „instalaci“ – klíč funguje, síť prochází, model odpovídá – a hodí se dobře pro kontrolu zdraví při startu. Druhý, originálnější, testuje samotnou kvalitu promptu: předložíte případ, kde znáte správnou odpověď, a ověříte, že se objeví. Tato tvrzení jsou vaší bezpečnostní sítí proti regresím při přeformulování šablony.

def test_api_disponible():
    """Ověří, že API je přístupné."""
    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:
    """Ověří, že prompt vrací konzistentní výsledek."""
    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

# Testy regrese promptů
assert test_prompt_quality(
    "Classify 'excellent product': positive or negative?",
    "positive"
)

Sestavte tucet takových testovacích případů reprezentativních pro vaše reálné použití a spouštějte je pokaždé, když upravíte prompt. Desetiminutová sada testů vám ušetří týdny pochybností o vnímané kvalitě.

7. Kontrolní seznam pro nasazení do produkce

Před nasazením ověřte každý bod:

Infrastruktura

  • Nakonfigurované proměnné prostředí (OPENAI_API_KEY atd.)
  • Nakonfigurované časové limity a max_retries
  • Zavedeno strukturované logování
  • Povoleno monitorování nákladů

Odolnost

  • Kompletní zpracování chyb (všechny HTTP kódy)
  • Exponenciální backoff pro opakování
  • Jistič (circuit breaker) pro dlouhodobé výpadky
  • Záložní přechod na alternativní model

Bezpečnost

  • Klíč API nikdy neodhalen v kódu ani logách
  • Validace uživatelského vstupu
  • Omezování rychlosti na straně klienta
  • Žádná citlivá data v promptech

Výkon

  • Streamování povoleno pro uživatelská rozhraní
  • Dávkové zpracování pro úlohy s vysokým objemem
  • Mezipaměť pro opakující se požadavky
  • Výběr modelu přizpůsobený každému úkolu

Náklady

  • Definován denní rozpočet
  • Nakonfigurována upozornění
  • Nastaveno max_output_tokens, kde je to možné
  • Pro každý úkol vybrán nejvýhodnější model

Klíčové poznatky

  • Centralizujte konfiguraci klienta pomocí singletonu
  • Oddělte a verzujte své prompty mimo kód
  • Implementujte záložní model pro vysokou dostupnost
  • Pro velké objemy používejte dávkové zpracování s omezenou souběžností
  • Testujte své prompty pomocí kontrol kvality
  • Před každým nasazením do produkce dodržujte kompletní kontrolní seznam