WebSockets & Realtime Systems Programming · Lesson

Distributed State Management

Explore using external message brokers (e.g., Redis Pub/Sub, Kafka) to synchronize state across multiple WebSocket servers.

Distributed State Management is a free WebSockets & Realtime Systems Programming lesson on CoddyKit — lesson 3 of 4. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the WebSockets & Realtime Systems Programming learning path, one of 4 lessons in the course, and your progress syncs across the web and the CoddyKit app.

Scaling Challenges: Shared State

You've learned about scaling WebSocket applications by running multiple server instances behind a load balancer. But what happens when a client connects to Server A, and another client connected to Server B needs to send a message to the first client?

This is the challenge of distributed state management: how do your servers share information and coordinate?

Why Centralize State?

Imagine a chat application. If Client 1 is on Server A and Client 2 is on Server B, and Client 1 sends a message, how does Server A tell Server B to deliver it to Client 2?

Without a way for servers to communicate, messages or updates might only reach clients connected to the same server, breaking the real-time experience.

Introducing Message Brokers

To solve this, we use a message broker. Think of it as a central post office for your servers.

Servers send messages to the broker.
Other servers can then receive messages from the broker.

This allows all your WebSocket servers to communicate indirectly, without needing to know about each other's existence.

The Pub/Sub Pattern

Many message brokers use a Publisher-Subscriber (Pub/Sub) pattern. It works like this:

Publishers send messages to specific channels or topics.
Subscribers express interest in one or more channels and receive all messages published to them.

This pattern is perfect for broadcasting data across multiple server instances.

Redis Pub/Sub Example

Redis is a popular, open-source, in-memory data store that's often used as a message broker. Its Pub/Sub feature is fast and simple to use.

You can have multiple Node.js WebSocket servers, all connected to a single Redis instance, using it to exchange messages.

Redis Pub/Sub Basics

Let's say you have two WebSocket servers, Server A and Server B, both connected to Redis.

When Server A receives a message it needs to share, it publishes that message to a Redis channel (e.g., 'global_chat').
Server B has subscribed to 'global_chat', so it instantly receives the message from Redis.

Then, Server B can forward that message to its own connected clients.

Server Publishes to Redis

Here's a simplified Node.js example for a WebSocket server publishing messages to a Redis channel. We'll use the ws library for WebSockets and ioredis for Redis.

Make sure you have Redis running and ws and ioredis installed (`npm i ws ioredis`).

const WebSocket = require('ws');
const Redis = require('ioredis');

const wss = new WebSocket.Server({ port: 8080 });
const publisher = new Redis(); // Connects to localhost:6379

wss.on('connection', ws => {
  console.log('Client connected to Server 1');

  ws.on('message', message => {
    const msg = message.toString();
    console.log(`Server 1 received: ${msg}`);
    // Publish message to 'chat_messages' channel
    publisher.publish('chat_messages', msg);
    ws.send(`You said: ${msg}`); // Echo back to sender
  });
});

console.log('Server 1 listening on ws://localhost:8080');

Server Subscribes & Relays

Now, here's another Node.js WebSocket server (running on a different port) that subscribes to the same Redis channel. When it gets a message from Redis, it broadcasts it to its own connected clients.

You would run this in a separate terminal from server1.js.

const WebSocket = require('ws');
const Redis = require('ioredis');

const wss = new WebSocket.Server({ port: 8081 });
const subscriber = new Redis(); // Connects to localhost:6379

// Subscribe to the 'chat_messages' channel
subscriber.subscribe('chat_messages', (err, count) => {
  if (err) console.error('Failed to subscribe:', err.message);
  else console.log(`Subscribed to ${count} channel(s)`);
});

// Handle messages received from Redis
subscriber.on('message', (channel, message) => {
  console.log(`Server 2 received from Redis [${channel}]: ${message}`);
  // Broadcast to all connected clients on Server 2
  wss.clients.forEach(client => {
    if (client.readyState === WebSocket.OPEN) {
      client.send(`Global Chat: ${message}`);
    }
  });
});

wss.on('connection', ws => {
  console.log('Client connected to Server 2');
  ws.send('Welcome to Server 2!');
});

console.log('Server 2 listening on ws://localhost:8081');

Benefits for Scaling

Using a message broker like Redis Pub/Sub offers significant advantages for scaling WebSocket applications:

Decoupling: Servers don't need direct knowledge of each other. They only interact with the broker.
Horizontal Scalability: You can easily add more WebSocket servers as traffic grows, and they'll all connect to the same broker.
Global Broadcasts: Messages can be efficiently broadcast to all clients, regardless of which server they are connected to.

Beyond Broadcasts: Presence

Message brokers aren't just for broadcasting chat messages. They are vital for synchronizing other types of distributed state, like user presence.

For example, when a user logs in, their connected server can publish an 'online' status to a Redis channel. Other servers subscribe to this to keep their lists of online users updated.

Message Broker Check

Consider a scenario where you have multiple WebSocket servers, and a message sent to one server needs to reach a client connected to another server. Which pattern best addresses this?

Recap: Distributed State

We learned that scaling WebSocket applications requires managing distributed state. Message brokers like Redis, using the Pub/Sub pattern, are crucial for allowing multiple WebSocket servers to communicate and synchronize data, ensuring all clients receive relevant updates regardless of which server they're connected to.

This makes your application more resilient and scalable as you add more server instances.

Frequently asked questions

Is the “Distributed State Management” lesson free?

Yes — the full text of “Distributed State Management” is free to read here on the web, and the WebSockets & Realtime Systems Programming course includes 4 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the WebSockets & Realtime Systems Programming course, upgrade to CoddyKit PRO.

What will I learn in “Distributed State Management”?

Explore using external message brokers (e.g., Redis Pub/Sub, Kafka) to synchronize state across multiple WebSocket servers. You practise WebSockets & Realtime Systems Programming with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.

Do I need any experience to start WebSockets & Realtime Systems Programming?

No prior experience is required. WebSockets & Realtime Systems Programming on CoddyKit is structured for beginners through advanced learners; this is — lesson 3 of 4, so you can start here or from the beginning and move at your own pace.

How long does the “Distributed State Management” lesson take?

Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.

Can I write and run code in this WebSockets & Realtime Systems Programming lesson?

Yes. Every WebSockets & Realtime Systems Programming lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.

All lessons in this course

← Back to WebSockets & Realtime Systems Programming