• 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

Process messages reliably (Service Bus)

Reliable message processing asegura que la AI pipe tenga en cuenta y sepa manejar crasheos de micros, modelos que devuelven errores o payloads que contiene unexpected data.

Receive modes

Service Bus ofrece distintos receive modes que controlar como los brokers manejan el acknowledgment del message delivery. Esto es si priorizamos throughput o garantías de entrega.

Receive-and-delete mode

En receive-and-delete mode, Service Bus elimina el mensaje de la cola inmediatamente cuando se entrega el mensaje al consumidor. Si el consumer se crashea después de recibir el mensaje, pero antes de completar la entrega, el sistema pierde ese mensaje.

Este escenario ofrece el throughput más alto porque elimina el lock y el viaje de vuelta del ack.

Solo es para escenarios donde una pérdida ocasional del mensaje es aceptable y la prioridad es la velocidad de entrega

Ejemplo: telemetría en tiempo eral o non-critical logging - si perdemos algunas entradas no pasa nada

Peek-lock mode

IMPORTANTE

Es el modo por defecto y el recomendado para AI workloads

/IMPORTANTE

Service Bus pone un lock al mensaje durante una cantidad de tiempo configurable y lo envía al consumer, sin eliminarlo de la cola. El consumer debe marcar un estado explícito para el mensaje (complete, abandon, dead-letter, defer) durante la duración de este lock.

Si el lock expira antes de obtener un estado, Service Bus quita el lock y marca el mensaje como disponible para otro consumer. Este proceso en 2 fases asegura mínimo un procesamiento.

El trade-off de peek-lock es un menor throughput comparado con receive-and-delete. Para la mayoría de apps, este overhead es un mal menor.

ejemplo de peek-lock receive w. complete y dead-letter settlements

# Code fragment - focus on peek-lock receive with settlement
import json
from azure.servicebus import ServiceBusClient, ServiceBusReceiveMode
from azure.identity import DefaultAzureCredential

credential = DefaultAzureCredential()

with ServiceBusClient(
    fully_qualified_namespace="<namespace>.servicebus.windows.net",
    credential=credential
) as client:
    with client.get_queue_receiver(
        queue_name="inference-requests",
        receive_mode=ServiceBusReceiveMode.PEEK_LOCK,
        max_wait_time=30
    ) as receiver:
        for msg in receiver:
            try:
                payload = json.loads(str(msg))
                result = run_inference(payload)
                save_result(result, payload.get("document_id"))
                receiver.complete_message(msg)
            except json.JSONDecodeError:
                receiver.dead_letter_message(
                    msg,
                    reason="MalformedPayload",
                    error_description="Message body is not valid JSON"
                )
            except ModelNotFoundError:
                receiver.dead_letter_message(
                    msg,
                    reason="UnsupportedModel",
                    error_description=f"Model {payload.get('model')} is not available"
                )
            except TransientServiceError:
                receiver.abandon_message(msg)

estados disponibles

Complete

Método complete_message() lo marca como procesado OK y lo quita de la queue de manera permanente.

Abandon

Método abandon_message() hace release del lock sin quitar el mensaje de la queue, haciéndolo inmediatamente entregable a otro consumer.

Se suele abandonar un mensaje cuando hay un error transiente que se puede procesar bien en un retry, como un timeout o errores de red.

IMPORTANTE

Cada vez que un mensaje se abandona Service Bus incrementa el count de entrega, si este llega a un límite, el mensaje eventualmente se mueve a dead-letter.

/IMPORTANTE

Dead-letter

Método dead_letter_message() mueve el mensaje a la sub-queue dead-letter con una reason string y un error description.

Un mensaje se marca como dead-letter cuando hay un error no recuperable que hace que no se pueda procesar.

Marcarlo como dead-letter lo quita de la queue normal y lo preserva en otra queue para que lo investiguemos.

Ejemplo: JSON mal formado

Defer

Método defer_message() mantiene el mensaje en la queue pero lo borra de regular delivery. Solo puedes hacer retrieve de ese mensaje después por su sequence number usando receive_deferred_messages().

IMPORTANTE

Esto se utiliza para escenarios donde el consumer no puede procesar un mensaje en ese momento, pero si que podrá después más tarde, o cuando los mensajes necesitan un orden específico pero llegan desordenados.

/IMPORTANTE

Handle poison messages with max delivery count

Service Bus trackea cuantas veces se hace deliver de cada message. Cuando el delivery count se pasa del param max_delivery_count de la queue (default is 10), Service Bus automáticamente mueve el mensaje a la dead-letter queue con la razón MaxDeliveryCountExceeded.
Este mecanismo previene que mensajes que fallan constantemente bloqueen la queue.

Poniendo un valor más bajo (de 3 a 5) los poison messages se envían a la dead-letter más rápido, liberando capacidad para mensajes sanos.
Con un valor más alto los errores transientes tienen más posibilidades de arreglarse solos.

Monitor and process dead-letter queue

La dead-letter queue (DLQ) es una sub-queue que tiene toda queue y subscription

Mantiene los messages que expiran, se pasan del max delivery count, o que la app marca explicitamente como dead-letters. La DLQ existe automaticamente y no hay que crearla. Los mensajes en la DLQ persisten hasta que explicitamente los recibes y los completas.

Cada dead-letter message contiene dead_letter_reason y dead_letter_error_description que explican por qué se han movido allí. Para los mensajes que se pasan del max delivery count, la razón es MaxDeliveryCountExceeded. Para los mensajes que la app manda explicitamente a la DLQ se pasa la razón en la string dead_letter_message()

Monitorizar la DLQ es crítico ya que puede indicar cosas como un formato nuevo que no se puede procesar o un deployment de un modelo que no funciona.

Se puede poner alertas en Azure Monitor sobre la DLQ para hacer tracking del número de mensajes.

Accedes a la DLQ usando sub_queue=ServiceBusSubQueue.DEAD_LETTER

# Code fragment - focus on receiving and inspecting dead-letter messages
from azure.servicebus import ServiceBusClient, ServiceBusSubQueue
from azure.identity import DefaultAzureCredential

credential = DefaultAzureCredential()

with ServiceBusClient(
    fully_qualified_namespace="<namespace>.servicebus.windows.net",
    credential=credential
) as client:
    with client.get_queue_receiver(
        queue_name="inference-requests",
        sub_queue=ServiceBusSubQueue.DEAD_LETTER,
        max_wait_time=10
    ) as dlq_receiver:
        for msg in dlq_receiver:
            print(f"Dead-letter reason: {msg.dead_letter_reason}")
            print(f"Error description: {msg.dead_letter_error_description}")
            print(f"Correlation ID: {msg.correlation_id}")
            print(f"Delivery count: {msg.delivery_count}")
            print(f"Body: {str(msg)}")
            # Inspect and decide whether to resubmit or discard
            dlq_receiver.complete_message(msg)

Reprocess dead-lettered messages

Después de arreglar el fallo raíz del problema, se pueden volver a mandar los dead-letter messages a la cola original

El patrón conlleva

  1. leer cada mensaje de la DLQ
  2. crear UN NUEVO MENSAJE con el mismo body y properties
  3. volver a mandarlo a la queue original
  4. completar el dead-letter message para eliminarlo de la DLQ
# Code fragment - focus on resubmitting dead-lettered messages
with client.get_queue_receiver(
    queue_name="inference-requests",
    sub_queue=ServiceBusSubQueue.DEAD_LETTER,
    max_wait_time=10
) as dlq_receiver:
    with client.get_queue_sender("inference-requests") as sender:
        for msg in dlq_receiver:
            # Create a new message with the original body and properties
            new_message = ServiceBusMessage(
                body=msg.body,
                content_type=msg.content_type,
                correlation_id=msg.correlation_id,
                application_properties=msg.application_properties
            )
            sender.send_messages(new_message)
            dlq_receiver.complete_message(msg)

