Panduan nftables: Konfigurasi Firewall Linux Modern untuk Server di 2026

Pendahuluan: Kenapa Harus Beralih ke nftables di 2026

Jujur, kalau kamu masih pakai iptables untuk mengelola firewall Linux di tahun 2026, sudah saatnya serius mempertimbangkan pindah ke nftables. Bukan karena iptables tiba-tiba jadi jelek — tool itu masih bekerja kok. Tapi nftables memang dirancang dari awal untuk mengatasi keterbatasan fundamental iptables, dan sekarang sudah jadi standar default di hampir semua distro Linux modern.

Debian sejak versi 10, RHEL sejak versi 8, Ubuntu sejak 20.04, Fedora sudah lama — semuanya mengadopsi nftables. Bahkan di kernel Linux terbaru, subsistem xtables (backend iptables) sudah ditandai sebagai legacy. Artinya, pengembangan aktif dan perbaikan performa sepenuhnya difokuskan ke nftables.

Saya sendiri awalnya agak malas migrasi karena sudah terlalu nyaman dengan iptables. Tapi setelah beberapa kali mengalami masalah performa di server dengan ruleset besar, akhirnya coba nftables — dan ternyata perbedaannya terasa banget.

Di artikel ini, kita bakal membahas nftables dari nol sampai production-ready. Mulai dari konsep dasar, instalasi, konfigurasi firewall server, fitur canggih seperti sets dan verdict maps, rate limiting, integrasi Fail2ban, sampai migrasi dari iptables. Semua dengan contoh yang bisa langsung kamu terapkan.

Apa Itu nftables dan Kenapa Lebih Baik dari iptables

nftables adalah framework packet filtering modern di Linux yang menggantikan empat tool terpisah sekaligus: iptables, ip6tables, arptables, dan ebtables. Dengan nftables, semua itu cukup dikelola lewat satu tool: nft. Simpel.

Perbandingan iptables vs nftables

Berikut perbandingan langsung yang menunjukkan kenapa nftables lebih unggul:

• Performa — iptables memproses rules secara linear O(n), artinya makin banyak rules makin lambat. nftables menggunakan struktur data seperti hash table dan red-black tree sehingga lookup bisa O(log n) atau bahkan O(1). Ini perbedaan yang sangat besar kalau kamu punya ratusan rules.
• Unified tool — iptables butuh tool terpisah untuk IPv4, IPv6, ARP, dan bridge. nftables? Cukup satu tool nft untuk semuanya.
• Dual-stack IPv4/IPv6 — nftables punya address family inet yang menangani IPv4 dan IPv6 sekaligus dalam satu ruleset. Nggak perlu maintain dua set rules terpisah.
• Atomicity — iptables menerapkan rules satu per satu (ada window di mana firewall-mu inkonsisten, dan ini bisa jadi masalah serius). nftables menerapkan seluruh ruleset secara atomik dalam satu transaksi.
• Sets dan Maps — nftables punya fitur built-in sets, maps, dan verdict maps yang powerful banget. Di iptables, kamu butuh modul eksternal ipset untuk fungsi serupa.
• No default chains — iptables memaksakan chain dan table default pada setiap paket meskipun kosong, yang membuang resource. nftables tidak membuat apapun secara default — kamu hanya membuat yang benar-benar dibutuhkan.

Instalasi dan Setup Awal nftables

Instalasi di Berbagai Distro

Kabar baiknya, di sebagian besar distro modern nftables sudah terinstal. Tapi kalau belum, instalasinya gampang:

# Debian/Ubuntu
sudo apt update && sudo apt install nftables -y

# RHEL/AlmaLinux/Rocky Linux
sudo dnf install nftables -y

# Arch Linux
sudo pacman -S nftables

Mengaktifkan Service nftables

Setelah instalasi, aktifkan service-nya supaya jalan otomatis saat boot:

# Aktifkan dan jalankan nftables
sudo systemctl enable nftables
sudo systemctl start nftables

# Cek status
sudo systemctl status nftables

Penting: Pastikan cuma satu firewall manager yang aktif di satu waktu. Kalau sebelumnya kamu pakai firewalld atau ufw, nonaktifkan dulu sebelum mengaktifkan nftables langsung. Ini sering jadi sumber masalah yang bikin pusing:

# Nonaktifkan firewalld (RHEL/CentOS)
sudo systemctl stop firewalld
sudo systemctl disable firewalld

# Nonaktifkan ufw (Ubuntu)
sudo ufw disable
sudo systemctl disable ufw

Memahami Arsitektur nftables: Table, Chain, dan Rule

Berbeda dengan iptables yang langsung menyediakan table dan chain default, nftables mengharuskan kamu membuat semuanya dari nol. Kedengarannya lebih ribet ya? Tapi sebenarnya justru memberi kontrol yang jauh lebih granular — kamu tahu persis apa yang ada di ruleset-mu.

Hierarki nftables

Struktur nftables mengikuti hierarki tiga level:

• Table — Container paling atas, berisi chains. Setiap table punya address family yang menentukan tipe paket yang diproses.
• Chain — Berisi rules. Chain bisa bertipe base chain (terhubung ke hook kernel) atau regular chain (dipanggil dari chain lain).
• Rule — Aturan individual yang mencocokkan paket dan menentukan aksi (accept, drop, reject, dll.).

Address Family

nftables mendukung beberapa address family:

• ip — Hanya IPv4
• ip6 — Hanya IPv6
• inet — IPv4 dan IPv6 sekaligus (ini yang paling direkomendasikan untuk firewall server)
• arp — Paket ARP
• bridge — Paket yang melewati bridge
• netdev — Paket di level ingress, sebelum masuk ke network stack

Untuk firewall server, pilih inet. Titik. Ini otomatis menangani IPv4 dan IPv6 tanpa perlu dua set rules terpisah.

Hook Points dan Priority

Base chain harus dikaitkan dengan salah satu hook point di kernel. Hook point ini menentukan kapan chain diproses dalam perjalanan paket:

• input — Paket yang ditujukan ke mesin lokal
• output — Paket yang berasal dari mesin lokal
• forward — Paket yang diteruskan (routing) melalui mesin
• prerouting — Sebelum routing decision, biasanya untuk DNAT
• postrouting — Setelah routing decision, untuk SNAT/masquerade

Konfigurasi Firewall Server: Dari Dasar hingga Production-Ready

Konfigurasi Dasar: Default Deny

Prinsip paling fundamental dalam firewall security: tolak semua, izinkan hanya yang diperlukan. Nggak ada kompromi di sini. Berikut konfigurasi dasar yang bisa kamu gunakan sebagai titik awal:

#!/usr/sbin/nft -f

# Bersihkan semua rules yang ada
flush ruleset

table inet filter {
    chain input {
        type filter hook input priority 0; policy drop;

        # Izinkan koneksi yang sudah established/related
        ct state established,related accept

        # Izinkan traffic loopback
        iif "lo" accept

        # Drop paket invalid
        ct state invalid drop

        # Izinkan ICMP (ping) dengan rate limit
        ip protocol icmp limit rate 4/second accept
        ip6 nexthdr icmpv6 limit rate 4/second accept

        # Izinkan SSH (port 22)
        tcp dport 22 accept

        # Log paket yang di-drop (opsional, untuk debugging)
        limit rate 5/minute log prefix "nftables-drop: " level info
    }

    chain forward {
        type filter hook forward priority 0; policy drop;
    }

    chain output {
        type filter hook output priority 0; policy accept;
    }
}

Simpan konfigurasi ini ke /etc/nftables.conf lalu muat dengan:

# Validasi konfigurasi tanpa menerapkan
sudo nft -c -f /etc/nftables.conf

# Terapkan konfigurasi
sudo nft -f /etc/nftables.conf

# Verifikasi rules yang aktif
sudo nft list ruleset

Konfigurasi Web Server (HTTP/HTTPS + SSH)

Untuk server yang menjalankan web service, kamu perlu buka port 80 dan 443 juga. Tapi daripada hardcode port di setiap rule, kita pakai pendekatan yang lebih elegan:

#!/usr/sbin/nft -f

flush ruleset

