Azure v produkcii
Na tejto strane
Príprava robustného nasadenia na Azure
Fungujúci prototyp na tvojom notebooku sa od produkčného systému nelíši vo volacom kóde, ktorý zostáva identický. Líšia sa vo všetkom, čo tento kód obklopuje: odkiaľ pochádzajú tajné údaje, ako sleduješ dianie, čo sa stane pri zdvojnásobení prevádzky a ktorou sieťovou cestou putujú dáta. Táto lekcia pokrýva tieto štyri dimenzie pre nasadenie modelu Mistral na Azure.
Produkčná architektúra
Typické nasadenie spája päť stavebných blokov. Koncový bod Azure AI hostí model Mistral ako MaaS; Azure Key Vault ukladá kľúče API; Azure Monitor a Application Insights zabezpečujú pozorovateľnosť; Azure API Management funguje ako brána s obmedzovaním rýchlosti a overovaním pred tvojou aplikáciou; a napokon Azure Virtual Network poskytuje sieťovú izoláciu, čo je voliteľné, ale často potrebné pre citlivé dáta.
Tvojím prvým krokom by malo byť vytiahnutie tajných údajov z kódu a premenných prostredia tak, aby si ich aplikácia čítala pri štarte priamo z Key Vault.
from azure.identity import DefaultAzureCredential
from azure.keyvault.secrets import SecretClient
from mistralai.azure.client import MistralAzure
# Získanie kľúča 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)
Prínos presahuje jednoduchú dôvernosť. Keď rotuješ kľúč, nie je potrebné opätovné nasadenie aplikácie, pretože hodnota sa číta z trezoru, namiesto toho, aby bola natvrdo zakódovaná v konfigurácii.
Monitorovanie s Application Insights
Bez inštrumentácie budeš o incidente vedieť len to, že používateľ označí aplikáciu ako „pomalú“. Sledovanie každého volania s jeho trvaním, počtom tokenov a použitým modelom ti dáva to, čo potrebuješ na reakciu v priebehu minút.
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"):
"""Volanie 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
Tieto metriky majú hodnotu len vtedy, ak ich niekto sleduje. Nakonfiguruj zodpovedajúce alerty v Azure Monitor:
- Latencia P95 > 5 s – zhoršenie výkonu
- Miera chýb 5xx > 1 % – problémy na strane servera
- Chyby 429 > 10/min – dosiahnutý limit rýchlosti
- Spotreba tokenov > 80 % kvóty – blížiaci sa limit
Škálovateľnosť
Keď objem rastie, prvou chybou je synchronné volanie modelu z prichádzajúcej HTTP požiadavky: akékoľvek spomalenie sa priamo prenesie na používateľa. Oddelenie pomocou Azure Service Bus ti umožní absorbovať špičky – požiadavky sa hromadia v fronte a sú spracovávané tempom, ktoré tvoja kvóta dovoľuje.
from azure.servicebus import ServiceBusClient, ServiceBusMessage
import json
# Producent: odoslanie požiadaviek 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: spracovanie požiadaviek 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ženie výsledku...
receiver.complete_message(msg)
Ak úzkym hrdlom nie je okamžitá záťaž, ale samotná priepustnosť, nasadź viacero koncových bodov pre ten istý model a rozdeľuj medzi ne volania.
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 medzi koncovými bodmi."""
ep = random.choice(endpoints)
return MistralAzure(server_url=ep["url"], api_key=ep["key"])
Sieťová bezpečnosť
Pre citlivé dáta Azure Private Link zabezpečuje, že premávka medzi tvojou aplikáciou a koncovým bodom Mistral nikdy neprejde cez verejný internet. Konfigurácia prebieha v štyroch krokoch:
- Vytvorenie súkromného koncového bodu (Private Endpoint) vo tvojej VNet
- Prepojenie s tvojím zdrojom Azure AI
- Zakázanie verejného prístupu na koncovom bode
- Konfigurácia súkromného DNS pre rozlíšenie
Tretí krok je ten, na ktorý ľudia zabúdajú, a bez neho zostáva verejná cesta otvorená paralelne: Private Link existuje, ale nič nebráni jeho obchádzaniu.
V rovnakom duchu Managed Identity odstraňuje kľúč API z rovnice: aplikácia získava svoje tokeny od Microsoft Entra ID, takže nie je čo ukladať ani rotovať. Platia však dve podmienky. Klient MistralAzure dokumentovaný spoločnosťou Mistral sa overuje kľúčom; overovanie bez kľúča, ktoré opisuje Microsoft, prebieha cez model nasadený v zdroji Microsoft Foundry, dotazovaný na jeho rute kompatibilnej s OpenAI /openai/v1/, s tokenmi vydanými pre rozsah https://ai.azure.com/.default. Identita musí mať navyše vopred pridelenú rolu inferencie na tomto zdroji. Poskytovateľ tokenov, namiesto jednorazového prečítania tokenu pri štarte, obnovuje prístup pred vypršaním platnosti:
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ázov tvojho nasadenia
messages=[{"role": "user", "content": "Zhrň politiku uchovávania dát."}],
)
print(response.choices[0].message.content)
Zdroj: Koncové body pre modely Microsoft Foundry – overovanie bez kľúča.
Kontrolný zoznam pripravenosti na produkciu
Predtým, ako vyhlásiš svoje nasadenie za hotové, prejdite reťazec v poradí, v akom bol vytvorený. Premenné prostredia a tajné údaje sa musia presunúť do Key Vault a tvoj volací kód musí byť chránený exponenciálnym opakovaním pokusov, ktoré pokrýva chyby 429 aj 5xx. Monitorovanie Application Insights musí hlásiť latenciu, chyby a tokeny, pričom na kritické metriky musia byť skutočne nakonfigurované alerty – nielen naplánované. Napokon sa pust do toho, čo ľudia tendujú odkladať: skutočne spustené záťažové testy, prístup cez súkromnú sieť, ak sú dáta citlivé, a rotácia kľúčov API naplánovaná na konkrétny dátum, nie ponechaná na všeobecné uváženie.
Kľúčové poznatky
- Na ukladanie kľúčov API používaj Azure Key Vault, nie plain textové premenné prostredia
- Monitoruj každé volanie pomocou Application Insights (latencia, tokeny, chyby)
- Pre vysoké objemy práce oddel komponenty pomocou Service Bus
- Pre bezpečné prostredia používaj Private Link a Managed Identity
- Pred nasadením do produkcie spusti záťažové testy a nakonfiguruj alerty