Membangun Real-Time WebSocket Server Berskala Tinggi Menggunakan Node.js dan Redis Pub/Sub

1. Konteks Industri & Analisis Akar Masalah

Dalam lanskap pengembangan web modern, aplikasi real-time bukan lagi sekadar fitur tambahan (nice-to-have), melainkan standar industri yang esensial untuk platform e-commerce, aplikasi finansial, dashboard pemantauan infrastruktur, hingga platform kolaborasi. Namun, seiring dengan bertambahnya basis pengguna hingga mencapai skala jutaan koneksi konkuren (concurrent connections), arsitektur tradisional berbasis Single Node WebSocket Server pasti akan mengalami kegagalan.

Bottleneck Performa pada Arsitektur Tunggal

Ketika sebuah server Node.js menangani koneksi WebSocket, setiap koneksi klien mempertahankan soket TCP yang persisten. Batasan utama dalam arsitektur tunggal meliputi:

1. Keterbatasan File Descriptors (ULIMIT): Sistem operasi secara default membatasi jumlah file terbuka per proses (nofile). Tanpa penyesuaian kernel sistem operasi seperti Linux, server akan menolak koneksi baru meskipun memori dan CPU masih mencukupi.
2. Konsumsi Memori V8 Engine: Setiap objek soket dan struktur data stateful di dalam heap Node.js mengkonsumsi memori RAM. Dengan asumsi penggunaan memori per koneksi sekitar 10KB - 20KB, 1 juta koneksi membutuhkan setidaknya 10GB - 20GB RAM murni hanya untuk overhead soket, belum termasuk payload aplikasi.
3. Isolasi Cluster Node.js: Ketika kita menjalankan Node.js dalam mode cluster (multi-core menggunakan modul cluster bawaan) atau mendistribusikan beban ke beberapa instance server di balik Load Balancer (seperti Nginx), proses di Core A tidak mengetahui keberadaan klien yang terhubung ke Core B atau Server X dan Server Y. Akibatnya, pesan yang dikirimkan oleh satu pengguna tidak akan sampai ke pengguna lain yang terhubung ke instance server yang berbeda.

Perbandingan Kondisi: Sebelum vs Sesudah Penerapan Cluster & Redis Pub/Sub

[!WARNING] Jangan pernah menggunakan teknik polling atau long-polling untuk aplikasi berskala jutaan pengguna karena akan melipatgandakan beban HTTP request header pada web server dan menghabiskan sumber daya jaringan secara sia-sia.

2. Konsep Inti & Deep Dive Arsitektur

Untuk membangun sistem real-time yang mampu menangani jutaan koneksi, kita memerlukan pola arsitektur Distributed WebSocket Cluster. Arsitektur ini mengombinasikan beberapa komponen utama:

• Nginx Reverse Proxy & Load Balancer: Bertindak sebagai pintu gerbang terdepan yang menangani SSL termination, mendistribusikan koneksi TCP masuk menggunakan algoritma least_conn atau ip_hash, serta mengonfigurasi pengaturan buffer dan timeout WebSocket.
• Node.js WebSocket Server Cluster: Sekumpulan proses atau server Node.js (menggunakan pustaka seperti ws atau Socket.io) yang masing-masing memelihara puluhan ribu koneksi klien lokal.
• Redis Pub/Sub Layer: Bertindak sebagai message broker terpusat yang menyinkronkan pesan antar instance Node.js. Ketika Server A menerima pesan dari Klien A yang ditujukan ke sebuah channel, pesan tersebut dipublikasikan ke Redis. Seluruh server lain (termasuk Server A sendiri) yang berlangganan (subscribe) ke channel tersebut akan menerima pesan dan meneruskannya ke klien lokal mereka masing-masing.

Diagram Alur Arsitektur Sistem

+-------------------------------------------------------------------------+
|                              KLIEN / BROWSER                            |
|         (Client 1)              (Client 2)              (Client N)      
+-------------------------------------------------------------------------+
     |                         |                         |
     +-------------------------+-------------------------+
                               | WebSocket Handshake & Persistent Connection
                               v
