Create triggers and bindings (Azure Functions)

Los triggers y los bindings ofrecen una manera declarativa de conectar funciones a servicios externos.

  • Trigger determina como se invoca la función
  • Binding mueven data into - and out of - functions a través de configuración

Cada función tiene un único trigger que determina el tipo de event source que invoca la función. Ej: HTTP requests, queue messages, timer schedules, database change feeds. El trigger también sirve como input binding, proveyendo el event data a tu función.

Los bindings son opcionales. Una función puede tener 0 o múltiples bindings de cualquier tipo. El runtime se encarga de la auth y data serialization.

Create HTTP triggers (inference endpoint)

Soportan GET, POST y otros HTTP methods.

En Python v2 se definen HTTP triggers usando @app.route(). Especificas la ruta, HTTP method y Auth level. La función recibe un HttpRequest que contiene los headers, query params y body. La función devuelve HttpResponse con el resultado.

# Code fragment - focus on HTTP trigger for an inference endpoint
import azure.functions as func
import json

app = func.FunctionApp()

@app.route(route="classify", methods=["POST"], auth_level=func.AuthLevel.FUNCTION)
def classify_document(req: func.HttpRequest) -> func.HttpResponse:
    payload = req.get_json()
    document_text = payload.get("text")

    # Call inference logic or Azure AI service
    classification = perform_classification(document_text)

    return func.HttpResponse(
        json.dumps({"category": classification}),
        status_code=200,
        mimetype="application/json"
    )

HTTP-triggered functions tienen un timeout de 230 segundos impuesto por el Azure Load Balancer. Para tareas de inferencia que tarden más, devolver un 202 Accepted con un status endpoint URL y procesar el trabajo de manera asincrona usando un Service Bus trigger (async request-repply pattern)

Authorization levels

Los Auth levels controlan quien puede invocar la función

  • anonymous no key - para development e internal health check endpoints
  • function - requiere una key function-specific enviada en functions-keys header o code query param. recomendado para PROD
  • admin - requiere la master key. reservarla para administrative operations

El uso de auth keys es una base pero, no sustituye a Entra ID.

Create Service Bus Triggers (Batch Processing)

Hacer trigger de la function cuando llega un message a la Azure Service Bus queue. Este trigger es la base para async AI processing patterns donde el work item se envia a través de una interfaz y se procesa a un ritmo independiente determinado por los compute resources.

Service Bus triggers administran de manera automática la retry logic, dead-letter management y concurrency scaling.

Service Bus ofrece features complejas como:

  • message sessions
  • duplication detection
  • scheduled delivery

En Python v2 definimos Service Bus queue triggers usando @app.service_bus_queue_trigger(). Especifica queue name y connection setting que resuelve al Service Bus namespace conn string (o identity-based conn)

# Code fragment - focus on Service Bus queue trigger for processing work items
@app.service_bus_queue_trigger(arg_name="msg", queue_name="document-jobs", connection="ServiceBusConnection")
def process_document(msg: func.ServiceBusMessage) -> None:
    job = json.loads(msg.get_body().decode("utf-8"))
    document_url = job["document_url"]
    job_id = job["job_id"]

    # Perform document processing and classification
    result = extract_and_classify(document_url)

    # Store result (using output binding or SDK client)
    save_result(job_id, result)
  • Podemos configurar el concurrency behavior para Service Bus triggers en host.json
  • maxConcurrentCalls controla cuantos mensajes puede procesar cada instancia de manera simultánea - un valor de 1 asegura que cada mensaje tiene full instance resources
  • maxAutoLockRenewalDuration controla cuanto tiempo el runtime renueva el message lock (esto es, el procesamiento continúa) - debería ponerse tan alto como para cubrir tu caso más largo para que el lock no expire mientras la AI service call is WIP
  • maxDeliveryCount (default: 10) Cuando un mensaje se pasa de este valor, el Service Bus broker automáticamente lo mueve a la dead-letter sub-queue. Esta cola es para mensajes que han fallado repetidamente el procesamiento y se puede monitorizar.
{
    "version": "2.0",
    "extensions": {
        "serviceBus": {
            "maxConcurrentCalls": 1,
            "maxAutoLockRenewalDuration": "00:05:00"
        }
    }
}