Con scripts de reprocesado automático podemos volver a mandar los DLQ messages en bulk o batches.

Manage lock duration for long-running AI ops

IMPORTANTE

Algunas ops como procesar docs muy grandes necesitan más tiempo del default lock duration. Este valor es configurable hasta 5 minutos, con un default de 1 minuto.

Si el lock expira antes de que el consumer resuelva el mensaje, este mensaje se marca como available para otro consumer, lo que duplica el procesamiento.

Para operaciones que se puedan pasar del lock duration hay dos opciones

  • extender el lock llamando a receiver.renew_message_lock() periodicamente durante el reprocesado
  • Usar la clase AutoLockRenewer la cual automáticamente renueva el lock en background las veces configuradas (es la opción más simple)

/IMPORTANTE

# Code fragment - focus on automatic lock renewal for long-running processing
from azure.servicebus import ServiceBusClient, AutoLockRenewer
from azure.identity import DefaultAzureCredential

credential = DefaultAzureCredential()

with ServiceBusClient(
    fully_qualified_namespace="<namespace>.servicebus.windows.net",
    credential=credential
) as client:
    renewer = AutoLockRenewer()
    with client.get_queue_receiver(
        queue_name="inference-requests",
        max_wait_time=30
    ) as receiver:
        for msg in receiver.receive_messages():
            # Renew the lock for up to 10 minutes
            renewer.register(receiver, msg, max_lock_renewal_duration=600)
            result = run_long_inference(msg)
            receiver.complete_message(msg)
    renewer.close()

Para operaciones realmente largas que consistemente se salten el tiempo y haya que extenderlo, es recomendable un approach en 2-fases

  1. El consumer recibe el mensaje, almacena la request en algún tipo de store persistente y lo marca como completado
  2. Un proceso standalone se encarga de coger las requests de ese store persistente e ir procesándolas a su ritmo

Este approach se salta el lock management y usa la queue solo para un reliable initial delivery

Azure Event Grid

Azure Event Grid es un servicio fully managed que conecta productores y consumidores de eventos, de forma desacoplada. Event Grid está preparado para manejar millones de eventos / s con una latencia mínima (<1s).

Opera como un servicio pub-sub que enruta eventos de productores a consumidores sin tener que administrar nosotros la infraestructura. El servicio ingesta eventos de otros servicios Azure, custom apps y/o partner systems y o bien entrega esos eventos a los endpoints de los consumidores, basándose en subscription filters, o son los mismos consumidores los que hacen pull de los eventos para leer a su ritmo.

Soporta dos modos de delivery:

  • push delivery: envía eventos al endpoint que especifiques. (ej: webhook, Azure Function, Service Bus queue)
  • pull delivery: permite a tu consumer app conectarse a Event Grid y leer eventos a su propio ritmo

Ambos modelos sirven modelos de arquitectura diferentes. La elección se basa en si los consumidores aceptan incoming HTTP requests o queremos que consuman eventos a demanda.

Event grid se integra con otros servicios de Azure a través de system topics y soporta custom app events a través de custom topics.
Esta combinación permite a tu app reaccionar a ambos tipos de eventos usando la misma infraestructura.

  • application-level: se completa una inferencia; un modelo acaba su entrenamiento
  • infrastructure-level: un blob aparece en un storage; una container image se envía al registry

Core components of Event Grid architecture

Events

Un event es una lightweight notification que describe un state change. Los eventos indican que algo ha ocurrido sin transportar el recurso completado entero (ej: “blob created”; “model training completed”). Si el consumer necesita los detalles del mensaje completo, el mismo hace retrieve del recurso.

Este diseño mantiene los eventos pequeños y rápidos de entregar.

Cada evento contiene metadata, que identifica que ha ocurrido, donde y cuando. El event body incluye un data payload con detalles de la operacion, pero el payload se espera que sea pequeño y compacto. (ej: la creación de un blob solo conllevaria el blob URL y el content type, pero no el blob en si mismo)

Event sources

Los event sources son servicios de Azure o custom apps que emiten eventos. Servicios como Blob Storage o Container Registry automáticamente publican eventos como system topics.

Custom apps pueden publicar eventos sobre custom topics que tu mismo crees. Una misma app puede actuar como ambos productor y consumidor.

Topics

Los topics son endpoints que reciben eventos de los productores. Hay de varios tipos

  • System topics: Event Grid crea system topics automaticamente para eventos de servicios de Azure. Cuando creas una event subscription para un recurso de Azure, el system topic aparece automaticamente. No puedes publicar directamente a system topics porque están restringidos para servicios de Azure.
  • Custom topics: user-defined endpoints donde tus custom apps envían eventos. Creas tu propio custom topic, configuras el input schema y publicas eventos al endpoint
  • Namespace topics: parte del Event Grid namespace resource y soporta ambos push y pull delivery. Namespace topics ofrecen capacidades adicionales como MQTT support y tienes más control sobre el consumo de eventos

No hay por que usar exclusivamente uno. Una app normal puede usar ambos por ej system y custom topics.

Event subscriptions

Un event subscription es un recurso de configuración que define que eventos vas a recibir de un determinado topic y donde se tienen que enviar.

Cada subscripcion especifica un topic en el que escucha, con filtros opcionales para seleccionar eventos, y un endpoint de destino (el event handler). Puedes crear multiples subscripciones sobre el mismo topic para filtrar eventos a diferentes handlers. Los filtros permiten reducir y seleccionar los eventos que cada subscripcion recibe por: event type, subject path o data attributes.

Event handlers

Los event handlers son los servicios de destino que reciben y procesan eventos.

Event Grid soporta varios handler types para push delivery:

  • Azure Functions: lightweight stateless event processing
  • Azure Event Hubs: ingesta eventos en una pipe de high-throughput
  • Azure Service Bus queues y topics: queues donde necesitas procesar con un orden
  • Webhooks: envia eventos a cualquier endpoint HTTP (incluidos custom services)
  • Azure Storage queues: Queue events para async processing por consumers

How AI architectures benefit from event-driven patterns

Los AI workflows conllevan muchos componentes loose coupled que necesitan coordinarse y comunicarse sin dependencias. Event-driven architecture pushea notificaciones a las partes interesadas tal y como ocurren los cambios.

Cuando llega un nuevo dataset al Blob Storage, Event Grid notifica inmediatamente a la pipe correspondiente, en vez de esperar un tiempo determinado para comprobar cambios. Este cambio reduce la latencia de minutos a segundos.

Event-driven también mejora el aislamiento de fallos. Si un consumidor experiencia un fallo, otros consumidores continúan recibiendo y procesando eventos de manera independiente.

Apply event-driven patterns to AI workload

Reactive data processing

Te subscribes a Blob Storage events (Microsoft.Storage.BlobCreated) como triggers para una AI pipe cada vez que hay nuevos datos o llegan docs. La pipe recibe el evento, hace retrieve del blob usando la URL del event data y procesa el evento.

Este patrón funciona para escenarios como document ingestion, RAG pipe, image classification o dataset preparation para model retraining.

Pipeline stage coordination

Multi-step AI pipes se benefician de custom events que señalen cambios entre transiciones.

Cuando un paso de la generacion de embeddings se completa, se envia un evento que hace trigger del proximo paso. Cada paso oepra independientemente y escala basandose en su propio workload.

Model lifecycle management

Puedes publicar custom events para model training completion, validar resultados y hacer promotions. Los servicios se subscriben a estos eventos para hacer update de sus endpoints, refrescar caches o enviar notificaciones

Structure messages (Service Bus)

