• Updated:
  • Featured post

How LLMs get their probabilities for the next token

(este post es una explicación de la teoría. dejo aquí otro post con el detalle práctico de como usar la temperature, top_k y top_p a efectos prácticos)

Explicación más en detalle de cómo obtienen los LLMs las probabilidades para generar el siguiente token

Sampling

En cada posición el modelo tiene una bolsa con miles de tokens posibles. Sampling es el proceso de no coger siempre el token más probable, si no de orientarlo a coger respuestas con determinadas características.

Si el modelo escogiera siempre el token con más probabilidades, obtendríamos respuestas aburridas y repetitivas.

Logits

Para generar el siguiente token, una red neuronal calcula primero los vectores de logits, donde cada logit corresponde a un valor posible. El tamaño de estos vectores de logits es tan grande como el vocabulario completo del modelo.

(representación de vectores de logits)

flowchart LR
	N1["What's your favorite color?"]:::note --> Z
	Z --> A1 --> A
	Z --> B1 --> B
	Z --> C1 --> C
	Z --> D1 --> D
	
	Z["Neural network"]
    A["a"]
    A1["(-0.5)"]
    B["green"]
    B1["(0.7)"]
    C["red"]
    C1["(0.5)"]
    D["the"]
    D1["(-1.2)"]
    
    classDef note fill:none,stroke:none,color:#777;    

Los logits NO representan probabilidades ya que no suman 1 y pueden incluso ser negativos (la probabilidades no pueden). Para convertir logits a probabilidades se usa una Softmax layer

Temperature

La temperatura es una constante que se aplica a los logits antes de la transformación de la Softmax layer. Se usa para ajustar la creatividad del modelo y redistribuir la probabilidad de los valores. Una temperatura más alta hace que el modelo sea más creativo ya que aumenta las posibilidades de elegir tokens menos probables.

xychart-beta
  title "Temperatura vs Probabilidad"
  x-axis "Temperatura (T)" [0.1, 0.2, 0.5, 1, 2, 5]
  y-axis "Probabilidad" 0 --> 1
  line "P(token1)" [0.9999546, 0.9933071, 0.8807971, 0.7310586, 0.6224593, 0.5498340]
  line "P(token2)" [0.0000454, 0.0066929, 0.1192029, 0.2689414, 0.3775407, 0.4501660]

Ejemplos de temperaturas:

  • Low (0.2-0.3): El modelo es cauto y elige las palabras más probables. Output factual y predecible.
  • Medium (0.5-0.7): Un mix de confiabilidad y engagement
  • High (0.9-1.0): Toma riesgos y es impredecible

Read More

Manage secrets and configurations (Azure Functions)

Use application settings for configuration

Los application settings son pares clave-valor que se configuran a través de:

  • Azure portal
  • Azure CLI
  • infrastructure-as-code

El runtime de las Azure Functions exponen estas settings a tu funcion como environment variables.

Azure encripta application settings at rest y lo desencripta solo cuando se inyecta en la app’s process memory, para que no se guarden en plaintext en el disco.

En python se accede a las app settings usando

  • os.environ para required settings
  • os.getenv para settings con fallback defaults

Este patron ayuda a mantener las functions environment-agnostic, ya que el mismo codigo lee config de local.settings.json en development y de las app settings en PROD.

# Code fragment - focus on reading application settings
import os

ai_endpoint = os.environ["AI_SERVICE_ENDPOINT"]
model_id = os.environ["MODEL_ID"]
confidence_threshold = float(os.getenv("CONFIDENCE_THRESHOLD", "0.85"))
max_batch_size = int(os.getenv("MAX_BATCH_SIZE", "10"))

Ignorar siempre local.settings.json del .gitignore

Reference secrets de Azure Key Vault

Las referencias a Key Vault permiten guardar valores sensibles directamente en Azure Key Vault y referenciarlos desde las app settings.

El runtime resuelve la referencia en app startup time, obtiene el secreto de la key vault y lo inyecta como environment variable, por lo que es transparente para la app.

Reference syntaxes

URI syntax - points to specific secret version (or latest)

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

Named syntax - uses vault name and secret name

@Microsoft.KeyVault(VaultName=myvault;SecretName=AiServiceKey)

Ambos tipos requieren que la Function App tenga una managed identity (system-assigned o user-assigned) con el rol Key Vault Secrets User en el target vault. Sin este rol, el runtime no puede obtener el secreto para la app.

Las Key Vault references se resuelven en app startup time. Al cambiar un secreto la nueva versión se usa dentro de las primeras 24 horas. Cualqueir cambio a la configuración de la app causa inmediatamente un refetch de los secretos.

Para AI backends que usen rotacion la recomendacion es usar versionless URIs para que el runtime pille la rotación automáticamente.

Los beneficioes de usar Key Vault son seguridad, centralizacion de secret management a través de multiple Function Apps y services, audir logging, separate secret ownership from app deployment. Un equipo de seguridad puede hacer management y rotar secretos sin tener que acceder a la config de la aplicacion.

Integrate with Azure App Configuration

IMPORTANTE

Azure App Configuration provee un store centralizado para non-secret configuration values y feature flags.

  • Application settings funciona bien para individual function apps.
  • App Configuration es util cuando multiples function apps o micros comparten valores comunes de config, como model endpoint URLs o feature toggles. Cambiar un setting una unica vez en App Configuration propaga este cambio a todas las apps conectadas.

/IMPORTANTE

En python se conecta a App Configuration usando una libreria a través de azure-appconfiguration-provider. Esto carga los config values en memoria y los pone disponibles para que la app los lea.

Soporta label-based filtering. Te permite cargar diferentes sets de valores para diferentes entornos.

# Code fragment - focus on loading configuration from App Configuration
from azure.appconfiguration.provider import load
from azure.identity import DefaultAzureCredential
import os

config = load(
    endpoint=os.environ["APP_CONFIG_ENDPOINT"],
    credential=DefaultAzureCredential(),
    selects=[{"key_filter": "AIBackend/*"}]
)

model_endpoint = config["AIBackend/ModelEndpoint"]
inference_timeout = int(config["AIBackend/InferenceTimeout"])

Una arquitectura comun es combinar App Configuration para nonsecret-values y Key Vault para secretos.

App Configuration soporta Key Vault references. Esto crea una configuration surface unificada para poder obtener todos los valores a través del mismo proveedor

Handle configuration in the local development workflow

Para desarrollo local necesitamos reproducir la misma config structure que corre en Azure, pero apuntando a local services y emuladores en vez de cloud resources.

El local.settings.json file hace mirror de las settings que ofrece el Azure portal.

Puedes hacer pull de current app settings de una deployed function app, a tu config local, usando Azure Functions Core Tools command. Este comando descarga todos los settings y los escribe a local.settings.json, lo cual es util para replicar PROD de manera rapida.

