Azure Functions para IA: hospedaje, escalado, desencadenadores, enlaces, seguridad y MCP

radio_button_uncheckedshort_text1. Escenario y objetivos de aprendizaje

Imagina una plataforma de documentos inteligente: una API recibe un archivo, un servicio de IA extrae el texto, la solución clasifica el contenido y guarda el resultado. Las máquinas virtuales dimensionadas para el pico quedan inactivas y aun requieren parches y administración. Azure Functions sustituye esa capacidad fija por ejecución controlada por eventos, escalado automático y facturación según el plan.

• Exponer una entrada HTTP de baja latencia.
• Enviar el trabajo largo a un procesador activado por cola.
• Usar enlaces para mover datos y SDK cuando no haya enlace.
• Proteger la configuración con Key Vault, Configuración de la aplicación e identidad administrada.
• Exponer operaciones concretas como herramientas MCP.

Resumen rápido

El objetivo es un back-end de IA seguro y ágil que separe la aceptación de la solicitud del procesamiento pesado.

radio_button_uncheckedshort_text2. Inicio en frío y su efecto ampliado por la IA

El inicio en frío ocurre cuando la plataforma asigna una instancia, inicia el host y el trabajador del lenguaje, carga la aplicación y prepara dependencias antes de la primera invocación. Puede suceder en cualquier plan que llegue a cero y se paga una vez por instancia nueva, no en cada solicitud.

SDK grandes, bibliotecas de inferencia, metadatos, configuración, tokens y grupos de conexiones aumentan el tiempo. Inicializa clientes reutilizables a nivel de módulo, reduce el paquete y mide por separado la latencia fría y la caliente.

Resumen rápido

El inicio en frío es por instancia; las dependencias pesadas lo amplían y las invocaciones calientes reutilizan el proceso.

radio_button_uncheckedshort_text3. Consumo flexible como opción sin servidor predeterminada

Consumo flexible es el plan basado en Linux recomendado para nuevas aplicaciones de funciones sin servidor. Incluye escalado por función, integración de red virtual, instancias de 512 MB, 2.048 MB o 4.096 MB y hasta 1.000 instancias bajo demanda. Usa 2.048 MB como punto inicial, 4.096 MB para cargas intensivas y 512 MB para procesadores ligeros.

Las instancias siempre listas mantienen caliente una función o grupo. Reducen el inicio en frío, pero crean un cargo básico; resérvalas para endpoints sensibles. El escalado bajo demanda continúa por encima de ese mínimo.

Resumen rápido

Consumo flexible ofrece economía controlada por eventos; la capacidad siempre lista solo se justifica por latencia.

radio_button_uncheckedshort_text4. Premium y las demás opciones de hospedaje

Resumen rápido

Premium cambia un coste base por arranque predecible; Dedicado y Container Apps cubren requisitos especiales.

radio_button_uncheckedshort_text5. Escalado por función, concurrencia y memoria

En Consumo flexible, los desencadenadores HTTP escalan como grupo; los blobs basados en Cuadrícula de Eventos forman otro y Durable Functions comparte un grupo. La mayoría de los demás, como Bus de servicio, colas y temporizadores, escala de forma independiente. Una ráfaga de cola no tiene que competir con la API.

Menor concurrencia distribuye llamadas de IA costosas entre más instancias y asigna más recursos a cada invocación; mayor concurrencia usa menos instancias, pero aumenta la contención. Ajusta con pruebas de carga, cuotas, memoria y latencia integral.

Resumen rápido

Los grupos determinan qué funciones comparten instancias; concurrencia y memoria determinan el trabajo por instancia.

radio_button_uncheckedshort_text6. Trabajo prolongado y solicitud-respuesta asincrónica

Una función HTTP tiene unos 230 segundos para responder por Azure Load Balancer aunque functionTimeout sea mayor. Consumo flexible y Premium permiten ejecuciones no HTTP sin máximo configurado, pero aún existen períodos de gracia en reducción de escala y actualizaciones.

1. Validar y crear el identificador.
2. Publicar en Bus de servicio.
3. Responder 202 Accepted con URL de estado.
4. Procesar en otra función.
5. Guardar estado y resultado.

import azure.functions as func
import json, uuid

app = func.FunctionApp()

@app.route(route="documents", methods=["POST"], auth_level=func.AuthLevel.FUNCTION)
@app.service_bus_queue_output(
    arg_name="job", queue_name="document-jobs", connection="ServiceBusConnection")
def accept_document(req: func.HttpRequest, job: func.Out[str]) -> func.HttpResponse:
    payload = req.get_json()
    job_id = str(uuid.uuid4())
    job.set(json.dumps({"jobId": job_id, "url": payload["documentUrl"]}))
    return func.HttpResponse(
        json.dumps({"jobId": job_id, "statusUrl": f"/api/jobs/{job_id}"}),
        status_code=202, mimetype="application/json")

Resumen rápido

La respuesta 202 y una cola desacoplan la latencia HTTP del procesamiento y permiten escalado independiente.

radio_button_uncheckedshort_text7. Herramientas locales y creación del proyecto

