Azure in produzione
In questa pagina
Preparare un deployment Azure robusto
Un prototipo funzionante sul tuo portatile e un sistema di produzione non differiscono nel codice di chiamata, che rimane identico. Differiscono in tutto ciò che circonda quel codice: da dove provengono i segreti, come osservi ciò che accade, cosa succede quando il traffico raddoppia e quale percorso di rete seguono i dati. Questa lezione copre queste quattro dimensioni per un deployment di Mistral su Azure.
Architettura di produzione
Un deployment tipico riunisce cinque blocchi fondamentali. L’endpoint Azure AI ospita il modello Mistral come MaaS; Azure Key Vault archivia le chiavi API; Azure Monitor e Application Insights forniscono l’osservabilità; Azure API Management funge da gateway con limitazione della velocità e autenticazione davanti alla tua applicazione; infine, una Rete Virtuale Azure fornisce l’isolamento di rete, opzionale ma spesso richiesto per i dati sensibili.
La tua prima mossa dovrebbe essere estrarre i segreti dal tuo codice e dalle variabili d’ambiente, facendo leggere all’applicazione direttamente da Key Vault all’avvio.
from azure.identity import DefaultAzureCredential
from azure.keyvault.secrets import SecretClient
from mistralai.azure.client import MistralAzure
# Recupera la chiave API da 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)
Il vantaggio va oltre la semplice riservatezza. Quando ruoti una chiave, non è necessario ridistribuire l’applicazione perché il valore viene letto dal vault invece di essere codificato nella configurazione.
Monitoraggio con Application Insights
Senza strumentazione, l’unica cosa che saprai di un incidente è che un utente trova l’applicazione “lenta”. Tracciare ogni chiamata con la sua durata, il conteggio dei token e il modello ti dà ciò che ti serve per rispondere in pochi minuti.
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"):
"""Chiamata Mistral con metriche 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
Queste metriche sono preziose solo se qualcuno le monitora. Configura i corrispondenti avvisi in Azure Monitor:
- Latenza P95 > 5s — degrado delle prestazioni
- Tasso di errore 5xx > 1% — problemi lato server
- Errori 429 > 10/min — limite di velocità raggiunto
- Consumo di token > 80% della quota — avvicinamento al limite
Scalabilità
Quando il volume cresce, il primo errore è chiamare il modello in modo sincrono dalla richiesta HTTP in arrivo: qualsiasi rallentamento si propaga direttamente all’utente. Il disaccoppiamento con Azure Service Bus ti permette di assorbire i picchi: le richieste si accumulano in una coda e vengono consumate al ritmo consentito dalla tua quota.
from azure.servicebus import ServiceBusClient, ServiceBusMessage
import json
# Produttore: invia richieste alla coda
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)
# Consumatore: elabora le richieste dalla coda
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"]}]
)
# Archivia il risultato...
receiver.complete_message(msg)
Se il collo di bottiglia deriva dal throughput stesso piuttosto che dal carico istantaneo, distribuisci più endpoint per lo stesso modello e distribuisci le chiamate tra di essi.
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 semplice tra gli endpoint."""
ep = random.choice(endpoints)
return MistralAzure(server_url=ep["url"], api_key=ep["key"])
Sicurezza di rete
Per i dati sensibili, Azure Private Link garantisce che il traffico tra la tua applicazione e l’endpoint Mistral non attraversi mai Internet pubblico. La configurazione avviene in quattro passaggi:
- Crea un Endpoint Privato nella tua VNet
- Collegalo alla tua risorsa Azure AI
- Disabilita l’accesso pubblico sull’endpoint
- Configura il DNS privato per la risoluzione
Il terzo passaggio è quello che le persone dimenticano e, senza di esso, il percorso pubblico rimane aperto in parallelo: Private Link esiste, ma nulla impedisce di aggirarlo.
Nella stessa ottica, un’Identità Gestita rimuove la chiave API dall’equazione: l’applicazione ottiene i suoi token da Microsoft Entra ID, quindi non c’è alcun segreto da archiviare o ruotare. Si applicano tuttavia due condizioni. Il client MistralAzure documentato da Mistral si autentica tramite chiave; l’autenticazione senza chiave descritta da Microsoft passa attraverso un modello distribuito in una risorsa Microsoft Foundry, interrogata sulla sua rotta compatibile con OpenAI /openai/v1/, con token emessi per lo scope https://ai.azure.com/.default. Inoltre, all’identità deve essere stato precedentemente concesso il ruolo di inferenza sulla risorsa. Un provider di token, piuttosto che un token letto una volta all’avvio, rinnova l’accesso prima della scadenza:
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", # nome del tuo deployment
messages=[{"role": "user", "content": "Riassumi la politica di conservazione dei dati."}],
)
print(response.choices[0].message.content)
Fonte: Endpoint per i modelli Microsoft Foundry — autenticazione senza chiave.
Checklist di prontezza alla produzione
Prima di dichiarare pronto il tuo deployment, percorri la catena nell’ordine in cui è stata costruita. Le variabili d’ambiente e i segreti devono essere migrati su Key Vault e il tuo codice di chiamata deve essere protetto da un retry esponenziale che copra sia gli errori 429 che quelli 5xx. Il monitoraggio di Application Insights deve riportare latenza, errori e token, con avvisi corrispondenti effettivamente configurati sulle metriche critiche, non solo pianificati. Infine, affronta ciò che le persone tendono a rimandare: test di carico effettivamente eseguiti, accesso alla rete privata se i dati sono sensibili e rotazione delle chiavi API programmata con una data precisa, non lasciata al libero arbitrio.
Punti chiave
- Usa Azure Key Vault per archiviare le chiavi API, non variabili d’ambiente in chiaro
- Monitora ogni chiamata con Application Insights (latenza, token, errori)
- Disaccoppia con Service Bus per carichi di lavoro ad alto volume
- Usa Private Link e Identità Gestita per ambienti sicuri
- Esegui test di carico e configura gli avvisi prima di andare in produzione