func azure functionapp fetch-app-settings <function-app-name>

Ya que este local.settings.json puede contener conn strings sensibles, podemos encriptar el fichero con Core Tools para proteger los secretos at rest en tu maquina. El local Functions runtime puede leer los valores, pero estos no son visibles si abres el fichero.

func settings encrypt

Para el dia a dia apuntar AzureWebJobsStorage a UseDevelopmentStorage=true para usar Azurite.

Configurar identity y access (Azure Functions)

Replace connection strings with identity-based connections

Azure Functions binding extensions soportan identity-based connections, las cuales usan la function app’s manage identity para autenticar, en vez de requerir una connection string guardada en application settings.

Este approach elimina secretos del trigger y binding configuration. En vez de guardar una full connection string que contiene account keys o shared access signatures, configuras el binding con una named connection, que incluye solo el service endpoint o account name.
El runtime se encarga de la auth de manera transparente usando la assigned managed identity.

Para preparar una identity-based connection, activa un system-assigned managed identity para la function app, entonces asignar los Azure rules necesarios para el target resource.
La function app autentica usando la identidad y no tenemos secret values que aparezcan en el app settings.
Esto es particularmente util para AI backends que conectan a multiples Azure services, ya que cada conexion adicional en la config expande el surface area para ataques.

El identity-based connection mas comun es el runtime own storage dependency. Podemos reemplazar el AzureWebJobsStorage tradicional connection string con identity-based settings, configurando el storage account name y asignando roles

AzureWebJobsStorage__accountName = mystorageaccount

El runtime autentica con la function app’s managed identity. El rol minimo requerido es Storage Blob Data Owner. Si tu app usa blob triggers, tambien necesitas Storage Queue Data Contributor y Storage Account Contributor ya que blob triggers internamente usan storage queues para blob receipts. Para Service Bus y CosmosDB, usar solo Storage Blob Data Owner es suficiente.

Usar identity-based connections for trigger y output bindings

Identity-based connection config difiere de connection string configs en la manera de hacer setup del named connection prefix. Cada binding’s connection property en function_app.py referencia un named prefix (ejemplo connection="ServiceBusConnection"). Con connection strings, creas una single app setting con el prefix name, que contiene el full connection string. Con identity-based connections, creas settings usando el prefijo con property suffixes que especifican el service endpoint.

Ejemplos:

Service Bus trigger with identity-based connection

Remplaza la Service Bus connection string, con el fully qualified namespace.
Asigna Azure Service Bus Data Receiver role a la function app’s managed identity en el Service Bus namespace. Para output bindings, asigna Azure Service Bus Data Sender role instead.

ServiceBusConnection__fullyQualifiedNamespace = mynamespace.servicebus.windows.net 
# Code fragment - focus on Service Bus trigger with identity-based connection
@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"))
    # Process the document...

CosmosDB output binding with identity-based connection

Reemplaza la CosmosDB connection string, con el account endpoints.

Asigna el rol Csomos DB Built-in Data Contributor a la function app’s managed identity.

CosmosDBConnection__accountEndpoint = https://mycosmosaccount.documents.azure.com:443/

Cada binding extension documenta su supported identity properties y required roles. El suffix pattern difiere por servicio

  • storage bindings usan __acountName o service-specific URIs
  • CosmosDB usa __accountEndpoint
  • Messaging services usan __fullyQualifiedNamespace

Autenticar SDK clients con managed identity

Para Azure services sin dedicated binding support, creamos SDK clients directamente en function code. Estos clients se autenticar usando la misma managed identity que sirve el trigger y las binding connections.

DefaultAzureCredential provee de credential chain para entornos locales y cloud.

Inicializamos ambos el credential objhect y el service client fuera del function handler, al nivel del modulo. Esto asegura que el objeto persista entre invocaciones en la misma instancia, evitando tener que crearlo cada vez.

# Code fragment - focus on module-level client initialization
import os
from azure.identity import DefaultAzureCredential
from azure.ai.documentintelligence import DocumentIntelligenceClient
from azure.search.documents import SearchClient

credential = DefaultAzureCredential()

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

search_client = SearchClient(
    endpoint=os.environ["SEARCH_ENDPOINT"],
    index_name=os.environ["SEARCH_INDEX"],
    credential=credential
)

Secure HTTP endpoints con authorization keys

Las Azure Functions usan access keys para restringir acceso a HTTP-triggered function endpoints. Esto es especifico para Azure Functions y opera independiente de Entra ID para auth.

IMPORTANTE

Access keys son una barrera basica para evitar invokers no autorizados, pero no comprueban la caller identity ni ofrecen fine-grained acess control.

Tipos de keys

  • Function keys Scoped a una single function. Cada function puede tener multiples named keys. Se incluyen en el header x-functions-key o el query param code, al llamar a la funcion
  • Host keys Scoped a todas las funciones en la function app. Una single host key da acceso a todas las HTTP-triggered functions. Usarlas para administrative tools o monitorizacion
  • System keys Usadas por extensiones especificas o para auth de ops internas. La MCP extension usa mcp_extension system key para autenticar MCP client connections a la function app. Son managed por el runtime y no se deben compartir
  • Master key Acceso administrativo y hace override de todas las otras keys. Nunca jamas compartirla en apps

Se establece el auth level por HTTP trigger usando auth_level en @app.route()

Recordamos:

  • anonymous no requiere key (health check endpoints o funciones que manejan la auth de manera separada)
  • function erquiere function-specific key o host key (baseline for PROD)
  • admin requiere master key (administrative ops)
# Code fragment - focus on authorization levels
@app.route(route="classify", methods=["POST"], auth_level=func.AuthLevel.FUNCTION)
def classify_document(req: func.HttpRequest) -> func.HttpResponse:
    # This function requires a function key or host key to invoke
    pass

@app.route(route="health", methods=["GET"], auth_level=func.AuthLevel.ANONYMOUS)
def health_check(req: func.HttpRequest) -> func.HttpResponse:
    return func.HttpResponse("OK", status_code=200)

Las access keys son una barrea basica pero no reemplazan la auth para PROD AI endpoints. Para paps que requieran verificar al caller, juntarlo con Azure API Management o App Service Authentication (Easy Auth) on top of access keys.

  • API Management añade rate limiting, request validation y OAuth 2.0 token verification
  • Easy Auth integra Entra ID directamente en la function app

/IMPORTANTE

Azure Durable Functions

Las Azure Durable Functions permiten que un AI workflow sobreviva a reinicios del host y a long delays. Graban cada operación y permiten hacer un replay para reconstruir el estado local que teníamos antes del reinicio.

Durable workflows

Un durable workflow combina una client function, una orchestrator function y una o más activity functions.

