WebSockets mit Python verstehen

Einführung

In der heutigen digitalen Landschaft, in der Echtzeitkommunikation wichtig ist. Herkömmliches HTTP ist aufgrund seines Anfrage-Antwort-Modells und der inhärenten Latenz unzureichend. Da Unternehmen und Anwendungen zunehmend eine sofortige Datenübertragung fordern – sei es bei Live-Aktualisierungen von Aktien, Multiplayer-Spielen oder Tools für die Zusammenarbeit – haben sich WebSockets zu einer bahnbrechenden Technologie entwickelt. Im Gegensatz zu HTTP ermöglichen WebSockets eine bidirektionale Vollduplex-Kommunikation, sodass sowohl der Server als auch der Client Nachrichten in Echtzeit über eine einzige, dauerhafte Verbindung senden und empfangen können. Dies reduziert nicht nur den Overhead, sondern verbessert auch die Leistung und Reaktionsfähigkeit von Webanwendungen erheblich.

Was ist WebSocket

WebSocket ist ein Kommunikationsprotokoll, das Vollduplex-Kommunikationskanäle über eine einzige, langlebige TCP-Verbindung bereitstellt. Dies bedeutet, dass, sobald eine WebSocket-Verbindung zwischen einem Client und einem Server hergestellt ist, beide Parteien gleichzeitig und kontinuierlich Daten senden und empfangen können, ohne dass eine Verbindung erneut geöffnet werden muss. WebSocket wurde so konzipiert, dass es effizient und mit geringer Latenz ist und sich daher ideal für Echtzeitanwendungen eignet.

Warum WebSocket?

WebSockets werden in Szenarien verwendet, in denen Echtzeitkommunikation zwischen einem Client und einem Server erforderlich ist. Im Gegensatz zu herkömmlichem HTTP, das einem Anfrage-Antwort-Modell folgt, bei dem der Client jede Anfrage initiieren muss, ermöglichen WebSockets eine bidirektionale Kommunikation. Dies macht WebSockets besonders nützlich in Anwendungen, bei denen Daten in Echtzeit vom Server an den Client übertragen werden müssen, ohne dass der Client dies anfordern muss.

Anwendungsfälle aus der Praxis

• Chat-Anwendungen: WebSockets werden häufig in Chat-Anwendungen verwendet, bei denen Nachrichten ohne Verzögerung in Echtzeit gesendet und empfangen werden müssen.
• Live-Streaming: WebSockets können zum Streamen von Live-Video oder -Audio verwendet werden, sodass der Server neue Inhalte an den Client senden kann, sobald diese verfügbar sind.
• Kollaborative Plattformen: In kollaborativen Tools wie Google Docs ermöglichen WebSockets mehreren Benutzern, von anderen vorgenommene Änderungen in Echtzeit zu sehen, ohne dass die Seite aktualisiert werden muss.

WebSockets vs. HTTP

Kommunikationsmodell

• HTTP: Folgt einem Anfrage-Antwort-Modell, bei dem der Client eine Anfrage initiiert und der Server antwortet. Nach der Antwort wird die Verbindung geschlossen.
• WebSockets: WebSockets bieten eine langlebige Vollduplex-Verbindung, bei der sowohl der Client als auch der Server kontinuierlich Daten senden und empfangen können, ohne die Verbindung jedes Mal neu öffnen zu müssen.

Verbindungsverwaltung

• HTTP: Jede Anfrage öffnet eine neue Verbindung und die Verbindung wird nach der Antwort geschlossen.
• WebSockets: Nach dem ersten Handshake (über HTTP) bleibt die Verbindung offen und ermöglicht so eine Kommunikation in Echtzeit, ohne dass Verbindungen erneut hergestellt werden müssen.

Effizienz

• HTTP: Geeignet für einmalige Kommunikation oder Transaktionen, bei denen selten Anfragen gestellt werden. Es ist zustandslos, daher werden für die kontinuierliche Kommunikation Techniken wie Long-Polling verwendet, die ressourcenintensiv sein können.
• WebSockets: WebSockets sind effizient für Echtzeit- und bidirektionale Kommunikation, da die Verbindung offen gehalten wird. Sie verbrauchen weniger Ressourcen im Vergleich zu Techniken wie Long-Polling.

Latenz

• HTTP: Es gibt immer eine Verzögerung (Latenz), da der Client eine Anfrage stellen und der Server antworten muss. Dies ist für Echtzeit-Anwendungsfälle ineffizient.
• WebSockets: Nachdem die Verbindung hergestellt wurde, können Daten fast sofort zwischen Client und Server fließen, was die Latenz reduziert und es ideal für Echtzeitanwendungen macht.

Anwendungsfall

• HTTP: Am besten geeignet für herkömmliche Webanwendungen, bei denen Anforderungen vom Client initiiert werden (z. B. REST-APIs).
• WebSockets: Ideal für Echtzeitanwendungen wie Chat-Apps, Aktienhandelsplattformen, Live-Dashboards und Online-Spiele.

Vorteile von WebSockets

1. Echtzeitkommunikation: WebSockets ermöglichen Echtzeitkommunikation mit geringer Latenz und eignen sich daher ideal für Anwendungen, die sofortige Updates benötigen.
2. Bidirektionaler Datenfluss: Sowohl Client als auch Server können jederzeit Daten senden und empfangen, im Gegensatz zu HTTP, wo der Server nur auf vom Client initiierte Anfragen antworten kann.
3. Reduzierter Overhead: Indem die Verbindung offen gehalten wird, reduzieren WebSockets die Notwendigkeit, wiederholt neue HTTP-Verbindungen herzustellen, wodurch Bandbreite gespart und die Latenz reduziert wird.
4. Effizienz: WebSockets verbrauchen im Vergleich zu Long-Polling- oder HTTP-Anfragen weniger Ressourcen für eine kontinuierliche Datenübertragung.
5. Skalierbarkeit: WebSockets können viele gleichzeitige Verbindungen effizient verarbeiten und eignen sich daher für skalierbare Echtzeitanwendungen.

Wie WebSockets funktionieren

1. Handshake: Eine WebSocket-Verbindung beginnt mit einem HTTP-Handshake. Der Client sendet eine Anfrage mit einem Upgrade-Header an den Server, um das Verbindungsprotokoll von HTTP auf WebSocket umzustellen.
2. Verbindung hergestellt: Nach dem Handshake wird die Verbindung hergestellt. Der Server und der Client unterhalten eine dauerhafte, offene TCP-Verbindung.
3. Vollduplex-Kommunikation: Sobald die WebSocket-Verbindung geöffnet ist, können Daten gleichzeitig hin und her gesendet werden. Sowohl der Server als auch der Client können jederzeit eine Kommunikation einleiten.
4. Verbindung schließen: Entweder der Server oder der Client können die Verbindung schließen, wenn sie nicht mehr benötigt wird. Dadurch wird die Sitzung beendet und die Ressourcen freigegeben.

Anwendungsfälle für WebSockets

1. Chat-Anwendungen: Instant-Messaging-Dienste wie WhatsApp und Slack nutzen WebSockets für Echtzeit-Messaging zwischen Benutzern.
2. Live-Updates: WebSockets ermöglichen Echtzeit-Datenaktualisierungen in Anwendungen wie Finanzhandelsplattformen (Aktienkurse), Sportergebnissen oder Live-Newsfeeds.
3. Kollaborative Tools: WebSockets ermöglichen Echtzeitaktualisierungen in kollaborativen Tools wie Google Docs oder Figma, bei denen mehrere Benutzer gleichzeitig ein Dokument bearbeiten können.
4. Online-Gaming: Multiplayer-Spiele basieren auf WebSockets für Spieleraktionen und -interaktionen in Echtzeit.
5. IoT- und Sensordaten: Geräte mit Echtzeit-Datenstreaming (z. B. IoT-Geräte, Wettersensoren) verwenden WebSockets, um kontinuierliche Updates zu senden.

Echtzeitanwendungen mit Python und WebSockets erstellen

Lassen Sie uns eine Echtzeitanwendung mit WebSockets mit Python (mit FastAPI) und Streamlit erstellen.

1. Richten Sie den FastAPI WebSocket-Server ein

Dieser Code richtet einen WebSocket-Server mithilfe von FastAPI ein.

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)

Dieser WebSocket-Server kann mehrere Verbindungen verarbeiten und Nachrichten an alle verbundenen Clients senden.

2. Streamlit-Frontend

Jetzt erstellen wir mit Streamlit eine Echtzeitanwendung, die eine Verbindung zum WebSocket-Server herstellt und Live-Updates empfängt.

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

Erklärung: Wenn der Benutzer auf die Schaltfläche „Mit WebSocket verbinden“ klickt, stellt das Streamlit-Frontend eine Verbindung mit dem WebSocket-Server her und wartet auf Nachrichten.

3. Ausführen der Anwendung

Führen Sie den FastAPI-Server aus:

uvicorn server:app --reload

Führen Sie die Streamlit-App aus:

streamlit run your_script.py

Wichtige Schritte in der Echtzeitkommunikation:

• WebSocket-Setup: Der WebSocket-Server läuft und akzeptiert Verbindungen.
• Streamlit-Verbindung: Das Streamlit-Frontend initiiert eine Verbindung zum WebSocket-Server.
• Vollduplex-Kommunikation: Sowohl Client (Streamlit) als auch Server (FastAPI) können Nachrichten in Echtzeit senden/empfangen.

Das obige ist der detaillierte Inhalt vonWebSockets mit Python verstehen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!