Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Azure i produktion

Lektion 6 af 14 Opdateret 2. november 2026 Avanceret
På denne side
  1. Forbered en robust Azure-implementering
  2. Produktionsarkitektur
  3. Overvågning med Application Insights
  4. Skalerbarhed
  5. Netværkssikkerhed
  6. Tjekliste til produktionsklarhed
  7. Vigtige pointer

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:

  1. Opret et Private Endpoint i dit VNet
  2. Link det til din Azure AI-ressource
  3. Deaktiver offentlig adgang på endpointet
  4. 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