El cómo estructuramos un mensaje determina como de eficientemente podemos procesar las requests. Con una buena estructura puedes hacer debug de los fallos, incluir metadatos para routing y tracking, y mantenernos dentro de los límites de nuestro tier de Service Bus.

Message anatomy

Un message de Service Bus se compone de:

  • body: lleva el payload. primary data que quieres transmitir
  • app properties: custom key-value metadata. util para enrutar, filtrar y trackear
  • system properties: propiedades añadidas por Service Bus o el SDK. Ejemplo message_id

Serializar prompts y model params

Podemos estructurar el body de un mensaje como JSON payload con todos los campos que necesita el consumer

El campo message_id se usa para identificar mensajes dentro de Service Bus. Si se activa duplicate detection en la queue, se usa este ID para descargar duplicados. Generar siempre un ID único por mensaje para evitar problemas de duplicación

# Code fragment - focus on creating a message with a JSON payload
import json
import uuid
from azure.servicebus import ServiceBusMessage

request_payload = {
    "prompt": "Extract the contract parties and effective date from this document.",
    "model": "gpt-4o",
    "temperature": 0.1,
    "max_tokens": 2000,
    "document_id": "doc-2025-0142"
}

message = ServiceBusMessage(
    body=json.dumps(request_payload),
    content_type="application/json",
    message_id=str(uuid.uuid4()),
    correlation_id="req-abc-12345",
    application_properties={
        "model_name": "gpt-4o",
        "priority": "standard",
        "document_type": "contract"
    }
)

Track requests w. correlation IDs

El correlation_id ofrece end-to-end request tracking a lo largo de la pipe. Debemos generar un ID único para cada request, ya que el mismo ID sigue al request desde el producer que lo encola, al consumer que lo procesa y al results store.

Al hacer debug de una inferencia fallida, puedes buscar los logs, colas y result stores por el correlation_id y ver el full lifecycle de la request.

# Code fragment - focus on propagating trace context in application properties
from opentelemetry import trace

current_span = trace.get_current_span()
span_context = current_span.get_span_context()

message = ServiceBusMessage(
    body=json.dumps(request_payload),
    correlation_id=correlation_id,
    application_properties={
        "traceparent": f"00-{format(span_context.trace_id, '032x')}-{format(span_context.span_id, '016x')}-01",
        "model_name": "gpt-4o"
    }
)

Handle large payloads with the claim-check pattern

Service Bus Standard tier soporta solo mensajes de 256 KB - el premium soporta hasta 100 MB.

El claim-check pattern permite separar el payload del mensaje. El producer encola un payload demasiado grande a Azure Blob Storage (u otro storage persistente) y envía al Service Bus un mensaje que contiene solo la blob URI como referencia.

De este modo el body se mantiene pequeño y solo mandamos la URL junto a los metadatos que necesitemos. El processor obtiene la el payload del storage usando la misma URI, y opcionalmente, borra el blob.

Esto también reduce los costes del broker throughput ya que hace las transferencias realmente pequeñas, y se puede usar en el Standard tier

# Code fragment - focus on the claim-check pattern for large payloads
import json
from azure.storage.blob import BlobServiceClient
from azure.servicebus import ServiceBusMessage

# Producer: upload the large payload to Blob Storage
blob_service = BlobServiceClient(
    account_url="https://<storage-account>.blob.core.windows.net",
    credential=credential
)
container_client = blob_service.get_container_client("documents")
blob_client = container_client.get_blob_client("doc-2025-0142.pdf")
blob_client.upload_blob(large_document_bytes)

# Send a claim-check message with the blob URI
claim_check = {
    "blob_uri": f"https://<storage-account>.blob.core.windows.net/documents/doc-2025-0142.pdf",
    "document_id": "doc-2025-0142",
    "model": "gpt-4o",
    "operation": "extract"
}

message = ServiceBusMessage(
    body=json.dumps(claim_check),
    content_type="application/json",
    correlation_id="req-abc-12345",
    application_properties={"pattern": "claim-check"}
)

Message TTL

La propiedad time_to_live define el tiempo de expiracion de un mensaje.

Cuando los mensajes expiran se pueden enrutar a la dead-letter queue paras ver los mensajes que no se procesaron a tiempo

# Code fragment - focus on setting time-to-live
from datetime import timedelta
from azure.servicebus import ServiceBusMessage

# Real-time classification: expire after five minutes
urgent_message = ServiceBusMessage(
    body=json.dumps(request_payload),
    time_to_live=timedelta(minutes=5)
)

# Batch processing: expire after 24 hours
batch_message = ServiceBusMessage(
    body=json.dumps(batch_payload),
    time_to_live=timedelta(hours=24)
)

Para batch processing donde la latencia no importa tanto es importante poner un TTL grande u omitirlo y usar el default de la queue

Batch messages for throughput

Cuando necesitamos enviar varias requests de a una usamos ServiceBusMessageBatch para agrupar mensajes en una única operación. Batchear reduce el numero de network round trips entre la app y el Service Bus broker.

El SDK administra el batch size automáticamente, asegurando que el total batch no se pasa del maximum size para tu tier.

El add_message() lanza MessageSizeExceededError cuando el mensaje se pasaría del batch size limit.

# Code fragment - focus on batch message sending
from azure.servicebus import ServiceBusClient, ServiceBusMessage
from azure.servicebus.exceptions import MessageSizeExceededError
import json

with client.get_queue_sender("inference-requests") as sender:
    batch = sender.create_message_batch()

    for request in pending_requests:
        message = ServiceBusMessage(
            body=json.dumps(request),
            content_type="application/json"
        )
        try:
            batch.add_message(message)
        except MessageSizeExceededError:
            # Batch is full, send the current batch and start a new one
            sender.send_messages(batch)
            batch = sender.create_message_batch()
            batch.add_message(message)

    # Send any remaining messages in the last batch
    if len(batch) > 0:
        sender.send_messages(batch)

Queues vs topics & subscriptions (Service Bus)

La primera decisión de ARQ con Azure Service Bus debe ser si usamos queues o topics + subscriptions.

Queues vs Topics

IMPORTANTE

Usamos queues cuando:

  • un único consumer necesita actuar en cada mensaje: Una pipe de doc extraction recibe un prompt, ejecuta un modelo, devuelve resultados
  • we want competing consumers for horizontal scaling: multiples consumers hacen pull de la misma queue. Service Bus asegura que cada mensaje solo es entregado a un único worker
  • no hay otros servicios que necesiten el mismo mensaje: el mensaje representa una task que se da por completado cuando un consumer lo ha procesado

Usamos topics + subscriptions cuando:

  • multiples servicios independientes reaccionan al mismo mensaje: una inferencia completa hace trigger de notificaciones, audit logs, dashboards y KPIs que se actualizan simultaneamente
  • necesitas content-based routing: Diferentes consumers reciben diferentes subsets de mensajes basándose en propiedades como priority level o document type
  • quieres añadir nuevos consumers sin modificar el producer: podemos crear nuevas subscriptions en cualquier momento sin tener que tocar el código del producer

/IMPORTANTE

Queues (single consumer)

Una queue de Service Bus entrega cada message a un único consumidor. Cuando tienes múltiples consumidores leyendo de la misma cola, Service Bus se asegura que cada mensaje sea procesado por un único consumidor.

Puedes escalar horizontalmente añadiendo más consumidores sin cambiar código. Cada consumidor se conecta de manera independiente a la queue, hace pull de los mensajes y los procesa.

Hay dos modos para controlar el ack:

  • Receive-and-delete mode: Service Bus borra el mensaje de la queue tan pronto como ha sido entregado
  • Peek-lock mode (default): Service Bus bloquea el message por una cantidad de tiempo y espera a que el consumidor explicitamente la complete, la abandone o lo marque como dead. Es el modo recomendado ya que provee at-least-once delivery. Si un consumer se crashea durante el procesado, el lock expira y el Service Bus lo vuelve a mandar a otro consumer

