Azure i produktion
På denne side
Forbered en robust Azure-implementering
En fungerende prototype på din bærbar og et produktionssystem adskiller sig ikke i deres kaldende kode, som forbliver identisk. De adskiller sig i alt omkring den kode: hvor hemmeligheder kommer fra, hvordan du observerer, hvad der sker, hvad der sker, når trafikken fordobles, og hvilken netværkssti data rejser. Denne lektion dækker disse fire dimensioner for en Mistral-implementering på Azure.
Produktionsarkitektur
En typisk implementering samler fem byggesten. Azure AI-endpointet hoster Mistral-modellen som MaaS; Azure Key Vault gemmer API-nøgler; Azure Monitor og Application Insights giver observabilitet; Azure API Management fungerer som en gateway med throttling og godkendelse foran din applikation; endelig giver et Azure Virtual Network netværksisolering, hvilket er valgfrit, men ofte påkrævet for følsomme data.
Dit første træk bør være at fjerne hemmeligheder fra din kode og miljøvariabler, så applikationen læser dem ved opstart fra Key Vault i stedet.
from azure.identity import DefaultAzureCredential
from azure.keyvault.secrets import SecretClient
from mistralai.azure.client import MistralAzure
# Retrieve the API key from 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)
Fordelen går ud over simpel fortrolighed. Når du roterer en nøgle, er ingen genudrulning af applikationen nødvendig, fordi værdien læses fra vaultet i stedet for at være hardcodet i konfigurationen.
Overvågning med Application Insights
Uden instrumentering er det eneste, du vil vide om en hændelse, at en bruger finder applikationen “langsom”. Sporing af hvert kald med dets varighed, antal tokens og model giver dig det, du har brug for til at reagere inden for minutter.
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"):
"""Mistral call with Azure Monitor metrics."""
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
Disse målinger er kun værdifulde, hvis nogen holder øje med dem. Konfigurer de tilsvarende alarmer i Azure Monitor:
- P95-latens > 5 s – ydelsesforringelse
- 5xx-fejlrate > 1 % – server-side problemer
- 429-fejl > 10/min – hastighedsbegrænsning nået
- Tokenforbrug > 80 % af kvoten – nærmer sig grænsen
Skalerbarhed
Når volumenet vokser, er den første fejl at kalde modellen synkront fra den indgående HTTP-anmodning: enhver afmatning forplanter sig direkte til brugeren. Afkobling med Azure Service Bus lader dig absorbere toppe – anmodninger hobes op i en kø og forbruges i det tempo, din kvote tillader.
from azure.servicebus import ServiceBusClient, ServiceBusMessage
import json
# Producer: send requests to the queue
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)
# Consumer: process requests from the queue
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"]}]
)
# Store the result...
receiver.complete_message(msg)
Hvis flaskehalsen kommer fra selve gennemstrømningen snarere end øjeblikkelig belastning, skal du implementere flere endpoints for den samme model og fordele kald på tværs af dem.
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():
"""Simple round-robin across endpoints."""
ep = random.choice(endpoints)
return MistralAzure(server_url=ep["url"], api_key=ep["key"])
Netværkssikkerhed
For følsomme data sikrer Azure Private Link, at trafikken mellem din applikation og Mistral-endpointet aldrig krydser det offentlige internet. Konfigurationen sker i fire trin:
- Opret et Private Endpoint i dit VNet
- Link det til din Azure AI-ressource
- Deaktiver offentlig adgang på endpointet
- Konfigurer privat DNS til opløsning
Trin tre er det, folk glemmer, og uden det forbliver den offentlige sti åben parallelt: Private Link eksisterer, men intet forhindrer omgåelse af det.
I samme ånd fjerner en Managed Identity API-nøglen fra ligningen: applikationen henter sine tokens fra Microsoft Entra ID, så der er ingen hemmelighed at gemme eller rotere. To betingelser gælder dog. MistralAzure-klienten dokumenteret af Mistral godkender via nøgle; den nøglefri godkendelse, Microsoft beskriver, går gennem en model implementeret i en Microsoft Foundry-ressource, forespurgt på dens OpenAI-kompatible rute /openai/v1/, med tokens udstedt for scope https://ai.azure.com/.default. Og identiteten skal på forhånd have fået tildelt inferensrollen på ressourcen. En tokenudbyder, snarere end et token læst én gang ved opstart, fornyer adgangen før udløb:
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", # name of your deployment
messages=[{"role": "user", "content": "Summarize the data retention policy."}],
)
print(response.choices[0].message.content)
Kilde: Endpoints for Microsoft Foundry Models — keyless authentication.
Tjekliste til produktionsklarhed
Før du erklærer din implementering klar, skal du gennemgå kæden i den rækkefølge, den blev bygget. Miljøvariabler og hemmeligheder skal være migreret til Key Vault, og din kaldende kode skal være beskyttet af eksponentiel genforsøg, der dækker både 429- og 5xx-fejl. Application Insights-overvågning skal rapportere latens, fejl og tokens, med tilsvarende alarmer faktisk konfigureret på kritiske målinger – ikke bare planlagt. Endelig skal du tackle det, folk har tendens til at udskyde: belastningstests faktisk kørt, privat netværksadgang hvis data er følsomme, og rotation af API-nøgler planlagt med en dato, ikke overladt til generelt skøn.
Vigtige pointer
- Brug Azure Key Vault til at gemme API-nøgler, ikke almindelige miljøvariabler
- Overvåg hvert kald med Application Insights (latens, tokens, fejl)
- Afkob med Service Bus til arbejdsbelastninger med højt volumen
- Brug Private Link og Managed Identity til sikre miljøer
- Kør belastningstests og konfigurer alarmer, før du går i produktion