Listen to messages with multiple customers(pub/sub)

Question

If I want to be able to have multiple users and channels, do I need to have each user create a client in redis (or whatever the pub/sub used) to subscribe to the channel? And how would you get the messages? I am thinking this way, clients redis-pub/sub would need to be at the level where the websocket server is, because the client server communication would only be by websocket, I do not know what pub/sub uses for communication, but I am only wanting websocket between client and server, and redis(database + pub/sub) communicating locally within the server:

'use strict';

//CREATE WEB SERVER
var express = require('express');
var app = express();
var http = require('http').Server(app);
//CREATE WS
const WebSocket = require('ws');
const wss = new WebSocket.Server({ server: http, port: 8080 });
//CREATE REDIS
var redis = require('redis');
var redisClient = redis.createClient({host : 'localhost', port : 6379});

var clients = {};

wss.on('connection', function connection(ws) {
    ws.on('message', function incoming(message) {
         // Aqui dependendo de certa mensagem recebida,
         // como um login por exemplo, eu faria algo assim:
         ws['user'] = obj.login.user.toString();
         //CRIAR UM NOVO CLIENTE REDIS SUBS
        clients[obj.login.user.toString()]['cliRedis'] = redis.createClient({host : 'localhost', port : 6379});
        // SE INSCREVER NO CANAL 
        clients[obj.login.user.toString()]['cliRedis'].subscribe();
    });

   if("user" in ws) {
        clients[ws.user]['cliRedis'].on("message", function(channel, message) {
             console.log("Msg on subscriber: " + message);
             //aqui enviaria os dados por websocket para o cliente
        });
   }
});

Up 1:

With the reply and comments of @rodorgas I was able to clarify a lot what I have to do. So I came to the conclusion that there are two possibilities, for the various customers to be able to listen to the messages sent by the pub/sub system:

1 - Using Centrifuge as indicated in the @rodorgas response:

2 - Using the pub/sub redis:

Comparisons:

Way 1 would have to have two active websockets connections, one for Centrifuge and one for Ws-server, at least I didn’t find anything in the Centrifuge documentation where I can handle messages that aren’t specific to the pub/sub, something like centrifuge-server.on("message", then I think it would even take two websockect connections in that mode. Then both would spend almost the same amount of sockets, because the sockets necessary for communication of pub/sub redis that would be won using the way 1, are lost having to open a new connection for communication with the client-Odot. The advantage of the way 1 is that it seems to be easier to understand, because the pub/sub client is even in the client, which does not even exist in fact, because Centrifugo only requires messages by websocket, there is no cli-Centrifugo as there is a cli-redis, the client-centrifuge is just the client-Godot sending messages via websocket. Already the way 2 clients-redis would be stored inside a javascript object in the nodejs script. Way 1 I will have to send messages in Centrifuge pattern that are big compared to what I can do by sending in Way 2.

Anyway, I’m wondering which way to start implementing, maybe I’ll do both and pick the one that’s faster. Anyway I’m running out of time in the next few days to start working on it, so I still have time to think about what to do.

Completion:

I chose to implement with the pub/sub redis, so I studied I would have more control over what I am doing. But I did not rule out Centrifugo, it will serve me very well if I come to implement a chat in the game, because it is very good for this task, with it I have like, for example, create private conversations between only two clients, among other facilities that are already implemented for you to use.

Answer 1

The Centrifuge is a pubsub server, it "creates channels" in websocket (actually it’s an abstraction layer, it takes care of unique users and allows you to group them into channels). This without having the redis as intermediary.

So let’s assume that your map is divided into sectors. The intention is to deliver a message to thousands of players who are in the (1.1) sector of the map. Put it like this in the browser:

<script type="text/javascript">

    var centrifuge = new Centrifuge({
        url: 'http://localhost:8000/connection',
        user: "USER ID",
        timestamp: "UNIX TIMESTAMP SECONDS",
        token: "SHA-256 HMAC TOKEN"
    });

    // inscreva o usuário no setor correspondente
    centrifuge.subscribe("(1,1)", function(message) {
        console.log(message);
    });

    centrifuge.connect();

</script>

In the backend, on the server side. Send a message like this (to assuming backend in nodejs, but centrifuge supports multiple languages):

Client = require("jscent");

var c = new Client({url: "http://localhost:8000", secret: "secret"});

c.publish("(1,1)", {"input": "test"}, function(err, resp){console.log(err, resp)});

When your game is huge and you have many servers, you put the redis in the parade. Centrifuge uses redis to load Alancing, for example, in high-scale situations.

Maybe someone comes up with an idea using the redis in the middle. But I see that the redis will always stay in the middle: you will need to pass to the browser later. The Centrifuge actually already solves it in one shot. I would use it.