table inet filter {
    # Set untuk port yang diizinkan — mudah diubah tanpa edit rules
    set allowed_tcp_ports {
        type inet_service
        elements = { 22, 80, 443 }
    }

    chain input {
        type filter hook input priority 0; policy drop;

        ct state established,related accept
        iif "lo" accept
        ct state invalid drop

        # Rate limit ICMP
        ip protocol icmp limit rate 4/second accept
        ip6 nexthdr icmpv6 limit rate 4/second accept

        # Izinkan port yang ada di set
        tcp dport @allowed_tcp_ports accept

        # Log drops
        limit rate 5/minute log prefix "nftables-drop: " level info
    }

    chain forward {
        type filter hook forward priority 0; policy drop;
    }

    chain output {
        type filter hook output priority 0; policy accept;
    }
}

Perhatikan penggunaan named set allowed_tcp_ports di sini. Bagian ini menurut saya salah satu keunggulan terbesar nftables — kamu bisa menambah atau menghapus port tanpa menyentuh rule-nya sama sekali:

# Tambah port baru (misalnya port 8080)
sudo nft add element inet filter allowed_tcp_ports { 8080 }

# Hapus port
sudo nft delete element inet filter allowed_tcp_ports { 8080 }

# Lihat isi set
sudo nft list set inet filter allowed_tcp_ports

Fitur Canggih nftables: Sets, Maps, dan Verdict Maps

Named Sets untuk IP Whitelist/Blacklist

So, mari kita masuk ke fitur yang menurut saya paling powerful di nftables — sets. Kamu bisa membuat whitelist atau blacklist IP yang bisa di-update secara dinamis tanpa reload seluruh ruleset:

table inet filter {
    # Whitelist IP yang selalu diizinkan
    set trusted_ips {
        type ipv4_addr
        flags interval
        elements = {
            10.0.0.0/8,
            192.168.1.0/24,
            203.0.113.50
        }
    }

    # Blacklist IP yang diblokir
    set blocked_ips {
        type ipv4_addr
        flags interval, timeout
        timeout 24h
    }

    chain input {
        type filter hook input priority 0; policy drop;

        # Drop IP yang masuk blacklist
        ip saddr @blocked_ips drop

        # Terima semua traffic dari trusted IPs
        ip saddr @trusted_ips accept

        ct state established,related accept
        iif "lo" accept
        ct state invalid drop

        tcp dport { 22, 80, 443 } accept
    }
}

Mengelola set secara dinamis itu gampang banget:

# Tambah IP ke blacklist (otomatis expire setelah 24 jam)
sudo nft add element inet filter blocked_ips { 45.33.32.156 }

# Tambah IP ke blacklist dengan timeout custom
sudo nft add element inet filter blocked_ips { 198.51.100.0/24 timeout 48h }

# Tambah IP ke whitelist
sudo nft add element inet filter trusted_ips { 172.16.0.0/12 }

# Lihat isi set
sudo nft list set inet filter blocked_ips

Verdict Maps: Routing Keputusan Berdasarkan Data

Verdict maps (atau vmaps) memungkinkan kamu memetakan nilai tertentu ke aksi yang berbeda dalam satu rule. Ini berguna banget untuk routing traffic berdasarkan port atau protocol ke chain yang berbeda — jauh lebih rapi daripada deretan if-else rules:

table inet filter {
    chain input {
        type filter hook input priority 0; policy drop;

        ct state established,related accept
        iif "lo" accept

        # Gunakan verdict map untuk routing berdasarkan protocol
        ip protocol vmap {
            tcp : jump tcp_filter,
            udp : jump udp_filter,
            icmp : jump icmp_filter
        }
    }

    chain tcp_filter {
        tcp dport 22 accept
        tcp dport { 80, 443 } accept
        tcp dport 3306 ip saddr 10.0.0.0/8 accept
    }

    chain udp_filter {
        udp dport 53 accept
        udp dport 123 accept
    }

    chain icmp_filter {
        icmp type echo-request limit rate 4/second accept
    }
}

Kamu juga bisa bikin named verdict map yang bisa di-update tanpa mengubah rule. Ini keren kalau kamu sering perlu mengubah policy per-port:

table inet filter {
    map port_policy {
        type inet_service : verdict
        elements = {
            22 : accept,
            80 : accept,
            443 : accept,
            3306 : drop,
            5432 : drop
        }
    }

    chain input {
        type filter hook input priority 0; policy drop;
        ct state established,related accept
        iif "lo" accept
        tcp dport vmap @port_policy
    }
}