Cuando un cliente comienza una orchestration, el Durable Task runtime graba el input y cada durable action en la orchestration history. El runtime chequea el progreso cuando el orchestrator asigna trabajo o recibe un resultado. Si el host se restartea, el runtime hace replay del history a través del orchestrator hasta que llega a la ultima accion no terminada.

Este modelo hace restore de local variables y workflow position sin que tengas que escribir ningún checkpoint.

Client Function

Una Client function comienza la orquestación, hace query del status, lo temrmina, o envía un evento externo.

Un cliente triggeado por HTTP, normalmente, devuelve una status URL que el caller usa para hacer track de long-running workflows

Orchestrator Function

Una Orchestrator function define la workflow sequence, branching rules, parallel tasks, durable waits y result aggregation.

El orchestrator pone en cola el durable work, en vez de hacer ese trabajo por si mismo

Activity Function

Una Activity function hace una unidad de trabajo no determinista como leer un blob, llamar un model endpoint, enviar una notificacion o hacer update de una BBDD

Son las que pueden ejecutar trabajo no-determinista como language libraries o Azure SDK Clients

Entity Function

Una Entity function administra una pieza de durable state state a través de operaciones explicitas.

Las Entities pueden ayudar a coordinar ese shared state. No son obligatorias. con un orchestrator y activity functions puede ser suficiente.

Keep orchestrator logic deterministic

Un orchestrator puede hacer replay muchas veces durante una workflow instance. Un codigo determinista produce la misma secuencia de durable actions con el mismo orchestration history, para que el runtime pueda hacer match de las acciones que se ha hecho replay para completar el trabajo.

Si hay trabajo no determinista puede causar que el workflow falle o se comporte de manera no predecible.

Puedes usar de manera segura calculos locales, loops sobre stable inputs y resultados devueltos por durable tasks. Usa orchestration context APIs cuando una decision requiere del current time o un identificador unico.

Ejemplos

  • context.current_utc_datetime devuelve un replay-safe time.
  • context.new_uuid() crea un ID determinista para el orchestration history

Evita las siguientes operaciones en orchestrator functions:

  • Direct HTTP, DDBB, file system o Azure SDK calls
  • Model inference o embedding requests
  • Random-number generators y nondeterministic UUID APIs
  • Language-native current time como datetime.now()
  • Block waits como time.sleep()
  • Threads, multiprocessing y async ops que el Durable Task runtime no schedulea
  • Environment-dependent decisions que pueden cambiar entre replays

ejemplo que usa orchestration-safe time para calcular una review deadline. En el replay context.current_utc_datetime devuelve el mismo valor

# Code fragment - focus on deterministic orchestration time
from datetime import timedelta
import azure.durable_functions as df


def orchestrator(
    context: df.DurableOrchestrationContext,
):
    review_deadline = context.current_utc_datetime + timedelta(hours=24)
    review_timer = context.create_timer(review_deadline)

    yield review_timer
    return {"status": "ReviewTimedOut"}

Move model calls e input/output a activities

Activity functions no hacen replay bajo el orchestrator deterministic execution rules. Pueden llamar Azure Services, usar SDK clients, generar random values y ejecutar otras operaciones externas.

Las activities son la unidad que las Durable Functions distribuyen across workers disponibles y se reintentan segun la orchestration policy.

La separación importa para AI workloads ya que las respuestas de los modelos son no deterministas y las llamadas a servicios pueden ser lentas o tener fallos transientes. El orchestrator pasa una request estable a una activity y hace record solo del activity result.

el orchestrator hace schedule de una actividad con una compact blob reference. La activity entonces lee el documento y llama al model client configurado

# Code fragment - focus on orchestration and activity boundaries
import azure.durable_functions as df

app = df.DFApp()


@app.orchestration_trigger(context_name="context")
def document_orchestrator(
    context: df.DurableOrchestrationContext,
):
    document = context.get_input()
    result = yield context.call_activity("analyze_document", document)
    return result


@app.activity_trigger(input_name="document")
def analyze_document(document: dict) -> dict:
    document_text = read_blob_text(document["blob_url"])
    model_result = call_classification_model(document_text)
    return {
        "document_id": document["document_id"],
        "category": model_result["category"],
        "confidence": model_result["confidence"],
    }

Llamar read_blob_text() o call_classification_model() desde el orchestrator violawria la regla de ejecucion determinista. Mantener esas operaciones en analyze_document mantiene efectos externos fuera del replaying orchestrator code y permite aplicar una retry policy especifica al external work.
Activity functions tienen at-least-once execution semantics, por lo que sus efectos deben ser idempotentes.

Control data in orchestration history

Durable Functions serializan orchestration inputs, activity inputs / outputs y otros workflow state en el durable store configurado. Payloads grandes incrementar el coste de las operaciones, replay time, memory use. Evitar pasar documentos completos, imagenes, prompts, embeddings, etc, a través de una orchestration.

Para nuevas Durtable Function Apps, se recomienda Durable Task Scheduler como el managed storage provider.

Guarda datos grandes en un servicio apropiado como Durable Task Scheduler o Azure Blob Storage. Pasa una referencia y los metadatos minimos necesarios para workflow decisiones como document ID, blob URL, content type, confidence score, etc. Una activity puede leer el source content y escribir un resultado detallado, mientras que el orchestrator recibe solo el status y los campos requeridos para su next branch.

Considerar el impacto de seguridad de la durable data. No poner secretos en orchestration inputs u outputs. Usa managed identities para credenciales.

Account for replay in telemetry

El replay puede ejecutar un orchestrator’s logging más de una vez. Los mensajes duplicados pueden llevar a confusión. Usar replay-safe logging support.

# Code fragment - focus on replay-aware orchestrator logging
import logging

if not context.is_replaying:
    logging.info(
        "Scheduling document analysis for orchestration %s",
        context.instance_id,
    )

Process independent work with fan-out/fan-in (Durable Functions)

El Durable Functions fan-out/fan-in pattern se usa para operaciones independientes que no tienen por que ejecutarse secuencialmente.

Fan-out/fan-in permite hacer schedule de esas operaciones de manera simultánea, esperar a que el grupo acabe y combinar los resultados.

Este patrón puede reducir batch latency mientras que mantiene la coordinacion y los checkpoints en el durable runtime.

Identify independent work

Fan-out/fan-in funciona mejor cuando cada work item se puede completar sin cambiar los inputs ed otro item (es completamente independiente).

Algunos ejemplos son extraer texto de varios documentos, clasificar imágenes, generar embeddings para chunks separados.

La fase fan-out distribuye estas tasks a lo largo de activity executions, mientras que la fase fan-in le da al orchestrator un result set completo para la siguiente decisión.

Schedule tasks before awaiting results

