Implémentation d'un WebSocket Forex évolutif à l'aide d'un proxy Python

Ce guide vous apprendra comment créer un serveur proxy WebSocket en Python.

Voici ce que fera le serveur :

• Vérifier l'identité du client : Avant d'autoriser les clients à se connecter, il vérifiera si chacun possède une "clé utilisateur (clé API)" unique.
• Connectez-vous à un autre WebSocket : Le serveur se connectera à un serveur WebSocket distinct.
• Messages relais : Le serveur recevra les messages du WebSocket connecté et les enverra à tous les clients vérifiés.

Avant de commencer :

• Assurez-vous d'avoir installé Python 3.6 ou une version plus récente. Les WebSockets nécessitent Python 3.6 ou supérieur.
• Installez la bibliothèque WebSockets : Vous pouvez l'installer à l'aide de la commande suivante dans votre terminal.

pip install websockets

1. Pour commencer

• Créez un nouveau dossier pour votre projet.
• Créez un nouveau fichier Python dans le dossier et nommez-le « websocket_proxy_server.py ». Ce fichier contiendra tout le code de votre serveur.

2. Créez le serveur WebSocket

• Importez les bibliothèques requises. Vous aurez besoin des bibliothèques que vous avez installées précédemment.
• Construisez la structure de base de votre serveur. Utilisez la bibliothèque WebSockets pour créer la base de votre serveur.

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. Connectez et vérifiez les clients

• Assurez-vous que le serveur est configuré pour accepter les connexions des clients.
• Ajoutez un chèque pour vérifier l'identité de chaque client. Lorsqu'un client tente de se connecter, le serveur doit demander une « clé utilisateur ». Seuls les clients disposant de la bonne clé seront autorisés à se connecter.

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. Connectez-vous à la source et partagez des messages

• Créez une fonction qui maintient le serveur connecté au WebSocket d'origine.
• Cette fonction devrait envoyer automatiquement les messages reçus du WebSocket d'origine à tous les clients vérifiés avec succès.

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. Démarrez le serveur

• Créez une fonction pour démarrer le serveur et écouter les connexions.
• Ajoutez du code pour exécuter cette fonction, en démarrant votre serveur proxy WebSocket.

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

En résumé

Vous avez développé avec succès un serveur proxy WebSocket basé sur Python. Ce serveur peut authentifier les identités des clients, maintenir une connexion persistante à une source de données désignée et distribuer efficacement les messages reçus de la source à tous les clients vérifiés. Cette fonctionnalité s'avère inestimable pour les applications qui nécessitent la diffusion sécurisée et instantanée de données d'une origine unique vers une base d'utilisateurs diversifiée.

Prochaines étapes

Des tests approfondis du serveur sont essentiels pour garantir des performances et une fiabilité optimales. Il vérifie sa bonne gestion des connexions et de la transmission des messages. Pour améliorer l'efficacité, envisagez de mettre en œuvre des mécanismes d'équilibrage de charge et de personnaliser les en-têtes de connexion. Enfin, il est conseillé de déployer le serveur dans un environnement adapté au déploiement en production, tel qu'un service cloud spécialement conçu pour accueillir des connexions réseau à long terme.

Veuillez également jeter un œil au didacticiel initialement publié sur notre site Web : Mise à l'échelle d'un WebSocket Forex avec un proxy Python

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!