SSD Nodes Learn Hosting plans →
Guide Matt ConnorDi Matt Connor · Aggiornato 2026-10-13

iptables o nftables su Ubuntu: quale usa il server?

Su Ubuntu 20.04 iptables usa ancora il backend legacy, mentre dalle 20.10 scrive regole nftables. Verifica il backend e scopri i conflitti con ufw e Docker.

iptables e nftables su Ubuntu: quale dei due è in esecuzione sul server?

Su Ubuntu 20.10 e versioni successive, incluse Ubuntu 22.04 LTS e tutte le versioni LTS successive, il comando iptables è un front end che scrive regole nftables. Nel kernel è in esecuzione un solo filtro dei pacchetti, nftables, e due comandi nello spazio utente lo configurano. Una riga iptables -A INPUT continua a funzionare esattamente come prima e la regola che crea è una regola nftables che nft può visualizzare.

Ubuntu 20.04 è l'eccezione. Il pacchetto iptables 1.8.4 era configurato per preferire il back end legacy e nessun aggiornamento di Ubuntu 20.04 ha modificato questa impostazione. Di conseguenza, su Ubuntu 20.04 iptables scrive regole x_tables obsolete e iptables -V restituisce (legacy). Il passaggio al back end nftables è stato introdotto nel pacchetto di Ubuntu 20.10.

Verifica questa informazione sul tuo server prima di darla per scontata.

iptables -V
sudo update-alternatives --display iptables
sudo nft list ruleset

Su Ubuntu 24.04 (iptables 1.8.10, a ottobre 2026), iptables -V visualizza iptables v1.8.10 (nf_tables). Il nome tra parentesi quadre identifica il back end. (nf_tables) indica che il comando comunica con nftables. (legacy) indica il vecchio back end x_tables, che Ubuntu distribuisce ancora come iptables-legacy e che il kernel mantiene come ruleset completamente separato. update-alternatives visualizza il symlink alla base di questa scelta: link currently points to /usr/sbin/iptables-nft.

Su un VPS appena installato e senza firewall configurato, sudo nft list ruleset non visualizza nulla. Questo output vuoto è il tuo punto di riferimento. Aggiungi una regola nel modo tradizionale e verifica di nuovo.

sudo iptables -A INPUT -p tcp --dport 22 -j ACCEPT
sudo nft list ruleset
# Warning: table ip filter is managed by iptables-nft, do not touch!
table ip filter {
  chain INPUT {
    type filter hook input priority filter; policy accept;
    tcp dport 22 counter packets 0 bytes 0 accept
  }
  chain FORWARD {
    type filter hook forward priority filter; policy accept;
  }
  chain OUTPUT {
    type filter hook output priority filter; policy accept;
  }
}

La tua regola iptables è una regola nftables. iptables-nft identifica le tabelle che crea e nft visualizza quell'avviso quando rileva l'identificatore, perché modificare una tabella di questo tipo con nft mette due strumenti in controllo dello stesso ruleset. Verifica cosa ha prodotto un singolo comando: una tabella che non hai nominato e catene che non hai richiesto. Questo è il modello precedente ed è il primo aspetto che cambia quando scrivi direttamente regole nftables.

Cosa ti nasconde iptables -L

iptables -L mostra solo la tabella filter. Le regole NAT (network address translation) richiedono iptables -t nat -L, mentre le regole mangle richiedono -t mangle. IPv6 usa un comando separato, ip6tables, con una propria copia di ogni regola. Un server può quindi sembrare pulito in un elenco, mentre una tabella che non hai controllato elimina o modifica i pacchetti.

sudo nft list ruleset stampa ogni famiglia, ogni tabella, ogni chain e ogni regola in un unico output. Su un server che non hai configurato personalmente, questo comando è il modo più rapido per vedere cosa è realmente caricato. Aggiungi -a per stampare gli handle delle regole, necessari per eliminare una singola regola invece dell'intera chain.

Conviene correggere anche due abitudini. iptables -L risolve indirizzi e porte nei relativi nomi, quindi su un server con un resolver non funzionante può sembrare bloccato: usa iptables -nvL. Verifica inoltre che il back end legacy sia vuoto con sudo iptables-legacy -nvL, perché se esistono regole in entrambi i back end il kernel le valuta entrambe e nessuno dei due elenchi mostra il quadro completo.

Tabelle e chain create da te, non ereditate

