Osvědčené postupy pro nasazení do produkce
Na této stránce
Lekce aktualizována 3. listopadu 2026 na základě dokumentace OpenAI: parametry
temperatureatop_pjsou přijímány pouze při úsilí o uvažování (reasoning effort) nastaveném nanone, zatímco modely GPT-5.6 ve výchozím nastavení uvažují (medium). Volání, která tyto parametry nastavují, musí proto specifikovatreasoning={"effort": "none"}(Responses API) neboreasoning_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