HTTP Function + Service Bus Function (decoupling pattern)

Un common AI pattern empareja un HTTP endpoint con un Service Bus trigger.

La HTTP function acepta un batch request, valida el input, manda los mensajes individuales a la Service Bus queue y devuelve inmediatamente. Una Service Bus triggered-function procesa entonces cada item de manera independiente ejecutando inferencias, llamando Azure AI Services y escribiendo los resultados a un storage.

Esta separación separa la ingestión del procesamiento, permitiendo que cada servicio escale a su propio ritmo.

Use output bindings to store results

Los output bindings escriben data a external service ocupándose el runtime de manejar connection management, auth y serialization basandose en la binding config.

Para AI backends, los output bindings proveen de una manera concisa de persistir inference results, processed documents y derived data a storage services.

Common output binding targets son

  • Azure Blob Storage store processed documents y binary artifacts
  • Azure Cosmos DB writing structured inference results
  • Azure Service Bus send out work to downstream processors

Service bus-triggered function que usa Blob Storage output binding para guardar processed text

# Code fragment - focus on output binding for storing results
@app.service_bus_queue_trigger(arg_name="msg", queue_name="document-jobs", connection="ServiceBusConnection")
@app.blob_output(arg_name="output_blob", path="results/{rand-guid}.json", connection="AzureWebJobsStorage")
def process_and_store(msg: func.ServiceBusMessage, output_blob: func.Out[str]) -> None:
    job = json.loads(msg.get_body().decode("utf-8"))

    result = extract_and_classify(job["document_url"])

    output_blob.set(json.dumps({
        "job_id": job["job_id"],
        "classification": result["category"],
        "confidence": result["score"]
    }))

Cuando una function necesita devolver una HTTP response y escribir a un output binding de manera simultanea, Python v2 soporta multiples outputs a través de un custom return type.
Defines la HTTP response y el output binding como properties separadas, por lo que la function puede responder al caller y persistir data en una unica invocacion

CosmosDB output bindings hacen write de JSON documents directamente a un contenedor. Especificas database name, container name, connection setting

# Code fragment - focus on Cosmos DB output binding
@app.service_bus_queue_trigger(arg_name="msg", queue_name="classification-results", connection="ServiceBusConnection")
@app.cosmos_db_output(
    arg_name="output_doc",
    database_name="ai-results",
    container_name="classifications",
    connection="CosmosDBConnection"
)
def store_classification(msg: func.ServiceBusMessage, output_doc: func.Out[func.Document]) -> None:
    result = json.loads(msg.get_body().decode("utf-8"))

    output_doc.set(func.Document.from_dict({
        "id": result["job_id"],
        "category": result["category"],
        "confidence": result["score"],
        "processed_at": datetime.utcnow().isoformat()
    }))

Connect to Azure AI services from a function

Los triggers y los binding models no cubren cada Azure service. Para servicios sin bindings dedicados puedes usar SDK clients directamente en código.

Este approach te da full access a la API del servicio y se beneficia del hosting y scaling de las Azure Functions.

Al crear SDK clients, inicializa el cliente fuera de la function handler para que persista la misma instancia entre invocaciones.

Usar DefaultAzureCredential para auth permite que el mismo código funcione localmente (usando developer credentials de Azure CLI o el IDE) y en PROD (usando la function managed identity)

# Code fragment - focus on SDK client initialization and reuse
from azure.identity import DefaultAzureCredential
from azure.ai.documentintelligence import DocumentIntelligenceClient
import os

credential = DefaultAzureCredential()

doc_intelligence_client = DocumentIntelligenceClient(
    endpoint=os.environ["DOCUMENT_INTELLIGENCE_ENDPOINT"],
    credential=credential
)

@app.service_bus_queue_trigger(arg_name="msg", queue_name="document-jobs", connection="ServiceBusConnection")
def analyze_document(msg: func.ServiceBusMessage) -> None:
    job = json.loads(msg.get_body().decode("utf-8"))

    poller = doc_intelligence_client.begin_analyze_document(
        "prebuilt-layout",
        analyze_request={"url_source": job["document_url"]},
        content_type="application/json"
    )
    result = poller.result()
    # Process extraction results...