Brandvägg och nätverksfiltrering 11 min läsningIntermediate

nftables Guide 2026: Modern brandväggskonfiguration på Linux med exempel

Komplett nftables-guide för 2026: tabeller, kedjor, sets och maps, IPv6 med inet-familjen, DDoS-mitigering, iptables-migrering och produktionsklar konfig.

Editorial TeamReviewed by Yuki Tanaka, Jun 2026
nftables Guide 2026: Linux brandvägg

Uppdaterad: 12 juni 2026

nftables är Linux-kärnans moderna ramverk för paketfiltrering, och sedan kärnversion 3.13 har det ersatt iptables som standardverktyg för brandväggar i alla större distributioner (RHEL 10, Debian 13, Ubuntu 26.04 LTS och Arch, för att nämna några). I den här guiden går jag igenom en komplett nftables-konfiguration från grunden: tabeller, kedjor, set och kartor, IPv6, hastighetsbegränsning, conntrack och migrering från iptables. Allt med körbara exempel som faktiskt fungerar på en typisk produktionsserver under 2026.

Ärligt talat, första gången jag rörde nftables på en kund-edge tyckte jag syntaxen kändes överkomplicerad. Efter två veckor ville jag aldrig tillbaka till iptables.

  • nftables ersätter iptables, ip6tables, arptables och ebtables med ett enhetligt verktyg och en virtuell maskin (nf_tables) i kärnan.
  • Familjen inet hanterar IPv4 och IPv6 i samma regelsats, så du slipper underhålla två parallella regeluppsättningar.
  • Named sets och maps gör dynamiska blocklistor, geo-IP-filtrering och fail2ban-integration drastiskt enklare än med iptables-ipset.
  • Regler sparas permanent i /etc/nftables.conf och laddas av systemd-tjänsten nftables.service vid uppstart.
  • iptables-translate och iptables-restore-translate konverterar äldre iptables-regler till nftables-syntax automatiskt.
  • I 2026 stöder nftables hårdvaruoffload på Mellanox/NVIDIA ConnectX och Intel E810 för regler i prerouting-kedjan, vilket är viktigt för 100 GbE-arbetslaster.

Vad är nftables och varför ersatte det iptables?

nftables är ett netfilter-projekt som introducerades i Linux 3.13 (2014). Det utvecklades för att lösa de strukturella problem som hade samlats i iptables under nästan två decennier: separata verktyg per protokollfamilj (iptables, ip6tables, arptables, ebtables), regelutvärdering i C-kod i kärnan, ingen atomisk regeluppdatering och svårfångad prestanda när regeltabellerna växte över några hundra rader. nftables ersätter allt detta med en enda virtuell maskin i kärnan (nf_tables) plus ett userspace-verktyg, nft.

Den största arkitektoniska skillnaden? nftables har inga fördefinierade kedjor. Du skapar tabeller och kedjor själv, vilket gör konfigurationen explicit och förutsägbar. Det är också en stor anledning till att Zero Trust-arkitektur på Linux är så mycket lättare att implementera med nftables än med iptables. Du kan modellera tjänstegränser direkt i regelsyntaxen utan parallella ipset-strukturer.

Andra viktiga fördelar: atomiska uppdateringar via nft -f, native sets och maps, expressiva uttryck (tcp dport { 80, 443 } istället för flera regler), och inbyggt JSON-utdatastöd för automation. Enligt netfilters officiella nftables-wiki är iptables fasat ut i alla större distributionsversioner som släpps efter 2024.

Installation och grundläggande struktur

På RHEL 10, Fedora 41+ och Debian 13 är nftables-paketet förinstallerat. På minimala installationer:

# RHEL/Fedora
sudo dnf install -y nftables

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

# Aktivera och starta tjänsten
sudo systemctl enable --now nftables.service

# Verifiera version (>= 1.0.9 rekommenderas)
nft --version