nftables parte da una configurazione vuota. Non esiste alcuna tabella filter finché non ne crei una, e la parola filter è soltanto un nome scelto da te. Una chain riceve pacchetti solo quando le assegni un tipo, un hook e una priorità, diventando così una base chain. Una chain priva di questi elementi viene raggiunta soltanto tramite un jump o un goto esplicito, quindi non comporta alcun costo finché qualcosa non vi esegue un salto.

L'altro cambiamento importante riguarda la famiglia inet. Una tabella inet gestisce IPv4 e IPv6 con le stesse regole. Questo elimina un'intera classe di errori in cui una porta è chiusa in iptables e completamente aperta in ip6tables. Questa discrepanza è abbastanza comune da avere una modalità di errore dedicata sui server con ufw.

Di seguito è riportato un ruleset completo per il server. Va inserito in /etc/nftables.conf.

#!/usr/sbin/nft -f
flush ruleset

table inet filter {
  set admin_ips {
    type ipv4_addr
    flags interval
    elements = { 203.0.113.5, 198.51.100.0/24 }
  }

  chain input {
    type filter hook input priority filter; policy drop;
    ct state established,related accept
    ct state invalid drop
    iif lo accept
    ip protocol icmp accept
    meta l4proto ipv6-icmp accept
    tcp dport 22 ip saddr @admin_ips counter accept
    tcp dport { 80, 443 } counter accept
  }

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

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

Leggi due volte la riga 2. flush ruleset elimina tutte le tabelle presenti sul server, comprese quelle create autonomamente da ufw e Docker. Continua a leggere prima di eseguire questo comando su un server in produzione.

La prima regola della chain input svolge gran parte del lavoro. ct state established,related accept consente il ritorno delle risposte alle connessioni avviate dal server, quindi il resto della chain deve decidere soltanto cosa fare delle nuove connessioni. ct state invalid drop scarta i pacchetti che non corrispondono ad alcuna connessione nota e non rappresentano un avvio valido. Tutto ciò che segue è un'apertura esplicita, mentre policy drop gestisce il resto.

Controlla il file prima di caricarlo e mantieni aperta una seconda sessione SSH durante l'operazione. policy drop, insieme a un solo errore di battitura nella regola SSH, può impedirti di accedere al tuo server.

sudo nft -c -f /etc/nftables.conf
sudo nft -f /etc/nftables.conf
sudo nft list ruleset

nft -c -f analizza il file e segnala gli errori senza caricare alcuna regola. Se l'analisi ha esito positivo, non viene visualizzato alcun output.

I set sostituiscono lunghi elenchi di regole

tcp dport { 80, 443 } è un set anonimo: una regola e una ricerca, invece di una regola per ogni porta. Un set denominato come admin_ips offre maggiore flessibilità, perché può essere modificato mentre il firewall è in esecuzione.

sudo nft add element inet filter admin_ips { 203.0.113.9 }
sudo nft list set inet filter admin_ips
sudo nft delete element inet filter admin_ips { 203.0.113.9 }

Non servono reload né la rinumerazione delle regole, e il confronto resta una singola ricerca sia che il set contenga cinque indirizzi sia che ne contenga cinquantamila. flags interval consente a un set di contenere intervalli e prefissi CIDR (Classless Inter-Domain Routing) come 198.51.100.0/24. Senza quel flag, il set accetta soltanto indirizzi singoli e il caricamento del prefisso non riesce.

I set possono anche far scadere autonomamente i propri elementi.

set banned {
  type ipv4_addr
  flags timeout
  timeout 1h
}

Con una regola ip saddr @banned drop, ogni elemento viene rimosso un'ora dopo essere stato aggiunto. È così che l'azione nftables in fail2ban su Ubuntu 24.04 blocca un indirizzo: aggiunge un elemento a un set, non aggiunge una regola. Se le porte sono ancora un concetto nuovo, inizia da che cos'è realmente una porta in Linux.

Durante una migrazione, una differenza può creare problemi. nftables non conta i pacchetti se non glielo si chiede esplicitamente. iptables -nvL mostra sempre i contatori per ogni regola. In nftables solo le regole che contengono la parola chiave counter hanno i numeri, quindi inserisci counter in ogni regola che prevedi di dover analizzare in seguito.

Come hook e priorità determinano l'ordine

Una catena di base definisce un hook, cioè il punto del percorso dei pacchetti in cui viene eseguita. prerouting viene eseguito prima della decisione di routing. input viene eseguito per i pacchetti indirizzati a questa macchina. forward viene eseguito per i pacchetti instradati attraverso di essa. output viene eseguito per i pacchetti generati dai processi locali. postrouting viene eseguito per ultimo, subito prima che il pacchetto lasci la macchina.

La priorità ordina le catene all'interno dello stesso hook, iniziando dal numero più basso. nftables assegna un nome ai valori classici: raw è -300, mangle è -150, dstnat è -100, filter è 0, srcnat è 100. Scrivere priority filter; equivale a scrivere priority 0;.

Ora vediamo il fattore che determina se la combinazione degli strumenti funziona. Ogni catena di base registrata su un hook viene eseguita, nell'ordine definito dalla priorità. Un pacchetto accettato nella propria catena non ha terminato l'elaborazione: accept termina soltanto quella catena e il pacchetto prosegue verso la catena di base successiva dello stesso hook. drop è definitivo ovunque e interrompe immediatamente l'elaborazione del pacchetto. Di conseguenza, una regola permissiva nella propria tabella non può annullare un drop nella tabella di ufw, indipendentemente da quale delle due venga eseguita per prima, e il proprio accept non protegge da una catena eseguita successivamente.

Due catene di base sullo stesso hook con la stessa priorità vengono eseguite nell'ordine di registrazione, che dipende dal servizio avviato per primo. Questo ordine può cambiare dopo un riavvio. Se è necessario eseguire la propria tabella insieme a ufw, assegnarle una priorità distinta, in modo che l'ordine sia definito esplicitamente anziché dipendere da una condizione di gara.

Perché non c’è alcuna regola di reverse NAT da scrivere?

Questa è la domanda a cui si risponde più spesso in modo errato, quindi ecco la risposta diretta. Il connection tracking scrive automaticamente la traduzione inversa. Non occorre aggiungere una seconda regola.

Una tabella nat che gestisce entrambe le direzioni del consueto lavoro di un VPS è simile alla seguente.

table inet nat {
  chain prerouting {
    type nat hook prerouting priority dstnat; policy accept;
    iifname "enp1s0" tcp dport 8080 dnat ip to 10.0.0.5:80
  }

  chain postrouting {
    type nat hook postrouting priority srcnat; policy accept;
    ip saddr 10.0.0.0/24 oifname "enp1s0" masquerade
  }
}

Solo il primo pacchetto di una connessione viene valutato rispetto a una catena nat. Quando una regola corrisponde, il kernel salva quella traduzione nella tabella di connection tracking insieme alla voce della connessione. Ogni pacchetto successivo, in entrambe le direzioni, viene riscritto usando la voce salvata e nessuna regola viene letta di nuovo. Installa lo strumento conntrack e osserva una voce attiva.

sudo apt install -y conntrack
sudo conntrack -L -p tcp
tcp 6 431999 ESTABLISHED src=198.51.100.20 dst=203.0.113.10 sport=54321 dport=8080 src=10.0.0.5 dst=198.51.100.20 sport=80 dport=54321 [ASSURED] mark=0 use=1

Interpretala come due tuple. I primi quattro campi rappresentano la connessione così come è stata inviata dal client, indirizzata a 203.0.113.10:8080, il tuo indirizzo pubblico. I quattro campi successivi rappresentano la risposta che il kernel si aspetta, già invertita e già tradotta, proveniente da 10.0.0.5:80, il backend reale. Questa seconda tupla è la regola inversa. Il kernel l’ha scritta quando il primo pacchetto ha corrisposto alla regola.

Non scrivere quindi una regola per la direzione di ritorno. Non può corrispondere, perché i pacchetti di ritorno appartengono a una connessione già stabilita e non raggiungono mai una catena nat; se riuscissero in qualche modo a raggiungerla, tradurresti un pacchetto che il kernel ha già corretto.

La posizione in cui deve essere eseguita una riscrittura dipende dallo stesso meccanismo. La traduzione della destinazione deve essere eseguita in prerouting, prima della decisione di routing, perché il routing deve vedere la nuova destinazione; altrimenti il pacchetto viene inviato nel posto sbagliato. Il traffico generato direttamente dal sistema viene gestito nell’hook output per lo stesso motivo. La traduzione dell’origine, inclusa la riscrittura della porta sorgente, deve essere eseguita in postrouting, dopo che il routing ha scelto l’interfaccia in uscita. masquerade ricava il proprio indirizzo da quell’interfaccia, che non è nota finché il routing non è stato eseguito.

Per questo una regola come la seguente appartiene alla fine del percorso e in nessun altro punto.

ip saddr 10.0.0.0/24 oifname "enp1s0" snat ip to 203.0.113.10:20000-30000

L’intervallo di porte riscrive la porta sorgente insieme all’indirizzo sorgente. È ciò che serve quando molti client interni condividono un unico indirizzo pubblico e le rispettive porte sorgente entrano in conflitto. Una risposta arriva indirizzata a una porta compresa nell’intervallo; conntrack la associa alla voce corrispondente e la porta sorgente originale viene ripristinata prima della consegna del pacchetto. Anche in questo caso non serve una seconda regola.

Una conseguenza pratica è che la modifica di una regola NAT non sposta le connessioni già esistenti, perché la loro traduzione è già stata salvata. Queste connessioni mantengono il comportamento precedente finché le rispettive voci non scadono. sudo conntrack -D -p tcp --dport 8080 elimina le voci corrispondenti e sudo conntrack -F le elimina tutte. Usa il secondo comando con cautela su un sistema che esegue NAT, perché sono proprio le traduzioni salvate a mantenere attive le connessioni correnti; svuotarle interrompe contemporaneamente ogni connessione che attraversa il sistema.

ufw e Docker scrivono entrambi regole proprie

ufw è un front end per iptables, che su Ubuntu 20.10 e versioni successive è a sua volta un front end per nftables. Un sistema che usa ufw contiene quindi una tabella ip filter con catene denominate ufw-before-input, ufw-user-input e così via, oltre a una copia ip6 filter della stessa struttura. Verificarla con sudo nft list ruleset | grep ufw. Queste catene vengono generate dai file in /etc/ufw e ufw reload le riscrive da zero. Per questo una regola iptables aggiunta manualmente scompare al successivo ricaricamento. Le nozioni di base di ufw per un VPS descrivono questa struttura dei file.

Docker configura direttamente il firewall e non consulta ufw. La pubblicazione di una porta con -p 80:80 scrive una regola DNAT nella tabella nat e una regola di accettazione nel percorso di forwarding; entrambe vengono elaborate prima delle catene utente di ufw. Il risultato sorprende almeno una volta: ufw deny 80 viene caricato, ma il container è ancora raggiungibile da Internet. La correzione va applicata nella catena DOCKER-USER che Docker riserva alle regole dell'utente; perché i container Docker ignorano ufw spiega il funzionamento. Verificare il contenuto del sistema con sudo nft list ruleset | grep -i docker.

Ora rileggere la riga flush ruleset della configurazione precedente. Elimina ogni tabella, comprese quelle gestite da questi due strumenti. Su un host Docker, le porte pubblicate smettono di funzionare finché sudo systemctl restart docker non ricrea le catene. Questa riga è il modo più comune con cui si rendono non disponibili i propri servizi durante la pulizia della configurazione del firewall.

Regole che restano dopo un riavvio

Nessuno dei due set di regole è persistente autonomamente. Il kernel dimentica tutto durante lo spegnimento e ciascun sistema risolve il problema con un pacchetto distinto.

Per nftables, /etc/nftables.conf viene letto da nftables.service. Ubuntu distribuisce questo servizio disabilitato, quindi controllalo prima di considerarlo affidabile.

systemctl is-enabled nftables
sudo nft -c -f /etc/nftables.conf
sudo systemctl enable --now nftables

Per iptables, il pacchetto è iptables-persistent, che installa netfilter-persistent e salva in /etc/iptables/rules.v4 e /etc/iptables/rules.v6.

sudo apt install -y iptables-persistent
sudo netfilter-persistent save

Non eseguire entrambi. Due file che dichiarano entrambi di contenere il firewall finiranno per divergere e prevarrà quello caricato per ultimo, in un modo che non è possibile determinare leggendo uno dei due file.

Esiste un problema analogo nel salvare un set di regole attivo. sudo nft -s list ruleset > /etc/nftables.conf acquisisce tutto ciò che è caricato in quel momento, comprese le tabelle di ufw e Docker. Se ripristini quel contenuto all'avvio, ottieni una copia congelata delle regole che questi strumenti prevedono di creare autonomamente, poi una seconda copia quando vengono avviati. Salva soltanto la tua tabella, usando sudo nft -s list table inet filter. Il flag -s esclude i contatori, che non appartengono a un file di configurazione.

Conviene passare alla gestione nativa del firewall sul VPS?

Lascia ufw invariato, a meno che ti serva una funzione che non può esprimere. ufw copre il caso d'uso ordinario di un VPS: negazione predefinita con poche porte aperte. Sostituirlo con un ruleset scritto manualmente senza una necessità concreta ti lascia lo stesso firewall, con un ulteriore insieme di regole da mantenere.

Passa alla gestione nativa quando ciò che ti serve non rientra nel modello di ufw: NAT e port forwarding, set aggiornati durante l'esecuzione, una sola regola valida per entrambe le famiglie di indirizzi oppure priorità delle chain definite direttamente da te. Sono motivi concreti e ufw non offre un modo per esprimerli.

Se passi alla gestione nativa, completala senza lasciare configurazioni sovrapposte. Esegui sudo ufw disable e sudo systemctl disable --now ufw, verifica con sudo nft list ruleset che le relative tabelle siano state rimosse, quindi carica il tuo file. Un sistema che esegue ufw insieme a una tabella scritta manualmente continua a inoltrare il traffico, ma la policy attiva diventa l'unione di due ruleset valutati in un ordine determinato dall'avvio dei servizi. Leggendo uno solo dei due file, nessuno può stabilire quale sia il comportamento effettivo del sistema.

Migrazione di un ruleset iptables esistente

iptables-translate converte una regola e stampa la sintassi nftables corrispondente. Non modifica nulla sul server.

iptables-translate -A INPUT -p tcp --dport 22 -j ACCEPT
nft add rule ip filter INPUT tcp dport 22 counter accept

iptables-restore-translate -f /etc/iptables/rules.v4 esegue la stessa operazione su un ruleset salvato completo. Considera l'output come una prima bozza. La conversione è meccanica, quindi vengono mantenuti i vecchi nomi di tabelle e catene e vengono restituiti due ruleset separati per IPv4 e IPv6. Vengono creati solo set anonimi, quando una vecchia regola usava già -m multiport e l'elenco delle porte viene restituito tra parentesi graffe; non sono quindi disponibili set denominati da aggiornare a runtime. Alcune estensioni iptables non hanno alcuna traduzione nftables, quindi esamina l'output per individuare le regole che non è stato possibile convertire e scrivile manualmente. Riscrivilo manualmente come un'unica tabella inet, quindi verificalo con nft -c -f prima di applicarlo a un server in produzione.

Gli indirizzi di questi esempi provengono dagli intervalli riservati alla documentazione 203.0.113.0/24 e 198.51.100.0/24, mentre enp1s0 è un nome di interfaccia. Usa i valori ottenuti da ip route show default e ip -br addr invece di copiare i miei, perché nelle immagini Ubuntu attuali l'interfaccia raramente si chiama eth0.

FAQ

iptables è deprecato su Ubuntu?

Il comando non verrà rimosso e continua a funzionare su Ubuntu 24.04. È cambiato ciò che avviene internamente: iptables è un front end che scrive regole nftables tramite il back end iptables-nft. Verifica il tuo con iptables -V, che su 24.04 restituisce iptables v1.8.10 (nf_tables). Il vecchio back end x_tables viene ancora distribuito come iptables-legacy e mantiene un ruleset completamente separato. Inserisci quindi le regole in un solo back end, non in entrambi.

Serve una seconda regola per annullare il NAT al ritorno?

No. Il connection tracking memorizza la traduzione quando il primo pacchetto di una connessione corrisponde a una regola nat. Ogni pacchetto successivo, in entrambe le direzioni, viene riscritto in base a quella voce memorizzata. sudo conntrack -L mostra due tuple per ogni connessione: prima la direzione originale, poi la risposta già invertita. Una regola scritta per la direzione di ritorno non è utile, perché i pacchetti di ritorno non raggiungono mai una catena nat.

Posso eseguire ufw e le mie regole nftables contemporaneamente?

Funziona, ma introduce un problema. Viene eseguita ogni base chain associata a un hook. La policy effettiva è quindi la combinazione dei due ruleset, nell'ordine determinato dalla priorità e, a parità di priorità, dal servizio avviato per primo. Un drop in uno dei due è definitivo e un accept nel tuo ruleset non impedisce all'altro di scartare lo stesso pacchetto. Scegli un solo strumento. Se scegli nftables, disabilita prima ufw e verifica che le sue tabelle siano state rimosse con sudo nft list ruleset.

Come posso fare in modo che le regole nftables restino attive dopo un riavvio su Ubuntu?

Inserisci il ruleset in /etc/nftables.conf, verificalo con sudo nft -c -f /etc/nftables.conf, quindi esegui sudo systemctl enable --now nftables. Il servizio non è abilitato per impostazione predefinita, quindi conviene eseguire una volta systemctl is-enabled nftables. Quando generi quel file, esporta soltanto la tua tabella con sudo nft -s list table inet filter, perché un dump completo di list ruleset include anche le tabelle gestite autonomamente da ufw e Docker.

Questo articolo ti è stato utile?