Memahami TCP Sockets dari Nol: Panduan Praktis

Backend engineer, DevOps, dan platform engineer seringkali bekerja dengan abstraction layer yang tinggi. Framework HTTP seperti Express, FastAPI, atau Spring Boot menyembunyikan detail socket di balik decorator dan middleware. Padahal, memahami cara kerja TCP socket dari nol adalah fondasi yang membedakan engineer yang tahu root cause dari yang sekadar copy-paste. Artikel ini berdasarkan tutorial dari iximiuz Labs dan akan membimbingmu membangun server serta client TCP sederhana menggunakan Python.

Sesuai definisi dari tutorial tersebut, TCP server adalah proses biasa yang dijalankan sistem operasi. Ia menunggu client, menerima input, menerapkan logika, dan mengirimkan output kembali. Perbedaannya adalah input dan output mengalir melalui koneksi jaringan, bukan stdin atau stdout.

Mengapa Belajar TCP Socket?

TCP tidak peduli apakah kamu mengirim HTTP request, Redis command, atau PostgreSQL query. Bagi TCP, semua itu adalah ordered stream of bytes. Artinya, HTTP server, database server, dan echo server kecil semuanya melakukan dance yang sama: create socket, bind, listen, accept, read, write, close. Memahami fondasi ini membantumu mendebbug network issue, mengoptimasi connection pooling, dan memahami protokol application-level dengan lebih baik.

Langkah 1: Membuat Server TCP Sederhana

Kita mulai dengan Python karena standard library-nya menyediakan modul socket yang langsung memapaskan Berkeley sockets API. Buat file server.py:

import socket

HOST = "127.0.0.1"
PORT = 65432

with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
    s.bind((HOST, PORT))
    s.listen()
    print(f"Server listening on {HOST}:{PORT}")
    conn, addr = s.accept()
    with conn:
        print(f"Connected by {addr}")
        while True:
            data = conn.recv(1024)
            if not data:
                break
            conn.sendall(data)

Jalankan server dengan python3 server.py. Server akan menunggu koneksi di localhost port 65432. Perhatikan pola socket(), bind(), listen(), dan accept(). Ini adalah ritual wajib setiap TCP server.

Langkah 2: Membuat Client TCP

Buat file client.py di terminal lain. Client akan menghubungi server, mengirim pesan, dan mencetak respons:

import socket

HOST = "127.0.0.1"
PORT = 65432

with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
    s.connect((HOST, PORT))
    s.sendall(b"Hello, TCP Socket!")
    data = s.recv(1024)

print(f"Received: {data.decode()}")

Jalankan client dengan python3 client.py. Kamu akan melihat pesan Hello, TCP Socket! dikembalikan oleh server. Ini adalah echo server paling sederhana. Proses connect() pada client berpasangan dengan accept() pada server.

Langkah 3: Memahami Chunking dan Stream

TCP menyediakan reliable, ordered, error-checked byte stream. Namun, data tidak dikirim sekaligus. NIC memotong data menjadi chunk kecil. Oleh karena itu, jangan pernah mengasumsikan satu send() berkorespondensi satu-for-one dengan satu recv(). Untuk protokol application-level, kamu perlu menambahkan framing: misalnya prefix length, delimiter, atau fixed-size message.

Modifikasi server untuk menambahkan prefix 4-byte length:

import struct

with conn:
    while True:
        raw_len = conn.recv(4)
        if not raw_len:
            break
        msg_len = struct.unpack("!I", raw_len)[0]
        data = conn.recv(msg_len)
        conn.sendall(raw_len + data)

Client juga perlu mengirim prefix sebelum payload:

msg = b"Hello, Framed TCP!"
s.sendall(struct.pack("!I", len(msg)) + msg)

Langkah 4: Menangani Multiple Client dengan Threading

Server sebelumnya hanya menangani satu client. Di dunia nyata, server harus concurrent. Gunakan modul threading untuk menangani setiap koneksi di thread terpisah:

import threading

def handle_client(conn, addr):
    with conn:
        while True:
            data = conn.recv(1024)
            if not data:
                break
            conn.sendall(data)

with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
    s.bind((HOST, PORT))
    s.listen()
    while True:
        conn, addr = s.accept()
        t = threading.Thread(target=handle_client, args=(conn, addr))
        t.start()

Sekarang server bisa menangani banyak client secara bersamaan. Ini adalah fondasi dari web server multithreaded. Untuk production, kamu akan menggunakan select, poll, epoll, atau async I/O. Tetapi konsep dasarnya tetap sama: satu listening socket menerima banyak client.

Langkah 5: Inspeksi dengan netstat dan tcpdump

Setelah server berjalan, verifikasi dengan tool sistem. Perintah netstat atau ss menunjukkan socket yang sedang listen:

ss -tlnp | grep 65432

Untuk melihat packet-level detail, gunakan tcpdump:

sudo tcpdump -i lo port 65432 -nn -X

Output tcpdump akan menampilkan TCP handshake (SYN, SYN-ACK, ACK), data transfer, dan connection teardown (FIN). Melihat ini secara langsung memperkuat pemahamanmu tentang three-way handshake dan state machine TCP.

Kesimpulan

TCP socket adalah fondasi yang sering diabaikan. Setelah memahami bind(), listen(), accept(), dan framing, kamu akan lebih percaya diri saat membaca dokumentasi database, mengkonfigurasi load balancer, atau mendebbug timeout. Tutorial ini diadaptasi dari How Servers Work: A Hands-On Introduction to TCP Sockets oleh Ivan Velichko. Latihan ini layak dilakukan minimal sekali dalam karir backend engineering.

Memahami TCP Sockets dari Nol: Bangun Server dan Client Sendiri