Curso de ZeroMQ para tu equipo — Sistemas distribuidos

Tipos de socket: REQ, REP, PUB, SUB, PUSH, PULL, DEALER, ROUTER

Creación y binding (`bind`, `connect`)

Métodos `send`, `recv`, `poll`

Práctica: servidor REP y cliente REQ en local

Blocking vs non-blocking sockets

Transmisión de strings y binarios

Identificación de sockets (`setsockopt`)

Control de tiempo (`RCVTIMEO`, `SNDTIMEO`)

Revisión de `zmq.Context` y su rol

Gestión de errores y excepciones

Diseño clásico de petición-respuesta

Práctica: servidor de eco con control de mensajes

Ciclo REQ/REP estricto: send-receive

Problemas de bloqueo y timeouts

Serialización con `json`, `pickle`

Patrones de respuesta condicional

Timeouts y reintentos de cliente

Creación de múltiples clientes conectados

Escalado horizontal del servidor

Logging de tráfico

Publicación y suscripción

Práctica: simulador de precios en tiempo real

Subscripciones por prefijo y patrón

Control de temas y filtros

Ejecución asincrónica con múltiples subscriptores

Conexiones interrumpidas y reconexión

Casos de uso: logs, eventos, métricas

Limitaciones de PUB/SUB y entrega de mensajes

Aplicación en dashboards en vivo

Mejores prácticas en entornos broadcast

Patrón de distribución de carga

Práctica: cola de tareas con múltiples workers

Balanceo automático por diseño

Simulación de latencia entre nodos

Diseño sin servidor central

Paralelización de procesamiento

Workers escalables y dinámicos

Patrones de control y monitoreo

Control de flujo y buffers

Aplicación en pipelines ETL

Sockets de nivel avanzado

Práctica: broker enrutador con múltiples clientes

Control manual del enrutamiento

Identificadores personalizados (`zmq.IDENTITY`)

Implementación de backend inteligente

Balanceo en ROUND-ROBIN o prioridad

Gestión de sesiones y contexto

Conversaciones asincrónicas

Middleware personalizado sobre ROUTER

Envío multipartes

Comparativa con `multiprocessing.Queue`

Práctica: producción y consumo de datos entre procesos

Ventajas frente a sockets estándar

Compartición de contexto entre procesos

Uso con `threading` y `asyncio`

Mensajería segura entre procesos del mismo host

Envío eficiente de estructuras de datos

Limitaciones por arquitectura

Persistencia temporal en memoria

Modelo de comunicación híbrido

Definición de topologías distribuidas: estrella, malla, árbol

Práctica: diseño de red jerárquica con PUB/SUB y ROUTER

Combinación de patrones

Routing interno vs externo

Diagramas de arquitectura de ejemplo

Balanceo y tolerancia a fallos

Casos reales (logs distribuidos, controladores)

Coordinación de nodos

Aislamiento de fallos

Mecanismos de recuperación

Text vs binary: UTF-8, JSON, Pickle, Protocol Buffers

Práctica: comparar rendimiento entre formatos

Compresión de mensajes grandes

Serialización en Python y C++

Custom protocol framing

Cifrado básico con `libsodium`

Conversión a hexadecimal y base64

Pruebas de integridad (hashing)

Recepción de archivos binarios (PDF, imágenes)

Casos de uso mixtos: texto + binario

Arquitectura de productor -> broker -> worker

Desacoplamiento total entre productor y consumidor

Multiples productores simulando tareas reales

Balanceo de carga con PUSH/PULL

Logs de ejecución y métricas

Gestión de errores y reintentos

Serialización de resultados

Escalado horizontal de nodos

Simulación de fallo y recuperación

Visualización de flujo en tiempo real

Gestión de timeouts en envío y recepción

Reintentos y backoff exponencial

Práctica: cliente REQ con reconexión automática

Captura de excepciones por desconexión

Supervisión de procesos consumidores

Reconexión de nodos interrumpidos

Keep-alive en redes no confiables

