Comprendre les WebSockets à l'aide de Python

Introduction

Dans le paysage numérique d’aujourd’hui, où la communication en temps réel est importante. Le HTTP traditionnel échoue en raison de son modèle requête-réponse et de sa latence inhérente. Alors que les entreprises et les applications exigent de plus en plus un transfert de données instantané, qu'il s'agisse de mises à jour de stock en direct, de jeux multijoueurs ou d'outils collaboratifs, les WebSockets sont devenus une technologie révolutionnaire. Contrairement à HTTP, les WebSockets permettent une communication bidirectionnelle en duplex intégral, permettant au serveur et au client d'envoyer et de recevoir des messages en temps réel via une connexion unique et persistante. Cela réduit non seulement les frais généraux, mais améliore également considérablement les performances et la réactivité des applications Web.

Qu'est-ce que WebSocket

WebSocket est un protocole de communication qui fournit des canaux de communication en duplex intégral sur une seule connexion TCP de longue durée. Cela signifie qu'une fois qu'une connexion WebSocket est établie entre un client et un serveur, les deux parties peuvent envoyer et recevoir des données simultanément et en continu sans avoir besoin de rouvrir une connexion. WebSocket a été conçu pour être efficace et à faible latence, ce qui le rend idéal pour les applications en temps réel.

Pourquoi WebSocket ?

Les WebSockets sont utilisés dans des scénarios où une communication en temps réel entre un client et un serveur est nécessaire. Contrairement au HTTP traditionnel, qui suit un modèle requête-réponse dans lequel le client doit initier chaque requête, les WebSockets permettent une communication bidirectionnelle. Cela rend les WebSockets particulièrement utiles dans les applications où les données doivent être transmises du serveur au client en temps réel sans que le client n'ait à le demander.

Cas d'utilisation réels

• Applications de chat : les WebSockets sont couramment utilisés dans les applications de chat où les messages doivent être envoyés et reçus en temps réel sans délai.
• Diffusion en direct : les WebSockets peuvent être utilisés pour diffuser de la vidéo ou de l'audio en direct, permettant au serveur de transmettre du nouveau contenu au client dès qu'il devient disponible.
• Plateformes collaboratives : dans les outils collaboratifs comme Google Docs, les WebSockets permettent à plusieurs utilisateurs de voir les modifications apportées en temps réel par d'autres sans avoir besoin d'actualiser la page.

WebSockets contre HTTP

Modèle de communication

• HTTP : suit un modèle de demande-réponse dans lequel le client initie une demande et le serveur répond. Après la réponse, la connexion est fermée.
• WebSockets : les WebSockets fournissent une connexion full duplex de longue durée où le client et le serveur peuvent envoyer et recevoir des données en continu sans rouvrir la connexion à chaque fois.

Gestion des connexions

• HTTP : Chaque requête ouvre une nouvelle connexion, et la connexion est fermée après la réponse.
• WebSockets : après la poignée de main initiale (via HTTP), la connexion reste ouverte, permettant une communication en temps réel sans qu'il soit nécessaire de rétablir les connexions.

Efficacité

• HTTP : convient aux communications ponctuelles ou aux transactions où les demandes sont peu fréquentes. Il est apatride, donc pour une communication continue, des techniques telles que les interrogations longues sont utilisées, ce qui peut consommer beaucoup de ressources.
• WebSockets : les WebSockets sont efficaces pour la communication en temps réel et bidirectionnelle puisque la connexion est maintenue ouverte. Ils utilisent moins de ressources par rapport à des techniques telles que les sondages longs.

Latence

• HTTP : Il y a toujours un délai (latence) car le client doit le demander et le serveur doit répondre. Ceci est inefficace pour les cas d’utilisation en temps réel.
• WebSockets : une fois la connexion établie, les données peuvent circuler presque instantanément entre le client et le serveur, ce qui réduit la latence et les rend idéales pour les applications en temps réel.

Cas d'utilisation

• HTTP : idéal pour les applications Web traditionnelles où les requêtes sont initiées par le client (par exemple, les API REST).
• WebSockets : idéal pour les applications en temps réel telles que les applications de chat, les plateformes de négociation d'actions, les tableaux de bord en direct et les jeux en ligne.

