Comparación de 8 tecnologías de comunicación web en Python — Guía por caso de uso

Al construir servicios web o APIs en Python, elegir la tecnología de comunicación adecuada es una de las decisiones de diseño más fundamentales. REST, WebSocket, gRPC, MQTT — probablemente has oído hablar de todas, pero saber cuál se adapta a tu proyecto puede ser sorprendentemente difícil.

Este artículo compara 8 tecnologías de comunicación utilizadas habitualmente en Python, organizadas por caso de uso, dificultad, velocidad y capacidad en tiempo real, con ejemplos de código prácticos y orientación sobre cuándo elegir cada una.

Resumen comparativo

El punto clave: no elijas una tecnología porque sea «rápida» o «moderna». Elige la que se adapte a los requisitos de tu proyecto. El 90% de los proyectos funcionan perfectamente solo con REST, y siempre puedes añadir WebSocket o Celery más tarde.

REST — El estándar de las API web

REST (Representational State Transfer) utiliza métodos HTTP (GET / POST / PUT / DELETE) para operar sobre recursos. Es el estilo de diseño de API más ampliamente adoptado, y la regla práctica es simple: en caso de duda, usa REST.

En Python, FastAPI se ha convertido en el estándar de facto. Ofrece validación basada en type hints, documentación automática (Swagger UI) y soporte asíncrono.

from fastapi import FastAPI

app = FastAPI()

@app.get("/users/{user_id}")
def get_user(user_id: int):
    return {"user_id": user_id, "name": "Alice"}

# GET /users/1 → {"user_id": 1, "name": "Alice"}

Cuándo usar:

• APIs web públicas o internas
• Operaciones CRUD
• Backends de paneles de administración
• Lógica del lado servidor para apps móviles

pip install fastapi uvicorn

WebSocket — Comunicación bidireccional en tiempo real

WebSocket establece un canal de comunicación persistente y bidireccional entre cliente y servidor. A diferencia de HTTP, una vez conectados, ambos lados pueden enviar datos libremente.

FastAPI soporta WebSocket de forma nativa, por lo que puedes añadir endpoints en tiempo real junto a tu API REST en el mismo proyecto.

from fastapi import FastAPI, WebSocket

app = FastAPI()

@app.websocket("/ws")
async def websocket_endpoint(ws: WebSocket):
    await ws.accept()
    while True:
        data = await ws.receive_text()
        await ws.send_text(f"Echo: {data}")

Cuándo usar:

• Aplicaciones de chat
• Dashboards en tiempo real
• Sincronización de estado de juegos online
• Edición colaborativa

pip install fastapi uvicorn

gRPC — Comunicación de alta velocidad entre microservicios

gRPC es un framework RPC desarrollado por Google. Utiliza Protocol Buffers (protobuf) para la serialización de datos, resultando en payloads más pequeños y procesamiento más rápido que REST basado en JSON.

Defines las interfaces de servicio en archivos .proto, y luego se genera automáticamente el código de cliente y servidor. Esto garantiza seguridad de tipos.

# Using a client generated from greeter.proto
import grpc
import greeter_pb2
import greeter_pb2_grpc

channel = grpc.insecure_channel('localhost:50051')
stub = greeter_pb2_grpc.GreeterStub(channel)
response = stub.SayHello(greeter_pb2.HelloRequest(name='World'))
print(response.message)  # Hello, World!

Cuándo usar:

• Comunicación interna entre microservicios
• Sistemas de alta carga sensibles a latencia
• Entornos multi-lenguaje (Python ↔ Go ↔ Java)
• Escenarios de comunicación streaming

pip install grpcio grpcio-tools

MQTT — Protocolo ligero para IoT

MQTT es un protocolo de mensajería Pub/Sub ultraligero diseñado para entornos con ancho de banda limitado. Funciona sobre TCP, con un header que puede ser tan pequeño como 2 bytes.

Los mensajes fluyen a través de un servidor «broker»: los publicadores envían mensajes a temas, y los suscriptores los reciben.

import paho.mqtt.client as mqtt

def on_connect(client, userdata, flags, rc):
    print(f"Connected (rc={rc})")
    client.subscribe("sensor/temperature")

def on_message(client, userdata, msg):
    print(f"{msg.topic}: {msg.payload.decode()}")

client = mqtt.Client()
client.on_connect = on_connect
client.on_message = on_message
client.connect("broker.hivemq.com", 1883)
client.loop_forever()

Cuándo usar:

• Recolección de datos de sensores IoT
• Control remoto de robots
• Coordinación de dispositivos smart home
• Monitoreo de equipos industriales

pip install paho-mqtt

SSE — Push unidireccional del servidor

