Chat app example:
  User A sends a message → User B should see it instantly

With HTTP:
  User B would need to ask: "Any new messages?"
  Every 1 second... every 2 seconds...
  → Wasteful, slow, doesn't scale

HTTP:       Client → "Hello?" → Server → "Hi!" → Hang up
            Client → "Any news?" → Server → "No" → Hang up
            Client → "Any news?" → Server → "Yes, here!" → Hang up

WebSocket:  Client ←→ Open Channel ←→ Server
            Server: "Hey, new message!" (no client asking)
            Client: "Got it!" (instant)
            Server: "And another one!" (instant)

Client → Server:
  GET /chat HTTP/1.1
  Host: example.com
  Upgrade: websocket
  Connection: Upgrade
  Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==
  Sec-WebSocket-Version: 13

Server → Client:
  HTTP/1.1 101 Switching Protocols
  Upgrade: websocket
  Connection: Upgrade
  Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=

Connection is now a WebSocket. Both sides can send messages at any time.

After the handshake:

  Client ←→ WebSocket ←→ Server

  Both sides can send messages independently.
  No more request-response pattern.
  Messages are small (2-14 bytes header vs HTTP's hundreds of bytes).

 0                   1                   2                   3
 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+-+-+-+-+-------+-+-------------+-------------------------------+
|F|R|R|R| opcode|M| Payload len |    Extended payload length    |
|I|S|S|S|  (4)  |A|     (7)     |             (16/64)           |
|N|V|V|V|       |S|             |   (if payload len==126/127)   |
| |1|2|3|       |K|             |                               |
+-+-+-+-+-------+-+-------------+ - - - - - - - - - - - - - - - +
|     Extended payload length continued, if payload len == 127  |
+ - - - - - - - - - - - - - - - +-------------------------------+
|                               |Masking-key, if MASK set to 1  |
+-------------------------------+-------------------------------+
| Masking-key (continued)       |          Payload Data         |
+-------------------------------- - - - - - - - - - - - - - - - +
:                     Payload Data continued ...                :
+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -+
|                     Payload Data (continued)                  |
+---------------------------------------------------------------+

const WebSocket = require('ws');
const wss = new WebSocket.Server({ port: 8080 });
 
wss.on('connection', (ws) => {
  console.log('New client connected');
  
  // Send welcome message
  ws.send(JSON.stringify({ type: 'welcome', message: 'Connected!' }));
  
  // Handle incoming messages
  ws.on('message', (data) => {
    const message = JSON.parse(data);
    
    // Broadcast to all connected clients
    wss.clients.forEach((client) => {
      if (client.readyState === WebSocket.OPEN) {
        client.send(JSON.stringify({
          type: 'chat',
          user: message.user,
          text: message.text,
          timestamp: Date.now()
        }));
      }
    });
  });
  
  // Handle disconnection
  ws.on('close', () => {
    console.log('Client disconnected');
  });
  
  // Handle errors
  ws.on('error', (error) => {
    console.error('WebSocket error:', error);
  });
});

import asyncio
import websockets
 
connected_clients = set()
 
async def handler(websocket, path):
    connected_clients.add(websocket)
    try:
        async for message in websocket:
            # Broadcast to all connected clients
            for client in connected_clients:
                if client != websocket:
                    await client.send(message)
    finally:
        connected_clients.remove(websocket)
 
async def main():
    async with websockets.serve(handler, "localhost", 8070):
        await asyncio.Future()  # Run forever
 
asyncio.run(main())

Problem:
  User A → Server 1 (WebSocket)
  User B → Server 2 (WebSocket)
  
  User A sends message to User B
  Server 1 doesn't know User B is on Server 2!

User A → Server 1 → Redis Pub/Sub → Server 2 → User B

1. Each WebSocket server subscribes to a Redis channel
2. When a message arrives, publish to Redis
3. Redis fans out to all subscribers
4. Servers deliver to relevant connected clients

import redis
 
r = redis.Redis()
 
class WebSocketServer:
    def __init__(self):
        self.pubsub = r.pubsub()
        self.pubsub.subscribe('chat_messages')
    
    def handle_message(self, user_id, message):
        # Publish to Redis
        r.publish('chat_messages', json.dumps({
            'user_id': user_id,
            'message': message,
            'server_id': self.server_id
        }))
    
    def listen_for_messages(self):
        for item in self.pubsub.listen():
            if item['type'] == 'message':
                data = json.loads(item['data'])
                # Deliver to connected clients on this server
                self.deliver_to_local_clients(data)