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
- leer cada mensaje de la DLQ
- crear UN NUEVO MENSAJE con el mismo body y properties
- volver a mandarlo a la queue original
- 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
AutoLockRenewerla 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
- El consumer recibe el mensaje, almacena la request en algún tipo de store persistente y lo marca como completado
- 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