@socket.io/redis-adapter

What is @socket.io/redis-adapter?

@socket.io/redis-adapter is an adapter for Socket.IO that allows you to use Redis as a message broker to enable horizontal scaling. It facilitates communication between multiple Socket.IO servers by using Redis Pub/Sub mechanism.

What are @socket.io/redis-adapter's main functionalities?

Basic Setup

This code demonstrates the basic setup of the @socket.io/redis-adapter. It initializes a Socket.IO server and configures it to use Redis for message brokering.

const { createAdapter } = require('@socket.io/redis-adapter');
const { Server } = require('socket.io');
const { createClient } = require('redis');

const io = new Server();
const pubClient = createClient({ host: 'localhost', port: 6379 });
const subClient = pubClient.duplicate();

io.adapter(createAdapter(pubClient, subClient));
io.listen(3000);

Broadcasting Events

This code shows how to broadcast events to all connected clients using the @socket.io/redis-adapter. When a 'message' event is received, it is broadcasted to all clients.

io.on('connection', (socket) => {
  socket.on('message', (data) => {
    io.emit('message', data);
  });
});

Handling Rooms

This code demonstrates how to handle rooms with the @socket.io/redis-adapter. Clients can join rooms and messages can be sent to specific rooms.

io.on('connection', (socket) => {
  socket.on('joinRoom', (room) => {
    socket.join(room);
  });

  socket.on('message', (data) => {
    io.to(data.room).emit('message', data.message);
  });
});

Other packages similar to @socket.io/redis-adapter

socket.io-emitter

socket.io-emitter is a package that allows you to send events to Socket.IO servers from non-Socket.IO processes. It uses Redis to communicate with the Socket.IO servers, similar to @socket.io/redis-adapter, but is designed for external processes rather than internal server-to-server communication.

socket.io-redis

socket.io-redis is another adapter for Socket.IO that uses Redis Pub/Sub to enable horizontal scaling. It is very similar to @socket.io/redis-adapter, but @socket.io/redis-adapter is the more modern and actively maintained version.

README

socket.io-redis

Table of contents

• How to use
  • CommonJS
  • ES6 module
  • TypeScript
• Compatibility table
• How does it work under the hood?
• API
  • adapter(pubClient, subClient[, opts])
  • RedisAdapter
    • RedisAdapter#sockets(rooms: Set<String>)
    • RedisAdapter#allRooms()
    • RedisAdapter#remoteJoin(id:String, room:String)
    • RedisAdapter#remoteLeave(id:String, room:String)
    • RedisAdapter#remoteDisconnect(id:String, close:Boolean)
• With ioredis client
  • Cluster example
  • Sentinel Example
• Protocol
• Migrating from socket.io-redis
• License

How to use

Installation:

$ npm install @socket.io/redis-adapter redis

CommonJS

const { Server } = require('socket.io');
const { createClient } = require('redis');
const { createAdapter } = require('@socket.io/redis-adapter');

const io = new Server();
const pubClient = createClient({ host: 'localhost', port: 6379 });
const subClient = pubClient.duplicate();

Promise.all([pubClient.connect(), subClient.connect()]).then(() => {
  io.adapter(createAdapter(pubClient, subClient));
  io.listen(3000);
});

With redis@3, calling connect() on the Redis clients is not needed:

const { Server } = require('socket.io');
const { createClient } = require('redis');
const { createAdapter } = require('@socket.io/redis-adapter');

const io = new Server();
const pubClient = createClient({ host: 'localhost', port: 6379 });
const subClient = pubClient.duplicate();

io.adapter(createAdapter(pubClient, subClient));

io.listen(3000);

ES6 modules

import { Server } from 'socket.io';
import { createClient } from 'redis';
import { createAdapter } from '@socket.io/redis-adapter';

const io = new Server();
const pubClient = createClient({ host: 'localhost', port: 6379 });
const subClient = pubClient.duplicate();

