Skip to content
Building REST API Microservices

Web Sockets

1. Introduction

WebSockets are a communication protocol that provides full-duplex, bidirectional communication channels over a single, long-lived TCP connection. Unlike the traditional request-response model of REST APIs, WebSockets allow servers and clients to send messages to each other independently and simultaneously, making them ideal for real-time, interactive applications. WebSockets are commonly used in chat applications, online gaming, financial trading platforms, and other scenarios where low latency and continuous data exchange are critical. This chapter explores WebSockets, their benefits, use cases, and best practices for implementing them alongside REST APIs.

2. What are WebSockets?

WebSockets are a protocol standardized by the IETF (Internet Engineering Task Force) that enables persistent connections between a client and a server. This protocol allows for low-latency, real-time communication without the need for repeated HTTP requests. WebSockets operate on top of TCP, initiating a connection via an HTTP handshake and then upgrading the protocol to WebSocket, maintaining an open connection for continuous data exchange.

How WebSockets Work:

  1. Handshake: The client initiates a connection with the server by sending an HTTP request with the Upgrade: websocket header.
  2. Protocol Upgrade: The server responds with a 101 Switching Protocols status code, upgrading the connection to WebSocket.
  3. Persistent Connection: Once established, the WebSocket connection remains open, allowing both the client and server to send and receive messages independently.
  4. Message Exchange: Data is exchanged as frames, which can be text or binary, enabling the efficient transfer of information.

3. Use Cases for WebSockets

  1. Real-Time Chat Applications

    • WebSockets are ideal for real-time chat applications where users need to send and receive messages instantly. The bidirectional nature of WebSockets ensures that messages are delivered with minimal delay.

    • Example: A chat application where users can send and receive messages instantly without refreshing the page.

  2. Online Gaming

    • Online multiplayer games often require constant communication between the client and server to update game state, player positions, and other dynamic elements. WebSockets provide the low-latency communication needed for a smooth gaming experience.

    • Example: A real-time strategy game where player actions are immediately synchronized across all participants.

  3. Live Financial Trading Platforms

    • Financial trading platforms use WebSockets to deliver live market data, such as stock prices, to clients. This ensures traders receive up-to-the-millisecond updates necessary for making informed trading decisions.

    • Example: A stock trading app that streams live prices and order book updates.

  4. Collaborative Tools

    • Collaborative applications, such as document editors, whiteboards, and project management tools, use WebSockets to synchronize changes among multiple users in real-time.

    • Example: A shared document editor where users see each other’s changes instantly.

  5. Real-Time Notifications

    • WebSockets are commonly used for sending real-time notifications to users, such as alerts, updates, or reminders, without the need for repeated polling.

    • Example: A monitoring dashboard that sends alerts when certain thresholds are crossed.

  6. IoT Devices and Sensor Data

    • WebSockets provide a reliable way for IoT devices to send sensor data to a central server or for remote control applications where commands need to be executed instantly.

    • Example: A home automation system where commands are sent to smart devices with immediate feedback.

4. Implementing WebSockets in REST APIs

  1. Setting Up a WebSocket Server

    Below is an example of setting up a WebSocket server using NodeJS and the ws library, one of the most popular libraries for WebSocket implementation in NodeJS.

    const WebSocket = require("ws");
    const http = require("http");
    

    // Create an HTTP server to handle WebSocket connections
    const server = http.createServer();
    const wss = new WebSocket.Server({ server });
    

    // Handle WebSocket connection events
    wss.on("connection", (ws) => {
      console.log("Client connected");
    

      // Handle incoming messages from the client
      ws.on("message", (message) => {
        console.log("Received:", message);
        // Echo the message back to the client
        ws.send(`Server received: ${message}`);
      });
    

      // Handle WebSocket close event
      ws.on("close", () => {
        console.log("Client disconnected");
      });
    });
    

    // Start the server on port 3000
    server.listen(3000, () => {
      console.log("WebSocket server running on ws://localhost:3000");
    });

    Key Points in the Example:

    • Server Setup: A WebSocket server is created on top of an existing HTTP server to handle WebSocket connections.
    • Connection Handling: When a client connects, the server listens for incoming messages and can respond immediately.
    • Message Exchange: The server echoes incoming messages back to the client, demonstrating bidirectional communication.

  2. Client-Side Implementation

    Clients can connect to the WebSocket server using JavaScript’s native WebSocket API, which provides an easy way to establish and manage WebSocket connections.

    // Create a new WebSocket connection to the server
    const socket = new WebSocket("ws://localhost:3000");
    

    // Handle connection open event
    socket.onopen = () => {
      console.log("Connected to the WebSocket server");
      // Send a message to the server
      socket.send("Hello, server!");
    };
    

    // Handle incoming messages from the server
    socket.onmessage = (event) => {
      console.log("Received from server:", event.data);
    };
    

    // Handle connection close event
    socket.onclose = () => {
      console.log("Disconnected from the WebSocket server");
    };
    

    // Handle error event
    socket.onerror = (error) => {
      console.error("WebSocket error:", error);
    };

    Key Points in the Client Example:

    • Bidirectional Communication: The client can send and receive messages independently of any HTTP request-response cycle.
    • Event Handling: The client handles connection open, message, close, and error events, providing a robust communication mechanism.

5. Benefits of Using WebSockets

  1. Full-Duplex Communication

    • WebSockets allow both the client and server to send messages at any time, enabling real-time, interactive communication that is not constrained by the traditional request-response model.

  2. Low Latency

    • WebSockets provide a low-latency communication channel, as messages are sent directly over the established connection without the overhead of HTTP headers and handshakes for every message.

  3. Reduced Network Overhead

    • By maintaining a single persistent connection, WebSockets reduce the need for repeated TCP handshakes and HTTP requests, minimizing network traffic and improving performance.

  4. Scalability for Real-Time Applications

    • WebSockets are highly scalable, making them suitable for applications that require continuous updates to a large number of clients, such as live sports scores or real-time collaboration tools.

  5. Efficient Resource Use

    • WebSockets make efficient use of server and client resources by maintaining a single connection for all communication, reducing CPU and memory usage compared to repeated HTTP requests.

6. Best Practices for Using WebSockets

  1. Secure the Connection: Always use WebSockets over SSL/TLS (wss://) to encrypt the data and protect against man-in-the-middle attacks.

  2. Implement Heartbeat Messages: Use ping-pong messages between the client and server to keep the connection alive and detect disconnections promptly.

  3. Handle Reconnection Gracefully: Implement reconnection logic on the client side to automatically attempt to reconnect if the connection is lost.

  4. Manage Connection Limits: Be mindful of the number of simultaneous WebSocket connections allowed by your server and ensure resources are managed appropriately.

  5. Monitor and Log WebSocket Traffic: Use monitoring tools to track WebSocket traffic, message rates, and connection status to ensure the service is running efficiently.

  6. Use WebSockets for Real-Time Data Only: While WebSockets are powerful, they should be used primarily for real-time communication. For standard RESTful operations, continue using traditional HTTP methods.

  7. Optimize Message Size: Minimize the size of messages sent over WebSockets to reduce latency and improve performance, especially in environments with limited bandwidth.

7. Conclusion

WebSockets provide a powerful, low-latency communication channel that is ideal for real-time, interactive applications. By enabling full-duplex communication over a persistent connection, WebSockets allow developers to create dynamic user experiences that go beyond the capabilities of traditional REST APIs. Implementing WebSockets alongside REST can enhance the responsiveness and interactivity of applications, making them well-suited for the demands of modern web and mobile environments.