Azure v produkci
Na této stránce
Příprava robustního nasazení na Azure
Fungující prototyp na tvém laptopu a produkční systém se neliší volacím kódem, který zůstává totožný. Liší se ve všem, co tento kód obklopuje: odkud pocházejí tajné údaje, jak sleduješ dění, co se stane při zdvojnásobení provozu a kudy putují data po síti. Tato lekce pokrývá tyto čtyři dimenze pro nasazení Mistral na Azure.
Produkční architektura
Typické nasazení spojuje pět stavebních kamenů. Koncový bod Azure AI hostuje model Mistral jako MaaS; Azure Key Vault ukládá klíče API; Azure Monitor a Application Insights zajišťují pozorovatelnost; Azure API Management funguje jako brána s omezováním rychlosti a ověřováním před tvou aplikací; nakonec Azure Virtual Network poskytuje izolaci sítě, což je volitelné, ale u citlivých dat často nezbytné.
Tvým prvním krokem by mělo být vytažení tajných údajů z kódu a proměnných prostředí tak, aby si je aplikace při startu četla přímo z Key Vault.
from azure.identity import DefaultAzureCredential
from azure.keyvault.secrets import SecretClient
from mistralai.azure.client import MistralAzure
# Načtení klíče API z Key Vault
credential = DefaultAzureCredential()
vault_url = "https://mon-keyvault.vault.azure.net"
secret_client = SecretClient(vault_url=vault_url, credential=credential)
endpoint = secret_client.get_secret("mistral-endpoint").value
api_key = secret_client.get_secret("mistral-api-key").value
client = MistralAzure(server_url=endpoint, api_key=api_key)
Přínos přesahuje prostou důvěrnost. Když rotuješ klíč, není potřeba žádné nové nasazení aplikace, protože hodnota se čte z trezoru, nikoliv není natvrdo zakódována v konfiguraci.
Monitorování s Application Insights
Bez instrumentace se o incidentu dozvíš jen to, že uživatel považuje aplikaci za „pomalou“. Trasování každého volání s jeho dobou trvání, počtem tokenů a použitým modelem ti dá vše potřebné k reakci během minut.
import time
import logging
from opencensus.ext.azure.log_exporter import AzureLogHandler
logger = logging.getLogger(__name__)
logger.addHandler(AzureLogHandler(
connection_string="InstrumentationKey=your-key"
))
def monitored_call(client, messages, model="azureai"):
"""Volání Mistral s metrikami Azure Monitor."""
start = time.time()
try:
response = client.chat.complete(model=model, messages=messages)
duration = time.time() - start
logger.info(
"MistralCall",
extra={
"custom_dimensions": {
"duration_ms": int(duration * 1000),
"prompt_tokens": response.usage.prompt_tokens,
"completion_tokens": response.usage.completion_tokens,
"model": model
}
}
)
return response
except Exception as e:
duration = time.time() - start
logger.error(
f"MistralError: {e}",
extra={
"custom_dimensions": {
"duration_ms": int(duration * 1000),
"error_type": type(e).__name__
}
}
)
raise
Tyto metriky mají cenu pouze tehdy, pokud je někdo sleduje. Nakonfiguruj odpovídající alerty v Azure Monitor:
- Latence P95 > 5 s – degradace výkonu
- Chybovost 5xx > 1 % – problémy na straně serveru
- Chyby 429 > 10/min – dosažen limit rychlosti
- Spotřeba tokenů > 80 % kvóty – blížící se limit
Škálovatelnost
Když roste objem, první chybou je synchronní volání modelu z příchozího HTTP požadavku: jakékoli zpomalení se přímo přenese na uživatele. Oddělení pomocí Azure Service Bus ti umožní absorbovat špičky – požadavky se hromadí ve frontě a jsou zpracovávány tempem, které umožňuje tvoje kvóta.
from azure.servicebus import ServiceBusClient, ServiceBusMessage
import json
# Producent: odeslání požadavků do fronty
def enqueue_request(prompt: str, request_id: str):
with ServiceBusClient.from_connection_string(conn_str) as sb_client:
sender = sb_client.get_queue_sender(queue_name="mistral-requests")
message = ServiceBusMessage(
json.dumps({"prompt": prompt, "request_id": request_id})
)
sender.send_messages(message)
# Konzument: zpracování požadavků z fronty
def process_queue():
with ServiceBusClient.from_connection_string(conn_str) as sb_client:
receiver = sb_client.get_queue_receiver(queue_name="mistral-requests")
for msg in receiver:
data = json.loads(str(msg))
response = client.chat.complete(
model="azureai",
messages=[{"role": "user", "content": data["prompt"]}]
)
# Uložení výsledku...
receiver.complete_message(msg)
Pokud úzkým hrdlem není okamžitá zátěž, ale samotná propustnost, nasaď více koncových bodů pro stejný model a rozlož mezi ně volání.
import random
endpoints = [
{"url": os.environ["AZUREAI_ENDPOINT_1"], "key": os.environ["AZUREAI_KEY_1"]},
{"url": os.environ["AZUREAI_ENDPOINT_2"], "key": os.environ["AZUREAI_KEY_2"]},
]
def get_client():
"""Jednoduchý round-robin mezi koncovými body."""
ep = random.choice(endpoints)
return MistralAzure(server_url=ep["url"], api_key=ep["key"])
Zabezpečení sítě
U citlivých dat Azure Private Link zajišťuje, že provoz mezi tvou aplikací a koncovým bodem Mistral nikdy neopustí veřejný internet. Konfigurace probíhá ve čtyřech krocích:
- Vytvoř privátní koncový bod ve své VNet
- Propoj jej se svým zdrojem Azure AI
- Zakaž veřejný přístup na koncovém bodu
- Nakonfiguruj privátní DNS pro překlad názvů
Třetí krok je ten, na který lidé zapomínají, a bez něj zůstává veřejná cesta otevřená paralelně: Private Link existuje, ale nic nebrání jeho obejití.
Ve stejném duchu Managed Identity odstraní klíč API z rovnice: aplikace získává své tokeny od Microsoft Entra ID, takže není co ukládat ani rotovat. Platí však dvě podmínky. Klient MistralAzure dokumentovaný společností Mistral se ověřuje klíčem; ověření bez klíče, které popisuje Microsoft, probíhá přes model nasazený ve zdroji Microsoft Foundry, dotazovaný na jeho route kompatibilní s OpenAI /openai/v1/, s tokeny vydanými pro scope https://ai.azure.com/.default. Identita musí mít navíc předem udělenou roli pro inferenci na tomto zdroji. Poskytovatel tokenů, nikoliv token načtený jednou při startu, obnovuje přístup před vypršením:
from azure.identity import ManagedIdentityCredential, get_bearer_token_provider
from openai import OpenAI
token_provider = get_bearer_token_provider(
ManagedIdentityCredential(),
"https://ai.azure.com/.default",
)
client = OpenAI(
base_url="https://<resource>.openai.azure.com/openai/v1/",
api_key=token_provider,
)
response = client.chat.completions.create(
model="my-mistral-deployment", # název tvého nasazení
messages=[{"role": "user", "content": "Shrň zásady uchovávání dat."}],
)
print(response.choices[0].message.content)
Zdroj: Endpoints for Microsoft Foundry Models — keyless authentication.
Kontrolní seznam připravenosti k produkci
Než prohlásíš své nasazení za hotové, projdi řetězec v pořadí, v jakém byl budován. Proměnné prostředí a tajné údaje se musí přesunout do Key Vault a tvůj volací kód musí být chráněn exponenciálním opakováním pokrývajícím chyby 429 i 5xx. Monitorování Application Insights musí hlásit latenci, chyby a tokeny, přičemž na kritické metriky musí být skutečně nakonfigurovány alerty – ne jen naplánovány. Nakonec se pusť do toho, co lidé mají tendenci odkládat: skutečně provedené zátěžové testy, přístup přes privátní síť, pokud jsou data citlivá, a rotace klíčů API naplánovaná na konkrétní datum, nikoliv ponechaná na obecném uvážení.
Klíčové poznatky
- Používej Azure Key Vault k ukládání klíčů API, nikoliv prosté textové proměnné prostředí
- Monitoruj každé volání pomocí Application Insights (latence, tokeny, chyby)
- Pro vysoké objemy práce odděl komponenty pomocí Service Bus
- V zabezpečených prostředích používej Private Link a Managed Identity
- Před nasazením do produkce proveď zátěžové testy a nakonfiguruj alerty