Azure en production

Préparer un déploiement Azure robuste

Passer d’un prototype à un système de production avec Mistral sur Azure nécessite une attention particulière à la scalabilité, au monitoring et à l’intégration avec l’écosystème Azure. Cette leçon couvre les bonnes pratiques pour un déploiement fiable.

Architecture de production

Composants recommandés

Un déploiement production typique sur Azure combine :

• Azure AI endpoint — le modèle Mistral en MaaS
• Azure Key Vault — stockage sécurisé des clés API
• Azure Monitor / Application Insights — observabilité
• Azure API Management — gateway API avec throttling et authentification
• Azure Virtual Network — isolation réseau (optionnel)

Récupérer les secrets depuis Key Vault

from azure.identity import DefaultAzureCredential
from azure.keyvault.secrets import SecretClient
from mistralai import MistralAzure

# Récupérer la clé API depuis 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(azure_endpoint=endpoint, azure_api_key=api_key)

Cette approche évite de stocker les secrets dans des variables d’environnement ou des fichiers de configuration.

Monitoring avec Application Insights

Tracer chaque appel

import time
import logging
from opencensus.ext.azure.log_exporter import AzureLogHandler

logger = logging.getLogger(__name__)
logger.addHandler(AzureLogHandler(
    connection_string="InstrumentationKey=votre-clé"
))

def monitored_call(client, messages, model="azureai"):
    """Appel Mistral avec métriques Azure Monitor."""
    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

Alertes recommandées

Configurez des alertes dans Azure Monitor pour :

• Latence P95 > 5s — dégradation des performances
• Taux d’erreurs 5xx > 1% — problèmes côté serveur
• Erreurs 429 > 10/min — rate limiting atteint
• Consommation tokens > 80% quota — approche de la limite

Scalabilité

Gérer la charge avec des queues

Pour les workloads à fort volume, découpler les requêtes avec Azure Service Bus :

from azure.servicebus import ServiceBusClient, ServiceBusMessage
import json

# Producteur : envoyer les requêtes dans la 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)

# Consommateur : traiter les requêtes depuis la 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"]}]
            )
            # Stocker le résultat...
            receiver.complete_message(msg)

Plusieurs endpoints

Pour augmenter le débit, déployez plusieurs endpoints du même modèle et répartissez la charge :

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():
    """Round-robin simple sur les endpoints."""
    ep = random.choice(endpoints)
    return MistralAzure(azure_endpoint=ep["url"], azure_api_key=ep["key"])

Sécurité réseau

Private Link

Pour les données sensibles, configurez un Azure Private Link afin que le trafic entre votre application et l’endpoint Mistral ne transite jamais par l’Internet public :

1. Créez un Private Endpoint dans votre VNet
2. Liez-le à votre ressource Azure AI
3. Désactivez l’accès public sur l’endpoint
4. Configurez un DNS privé pour la résolution

Managed Identity

Remplacez les clés API par une Managed Identity pour une authentification sans secret :

from azure.identity import ManagedIdentityCredential

credential = ManagedIdentityCredential()
token = credential.get_token("https://cognitiveservices.azure.com/.default")

# Utiliser le token comme clé API
client = MistralAzure(
    azure_endpoint=os.environ["AZUREAI_ENDPOINT"],
    azure_api_key=token.token
)

Checklist de mise en production

Avant de déclarer votre déploiement prêt pour la production :

• Variables d’environnement et secrets dans Key Vault
• Retry exponentiel avec gestion des erreurs 429, 5xx
• Monitoring avec Application Insights (latence, erreurs, tokens)
• Alertes configurées sur les métriques critiques
• Tests de charge validés
• Accès réseau privé si données sensibles
• Rotation des clés API planifiée

Points clés à retenir

• Utilisez Azure Key Vault pour stocker les clés API, pas des variables d’environnement en clair
• Monitorez chaque appel avec Application Insights (latence, tokens, erreurs)
• Découplage avec Service Bus pour les workloads à fort volume
• Private Link et Managed Identity pour les environnements sécurisés
• Testez la charge et configurez des alertes avant de passer en production