+-------------------------------------------------------------------------+
|                        NGINX REVERSE PROXY / LB                         |
|                 (SSL Termination & Load Balancing Layer)                |
+-------------------------------------------------------------------------+
     |                                           | 
     | (Upstream Node.js 1)                      | (Upstream Node.js 2)
     v                                           v
+-------------------------+                 +-------------------------+
|   NODE.JS INSTANCE 1    |                 |   NODE.JS INSTANCE 2    |
|  (Local WS Connections) |                 |  (Local WS Connections) |
+-------------------------+                 +-------------------------+
     |                                           |
     +------------------+     +------------------+
                        |     |
                        v     v
+-------------------------------------------------------------------------+
|                           REDIS PUB / SUB CLUSTER                       |
|                  (Inter-Server Message Synchronization)                 |
+-------------------------------------------------------------------------+

3. Perbandingan Komparatif / Analisis Pendekatan

Dalam merancang sistem WebSocket berskala besar, pemilihan pustaka backend dan mekanisme penyimpanan state memengaruhi performa secara drastis. Berikut adalah analisis perbandingan tiga pendekatan populer:

[!TIP] Jika Anda membangun sistem messaging enterprise yang membutuhkan kontrol penuh terhadap struktur byte frame WebSocket dan efisiensi memori yang ekstrem, kombinasi Node.js dengan pustaka ws murni dan Redis Pub/Sub adalah pilihan paling rasional dan teruji di industri.

4. Prasyarat Sistem & Persiapan Lingkungan

Sebelum mulai menulis kode, pastikan infrastruktur sistem operasi Linux (Ubuntu 22.04 LTS atau AlmaLinux 9) disetel untuk mendukung high concurrency (melewati batas standar sistem operasi).

A. Penyesuaian Kernel & File Descriptors (/etc/security/limits.conf) tambahkan baris berikut:

* soft nofile 1000000
* hard nofile 1000000
root soft nofile 1000000
root hard nofile 1000000

B. Penyesuaian Parameter Jaringan Kernel (/etc/sysctl.conf):

# Meningkatkan batas antrean koneksi TCP
net.core.somaxconn = 65535

# Mengaktifkan reuse port dan recycle socket
net.ipv4.tcp_tw_reuse = 1
net.ipv4.ip_local_port_range = 1024 65535

# Memperbesar ukuran memori buffer TCP
net.ipv4.tcp_rmem = 4096 87380 16777216
net.ipv4.tcp_wmem = 4096 65536 16777216

Terapkan perubahan sysctl dengan perintah:

sudo sysctl -p

5. Panduan Implementasi Langkah demi Langkah

Langkah 1: Inisialisasi Proyek Node.js

Buat direktori baru dan instal dependensi yang dibutuhkan (ws untuk manajemen WebSocket, ioredis untuk koneksi Redis yang handal dan performa tinggi, serta dotenv):

mkdir high-scale-ws-server
cd high-scale-ws-server
npm init -y
npm install ws ioredis dotenv
npm install --save-dev typescript @types/node @types/ws tsx

Langkah 2: Konfigurasi TypeScript (tsconfig.json)

{
  "compilerOptions": {
    "target": "ES2022",
    "module": "NodeNext",
    "moduleResolution": "NodeNext",
    "lib": ["ES2022"],
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true,
    "forceConsistentCasingInFileNames": true,
    "outDir": "./dist"
  },
  "include": ["src/**/*"]
}

Langkah 3: Implementasi Server WebSocket (src/server.ts)

Buat file kode sumber lengkap yang mencakup manajemen koneksi, heartbeat ping/pong untuk mendeteksi koneksi terputus (dead connections), serta integrasi Redis Pub/Sub.

import { WebSocketServer, WebSocket } from 'ws';
import { createClient } from 'ioredis';
import http from 'http';
import dotenv from 'dotenv';

dotenv.config();

const PORT = process.env.PORT ? parseInt(process.env.PORT) : 8080;
const INSTANCE_ID = process.env.INSTANCE_ID || `node-ws-${Math.random().toString(36).substring(7))}`;