Rate Limiting dan Proteksi Anti-Brute-Force

Rate Limiting SSH per IP

Kalau kamu pernah cek auth log di server publik, kamu pasti tahu betapa agresifnya bot-bot brute-force SSH di luar sana. Serius, kadang ribuan percobaan per jam. nftables punya fitur rate limiting yang granular untuk menangani ini:

table inet filter {
    # Set dinamis untuk rate limiting SSH per IP
    set ssh_ratelimit {
        type ipv4_addr
        timeout 120s
        flags dynamic
    }

    chain input {
        type filter hook input priority 0; policy drop;

        ct state established,related accept
        iif "lo" accept
        ct state invalid drop

        # Rate limit SSH: maksimal 3 koneksi baru per menit per IP
        tcp dport 22 ct state new update @ssh_ratelimit {
            ip saddr limit rate 3/minute
        } accept

        # Drop koneksi SSH yang melebihi rate limit
        tcp dport 22 ct state new drop

        tcp dport { 80, 443 } accept
    }
}

Proteksi SYN Flood

SYN flood itu serangan DDoS klasik di mana penyerang mengirim ribuan paket SYN untuk menghabiskan resource koneksi server. Masih sangat relevan di 2026. nftables bisa membatasi ini langsung di level kernel:

chain input {
    type filter hook input priority 0; policy drop;

    ct state established,related accept
    iif "lo" accept

    # Drop paket invalid dan fragmented
    ct state invalid drop
    ip frag-off & 0x1fff != 0 drop

    # Rate limit SYN packets
    tcp flags syn limit rate 25/second burst 50 packets accept
    tcp flags syn drop

    # Rate limit koneksi baru secara keseluruhan
    ct state new limit rate 100/second burst 200 packets accept
}

Dynamic Deny List: Auto-Block Penyerang

Nah, ini yang menurut saya fitur paling keren dari nftables — kemampuan membuat deny list dinamis yang otomatis blokir IP penyerang dan menghapusnya setelah timeout tertentu. Tanpa tool tambahan apapun:

table inet filter {
    set denylist {
        type ipv4_addr
        flags dynamic, timeout
        timeout 10m
    }

    chain input {
        type filter hook input priority 0; policy drop;

        # Drop semua traffic dari IP di denylist
        ip saddr @denylist drop

        ct state established,related accept
        iif "lo" accept

        # Auto-block IP yang membuat lebih dari 20 koneksi TCP baru per menit
        ip protocol tcp ct state new limit rate over 20/minute add @denylist { ip saddr } drop

        tcp dport { 22, 80, 443 } accept
    }
}

Dengan konfigurasi ini, IP yang mencoba bikin lebih dari 20 koneksi baru per menit otomatis diblokir selama 10 menit. Setelah itu, IP tersebut otomatis dihapus dari denylist. Sederhana tapi efektif.

Membatasi Jumlah Koneksi Simultan

Selain rate limiting, kamu juga bisa membatasi jumlah koneksi simultan dari satu IP menggunakan ct count. Ini penting untuk mencegah satu IP menghabiskan semua slot koneksi server-mu:

chain input {
    type filter hook input priority 0; policy drop;

    ct state established,related accept
    iif "lo" accept

    # Maksimal 3 koneksi SSH simultan per IP
    tcp dport 22 meter ssh_connlimit {
        ip saddr ct count over 3
    } reject with tcp reset

    # Maksimal 50 koneksi HTTP simultan per IP
    tcp dport { 80, 443 } meter http_connlimit {
        ip saddr ct count over 50
    } reject with tcp reset

    tcp dport { 22, 80, 443 } accept
}

Integrasi nftables dengan Fail2ban

Fail2ban tetap jadi tool favorit banyak sysadmin untuk memblokir IP yang melakukan brute-force. Kabar baiknya, di tahun 2026 Fail2ban sudah mendukung nftables sebagai backend secara native. Jadi integrasinya cukup straightforward.

Konfigurasi Fail2ban untuk nftables

Edit file /etc/fail2ban/jail.local (buat kalau belum ada):

# /etc/fail2ban/jail.local

[DEFAULT]
# Gunakan nftables sebagai backend ban action
banaction = nftables-multiport
banaction_allports = nftables-allports
backend = systemd