nftables-strukturen består av fyra nivåer: tabeller (namnrymd per adressfamilj), kedjor (sekvenser av regler med en hook-punkt), regler (matchning + åtgärd) och objekt (sets, maps, countrar, kvotor). En kedja kopplas till en netfilter-hook (prerouting, input, forward, output eller postrouting) och utvärderas när paket passerar den hookpunkten i kärnan.

Adressfamiljerna är: ip (IPv4), ip6 (IPv6), inet (båda), arp, bridge och netdev. För en servervägd, dual-stack-uppsättning är inet nästan alltid rätt val. Det innebär en regelsats istället för två synkroniserade.

Skriv din första kompletta regelsats

Nedan är en produktionsklar grundkonfiguration för en publik server som kör SSH (port 22) och HTTPS (port 443). Lägg den i /etc/nftables.conf:

#!/usr/sbin/nft -f

flush ruleset

table inet filter {
    # Tillåt vänner från trusted-nätverk
    set admin_v4 {
        type ipv4_addr
        flags interval
        elements = { 10.0.0.0/8, 192.168.50.0/24 }
    }

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

        # Tillåt etablerade och relaterade anslutningar
        ct state established,related accept
        ct state invalid drop

        # Loopback
        iif lo accept

        # ICMP/ICMPv6, nödvändigt för PMTU och felrapportering
        ip protocol icmp icmp type { echo-request, destination-unreachable, time-exceeded } accept
        ip6 nexthdr icmpv6 icmpv6 type { echo-request, destination-unreachable, packet-too-big, time-exceeded, nd-router-advert, nd-neighbor-solicit, nd-neighbor-advert } accept

        # SSH endast från admin-nätverk
        ip saddr @admin_v4 tcp dport 22 accept

        # HTTPS från valfri källa
        tcp dport 443 accept

        # Logga och slappa resten (begransa loggningen for att inte fylla disk)
        limit rate 5/minute log prefix "nft drop input: " level info
    }

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

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

Ladda och verifiera regelsatsen atomiskt:

# Syntax-kontroll utan att applicera
sudo nft -c -f /etc/nftables.conf

# Applicera atomiskt
sudo nft -f /etc/nftables.conf

# Visa aktiv regelsats
sudo nft list ruleset

# Visa endast en specifik kedja
sudo nft list chain inet filter input

Sets och maps för dynamisk filtrering

Named sets är, ärligt talat, nftables största praktiska förbättring över iptables. Ett set är en namngiven samling av element (IP-adresser, portar, gränssnitt eller kombinationer) som kan refereras i regler med @setname och uppdateras vid runtime utan att regelsatsen behöver laddas om. Det ersätter helt det externa ipset-verktyget som krävdes i iptables-eran.

Ett dynamiskt set med automatisk timeout är användbart för fail2ban-liknande blockering direkt i nftables:

table inet filter {
    set blocked {
        type ipv4_addr
        flags timeout
        timeout 1h
    }

    chain input {
        type filter hook input priority filter; policy drop;
        ip saddr @blocked drop
        # ... ovriga regler
    }
}

# Lagg till en IP-adress dynamiskt (timeout overridas till 6h)
sudo nft add element inet filter blocked '{ 203.0.113.42 timeout 6h }'

# Lista innehallet
sudo nft list set inet filter blocked

Maps är som sets, fast de kopplar nycklar till värden. Perfekt för portforwarding eller policy-baserad routing. Det här exemplet kör DNAT till två backend-servrar beroende på destinationsport:

table ip nat {
    chain prerouting {
        type nat hook prerouting priority dstnat;
        iif "eth0" tcp dport vmap {
            8080 : jump backend_a,
            8081 : jump backend_b
        }
    }
    chain backend_a { dnat to 10.0.1.10:80 }
    chain backend_b { dnat to 10.0.1.11:80 }
}

Hastighetsbegränsning och DDoS-mitigering

nftables har inbyggd ratelimit via limit-uttrycket. Ingen extra modul, inget hashlimit. Det vanligaste användningsfallet är SYN-flood-skydd och SSH-brute-force-mitigering:

table inet filter {
    chain input {
        type filter hook input priority filter; policy drop;
        ct state established,related accept

        # SYN-flood-skydd: max 25 nya TCP-anslutningar per sekund per kall-IP
        tcp flags & (syn|ack) == syn \
            meter syn_meter { ip saddr limit rate 25/second burst 50 packets } \
            accept

        # SSH brute-force: max 4 anslutningsforsok per minut per kall-IP, annars 1h-blockering
        tcp dport 22 ct state new \
            meter ssh_meter { ip saddr timeout 1h limit rate 4/minute } \
            accept
        tcp dport 22 ct state new add @blocked { ip saddr timeout 1h } drop
    }
}

Konstruktionen meter skapar implicit ett dynamiskt set per käll-IP med automatisk garbage collection, så ingen extern process behövs. Det här täcker en stor del av vad fail2ban traditionellt har gjort, med lägre overhead, eftersom matchningen sker direkt i kärnan istället för i ett userspace-script som tailar loggar. För djupare lager-7-skydd kompletterar du ändå med SSH-härdning med certifikat och FIDO2-nycklar, så att en låst port är ett extra skyddslager snarare än ditt enda försvar.

IPv6 och inet-familjen i praktiken

I 2026 är dubbla regelsatser för IPv4 och IPv6 ett antimönster. inet-familjen hanterar båda i samma tabell, och alla uttryck som inte är familjespecifika (TCP-portar, conntrack-tillstånd, mätare) fungerar identiskt. Familjespecifika uttryck använder ip- och ip6-prefix:

table inet filter {
    set trusted_v4 { type ipv4_addr; flags interval;
                     elements = { 10.0.0.0/8, 192.168.50.0/24 } }
    set trusted_v6 { type ipv6_addr; flags interval;
                     elements = { fd00::/8, 2001:db8:1::/48 } }

    chain input {
        type filter hook input priority filter; policy drop;
        ct state established,related accept
        iif lo accept

        # Tillat SSH fran betrodda natverk i bada familjer
        ip  saddr @trusted_v4 tcp dport 22 accept
        ip6 saddr @trusted_v6 tcp dport 22 accept

        # NDP, absolut nodvandigt for IPv6 (motsvarande ARP)
        ip6 nexthdr icmpv6 icmpv6 type {
            nd-router-solicit, nd-router-advert,
            nd-neighbor-solicit, nd-neighbor-advert
        } accept
    }
}

Hur konverterar jag iptables-regler till nftables?

Det enklaste sättet är verktygen iptables-translate och iptables-restore-translate, som följer med nftables-paketet. De konverterar iptables-syntax till motsvarande nftables-uttryck utan att applicera något:

# Oversatt en enskild regel
iptables-translate -A INPUT -p tcp --dport 22 -s 10.0.0.0/8 -j ACCEPT
# Output: add rule ip filter INPUT ip saddr 10.0.0.0/8 tcp dport 22 counter accept

# Oversatt en hel sparad regelsats
sudo iptables-save > /tmp/old-iptables.rules
iptables-restore-translate -f /tmp/old-iptables.rules > /tmp/new-nftables.conf

# Granska och justera den genererade filen, counter-keyword kan ofta tas bort,
# och regler kan slas ihop med named sets for lasbarhet

Automatöversättningen producerar funktionellt korrekt men inte idiomatisk nftables-kod. Vanliga manuella förbättringar efteråt: ersätt upprepade tcp dport N accept-rader med tcp dport { 22, 80, 443 } accept, flytta IP-listor till named sets och byt ip filter mot inet filter där det är möjligt.

Är nftables bättre än firewalld?

Frågan är, ärligt talat, felställd. firewalld använder nftables som backend sedan version 0.8 (2020). Skillnaden ligger i abstraktionsnivå: firewalld erbjuder ett zonbaserat högnivågränssnitt (publika/interna/vita zoner med fördefinierade tjänster), medan rå nftables ger dig fullt uttryckligt regelspråk.

