Membangun Real-Time Collaborative API dengan GraphQL Subscriptions dan Redis Pub/Sub

1. Konteks Industri & Analisis Akar Masalah

Dalam lanskap pengembangan aplikasi web modern, kebutuhan akan komunikasi data secara instan (real-time) bukan lagi sekadar fitur tambahan, melainkan standar industri yang mutlak. Dari platform kolaborasi dokumen seperti Google Docs, dashboard pemantauan infrastruktur cloud, hingga aplikasi chatting enterprise dan trading engine, pengguna menuntut pengalaman tanpa latensi. Namun, transisi dari arsitektur HTTP request-response konvensional ke arsitektur berbasis event-driven menghadirkan tantangan teknik yang kompleks bagi para Web Architect, Backend Engineer, dan System Administrator.

Secara historis, aplikasi web mengandalkan teknik polling (Short Polling atau Long Polling) untuk mensimulasikan pembaruan data secara waktu nyata. Pendekatan ini terbukti tidak efisien, membebani CPU server, menghabiskan alokasi memori, serta memicu lonjakan penggunaan bandwidth akibat HTTP header overhead yang berulang-ulang setiap kali koneksi dibuka dan ditutup. Masalah ini semakin parah ketika aplikasi diskalakan secara horizontal (horizontal scaling) di balik infrastruktur load balancer modern seperti Nginx atau AWS ALB.

Masalah: Botol Leher Kinerja dan Keterbatasan Protokol

Ketika kita beralih ke GraphQL—sebuah bahasa kueri API yang sangat populer karena fleksibilitasnya dalam mengambil data presisi sesuai kebutuhan klien—kita dihadapkan pada satu keterbatasan mendasar pada spesifikasi dasarnya. Kueri (Query) dan Mutasi (Mutation) beroperasi di atas protokol HTTP standar yang bersifat stateless. Untuk kebutuhan real-time, spesifikasi GraphQL menyediakan Subscriptions, yang berjalan di atas protokol transport yang berbeda, yaitu WebSocket.

Namun, mengimplementasikan GraphQL Subscriptions dalam lingkungan produksi skala besar memunculkan dua masalah krusial:

1. Koneksi Stateful dan State Synchronization antar Instance Server: Protokol WebSocket mempertahankan koneksi TCP persisten (stateful). Jika aplikasi Anda berjalan di atas kluster Kubernetes dengan 5 replica pod backend Node.js, dan Klien A terhubung ke Pod 1 sementara Klien B terhubung ke Pod 3, bagaimana Pod 1 memberi tahu Pod 3 bahwa sebuah mutasi data telah terjadi sehingga Pod 3 dapat mendorong pembaruan ke Klien B? Tanpa lapisan perantara (broker), instans server terisolasi satu sama lain.
2. Masalah N+1 Query dan Latency Resolver: Berbeda dengan REST API di mana endpoint tunggal mengembalikan struktur data tetap, GraphQL menyelesaikan kueri melalui pohon resolver. Jika langganan (subscription) memicu pembaruan yang melibatkan relasi basis data yang kompleks (misalnya: mengambil data proyek, daftar tugas di dalamnya, dan profil pengguna yang mengerjakannya), kesalahan dalam penulisan resolver dapat memicu ribuan kueri terisolasi ke database (MySQL/PostgreSQL), melumpuhkan koneksi pool, dan menyebabkan lonjakan latensi yang parah.

Perbandingan: Sebelum vs Sesudah Penerapan

[!WARNING] Jangan pernah mencoba menjalankan GraphQL Subscriptions di lingkungan produksi multi-server tanpa lapisan message broker eksternal seperti Redis. Tanpa Redis, sinkronisasi antar-node akan gagal, menyebabkan inkonsistensi data yang fatal bagi pengguna akhir.

2. Konsep Inti & Deep Dive Arsitektur