Promise.all([pubClient.connect(), subClient.connect()]).then(() => {
  io.adapter(createAdapter(pubClient, subClient));
  io.listen(3000);
});

TypeScript

import { Server } from 'socket.io';
import { createClient } from 'redis';
import { createAdapter } from '@socket.io/redis-adapter';

const io = new Server();
const pubClient = createClient({ host: 'localhost', port: 6379 });
const subClient = pubClient.duplicate();

Promise.all([pubClient.connect(), subClient.connect()]).then(() => {
  io.adapter(createAdapter(pubClient, subClient));
  io.listen(3000);
});

By running Socket.IO with the @socket.io/redis-adapter adapter you can run multiple Socket.IO instances in different processes or servers that can all broadcast and emit events to and from each other.

So any of the following commands:

io.emit('hello', 'to all clients');
io.to('room42').emit('hello', "to all clients in 'room42' room");

io.on('connection', (socket) => {
  socket.broadcast.emit('hello', 'to all clients except sender');
  socket.to('room42').emit('hello', "to all clients in 'room42' room except sender");
});

will properly be broadcast to the clients through the Redis Pub/Sub mechanism.

If you need to emit events to socket.io instances from a non-socket.io process, you should use socket.io-emitter.

Compatibility table

Redis Adapter version	Socket.IO server version
4.x	1.x
5.x	2.x
6.0.x	3.x
6.1.x and above	4.x

How does it work under the hood?

This adapter extends the in-memory adapter that is included by default with the Socket.IO server.

The in-memory adapter stores the relationships between Sockets and Rooms in two Maps.

When you run socket.join("room21"), here's what happens:

console.log(adapter.rooms); // Map { "room21" => Set { "mdpk4kxF5CmhwfCdAHD8" } }
console.log(adapter.sids); // Map { "mdpk4kxF5CmhwfCdAHD8" => Set { "mdpk4kxF5CmhwfCdAHD8", "room21" } }
// "mdpk4kxF5CmhwfCdAHD8" being the ID of the given socket

Those two Maps are then used when broadcasting:

• a broadcast to all sockets (io.emit()) loops through the sids Map, and send the packet to all sockets
• a broadcast to a given room (io.to("room21").emit()) loops through the Set in the rooms Map, and sends the packet to all matching sockets

The Redis adapter extends the broadcast function of the in-memory adapter: the packet is also published to a Redis channel (see below for the format of the channel name).

Each Socket.IO server receives this packet and broadcasts it to its own list of connected sockets.

To check what's happening on your Redis instance:

$ redis-cli
127.0.0.1:6379> PSUBSCRIBE *
Reading messages... (press Ctrl-C to quit)
1) "psubscribe"
2) "*"
3) (integer) 1

1) "pmessage"
2) "*"
3) "socket.io#/#" (a broadcast to all sockets or to a list of rooms)
4) <the packet content>

1) "pmessage"
2) "*"
3) "socket.io#/#room21#" (a broadcast to a single room)
4) <the packet content>

Note: no data is stored in Redis itself

There are 3 Redis subscriptions per namespace:

• main channel: <prefix>#<namespace>#* (glob)
• request channel: <prefix>-request#<namespace>#
• response channel: <prefix>-response#<namespace>#

The request and response channels are used in the additional methods exposed by the Redis adapter, like RedisAdapter#allRooms().

API

adapter(pubClient, subClient[, opts])

The following options are allowed:

• key: the name of the key to pub/sub events on as prefix (socket.io)
• requestsTimeout: optional, after this timeout the adapter will stop waiting from responses to request (5000ms)
• parser: optional, parser to use for encoding and decoding messages passed through Redis (notepack.io)

RedisAdapter

The redis adapter instances expose the following properties that a regular Adapter does not

• uid
• prefix
• pubClient
• subClient
• requestsTimeout
• parser

RedisAdapter#sockets(rooms: Set<String>)

Returns the list of socket IDs connected to rooms across all nodes. See Namespace#allSockets()