El python durable functions SDK representa activity calls como durable tasks. Para fan-out, el orchestrator crea una task para cada referencia work-item y guarda las tasks en una lista. Entonces entrega context.task_all(tasks para hacer wait de cada scheduled activity y recibir los resultados.

schedule una activity por document reference. Cada activity puede leer su source blob, llamar al AI model requerido y escribir un output detallado al storage. El orchestrator recibe compact fields que puede agregar sin poner large model responses en orchestration history

# Code fragment - focus on fan-out/fan-in coordination
import azure.durable_functions as df


def orchestrator(
    context: df.DurableOrchestrationContext,
):
    batch = context.get_input()
    tasks = []

    for document in batch["documents"]:
        tasks.append(
            context.call_activity(
                "process_document",
                {
                    "batch_id": batch["batch_id"],
                    "document_id": document["document_id"],
                    "blob_url": document["blob_url"],
                },
            )
        )

    results = yield context.task_all(tasks)

    return {
        "batch_id": batch["batch_id"],
        "processed": len(results),
        "requires_review": [
            item["document_id"]
            for item in results
            if item["confidence"] < 0.80
        ],
    }

El orden de las listas devueltas hace match con la task list, aun cuando las activities acaban en un orden distinto.
Una activity fallida causa que la task_all operation haga raise de un task failure al orchestrator. El orchestrator puede hace catch de ese error y puede elegir si falla el batch entero, compensa el trabajo completado o lo marca para investigación

Design compact fan-in results

fan-in se ejecuta dentro de una orchestrator instance, por lo que la agregación se debe mantener determinista y lightweight. Puedes contar status, seleccionar documentos por debajo de un confidence threshold o construir un summary compacto para activity outputs.

Las expensive transformations y external writes pertenecen a otra acticity

Una document-processing activity podria devolver los siguientes campos:

  • Document ID: correlacionar resultado con original work item
  • Status: success/validation failure
  • Confidence: soporta deterministic routing a un approval step
  • Result URL: apunta al full output almacenado en Blob Storage o BBDD
  • Operation ID: para idempotent updates y trazas

No devuelvas extracted text, full model prompts, large arrays of embeddings. Estos valores expanden la orchestration history y las Durable Functions los tienen que cargar durante el replay. Escribe estos resultados desde la activity a un external store y devuelve una referencia.

Si la agregacion en si misma requiere mucha CPU, memoria, IO ops - haz schedule de una AggregateResults activity tras task_all. El orchestrator puede pasar compact result references a esa activity y esperar un final summary. Este diseño preserva un small orchestration history mientras permite la agregacion del trabajo par usar normal function execution.

Bound parallel work

Un batch con miles de documentos puede hacer schedule de un gran numero de activities de a una. El durable runtime puede grabar esas tasks, pero el historial resultado y fan-in work puede volverse muy caro.
Asi mismo, un burst de trabajo puede exceder los rate limits de los modelos.

Puedes dividir inputs grandes en bounded batches y procesar los batches de uno en uno. Cada batch ejecuta sus items en paralelo, pero el workflow espera antes de asignar el siguiente grupo.

# Code fragment - focus on bounded fan-out
batch_size = 20
all_results = []

for start in range(0, len(documents), batch_size):
    current_batch = documents[start : start + batch_size]
    tasks = [
        context.call_activity("process_document", document)
        for document in current_batch
    ]
    batch_results = yield context.task_all(tasks)
    all_results.extend(batch_results)

Los Bounded Batches limitan el trabajo asignado pero no ofrecen un limite preciso de requests-por-segundo.

Scale aggregation with sub-orchestration

Un orchestrator ejecuta el fan-in step en un worker a la vez. Un solo flat fan-in puede convertirse en un cuello de botella cuando tiene que cargar y agregar muchos resultados. Sub-orchestrations te permiten crear una jerarquia en la cual child orchestration procesan particiones separadas y un padre combina sus summaries.

Por ejemplo un parent orchestration divide un claim archive grande por policy o mes.
Cada child orchestration hace fan out de su propio document activities y devuelve counts + result locations.
El parent entonces agregar esos summaries en vez de cada document result individual.

Este approach reduce la cantidad de estado manejada por una orquestacion y da a cada particion su estado independiente.

La sub-orquestacion junta coordinacion y history records, por lo que no son necesarios para small batches. Comienza con un fan-out/fan-in pattern, mide la ejecucion y el replay behavior, e introduce partitioning cuando el batch size o el coste de agregacion justifique la estructura añadida.

Coordinate human approval with external events (Durable Functions)

Algunos workflwos requieren de input por parte de una persona u otro sistema cuando el proceso automatizado termina. Las Durable Functions pueden suspender una orchestration mientras espera por un external event, y entonces recomenzar desde su durable state cuando ese event llega.

La orchestration suspendida no mantiene un worker ni una invocacion de funcion activa. Esto se recomienda para approval windows de horas a dias.

Model an approval as an external event

Un external event es un one-way message, con nombre, enviado a una instancia especifica de orquestacion. El orchestrator crea una durable task con wait_for_external_event() y cede esa task cuando necesita del event data.

Las Durable Functions extensions persisten un evento que llega al orchestrator antes de que este comience la espera, para que el workflow pueda consumir ese buffered event más tarde.

Para un document-processing workflow, una activity primero crea un approval record y notifica al adjuster asignado. El orchestrator entonces espera a un evento ApprovalResponse que contiene la decision y la identidad del reviewer.

Diseña el event contract alrededor de workflow decisions, en vez de una user-interface action. Un approval payload compacto puede contener:

  • Decision Un valor fijo como Approved o Rejected
  • Reviewer ID para auditar y correlacionar
  • Document ID el work item que el reviewer ha evaluado
  • Approval version Un valor que ayuda al workflow a rechazar una respuesta para una review request viaje
  • Comment reference URL para cargar detalles, almacenado fuera del flujo

Combina un external event con un durable timer

Un approval process necesita una deadline para que un workflow no espere de manera infinita.
Usa context.create_timer() con context.current_utc_datetime. NO USAR time.sleep() u otras APIs bloqueantes. Un durable timer graba el deadline en la orchestration history y no requiere que el worker se mantenga activo mientras no hay trabajo.

Patrón human interaction - es una carrera entre el event task contra el timer task con context.task_any(). Si el evento gana, el orchestrator lee el event result y cancela el timer. Si el timer gana, el orchestrator sigue el timeout path.

ejemplo que implementa approval, rejection y timeout outcomes. Usa un input estable y orchestration-safe time para el replay

# Code fragment - focus on the event-and-timer race
from datetime import timedelta
import azure.durable_functions as df


def orchestrator(
    context: df.DurableOrchestrationContext,
):
    review_request = context.get_input()

    yield context.call_activity("notify_approver", review_request)

    approval_task = context.wait_for_external_event("ApprovalResponse")
    deadline = context.current_utc_datetime + timedelta(hours=24)
    timeout_task = context.create_timer(deadline)

    winner = yield context.task_any([approval_task, timeout_task])

    if winner == approval_task:
        if not timeout_task.is_completed:
            timeout_task.cancel()

        response = approval_task.result
        if response["decision"] == "Approved":
            return {"status": "Approved"}

        return {"status": "Rejected"}

    return {"status": "TimedOut"}

Una external event task no requiere cancelación después de que el timer gane. Si el workflow puede recibir otro evento con el mismo nombre despues, definimos si la app ignora ese evento tardia, lo graba para auditarlo, o lo enruta hacia orta orchestration instance nueva.

Send an event to the correct instance

Una client function usa las Durable Functions orchestration client binding para enviar un evento. El cliente debe conocer el orchestration instance ID o usar el mismo event name que el orchestrator espera. Los event names deberian ser estables.

fragmento que muestra Durable Function call tras un OK de app-specific auth y validacion. El endpoint devuelve 202 ya que el event delivery retoma la orchestration de manera asincrona

# Code fragment - focus on raising an external event
import json
import azure.functions as func
import azure.durable_functions as df

app = df.DFApp(http_auth_level=func.AuthLevel.FUNCTION)


@app.route(route="approvals/{instance_id}", methods=["POST"])
@app.durable_client_input(client_name="client")
async def submit_approval(
    req: func.HttpRequest,
    client: df.DurableOrchestrationClient,
) -> func.HttpResponse:
    instance_id = req.route_params["instance_id"]
    response = req.get_json()

    reviewer = authorize_reviewer(req)
    validated_event = validate_approval_response(response, reviewer)

    await client.raise_event(
        instance_id,
        "ApprovalResponse",
        validated_event,
    )

    return func.HttpResponse(
        json.dumps({"status": "Accepted"}),
        status_code=202,
        mimetype="application/json",
    )

Handle duplicate and out-of-order responses

Diferentes servicios pueden mandar la misma decision mas de una vez. External events tienen at-least-once delivery guarantee, por lo que restarts, escalado o fallos pueden producir deliveries duplicadas. Sigue siendo nuestra responsabilidad garantizar idempotencia ya que un evento duplicado no debería crear un segundo approval record o repetir una operación downstream.

Podemos incluir un ID estable para approvals y que una actividad de manera atómica compruebe este ID para reportar si la operación ya existe.

Respuestas out-of-order requieren de una policy explicita. Evitar usar solo el orden de llegada cuando hay múltiples sistemas que pueden mandar eventos.

Choose a timeout outcome

Un timeout es un outcome pero no necesariamente un fallo técnico. El orchestrator debe elegir un terminal path y hacer schedule de cualquier update requerida, a través de activities.

Set up local dev environment (Azure Functions)

Install Azure Functions Core Tool

Para Visual Studio Code instalar la Azure Functions extension. Esta depende de Azure Functions Core Tools, la cual permite ejecutar una versión local del runtime de las Azure Functions. Tiene el mismo trigger y binding logic que corre en Azure, por lo que funciona de manera consistente entre local y cloud envs.

Gracias a ellas también puedes crear nuevas Functions desde tu local. Esto crea la function y te permite ejecutarla con func start y expone http://localhost:7071 por defecto.

Understand local project structure

El programming model Python v2 usa un single entry point file function_app.py, donde defines tus functions y sus triggers usando decorators. Este approach consolida las function definitions en un solo lugar.

Un único function_app.py funciona bien para projectos con una miriada de funciones como HTTP trigger para inferencias y queue trigger para batch processing.

A medida que el número de functions crece, se puede partir sus definiciones en files separados usando blueprints. Los blueprints permiten definir funciones en modules individuales y registrarlos en el main entry point function_app.py.

El fichero host.json contiene global runtime configs que aplican a todas las funciones de la app. Esto incluye settings como timeout durations, log levels o concurrency limits.

El fichero local.settings.json contiene app settings y conn strings para desarrollo local. El runtime lee valores del Values object en este fichero y los expone como environment vars en código.
Este fichero se excluye de git por defecto. NUNCA. COMMITEES. `local.settings.json`. N.U.N.C.A

El folder .vscode contiene config files generadas por la Azure Functions extension. El launch.json file configura el debugger, tasks.json define el build y host start.

El fichero requirements.txt (python) o package.json (Node.js) contienen las dependencias del proyecto para funcionar. El runtime instala estas dependencias durante deployment.

El fichero .funcignore especifica files y folders a exlcuir de los deployment packages, manteniendo tus artefactos con poco tamaño, omitiendo ficheros de testing, documentación, etc.

Use Azurite for Functions runtime storage dependency

Azurite provee de implementaciones locales de Azure Blob Storage, Queue Storage y Table Storage, que se comportan como si fuera un cloud service. Así, Azurite elimina la necesidad de crear un Storage account para desarrollo local

El runtime de las Azure Functions requiere una connection a un storage account (configurado a través de AzureWebJobsStorage) para coordinaciones internas. Esta dependencia existe aunque tu app use Azure Storage directamente.

Para desarrollo local puedes enrutas esta dependencia al Azurite emulator poniendo AzureWebJobsStorage como UseDevelopmentStorage=true en local.settings.json.

La manera más simple de usar Azurite es instalar su extension, la cual enciende el emulador cuando haces start del programa local.

{
    "IsEncrypted": false,
    "Values": {
        "AzureWebJobsStorage": "UseDevelopmentStorage=true",
        "FUNCTIONS_WORKER_RUNTIME": "python"
    }
}

El valor UseDevelopmentStorage=true solo tiene efecto en local. Al lanzar la Function, Azure crea o requiere de un storage account automáticamente

Use emulators and local services for connected resources

Para servicios como BBDD, caches y otros data-level ops podemos usar emuladores y alternativas locales para poder testear y mantener los costes bajos.

Azure Cosmos DB emulator se ejecuta en local en Windows, Linux y macOS (a través de Docker). Soporta la NoSQL API y provee de un local endpoint que se comporta como el cloud service.

Azure Database for PostgreSQL no tiene un emulador, pero PostgreSQL es open source por lo que puedes instalar una instancia local.

Azure Managed Redis tampoco tiene emulador, pero Redis es open source.

Simplemente cambiamos los valores con local.settings.json.

Synchronize settings between local and Azure

La Azure Functions extension y Core Tools ofrecen maneras de sincronizar settings entre local y Azure.

En Visual Studio Code puedes hacer click derecho en la function app y seleccionar Download Remote Settings para bajarte los settings a tu local.settings.json.
También puedes Upload Local Settings para hacer push de local values a Azure.

Puedes encriptar tus local settings file con func settings encrypt para proteger secretos en tu maquina de desarrollo.

Azure Functions

El hosting plan que se elige para la Function App determina como inician las instancian, como escala la app bajo carga y cuanta memoria hay disponible.

Los dos planes enfocados a serverless AI workloads son: El Flex Consumption y el Premium plan

Cold start and why it matters for AI

Cold start es el delay que ocurre cuando la Azure Functions platform:

  • aloca una nueva instancia
  • carga el runtime
  • inicializa las dependencias de la app

Todo esto antes de que la instancia esté lista para manejar su primera request.

Cada serverless hosting plan que escala a zero sufre este cold start ya que no hay preallocated compute cuando llega la invocación inicial.

Las AI apps suelen amplificar el cold start por las grandes dependencias de grados y librerias de ML que tienen, además de los SDKs y entornos de ejecución de código.

El cold start es por instancia. Solo afecta a la primera request que se enrute a una nueva instancia.

Flex Consumption vs Premium

Son los dos planes enfocados a AI backends.

Flex Consumption

Flex consumption es el recomendado by default.

Características

  • Plan linux-only
  • scaling per-function
  • virtual network connectivity
  • memoria configurable por instancia (512 MB,2048 MB,4096 MB)
  • always-ready instances

Escala hasta 1000 instancias y cobra basado en active execution time + always-ready baseline.

El always-ready permite mantener un número mínimo de instancias calientes para funciones que sean sensibles a la latencia, mientas que otras Functions en la misma Function App se mantienen fully serverless y escaladas a 0.

Premium

Elimina el cold start del todo y mantiene siempre al menos una instancia en caliente.

Características

  • ofrece siempre al menos una pre-warmed instance
  • custom Linux image support
  • virtual network connectivity

Elige Premium cuando:

  • tus funciones se ejecutan continuamente (o casi)
  • el coste de always-on esté justificado
  • tengas cargas de computación más grandes de las que ofrece el flex
  • necesites desplegar functions usando custom container images

Otros planes

  • Dedicated (App Service) plan: cuando tienes underutilized App Service capacity ya existente y quieres ejecutar tus functions en esas instancias sin coste adicional
  • Container Apps hosting: Cuando las functions necesitan GPU access para model inference, custom OS-level packages o ejecutarse al mismo nivel que microservicios contenerizados en el mismo env
  • Consumption plan (Linux): Legacy serverless plan. Los nuevos proyectos deben usar Flex Consumption

Configure scaling and concurrency

El plan Flex Consumption introduce per-function scaling. Cada tipo de trigger escala de manera independiente basándose en su propia demanda por tipo.

Todas las HTTP functions de una Function App escalan juntas como grupo. El resto de tipos como queue triggers, timer triggers o Service Bus triggers escalan de manera independiente. Esta separacion significa que un aumento de peticiones de las queue, no compite por recursos con un aumento de las peticiones HTTP.

Instance memory el default son 2048 MB. Se puede subir a 4096 MB cuando tengamos cargas más grandes o para subir CPU-cores (van proporcionales).

Long-running AI tasks

MUY IMPORTANTE

Las HTTP functions tienen un timeout de 230 segundos impuesto por el Azure Load Balancer que no se puede cambiar, independiente del functionTimeout setting in host.json.

Todas las requests que se pasen de este tiempo devuelven un error al caller, aunque la function se puede seguir ejecutando en el backend. Esto es especialmente peligroso para las AI apps.

La recomendación es usar async request-reply pattern: La HTTP function

  1. acepta la request
  2. valida el input
  3. escribe un mensaje a la Service Bus queue
  4. devuelve inmediatamente un 202 Accepted con una URL de status

Entonces una function separada con Service Bus trigger pilla ese mensaje y ejecuta la long-running task sin ningún tipo de constraint, ya que las service bus-trigger Functions poder ejecutarse de manera indefinida en los planes Flex y Premium.

De este modo, cada componente - HTTP endpoint y Service Bus trigger - escalan de manera independiente.

/MUY IMPORTANTE

Publish custom events (Event Grid)

Create custom topic for AI events

Un custom topic tiene un user-defined endpoint donde tu app postea eventos.

Antes de poder publicar eventos, tienes que crear y configurar el topic y el schema de tus eventos.

Usa el input schema a cloudeventsschemav1_0 al crear el topic para que los eventos usen el formato standard CloudEvents.

az eventgrid topic create \
	--name ai-pipeline-events \
	--resource-group ai-platform-rg \
	--location eastus \
	--input-schema cloudeventschemav1_0

Después de crear el topic, necesitas credenciales para publicar eventos. Puedes obtener el topic endpoint y access key con Azure CLI

az eventgrid topic show \
	--name ai-pipeline-events \
	--resource-group ai-platform-rg \
	--query "endpoint" \
	--output tsv

az eventgrid topic key list \
	--name ai-pipeline-events \
	--resource-group ai-platform-rg \
	--query "key1" \
	--output tsv

Event Grid soporta 3 metodos de auth:

  • access key auth (header aeg-sas-key)
  • SAS token auth
  • Microsoft Entra ID

Construct events for AI ops

Cada custom event describe e implica un meaningful state change en tu sistema. Un evento bien construido incluye suficiente contexto como para que el consumer comience a procesar, pero sin llegar a meter todos los datos dentro. Los subscribers sacan los datos detallados de un data store usando IDs del event data.

CloudEvents event. type categoriza la op, source la fuente donde se origina, subject provee un path filtrable, data payload incluye metadatos sobre la op y una referencia donde el evento puede encontrar todos los detalles

{
    "specversion": "1.0",
    "type": "com.contoso.ai.InferenceCompleted",
    "source": "/services/content-moderation",
    "id": "evt-20250915-143000-001",
    "time": "2025-09-15T14:30:00Z",
    "subject": "/pipelines/moderation/image-classifier",
    "datacontenttype": "application/json",
    "data": {
        "requestId": "req-78901",
        "modelName": "content-classifier-v3",
        "modelVersion": "3.2.1",
        "processingDurationMs": 1250,
        "resultLocation": "https://results.blob.core.windows.net/output/req-78901.json",
        "status": "completed",
        "itemsProcessed": 1,
        "summary": {
            "classification": "safe",
            "confidence": 0.97
        }
    }
}

Al diseñar eventos:

  • Incluye IDs para correlacion: requestId o pipe run ID para tracear entre servicios distribuidos
  • Referencia resultados en vez de meterlos: Los resultados detallados van a un storage y se manda solo la referencia
  • Operational metadata: Campos como processingDurationMs o modelVersion permiten monitorizar trends
  • Provee un summary: asi los consumidores pueden tomar routing decisions sin tener que descargar el texto completo

Publish events using Event Grid SDK

El EventGridPublisherClient de la libreria azure-eventgrid maneja serializacion, atuh y retries.

crea un client y publica CloudEvent to custom topic

# Code fragment - focus on creating and sending a CloudEvent
from azure.core.credentials import AzureKeyCredential
from azure.core.messaging import CloudEvent
from azure.eventgrid import EventGridPublisherClient

endpoint = os.environ["EVENTGRID_TOPIC_ENDPOINT"]
key = os.environ["EVENTGRID_TOPIC_KEY"]

credential = AzureKeyCredential(key)
client = EventGridPublisherClient(endpoint, credential)

event = CloudEvent(
    type="com.contoso.ai.InferenceCompleted",
    source="/services/content-moderation",
    data={
        "requestId": "req-78901",
        "modelName": "content-classifier-v3",
        "processingDurationMs": 1250,
        "resultLocation": "https://results.blob.core.windows.net/output/req-78901.json",
        "status": "completed"
    },
    subject="/pipelines/moderation/image-classifier"
)

client.send(event)

Para PROD usar DefaultAzureCredential para autenticar con manage identity - no usar keys

# Code fragment - focus on managed identity authentication
from azure.identity import DefaultAzureCredential
from azure.core.messaging import CloudEvent
from azure.eventgrid import EventGridPublisherClient

endpoint = os.environ["EVENTGRID_TOPIC_ENDPOINT"]

credential = DefaultAzureCredential()
client = EventGridPublisherClient(endpoint, credential)

Podemos publicar eventos en batches también

# Code fragment - focus on batch publishing
events = [
    CloudEvent(
        type="com.contoso.ai.StageCompleted",
        source="/services/embeddings",
        data={"pipelineRunId": "run-42", "stage": "embeddings", "status": "completed"},
        subject="/pipelines/rag/run-42"
    ),
    CloudEvent(
        type="com.contoso.ai.StageCompleted",
        source="/services/indexing",
        data={"pipelineRunId": "run-42", "stage": "indexing", "status": "completed"},
        subject="/pipelines/rag/run-42"
    )
]

client.send(events)

Publish events using REST API

Podemos publicar eventos enviando un HTTP POST directos al custom topic endpoint.

curl -X POST \
    -H "Content-Type: application/cloudevents+json; charset=utf-8" \
    -H "aeg-sas-key: $EVENTGRID_TOPIC_KEY" \
    -d '{
        "specversion": "1.0",
        "type": "com.contoso.ai.ModelRetrained",
        "source": "/services/training",
        "id": "evt-20250915-160000-001",
        "time": "2025-09-15T16:00:00Z",
        "subject": "/models/sentiment-v2",
        "datacontenttype": "application/json",
        "data": {
            "modelName": "sentiment-v2",
            "modelVersion": "2.1.0",
            "accuracy": 0.94,
            "trainingDurationMinutes": 45,
            "artifactLocation": "https://models.blob.core.windows.net/trained/sentiment-v2.1.0.tar.gz"
        }
    }' \
    "$EVENTGRID_TOPIC_ENDPOINT"

