Is elasticache cluster mode supported with node-redis?

[jlippold]

When using this package with node-redis, I get the following error

node:internal/process/promises:289
            triggerUncaughtException(err, true /* fromPromise */);
            ^

[ErrorReply: ERR unknown command 'psubscribe', with args beginning with: socket.io#/#*]

The only related issue I can find, is this one which describes switching to io-redis over node-redis when using elasticache for cluster mode. #484

This issue in node-redis says support was added: redis/node-redis#2065 but they don't really give any documention on how to use it.

Does this package support node-redis with Elasticache in AWS? I'm running Redis OSS cluster serverless. Thanks for the help

"socket.io": "^4.7.5",
"@socket.io/redis-adapter": "^8.3.0",
"@socket.io/redis-emitter": "^5.1.0",
"redis": "^4.7.0",

Here's a code snippet of my current socket implementation which does throws the error

const { Server } = require("socket.io");
const { createAdapter } = require("@socket.io/redis-adapter");
const { Emitter } = require("@socket.io/redis-emitter");
const { createClient } = require("redis");
const redis = require('../../configs/redis');
const env = process.env.NODE_ENV || 'local';

const host = redis[env].host || '127.0.0.1';
const port = redis[env].port || 6379;

let io = null;
let emitter = null;

function startServer(server) {

    const pubClient = createClient({
            url: `rediss://${host}:${port}`, // rediss:// is the secure version of redis://
    });
    const subClient = pubClient.duplicate();
    const tasks = [
        pubClient.connect(), subClient.connect()
    ];

    Promise.all(tasks).then(() => {

        emitter = new Emitter(pubClient);

        const serverOptions = {
            adapter: createAdapter(pubClient, subClient, {
                key: adapterKey,
                requestsTimeout: 10000
            }),
            connectionStateRecovery: {
                maxDisconnectionDuration: 2 * 60 * 1000, // the backup duration of the sessions and the packets
                skipMiddlewares: true, // whether to skip middlewares upon successful recovery
            },
            cors: {
                origin: [
                    'http://localhost:8080',
                    'http://localhost:3000',
                    'http://localhost',
                ]
            }
        };

        io = new Server(server, serverOptions);

        io.on('connection', (socket) => {
            console.log(`WebSocket connection established: socket.id ${socket.id} for ${ioKey}`);

            socket.on('error', function (err) {
                console.error('Socket error', err);
            });

        });

        io.on('socketMessage', (data) => {
             console.log(`${ioKey} received socketMessage`); // Logs all clusters that received the message
        });

        io.on('error', (err) => {
            console.error('WebSocket server error', err);
        });

        io.on('close', () => {
            console.error('WebSocket server closed');
        });

        io.engine.on("connection_error", (err) => {
            console.error('WebSocket connection error', err); // See https://socket.io/docs/v4/troubleshooting-connection-issues
        });

    }).catch((err) => {
        console.error('FATAL: Could not start Socket.io server with redis adapter', err);
    });

}

Thanks for the help

[vanics]

I am also facing this issue. Have you come across a solution @jlippold ?

[jlippold]

Nah bro, I switched to io-redis instead

[darrachequesne]

Hi! I was not able to reproduce the issue:

Elasticache with cluster mode enabled:

Dependencies:

$ npm ls 
tmp-socket.io-redis@1.0.0 /tmp/tmp-socket.io-redis
├── @socket.io/redis-adapter@8.3.0
├── redis@4.7.0
└── socket.io@4.8.1

My server:

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

async function main() {
  const pubClient = createCluster({
    rootNodes: [
      {
        url: "redis://test02-0001-001.jrvb7m.0001.usw1.cache.amazonaws.com:6379",
      },
      {
        url: "redis://test02-0002-001.jrvb7m.0001.usw1.cache.amazonaws.com:6379",
      },
      {
        url: "redis://test02-0003-001.jrvb7m.0001.usw1.cache.amazonaws.com:6379",
      },
    ],
  });
  const subClient = pubClient.duplicate();

  await Promise.all([
    pubClient.connect(),
    subClient.connect(),
  ]);

  console.log("successful connection");

  const io = new Server({
    adapter: createAdapter(pubClient, subClient)
  });

  const io2 = new Server({
    adapter: createAdapter(pubClient, subClient)
  });

  io2.on("hello", (val) => {
    console.log("received", val);
  });

  setTimeout(() => {
    io.serverSideEmit("hello", "world");
  }, 100);
}

main().catch((err) => {
  console.error(err);
});

Output:

$ node test.js 
successful connection
received world

The serverSideEmit ensures the link between the two Socket.IO servers is properly going through the Redis cluster.

Could you please check?

Reference: https://socket.io/docs/v4/redis-adapter/#with-the-redis-package-and-a-redis-cluster

[ollie5463]

@jlippold did you ever find a solution? I'm having the same issue using redis elasticache serverless. When using ioredis I can connect but I'm seeing the following error

ReplyError: ERR unknown command 'psubscribe', with args beginning with: socket.io#/#*

My code looks like this

  const pubClient = new IORedis(config.redisUri, {
    maxRetriesPerRequest: null,
    lazyConnect: true,
  });

  const subClient = pubClient.duplicate();

  await Promise.all([pubClient.connect(), subClient.connect()]);
  socketServer.adapter(createAdapter(pubClient, subClient));

[jlippold]

Sorry, I ended up switching to ioredis