Konsep Networking

Setiap kali kita memanggil fetch atau menjalankan server HTTP, di bawah tenda terjadi percakapan panjang antara beberapa lapisan protokol jaringan. Module seperti node:http menyembunyikan detail tersebut supaya kita bisa fokus pada URL dan body, tetapi ada kalanya kita butuh kendali penuh: membangun protokol sendiri, berbicara dengan perangkat IoT, atau sekadar memahami kenapa koneksi bisa terputus. Section Networking ini membuka kotak tersebut mulai dari module node:net untuk TCP, node:dgram untuk UDP, hingga node:dns untuk resolusi nama. Sebelum menulis kode server pertama, kita rapikan dulu kosakata dasarnya: IP, TCP, UDP, port, dan socket.

Lapisan Protokol dari Bawah ke Atas #

Komunikasi jaringan dibangun berlapis-lapis, dan setiap lapisan hanya memikul satu tanggung jawab. Lapisan paling bawah yang kita sentuh sebagai programmer aplikasi adalah IP (Internet Protocol): tugasnya membawa paket data dari satu alamat IP ke alamat IP lain. IP bekerja best-effort — paket bisa sampai, tertukar urutan, atau tidak sampai sama sekali, dan IP tidak memberi tahu kita. Di atas IP berdiri dua protokol transport yang menyediakan nomor port agar banyak program bisa berbagi satu alamat IP: TCP yang berorientasi koneksi dan andal, serta UDP yang ringan dan tanpa koneksi.

Diagram berikut memperlihatkan posisi masing-masing lapisan berikut module Node.js yang membungkusnya:

+---------------------------------------------------------+
|  Aplikasi                                                |
|  (HTTP server, chat, protokol rancangan sendiri)         |
+---------------------------------------------------------+
|  Transport: TCP atau UDP                                 |
|  module node:net            module node:dgram            |
+---------------------------------------------------------+
|  Internet: IP                                            |
|  alamat IPv4 / IPv6, perutean paket                      |
+---------------------------------------------------------+
|  Tautan fisik: ethernet, wi-fi                           |
+---------------------------------------------------------+

Ketika kita menulis net.createServer() pada chapter berikutnya, kode kita berada di baris teratas diagram: kita memakai TCP tanpa perlu menyusun segmen ACK atau checksum secara manual. Mesin TCP di sistem operasilah yang bekerja untuk kita, dan module node:net hanyalah jembatan menuju mesin tersebut.

TCP versus UDP #

Kedua protokol transport ini menawarkan kompromi yang berlawanan, jadi pilihan di antara keduanya selalu bergantung pada kebutuhan aplikasi. Tabel berikut merangkum perbedaan yang paling sering memengaruhi keputusan:

TCP cocok ketika kehilangan satu byte pun membuat data rusak — unduhan berkas, permintaan API, komunikasi basis data. UDP justru diandalkan ketika kecepatan lebih berharga daripada kelengkapan: video conference tetap nyaman ditonton walau beberapa frame tidak sampai, dan menunggu paket lama dikirim ulang hanya menambah jeda. Batas keduanya juga tidak kaku — DNS memakai UDP untuk query kecil, tetapi beralih ke TCP untuk respons berukuran besar.

Alamat IP dan Port #

Alamat IP mengidentifikasi mesin, sedangkan port mengidentifikasi program di dalam mesin tersebut. IPv4 ditulis sebagai empat angka seperti 192.168.1.10, sedangkan IPv6 memakai delapan grup heksadesimal seperti ::1. Komposisi keduanya membentuk alamat lengkap sebuah layanan, misalnya 127.0.0.1:3000. Port 0 sampai 1023 adalah well-known ports yang dicadangkan untuk layanan standar:

Nomor port di atas 1024 bebas kita pakai untuk aplikasi sendiri. Satu konvensi penting yang akan sering muncul di Section ini: listen(0) meminta sistem operasi memilih port acak yang sedang tidak dipakai (ephemeral port), sehingga contoh kode bisa dijalankan berulang tanpa bentrok dengan program lain di komputer pembaca.

Module node:net menyediakan fungsi kecil untuk memeriksa apakah sebuah string berbentuk alamat IP. Fungsi net.isIP() mengembalikan 4 untuk IPv4, 6 untuk IPv6, dan 0 jika string tersebut bukan alamat IP:

import net from 'node:net';

const kandidat = ['127.0.0.1', '::1', 'localhost'];

for (const satu of kandidat) {
  console.log(`${satu.padEnd(10)} -> net.isIP: ${net.isIP(satu)}`);
}

console.log('isIPv4:', net.isIPv4('127.0.0.1'));
console.log('isIPv6:', net.isIPv6('::1'));

Output yang Dihasilkan:

127.0.0.1  -> net.isIP: 4
::1        -> net.isIP: 6
localhost  -> net.isIP: 0
isIPv4: true
isIPv6: true

Perhatikan bahwa localhost menghasilkan 0 karena nilai tersebut adalah nama host, bukan alamat IP; penerjemahan nama menjadi alamat adalah pekerjaan DNS dan akan kita bahas pada chapter Resolusi DNS. Pemeriksaan seperti ini berguna saat memvalidasi masukan pengguna sebelum dipakai membuka koneksi.

Socket, Titik Ujung Komunikasi #

Kata socket muncul di mana-mana dalam kode jaringan, jadi kita tetapkan maknanya sejak awal: socket adalah titik ujung sebuah komunikasi, diwakili pasangan alamat IP dan port. Sebuah koneksi TCP terbentuk dari dua socket — socket server yang mendengarkan dan socket client yang memulai — dan setelah koneksi terbentuk, keduanya setara: masing-masing bisa mengirim dan menerima aliran byte. Dalam Node.js, socket tersebut direpresentasikan sebagai object net.Socket, yang sekaligus merupakan stream Duplex seperti yang kita kenal pada Section Buffers dan Streams.

Di sisi server, ada satu object tambahan bernama net.Server yang tugasnya khusus mendengarkan koneksi masuk. Object server sendiri tidak mengirim data; object server hanya menyediakan satu net.Socket baru setiap kali sebuah client berhasil terhubung. Pemisahan peran ini memungkinkan satu server menangani banyak client sekaligus.

Siklus Hidup Koneksi TCP #

Koneksi TCP hidup dalam tahapan yang jelas, dan setiap tahap punya pantulan di event Node.js. Urutan lengkapnya untuk satu koneksi:

1. Listening — server memanggil listen() dan menunggu di sebuah alamat serta port.
2. Connection establishment — client memulai jabat tangan tiga arah (SYN, SYN-ACK, ACK); setelah selesai, event 'connection' terbit di server dan 'connect' terbit di client.
3. Data transfer — kedua pihak saling mengirim aliran byte; event 'data' terbit setiap kali ada potongan data baru tiba.
4. Half-close — salah satu pihak boleh berhenti mengirim dengan end() sambil tetap menerima data dari lawannya.
5. Close — ketika kedua arah sudah ditutup, event 'close' terbit di kedua socket dan semua resource dibebaskan.

Pemahaman tahapan ini menjelaskan banyak gejala yang kelak kita temui: pesan yang tiba terpotong-potong karena TCP adalah aliran byte, atau server yang masih hidup meski semua client sudah pergi karena listen() memang tidak ikut berhenti.

Dengan peta konsep ini di tangan, kita siap turun ke kode nyata. Kompromi keandalan versus kecepatan antara TCP dan UDP akan terasa langsung begitu kita menulis program pertama: sebuah TCP server yang menerima koneksi dan menggema balik setiap byte yang dikirimkan client — itu topik Chapter Membangun TCP Server.