Event schemas and properties (Event Grid)

EventGrid vs CloudEvents schema

Event Grid soporta dos event schemas

  • CloudEvents v1.0 schema: recomendado para nuevas implementaciones. Event structure standard y protocol-agnostic. Este standard implica que los eventos producidos por tus AI services pueden interoperar con cualquier sistema que soporte CloudEvents, no solo Event Grid. Simplifica la integración multi-plataforma.
  • Event Grid schema (propietario): se mantiene por backward compatibility. NO se pueden intercambiar mensajes cloudevents-eventgrid

CloudEvents schema structure

IMPORTANTE

{
    "specversion": "1.0",
    "type": "com.contoso.ai.InferenceCompleted",
    "source": "/services/content-moderation",
    "id": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
    "time": "2025-09-15T14:30:00Z",
    "subject": "/pipelines/moderation/batch-42",
    "datacontenttype": "application/json",
    "data": {
        "modelName": "content-classifier-v3",
        "requestId": "req-78901",
        "resultLocation": "https://storage.blob.core.windows.net/results/batch-42.json",
        "processingDurationMs": 1250,
        "status": "success",
        "itemsProcessed": 150
    }
}

Los atributos requeridos son:

  • specversion identifica la spec version del CloudEvents. Se pone siempre a "1.0"
  • type categoriza el evento. permite filtrar luego por event type. Se usa reverse-DNS naming convention para evitar colisiones
  • source identifica el sistema origen. Combinado con type permite identificar el contexto donde el evento ocurre
  • id es unico de este evento. Los consumers lo usan para detectar y deduplicar deliveries repetidas

