Azure in productie
Op deze pagina
Een robuuste Azure-implementatie voorbereiden
Een werkend prototype op uw laptop en een productiesysteem verschillen niet in hun aanroepcode; deze blijft identiek. Het verschil zit in alles eromheen: waar geheimen vandaan komen, hoe u observeert wat er gebeurt, wat er gebeurt wanneer het verkeer verdubbelt en welk netwerkpads de data aflegt. Deze les behandelt deze vier dimensies voor een Mistral-implementatie op Azure.
Productiearchitectuur
Een typische implementatie brengt vijf bouwstenen samen. Het Azure AI-eindpunt host het Mistral-model als MaaS; Azure Key Vault slaat API-sleutels op; Azure Monitor en Application Insights bieden observeerbaarheid; Azure API Management fungeert als gateway met throttling en authenticatie voor uw applicatie; tot slot biedt een Azure Virtual Network netwerkisolation, wat optioneel is maar vaak vereist voor gevoelige data.
Uw eerste stap moet zijn om geheimen uit uw code en omgevingsvariabelen te halen, zodat de applicatie deze bij opstarten uitleest vanuit Key Vault.
from azure.identity import DefaultAzureCredential
from azure.keyvault.secrets import SecretClient
from mistralai.azure.client import MistralAzure
# Haal de API-sleutel op uit 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)
Het voordeel gaat verder dan eenvoudige vertrouwelijkheid. Wanneer u een sleutel roteert, is geen herimplementatie van de applicatie nodig omdat de waarde uit de kluis wordt gelezen in plaats van hardgecodeerd in de configuratie te staan.
Monitoring met Application Insights
Zonder instrumentatie is het enige wat u over een incident weet, dat een gebruiker de applicatie “traag” vindt. Het traceren van elke aanroep met de duur, het aantal tokens en het model geeft u wat u nodig hebt om binnen enkele minuten te reageren.
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-aanroep met Azure Monitor-metrieken."""
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
Deze metrieken zijn alleen waardevol als iemand ze in de gaten houdt. Configureer de bijbehorende waarschuwingen in Azure Monitor:
- P95-latentie > 5s — prestatievermindering
- 5xx-foutpercentage > 1% — serverzijde problemen
- 429-fouten > 10/min — tarieflimiet bereikt
- Tokenverbruik > 80% van quota — limiet naderen
Schaalbaarheid
Wanneer het volume groeit, is de eerste fout om het model synchroon aan te roepen vanuit het binnenkomende HTTP-verzoek: elke vertraging plant zich rechtstreeks voort naar de gebruiker. Ontkoppeling met Azure Service Bus stelt u in staat pieken op te vangen; verzoeken stapelen zich op in een wachtrij en worden verwerkt op het tempo dat uw quota toelaat.
from azure.servicebus import ServiceBusClient, ServiceBusMessage
import json
# Producent: verzoeken naar de wachtrij sturen
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)
# Consument: verzoeken uit de wachtrij verwerken
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"]}]
)
# Sla het resultaat op...
receiver.complete_message(msg)
Als de bottleneck komt van de doorvoer zelf in plaats van de momentane belasting, implementeer dan meerdere eindpunten voor hetzelfde model en verdeel de aanroepen daarover.
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():
"""Eenvoudige round-robin over eindpunten."""
ep = random.choice(endpoints)
return MistralAzure(server_url=ep["url"], api_key=ep["key"])
Netwerkbeveiliging
Voor gevoelige data zorgt Azure Private Link ervoor dat verkeer tussen uw applicatie en het Mistral-eindpunt nooit het openbare internet kruist. De configuratie gebeurt in vier stappen:
- Maak een Private Endpoint in uw VNet
- Koppel deze aan uw Azure AI-bron
- Schakel openbare toegang op het eindpunt uit
- Configureer private DNS voor resolutie
Stap drie is degene die mensen vergeten, en zonder deze blijft het openbare pad parallel open: Private Link bestaat, maar niets verhindert omzeiling.
In dezelfde geest verwijdert een Managed Identity de API-sleutel uit de vergelijking: de applicatie verkrijgt zijn tokens van Microsoft Entra ID, dus er is geen geheim om op te slaan of te roteren. Er gelden echter twee voorwaarden. De MistralAzure-client zoals gedocumenteerd door Mistral authenticeert via sleutel; de sleutelloze authenticatie die Microsoft beschrijft, loopt via een model dat is geïmplementeerd in een Microsoft Foundry-bron, bevraagd op zijn OpenAI-compatibele route /openai/v1/, met tokens uitgegeven voor het bereik https://ai.azure.com/.default. En de identiteit moet vooraf de inferentierol op de bron hebben gekregen. Een tokenprovider, in plaats van een token dat eenmaal bij opstarten wordt gelezen, vernieuwt de toegang voordat deze verloopt:
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", # naam van uw implementatie
messages=[{"role": "user", "content": "Summarize the data retention policy."}],
)
print(response.choices[0].message.content)
Bron: Endpoints for Microsoft Foundry Models — keyless authentication.
Checklist voor productieklaarheid
Voordat u uw implementatie als klaar declareert, doorloopt u de keten in de volgorde waarin deze is gebouwd. Omgevingsvariabelen en geheimen moeten zijn gemigreerd naar Key Vault, en uw aanroepcode moet worden beschermd door exponentiële retry die zowel 429- als 5xx-fouten afdekt. Application Insights-monitoring moet latentie, fouten en tokens rapporteren, met daadwerkelijk geconfigureerde waarschuwingen voor kritieke metrieken – niet alleen gepland. Pak ten slotte aan wat mensen neigen uit te stellen: load-tests die daadwerkelijk zijn uitgevoerd, toegang via privénetwerk als de data gevoelig is, en API-sleutelrotatie gepland met een datum, niet overgelaten aan algemene discretie.
Belangrijkste punten
- Gebruik Azure Key Vault om API-sleutels op te slaan, niet als platte tekst in omgevingsvariabelen
- Monitor elke aanroep met Application Insights (latentie, tokens, fouten)
- Koppel los met Service Bus voor workloads met hoog volume
- Gebruik Private Link en Managed Identity voor beveiligde omgevingen
- Voer load-tests uit en configureer waarschuwingen voordat u naar productie gaat