Untuk membangun sistem yang tangguh, kita harus memahami secara mendalam bagaimana aliran data (data flow) bekerja dari tingkat klien web hingga penyimpanan persisten, melalui perantara WebSocket dan Redis Pub/Sub.

Alur Eksekusi (Under the Hood)

1. Inisiasi Koneksi (Handshake): Klien melakukan koneksi awal menggunakan protokol HTTP standar ke endpoint GraphQL (/graphql), kemudian melakukan proses upgrade protokol ke WebSocket melalui skema ws:// atau wss:// (menggunakan sub-protokol graphql-transport-ws).
2. Autentikasi & Otorisasi Handshake: Token JWT dikirimkan oleh klien pada tahap awal koneksi WebSocket (biasanya melalui payload connection_init). Server memvalidasi token tersebut; jika valid, konteks koneksi (connection context) disimpan dalam memori proses server.
3. Registrasi Subscription: Klien mengirimkan kueri subscription (contoh: subscription { taskUpdated { id title status } }). Server mendaftarkan klien tersebut ke dalam struktur memori internal (biasanya berupa PubSub iterator).
4. Pemicu Mutasi (Mutation Trigger): Pengguna lain melakukan mutasi data (contoh: mutation { updateTask(id: "123", status: "COMPLETED") }). Backend memproses mutasi, menyimpan perubahan ke database utama (MySQL/PostgreSQL).
5. Publikasi ke Redis: Setelah data berhasil disimpan di database, backend memanggil fungsi pubsub.publish('TASK_UPDATED', { taskUpdated: updatedData }). Pesan ini dikirimkan ke server Redis melalui perintah PUBLISH.
6. Distribusi Kluster: Redis bertindak sebagai message broker pusat yang mendistribusikan pesan tersebut ke seluruh instans backend yang terhubung ke kluster Redis yang sama.
7. Pengiriman ke Klien: Setiap instans backend menerima pesan dari Redis, memeriksa apakah ada klien lokal yang berlangganan channel tersebut, lalu meneruskan payload JSON secara asinkron melalui soket WebSocket aktif ke masing-masing klien.