const sockets = await io.of('/').adapter.sockets(new Set());
console.log(sockets); // a Set containing all the connected socket ids

const sockets = await io.of('/').adapter.sockets(new Set(['room1', 'room2']));
console.log(sockets); // a Set containing the socket ids in 'room1' or in 'room2'

// this method is also exposed by the Server instance
const sockets = await io.in('room3').allSockets();
console.log(sockets); // a Set containing the socket ids in 'room3'

RedisAdapter#allRooms()

Returns the list of all rooms.

const rooms = await io.of('/').adapter.allRooms();
console.log(rooms); // a Set containing all rooms (across every node)

RedisAdapter#remoteJoin(id:String, room:String)

Makes the socket with the given id join the room.

try {
  await io.of('/').adapter.remoteJoin('<my-id>', 'room1');
} catch (e) {
  // the socket was not found
}

RedisAdapter#remoteLeave(id:String, room:String)

Makes the socket with the given id leave the room.

try {
  await io.of('/').adapter.remoteLeave('<my-id>', 'room1');
} catch (e) {
  // the socket was not found
}

RedisAdapter#remoteDisconnect(id:String, close:Boolean)

Makes the socket with the given id to get disconnected. If close is set to true, it also closes the underlying socket.

try {
  await io.of('/').adapter.remoteDisconnect('<my-id>', true);
} catch (e) {
  // the socket was not found
}

With ioredis client

Cluster example

const io = require('socket.io')(3000);
const redisAdapter = require('@socket.io/redis-adapter');
const Redis = require('ioredis');

const startupNodes = [
  {
    port: 6380,
    host: '127.0.0.1'
  },
  {
    port: 6381,
    host: '127.0.0.1'
  }
];

const pubClient = new Redis.Cluster(startupNodes);
const subClient = pubClient.duplicate();

io.adapter(redisAdapter(pubClient, subClient));

Sentinel Example

const io = require('socket.io')(3000);
const redisAdapter = require('@socket.io/redis-adapter');
const Redis = require('ioredis');

const options = {
  sentinels: [
    { host: 'somehost1', port: 26379 },
    { host: 'somehost2', port: 26379 }
  ],
  name: 'master01'
};

const pubClient = new Redis(options);
const subClient = pubClient.duplicate();

io.adapter(redisAdapter(pubClient, subClient));

Protocol

The @socket.io/redis-adapter adapter broadcasts and receives messages on particularly named Redis channels. For global broadcasts the channel name is:

prefix + '#' + namespace + '#'

In broadcasting to a single room the channel name is:

prefix + '#' + namespace + '#' + room + '#'

• prefix: The base channel name. Default value is socket.io. Changed by setting opts.key in adapter(opts) constructor
• namespace: See https://github.com/socketio/socket.io#namespace.
• room : Used if targeting a specific room.

A number of other libraries adopt this protocol including:

• socket.io-redis-emitter
• socket.io-python-emitter
• socket.io-emitter-go

Migrating from socket.io-redis

The package was renamed from socket.io-redis to @socket.io/redis-adapter in v7, in order to match the name of the Redis emitter (@socket.io/redis-emitter).

To migrate to the new package, you'll need to make sure to provide your own Redis clients, as the package will no longer create Redis clients on behalf of the user.

Before:

const redisAdapter = require("socket.io-redis");

io.adapter(redisAdapter({ host: "localhost", port: 6379 }));

After:

const { createClient } = require("redis");
const { createAdapter } = require("@socket.io/redis-adapter");

const pubClient = createClient({ host: "localhost", port: 6379 });
const subClient = pubClient.duplicate();

io.adapter(createAdapter(pubClient, subClient));

Please note that the communication protocol between the Socket.IO servers has not been updated, so you can have some servers with socket.io-redis and some others with @socket.io/redis-adapter at the same time.

License

MIT

Changelog

8.0.1 (2023-01-11)

This release pins the socket.io-adapter package to version ~2.4.0 instead of ^2.4.0.