Atributos opcionales:

  • subject provee de un path para filtrar. Se usa con valores jerarquicos que reflejen el contexto del evento permitiendo filtrar por prefijos y sufijos
  • time cuando ocurre el evento
  • datacontenttype formato del payload
  • data payload como tal

IMPORTANTE

Design custom event types

Los event types tienen que tener pensamiento detrás y estar bien diseñados. Cada event type tiene que representar un cambio de estado con un significado, que al menos un consumer deba conocer.

Ejemplos:

  • com.contoso.ai.InferenceCompleted
  • com.contoso.ai.EmbeddingsRefreshed
  • com.contoso.ai.AnomalyDetected
  • com.contoso.ai.ContentClassified

El event payload debe ser pequeño y estar enfocado. Incluir suficiente contexto para que el consumer pueda comenzar a procesar como por ej: resource URI, model name, processing duration y result summary.
Si necesitamos incluir muchos datos no meterlos en el payload, pasar una URL y que el consumer haga el fetch de la BBDD o storage.

Configure event type filtering

Las event subscriptions pueden filtrar eventos por type para que cada consumer reciba solo los que realmente necesita.

Puedes configurar event type filtering cuando creas una event subscription con el param --included-event-types

az eventgrid event-subscription create \
	--name inference-handler-sub \
	--source-resource-id /subscriptions/{sub-id}/resourceGroups/{rg}/providers/Microsoft.EventGrid/topics/ai-events \
	--endpoint https://inference-handler.azurewebsites.net/api/events \
	--included-event-types com.contoso.ai.InferenceCompleted

