Web Sockets

Imagine you're in a conversation with a friend. You don't want to hang up the phone and call them again every time you want to say something new. Instead, you stay on the line and chat back and forth in real-time. That's pretty much how WebSockets work in the world of the internet. This article will explain WebSockets in simple terms, so you can understand what they are, how they work, and why they’re useful.

What are WebSockets?

WebSockets are a way for your web browser and a server to communicate with each other in real-time, without the delay of constantly opening and closing connections. Unlike the usual method where your browser makes a request and waits for the server to reply, WebSockets allow both sides to send messages whenever they want. This makes it possible to have instant updates, just like chatting with a friend on the phone.

How Do WebSockets Work?

Handshake:

• It all starts with a handshake. Your browser sends a request to the server, saying, "Let’s switch to WebSockets." If the server agrees, it replies with a "Yes, let’s do it!" message. After this, they switch from the usual web protocol (HTTP) to WebSockets.

Open Connection:

• Now, the connection is open and stays open. This is called a "persistent" or "long-lived" connection, meaning it doesn’t close after each message. Your browser and the server can now send messages to each other whenever they want, without any delay.

Message Exchange:

• Both the browser and the server can send and receive messages in real-time. This is called "full-duplex communication," meaning data can flow both ways simultaneously.

Closing the Connection:

• When either side is done, they can close the connection. This is like hanging up the phone when you’re finished talking.

Why Use WebSockets?

WebSockets are really useful for situations where you need real-time communication. Here are some examples:

• Chat Apps: When you’re chatting online, you want your messages to be sent and received instantly. WebSockets make this possible.
• Live Updates: Websites that show live scores for sports or stock prices can use WebSockets to update the information without you having to refresh the page.
• Online Games: In multiplayer games, WebSockets allow the game to update for all players in real-time, making the experience smooth and responsive.

WebSockets are a powerful technology for enabling real-time, bi-directional communication between a client and a server. but, implementing and scaling WebSockets comes with several challenges:

1. Scalability

• High Connection Volume:
  • WebSockets maintain a persistent connection, which can lead to a large number of concurrent open connections. Managing millions of simultaneous connections can strain server resources (memory, CPU, file descriptors).
• Horizontal Scaling:
  • Distributing WebSocket connections across multiple servers is complex. Unlike stateless HTTP requests, WebSocket connections are stateful, meaning they need to maintain a session. Load balancers must handle sticky sessions (session affinity) to ensure that the same client always connects to the same server.
• Server Resource Usage:
  • Each WebSocket connection consumes server resources. As the number of connections grows, the server may run out of memory or file descriptors, especially if not properly tuned or scaled.

2. Connection Management

• Idle Connections:
  • Clients may keep WebSocket connections open even when not actively communicating, leading to resource wastage. Managing idle connections effectively requires implementing timeouts or sending periodic ping/pong frames to detect dead connections.
• Load Balancing:
  • WebSocket connections require special handling in load balancers. Traditional round-robin load balancing is not ideal because WebSocket connections are long-lived. Load balancers must support WebSocket protocols and handle session stickiness properly.

3. Security

• Man-in-the-Middle Attacks:
  • WebSocket connections, if not properly secured with WSS (WebSocket Secure), are vulnerable to man-in-the-middle attacks where an attacker can intercept and manipulate the data being sent between the client and server.
• DDoS Attacks:
  • Because WebSocket connections are persistent, they can be exploited in DDoS (Distributed Denial of Service) attacks, where an attacker overwhelms the server by opening a large number of connections, exhausting its resources.

4. Proxy and Firewall Compatibility

• Proxy and Firewall Issues:
  • Some proxies and firewalls may not properly handle WebSocket traffic, leading to dropped connections or blocked WebSocket communication. This is particularly problematic in enterprise environments where strict network policies are enforced.
• Connection Interruption:
  • Network devices that don’t recognize WebSocket traffic might terminate connections prematurely, causing disruptions in communication.

5. Backward Compatibility

• Browser Support:
  • While modern browsers widely support WebSocket, some older browsers may not. This can require fallback mechanisms, such as long polling or server-sent events, to ensure compatibility.
• Legacy Systems:
  • Integrating WebSockets into existing systems that were not designed for real-time communication can be difficult. Legacy backends may not be optimized for handling the persistent connections and high-frequency updates that WebSockets require.

When Not to Use WebSockets

WebSockets might not be necessary if:

• Simple Data Requests: If your application just needs to request data occasionally, regular HTTP requests might be simpler.
• Low-Frequency Updates: If updates are infrequent, the overhead of maintaining a WebSocket connection might not be worth it.
  

References:

https://gcore.com/learning/what-is-websocket/

https://www.geeksforgeeks.org/what-is-web-socket-and-how-it-is-different-from-the-http/

That's a wrap. Thanks for reading.
Happy Coding🥂