# Konfigurasi ban progresif
bantime = 1h
bantime.increment = true
bantime.factor = 2
bantime.maxtime = 2w
findtime = 10m
maxretry = 5

# IP yang tidak akan pernah di-ban
ignoreip = 127.0.0.1/8 ::1 10.0.0.0/8

[sshd]
enabled = true
port = ssh
maxretry = 3
findtime = 5m
bantime = 2h

Verifikasi Integrasi

Setelah restart Fail2ban, cek apakah nftables sudah digunakan sebagai backend:

# Restart Fail2ban
sudo systemctl restart fail2ban

# Cek status jail
sudo fail2ban-client status sshd

# Lihat rules nftables yang dibuat Fail2ban
sudo nft list ruleset | grep f2b

Fail2ban secara otomatis membuat table dan chain nftables terpisah, jadi nggak akan mengganggu konfigurasi firewall utamamu. Rapi.

Konfigurasi NAT dengan nftables

Kalau server kamu berfungsi sebagai gateway atau router, nftables juga mendukung Network Address Translation secara native. Nggak perlu tool tambahan.

Source NAT (Masquerade)

table ip nat {
    chain postrouting {
        type nat hook postrouting priority 100; policy accept;

        # Masquerade traffic dari jaringan internal ke internet
        ip saddr 192.168.1.0/24 oifname "eth0" masquerade
    }
}

table inet filter {
    chain forward {
        type filter hook forward priority 0; policy drop;

        # Izinkan traffic dari LAN ke WAN
        iifname "eth1" oifname "eth0" accept

        # Izinkan return traffic
        iifname "eth0" oifname "eth1" ct state established,related accept
    }
}

Destination NAT (Port Forwarding)

table ip nat {
    chain prerouting {
        type nat hook prerouting priority -100; policy accept;

        # Forward port 8080 dari public IP ke server internal 192.168.1.100:80
        tcp dport 8080 dnat to 192.168.1.100:80
    }

    chain postrouting {
        type nat hook postrouting priority 100; policy accept;
        ip saddr 192.168.1.0/24 oifname "eth0" masquerade
    }
}

Port Forwarding dengan Maps

Kalau kamu butuh multiple port forwarding, gunakan maps supaya konfigurasi lebih bersih dan gampang dikelola (daripada punya banyak rule individual yang bikin pusing):

table ip nat {
    map port_forward {
        type inet_service : ipv4_addr . inet_service
        elements = {
            8080 : 192.168.1.100 . 80,
            8443 : 192.168.1.100 . 443,
            3389 : 192.168.1.200 . 3389
        }
    }

    chain prerouting {
        type nat hook prerouting priority -100; policy accept;
        dnat to tcp dport map @port_forward
    }
}

Migrasi dari iptables ke nftables

Kalau kamu sudah punya ruleset iptables yang kompleks, tenang — nggak perlu tulis ulang semuanya dari nol. nftables menyediakan tool migrasi resmi yang cukup membantu (walaupun hasilnya kadang perlu sedikit polesan manual).

Langkah 1: Ekspor Rules iptables

# Backup rules iptables saat ini
sudo iptables-save > ~/rules-v4.iptables
sudo ip6tables-save > ~/rules-v6.iptables

Langkah 2: Translate ke Format nftables

# Translate keseluruhan ruleset
sudo iptables-restore-translate -f ~/rules-v4.iptables > ~/rules-v4.nft
sudo ip6tables-restore-translate -f ~/rules-v6.iptables > ~/rules-v6.nft

# Atau translate rule individual
iptables-translate -A INPUT -p tcp --dport 22 -m conntrack --ctstate NEW -j ACCEPT
# Output: nft add rule ip filter INPUT tcp dport 22 ct state new counter accept

Langkah 3: Review dan Terapkan

Jangan langsung terapkan hasil translate di production ya. Review dulu:

# Review hasil translate
cat ~/rules-v4.nft

# Test di staging environment dulu
sudo nft -c -f ~/rules-v4.nft

# Kalau valid, terapkan
sudo nft -f ~/rules-v4.nft

# Verifikasi
sudo nft list ruleset

Langkah 4: Switch Default Backend

# Set nftables sebagai backend default
sudo update-alternatives --set iptables /usr/sbin/iptables-nft
sudo update-alternatives --set ip6tables /usr/sbin/ip6tables-nft