SSE (Server-Sent Events) proporciona comunicación en tiempo real unidireccional del servidor al cliente. Funciona sobre HTTP estándar, con mejor compatibilidad con proxies y firewalls que WebSocket.

Es ideal para escenarios donde el servidor envía actualizaciones continuamente — streaming de logs, feeds de notificaciones, indicadores de progreso.

from fastapi import FastAPI
from fastapi.responses import StreamingResponse
import asyncio

app = FastAPI()

async def event_generator():
    for i in range(10):
        yield f"data: Event {i}

"
        await asyncio.sleep(1)

@app.get("/stream")
async def stream():
    return StreamingResponse(
        event_generator(),
        media_type="text/event-stream"
    )

Cuándo usar:

• Feeds de notificaciones
• Visualización de logs en tiempo real
• Barras de progreso para operaciones largas
• Respuestas streaming de IA (estilo ChatGPT)

pip install fastapi uvicorn

Celery — Cola de tareas en segundo plano

Celery es un sistema de cola de tareas para ejecución asíncrona en segundo plano de operaciones pesadas. Celery descarga estas tareas para que la petición retorne inmediatamente.

Utiliza un broker de mensajes (Redis o RabbitMQ) para encolar y distribuir tareas entre procesos worker.

from celery import Celery

app = Celery('tasks', broker='redis://localhost:6379/0')

@app.task
def send_welcome_email(user_id: int):
    # Heavy operation (email, external API call, etc.)
    print(f"Sending email to user {user_id}")
    return True

# Caller: send_welcome_email.delay(42)

Cuándo usar:

• Envío asíncrono de emails / notificaciones
• Procesamiento de imágenes y video
• Tareas batch programadas (celery beat)
• Generación de reportes, exportación de datos

pip install celery redis

requests — El cliente HTTP más simple

requests es la librería de referencia para hacer llamadas HTTP en Python. Ya sea para consumir APIs externas, hacer web scraping o probar endpoints, es típicamente la primera opción.

Su mayor fortaleza es la simplicidad absoluta. Un GET HTTP completo se hace en solo 3 líneas.

import requests

response = requests.get("https://api.github.com/users/python")
print(response.status_code)  # 200
print(response.json()["name"])  # Python

Cuándo usar:

• Consumo de APIs REST externas
• HTTP para web scraping
• Tests de API durante desarrollo
• Herramientas CLI con peticiones HTTP

pip install requests

aiohttp — Cliente HTTP asíncrono

aiohttp es una librería cliente/servidor HTTP asíncrona basada en asyncio. Piensa en ella como la versión async de requests. Puede enviar grandes cantidades de peticiones HTTP concurrentemente.

import aiohttp
import asyncio

async def fetch(url: str) -> int:
    async with aiohttp.ClientSession() as session:
        async with session.get(url) as response:
            return response.status

async def main():
    urls = ["https://api.github.com"] * 10
    tasks = [fetch(url) for url in urls]
    results = await asyncio.gather(*tasks)
    print(results)  # [200, 200, 200, ...]

asyncio.run(main())

Cuándo usar:

• Alto volumen de llamadas API externas
• Web crawlers y scrapers
• Proyectos que ya usan asyncio
• Construcción de servidores web async

pip install aiohttp

Guía de selección + patrones de arquitectura

Tras revisar las 8 tecnologías, recuerda que en la práctica rara vez usas solo una — las combinas. Estos son patrones de arquitectura probados organizados por escala.

Errores comunes de principiantes:

• Construir todo con WebSocket — Las partes sin necesidad de tiempo real pierden caché y son más difíciles de depurar
• Empezar con gRPC — Para proyectos pequeños, REST es más que suficiente
• Usar aiohttp sin entender async — Si requests no causa problemas, no fuerces la migración
• Sobre-introducir Celery — Para pocas tareas, BackgroundTasks de FastAPI basta

El denominador común es sobre-ingeniería del stack tecnológico. Empieza simple y añade complejidad solo cuando los requisitos lo exijan.

Resumen

Las tecnologías de comunicación web en Python son fáciles de elegir cuando conoces tu caso de uso.

• APIs en general → REST (FastAPI)
• Bidireccional en tiempo real → WebSocket
• Alta velocidad interna → gRPC
• IoT / Sensores → MQTT
• Push del servidor → SSE
• Procesamiento en segundo plano → Celery
• Cliente HTTP (síncrono) → requests
• Cliente HTTP (asíncrono) → aiohttp

En caso de duda, empieza con REST. La mayoría de los proyectos arrancan perfectamente solo con REST, y añadir WebSocket o Celery después no es difícil. En la selección tecnológica, «añadir cuando lo necesites» es la mentalidad correcta.