Las queues usan FIFO y se pueden usar para multi-step pipelines donde todos los pasos se deben ejecutar en orden

Topics + subscriptions (multiple consumers independientes)

Un Service Bus topic acepta mensajes de producers y distribuye copias a cada consumer subscrito. Cada subscripcion actua como una cola virtual independiente con sus propios consumidores.

Esté patrón se usa para escenarios donde múltiples servicios necesitan reaccionar al mismo evento de manera independiente. Ejemplo: terminamos el análisis de un documento y necesitamos notificar una alerta al usuario, un log para la BBDD para poder auditar, un aviso para el sistema de KPIs, etc. Cada subscripción procesa la copia del mensaje de manera independiente, por lo que un fallo en un sistema no afecta al resto.

Los Topics desacoplan los producers de los consumers. El producer publica mensajes a un topic sin saber cuantas subscripciones existen o lo que cada consumer hace con los mensajes. Puedes añadir nuevas subscripciones sin modificar código. Es muy util para comenzar con las necesidades y requisitos actuales y añadir nuevos servicios a medida que los necesitas sin modificar el código del resto.

Filter messages with subscription rules

Las subscriptions soportan filter rules que seleccionan messages según basándose en propiedades, permitiendo enrutar mensajes selectivamente sin escribir esa lógica en cada consumer.

IMPORTANTE

Service Bus evalúa filter rules al broken level, por lo que los mensajes que no hagan match con los filtros de una subscripción nunca se entregan a la subscripción de ese consumer.

Hay 3 tipos de filtros

  • Boolean filters: TrueFilter (default) acepta todos los mensajes; FalseFilter rechaza todos los mensajes
  • SQL filters: usa SQL-like expressions para evaluar contra app y system properties del mensaje
  • Correlation filters: matchean contra specific property values. Son más eficientes que los filtros SQL para exact-match scenarios

Se puede hacer tag de messages con app properties como model_name, priority o document_type y cada subscripción recibe solo mensajes que hacen match de ese filtro.

/IMPORTANTE

Ejemplo: filtramos por priority=high para enrutar peticiones urgentes a una VM con capacidad de GPU reservada.

# Code fragment - focus on creating a subscription rule with the management client
from azure.servicebus.management import ServiceBusAdministrationClient, SqlRuleFilter

admin_client = ServiceBusAdministrationClient(
    fully_qualified_namespace="<namespace>.servicebus.windows.net",
    credential=credential
)

admin_client.create_rule(
    topic_name="inference-results",
    subscription_name="high-priority",
    rule_name="filter-high-priority",
    filter=SqlRuleFilter("priority = 'high'")
)

Send messages with queue/topic senders

El SDK azure-servicebus usa el mismo ServiceBusClient para ambos queues y topics.

  • get_queue_sender() envía a una queue
  • get_queue_receiver() queue el consumer

  • get_topic_sender() publica en un topic
  • get_subscription_receiver() subscribe el consumer

En el receiving side, un subscription consumer se conecta a una subscripción específica en un topic. Cada subscripcion mantiene su propia copia de los mensajes, por lo que consumir de una subscripcion no afecta a la disponibilidad de mensajes de otras subscripciones.

ServiceBusClient se usa junto a with statements para asegurar que las conexiones se cierran. Es lo mismo que llamar manualmente a client.close()

# Code fragment - focus on sending to a queue versus a topic
from azure.servicebus import ServiceBusClient, ServiceBusMessage
from azure.identity import DefaultAzureCredential

credential = DefaultAzureCredential()

with ServiceBusClient(
    fully_qualified_namespace="<namespace>.servicebus.windows.net",
    credential=credential
) as client:
    # Send to a queue (point-to-point)
    with client.get_queue_sender("inference-requests") as queue_sender:
        queue_sender.send_messages(
            ServiceBusMessage("queue message body")
        )

    # Send to a topic (publish-subscribe)
    with client.get_topic_sender("inference-results") as topic_sender:
        topic_sender.send_messages(
            ServiceBusMessage("topic message body")
        )
# Code fragment - focus on receiving from a subscription
with client.get_subscription_receiver(
    topic_name="inference-results",
    subscription_name="notifications"
) as receiver:
    for msg in receiver:
        print(str(msg))
        receiver.complete_message(msg)

Azure Service Bus

Azure Service Bus es un broker managed que provee de queuing y pub/sub para apps distribuidas. Sirve de capa de conexión media entre productores y consumidores. Por debajo usa AMQP (Advanced Message Queuing Protocol). Soporta ordering y detecta duplicados.

Tiene dos tipos de funcionamiento:

  • queues (point-to-point delivery)
  • topics + subscriptions (pub/sub o broadcast)

Cada service bus reside dentro de un namespace que sirve como contenedor y provee de allocation capacity. Puedes crear múltiples queues y topics dentro de un mismo namespace, y cada namespace tiene su propio endpoint en la forma <namespace-name>.servicebus.windows.net.

Para autenticar usa SAS (Shared Access Signatures) o Entra ID.

Why to use messaging

Las AI inference ops tienen una latencia no predecible, lo cual no está hecho para sync requests. Un documento simple puede tardar 2s y uno complejo 5m.

Messaging provee de un desacoplamiento entre producer y consumer. El producer envía un message al Service Bus queue y devuelve directamente un acknowledgment (ack) al cliente.
El consumer hace retrieve de los mensajes de la queue a su propio ritmo.

Este desacoplamiento permite escalar horizontalmente de manera independiente.

Core messaging patterns

Load leveling

El load leveling pattern usa una queue para absorber burst de requests, permitiendo a los consumidores que procesen a un ritmo estable.

Durante un pico de tráfico los mensajes se acumulan en la cola en vez de poner estrés a los consumers. Simplemente trabajan en el backlog independientemente del tamaño de este.

Competing consumers

El competing consumers pattern pone varios consumers como recibidores de una misma queue. El Service Bus entrega cada mensaje a un solo consumidor, por lo que los consumers leen de la misma cola sin procesar duplicar trabajo.

Cada consumer procesa a su propio maximum rate y podemos añadir más consumidores para incrementar el throughput sin ahcer cambios de código.

Si un consumer se crashea, como no ha hecho ack de la task, esta se pone como disponible para otros workers.

Temporal decoupling

El temporal decoupling pattern significa que los productores y los consumidores no tienen que estar online de manera simultánea. Un producer puede encolar requests con todos los consumers offline (por mantenimiento, deployment, etc).

Los mensajes se persisten en la cola hasta que los consumers vuelven y los procesan.

Esto se usa para critical AI platforms.

Manage backpressure with queue depth monitoring

Si la queue incrementa demasiado los mensajes se acumulan. En vez de tratar esto como un problema, podemos usarlo como nuestro trigger que nos indique cuando tenemos que escalar consumers.

Azure Monitor provee de métricas para revisar active message count para cada queue, y puedes activar alertas cuando superen un umbral custom

Azure Container Apps y Azure Functions soportan KEDA-based scalers que automáticamente añaden processing instances basandose en el Service Bus queue length

Service Bus Tiers

Standard Tier

Soporta queues, topics y subscriptions con recursos compartidos con otros tenants. Mensajes hasta 256 KB y variable throughput basado en la carga. Versión cost-effective.

Premium Tier

Ofrece recursos dedicados, por lo que tu workload no comparte con otros tenants. Soporta mensajes hasta 100 MB al usar AMQP (1 MB para HTTP). Ofrece latencia predecible y VNET integration / private endpoints. También ofrece availability zones.

Optimize data structures for vector storage (Redis)

Hash storage es más rápido y usa menos memoria porque los vectores se guardan como compact binary blobs.