# Aktifkan service nftables
sudo systemctl enable nftables
sudo systemctl start nftables

# Nonaktifkan iptables legacy (kalau ada)
sudo systemctl disable iptables 2>/dev/null

Peringatan: Jangan pernah jalankan iptables-legacy dan nftables bersamaan. Keduanya beroperasi di subsistem Netfilter kernel dan hasilnya bakal saling bertabrakan. Selama migrasi, pilih satu backend atau gunakan layer kompatibilitas iptables-nft.

Perintah nftables yang Wajib Dikuasai

Berikut rangkuman perintah nft yang paling sering dibutuhkan sehari-hari. Saya sarankan bookmark bagian ini karena kamu bakal sering balik ke sini:

# === Melihat Konfigurasi ===
sudo nft list ruleset                        # Tampilkan semua rules
sudo nft list tables                          # Tampilkan semua tables
sudo nft list table inet filter               # Tampilkan table spesifik
sudo nft list chain inet filter input         # Tampilkan chain spesifik
sudo nft list set inet filter blocked_ips     # Tampilkan isi set

# === Mengelola Rules ===
sudo nft add rule inet filter input tcp dport 8080 accept
sudo nft insert rule inet filter input position 5 tcp dport 25 accept
sudo nft delete rule inet filter input handle 12
sudo nft -a list chain inet filter input      # Tampilkan handles

# === Mengelola Sets ===
sudo nft add element inet filter blocked_ips { 1.2.3.4 }
sudo nft delete element inet filter blocked_ips { 1.2.3.4 }

# === Operasi Bulk ===
sudo nft flush ruleset                        # Hapus SEMUA rules
sudo nft flush chain inet filter input        # Hapus rules di chain tertentu
sudo nft -f /etc/nftables.conf                # Muat ulang dari file
sudo nft -c -f /etc/nftables.conf             # Validasi tanpa menerapkan

Konfigurasi Production-Ready: Template Lengkap

Oke, ini dia yang ditunggu-tunggu. Berikut template konfigurasi nftables lengkap yang bisa langsung dipakai di server produksi. Template ini menggabungkan semua best practice yang sudah kita bahas di atas:

#!/usr/sbin/nft -f

flush ruleset

table inet filter {
    # === SETS ===
    set trusted_ips {
        type ipv4_addr
        flags interval
        elements = {
            10.0.0.0/8,
            172.16.0.0/12,
            192.168.0.0/16
        }
    }

    set blocked_ips {
        type ipv4_addr
        flags dynamic, timeout
        timeout 1h
    }

    set allowed_tcp_ports {
        type inet_service
        elements = { 22, 80, 443 }
    }

    set ssh_ratelimit {
        type ipv4_addr
        flags dynamic, timeout
        timeout 120s
    }

    # === INPUT CHAIN ===
    chain input {
        type filter hook input priority 0; policy drop;

        # Fast-track: izinkan koneksi established/related
        ct state established,related accept

        # Loopback selalu diizinkan
        iif "lo" accept

        # Drop paket invalid
        ct state invalid drop

        # Drop IP yang masuk blacklist
        ip saddr @blocked_ips counter drop

        # Izinkan semua traffic dari trusted IPs
        ip saddr @trusted_ips accept

        # Rate limit ICMP
        ip protocol icmp limit rate 4/second burst 8 packets accept
        ip6 nexthdr icmpv6 limit rate 4/second burst 8 packets accept

        # SSH: rate limit 3 koneksi baru per menit per IP
        tcp dport 22 ct state new update @ssh_ratelimit {
            ip saddr limit rate 3/minute burst 5 packets
        } accept

        # Auto-block IP yang terlalu agresif (50+ koneksi/menit)
        ip protocol tcp ct state new limit rate over 50/minute add @blocked_ips { ip saddr } counter drop

        # Izinkan port yang ada di set (selain SSH yang sudah di-handle)
        tcp dport @allowed_tcp_ports accept

        # Log drops dengan rate limit agar tidak membanjiri log
        limit rate 10/minute burst 20 packets log prefix "nftables-drop: " level info
    }

    # === FORWARD CHAIN ===
    chain forward {
        type filter hook forward priority 0; policy drop;
    }

    # === OUTPUT CHAIN ===
    chain output {
        type filter hook output priority 0; policy accept;
    }
}