// HTTP Server dasar untuk health check
const server = http.createServer((req, res) => {
  if (req.url === '/health') {
    res.writeHead(200, { 'Content-Type': 'application/json' });
    res.end(JSON.stringify({ status: 'OK', instance: INSTANCE_ID, uptime: process.uptime() }));
  } else {
    res.writeHead(404);
    res.end();
  }
});

// WebSocket Server di atas HTTP server
const wss = new WebSocketServer({ noServer: true });

server.on('upgrade', (request, socket, head) => {
  wss.handleUpgrade(request, socket, head, (ws) => {
    wss.emit('connection', ws, request);
  });
});

// Setup Redis Clients (Pub dan Sub harus menggunakan koneksi terpisah di ioredis)
const redisPub = createClient({ host: process.env.REDIS_HOST || '127.0.0.1', port: parseInt(process.env.REDIS_PORT || '6379') });
const redisSub = createClient({ host: process.env.REDIS_HOST || '127.0.0.1', port: parseInt(process.env.REDIS_PORT || '6379') });

const GLOBAL_CHANNEL = 'chat_global_channel';

interface ExtWebSocket extends WebSocket {
  isAlive?: boolean;
  id?: string;
}

// Subscribe ke Redis Channel untuk menerima pesan dari instance lain
redisSub.subscribe(GLOBAL_CHANNEL, (err, count) => {
  if (err) {
    console.error(`[${INSTANCE_ID}] Gagal subscribe ke Redis channel:`, err);
  } else {
    console.log(`[${INSTANCE_ID}] Berhasil subscribe ke ${GLOBAL_CHANNEL}. Total subscribers: ${count}`);
  }
});

// Tangkap pesan yang datang dari Redis Pub/Sub dan broadcast ke klien lokal
redisSub.on('message', (channel, message) => {
  if (channel === GLOBAL_CHANNEL) {
    try {
      const parsedMessage = JSON.parse(message);
      // Jangan kirim ulang ke pengirim asli jika berasal dari instance ini (opsional)
      // Di sini kita broadcast ke seluruh klien yang terhubung ke instance ini
      wss.clients.forEach((client) => {
        if (client.readyState === WebSocket.OPEN) {
          client.send(JSON.stringify(parsedMessage));
        }
      });
    } catch (e) {
      console.error(`[${INSTANCE_ID}] Gagal parsing pesan dari Redis:`, e);
    }
  }
});

// Manajemen Koneksi WebSocket
wss.on('connection', (ws: ExtWebSocket) => {
  ws.isAlive = true;
  ws.id = Math.random().toString(36).substring(2, 11);
  console.log(`[${INSTANCE_ID}] Klien terhubung: ${ws.id}`);

  ws.on('pong', () => {
    ws.isAlive = true;
  });

  ws.on('message', async (data: Buffer) => {
    try {
      const payload = JSON.parse(data.toString());
      console.log(`[${INSTANCE_ID}] Menerima pesan dari klien ${ws.id}:`, payload);
      
      // Publikasikan pesan ke Redis agar seluruh instance server meneruskannya
      const messageEnvelope = {
        senderId: ws.id,
        originInstance: INSTANCE_ID,
        data: payload,
        timestamp: Date.now()
      };

      await redisPub.publish(GLOBAL_CHANNEL, JSON.stringify(messageEnvelope));
    } catch (error) {
      console.error(`[${INSTANCE_ID}] Format pesan tidak valid dari ${ws.id}:`, error);
      ws.send(JSON.stringify({ error: 'Invalid JSON payload format' }));
    }
  });

  ws.on('close', () => {
    console.log(`[${INSTANCE_ID}] Klien terputus: ${ws.id}`);
  });

  ws.on('error', (error) => {
    console.error(`[${INSTANCE_ID}] WebSocket error pada klien ${ws.id}:`, error);
  });
});

// Mekanisme Heartbeat Interval (Ping/Pong setiap 30 detik untuk mendeteksi Dead Connections)
const interval = setInterval(() => {
  wss.clients.forEach((ws: ExtWebSocket) => {
    if (ws.isAlive === false) {
      console.log(`[${INSTANCE_ID}] Menutup koneksi mati klien: ${ws.id}`);
      return ws.terminate();
    }

    ws.isAlive = false;
    ws.ping();
  });
}, 30000);

