Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Azure i produktion

Lektion 6 av 14 Uppdaterad 2 november 2026 Avancerad
På denna sida
  1. Förbered en robust Azure-distribution
  2. Produktionsarkitektur
  3. Övervakning med Application Insights
  4. Skalbarhet
  5. Nätverkssäkerhet
  6. Checklista för produktionsredo
  7. Viktiga punkter

Förbered en robust Azure-distribution

En fungerande prototyp på din bärbara dator och ett produktionssystem skiljer sig inte åt i den anropande koden, som förblir identisk. De skiljer sig åt i allt som omger den koden: var hemligheter hämtas, hur du observerar vad som händer, vad som sker när trafiken fördubblas och vilken nätväg datan färdas. Denna lektion täcker dessa fyra dimensioner för en Mistral-distribution på Azure.

Produktionsarkitektur

En typisk distribution sammanför fem byggstenar. Azure AI-endpunkten värdar Mistral-modellen som MaaS; Azure Key Vault lagrar API-nycklar; Azure Monitor och Application Insights tillhandahåller observerbarhet; Azure API Management fungerar som en gateway med strypning och autentisering framför din applikation; slutligen tillhandahåller ett Azure Virtual Network nätverksisolering, vilket är valfritt men ofta krävs för känslig data.

Ditt första steg bör vara att flytta hemligheter ur din kod och dina miljövariabler, så att applikationen läser dem vid start från Key Vault istället.

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)

Fördelen går bortom enkel konfidentialitet. När du roterar en nyckel krävs ingen omstart av applikationen eftersom värdet läses från valvet snarare än att vara hårdkodat i konfigurationen.

Övervakning med Application Insights

Utan instrumentering är det enda du vet om en incident att en användare finner applikationen “långsam”. Spårning av varje anrop med dess varaktighet, antal token och modell ger dig det du behöver för att reagera inom minuter.

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

Dessa mätvärden är bara värdefulla om någon bevakar dem. Konfigurera motsvarande varningar i Azure Monitor:

  • P95-latens > 5 s – prestandaförsämring
  • 5xx-felfrekvens > 1 % – serversidiga problem
  • 429-fel > 10/min – hastighetsbegränsning nådd
  • Tokenförbrukning > 80 % av kvoten – närmar sig gränsen

Skalbarhet

När volymen växer är det första misstaget att anropa modellen synkront från den inkommande HTTP-begäran: varje försening propageras direkt till användaren. Att koppla bort med Azure Service Bus låter dig absorbera toppar – begäranden samlas i en kö och konsumeras i den takt din kvot tillåter.

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)

Om flaskhalsen kommer från själva genomströmningen snarare än momentan belastning, distribuera flera endpunkter för samma modell och fördela anropen mellan 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"])

Nätverkssäkerhet

För känslig data säkerställer Azure Private Link att trafiken mellan din applikation och Mistral-endpunkten aldrig korsar det publika internet. Konfigurationen sker i fyra steg:

  1. Skapa en privat endpunkt i ditt VNet
  2. Länka den till din Azure AI-resurs
  3. Inaktivera publik åtkomst på endpunkten
  4. Konfigurera privat DNS för uppslagning

Steg tre är det folk glömmer, och utan det förblir den publika vägen öppen parallellt: Private Link existerar, men inget hindrar att man kringgår den.

I samma anda tar en hanterad identitet bort API-nyckeln ur ekvationen: applikationen hämtar sina token från Microsoft Entra ID, så det finns ingen hemlighet att lagra eller rotera. Två villkor gäller dock. Klienten MistralAzure som dokumenteras av Mistral autentiserar med nyckel; den nyckellösa autentisering Microsoft beskriver går via en modell distribuerad i en Microsoft Foundry-resurs, frågad på sin OpenAI-kompatibla rutt /openai/v1/, med token utfärdade för omfånget https://ai.azure.com/.default. Och identiteten måste ha beviljats inferensrollen på resursen i förväg. En tokenleverantör, snarare än ett token som läses en gång vid start, förnyar åtkomsten före utgång:

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)

Källa: Endpoints for Microsoft Foundry Models — keyless authentication.

Checklista för produktionsredo

Innan du förklarar din distribution redo, gå igenom kedjan i den ordning den byggdes. Miljövariabler och hemligheter måste ha migrerats till Key Vault, och din anropande kod måste skyddas av exponentiell återförsök som täcker både 429- och 5xx-fel. Övervakning med Application Insights måste rapportera latens, fel och token, med motsvarande varningar faktiskt konfigurerade för kritiska mätvärden – inte bara planerade. Slutligen, ta itu med det folk tenderar att skjuta upp: lasttester som faktiskt körs, privat nätverksåtkomst om datan är känslig, och rotation av API-nycklar schemalagd med ett datum, inte lämnad till allmänt omdöme.

Viktiga punkter

  • Använd Azure Key Vault för att lagra API-nycklar, inte klartext i miljövariabler
  • Övervaka varje anrop med Application Insights (latens, token, fel)
  • Koppla bort med Service Bus för arbetsbelastningar med hög volym
  • Använd Private Link och hanterad identitet för säkra miljöer
  • Kör lasttester och konfigurera varningar innan du går till produktion