Load Balancing Methods with Socket.IO

What is Socket.IO and Why is it Used?

Socket.IO is a powerful and widely used library for developing real-time web applications based on Node.js. This technology, which works on a WebSocket basis, is frequently preferred in applications that require instant data transmission and bi-directional communication (chat applications, live notification systems, etc.). When scalability and performance requirements increase, balancing the load across Socket.IO servers, that is, load balancing, becomes critical for large-scale systems.

How is Load Balancing Done with Socket.IO?

In large-scale Socket.IO applications, directing incoming connections to a single server can lead to scalability and performance problems. Therefore, the load must be distributed among multiple Socket.IO servers. However, since Socket.IO establishes persistent connections between the client and server, it requires additional configuration unlike traditional stateless HTTP load balancers.

As a solution, either a load balancer with the "sticky session" method is used or a scalable architecture is established at the application level. One of the most popular methods is sharing socket information between different servers with a Redis adapter. Here is a sample load balancing scenario:

// app.js
const http = require("http");
const express = require("express");
const socketIo = require("socket.io");
const { createAdapter } = require("@socket.io/redis-adapter");
const { createClient } = require("redis");

const app = express();
const server = http.createServer(app);
const io = socketIo(server);

// Setting up the adapter with Redis
t(async () => {
  const pubClient = createClient({ url: "redis://localhost:6379" });
  const subClient = pubClient.duplicate();
  await pubClient.connect();
  await subClient.connect();
  io.adapter(createAdapter(pubClient, subClient));
})();

io.on("connection", socket => {
  console.log("Connection established: " + socket.id);
});

server.listen(3000, () => {
  console.log("Server is running on port 3000");
});

In the example above, each Socket.IO server connects with each other via Redis and client events are seamlessly transmitted among servers. Thus, no matter which server users connect to, real-time communication between users works flawlessly.

Best Practices and Conclusion

When doing load balancing with Socket.IO, it is generally recommended to use a load balancer with sticky session support (e.g., Nginx, AWS ELB) to ensure that clients are directed to the same server. In addition, thanks to centralized data sharing solutions such as the Redis adapter, horizontal scaling becomes easier. The performance of your Redis server plays a key role in the scalability of your Socket.IO application. In production environments, deployment based on pm2, docker or kubernetes offers effective solutions for automatically adding/removing nodes.

As a result, using "Load Balancing Methods with Socket.IO" to scale real-time Socket.IO services provides high performance and uninterrupted user experience for modern web applications.