Puedes incluir múltiples event types en una única subscripción

Subject filtering (granular routing)

El field subject permite un filtrado basado en un path, usando prefijos y sufijos. Ej: /pipelines/embeddings/batch-42

De este modo los subscribers pueden filtrar eventos basándose en la jerarquía donde el evento se originó.

Subject filtering usa dos params en la event subscription

  • subjectBeginsWith: se usa para filtrar pipes o categorías específicas
  • subjectWendsWith: se usa para filtrar por tipo, versión o estado
az eventgrid event-subscription create \
	--name embeddings-sub \ 
	--source-resource-id /subscriptions/{sub-id}/resourceGroups/{rg}/providers/Microsoft.EventGrid/topics/ai-events \
	--endpoint https://embeddings-handler.azurewebsites.net/api/events \
	--subject-begins-with /pipelines/embeddings

Advanced filtering

Event Grid soporta filtros avanzados para buscar matches dentro del event body o extension attributes. Estos filtros permiten tomar decisiones de routing basándose en el contenido del event data como confidence scores, model names o processing statuses.

Tienen operadores como:

  • StringContains
  • NumberGreaterThan
  • StringBeginsWith
  • BoolEquals
  • IsNotNull

Se pueden definir hasta 25 filtros POR SUBSCRIPCIÓN