Tips Troubleshooting dan Debugging

Tracing Paket

nftables punya fitur tracing bawaan yang jauh lebih baik dari iptables. Kalau kamu bingung kenapa paket tertentu di-drop (pasti pernah ngalamin), cara debug-nya begini:

# Aktifkan tracing di chain input
sudo nft insert rule inet filter input meta nftrace set 1

# Monitor trace secara real-time
sudo nft monitor trace

# Jangan lupa hapus rule trace setelah selesai debugging
sudo nft -a list chain inet filter input
# Cari handle rule trace, lalu hapus dengan:
# sudo nft delete rule inet filter input handle [nomor_handle]

Menghindari Lockout

Ini penting. Kesalahan paling fatal saat konfigurasi firewall remote adalah memblokir diri sendiri dari SSH. Percaya deh, ini bukan pengalaman yang menyenangkan (dan ya, saya pernah mengalaminya). Beberapa tips pencegahan:

# 1. Selalu validasi konfigurasi sebelum menerapkan
sudo nft -c -f /etc/nftables.conf

# 2. Gunakan "at" untuk auto-restore jika terkunci
echo "nft flush ruleset" | sudo at now + 5 minutes

# 3. Baru kemudian terapkan konfigurasi baru
sudo nft -f /etc/nftables.conf

# 4. Kalau semuanya OK, batalkan auto-restore
sudo atrm $(atq | head -1 | cut -f1)

# 5. Atau gunakan screen/tmux session yang tetap aktif
#    untuk recovery jika SSH session terputus

Trik at di atas itu penyelamat. Idenya sederhana: sebelum menerapkan rules baru, kamu jadwalkan perintah untuk menghapus semua rules 5 menit kemudian. Kalau terkunci, tinggal tunggu 5 menit dan firewall otomatis di-reset. Kalau semua lancar, batalkan jadwalnya.

FAQ: Pertanyaan yang Sering Diajukan

Apakah nftables kompatibel dengan Docker?

Docker secara default masih menggunakan iptables untuk mengelola network rules-nya. Tapi Docker sudah mendukung backend iptables-nft yang menerjemahkan perintah iptables ke nftables di belakang layar. Pastikan kamu pakai iptables-nft (bukan iptables-legacy) supaya nggak terjadi konflik. Cek dengan iptables --version — outputnya harus menunjukkan (nf_tables).

Bagaimana cara menyimpan rules nftables agar persisten setelah reboot?

Rules disimpan di file /etc/nftables.conf. Selama service nftables diaktifkan (systemctl enable nftables), file ini otomatis dimuat saat boot. Yang sering dilupakan orang: setelah mengubah rules secara live dengan perintah nft, kamu harus ekspor ke file dengan sudo nft list ruleset > /etc/nftables.conf. Kalau lupa, perubahan hilang setelah reboot.

Apakah nftables lebih cepat dari iptables untuk ruleset besar?

Ya, secara signifikan. iptables memproses rules secara linear — setiap paket dicek satu per satu dari atas ke bawah. Dengan 1000 rules, setiap paket harus melewati 1000 pengecekan. nftables pakai hash table dan red-black tree, jadi lookup bisa O(log n) atau O(1) untuk named sets. Pada ruleset besar (ribuan rules atau IP), perbedaan performanya terasa banget.

Bisakah nftables dan iptables berjalan bersamaan?

Secara teknis bisa, tapi jangan. Keduanya beroperasi di subsistem Netfilter kernel dan bakal menghasilkan ruleset yang saling bertabrakan. Selama masa transisi, gunakan layer kompatibilitas iptables-nft yang menerjemahkan syntax iptables ke nftables di belakang layar — jadi semua rules tetap dikelola satu subsistem.

Bagaimana cara monitoring rules nftables secara real-time?

Pakai sudo nft monitor untuk melihat perubahan ruleset secara real-time. Untuk melihat statistik traffic per-rule, tambahkan keyword counter pada rules yang ingin kamu monitor, lalu lihat hasilnya dengan sudo nft list ruleset. Counter akan menampilkan jumlah paket dan bytes yang match dengan setiap rule — sangat berguna buat debugging dan capacity planning.