Redis pub/sub

Azure Managed Redis incorpora messaging capabilities a través del patrón publish/subscribe (pub/sub). Esto permite comunicación asíncrona en tiempo real entre diferentes partes de tu AI app.

Este modelo permite a los publishers enviar mensajes a named channels sin tener detalles de quién los va a recibir, o sin saber si hay alguien escuchando. Los subscribers pueden escuchar uno o más canales y recibir los mensajes publicados, creando una loosely coupled, event-driven AI architecture.

Redis pub/sub es útil en AI apps donde los componentes necesitan reaccionar inmediatamente a eventos sin bloqueos.

Como funciona pub/sub

  • at-most-once delivery: los mensajes se entregan a los subscribers que están activamente conectados cuando se publica el mensaje. No hay garantías si un subscriber se desconecta temporalmente.
  • no message persistence: los mensajes existen solo en memoria mientras se distribuyen a los subscribers. Una vez entregados no se guardan por Redis. Esto lo hace ideal para real-time notifications pero no es util para escenarios que requieren persistencia de mensajes
  • fire-and-forget: Los publishers no saben si hay subscribers que reciben los mensajes. Este desacoplado lo hace muy fuerte para el escalado, pero significa que no hay confirmación
  • high throughput

Límites a considerar

  • No message durability: Los mensajes que llegan cuando no hay subscribers escuchando se pierden para siempre. Si un subscriber se desconecta temporalmente, se pierde los mensajes que hayan llegado mientras estaba offline
  • No delivery guarantees: Los publishers no saben si alguien recibe los mensajes correctamente. Si todos los subscribers están offline, los mensajes se pierden
  • Memory-only operation: Los mensajes solo se mantienen en memoria, nunca en disco. Redis pub/sub no es útil para escenarios que requieren de persistencia de los mensajes, un orden procesado o replay capabilities

Cuando usar pub/sub

Usarlo cuando necesites:

  • coordinación en tiempo real con latencia sub-millisecond
  • broadcasting updates a multiples componentes de manera simultanea
  • un loose coupling entre micros
  • high throughput messages
  • simple event distribution
  • parallel processing triggers

Channel naming and patterns

Los canales en Redis son strings

ai:conversations:123       # Conversation-specific AI events
ml:model:predictions       # ML model prediction results
ai:training:status         # Model training status updates
embeddings:cache:refresh   # Vector embedding cache updates

Redis soporta pattern matching para los subscriptores, permitiendo a los componentes escuchar en múltiples canales relacionados

ai:conversations:*        # All conversation AI events
ml:models:*:status       # All model status updates
ai:*:predictions        # All AI prediction events

Code examples

publish events

Usa PUBLISH para enviar messages a channels.

# Publish a cache invalidation event
def notify_model_updated(model_name, version):
    message = f"{model_name}:{version}"
    redis_client.publish('ai:models:updated', message)

# Publish embedding refresh notification
def notify_embeddings_refreshed(collection_id):
    redis_client.publish('ai:embeddings:refresh', collection_id)

subscribe to channels in worker services

Usa SUBSCRIBE para escuchar a canales específicos. Los subscriben son servicios que corren en background y reaccionan a eventos

# Subscribe to specific channels
pubsub = redis_client.pubsub()
pubsub.subscribe('ai:models:updated', 'ai:embeddings:refresh')

# Listen for messages
for message in pubsub.listen():
    if message['type'] == 'message':
        channel = message['channel']
        data = message['data']

        if channel == 'ai:models:updated':
            # Clear model cache
            clear_model_cache(data)
        elif channel == 'ai:embeddings:refresh':
            # Refresh embedding cache
            refresh_embeddings(data)

use pattern subscriptions

Usa PSUBSCRIBE para subscribirte a múltiples canales con pattern matching. Esto es útil cuando quieres escuchar en todos los canales de una categoría.

# Subscribe to all AI-related channels
pubsub = redis_client.pubsub()
pubsub.psubscribe('ai:*')

# Handle messages from any AI channel
for message in pubsub.listen():
    if message['type'] == 'pmessage':
        pattern = message['pattern']  # 'ai:*'
        channel = message['channel']  # Actual channel name
        data = message['data']

        print(f"Received on {channel}: {data}")
        handle_ai_event(channel, data)

broadcasting to WebSocket clients

Combina pub/sub con WebSocket connections para pushear eral-time updates to browser clients

from fastapi import FastAPI, WebSocket
import redis.asyncio as redis
import asyncio

app = FastAPI()

# Background task to listen for Redis pub/sub messages
async def redis_listener(websocket: WebSocket):
    redis_client = redis.Redis(
        host='your-redis.redis.cache.windows.net',
        port=<PORT>,
        password='your-access-key',
        ssl=True,
        decode_responses=True
    )

    async with redis_client.pubsub() as pubsub:
        await pubsub.subscribe('ai:predictions:ready')

        async for message in pubsub.listen():
            if message['type'] == 'message':
                # Forward Redis message to WebSocket client
                await websocket.send_json({
                    'type': 'prediction',
                    'data': message['data']
                })

@app.websocket("/ws/{client_id}")
async def websocket_endpoint(websocket: WebSocket, client_id: str):
    await websocket.accept()
    await redis_listener(websocket)