crea una subscription que recibe solo eventos donde data.status es igual a "flagged"

az eventgrid event-subscription create \ 
	--name flagged-content-sub \
	--source-resource-id /subscriptions/{sub-id}/resourceGroups/{rg}/providers/Microsoft.EventGrid/topics/ai-events \
	--endpoint https://review-service.azurewebsites.net/api/events \
	--advanced-filter data.status StringIn flagged

Para AI events, los filtros avanzados permiten hacer target de escenarios especificos y tomar decisiones sobre:

  • Confidence-based routing: Podemos enrutar los eventos a diferentes consumers según el confidence score
  • Model-specific subscriptions: Enrutar según el modelo
  • Status-based workflows: Crear workflows con diferentes consumers o pasos según el estado

Configure input and output schema

Al crear un custom topic el param input-schema controla los schemas que el topic acepta.

IMPORTANTE

Con este valor a cloudeventsschemaV1_0 aceptamos eventos con formato CloudEvents

az eventgrid topic create \
	--name ai-events \
	--resource-group ai-platform-rg \
	--location eastus \
	--input-schema cloudeventschemav1_0

Al crear la event subscription el param event-delivery-schema controla el formato de entrega al handler. Event Grid puede intercambiar entre Event Grid schema y CloudEvents schema durante la entrega, pero no se soporta CloudEvents-to-EventGrid conversion.

/IMPORTANTE

Configure delivery and retry policies (Event Grid)

How Event Grid delivers events

Event Grid entrega eventos enviando un HTTP POST al subscriber’s endpoint. El subscriber tiene que responder con un status code 20x para hacer acknowledge. Cualquier otra respuesta o ninguna durante el timeout period, hace trigger de un retry.
Event Grid espera 30s para la respuesta después de la entrega de un mensaje. Si el endpoint no responde, se encola el mensaje para retry.

Retry and error handling

Cuando Event Grid recibe un error como respuesta, evalúa el error type y decide si lo reintenta o no. No todos los errores se reintentan.

Los siguientes errores NO se reintentan ya que son issues permanentes:

  • 400 Bad Request: el event payload está mal formado
  • 413 Entity Too Large: el evento excede el size limit del endopint
  • 403 Forbidden

Para webhook endpoints un 401 Unauthorized NO se reintenta. Para Azure resource endpoints, 401 y 404 se reintentan tras 5 minutos

Para otro tipo de errores los reintentos son exponenciales. A los siguientes tiempos se les añade un randomizer para que no ocurran de golpe.

  1. 10s
  2. 30s
  3. 1m
  4. 5m
  5. 10m
  6. 30m
  7. 1h
  8. 3h
  9. 6h
  10. Cada 12 to 24h

Retry policy settings

Hay dos params para controlar el retry (se establecen al crear un event subscription):

(se para cuando se cumpla el primero)

  • Maximum number of attempts: default 30
  • Event TTL en minutos: default 24h
az eventgrid event-subscription create \
	--name moderation-sub \
	--source-resource-id /subscriptions/{sub-id}/resourceGroups/{rg}/providers/Microsoft.EventGrid/topics/ai-events \
	--endpoint https://moderation-service.azurewebsites.net/api/events \
	--max-delivery-attempts 5 \
	--event-ttl 30

Dead-letter destinations (undeliverable events)

Cuando Event Grid agota todos los retry attempts o el TTL del evento expira, se envia el evento no entregado a la dead-letter destination. Dead-lettering está disabled by default.

Para activarlo tienes que especificar un Azure Blob Storage container como dead-letter endpoint al crear la event subscription.

az eventgrid event-subscription create \
	--name moderation-sub \
	--source-resource-id /subscriptions/{sub-id}/resourceGroups/{rg}/providers/Microsoft.EventGrid/topics/ai-events \
	--endpoint https://moderation-service.azurewebsites.net/api/events \
	--max-delivery-attempts 5 \
	--event-ttl 30 \
	--deadletter-endpoint /subscriptions/{sub-id}/resourceGroups/{rg}/providers/Microsoft.Storage/storageAccounts/{storage-account}/blobServices/default/containers/dead-letters

Cada evento marcado como dead-letter incluye propiedades que ayudan a entender por qué ha fallado.

  • deadLetterReason ejemplo MaxDeliveryAttemptsExceeded o MaxRetryDurationExceeded
  • deliveryAttempts numero de reintentos
  • lastDeliveryOutcome el resultado del last delivery NotFound, TimedOut, Busy
  • publishTime tiempo en el que Event Grid acepto el evento
  • lastDeliveryAttemptTime

La aparición de dead-letter events indican problemas sistémicos que necesitan investigación. Un batch de dead-letter events puede indicar cambios de URL o fallos generales.

Se puede crear una event subscription al Blob Storage container que contiene las dead-letters. Así puedes notificar un monitoring service cuando llega una nueva dead-letter, permitiendo alertas automáticas o reprocesados.

Transient failures

El mecanismo de retry de Event Grid se encarga automáticamente de los fallos transientes.

Tenemos que diseñar endpoints que soporten este patrón:

  • devolver 200-204 para OK. 503 si el servicio está temporalmente overloaded. 400 para fallos permanentes que no queremos que se reintenten
  • Implementar procesamiento idempotente: Llevar un track de los event IDs ya procesados. Event Grid’s at-least-once guarantee significa que los consumidores pueden recibir el mismo evento más de una vez
  • Procesar (o hacer ack) rápidamente: si tu proceso de inferencia tarda +30s devuelve un 202 (Accepted) inmediatamente y procesa el evento asíncronamente

Output batching (high-throughput workloads)

Usamos batches para sistemas que generan o procesan un gran volumen de requests. Se configura batching en el event subscription con 2 params:

  • Maximum events per batch: 1-5000
  • Preferred batch size (kbs): 1-1024. Un evento que se pase de este tamaño se entrega en su propio batch

IMPORTANTE

Batching usa all-or-none delivery. El handler devuelve un success code para el batch entero. Si algún evento del batch falla, todos se reprocesan. Esto significa que tienes que diseñar el sistema para procesar eventos en batches o rechazar todos.

/IMPORTANTE

Monitor delivery outcomes

Event Grid publica metrics a través de Azure Monitor para tener visibilidad del estado del sistema.

  • Delivery success count
  • Delivery failure count
  • Matched events: eventos que hacen match de al menos un subscription filter
  • Dropped events: eventos que hacen match de una subscripcion pero se pasan de retry limits, sin dead-lettering
  • Dead-lettered events: eventos enviados a dead-letter destination después de un número exhaustivo de retries