Usar Hash cuando:

  • Tienes datos flat y simples, sin nested objects
  • necesitas maxima query performance
  • priorizas memory efficiency
  • tu modelo de datos no necesita objetos nesteados

JSON storage añade overhead debido al array structure, pero ofrece más flexibilidad.

Usar JSON cuando:

  • tus datos necesitan estructuras nested
  • necesitas almacenar múltiples vectores por item
  • tu aplicación ya usa JSON
  • la flexibilidad es más importante que la raw performance

Using Redis Hash for vectors

IMPORTANTE

Redis Hash es una data structure que guarda la información como pares clave-valor en una single key (ej: product:12345), similar a un diccionario. Cuando usas Hash para vector storage, tus embeddings se convierten en un campo (guardados como binary bytes) junto a otros datos. Hash es muy buena en performance y memory eficiente. Ofrece las queries más rápidas y el menor consumo de memoria.

/IMPORTANTE

Storing vectors in hash

# Code fragment - focus on Hash storage
import numpy as np

embedding = np.array([0.1, 0.2, 0.3, ...], dtype=np.float32)

redis_client.hset(
    "product:12345",
    mapping={
        "name": "Wireless Mouse",
        "price": "29.99",
        "category": "electronics",
        "embedding": embedding.tobytes()  # Store vector as bytes
    }
)

Creating an index for Hash-based vectors

# Code fragment - focus on Hash index
from redis.commands.search.field import TextField, NumericField, VectorField
from redis.commands.search.indexDefinition import IndexDefinition, IndexType

schema = (
    TextField("name"),
    NumericField("price"),
    TextField("category"),
    VectorField("embedding", "HNSW", {
        "TYPE": "FLOAT32",
        "DIM": 1536,
        "DISTANCE_METRIC": "COSINE"
    })
)

redis_client.ft("idx:products").create_index(
    fields=schema,
    definition=IndexDefinition(
        prefix=["product:"],
        index_type=IndexType.HASH
    )
)

Using Redis JSON for vectors

IMPORTANTE

Redis JSON guarda los datos como JSON documents, permitiendo guardar información jerárquica con nested objects y arrays.

A diferencia de Hash que está flatted, JSON te permite estructurar datos complejos de forma natural. Esta flexibilidad viene con un overhead mayor de memoria y query time comparado con Hash.

/IMPORTANTE

Storing vectors in JSON

Al guardar vectors en JSON, conviertes tu NumPy array a Python list usando tolist()

# Code fragment - focus on JSON storage
import redis.commands.json as json_commands

document = {
    "name": "Wireless Mouse",
    "price": 29.99,
    "category": "electronics",
    "embedding": embedding.tolist(),  # Convert to list for JSON
    "specs": {
        "color": "black",
        "wireless": True,
        "battery": "AA"
    }
}

redis_client.json().set("product:12345", "$", document)

Creating an index for JSON-based vectors

hay una diferencia con $. para los field names y as_name param para query references

# Code fragment - focus on JSON index
from redis.commands.search.field import TextField, NumericField, VectorField
from redis.commands.search.indexDefinition import IndexDefinition, IndexType

schema = (
    TextField("$.name", as_name="name"),
    NumericField("$.price", as_name="price"),
    TextField("$.category", as_name="category"),
    VectorField("$.embedding", "HNSW", {
        "TYPE": "FLOAT32",
        "DIM": 1536,
        "DISTANCE_METRIC": "COSINE"
    }, as_name="embedding")
)

redis_client.ft("idx:products").create_index(
    fields=schema,
    definition=IndexDefinition(
        prefix=["product:"],
        index_type=IndexType.JSON
    )
)

Index and query vector data (Redis)

Azure Managed Redis ofrece capacidades de BBDD vectorial a través de RediSearch, lo que permite guardar y querying de embeddings con una latencia medida en milisegundos.

Crear un vector index

Para poder guardar vectores necesitas definir un index schema que especifique como manejar los embeddings.

Index schema components

IMPORTANTE

El campo crítico del schema es VectorField, ya que le indica a Redis como manejar tus embeddings.

/IMPORTANTE

# Code fragment - focus on VectorField configuration
from redis.commands.search.field import TextField, VectorField
from redis.commands.search.indexDefinition import IndexDefinition, IndexType

schema = (
    TextField("title"),
    TextField("content"),
    VectorField(
        "embedding",           # Field name in your Redis hashes
        "HNSW",               # Algorithm: FLAT or HNSW
        {
            "TYPE": "FLOAT32",          # Standard for AI embeddings
            "DIM": 1536,                # Must match your model's output
            "DISTANCE_METRIC": "COSINE" # Use COSINE for text, L2 for images
        }
    )
)

redis_client.ft("idx:documents").create_index(
    fields=schema,
    definition=IndexDefinition(
        prefix=["doc:"],          # Index keys starting with "doc:"
        index_type=IndexType.HASH # HASH or JSON
    )
)

Elegir indexing algorithm

REVISAR TODOS LOS SITIOS DONDE HABLE DE ESTO Y UNIFICARLO. ES UN TEMA A LO LARGO DE LA CERTIFICACIÓN

IMPORTANTE

Compara tu query contra cada vector individual en el índice para encontrar matches exactos. garantiza perfect accuracy para encontrar NN (Nearest Neighbour), pero se vuelve muy lento a medida que tus datos crecen.

FLAT es ideal para:

  • DEV
  • prototipos
  • PROD systems con datasets pequeños
  • necesitas perfect accuracy
  • puedes aceptar query latency
# Code fragment - focus on FLAT index configuration
VectorField(
    "embedding",
    "FLAT",  # Exact nearest neighbor search
    {
        "TYPE": "FLOAT32",
        "DIM": 1536,
        "DISTANCE_METRIC": "COSINE"
    }
)

Construye un grafo de varias capas y lo navega. Encuentra ANN (Aproximate Nearest Neighbour) en ms, pero no garantiza un 100% de matches exactos.

HNSW es ideal para:

  • large datasets (> 10.000 vectores)
  • PROD systems que necesiten fast queries (<10ms)
  • si 95-99% accuracy es aceptable

La mayoría de sistemas en PROD usan HNSW por las ganancias de performance, aún con la pérdida de accuracy

# Code fragment - focus on HNSW index configuration
VectorField(
    "embedding",
    "HNSW",  # Approximate nearest neighbor search
    {
        "TYPE": "FLOAT32",
        "DIM": 1536,
        "DISTANCE_METRIC": "COSINE"
    }
)

El param EF_RUNTIME indica el número de grafos a explorar para cada query

# Code fragment - focus on runtime tuning
query = Query(
    "*=>[KNN 10 @embedding $query_vec EF_RUNTIME 100 AS score]"
).dialect(2)

/IMPORTANTE

Ingest vector data

La ingestión es el proceso de cargar los embeddings en Redis para que sean buscables. A diferencia de datos normales, los vectores necesitan cuidados especiales.

IMPORTANTE

Redis guarda los emebddings como binary blobs (byte arrays) por temas de eficiencia, lo que significa que tienes que convertir tus arrays a bytes con tobytes() antes de guardarlos.

Al añadir embeddings a index prefix (ej: doc:*) Redis automáticamente se encarga de indexarlos. No tienes que hacer nada más.

/IMPORTANTE

Store vectors with metadata

IMPORTANTE

Siempre debemos guardar vectores junto a metadatos para filtrar resultados. Redis Hash permite guardar todo junto en una single key usando hset con un mapping dictionary.

/IMPORTANTE

# Code fragment - focus on vector storage with tobytes()
import numpy as np

embedding = np.array([0.1, 0.2, 0.3, ...], dtype=np.float32)

redis_client.hset(
    "doc:001",
    mapping={
        "title": "Getting Started with Azure AI",
        "content": "Azure AI Services provide pre-built models...",
        "embedding": embedding.tobytes(),  # Convert NumPy array to bytes
        "category": "documentation"
    }
)

Bulk ingestion (for performance)

IMPORTANTE

No es ideal mandar cientos de millones de vectores de golpe con hset ya que la red puede ser un límite al throughput. Solucionamos estos con Pipeles, enviando batches de multiples comandos juntos en un single network trip. Todos los comandos se ejecutan de manera atómica en el server y recives las respuestas de todos a una cuando llamas execute()

/IMPORTANTE

# Code fragment - focus on bulk ingestion pattern
# Assumes `documents` is a list of dicts with 'id', 'title', 'content', 'embedding'

pipeline = redis_client.pipeline()

for doc in documents:
    vector_bytes = np.array(doc['embedding'], dtype=np.float32).tobytes()

    pipeline.hset(
        f"doc:{doc['id']}",
        mapping={
            "title": doc['title'],
            "content": doc['content'],
            "embedding": vector_bytes,
            "category": doc.get('category', 'general')
        }
    )

# Execute all HSETs in one network round-trip
pipeline.execute()

Querying por similaridad

Vector similarity usa KNN (K-Nearest Neighbours) para encontrar los vectores más similares - para COSINE distance 0.0 significa vectores idénticos mientras que 2.0 indica vectores opuestos.

Basic KNN queries

Una query KNN requiere

  • query vector (convertido a bytes)
  • número K a devolver (cuantos queremos)
  • vector field a buscar (@embedding)
  • dialect(2) (requerido para vector queries)

Ejemplo de query string

*=>[KNN 5 @embedding $query_vec as score]

la cual indica:

  • * busca todos los documentos
  • => indica vector search syntax
  • KNN 5 pide 5 NN
  • @embedding especifica que campo contiene los vectores
  • $query_vec es un placeholder para tu query vectorial
  • AS score devuelve la distancia como un campo que puedas filtrar
# Code fragment - focus on KNN query syntax
from redis.commands.search.query import Query

query_bytes = np.array(query_embedding, dtype=np.float32).tobytes()

query = (
    Query("*=>[KNN 5 @embedding $query_vec AS score]")
    .return_fields("title", "content", "score")
    .sort_by("score")
    .dialect(2)
)

results = redis_client.ft("idx:documents").search(
    query,
    query_params={"query_vec": query_bytes}
)

Hybrid search: Filtrar por metadatos

Hybrid search mezcla vector similarity con metadata filters.

Ejemplo de query string con filtros

@category:{documentation}=>[KNN 3 @embedding $query_vec AS score]

la cual indica:

  • @category:{documentation} antes de => indica que filtre los matching items antes de pasar a la búsqueda vectorial
# Code fragment - focus on hybrid query syntax
hybrid_query = Query(
    "@category:{documentation}=>[KNN 3 @embedding $query_vec AS score]"
).return_fields("title", "category", "score").sort_by("score").dialect(2)

results = redis_client.ft("idx:documents").search(
    hybrid_query,
    query_params={"query_vec": query_bytes}
)

Range queries: Threshold-based retrieval

Mientras que KNN devuelve un número fijo de resultados, las range queries devuelven todos los vectores que haya a una distancia especificada.

Es útil cuando quieres todo lo que haya con un cierto nivel de similitud, independientemente de devolver un número arbitrario.

Por ejemplo: queremos todos los docs con un COSINE distance menor de 0.2, lo cual puede devolver 3 o 300

# Code fragment - focus on VECTOR_RANGE syntax
range_query = Query(
    "@embedding:[VECTOR_RANGE 0.2 $query_vec]=>{$YIELD_DISTANCE_AS: score}"
).return_fields("title", "score").sort_by("score").dialect(2)

results = redis_client.ft("idx:documents").search(
    range_query,
    query_params={"query_vec": query_bytes}
)

Understand distance metrics

ATENCION: esto moverlo a otra parte ya que es un tema multi-repetido a lo largo de toda la cert.

  • COSINE: Usar para text embeddings
  • L2 (Euclidean): Usar para image embeddings o spatial data
  • IP: Usar solo para embeddings pre-normalizados

/ATENCION: esto moverlo a otra parte ya que es un tema multi-repetido a lo largo de toda la cert.

Choose vector types and indexing strategies (Redis)

Vector data types

Redis usa FLOAT32 o FLOAT64, lo cual impacta en la memoria que consumen tus vectores (junto a la dimensionalidad de los embeddings) y en la precisión de las búsquedas semánticas,

IMPORTANTE

Para la mayoría de AI apps FLOAT64 no provee de ninguna mejora respecto a FLOAT32 porque los modelos no dan valores tan precisos. Para standard work se debe usar FLOAT32

/IMPORTANTE

# Code fragment - focus on vector data type configuration
VectorField(
    "embedding",
    "HNSW",
    {
        "TYPE": "FLOAT32",  # Standard choice for AI embeddings
        "DIM": 1536,
        "DISTANCE_METRIC": "COSINE"
    }
)

Match embeddings dimensions

La dimensionalidad tiene que ser la misma en Redis y en el embedding’s model output

# Code fragment - focus on dimension matching
embedding_models = {
    "small-model": 384,
    "medium-model": 768,
    "large-model": 1536,
    "xlarge-model": 3072,
}

# Create index matching your model
VectorField(
    "embedding",
    "HNSW",
    {
        "TYPE": "FLOAT32",
        "DIM": 1536,  # Must match model output
        "DISTANCE_METRIC": "COSINE"
    }
)

Distance metrics

IMPORTANTE

Para la mayoría de AI apps que envuelven texto, usaremos COSINE

  • COSINE: mide el ángulo entre vectores, ignorando la magnitud. Se usa para text embeddinsg y semantic similarity (OpenAI y lo que la mayoría de LLMs esperan)
  • L2 (Euclidean): mide la distancia recta en el espacio vectorial. Se usa para image embeddings y spatial data donde importan ambos la dirección y la magnitud
  • IP (Inner product): Computa el dot product entre vectores. Se usa solo cuanto tenemos embeddings pre-normalizados o modelos espacializados que lo requieren.

/IMPORTANTE

Es importante tener en cuenta la distancia para la que está entrenado el embeddings model - hay modelos que necesitan distance metrics específicas.

# Code fragment - focus on distance metric selection

# For text embeddings (most common)
VectorField("embedding", "HNSW", {
    "TYPE": "FLOAT32",
    "DIM": 1536,
    "DISTANCE_METRIC": "COSINE"  # Use for OpenAI, Cohere, Sentence Transformers
})

# For image embeddings
VectorField("image_embedding", "HNSW", {
    "TYPE": "FLOAT32",
    "DIM": 768,
    "DISTANCE_METRIC": "L2"  # Use for vision models
})

Broadcast (pub/sub) vs Coordinated distribution (streams)

Imagina que tienes tres worker services procesando requests.

Con pub/sub si suscribes a los 3 workers al mismo channel, cada worker recibe cada mensaje, lo que crea duplica el procesamiento.

Con Streams consumer groups cada request va a un solo worker, distribuyendo la carga de trabajo automáticamente.

Choosing the right approach

IMPORTANTE

Usa pub/sub cuando:

  • Todos los subscribers necesiten procesar el mismo mensaje (cache invalidation, config updates, notifications)
  • No necesites garantias de entrega o acknowledgments
  • Cada subscriber ejecuta acciones diferentes basados en el mismo evento

Usa Stream consumer groups cuando:

  • Cada mensaje deba ser procesado por exactamente un worker (task queues, job processing)
  • Si que necesites garantias de entrega o acknowledgments
  • Necesites escalar el procesamiento añadiendo más consumidores
  • Necesites poder manejar fallos y reasignar tareas