Protección contra mensajes corruptos o incompletos

Implementación de watchdogs

Detección de “nodos zombies”

Escalado de workers en PUSH/PULL

Práctica: simular carga con múltiples productores y consumidores

Consumo paralelo desde un broker

Estrategias round-robin vs weighted

Separación por funciones o canales

Afinidad por datos o zona geográfica

Estrategias para evitar cuellos de botella

Configuraciones para entornos de alta disponibilidad

Consistencia eventual vs inmediata

Coordinación de nodos

Logging centralizado desde sockets

Práctica: servidor de logs usando PUB/SUB

Métricas básicas: mensajes enviados, fallidos, en cola

Recolección con Prometheus (exporters)

Trazas por sesión y nodo

Análisis de tiempo de viaje (latencia)

Visualización con Grafana

Uso de IDs únicos por mensaje

Log rotación y exportación a CSV

Alarmas por latencia o pérdida de conexión

Introducción a CurveZMQ (CurveCP + ZeroMQ)

Generación de claves públicas/privadas

Práctica: asegurar canal REQ/REP con Curve

Encriptación de mensajes punto a punto

Validación de identidades entre sockets

Seguridad en sockets públicos (firewall + auth)

Protección contra spoofing

Uso de ZAP (ZMQ Authentication Protocol)

Control de accesos y whitelist de nodos

Gestión segura de claves

Interoperabilidad entre clientes en distintos lenguajes

Práctica: cliente C++ que se comunica con broker Python

Uso de bindings oficiales (`cppzmq`, `pyzmq`, `jzmq`)

Serialización común: JSON, MsgPack, Protobuf

Convenciones en cabeceras y metadatos

Wrapper de librerías para APIs internas

Generación de código desde IDL

Compilación y ejecución en entornos mixtos

Reutilización de sockets entre módulos

Librerías multilenguaje compatibles

Servir APIs REST sobre sockets internos

Práctica: Flask como API externa, ZeroMQ como capa de trabajo

Separación de red pública y privada

Gestión de cargas desde frontend web

WebSockets para broadcast con ZeroMQ

Integración con sistemas legacy (JSON, XML)

Microservicios coordinados por sockets

Recolección de tareas desde frontend

ZeroMQ como intermediario backend

Validación, autenticación y logging web

ZeroMQ no incluye almacenamiento por defecto

Práctica: cola persistente con SQLite + ZeroMQ

Implementación de colas durables

Envío garantizado tras reinicio de proceso

Escritura de logs de mensajes enviados/recibidos

Retención de mensajes no entregados

Bases de datos ligeras como buffer

Confirmación de recepción por ACK personalizado

Modelo publish & persist

Casos de uso con MQ híbrida

Herramientas: `time`, `ab`, `wrk`, `locust`, `zmqperf`

Práctica: benchmark de sistema PUB/SUB con 10.000 mensajes

Medición de latencia media y desviación estándar

Métricas: throughput, backpressure, uso de CPU

Comparación de patrones bajo carga

Uso de buffers, prioridades y tamaños de mensaje

Benchmark local vs en red real

Resultados por volumen y frecuencia

Stress testing distribuido

Documentación técnica de resultados

Elección correcta del patrón de socket según el caso

Práctica: refactorizar app simple para usar PUSH/PULL

Separación de lógica de transporte

Reutilización de contextos entre módulos

Definición clara de contratos de mensaje

Desacoplamiento con middlewares ligeros

Control de errores centralizado

Integración con supervisores (`systemd`, `pm2`)

Mantenimiento de nodos en caliente

Checklist de calidad de implementación

Diseño de arquitectura para ingestión masiva

3 productores -> broker -> 5 workers + persistencia

Uso de PUSH/PULL y DEALER/ROUTER

Gestión de balanceo y recuperación

Cifrado de canal entre nodos

Monitorización y logging centralizado

Retención de tareas no completadas

Exposición vía API REST

Stress testing y validación

Documentación completa del sistema