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)