Comparaison de 8 technologies de communication web en Python — Guide par cas d’usage

Lorsqu’on développe des services web ou des APIs en Python, le choix de la technologie de communication est l’une des décisions de conception les plus fondamentales. REST, WebSocket, gRPC, MQTT — vous en avez certainement entendu parler, mais savoir laquelle convient à votre projet peut s’avérer étonnamment délicat.

Cet article compare 8 technologies de communication couramment utilisées en Python, organisées par cas d’usage, difficulté, vitesse et capacité temps réel, avec des exemples de code pratiques.

Vue d’ensemble comparative

Le point clé : ne choisissez pas une technologie parce qu’elle est « rapide » ou « tendance ». Choisissez celle qui correspond aux exigences de votre projet. 90% des projets fonctionnent parfaitement avec REST seul.

REST — Le standard des API web

REST (Representational State Transfer) utilise les méthodes HTTP (GET / POST / PUT / DELETE) pour manipuler des ressources. C’est le style de conception d’API le plus répandu : en cas de doute, utilisez REST.

En Python, FastAPI est devenu le standard de facto. Il offre la validation basée sur les type hints, la documentation automatique (Swagger UI) et le support asynchrone.

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"}

Quand l’utiliser :

• APIs web publiques ou internes
• Opérations CRUD
• Backends de panneaux d’administration
• Logique serveur pour apps mobiles

pip install fastapi uvicorn

WebSocket — Communication bidirectionnelle en temps réel

WebSocket établit un canal de communication persistant et bidirectionnel entre client et serveur. Une fois connectés, les deux côtés peuvent envoyer des données librement.

FastAPI supporte nativement WebSocket, vous pouvez donc ajouter des endpoints temps réel à côté de votre API REST.

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}")

Quand l’utiliser :

• Applications de chat
• Tableaux de bord en temps réel
• Synchronisation de jeux en ligne
• Édition collaborative

pip install fastapi uvicorn

gRPC — Communication haute vitesse entre microservices

gRPC est un framework RPC développé par Google. Il utilise Protocol Buffers (protobuf) pour la sérialisation, donnant des payloads plus petits et un traitement plus rapide que REST/JSON.

Les interfaces sont définies dans des fichiers .proto, puis le code client/serveur est généré automatiquement. Cela garantit la sécurité des types.

# 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!

Quand l’utiliser :

• Communication interne entre microservices
• Systèmes haute charge
• Environnements multi-langages
• Communication streaming

pip install grpcio grpcio-tools

MQTT — Protocole léger pour l’IoT

MQTT est un protocole de messagerie Pub/Sub ultra-léger conçu pour les environnements à bande passante limitée. Son en-tête peut être aussi petit que 2 octets.

Les messages transitent par un serveur « broker » : les éditeurs publient sur des topics, les abonnés reçoivent.

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()

Quand l’utiliser :

• Collecte de données IoT
• Contrôle à distance de robots
• Domotique
• Supervision industrielle

pip install paho-mqtt

SSE — Push unidirectionnel du serveur

SSE (Server-Sent Events) fournit une communication temps réel unidirectionnelle du serveur vers le client. Il fonctionne sur HTTP standard, avec meilleure compatibilité proxy/firewall que WebSocket.

Idéal quand le serveur envoie des mises à jour en continu — logs, notifications, barres de progression.

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"
    )

Quand l’utiliser :

• Fils de notifications
• Logs en temps réel
• Barres de progression
• Réponses streaming IA (ChatGPT)

pip install fastapi uvicorn

Celery — File de tâches en arrière-plan

Celery est un système de file de tâches pour l’exécution asynchrone en arrière-plan d’opérations lourdes. Il décharge les tâches pour que la requête retourne immédiatement.

Il utilise un broker de messages (Redis ou RabbitMQ) pour mettre en file d’attente et distribuer les tâches.

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)

Quand l’utiliser :

• Envoi asynchrone d’emails
• Traitement d’images/vidéos
• Tâches batch (celery beat)
• Génération de rapports

pip install celery redis

requests — Le client HTTP le plus simple

requests est la bibliothèque incontournable pour les appels HTTP en Python. Que ce soit pour des APIs externes, du web scraping ou des tests, c’est le premier choix.

Sa plus grande force est la simplicité absolue. Un GET HTTP complet en 3 lignes.

import requests

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

Quand l’utiliser :

• Consommation d’APIs externes
• Web scraping
• Tests d’API
• Outils CLI

pip install requests

aiohttp — Client HTTP asynchrone

aiohttp est une bibliothèque client/serveur HTTP asynchrone basée sur asyncio. Pensez-y comme la version async de requests, capable d’envoyer de grandes quantités de requêtes en parallèle.

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())

Quand l’utiliser :

• Grand volume d’appels API
• Crawlers web
• Projets asyncio existants
• Serveurs web asynchrones

pip install aiohttp

Guide de sélection + modèles d’architecture

Après avoir examiné les 8 technologies, n’oubliez pas qu’en pratique on les combine. Voici des modèles d’architecture éprouvés par échelle.

Erreurs courantes des débutants :

• Tout en WebSocket — Les parties sans besoin temps réel perdent le cache
• Commencer par gRPC — Pour les petits projets, REST suffit
• aiohttp sans comprendre async — Ne forcez pas la migration
• Sur-introduire Celery — BackgroundTasks de FastAPI suffit souvent

Le dénominateur commun ? La sur-ingénierie du stack. Commencez simple, ajoutez de la complexité quand les besoins l’exigent.

Résumé

Les technologies de communication web en Python sont faciles à choisir quand on connaît son cas d’usage.

• APIs en général → REST (FastAPI)
• Bidirectionnel temps réel → WebSocket
• Haute vitesse interne → gRPC
• IoT / Capteurs → MQTT
• Push serveur → SSE
• Traitement en arrière-plan → Celery
• Client HTTP (synchrone) → requests
• Client HTTP (asynchrone) → aiohttp

En cas de doute, commencez par REST. La plupart des projets démarrent très bien avec REST seul, et ajouter WebSocket ou Celery plus tard n’est pas difficile.