+---------------------------------------------------------------------------------------------------------+
|                                             CLIENT BROWSER                                              |
|   +--------------------------+                  +---------------------------------------------------+   |
|   | WebSocket Client         |                  | GraphQL Subscription Operation                    |   |
|   +--------------------------+                  +---------------------------------------------------+   |
+---------------------------------------------------------------------------------------------------------+
                                                         ^                                  |
                                                         |                                  | WebSocket (WSS)
                                            WebSocket    |                                  | (ws:// or wss://)
                                            (Frame Data) |                                  |
+--------------------------------------------------------+------------------------------------------+
|                                           Nginx Reverse Proxy / Load Balancer                       | 
|                                    (Proxy Pass, Upgrade Headers, SSL Termination)                   |
+--------------------------------------------------------+------------------------------------------+
                                                         ^                                  |
                                                         |                                  |
+--------------------------------------------------------+------------------------------------------+
|                                         BACKEND CLUSTER (Node.js / Go)                            |
|                                                                                                   |
|   +-----------------------+                    +----------------------------------------------+   |
|   | GraphQL Server        |                    | Redis Pub/Sub Extension / Adapter            |   |
|   | (subscriptions-transport |                 | (graphql-redis-subscriptions)                |   |
|   +-----------------------+                    +----------------------------------------------+   |
+---------------------------------------------------------------------------------------------------------+
                                                         ^                                  |
                                                         |                                  |
                                            Publish      |                                  | Redis Protocol (TCP)
                                            Event        |                                  | (PUBLISH / SUBSCRIBE)
                                                         v                                  v
+---------------------------------------------------------------------------------------------------------+
|                                            REDIS CLUSTER / INSTANCE                                     |
|                                     (In-Memory Message Broker & Pub/Sub Engine)                         |
+---------------------------------------------------------------------------------------------------------+

3. Perbandingan Komparatif / Analisis Pendekatan

Dalam merancang sistem komunikasi real-time, arsitek sering dihadapkan pada pilihan teknologi transport. Berikut adalah analisis komprehensif antara GraphQL Subscriptions, REST + WebSockets murni, dan Server-Sent Events (SSE).

[!TIP] Gunakan GraphQL Subscriptions jika aplikasi Anda sudah menggunakan ekosistem GraphQL secara menyeluruh dan klien memerlukan kemampuan untuk memfilter bentuk data (shape) yang diterima saat pembaruan terjadi. Gunakan SSE jika Anda hanya memerlukan aliran data satu arah (misalnya notifikasi atau live ticker) dan ingin menghindari kerumitan manajemen koneksi WebSocket di balik corporate proxy yang agresif.

4. Prasyarat Sistem & Persiapan Lingkungan

Sebelum menyelami implementasi kode, pastikan infrastruktur dan lingkungan pengembangan Anda memenuhi spesifikasi minimum berikut:

• Sistem Operasi: Ubuntu Server 22.04 LTS (atau distribusi Linux berbasis Debian/RHEL modern).
• Runtime Environment: Node.js Versi 20.x LTS (atau Go 1.22+ jika menggunakan arsitektur backend Go).
• Message Broker: Redis Server Versi 7.0+ (dikonfigurasi dengan proteksi kata sandi dan pembatasan memori).
• Web Server / Reverse Proxy: Nginx (untuk menangani SSL termination dan WebSocket connection upgrade).
• Alat Pengujian: wscat (CLI WebSocket client) dan k6 untuk load testing.

Instalasi Dependensi Dasar (Ubuntu / Linux)

Jalankan perintah berikut pada terminal untuk menyiapkan pustaka sistem dan memperbarui paket:

# Perbarui daftar paket sistem
sudo apt update && sudo apt upgrade -y

# Instal curl, git, dan build-essential
sudo apt install -y curl git build-essential ufw

# Instal Node.js 20.x LTS melalui NodeSource repository
curl -fsSL https://deb.nodesource.com/setup_20.x | sudo -E bash -
sudo apt install -y nodejs

# Verifikasi instalasi Node dan npm
node -v && npm -v

# Instal Redis Server
sudo apt install -y redis-server

# Verifikasi status layanan Redis
sudo systemctl status redis-server

Konfigurasi Keamanan Redis (/etc/redis/redis.conf)

Pastikan Redis dikonfigurasi dengan aman untuk lingkungan produksi:

# Batasi akses hanya ke localhost atau IP internal private network
bind 127.0.0.1 ::1

# Ubah port default jika diperlukan (opsional)
port 6379

# Aktifkan autentikasi kata sandi yang kuat
requirepass YourSuperSecureRedisPasswordHere2024!

# Batasi penggunaan memori maksimal untuk mencegah Out-Of-Memory (OOM) killer
maxmemory 512mb
maxmemory-policy allkeys-lru

Setelah mengubah konfigurasi, restart layanan Redis:

sudo systemctl restart redis-server

5. Panduan Implementasi Langkah demi Langkah

Kita akan membangun sebuah server GraphQL berbasis Node.js menggunakan kerangka kerja modern: Apollo Server 4, GraphQL Subscriptions (graphql-ws), Redis Pub/Sub (ioredis dan graphql-redis-subscriptions), dan Express.js.

Langkah 1: Inisialisasi Proyek dan Instalasi Paket

Buat direktori baru, inisialisasi proyek Node.js, dan instal dependensi yang diperlukan secara lengkap.

mkdir graphql-redis-realtime
cd graphql-redis-realtime
npm init -y

# Instal dependensi utama produksi
npm install express graphql @apollo/server @apollo/express4 cors dotenv ioredis graphql-redis-subscriptions graphql-ws ws

# Instal devDependencies untuk proses pengembangan
npm install -D typescript @types/node @types/express @types/cors tsx

# Inisialisasi konfigurasi TypeScript
npx tsc --init

Langkah 2: Konfigurasi TypeScript (tsconfig.json)

Sesuaikan file tsconfig.json dengan konfigurasi optimal untuk backend Node.js modern:

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

Langkah 3: Kode Sumber Implementasi Lengkap

Buat struktur folder src/ dan file utama src/index.ts. Masukkan kode lengkap berikut tanpa ada placeholder:

import dotenv from 'dotenv';
dotenv.config();

import http from 'http';
import express from 'express';
import { ApolloServer } from '@apollo/server';
import { expressMiddleware } from '@apollo/server/express4';
import { ApolloServerPluginDrainHttpServer } from '@apollo/server/plugin/drainHttpServer';
import { makeExecutableSchema } from '@graphql-tools/schema';
import { WebSocketServer } from 'ws';
import { useServer } from 'graphql-ws/lib/use/ws';
import cors from 'cors';
import Redis from 'ioredis';
import { RedisPubSub } from 'graphql-redis-subscriptions';

// 1. Konfigurasi Redis Publisher & Subscriber menggunakan ioredis
const REDIS_URL = process.env.REDIS_URL || 'redis://:YourSuperSecureRedisPasswordHere2024!@127.0.0.1:6379';

const pubSubRedisClient = new Redis(REDIS_URL);
const subRedisClient = new Redis(REDIS_URL);

// Inisialisasi GraphQL Redis PubSub Adapter
const pubsub = new RedisPubSub({
  publisher: pubSubRedisClient,
  subscriber: subRedisClient,
});

const TASK_ADDED_CHANNEL = 'TASK_ADDED_CHANNEL';

// 2. Definisi Skema GraphQL (Schema Definition Language)
const typeDefs = `#graphql
  type Task {
    id: ID!
    title: String!
    status: String!
  }

  type Query {
    tasks: [Task!]!
  }

  input CreateTaskInput {
    title: String!
    status: String!
  }

  type Mutation {
    createTask(input: CreateTaskInput!): Task!
  }

  type Subscription {
    taskAdded: Task!
  }
`;

// Mock Database In-Memory untuk keperluan demonstrasi
interface TaskEntity {
  id: string;
  title: string;
  status: string;
}

const tasksDatabase: TaskEntity[] = [
  { id: '1', title: 'Inisialisasi Infrastruktur Cloud', status: 'COMPLETED' },
  { id: '2', title: 'Konfigurasi Redis Cluster', status: 'IN_PROGRESS' },
];

// 3. Definisi Resolvers
const resolvers = {
  Query: {
    tasks: () => tasksDatabase,
  },
  Mutation: {
    createTask: async (_: any, { input }: { input: { title: string; status: string } }) => {
      const newTask: TaskEntity = {
        id: String(tasksDatabase.length + 1),
        title: input.title,
        status: input.status,
      };

      tasksDatabase.push(newTask);

      // Publikasikan event ke Redis Pub/Sub
      await pubsub.publish(TASK_ADDED_CHANNEL, { taskAdded: newTask });

      return newTask;
    },
  },
  Subscription: {
    taskAdded: {
      // Menggunakan asyncIterator yang didukung oleh Redis PubSub
      subscribe: () => pubsub.asyncIterator([TASK_ADDED_CHANNEL]),
    },
  },
};

async function startServer() {
  const app = express();
  const httpServer = http.createServer(app);

  // Buat executable schema
  const schema = makeExecutableSchema({ typeDefs, resolvers });

  // Konfigurasi WebSocket Server untuk Subscriptions
  const wsServer = new WebSocketServer({
    server: httpServer,
    path: '/graphql',
  });

  // Gunakan graphql-ws untuk mengelola siklus hidup WebSocket
  const serverCleanup = useServer(
    {
      schema,
      context: async (ctx) => {
        // Di sini Anda dapat mengekstrak token dari connectionParams untuk autentikasi WebSocket
        const token = ctx.connectionParams?.authToken;
        // Contoh validasi sederhana:
        // if (!token) throw new Error('Unauthorized WebSocket connection');
        return { currentUser: { id: 'user_123', role: 'ADMIN' } };
      },
    },
    wsServer
  );

  // Konfigurasi Apollo Server dengan plugin drain http & ws
  const server = new ApolloServer({
    schema,
    plugins: [
      ApolloServerPluginDrainHttpServer({ httpServer }),
      {
        async serverWillStart() {
          return {
            async drainServer() {
              await serverCleanup.dispose();
            },
          };
        },
      },
    ],
  });

  await server.start();

  // Terapkan middleware Express
  app.use(
    '/graphql',
    cors<cors.CorsRequest>(),
    express.json(),
    expressMiddleware(server, {
      context: async ({ req }) => ({ token: req.headers.token }),
    })
  );

  const PORT = process.env.PORT || 4000;

  httpServer.listen(PORT, () => {
    console.log(`🚀 Server berjalan optimal di http://localhost:${PORT}/graphql`);
    console.log(`🔌 WebSocket Subscriptions aktif di ws://localhost:${PORT}/graphql`);
  });
}

startServer().catch((err) => {
  console.error('Gagal memulai server:', err);
  process.exit!(1);
});

Langkah 4: Konfigurasi Nginx sebagai Reverse Proxy & WebSocket Upgrade

Untuk mendeploy aplikasi ini di balik server web Nginx, buat file konfigurasi virtual host (/etc/nginx/sites-available/graphql-realtime):

map $http_upgrade $connection_upgrade {
    default upgrade;
    ''      close;
}

upstream graphql_backend {
    server 127.0.0.1:4000;
    keepalive 64;
}

server {
    listen 80;
    server_name api.example.com;

    # Redirect HTTP ke HTTPS secara otomatis (Let's Encrypt)
    return 301 https://$host$request_uri;
}

server {
    listen 443 ssl http2;
    server_name api.example.com;

    ssl_certificate /etc/letsencrypt/live/api.example.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/api.example.com/privkey.pem;
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers HIGH:!aNULL:!MD5;

    client_max_body_size 10M;

    location /graphql {
        proxy_pass http://graphql_backend;
        proxy_http_version 1.1;
        
        # Header krusial untuk WebSocket Upgrade
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection $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;
        proxy_set_header X-Forwarded-Proto $scheme;

        # Atur timeout agar koneksi WebSocket persisten tidak terputus prematur
        proxy_read_timeout 3600s;
        proxy_send_timeout 3600s;
    }
}

Aktifkan konfigurasi Nginx dan uji sintaksnya:

sudo ln -s /etc/nginx/sites-available/graphql-realtime /etc/nginx/sites-enabled/
sudo nginx -t
sudo systemctl reload nginx

6. Bedah Kode & Penjelasan Detail Baris Kunci

Mari kita bedah beberapa komponen paling krusial dari implementasi di atas untuk memahami alasan arsitektural di balik pemilihan kode tersebut:

• new Redis(REDIS_URL) Terpisah (Publisher & Subscriber): Mengapa kita membuat dua instance Redis terpisah (pubSubRedisClient dan subRedisClient)? Menurut spesifikasi klien ioredis, ketika sebuah koneksi Redis memasuki mode subscription (SUBSCRIBE atau PSUBSCRIBE), koneksi tersebut tidak dapat menjalankan perintah lain selain menerima pesan dari channel yang diikuti. Oleh karena itu, arsitektur wajib memisahkan koneksi khusus untuk menerbitkan data (publisher) dan mendengarkan data (subscriber).
• graphql-redis-subscriptions Adapter: Pustaka ini menjembatani antarmuka PubSubEngine standar Apollo dengan protokol publish/subscribe Redis. Ketika pubsub.publish() dipanggil di dalam mutasi, adapter ini mengubah objek JavaScript menjadi string JSON dan mengirimkannya ke saluran Redis yang sesuai, memastikan semua instans server yang mendengarkan saluran tersebut menerima notifikasi yang seragam.
• useServer dari graphql-ws: Kami meninggalkan pustaka usang subscriptions-transport-ws karena sudah tidak lagi dipelihara dan memiliki kerentanan memori. graphql-ws adalah implementasi resmi modern yang sepenuhnya kompatibel dengan spesifikasi graphql-transport-ws sub-protokol, mendukung penanganan koneksi ulang otomatis dan manajemen konteks autentikasi berbasis WebSocket yang aman.
• Map Variabel $http_upgrade di Nginx: Blok map Nginx di atas secara dinamis mendeteksi apakah klien meminta koneksi WebSocket (Upgrade: websocket). Jika ya, Nginx meneruskan header tersebut ke backend Node.js, memungkinkan pembuatan terowongan TCP persisten tanpa merusak lalu lintas HTTP biasa.

7. Skenario Produksi & Studi Kasus Dunia Nyata

Studi Kasus: Platform Kolaborasi Dokumen Real-Time (High Concurrency)

Bayangkan sebuah perusahaan SaaS dengan 50.000 pengguna aktif bersamaan (concurrent users) yang mengakses dokumen bersamaan. Setiap kali pengguna mengetik atau memperbarui blok data, mutasi dikirimkan ke server. Jika 5.000 pengguna berada di dalam dokumen yang sama, mutasi tersebut harus disiarkan ke 4.999 pengguna lainnya secara instan.

Strategi Skala Produksi:

1. Arsitektur Kluster Backend: Jalankan minimal 4 replica pod Node.js di dalam kontainer Docker / Kubernetes di belakang load balancer Nginx atau AWS ALB.
2. Kloning Kluster Redis (Redis Sentinel / Redis Cluster): Jangan gunakan instance Redis tunggal (single point of failure). Gunakan Redis Cluster dengan arsitektur Master-Replica untuk memastikan ketersediaan tinggi (High Availability) dan beban Pub/Sub terdistribusi dengan baik.
3. Manajemen Beban Resolver: Terapkan teknik DataLoader (pustaka Facebook untuk batching dan caching kueri) guna mencegah masalah N+1 Query ketika subscription memicu pengambilan relasi data yang mendalam.

8. Common Pitfalls, Anti-Patterns & Solusi

Berikut adalah kesalahan fatal yang sering dilakukan oleh pengembang saat membangun sistem GraphQL Subscriptions berbasis Redis:

• Anti-Pattern 1: Menggunakan satu koneksi ioredis untuk Publish dan Subscribe secara bersamaan.
  • Dampak: Aplikasi akan melempar error runtime seperti Command queue full atau This connection is closed karena klien Redis dalam mode subscriber melarang eksekusi perintah lain.
  • Solusi: Selalu inisialisasi dua instance koneksi Redis yang terpisah secara independen untuk keperluan pub dan sub.
• Anti-Pattern 2: Mengabaikan Pengaturan Keepalive pada Nginx atau Load Balancer.
  • Dampak: Koneksi WebSocket terputus secara misterius setiap 60 detik karena idle timeout dari corporate firewall atau AWS ALB.
  • Solusi: Tambahkan mekanisme heartbeat (ping/pong) di level protokol graphql-ws dan atur proxy_read_timeout 3600s pada konfigurasi Nginx.
• Anti-Pattern 3: Mengirimkan Data Sensitif secara Berlebihan melalui Payload Subscription.
  • Dampak: Mengirimkan seluruh objek profil pengguna (termasuk hash kata sandi, token internal, atau data pribadi) melalui saluran publikasi subscription.
  • Solusi: Lakukan sanitasi data secara ketat di dalam resolver subscription. Hanya kirimkan ID atau atribut minimum yang diperlukan oleh klien untuk memperbarui UI negara bagian (state).

9. Benchmark, Metrik Kinerja & Tuning Performa

Untuk memastikan sistem mampu menangani beban puncak, lakukan pengujian performa menggunakan perangkat load testing khusus WebSocket seperti k6.

Skrip Uji Beban k6 (load-test.js)

Buat file pengujian k6 untuk mensimulasikan ratusan klien yang membuka koneksi WebSocket dan mendengarkan subscription:

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

export const options = {
  stages: [
    { duration: '30s', target: 100 }, // Ramp up ke 100 pengguna
    { duration: '1m', target: 500 },  // Tahan di 500 pengguna konstan
    { duration: '20s', target: 0 },   // Ramp down
  ],
};

const GRAPHQL_WS_PROTOCOL = 'graphql-transport-ws';

export default function () {
  const url = 'ws://localhost:4000/graphql';
  
  const params = { headers: { 'Sec-WebSocket-Protocol': GRAPHQL_WS_PROTOCOL } };

  const res = ws.connect(url, params, function (socket) {
    socket.on('open', function () {
      // 1. Kirim inisialisasi koneksi protocol
      socket.send(JSON.stringify({ type: 'connection_init', payload: {} }));
    });

    socket.on('message', function (data) {
      const message = JSON.parse(data);
      if (message.type === 'connection_ack') {
        // 2. Kirim kueri subscription setelah diakui
        socket.send(
          JSON.stringify({
            id: '1',
            type: 'subscribe',
            payload: {
              query: 'subscription { taskAdded { id title status } }',
            },
          })
        );
      }
    });

    socket.setTimeout(function () {
      socket.close();
    }, 30000);
  });

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

Jalankan pengujian menggunakan perintah terminal:

k6 run load-test.js

Parameter Tuning Sistem Operasi (Sysctl)

Untuk menangani puluhan ribu koneksi TCP bersamaan (masalah C10K), sesuaikan parameter kernel Linux di /etc/sysctl.conf:

# Tingkatkan batas maksimum file descriptor terbuka
fs.file-max = 2097152

# Optimasi port lokal untuk koneksi keluar/masuk
net.ipv4.ip_local_port_range = 1024 65535

# Optimasi buffer TCP socket
net.ipv4.tcp_rmem = 4096 87380 16777216
net.ipv4.tcp_wmem = 4096 65536 16777216

# Aktifkan reuse TIME_WAIT sockets untuk koneksi cepat
net.ipv4.tcp_tw_reuse = 1

Terapkan perubahan dengan perintah:

sudo sysctl -p

10. Checklist Penerapan Produksi & Kesimpulan

Sebelum meluncurkan arsitektur GraphQL Subscriptions dan Redis Pub/Sub ke lingkungan produksi (production release), pastikan Anda telah memverifikasi daftar periksa berikut:

• Keamanan Transport: Seluruh koneksi eksternal menggunakan enkripsi TLS 1.3 (wss:// dan https://) melalui sertifikat SSL yang valid (Let's Encrypt).
• Autentikasi WebSocket: Token JWT divalidasi pada tahap connection_init sebelum koneksi WebSocket diterima sepenuhnya.
• Redudansi Redis: Menggunakan kluster Redis dengan replikasi aktif dan kebijakan proteksi kata sandi yang kuat.
• Manajemen Sumber Daya: Batas file descriptor sistem operasi (nofile) ditingkatkan pada level sistem dan konfigurasi layanan systemd (LimitNOFILE=65536).
• Pemantauan & Log: Metrik penggunaan CPU, memori, jumlah koneksi WebSocket aktif, dan latency redis pub/sub dipantau secara real-time menggunakan Prometheus dan Grafana.
• Manajemen Timeout: Konfigurasi proxy timeout pada Nginx dan heartbeat ping/pong diatur dengan benar untuk mencegah pemutusan koneksi yang tidak diinginkan.

Dengan mengikuti panduan mendalam ini, Anda kini memiliki fondasi arsitektural yang kokoh, terukur, dan aman untuk membangun aplikasi kolaboratif berkinerja tinggi yang siap menghadapi beban traffic enterprise di skala global.