Ir al contenido principal
Español— Elegir un idioma
Menú

Azure en producción

Lección 6 de 14 Actualizado el 2 de noviembre de 2026 Avanzado
En esta página
  1. Preparación de un despliegue robusto en Azure
  2. Arquitectura de producción
  3. Supervisión con Application Insights
  4. Escalabilidad
  5. Seguridad de red
  6. Lista de comprobación de preparación para producción
  7. Puntos clave

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:

  1. Crear un punto final privado en tu VNet
  2. Vincularlo a tu recurso de Azure AI
  3. Deshabilitar el acceso público en el punto final
  4. 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