Socket.IO — apa itu, pustaka untuk interaksi real-time

Apa itu Socket.IO?

Socket.IO adalah pustaka JavaScript open-source untuk komunikasi dua arah berbasis peristiwa antara klien dan server. Ini dibuat pada tahun 2010 oleh pengembang Guillermo Rauch dan sejak itu menjadi standar de facto untuk aplikasi real-time di Node.js.

Tidak seperti WebSocket API native, Socket.IO menyediakan abstraksi tambahan: kamar, ruang nama, koneksi ulang otomatis, dan tipe data biner. Pustaka ini bukan implementasi terpisah dari WebSocket — ia menggunakan Engine.IO sebagai lapisan transportasi, yang pertama-tama membuat koneksi HTTP long-polling, kemudian mencoba upgrade ke WebSocket.

Menurut statistik npm (2025), lebih dari 12 juta salinan paket socket.io diunduh setiap minggu, menjadikannya salah satu pustaka paling populer di ekosistem Node.js. Socket.IO didukung di semua platform modern: browser, iOS, Android, React Native, dan aplikasi desktop.

Sejarah penciptaan dan versi

Socket.IO versi 1.0 dirilis pada tahun 2014 dan memperkenalkan konsep ruang nama (namespaces), yang memungkinkan multipleks beberapa saluran logis melalui satu koneksi TCP. Versi 2.0 (2017) menambahkan dukungan untuk data biner dan meningkatkan kinerja penguraian. Versi saat ini 4.x (2020–2025) mencakup dukungan penuh TypeScript, mode adaptasi unggulan untuk penskalaan, dan kompatibilitas mundur yang ditingkatkan.

Setiap rilis utama mempertahankan kompatibilitas mundur API — klien socket.io@2 dapat terhubung ke server socket.io@4 melalui mode kompatibilitas khusus. Ini penting untuk proyek jangka panjang di mana pembaruan sisi klien dilakukan secara bertahap.

Bagaimana Socket.IO bekerja

Arsitektur Socket.IO terdiri dari dua komponen: modul server (paket npm socket.io) dan modul klien (paket npm socket.io-client). Server bekerja di atas server HTTP(S) Node.js dan menggunakan Engine.IO untuk mengelola lapisan transportasi.

Pada koneksi pertama, klien mengirim permintaan HTTP ke server. Engine.IO merespons dan membuat koneksi long-polling. Setelah itu, klien mengirim permintaan untuk meningkatkan protokol transportasi ke WebSocket. Jika server mendukung WebSocket, peningkatan terjadi dalam sesi TCP yang sama. Jika tidak, koneksi tetap pada long-polling dan kode aplikasi tidak perlu diubah.

Menurut pengujian kinerja Socket.IO (2024), saat menggunakan WebSocket, latensi adalah 2–5 ms per transmisi pesan, sedangkan long-polling menambahkan 150–300 ms karena overhead HTTP. Pilihan transportasi transparan bagi pengembang.

Protokol Engine.IO

Engine.IO adalah lapisan transportasi tingkat rendah di mana Socket.IO dibangun. Ini bertanggung jawab untuk pembentukan koneksi, pemilihan transportasi, heartbeat (ping/pong), dan pemutusan koneksi. Jenis paket Engine.IO utama: open (inisialisasi), close (penutupan), ping/pong (pemeriksaan hidup), upgrade (perubahan transportasi), message (data).

Socket.IO membangun model peristiwanya sendiri di atas Engine.IO — dengan inilah pengembang bekerja. Setiap pesan Socket.IO dikemas dalam paket Engine.IO dengan tipe message dan pengidentifikasi unik untuk konfirmasi pengiriman.

Fitur utama Socket.IO

Socket.IO menyediakan serangkaian fitur yang tidak ada di WebSocket API native dan yang membuat pengembangan aplikasi real-time jauh lebih sederhana. Mari kita bahas yang utama.

Koneksi ulang otomatis — klien secara otomatis memulihkan koneksi saat putus dengan penundaan eksponensial (100 ms, 200 ms, 400 ms... hingga maksimum). Menurut dokumentasi Socket.IO (2024), pengaturan percobaan ulang tersedia melalui parameter reconnectionDelay dan reconnectionAttempts. Opsi ini sangat penting untuk aplikasi seluler di mana koneksi dapat terputus saat berganti jaringan.

Dukungan kamar — server dapat mengelompokkan soket ke dalam kamar dan mengirim pesan hanya kepada anggota kamar tertentu. Kamar tidak memerlukan pembuatan eksplisit — mereka dibuat saat soket pertama bergabung. Kamar diimplementasikan di tingkat proses dan tidak dibagikan antar server yang berbeda tanpa adaptor khusus.

Ruang nama — pemisahan logis saluran komunikasi pada satu koneksi. Misalnya, ruang nama /chat untuk pesan obrolan dan /notifications untuk notifikasi. Setiap ruang nama memiliki kamar, middleware, dan penangan sendiri. Ruang nama dimultipleks melalui satu koneksi TCP, menghemat sumber daya.

Konfirmasi pengiriman — saat mengirim pesan, fungsi callback dapat diberikan yang akan dipanggil ketika server mengonfirmasi penerimaan. Ini diimplementasikan melalui pengidentifikasi unik setiap paket. Mekanisme konfirmasi menjamin bahwa pesan yang sangat penting (misalnya, transaksi pembayaran) telah dikirimkan ke penerima.