wss.on('close', () => {
  clearInterval(interval);
});

server.listen(PORT, () => {
  console.log(`[${INSTANCE_ID}] Server berjalan dan mendengarkan pada port ${PORT}`);
});

Langkah 6: Konfigurasi Nginx sebagai Load Balancer (/etc/nginx/sites-available/websocket_cluster)

Konfigurasikan Nginx untuk menangani koneksi upgrade WebSocket dengan benar dan mendistribusikannya ke beberapa instance Node.js lokal.

upstream websocket_backend {
    ip_hash; # Memastikan sticky sessions jika diperlukan, atau gunakan least_conn
    server 127.0.0.1:8080;
    server 127.0.0.1:8081;
    server 127.0.0.1:8082;
}

server {
    listen 80;
    server_name ws.enterprise.internal;

    location / {
        proxy_pass http://websocket_backend;
        proxy_http_version 1.1;
        
        # Header krusial untuk protokol WebSocket upgrade
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
        
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        
        # Timeout panjang agar koneksi WebSocket tidak terputus prematur oleh Nginx
        proxy_read_timeout 86400s;
        proxy_send_timeout 86400s;
    }
}

6. Bedah Kode & Penjelasan Detail Baris Kunci

• Pemisahan Redis Client (redisPub & redisSub): Berdasarkan spesifikasi pustaka ioredis dan klien Redis pada umumnya, sebuah koneksi yang masuk ke mode subscriber (SUBSCRIBE) tidak dapat menjalankan perintah lain selain menerima pesan dari channel yang di-subscribe. Oleh karena itu, kita wajib mendeklarasikan dua instance koneksi terpisah: satu untuk mempublikasikan (redisPub) dan satu lagi khusus mendengarkan (redisSub).
• Metode noServer: true dan server.on('upgrade', ...): Secara default, modul ws akan membuat server HTTP sendiri jika diinisialisasi dengan { port: 8080 }. Dengan menggunakan noServer: true, kita mengintegrasikan WebSocket server di atas instance http.createServer Node.js standar. Ini memungkinkan kita menjalankan pemeriksaan kesehatan (/health) pada port yang sama.
• Algoritma Heartbeat (ws.ping() dan ws.pong()): Koneksi TCP bisa terputus secara tiba-tiba tanpa event close terpanggil (misalnya karena gangguan jaringan seluler atau pemutusan router secara paksa). Dengan mengirimkan paket ping protokol WebSocket secara berkala setiap 30 detik dan mengevaluasi flag isAlive, server dapat membersihkan soket zombie yang memboroskan memori RAM.

7. Skenario Produksi & Studi Kasus Dunia Nyata

Dalam skenario penerapan di perusahaan Fintech penyedia layanan trading aset kripto real-time, latensi pengiriman data buku order (order book) tidak boleh melebihi 20 milidetik pada beban 500.000 pengguna aktif bersamaan.

Strategi Deployment Multi-Server:

1. Infrastruktur: Menggunakan 5 unit Virtual Machine (VM) berbasis cloud (masing-masing 8 vCPU, 32GB RAM).
2. Distribusi Proses: Setiap VM menjalankan 4 proses Node.js menggunakan modul PM2 dengan konfigurasi cluster mode (instances: 4).
3. Clustering Redis: Menggunakan Redis Cluster mandiri dengan arsitektur 3 Master dan 3 Replica untuk menjamin ketersediaan tinggi (High Availability) pada layer message broker.
4. Manajemen File Descriptor PM2 (ecosystem.config.js):

module.exports = {
  apps: [
    {
      name: 'ws-cluster-node',
      script: './dist/server.js',
      instances: 'max',
      exec_mode: 'cluster',
      env: {
        PORT: 8080,
        REDIS_HOST: 'redis-cluster.internal',
        REDIS_PORT: 6379
      },
      max_memory_restart: '2G'
    }
  ]
};

8. Common Pitfalls, Anti-Patterns & Solusi