Azure Functions Core Tools v4 aporta el host local disponible con carácter general y el comando func; Azure Functions CLI v5 sigue en versión preliminar. La extensión de Azure Functions para Visual Studio Code añade plantillas, depuración F5, implementación y sincronización. Crea con la paleta o func init, agrega con func new y ejecuta con func start.

• Core Tools v4
• Visual Studio Code y extensión de Azure Functions
• Python compatible y entorno virtual
• Azurite para almacenamiento del host
• curl o cliente .http

Resumen rápido

El host local usa el mismo modelo de desencadenadores y enlaces y acorta el ciclo de desarrollo.

radio_button_uncheckedshort_text8. Estructura del proyecto Python v2

Mantén las funciones sin estado, divide aplicaciones grandes mediante blueprints y confirma la configuración de depuración, pero no local.settings.json.

Resumen rápido

El código, el comportamiento global y el entorno permanecen separados en archivos con responsabilidades claras.

radio_button_uncheckedshort_text9. AzureWebJobsStorage, Azurite y dependencias locales

AzureWebJobsStorage coordina el host, guarda el estado de temporizadores y almacena claves. Un valor inválido puede impedir desencadenadores no HTTP. En local, UseDevelopmentStorage=true dirige el host y enlaces compatibles a Azurite, que implementa Blob, Queue y Table Storage.

{
  "IsEncrypted": false,
  "Values": {
    "AzureWebJobsStorage": "UseDevelopmentStorage=true",
    "FUNCTIONS_WORKER_RUNTIME": "python",
    "ServiceBusConnection__fullyQualifiedNamespace": "<namespace>.servicebus.windows.net"
  }
}

Usa el emulador de Azure Cosmos DB cuando proceda y contenedores locales PostgreSQL o Redis. Antes de publicar, prueba los servicios reales y nunca implementes UseDevelopmentStorage=true.

Resumen rápido

Azurite satisface la dependencia local del host; los emuladores aceleran el trabajo, pero no sustituyen la validación en Azure.

radio_button_uncheckedshort_text10. Desencadenadores HTTP y autorización

Cada función tiene exactamente un desencadenador. HTTP recibe método, encabezados, parámetros y cuerpo y devuelve HttpResponse. Usa anonymous solo si el acceso público es intencional, function como barrera básica y admin únicamente para operaciones con clave maestra.

Las claves no identifican al llamador. Usa API Management o Autenticación de App Service para Microsoft Entra ID, OAuth 2.0, cuotas, transformaciones o límites de velocidad.

Resumen rápido

El nivel de autorización decide si se exige clave; la identidad real requiere una capa de autenticación.

radio_button_uncheckedshort_text11. Bus de servicio, bloqueos, reintentos y mensajes fallidos

Un desencadenador de cola de Bus de servicio recibe con PeekLock. El éxito completa el mensaje y el error lo abandona para reentrega, salvo liquidación manual. maxConcurrentCalls limita devoluciones de llamada paralelas y maxAutoRenewDuration debe cubrir el procesamiento esperado.

{
  "version": "2.0",
  "extensions": {
    "serviceBus": {
      "maxConcurrentCalls": 1,
      "maxAutoRenewDuration": "00:10:00",
      "autoCompleteMessages": true
    }
  }
}

Al superar maxDeliveryCount, Bus de servicio mueve el mensaje a la subcola de mensajes fallidos con metadatos. Supervísala y reprocesa deliberadamente. El permiso de lectura administrativa mejora la precisión del escalado basado en destino.

Resumen rápido

Ajusta concurrencia y renovación de bloqueo y opera la cola de mensajes fallidos como parte del sistema.

radio_button_uncheckedshort_text12. Enlaces de entrada/salida y clientes SDK

El desencadenador también es un enlace de entrada. Otros enlaces leen o escriben sin código repetitivo: Azure Blob Storage para archivos, Azure Cosmos DB para resultados y Bus de servicio para distribución. Usa SDK si no hay un enlace adecuado o necesitas toda la API.

@app.service_bus_queue_trigger(
    arg_name="msg", queue_name="document-jobs", connection="ServiceBusConnection")
@app.cosmos_db_output(
    arg_name="result", database_name="ai-results",
    container_name="classifications", connection="CosmosDBConnection")
def classify(msg: func.ServiceBusMessage, result: func.Out[func.Document]) -> None:
    job = json.loads(msg.get_body().decode("utf-8"))
    answer = run_document_pipeline(job["url"])
    result.set(func.Document.from_dict({"id": job["jobId"], **answer}))

Crea credenciales y clientes costosos a nivel de módulo para reutilizar conexiones y tokens en invocaciones calientes.

Resumen rápido

Los enlaces reducen infraestructura; los SDK dan control completo y deben reutilizarse.

radio_button_uncheckedshort_text13. Configuración de la aplicación y separación de entornos

La configuración se cifra en reposo y se inyecta como variables de entorno. Guarda endpoints, modelos, umbrales y marcadores como pares simples. Usa os.environ para valores obligatorios y os.getenv para valores predeterminados explícitos.