Socket.IO vs WebSocket: perbandingan

Pilihan antara Socket.IO dan WebSocket native tergantung pada kebutuhan proyek. WebSocket adalah protokol standar (RFC 6455) yang didukung oleh semua browser modern. Socket.IO adalah pustaka yang menggunakan WebSocket sebagai transportasi, tetapi menambahkan fungsi tambahan.

Jika proyek memerlukan kinerja maksimal dan ukuran klien minimal — pilih WebSocket native. Jika diperlukan pengiriman yang andal, pengelompokan, dan model peristiwa — Socket.IO akan mempersingkat waktu pengembangan 2–3 kali berkat abstraksi yang siap pakai.

Menurut survei State of JS 2024, 67% pengembang aplikasi real-time lebih memilih Socket.IO karena kemudahan API dan penanganan kasus tepi bawaan (putus jaringan, koneksi ulang, data biner).

Cara menghubungkan Socket.IO di proyek

Instalasi Socket.IO memerlukan dua paket: server dan klien. Mari kita lihat konfigurasi dasar untuk proyek Node.js. Server membuat server HTTP, menginisialisasi Socket.IO, dan menangani peristiwa koneksi dan pemutusan klien.

Menurut dokumentasi Socket.IO (2024), server dapat dijalankan tanpa Express, menggunakan modul http bawaan, tetapi dalam proyek nyata biasanya Express atau Fastify digunakan untuk merutekan permintaan HTTP.

Kode server di Node.js

const express = require('express');
const http = require('http');
const Server = require('socket.io');

const app = express();
const server = http.createServer(app);
const io = new Server(server, {
    cors: { origin: '*' }
});

io.on('connection', (socket) => {
    console.log('Klien terhubung:', socket.id);

    socket.emit('welcome', { message: 'Hello from server' });

    socket.on('disconnect', () => {
        console.log('Klien terputus');
    });
});

server.listen(3000, () => {
    console.log('Server berjalan di port 3000');
});

Kode klien di browser

import { io } from 'socket.io-client';

const socket = io('http://localhost:3000', {
    transports: ['websocket', 'polling'],
    reconnectionDelay: 1000
});

socket.on('welcome', (data) => {
    console.log(data.message);
});

socket.emit('chat message', {
    user: 'Alice',
    text: 'Hello everyone!'
});

Peristiwa dan kamar di Socket.IO

Model peristiwa Socket.IO didasarkan pada peristiwa bernama. Server dan klien mengirim dan menerima pesan yang terkait dengan nama peristiwa tertentu. Payload dapat berupa string, objek JSON, atau data biner (Buffer, ArrayBuffer, Blob).

Setiap peristiwa mendukung ACK (acknowledgement) — penerusan fungsi callback yang dijalankan di sisi pengirim setelah peristiwa diproses oleh penerima. Ini memungkinkan implementasi pola request-response di atas model peristiwa. ACK hanya berfungsi jika penerima secara eksplisit memanggil callback.

Menurut dokumentasi Socket.IO (2024), ukuran maksimum satu pesan tidak boleh melebihi 1 MB untuk kinerja optimal. Pesan yang lebih besar harus dipecah menjadi fragmen atau dikirim melalui saluran terpisah.

Bekerja dengan kamar

io.on('connection', (socket) => {
    socket.join('room-1');

    socket.to('room-1').emit('user joined', {
        userId: socket.id
    });

    io.to('room-1').emit('message', {
        text: 'Broadcast to room'
    });

    socket.leave('room-1');
});

Penskalaan Socket.IO

Penskalaan horizontal Socket.IO memerlukan pemecahan masalah pembagian status antara beberapa proses server. Kamar, ruang nama, dan daftar soket yang terhubung disimpan dalam memori satu proses dan tidak terlihat oleh proses lain tanpa adaptor.

Adaptor resmi Socket.IO: redis (melalui Redis Pub/Sub), mongodb (melalui MongoDB change streams), cluster (untuk mode multiproses Node.js cluster). Adaptor bertindak sebagai broker pesan antara instance Socket.IO. Saat mengirim peristiwa ke kamar, adaptor mempublikasikannya di Redis dan semua server menerima notifikasi.

Menurut pengujian beban Socket.IO (2024), klaster dengan 4 server dengan adaptor Redis menangani hingga 400.000 koneksi simultan dengan latensi kurang dari 10 ms. Tanpa adaptor, kapasitas maksimum satu proses Node.js adalah sekitar 100.000 koneksi dengan 1 GB memori.

Konfigurasi adaptor Redis

const Server = require('socket.io');
const RedisAdapter = require('@socket.io/redis-adapter');
const Redis = require('ioredis');

const pubClient = new Redis({ host: 'localhost', port: 6379 });
const subClient = pubClient.duplicate();
const io = new Server(server);
io.adapter(RedisAdapter(pubClient, subClient));

Saat menggunakan Kubernetes atau Docker Swarm, disarankan untuk mengonfigurasi session affinity (sticky sessions) tambahan, sehingga permintaan dari klien yang sama mencapai server yang sama, jika tidak, penugasan dapat berubah setiap kali koneksi ulang.