1. Anti-Pattern: Menyimpan State Sesi Klien di Memori Lokal Saja
   • Kesalahan: Menyimpan daftar objek koneksi ke dalam array atau objek JavaScript global tanpa mekanisme Redis. Ketika server mengalami lonjakan traffic dan harus diskalakan secara horizontal, pesan antar server terisolasi.
   • Solusi: Selalu gunakan Redis atau database in-memory terpusat untuk melacak state atau mendistribusikan event menggunakan Redis Pub/Sub.
2. Kesalahan Konfigurasi Timeout Load Balancer (Nginx/HAProxy)
   • Kesalahan: Menggunakan konfigurasi timeout default Nginx (biasanya 60 detik). Klien WebSocket yang diam (idle) akan diputus oleh Nginx setiap menit.
   • Solusi: Set proxy_read_timeout 86400s; dan pastikan mekanisme aplikasi mengirimkan heartbeat secara berkala.
3. Kebocoran Memori (Memory Leak) Akibat Event Listener Ganda
   • Kesalahan: Menambahkan .on('message', ...) di dalam handler koneksi tanpa membersihkannya saat klien terputus.
   • Solusi: Pastikan menggunakan pembersihan referensi yang tepat atau manfaatkan pustaka yang secara otomatis membersihkan event listener saat soket tertutup.

9. Benchmark, Metrik Kinerja & Tuning Performa

Untuk menguji kemampuan ketahanan server WebSocket yang telah dibangun, kita dapat menggunakan tool pengujian beban modern berbasis JavaScript seperti k6.

Skrip Benchmark k6 (load-test.js)

import ws from 'k6/ws';
import { check, sleep } from 'k6';

export const options = {
  stages: [
    { duration: '30s', target: 1000 },  // Ramp up hingga 1000 pengguna dalam 30 detik
    { duration: '1m', target: 5000 },   // Pertahankan 5000 koneksi konkuren selama 1 menit
    { duration: '30s', target: 0 },     // Ramp down
  ],
};

export default function () {
  const url = 'ws://127.0.0.1:8080';
  
  const res = ws.connect(url, {}, function (socket) {
    socket.on('open', function () {
      console.log('Connected to WebSocket server');
      socket.send(JSON.stringify({ type: 'PING_TEST', message: 'Hello Server' }));
    });

    socket.on('message', function (message) {
      // Parsing pesan yang diterima kembali
      check(message, { 'message received': (msg) => msg.length > 0 });
    });

    socket.on('close', function () {
      console.log('Disconnected');
    });

    socket.setTimeout(function () {
      socket.close();
    }, 20000); // Pertahankan koneksi selama 20 detik
  });

  check(res, { 'status is 101': (r) => r && r.status === 101 });
  sleep(1);
}

Jalankan benchmark menggunakan perintah:

k6 run load-test.js

Interpretasi Metrik Pengujian:

• ws_connecting & ws_sessions: Memantau berapa banyak koneksi aktif yang berhasil dibuka secara bersamaan.
• CPU & RAM Node.js: Pastikan penggunaan CPU tetap di bawah 75% per core dan memori stabil tanpa lonjakan linier terus-menerus (indikasi memory leak).

10. Checklist Penerapan Produksi & Kesimpulan

Sebelum meluncurkan server WebSocket kluster ke lingkungan produksi (Production), pastikan Anda telah memverifikasi seluruh daftar periksa berikut:

• Batas sistem operasi (nofile dan parameter sysctl.conf) telah ditingkatkan pada semua node server.
• Konfigurasi Nginx telah mencakup header Upgrade dan Connection dengan timeout yang memadai (86400s).
• Redis Pub/Sub dikonfigurasi dengan High Availability (Redis Sentinel atau Redis Cluster) agar tidak menjadi Single Point of Failure.
• Mekanisme Heartbeat Ping/Pong aktif di sisi server untuk mendeteksi dan memutuskan koneksi mati secara otomatis.
• Pemantauan metrik (Prometheus & Grafana) telah diatur untuk melacak penggunaan memori heap Node.js, jumlah koneksi aktif, dan latensi pesan.

Dengan menerapkan arsitektur terdistribusi berbasis Node.js cluster dan Redis Pub/Sub ini, sistem Anda siap menangani jutaan koneksi konkuren secara stabil, andal, dan siap menghadapi lonjakan traffic enterprise skala global.