Avantages des WebSockets

1. Real-Time Communication: WebSockets allow for real-time, low-latency communication, making them ideal for applications that need instant updates.
2. Bi-Directional Data Flow: Both client and server can send and receive data at any time, unlike HTTP where the server can only respond to client-initiated requests.
3. Reduced Overhead: By keeping the connection open, WebSockets reduce the need to repeatedly establish new HTTP connections, saving bandwidth and reducing latency.
4. Efficiency: WebSockets use fewer resources compared to long-polling or HTTP requests for continuous data transfer.
5. Scalability: WebSockets can handle many concurrent connections efficiently, making them suitable for scalable real-time applications.

How WebSockets Work

1. Handshake: A WebSocket connection starts with an HTTP handshake. The client sends a request to the server with an Upgrade header to switch the connection protocol from HTTP to WebSocket.
2. Connection Established: After the handshake, the connection is established. The server and client maintain a persistent, open TCP connection.
3. Full-Duplex Communication: Once the WebSocket connection is open, data can be sent back and forth simultaneously. Both the server and the client can initiate communication at any time.
4. Close Connection: Either the server or the client can close the connection when it’s no longer needed. This terminates the session and releases the resources.

Use Cases for WebSockets

1. Chat Applications: Instant messaging services like WhatsApp and Slack use WebSockets for real-time messaging between users.
2. Live Updates: WebSockets power real-time data updates in applications such as financial trading platforms (stock prices), sports scores, or live news feeds.
3. Collaborative Tools: WebSockets enable real-time updates in collaborative tools like Google Docs or Figma, where multiple users can edit a document simultaneously.
4. Online Gaming: Multiplayer games rely on WebSockets for real-time player actions and interactions.
5. IoT and Sensor Data: Devices with real-time data streaming (e.g., IoT devices, weather sensors) use WebSockets to send continuous updates.

Building Real-Time Applications with Python and WebSockets

Let’s build a real-time application using WebSockets with Python (using FastAPI) and Streamlit.

1. Set Up FastAPI WebSocket Server

This code sets up a WebSocket server using FastAPI.

from fastapi import FastAPI, WebSocket, WebSocketDisconnect
from typing import List

app = FastAPI()

class ConnectionManager:
    def __init__(self):
        self.active_connections: List[WebSocket] = []

    async def connect(self, websocket: WebSocket):
        await websocket.accept()
        self.active_connections.append(websocket)

    def disconnect(self, websocket: WebSocket):
        self.active_connections.remove(websocket)

    async def broadcast(self, message: str):
        for connection in self.active_connections:
            await connection.send_text(message)

manager = ConnectionManager()

@app.websocket("/ws")
async def websocket_endpoint(websocket: WebSocket):
    await manager.connect(websocket)
    try:
        while True:
            data = await websocket.receive_text()
            await manager.broadcast(f"Message: {data}")
    except WebSocketDisconnect:
        manager.disconnect(websocket)

This WebSocket server can handle multiple connections and broadcast messages to all connected clients.

2. Streamlit Frontend

Now, let’s build a real-time application using Streamlit that connects to the WebSocket server and receives live updates.

import streamlit as st
import asyncio
import websockets

async def websocket_receive():
    uri = "ws://localhost:8000/ws"
    async with websockets.connect(uri) as websocket:
        while True:
            message = await websocket.recv()
            st.write(f"Received: {message}")

st.title("Real-Time WebSocket Client")

if st.button("Connect to WebSocket"):
    st.write("Connected!")
    asyncio.run(websocket_receive())

Explanation: When the user clicks the “Connect to WebSocket” button, the Streamlit frontend establishes a connection with the WebSocket server and listens for messages.

3. Running the Application

Run the FastAPI server:

uvicorn server:app --reload

Run the Streamlit app:

streamlit run your_script.py

Key Steps in Real-Time Communication:

• WebSocket Setup: The WebSocket server runs and accepts connections.
• Streamlit Connection: Streamlit frontend initiates a connection to the WebSocket server.
• Full-Duplex Communication: Both client (Streamlit) and server (FastAPI) can send/receive messages in real-time.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!