/IMPORTANTE

Pub/Sub: Broadcast to all subscribers

Cuando subscribes multiples servicios al mismo pub/sub channel, cada subscriber recibe cada mensaje. Redis pub/sub está diseñado para hacer broadcasting de eventos a múltiples consumidores de manera simultánea.

How broadcast distribution works

Redis delivers each published message to all active subscribers of that channel.

Si tienes 5 consumidores subscritos al channel ai:models:updated y publicas un mensaje en ese canal, los 5 servicios reciben el mismo mensaje de manera simultánea

# Publisher service
redis_client.publish('ai:cache:invalidate', 'embeddings-v2')

# All of these subscribers receive the message:
# - Subscriber 1 (API server instance 1)
# - Subscriber 2 (API server instance 2)
# - Subscriber 3 (Background worker)
# - Subscriber 4 (Analytics service)

Casos de uso

IMPORTANTE

Este diseño es intencional y es útil para escenarios específicos.

Usa pub/sub cuando necesites que todos tus servicios reaccionen al mismo evento de manera simultánea

  • Cache invalidation across microservices: publicamos en un channel para asegurar que cada instancia y cada microservicio recibe la señal de invalidar caché
# Model update service
def update_model(model_id, new_version):
    save_model_to_storage(model_id, new_version)
    # Notify all API instances to clear cache
    redis_client.publish('ai:models:cache:invalidate',
                        f'{model_id}:{new_version}')

# Each API instance subscribes and clears its own cache
pubsub = redis_client.pubsub()
pubsub.subscribe('ai:models:cache:invalidate')
for message in pubsub.listen():
    if message['type'] == 'message':
        clear_local_model_cache(message['data'])
  • Configuration updates for distributed services: Cuando al cambiar un param o una feature flag queremos que todos los servicios actualicen su conf
  • Real-time monitoring and metrics collection: podemos conectar multiples monitoring systems al mismo canal para que todos reciban los mismos datos sin interferir entre ellos
  • Event notification: Cuando un user completa una interacción y necesitamos avisar a múltiples servicios de manera simultánea

/IMPORTANTE

Cuando causa problemas

IMPORTANTE

No uses pub/sub cuando necesites:

  • Process tasks that should only run once: si tienes 3 consumers subscritos a un channel y publicas un mensaje, los 3 consumers procesan la misma request.
  • Load balancing across workers: pub/sub no distribuye mensajes - los duplica. No sirve para escalar horizontalmente.
  • Queue-like work distribution: pub/sub no garantiza que los mensajes han sido consumidos y no da acknowledgments. pub/sub es fire-and-forget. Los mensajes puedes ser procesados múltiples veces o ninguna - no hay manera de saberlo

/IMPORTANTE

Streams: Coordinated work distribution

Usar Streams cuando necesitas coordinar multiples subscribers para evitar duplica processing y distribuir carga de trabajo. Redis Streams consumer groups resuelven este problema. A diferencia de pub/sub, los consumer groups aseguran que cada mensaje vaya a un único subscriber.

How consumer groups distribute work

Los consumer groups particionan el Stream entre los group members. Cuando múltiples workers leen del mismo consumer group, Redis reparte automáticamente y asigna diferentes mensajes a diferentes workers. Cada mensaje se entrega a un único consumer en el grupo.
Esto ocurre automáticamente, no tienes que balancear nada.

# Setup: Create a consumer group once
redis_client.xgroup_create('ai:inference:queue', 'workers', '0', mkstream=True)

# Worker 1 gets messages 1, 3, 5
# Worker 2 gets messages 2, 4, 6
# Worker 3 gets messages 7, 8, 9

# All workers use the same group name but different consumer names
messages = redis_client.xreadgroup(
    groupname='workers',  # Same group
    consumername=f'worker-{worker_id}',  # Unique per worker
    streams={'ai:inference:queue': '>'},
    count=10
)

Setting up consumer groups in your worker services

Lo normal es crear el consumer group una única vez durante la inicialización de la App, y a partir de entonces que cada worker instance lea del mismo group.

cada worker obtiene tasks diferentes de manera automática, lo que permite un escalado horizontal

# Application startup code (runs once per deployment, not per instance)
def setup_worker_infrastructure():
    try:
        redis_client.xgroup_create(
            'ai:document:analysis',
            'analysis-workers',
            '0',  # Start from beginning
            mkstream=True  # Create stream if doesn't exist
        )
    except redis.ResponseError as e:
        # Group already exists, which is fine
        if 'BUSYGROUP' not in str(e):
            raise

# Worker processing loop (runs on each worker instance)
def process_documents():
    worker_id = f"{os.getenv('HOSTNAME')}-{os.getpid()}"

    while True:
        messages = redis_client.xreadgroup(
            groupname='analysis-workers',
            consumername=worker_id,
            streams={'ai:document:analysis': '>'},
            count=5,
            block=5000
        )

        for stream, tasks in messages:
            for task_id, task_data in tasks:
                analyze_document(task_data)
                redis_client.xack('ai:document:analysis',
                                 'analysis-workers',
                                 task_id)

Understand the > symbol and consumer positions

Al leer del consumer group el símbolo > le comunica a Redis que te dé nuevos mensajes que no hayan sido entregados todavía a ningún consumidor.

esto es lo que permite work distribution. Cuando worker-1 lee con > obtienes mensajes que worker-2 no recibe. Redis hace track de que mensajes se entregan a que consumidores

# Read only NEW messages not yet delivered to any consumer
redis_client.xreadgroup('workers', 'worker-1',
                       {'ai:queue': '>'}, count=10)

También podemos especificar un ID para leer de una posición específica, lo cual es útil para manejar pending messages.

# Read messages pending for this specific consumer
redis_client.xreadgroup('workers', 'worker-1',
                       {'ai:queue': '0'}, count=10)

Scaling workers dynamically

Una de las ventajas principales de los consumer groups es que permiten escalar horizontalmente sin cambios de código. Solo con escalar los micros es suficiente ya que automaticamente se distribuye el trabajo

# This same code runs on 2 workers or 20 workers
# Redis automatically distributes work based on how many workers are reading

def worker_main():
    setup_worker_infrastructure()  # Idempotent group creation

    worker_id = generate_unique_worker_id()

    while True:
        tasks = fetch_next_tasks('workers', worker_id)
        process_tasks(tasks)
        acknowledge_completion(tasks)

Handling failures and task reassignment

Los consumer groups tienen built-in mechanism para manejar fallos de los consumidores. Cuando un consumidor (worker) se crashea mientras procesa una task, esa task se queda en la lista de pendientes y se puede reasignar a otro healthy worker.

Detecting and claiming stuck tasks

Usa XPENDING para encontrar tasks que llevan en progreso demasiado tiempo y usa XCLAIM para reasignarlas.

# In a separate monitoring/health-check service or worker
def reassign_abandoned_tasks():
    # Check for tasks pending more than 5 minutes
    pending = redis_client.xpending_range(
        'ai:inference:queue',
        'workers',
        '-', '+',
        count=100
    )

    current_time = int(time.time() * 1000)

    for task in pending:
        task_id = task['message_id']
        idle_time = current_time - task['time_since_delivered']

        # Task processes for more than 5 minutes, likely stuck
        if idle_time > 300000:
            # Claim it for reprocessing
            redis_client.xclaim(
                'ai:inference:queue',
                'workers',
                f'recovery-worker-{os.getpid()}',
                300000,
                message_ids=(task_id,)
            )

            # Now process it
            reprocess_stuck_task(task_id)

Implement automatic retry in workers

Cada worker puede hacer check de sus propias tasks en startup, permitiendo automatic recovery después de los restarts.