AspektRå nftablesfirewalld
AbstraktionsnivåLåg, full kontroll över kedjor och hooksHög, zoner och fördefinierade tjänster
Konfigurationsfil/etc/nftables.confXML i /etc/firewalld/
D-Bus-APINejJa, bra för dynamisk hantering
BackendDirekt mot kärnanGenererar nftables-regler
Bäst förServer, edge, container-hostWorkstations, desktop, snabbprototyp
InlärningstidBrantareSnabb start
OverheadIngenD-Bus-tjänst alltid igång

För en produktionsserver där du vill ha versionskontrollerade, granskbara regler i ett enda filformat är rå nftables överlägset. För en arbetsstation eller en utvecklingsserver där användare ska kunna växla zoner med ett kommando är firewalld vinnaren. Båda är giltiga val. Välj efter operativ kontext, inte efter prestanda.

Felsökning, loggning och meterstatistik

När en regel inte beter sig som förväntat finns flera diagnostikvägar. Räknare kan läggas till per regel med counter-uttrycket och visar antal paket och bytes som matchat:

# Lagg till en raknare i en befintlig regel
sudo nft add rule inet filter input tcp dport 443 counter accept

# Visa raknarvarden
sudo nft list chain inet filter input

# Loggning till journald, alla droppade paket
sudo nft add rule inet filter input limit rate 10/minute \
    log prefix "[NFT-DROP] " level warn group 0 counter drop

# Granska loggade droppar
sudo journalctl -k -g 'NFT-DROP' --since '5 minutes ago'

För djup paketinspektion utan att ändra regelsatsen, använd nft monitor trace tillsammans med en meta nftrace set 1-regel. Det är nftables-motsvarigheten till iptables TRACE-target och visar exakt vilka kedjor och regler ett paket passerar. nft(8) man-sidan dokumenterar alla tillgängliga uttryck och alternativ.

För systematisk runtime-säkerhet bör du kombinera nftables med eBPF-baserad observabilitet. Vår guide till eBPF-baserad runtime-säkerhet med Falco och Tetragon visar hur du detekterar attacker som tar sig förbi brandväggen.

Vanliga frågor

Hur sparar jag nftables-regler permanent?

Skriv din regelsats till /etc/nftables.conf och aktivera systemctl enable --now nftables.service. Tjänsten kör nft -f /etc/nftables.conf vid uppstart. För att exportera den aktiva regelsatsen från en testsession: sudo nft list ruleset > /etc/nftables.conf.

Vad är skillnaden mellan tabellfamiljerna ip, ip6 och inet?

ip hanterar endast IPv4, ip6 endast IPv6, och inet båda samtidigt. Använd inet för all filterlogik som inte är familjespecifik. Det halverar antalet regler du behöver underhålla på en dual-stack-server.

Kan jag köra iptables och nftables samtidigt?

Tekniskt ja, men det rekommenderas inte. Båda använder netfilter-hooks i kärnan och kan generera oförutsägbar regelutvärderingsordning. På modern Linux är iptables-kommandot dessutom en wrapper som genererar nftables-regler i en separat tabell (ip filter), vilket gör situationen ännu mer svårfelsökt. Välj en.

Hur ser jag aktiva nftables-regler?

Använd sudo nft list ruleset för hela regelsatsen, sudo nft list table inet filter för en enskild tabell, eller sudo nft -a list ruleset för att även se regelhandtag (handles) som behövs för att radera enskilda regler med nft delete rule ... handle N.

Stöder nftables hårdvaruoffload?

Ja, sedan Linux 5.13 och vidareutvecklat i 6.x-kärnorna. Mellanox/NVIDIA ConnectX-6/7 och Intel E810 stöder offload av regler i ingress- och prerouting-kedjor med flaggan flags offload. För 100 GbE-arbetslaster är det här avgörande, eftersom programvarufiltrering på den hastigheten överskrider en enstaka CPU-kärnas kapacitet.

Om Författaren Editorial Team

Our team of expert writers and editors.