Azure in Production
Auf dieser Seite
Robuste Azure-Implementierung vorbereiten
Ein funktionierender Prototyp auf Ihrem Laptop und ein Produktionssystem unterscheiden sich nicht im Aufrufcode, der identisch bleibt. Sie unterscheiden sich in allem, was diesen Code umgibt: Woher die Geheimnisse stammen, wie Sie beobachten, was passiert, was geschieht, wenn der Datenverkehr sich verdoppelt, und welchen Netzwerkpfad die Daten durchlaufen. Diese Lektion behandelt diese vier Dimensionen für eine Mistral-Implementierung auf Azure.
Produktionsarchitektur
Eine typische Implementierung bringt fünf Bausteine zusammen. Der Azure AI-Endpunkt hostet das Mistral-Modell als MaaS; Azure Key Vault speichert API-Schlüssel; Azure Monitor und Application Insights bieten Observability; Azure API Management fungiert als Gateway mit Drosselung und Authentifizierung vor Ihrer Anwendung; schließlich stellt ein Azure Virtual Network Netzwerkkonfidentialität bereit, was optional ist, aber für sensible Daten oft erforderlich ist.
Ihr erster Schritt sollte sein, Geheimnisse aus Ihrem Code und Umgebungsvariablen zu entfernen und die Anwendung zu konfigurieren, diese beim Start aus Key Vault zu lesen.
from azure.identity import DefaultAzureCredential
from azure.keyvault.secrets import SecretClient
from mistralai.azure.client import MistralAzure
# Rufen Sie den API-Schlüssel aus Key Vault ab
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)
Der Vorteil geht über einfache Vertraulichkeit hinaus. Wenn Sie einen Schlüssel rotieren, ist keine Neudeployment der Anwendung erforderlich, da der Wert aus dem Vault gelesen wird und nicht hartcodiert in der Konfiguration steht.
Überwachung mit Application Insights
Ohne Instrumentierung ist das einzige, was Sie über einen Vorfall wissen, dass ein Benutzer die Anwendung als „langsam” findet. Das Verfolgen jedes Aufrufs mit seiner Dauer, der Token-Anzahl und dem Modell gibt Ihnen das, was Sie benötigen, um innerhalb weniger Minuten zu reagieren.
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-Aufruf mit Azure Monitor-Metriken."""
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
Diese Metriken sind nur dann wertvoll, wenn jemand sie überwacht. Konfigurieren Sie die entsprechenden Warnungen in Azure Monitor:
- P95-Latenz > 5s — Leistungsverschlechterung
- 5xx-Fehlerquote > 1% — Serverseitige Probleme
- 429-Fehler > 10/min — Drossellimit erreicht
- Tokenverbrauch > 80% des Kontingents — Annäherung an das Limit
Skalierbarkeit
Wenn das Volumen wächst, ist der erste Fehler, das Modell synchron vom eingehenden HTTP-Anfrage aus aufzurufen: Jede Verlangsamung propagiert direkt zum Benutzer. Die Entkopplung mit Azure Service Bus ermöglicht es, Spitzen abzufangen – Anfragen stapeln sich in einer Warteschlange und werden im Tempo verarbeitet, das Ihr Kontingent zulässt.
from azure.servicebus import ServiceBusClient, ServiceBusMessage
import json
# Producer: Senden Sie Anfragen an die Warteschlange
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: Verarbeiten Sie Anfragen aus der Warteschlange
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"]}]
)
# Speichern Sie das Ergebnis...
receiver.complete_message(msg)
Wenn die Engstelle von der Durchsatzkapazität selbst stammt und nicht von der momentanen Last, deployen Sie mehrere Endpunkte für dasselbe Modell und verteilen Sie die Aufrufe über diese hinweg.
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():
"""Einfache Round-Robin-Verteilung über Endpunkte."""
ep = random.choice(endpoints)
return MistralAzure(server_url=ep["url"], api_key=ep["key"])
Netzwerksicherheit
Für sensible Daten stellt Azure Private Link sicher, dass der Verkehr zwischen Ihrer Anwendung und dem Mistral-Endpunkt niemals das öffentliche Internet durchquert. Die Konfiguration erfolgt in vier Schritten:
- Erstellen Sie einen Private Endpoint in Ihrem VNet
- Verknüpfen Sie diesen mit Ihrem Azure AI-Ressource
- Deaktivieren Sie den öffentlichen Zugriff auf den Endpunkt
- Konfigurieren Sie privaten DNS für die Auflösung
Schritt drei ist derjenige, den Menschen vergessen, und ohne ihn bleibt der öffentliche Pfad parallel offen: Private Link existiert, aber nichts verhindert, dass er umgangen wird.
Im selben Geist entfernt eine Verwaltete Identität den API-Schlüssel aus der Gleichung: Die Anwendung erhält ihre Tokens von Microsoft Entra ID, sodass kein Geheimnis gespeichert oder rotiert werden muss. Es gelten jedoch zwei Bedingungen. Der von Mistral dokumentierte MistralAzure-Client authentifiziert sich per Schlüssel; die schlüssellose Authentifizierung, die Microsoft beschreibt, läuft über ein Modell, das in einer Microsoft Foundry-Ressource bereitgestellt ist, und wird über dessen OpenAI-kompatiblen Pfad /openai/v1/ abgefragt, wobei Tokens für den Bereich https://ai.azure.com/.default. ausgestellt werden. Und die Identität muss zuvor die Inferenzrolle auf der Ressource erhalten haben. Ein Token-Provider erneuert den Zugriff vor Ablauf, anstatt nur einmal beim Start gelesen zu werden:
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 Ihrer Bereitstellung
messages=[{"role": "user", "content": "Fassen Sie die Datenretentionsrichtlinie zusammen."}],
)
print(response.choices[0].message.content)
Quelle: Endpoints for Microsoft Foundry Models — keyless authentication.
Produktionsbereitschafts-Checkliste
Bevor Sie Ihre Implementierung als bereit erklären, gehen Sie die Kette in der Reihenfolge durch, in der sie erstellt wurde. Umgebungsvariablen und Geheimnisse müssen in Key Vault migriert sein, und Ihr Aufrufcode muss durch exponentielle Wiederholung geschützt sein, die sowohl 429- als auch 5xx-Fehler abdeckt. Die Application Insights-Überwachung muss Latenz, Fehler und Tokens melden, wobei entsprechende Warnungen tatsächlich für kritische Metriken konfiguriert sind – nicht nur geplant. Schließlich befassen Sie sich mit dem, was Menschen tendenziell hinauszögern: Lasttests werden tatsächlich ausgeführt, privater Netzwerzzugang, falls Daten sensibel sind, und die Rotation von API-Schlüsseln ist mit einem Datum geplant, nicht dem allgemeinen Ermessen überlassen.
Kernaussagen
- Verwenden Sie Azure Key Vault zum Speichern von API-Schlüsseln, nicht von Klartext-Umgebungsvariablen
- Überwachen Sie jeden Aufruf mit Application Insights (Latenz, Tokens, Fehler)
- Entkoppeln Sie mit Service Bus für Hochvolumen-Arbeitslasten
- Verwenden Sie Private Link und Verwaltete Identität für sichere Umgebungen
- Führen Sie Lasttests durch und konfigurieren Sie Warnungen, bevor Sie in die Produktion gehen