Azure en producción
En esta página
Preparación de un despliegue robusto en Azure
Un prototipo funcional en tu portátil y un sistema en producción no difieren en su código de llamada, que permanece idéntico. La diferencia radica en todo lo que rodea a ese código: de dónde proceden los secretos, cómo observas lo que ocurre, qué sucede cuando el tráfico se duplica y por qué ruta de red viajan los datos. Esta lección aborda estas cuatro dimensiones para un despliegue de Mistral en Azure.
Arquitectura de producción
Un despliegue típico reúne cinco bloques de construcción. El punto final (endpoint) de Azure AI aloja el modelo Mistral como MaaS; Azure Key Vault almacena las claves de API; Azure Monitor y Application Insights proporcionan observabilidad; Azure API Management actúa como puerta de enlace con limitación de tasa y autenticación frente a tu aplicación; finalmente, una Red Virtual de Azure proporciona aislamiento de red, algo opcional pero a menudo necesario para datos sensibles.
Tu primer movimiento debe ser extraer los secretos de tu código y de las variables de entorno, haciendo que la aplicación los lea al iniciarse desde Key Vault en su lugar.
from azure.identity import DefaultAzureCredential
from azure.keyvault.secrets import SecretClient
from mistralai.azure.client import MistralAzure
# Recuperar la clave de API desde 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)
La ventaja va más allá de la simple confidencialidad. Cuando rotas una clave, no es necesario volver a desplegar la aplicación, ya que el valor se lee desde la bóveda en lugar de estar codificado directamente en la configuración.
Supervisión con Application Insights
Sin instrumentación, lo único que sabrás sobre un incidente es que un usuario considera que la aplicación es «lenta». El rastreo de cada llamada con su duración, recuento de tokens y modelo te proporciona lo necesario para responder en minutos.
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"):
"""Llamada a Mistral con métricas de 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
Estas métricas solo son valiosas si alguien las supervisa. Configura las alertas correspondientes en Azure Monitor:
- Latencia P95 > 5 s: degradación del rendimiento
- Tasa de errores 5xx > 1 %: problemas del lado del servidor
- Errores 429 > 10/min: límite de tasa alcanzado
- Consumo de tokens > 80 % de la cuota: acercándose al límite
Escalabilidad
Cuando el volumen crece, el primer error es llamar al modelo de forma síncrona desde la solicitud HTTP entrante: cualquier ralentización se propaga directamente al usuario. El desacoplamiento con Azure Service Bus te permite absorber picos; las solicitudes se acumulan en una cola y se consumen al ritmo que permite tu cuota.
from azure.servicebus import ServiceBusClient, ServiceBusMessage
import json
# Productor: enviar solicitudes a la cola
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)
# Consumidor: procesar solicitudes de la cola
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"]}]
)
# Almacenar el resultado...
receiver.complete_message(msg)
Si el cuello de botella proviene del propio rendimiento en lugar de la carga instantánea, despliega múltiples puntos finales para el mismo modelo y distribuye las llamadas entre ellos.
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 entre puntos finales."""
ep = random.choice(endpoints)
return MistralAzure(server_url=ep["url"], api_key=ep["key"])
Seguridad de red
Para datos sensibles, Azure Private Link garantiza que el tráfico entre tu aplicación y el punto final de Mistral nunca cruce la internet pública. La configuración se realiza en cuatro pasos:
- Crear un punto final privado en tu VNet
- Vincularlo a tu recurso de Azure AI
- Deshabilitar el acceso público en el punto final
- Configurar DNS privado para la resolución
El tercer paso es el que la gente olvida y, sin él, la ruta pública permanece abierta en paralelo: existe Private Link, pero nada impide eludirlo.
En la misma línea, una Identidad administrada elimina la clave de API de la ecuación: la aplicación obtiene sus tokens de Microsoft Entra ID, por lo que no hay ningún secreto que almacenar ni rotar. Sin embargo, se aplican dos condiciones. El cliente MistralAzure documentado por Mistral se autentica mediante clave; la autenticación sin clave que describe Microsoft pasa por un modelo desplegado en un recurso de Microsoft Foundry, consultado en su ruta compatible con OpenAI /openai/v1/, con tokens emitidos para el ámbito https://ai.azure.com/.default. Además, la identidad debe haber recibido previamente el rol de inferencia sobre el recurso. Un proveedor de tokens, en lugar de una lectura única del token al inicio, renueva el acceso antes de su expiración:
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", # nombre de tu despliegue
messages=[{"role": "user", "content": "Resume la política de retención de datos."}],
)
print(response.choices[0].message.content)
Fuente: Puntos finales para modelos de Microsoft Foundry — autenticación sin clave.
Lista de comprobación de preparación para producción
Antes de declarar listo tu despliegue, recorre la cadena en el orden en que se construyó. Las variables de entorno y los secretos deben haber migrado a Key Vault, y tu código de llamada debe estar protegido por reintentos exponenciales que cubran tanto errores 429 como 5xx. La supervisión de Application Insights debe informar sobre latencia, errores y tokens, con las alertas correspondientes realmente configuradas para métricas críticas, no solo planificadas. Finalmente, aborda lo que la gente tiende a posponer: pruebas de carga realmente ejecutadas, acceso a red privada si los datos son sensibles y rotación de claves de API programada con una fecha concreta, no dejada al criterio general.
Puntos clave
- Usa Azure Key Vault para almacenar claves de API, no variables de entorno en texto plano
- Supervisa cada llamada con Application Insights (latencia, tokens, errores)
- Desacopla con Service Bus para cargas de trabajo de alto volumen
- Usa Private Link e Identidad administrada para entornos seguros
- Ejecuta pruebas de carga y configura alertas antes de pasar a producción