def worker_startup_recovery():
    worker_id = get_worker_id()

    # Check if this worker holds any pending tasks from before crash
    pending = redis_client.xpending_range(
        'ai:inference:queue',
        'workers',
        '-', '+',
        count=100
    )

    # Filter for tasks assigned to this consumer
    my_pending = [p for p in pending if p['consumer'] == worker_id]

    # Retry each pending task
    for task in my_pending:
        try:
            retry_task(task['message_id'])
            redis_client.xack('ai:inference:queue', 'workers',
                            task['message_id'])
        except Exception as e:
            log_error(f"Retry failed for {task['message_id']}: {e}")

Task queues with Redis Streams

Redis Streams es una manera de implementar task queues y event processing en backend services. Se usa cuando necesitas encolar requests, coordinar pipes multi-proceso o gestionar long-running ops.
Los Streams te dan la durabilidad y la coordinacion que pub/sub no da.

Redis Streams

Los Streams son append-only task queues donde añades items y los consumers hacen pull de los items de la cola.

Puedes usar

  • XADD para añadir tasks
  • XREADGROUP para hacer pull de tasks en tu worker
  • XACK para marcar tasks como completas

IMPORTANTE

La diferencia de listas con los Streams es que estos trackean que consumidor ha procesado que task, y permiten retries automáticos si tu servicio se crashea.

/IMPORTANTE

What devs get from Streams

  • task survive crashes: cuando hay un reinicio, no pierdes las tasks no procesadas. Estas siguen en el Stream.
  • automatic retry handling: si tu codigo se crashea mientras procesa una task, esa task se pone como disponible para reintentarla automaticamente
  • built-in work distribution: cuando escalas a múltiples workers, Stream consumer groups automaticamente distribuyen tasks a lo largo de instancias sin duplicar trabajo
  • processing history: puedes hacer queries para ver que ha pasado en la pipe, hacer un replay para debuggear o que servicios nuevos se pongan al dia con datos historicos
  • simple async patterns: Los handlers pueden añadir tasks a los streams y volver inmediatamente mientras background workers procesan tasks a su ritmo

Stream task structure

Cada task que añades a un Stream obtiene su ID auto-generado y puede contener cualquier campo que necesites. Piensa que es como añadir un JSON object a una cola.

este ID se asegura que las tasks se procesan en orden

# Adding an AI processing task
stream_id = redis.xadd('ai:inference:requests', {
    'user_id': '12345',
    'model': 'gpt-4',
    'prompt': 'Summarize this document...',
    'priority': 'high'
})
# Returns ID like: '1699980000000-0'

Scaling with multiple workers

Cuando haces deploy de multiples instancias, los consumer groups se aseguran de que cada task solo vaya a un único worker. Creas un grupo una única vez y entonces cada worker instance lee del mismo grupo.

ahora puedes escalar horizontalmente - añade más worker instances para compartir la carga

# In your worker deployment/startup code
try:
    redis.xgroup_create('ai:inference:requests', 'workers', id='0', mkstream=True)
except redis.ResponseError:
    pass  # Group already exists

# In your worker's processing loop (runs on each instance)
while True:
    tasks = redis.xreadgroup('workers', 'worker-instance-1',
                             {'ai:inference:requests': '>'},
                             count=10, block=5000)
    for task_id, task_data in tasks:
        process_ai_task(task_data)
        redis.xack('ai:inference:requests', 'workers', task_id)

Cuando usar Streams

Redis Streams son ideales para escenarios donde queremos reliability y la persistencia de las tasks es importante.

  • API endpoints que encolan requests: En vez de bloquear la API mientras espera una request lo podemos en una cola y devolvemos el ID automáticamente. Los background workers lo procesan y hacen update de los resultados
  • Multi-step processing pipelines: Cuando procesar requiere multiples pasos todos en orden (extraer - analizar - resumir). Si cualquier paso falla, no pierdes progreso
  • Worker services que escalan horizontalmente: los streams distribuyen automaticamente el trabajo
  • Long running operations que necesitan retry
  • System requiring processing history: cuando necesitamos un historial para ver que ha pasado y cuando

Code Examples

Adding AI tasks to a queue

Usa XADD para añadir a un Stream. Cada task tiene un ID unico.

# Your API handler code
def queue_inference_request(user_prompt, model_name):
    task_id = redis.xadd('ai:inference:queue', {
        'prompt': user_prompt,
        'model': model_name,
        'user_id': current_user.id,
        'requested_at': datetime.now().isoformat()
    })
    return task_id

Processing tasks in your worker service

Worker services usan XREADGROUP para hacer fetch de tasks desde un Stream y XACK para marcarlas como completadas.

# Worker service processing loop
def process_ai_tasks():
    # One-time setup: create consumer group
    try:
        redis.xgroup_create('ai:inference:queue', 'workers', id='0', mkstream=True)
    except:
        pass  # Already exists

    # Main processing loop
    while True:
        # Get up to 5 tasks, wait 5 seconds if queue empty
        messages = redis.xreadgroup(
            groupname='workers',
            consumername=f'worker-{os.getpid()}',
            streams={'ai:inference:queue': '>'},
            count=5,
            block=5000
        )

        for stream, tasks in messages:
            for task_id, task_data in tasks:
                try:
                    # Do your AI processing
                    result = run_inference(task_data['prompt'], task_data['model'])
                    save_result(task_id, result)

                    # Mark task complete
                    redis.xack('ai:inference:queue', 'workers', task_id)
                except Exception as e:
                    # Task stays in pending, will retry
                    log_error(f"Task {task_id} failed: {e}")

Handling failed tasks

Usa XPENDING para encontrawr tasks que han estado procesando demasiado tiempo y XCLAIM para reasignarlas. Esto se encarga de casos donde los workers se crashean a medio del proceso.

# Check for tasks that have been pending too long (stuck/crashed)
def retry_stuck_tasks():
    pending = redis.xpending('ai:inference:queue', 'workers', '-', '+', 10)

    for task in pending:
        task_id = task['message_id']
        idle_time = task['time_since_delivered']

        # If task pending more than 5 minutes, reassign it
        if idle_time > 300000:  # milliseconds
            redis.xclaim('ai:inference:queue', 'workers',
                        f'worker-{os.getpid()}', 0, [task_id])

Monitoring queue health

Usa XINFO para obtener metricas de Stream queues. Estos datos son utiles para dashboards y alertas.

# Get Stream metrics for your application dashboard
def get_queue_stats():
    info = redis_client.xinfo_stream('ai:documents:queue')
    groups = redis_client.xinfo_groups('ai:documents:queue')

    return {
        'total_tasks': info['length'],
        'pending_tasks': groups[0]['pending'],
        'consumers': groups[0]['consumers']
    }

Trade-offs a considerar

  • Memory management es TU responsabilidad: A diferencia de pub/sub donde los mensajes desaparecen despues de ser entregamos, Stream tasks se mantienen en memoria hasta que tu los borrar. Para high-volume queues necesitas encargarte de limpiar
# Trim to most recent 10,000 tasks when adding new ones
redis.xadd('ai:inference:queue', task_data, maxlen=10000, approximate=True)

# Or trim periodically in your worker after acknowledging tasks
if task_count % 100 == 0:  # Every 100 tasks
    redis_client.xtrim('ai:documents:queue', maxlen=10000, approximate=True)
  • Slighty higher latency than pub/sub: Streams añaden unos ms de latencia por la persistencia y el ack tracking. Si necesitas esos ms de latencia, usa pub/sub
  • Más complejidad: Necesitas gestionar consumer groups, ack, y pending task checks. Pub/sub es más simple pero a cambio obtienes esa erliability
  • Tasks no auto-expiran: Las tasks completadas se quedan en el Steram hasta que se borran