Separa desarrollo, preproducción y producción. Administra producción mediante infraestructura como código o CLI controlada; descargar puede exponer secretos y cargar valores locales puede romper producción.

Resumen rápido

El código permanece neutral cuando cada entorno proporciona su propia configuración.

radio_button_uncheckedshort_text14. Referencias de Key Vault y rotación

Una referencia de Key Vault resuelve el secreto como configuración sin cambiar el código. Asigna Key Vault Secrets User. Una URI sin versión sigue la última versión en un máximo de 24 horas de caché; una URI con versión queda fijada. Un cambio de configuración o actualización explícita fuerza una nueva resolución.

AI_SERVICE_KEY=@Microsoft.KeyVault(
  SecretUri=https://<vault>.vault.azure.net/secrets/AiServiceKey/)

from azure.appconfiguration.provider import load
from azure.identity import DefaultAzureCredential

credential = DefaultAzureCredential()
config = load(
    endpoint=os.environ["AZURE_APPCONFIG_ENDPOINT"],
    credential=credential,
    keyvault_credential=credential)

Resumen rápido

Conserva secretos en Key Vault, usa referencias sin versión para rotación y concede solo lectura.

radio_button_uncheckedshort_text15. Configuración de la aplicación y características

Configuración de la aplicación centraliza valores no secretos y marcadores compartidos. Las etiquetas seleccionan el entorno; el proveedor Python puede actualizar valores y resolver referencias de Key Vault mediante DefaultAzureCredential.

Guarda rutas de modelos, umbrales y marcadores en Configuración de la aplicación y credenciales en Key Vault.

Resumen rápido

Configuración de la aplicación centraliza comportamiento; Key Vault sigue siendo el origen de secretos.

radio_button_uncheckedshort_text16. Identidad administrada y privilegio mínimo

Las conexiones basadas en identidad sustituyen cadenas por un prefijo y endpoint. La identidad asignada por el sistema es predeterminada; una asignada por el usuario puede compartirse y prepararse antes de implementar. El doble guion bajo crea propiedades estructuradas.

AzureWebJobsStorage__accountName=<storage-account>
ServiceBusConnection__fullyQualifiedNamespace=<namespace>.servicebus.windows.net
CosmosDBConnection__accountEndpoint=https://<account>.documents.azure.com:443/

# SDK client created once and reused on warm invocations
credential = DefaultAzureCredential()
client = DocumentIntelligenceClient(
    endpoint=os.environ["DOCUMENT_INTELLIGENCE_ENDPOINT"],
    credential=credential)

Resumen rápido

La identidad elimina credenciales almacenadas, pero cada destino necesita el rol mínimo correcto.

radio_button_uncheckedshort_text17. Claves de acceso, protección de API y laboratorio MCP

Las claves de función alcanzan una función, las de host todas, las de sistema pertenecen a extensiones y la maestra habilita administración. Todas son secretos. API Management añade políticas y OAuth; Autenticación de App Service puede exigir Microsoft Entra ID.

La extensión MCP de Azure Functions expone desencadenadores de herramienta, recurso y prompt. Prefiere Streamable HTTP en /runtime/webhooks/mcp; SSE queda para compatibilidad. En Azure normalmente se requiere mcp_extension. Python necesita azure-functions 1.24.0 o posterior y la ejecución local Core Tools 4.0.7030 o posterior.

{
  "servers": {
    "local-functions-mcp": {
      "type": "http",
      "url": "http://localhost:7071/runtime/webhooks/mcp"
    },
    "remote-functions-mcp": {
      "type": "http",
      "url": "https://<app>.azurewebsites.net/runtime/webhooks/mcp",
      "headers": { "x-functions-key": "${input:mcp-extension-system-key}" }
    }
  }
}

1. Crear el proyecto y un desencadenador MCP Tool.
2. Confirmar el paquete de extensiones 4.x.
3. Implementar una herramienta pequeña y segura.
4. Ejecutar Azurite y func start y conectar el cliente.
5. Implementar, recuperar mcp_extension de forma segura y probar Streamable HTTP.

Resumen rápido

Las claves son secretos compartidos; las herramientas MCP deben ser estrechas y los endpoints remotos estar protegidos.

radio_button_uncheckedshort_text18. Evaluación, lista de comprobación y referencias

Lista final

• Mide latencia fría y caliente.
• Elige plan y memoria mediante pruebas.
• Encola lo que exceda HTTP.
• Ajusta concurrencia, bloqueo, reintentos y mensajes fallidos.
• No confirmes configuración local.
• Prefiere identidad y privilegio mínimo.
• Rota secretos con referencias sin versión.
• Supervisa errores, escalado, dependencias y coste.
• Restringe herramientas MCP.

1. Escalado y hospedaje de Azure Functions
2. Plan Consumo flexible
3. Desarrollo local
4. Desencadenador de Bus de servicio
5. Referencias de Key Vault
6. Enlaces MCP

Resumen rápido

El escenario une hospedaje, escalado, herramientas locales, mensajería, configuración, identidad y protección en un diseño operativo.