El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Sistemas de Mensajería en Tiempo Real

Siguiente ►
►

En este tema, exploraremos los sistemas de mensajería en tiempo real, que son fundamentales para aplicaciones que requieren comunicación instantánea y continua entre diferentes componentes o usuarios. Estos sistemas son esenciales en aplicaciones como chats en línea, notificaciones en tiempo real, y sistemas de monitoreo.

Conceptos Básicos

¿Qué es la Mensajería en Tiempo Real?

La mensajería en tiempo real se refiere a la transmisión de mensajes entre sistemas o usuarios con una latencia mínima, permitiendo una comunicación casi instantánea. Los sistemas de mensajería en tiempo real son diseñados para manejar grandes volúmenes de mensajes y garantizar la entrega rápida y confiable.

Características Clave

  • Baja Latencia: Los mensajes deben ser entregados casi instantáneamente.
  • Alta Disponibilidad: El sistema debe estar disponible en todo momento.
  • Escalabilidad: Capacidad para manejar un gran número de conexiones y mensajes simultáneamente.
  • Consistencia: Asegurar que los mensajes se entreguen en el orden correcto y sin pérdidas.

Protocolos de Mensajería en Tiempo Real

WebSockets

WebSockets es un protocolo que proporciona comunicación bidireccional entre un cliente y un servidor sobre una única conexión TCP. Es ideal para aplicaciones que requieren actualizaciones en tiempo real.

Ejemplo de WebSocket en JavaScript

// Crear una nueva conexión WebSocket
const socket = new WebSocket('ws://example.com/socket');

// Evento cuando la conexión está abierta
socket.addEventListener('open', function (event) {
    socket.send('Hello Server!');
});

// Evento cuando se recibe un mensaje
socket.addEventListener('message', function (event) {
    console.log('Message from server ', event.data);
});

Explicación:

  1. Se crea una nueva conexión WebSocket a ws://example.com/socket.
  2. Se envía un mensaje "Hello Server!" cuando la conexión está abierta.
  3. Se escucha y se imprime cualquier mensaje recibido del servidor.

MQTT

MQTT (Message Queuing Telemetry Transport) es un protocolo ligero de mensajería diseñado para conexiones con ancho de banda limitado y alta latencia. Es comúnmente utilizado en IoT (Internet de las Cosas).

Ejemplo de MQTT en Python

import paho.mqtt.client as mqtt

# Callback cuando se conecta al broker
def on_connect(client, userdata, flags, rc):
    print("Connected with result code " + str(rc))
    client.subscribe("test/topic")

# Callback cuando se recibe un mensaje
def on_message(client, userdata, msg):
    print(msg.topic + " " + str(msg.payload))

client = mqtt.Client()
client.on_connect = on_connect
client.on_message = on_message

client.connect("mqtt.example.com", 1883, 60)
client.loop_forever()

Explicación:

  1. Se define un callback on_connect que se ejecuta al conectarse al broker y suscribe al cliente a test/topic.
  2. Se define un callback on_message que se ejecuta al recibir un mensaje y lo imprime.
  3. Se crea un cliente MQTT y se asignan los callbacks.
  4. Se conecta al broker MQTT en mqtt.example.com y se inicia el bucle de eventos.

Arquitecturas de Sistemas de Mensajería en Tiempo Real

Publicación/Suscripción (Pub/Sub)

En este modelo, los productores de mensajes (publicadores) envían mensajes a un "topic", y los consumidores (suscriptores) reciben mensajes de los topics a los que están suscritos. Este modelo desacopla a los productores de los consumidores, permitiendo una mayor flexibilidad y escalabilidad.

Ejemplo de Pub/Sub con Redis

import redis

# Publicador
def publisher():
    r = redis.Redis()
    while True:
        message = input("Enter message: ")
        r.publish('channel', message)

# Suscriptor
def subscriber():
    r = redis.Redis()
    pubsub = r.pubsub()
    pubsub.subscribe('channel')
    for message in pubsub.listen():
        print(message['data'])

# Ejecutar en diferentes terminales
# publisher()
# subscriber()

Explicación:

  1. El publicador envía mensajes al canal channel.
  2. El suscriptor escucha mensajes del canal channel y los imprime.

Ejercicios Prácticos

Ejercicio 1: Implementar un Chat en Tiempo Real con WebSockets

Objetivo: Crear una aplicación de chat simple utilizando WebSockets.

Instrucciones:

  1. Configura un servidor WebSocket utilizando una biblioteca como ws en Node.js.
  2. Crea una interfaz de usuario simple en HTML y JavaScript que permita a los usuarios enviar y recibir mensajes.
  3. Asegúrate de que los mensajes se muestren en tiempo real en todos los clientes conectados.

Solución:

// Servidor (Node.js)
const WebSocket = require('ws');
const wss = new WebSocket.Server({ port: 8080 });

wss.on('connection', function connection(ws) {
    ws.on('message', function incoming(message) {
        wss.clients.forEach(function each(client) {
            if (client.readyState === WebSocket.OPEN) {
                client.send(message);
            }
        });
    });
});

// Cliente (HTML + JavaScript)
<!DOCTYPE html>
<html>
<body>
    <input id="message" type="text">
    <button onclick="sendMessage()">Send</button>
    <ul id="messages"></ul>

    <script>
        const socket = new WebSocket('ws://localhost:8080');
        socket.onmessage = function(event) {
            const li = document.createElement('li');
            li.textContent = event.data;
            document.getElementById('messages').appendChild(li);
        };

        function sendMessage() {
            const message = document.getElementById('message').value;
            socket.send(message);
        }
    </script>
</body>
</html>

Explicación:

  1. El servidor WebSocket en Node.js escucha en el puerto 8080 y retransmite cualquier mensaje recibido a todos los clientes conectados.
  2. El cliente HTML permite a los usuarios enviar mensajes y muestra los mensajes recibidos en una lista.

Ejercicio 2: Configurar un Broker MQTT y Publicar/Suscribir Mensajes

Objetivo: Configurar un broker MQTT y crear scripts de publicación y suscripción en Python.

Instrucciones:

  1. Instala un broker MQTT como Mosquitto.
  2. Crea un script en Python para publicar mensajes a un topic.
  3. Crea un script en Python para suscribirse a un topic y recibir mensajes.

Solución:

# Publicador
import paho.mqtt.client as mqtt

client = mqtt.Client()
client.connect("localhost", 1883, 60)
while True:
    message = input("Enter message: ")
    client.publish("test/topic", message)

# Suscriptor
import paho.mqtt.client as mqtt

def on_message(client, userdata, msg):
    print(msg.topic + " " + str(msg.payload))

client = mqtt.Client()
client.on_message = on_message
client.connect("localhost", 1883, 60)
client.subscribe("test/topic")
client.loop_forever()

Explicación:

  1. El publicador envía mensajes al topic test/topic.
  2. El suscriptor escucha mensajes del topic test/topic y los imprime.

Conclusión

En esta sección, hemos explorado los sistemas de mensajería en tiempo real, sus características clave, y los protocolos más utilizados como WebSockets y MQTT. También hemos visto ejemplos prácticos y ejercicios para implementar sistemas de mensajería en tiempo real. Estos conocimientos son fundamentales para desarrollar aplicaciones que requieren comunicación instantánea y eficiente entre diferentes componentes o usuarios.

◄ Anterior
◄
Siguiente ►
►
El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados