Implementierung eines skalierbaren Forex-WebSocket mithilfe eines Python-Proxys

Diese Anleitung zeigt Ihnen, wie Sie einen WebSocket-Proxyserver in Python erstellen.

Folgendes wird der Server tun:

• Client-Identität überprüfen: Bevor Clients eine Verbindung herstellen können, wird geprüft, ob jeder über einen eindeutigen „Benutzerschlüssel (API-Schlüssel)“ verfügt.
• Mit einem anderen WebSocket verbinden:Der Server stellt eine Verbindung zu einem separaten WebSocket-Server her.
• Nachrichten weiterleiten: Der Server empfängt Nachrichten vom verbundenen WebSocket und sendet sie an alle verifizierten Clients.

Bevor Sie beginnen:

• Stellen Sie sicher, dass Sie Python 3.6 oder eine neuere Version installiert haben. WebSockets benötigen Python 3.6 oder höher.
• Installieren Sie die WebSockets-Bibliothek: Sie können sie mit dem folgenden Befehl in Ihrem Terminal installieren.

pip install websockets

1. Erste Schritte

• Erstellen Sie einen neuen Ordner für Ihr Projekt.
• Erstellen Sie eine neue Python-Datei im Ordner und nennen Sie sie „websocket_proxy_server.py“. Diese Datei enthält den gesamten Code für Ihren Server.

2. Erstellen Sie den WebSocket-Server

• Importieren Sie die erforderlichen Bibliotheken. Sie benötigen die Bibliotheken, die Sie zuvor installiert haben.
• Erstellen Sie die Grundstruktur Ihres Servers. Verwenden Sie die WebSockets-Bibliothek, um die Grundlage für Ihren Server zu schaffen.

import asyncio
import websockets
import json

class WebSocketProxy:

    def init(self, source_url, symbols):

        self.source_url = source_url
        self.clients = set()
        self.symbols = symbols
        self.valid_user_key = "yourValidUserKey"  # Single valid user key for authentication

    async def on_open(self, ws):

        print("Connected to source")
        symbols_str = ",".join(self.symbols.keys())
        init_message = f"{{"userKey":"your_api_key", "symbol":"{symbols_str}"}}"
        await ws.send(init_message)

3. Clients verbinden und überprüfen

• Stellen Sie sicher, dass der Server so eingestellt ist, dass er Verbindungen von Clients akzeptiert.
• Fügen Sie einen Scheck hinzu, um die Identität jedes Kunden zu überprüfen. Wenn ein Client versucht, eine Verbindung herzustellen, sollte der Server nach einem „Benutzerschlüssel“ fragen. Nur Clients mit dem richtigen Schlüssel dürfen eine Verbindung herstellen.

async def client_handler(self, websocket, path):

        try:

            # Wait for a message that should contain the authentication key
            auth_message = await asyncio.wait_for(websocket.recv(), timeout=10)
            auth_data = json.loads(auth_message)
            user_key = auth_data.get("userKey")

            if user_key == self.valid_user_key:
                self.clients.add(websocket)
                print(f"Client authenticated with key: {user_key}")

                try:
                    await websocket.wait_closed()

                finally:
                    self.clients.remove(websocket)

            else:

                print("Authentication failed")
                await websocket.close(reason="Authentication failed")
        except (asyncio.TimeoutError, json.JSONDecodeError, KeyError):
            print("Failed to authenticate")
            await websocket.close(reason="Failed to authenticate")

4. Stellen Sie eine Verbindung zur Quelle her und teilen Sie Nachrichten

• Erstellen Sie eine Funktion, die den Server mit dem ursprünglichen WebSocket verbunden hält.
• Diese Funktion sollte vom ursprünglichen WebSocket empfangene Nachrichten automatisch an alle erfolgreich verifizierten Clients senden.

async def source_handler(self):
        async with websockets.connect(self.source_url) as websocket:
            await self.on_open(websocket)
            async for message in websocket:
                await self.broadcast(message)

    async def broadcast(self, message):
        if self.clients:
            await asyncio.gather(*(client.send(message) for client in self.clients))

5. Starten Sie den Server

• Erstellen Sie eine Funktion, um den Server zu starten und auf Verbindungen zu warten.
• Fügen Sie Code hinzu, um diese Funktion auszuführen und Ihren WebSocket-Proxyserver zu starten.

def run(self, host="localhost", port=8765):
        start_server = websockets.serve(self.client_handler, host, port)
        asyncio.get_event_loop().run_until_complete(start_server)
        asyncio.get_event_loop().run_until_complete(self.source_handler())
        asyncio.get_event_loop().run_forever()

if name == "main":
    symbols = {"EURUSD": {}, "GBPUSD": {}, "USDJPY": {}, "AUDUSD": {}, "USDCAD": {}}
    source_url = "ws://example.com/source"
    proxy = WebSocketProxy(source_url, symbols)
    proxy.run()

Zusammenfassend

Sie haben erfolgreich einen Python-basierten WebSocket-Proxyserver entwickelt. Dieser Server kann Client-Identitäten authentifizieren, eine dauerhafte Verbindung zu einer bestimmten Datenquelle aufrechterhalten und von der Quelle empfangene Nachrichten effektiv an alle verifizierten Clients verteilen. Diese Funktionalität erweist sich als unschätzbar wertvoll für Anwendungen, die die sichere und sofortige Verbreitung von Daten von einem einzigen Ursprung an eine vielfältige Benutzerbasis erfordern.

Nächste Schritte

Gründliche Servertests sind entscheidend, um optimale Leistung und Zuverlässigkeit sicherzustellen. Es überprüft die ordnungsgemäße Handhabung von Verbindungen und Nachrichtenübertragungen. Um die Effizienz zu steigern, sollten Sie Lastausgleichsmechanismen implementieren und Verbindungsheader anpassen. Schließlich empfiehlt es sich, den Server in einer geeigneten Umgebung für den Produktionseinsatz bereitzustellen, beispielsweise einem Cloud-Dienst, der speziell für langfristige Netzwerkverbindungen entwickelt wurde.

Schauen Sie sich auch das ursprünglich veröffentlichte Tutorial auf unserer Website an: Scaling a Forex WebSocket with Python Proxy

Das obige ist der detaillierte Inhalt vonImplementierung eines skalierbaren Forex-WebSocket mithilfe eines Python-Proxys. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!