标签：#websockets

The Hidden Trap: Why Round-Robin Fails WebSockets In the world of web architecture, the load balancer is the unsung hero. For standard, stateless HTTP traffic, a simple Round-Robin strategy is often the gold standard. It’s predictable, easy to implement, and keeps your server utilization roughly equal. However, when you shift your architecture to support real-time features using WebSockets, the rules of the game change. Defaulting to Round-Robin for WebSocket load balancing is one of the fastest ways to crash your production real-time system. Why the Math Breaks Down To understand the failure, we must look at the fundamental difference between HTTP and WebSockets. HTTP is inherently transactional. A request comes in, the server processes it, sends a response, and the connection is closed. Because these connections are short-lived, Round-Robin successfully distributes the work across your fleet. WebSockets, by contrast, are persistent. A client establishes a handshake once, and that TCP connection can remain open for hours. If you use Round-Robin, you are distributing the handshakes , not the ongoing load . Over time, this leads to a "hot spot" phenomenon. You end up with a small subset of backend nodes holding 90% of the active, heavy connections, while the rest of your fleet sits idle. When those overloaded nodes eventually buckle under the memory pressure or CPU overhead of thousands of active sockets, your system experiences cascading failures. 1. Swap Round-Robin for Least Connections The first step in fixing this imbalance is to change how your proxy makes routing decisions. Instead of blindly rotating handshakes, configure your load balancer to use leastconn (least connections) routing. This strategy forces the load balancer to track the number of active, concurrent connections on each backend node and route new handshakes to the server that is currently the least burdened. Example Nginx Configuration upstream websocket_servers { # Distribute based on active c

Every party game app I'd used before building this one wanted an account, a lobby website, or a subscription. I wanted the opposite: plug a laptop into the TV, run one command, and have everyone's phone connected in under thirty seconds — no internet required once the LAN is up. That constraint ends up dictating almost every architectural decision in GameNight : a Node/Express/Socket.io server that runs five real-time party games — a Mafia-style social deduction game I call Mongolpuri, UNO, a trivia quiz, Scribble, and Tic-Tac-Toe with tournament brackets — entirely from two in-memory Map s, no database, no auth, no build step on the frontend. Decision 1: A room is a plain object, not a schema const rooms = new Map (); // roomCode -> room const playerRooms = new Map (); // socketId -> roomCode const room = { code , gameType , host : socket . id , players : new Map ([[ socket . id , { id : socket . id , name , avatar }]]), status : ' lobby ' , gameState : null , timers : [], settings : defaultSettings ( gameType ), sessionStats : {}, }; Every game's state — the UNO deck, the Killer/Doctor night phase, the Scribble canvas buffer — lives in room.gameState , an untyped bag shaped differently per gameType . There's no ORM, no room class hierarchy, no GameEngine interface every game implements. Each game gets its own set of top-level functions ( startKD , kdResolveNight , startUno , unoPlayCard , …) that read and mutate room.gameState directly, dispatched through one handleAction switch: function handleAction ( room , socket , data ) { const gs = room . gameState ; if ( ! gs ) return ; switch ( room . gameType ) { case ' tictactoe ' : /* ... */ break ; case ' killerdoctor ' : kdAction ( room , socket , data ); break ; case ' scribble ' : scribbleAction ( room , socket , data ); break ; case ' uno ' : unoAction ( room , socket , data ); break ; case ' quiz ' : quizAction ( room , socket , data ); break ; } } For a five-game server built by one person, this is the right amo

Originally published on tamiz.pro . Real-time systems are at the heart of modern interactive applications, from chat platforms to collaborative editing tools and financial dashboards. Delivering a seamless, low-latency experience while ensuring high availability and fault tolerance presents significant architectural challenges. This deep-dive explores how WebSockets, for persistent client-server communication, and Redis, for state management and pub/sub, can be combined with strategic design patterns to build resilient real-time systems. The Core Challenge of Real-Time Resilience The primary challenge in real-time systems is maintaining continuous connectivity and data flow despite inevitable network issues, server failures, or application restarts. A single point of failure can disrupt numerous active user sessions, leading to a poor user experience. Resilience, in this context, means the system's ability to recover gracefully from failures and continue operating, even if in a degraded state. WebSockets: The Foundation for Real-Time Communication WebSockets provide a full-duplex communication channel over a single TCP connection, enabling persistent, low-latency message exchange between client and server. Unlike traditional HTTP requests, WebSockets keep the connection open, eliminating the overhead of connection setup for each message. However, managing a large number of concurrent WebSocket connections and ensuring their availability across a distributed system requires careful design. WebSocket Server Scalability and Load Balancing Directly load balancing WebSocket connections using standard HTTP load balancers can be tricky because WebSockets are long-lived. Sticky sessions are often employed to ensure a client consistently connects to the same backend server. While this works, it can lead to uneven server load and complicates server replacement during failures. A more robust approach involves a dedicated WebSocket gateway layer that can manage connections and

Part: 4 of 18 About this series This series documents the engineering evolution of a production-ready algorithmic trading platform in Python. It focuses on architecture, state management, execution, real-time data processing, persistence, and the engineering decisions that transformed a simple trading bot into a production-ready platform. In Part 3: Building a Production-Ready Position Manager for Algorithmic Trading , I described the component responsible for maintaining persistent position state throughout the entire trade lifecycle. Read Part 3 here: https://dev.to/pydevtop/building-a-production-ready-position-manager-for-algorithmic-trading-55n4 The Position Manager could remember every open position. The next challenge was deciding what should happen to those positions as market conditions continuously changed. Project Website This article is part of the engineering story behind the Bybit Signal Trading Platform . If you'd like to learn more about the project, see additional screenshots, features and technical details, visit: https://py-dev.top/application-software/bybit-signal-trading-bot The Problem Was Never Stop Loss If someone had asked me during the first weeks of development where the Stop Loss logic should live, I wouldn't have hesitated. Inside the Trade Execution Engine. Where else? The engine already received TradingView webhooks. It validated incoming requests. It calculated Take Profit. It opened positions. Adding one more calculation felt completely natural. The implementation looked something like this. signal = receive_signal () validate ( signal ) entry = execute_order ( signal ) stop_loss = calculate_stop_loss ( entry ) take_profit = calculate_take_profit ( entry ) Simple. Readable. Everything related to opening a trade existed in one place. At that moment there was absolutely no reason to introduce another component. There was only one trading pair. Only one open position. No persistence. No restart recovery. No Break Even. No Trailing Stop.