SSD Nodes Learn Hosting plans →
Guias Matt ConnorPor Matt Connor

iptables ou nftables no Ubuntu: qual está ativo?

No Ubuntu 20.10+, iptables grava regras nftables; no 20.04, usa legacy. Verifique o backend, leia o ruleset nativo e evite conflitos entre ufw e Docker.

iptables vs nftables no Ubuntu: qual está a ser usado no servidor?

No Ubuntu 20.10 e posteriores, incluindo o 22.04 LTS e todas as versões LTS seguintes, o comando iptables é um frontend que escreve regras nftables. Existe um filtro de pacotes no kernel, o nftables, e dois comandos no espaço do utilizador que o configuram. Uma linha iptables -A INPUT continua a funcionar exatamente como antes, e a regra que cria é uma regra nftables que nft pode mostrar.

O Ubuntu 20.04 é a exceção. O pacote iptables 1.8.4 estava configurado para preferir o backend legacy, e nenhuma atualização do 20.04 alterou esse comportamento. Por isso, no 20.04, iptables escreve regras x_tables antigas e iptables -V apresenta (legacy). A mudança para o backend nftables ocorreu no pacote do 20.10.

Confirme esse comportamento no seu próprio servidor antes de confiar nele.

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

No Ubuntu 24.04 (iptables 1.8.10, em outubro de 2026), iptables -V apresenta iptables v1.8.10 (nf_tables). O nome entre parênteses retos é o backend. (nf_tables) significa que o comando comunica com o nftables. (legacy) significa o antigo backend x_tables, que o Ubuntu continua a fornecer como iptables-legacy e que o kernel mantém como um conjunto de regras completamente separado. update-alternatives mostra o symlink associado a essa escolha: link currently points to /usr/sbin/iptables-nft.

Num VPS novo sem firewall configurado, sudo nft list ruleset não apresenta nada. Essa saída vazia é a referência inicial. Adicione uma regra da forma antiga e consulte novamente.

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;
  }
}

A sua regra iptables é uma regra nftables. iptables-nft identifica as tabelas que cria e nft apresenta esse aviso quando encontra essa identificação, porque editar uma tabela desse tipo com nft coloca duas ferramentas a gerir as mesmas regras. Observe o que um comando produziu: uma tabela cujo nome não definiu e chains que não pediu. Esse é o modelo antigo, e é a primeira coisa que muda quando escreve diretamente regras nftables.

O que iptables -L oculta

iptables -L mostra apenas a tabela filter. As regras de NAT (network address translation) precisam de iptables -t nat -L, e as regras de mangle precisam de -t mangle. O IPv6 usa um comando separado, ip6tables, com a sua própria cópia de cada regra. Por isso, um servidor pode parecer limpo numa listagem, enquanto algo descarta ou reescreve os seus pacotes numa tabela que não verificou.

sudo nft list ruleset imprime todas as famílias, todas as tabelas, todas as chains e todas as regras numa única saída. Num servidor que não configurou pessoalmente, esse comando é a forma mais rápida de ver o que está realmente carregado. Adicione -a para imprimir os identificadores das regras. Precisa deles para eliminar uma regra sem eliminar a chain inteira.

Vale a pena corrigir dois hábitos enquanto está aqui. iptables -L resolve endereços e portas para nomes. Num servidor com o resolver avariado, parece que o comando ficou bloqueado. Use iptables -nvL. Confirme também que o backend legado está vazio com sudo iptables-legacy -nvL. Se existirem regras em ambos os backends, o kernel avalia os dois, e nenhuma das listagens mostra o quadro completo.

Tabelas e chains que cria, não que herda

O nftables começa sem nada. Não existe nenhuma tabela filter até criar uma, e a palavra filter é apenas um nome que escolheu. Uma chain só vê pacotes quando lhe atribui um tipo, um hook e uma prioridade, tornando-a numa base chain. Uma chain sem esses elementos só é alcançada por um jump ou goto explícito, pelo que não tem qualquer custo até algo saltar para ela.

A outra grande alteração é a família inet. Uma tabela inet trata IPv4 e IPv6 com as mesmas regras, eliminando toda uma classe de erros em que uma porta está fechada em iptables e completamente aberta em ip6tables. Esta diferença é suficientemente comum para ter o seu próprio modo de falha em servidores com ufw.

Este é um ruleset completo para um servidor. Deve ser colocado em /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;
  }
}

Leia a linha 2 duas vezes. flush ruleset elimina todas as tabelas do servidor, incluindo as tabelas que o ufw e o Docker criaram para si próprios. Continue a ler antes de executar isto num servidor em produção.

A primeira regra na input chain faz a maior parte do trabalho. ct state established,related accept permite a entrada das respostas às ligações que iniciou, pelo que o resto da chain só precisa de decidir sobre novas ligações. ct state invalid drop descarta os pacotes que não correspondem a nenhuma ligação conhecida nem a um início válido. Tudo o que vem depois é uma abertura explícita, e policy drop trata do restante.

Verifique o ficheiro antes de o carregar e mantenha uma segunda sessão SSH aberta enquanto o faz. policy drop, juntamente com um erro de digitação na regra SSH, bloqueia o acesso ao seu próprio servidor.

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

nft -c -f analisa o ficheiro e comunica os erros sem carregar nada. Uma análise sem erros não produz qualquer saída.

Conjuntos substituem listas longas de regras

tcp dport { 80, 443 } é um conjunto anónimo: uma regra e uma pesquisa, em vez de uma regra por porta. Um conjunto nomeado, como admin_ips, vai mais longe, porque pode alterá-lo enquanto a firewall está em execução.

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 }

Não há recarga nem renumeração de regras, e a correspondência continua a ser uma única pesquisa, quer o conjunto contenha cinco endereços ou cinquenta mil. flags interval permite que um conjunto contenha intervalos e prefixos CIDR (classless inter-domain routing), como 198.51.100.0/24. Sem essa flag, o conjunto aceita apenas endereços individuais, e o carregamento do prefixo falha.

Os conjuntos também podem fazer expirar os próprios elementos.

set banned {
  type ipv4_addr
  flags timeout
  timeout 1h
}

Com uma regra ip saddr @banned drop, cada elemento remove-se uma hora depois de ser adicionado. É assim que a ação nftables em fail2ban no Ubuntu 24.04 bloqueia um endereço: adiciona um elemento a um conjunto, não adiciona uma regra. Se as portas ainda forem um conceito novo, comece por o que é realmente uma porta no Linux.

Uma diferença apanha muitas pessoas durante uma migração. O nftables não conta os pacotes, a menos que lho peça. iptables -nvL mostra sempre contadores para todas as regras. No nftables, apenas as regras que contêm a palavra-chave counter têm contadores. Por isso, inclua counter em qualquer regra que espere depurar mais tarde.

Como os hooks e as prioridades definem a ordem

Uma base chain define um hook, que é o ponto do percurso do pacote onde é executada. prerouting é executada antes da decisão de encaminhamento. input é executada para pacotes destinados a esta máquina. forward é executada para pacotes encaminhados através dela. output é executada para pacotes originados por processos locais. postrouting é executada por último, imediatamente antes de o pacote sair.

A prioridade ordena as chains dentro de um hook, começando pelo número mais baixo. O nftables atribui nomes aos valores clássicos: raw é -300, mangle é -150, dstnat é -100, filter é 0, srcnat é 100. Escrever priority filter; equivale a escrever priority 0;.

Agora, a parte que determina se a combinação das ferramentas funciona. Todas as base chains registadas num hook são executadas pela ordem de prioridade. Um pacote aceite na sua chain não terminou o processamento: accept termina apenas essa chain, e o pacote continua para a base chain seguinte no mesmo hook. drop é final em qualquer contexto e interrompe imediatamente o processamento do pacote. Portanto, uma regra permissiva na sua tabela não pode desfazer um drop na tabela do ufw, independentemente de qual seja executada primeiro, e o seu accept não o protege de uma chain executada posteriormente.

Duas base chains no mesmo hook e com a mesma prioridade são executadas pela ordem de registo, que depende do serviço iniciado primeiro. Essa ordem pode mudar depois de um reboot. Se tiver de executar a sua própria tabela juntamente com o ufw, atribua-lhe uma prioridade distinta. Assim, a ordem fica definida em vez de depender de uma disputa.

Por que não é necessário escrever uma regra de NAT inverso?

Esta é a pergunta em que as pessoas mais erram, por isso a resposta direta é a seguinte. O rastreamento de conexões escreve a tradução inversa automaticamente. Não é necessário adicionar uma segunda regra.

Uma tabela nat que executa as duas partes da função habitual de um VPS pode ter este aspeto.

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
  }
}

Apenas o primeiro pacote de uma conexão é avaliado numa cadeia nat. Quando uma regra corresponde, o kernel guarda essa tradução na tabela de rastreamento de conexões, juntamente com a entrada da conexão. Todos os pacotes seguintes, nas duas direções, são reescritos com base na entrada guardada, sem que nenhuma regra seja lida novamente. Instale a ferramenta conntrack e consulte uma entrada ativa.

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

Leia o resultado como dois tuplos. Os primeiros quatro campos representam a conexão tal como foi enviada pelo cliente, endereçada a 203.0.113.10:8080, o seu endereço público. Os quatro campos seguintes representam a resposta que o kernel espera, já invertida e já traduzida, proveniente de 10.0.0.5:80, o backend real. Esse segundo tuplo é a regra inversa. O kernel escreveu-o quando o primeiro pacote correspondeu à regra.

Por isso, não escreva uma regra para a direção de retorno. Ela não pode corresponder, porque os pacotes de retorno pertencem a uma conexão estabelecida e nunca chegam a uma cadeia nat. Se, de alguma forma, chegassem, traduziria um pacote que o kernel já tinha corrigido.

A localização de uma reescrita resulta do mesmo mecanismo. A tradução do destino tem de ser executada em prerouting, antes da decisão de encaminhamento, porque o encaminhamento tem de ver o novo destino. Caso contrário, o pacote segue para o local errado. O tráfego que o próprio sistema gera é tratado no hook output pelo mesmo motivo. A tradução da origem, incluindo uma reescrita da porta de origem, tem de ser executada em postrouting, depois de o encaminhamento escolher a interface de saída. masquerade obtém o seu endereço a partir dessa interface, e a interface só é conhecida depois de o encaminhamento ser executado.

É por isso que uma regra como esta pertence ao fim do percurso e a nenhum outro ponto.

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

O intervalo de portas reescreve a porta de origem juntamente com o endereço de origem. Isto é necessário quando muitos clientes internos partilham um endereço público e as respetivas portas de origem entram em conflito. A resposta chega endereçada a uma porta desse intervalo, o conntrack associa-a à entrada, e a porta de origem original é reposta antes de o pacote ser entregue. Mais uma vez, não é necessária uma segunda regra.

Uma consequência prática é que alterar uma regra de NAT não move as conexões que já existem, porque a tradução dessas conexões já está guardada. Elas mantêm o comportamento antigo até as respetivas entradas expirarem. sudo conntrack -D -p tcp --dport 8080 elimina as entradas correspondentes e sudo conntrack -F elimina todas. Use o segundo comando com cuidado num sistema que faz NAT, porque são essas traduções guardadas que mantêm as conexões atuais ativas. Ao limpá-las, interrompe todas as conexões através do sistema de uma só vez.

ufw e Docker escrevem as suas próprias regras

O ufw é um frontend do iptables, que no Ubuntu 20.10 e posteriores é um frontend do nftables. Por isso, um sistema com ufw tem uma tabela ip filter cheia de cadeias chamadas ufw-before-input, ufw-user-input e assim por diante, além de uma cópia ip6 filter da mesma estrutura. Consulte-a com sudo nft list ruleset | grep ufw. Essas cadeias são geradas a partir dos ficheiros em /etc/ufw, e o ufw reload volta a escrevê-las de raiz. Por isso, uma regra iptables adicionada manualmente desaparece no próximo reload. Os conceitos básicos do ufw para um VPS explicam essa estrutura de ficheiros.

O Docker configura o firewall diretamente e não consulta o ufw. A publicação de uma porta com -p 80:80 escreve uma regra DNAT na tabela nat e uma regra de aceitação no caminho de encaminhamento. Ambas são processadas antes das cadeias de utilizador do ufw. O resultado surpreende pelo menos uma vez: o ufw deny 80 é carregado, mas o contentor continua acessível a partir da internet. A correção deve ser feita na cadeia DOCKER-USER, que o Docker deixa disponível para as suas regras. O artigo por que os contentores Docker ignoram o ufw explica o processo. Veja o que está configurado no sistema com sudo nft list ruleset | grep -i docker.

Agora releia a linha flush ruleset da configuração apresentada acima. Ela elimina todas as tabelas, incluindo as tabelas geridas por essas duas ferramentas. Num host Docker, as portas publicadas deixam de funcionar até o sudo systemctl restart docker reconstruir as cadeias. Essa linha é a causa mais comum de os administradores deixarem os próprios serviços indisponíveis ao limpar a configuração do firewall.

Regras que sobrevivem a um reboot

Nenhum dos dois conjuntos de regras é persistente por si só. O kernel esquece tudo durante o encerramento, e cada opção resolve isso com um pacote separado.

No nftables, o ficheiro /etc/nftables.conf é lido por nftables.service. O Ubuntu instala esse serviço desativado, por isso confirme o estado antes de confiar nele.

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

No iptables, o pacote é iptables-persistent. Este instala netfilter-persistent e guarda as regras em /etc/iptables/rules.v4 e /etc/iptables/rules.v6.

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

Não execute os dois. Dois ficheiros que afirmam conter o firewall vão divergir, e a última configuração carregada prevalece de uma forma que ninguém consegue prever ao ler apenas um dos ficheiros.

Existe uma armadilha relacionada ao exportar um conjunto de regras ativo. sudo nft -s list ruleset > /etc/nftables.conf captura tudo o que está carregado naquele momento, incluindo as tabelas do ufw e do Docker. Ao restaurar isso no boot, obtém uma cópia fixa das regras que essas ferramentas esperam criar sozinhas e, depois, uma segunda cópia quando elas arrancam. Exporte apenas a sua própria tabela com sudo nft -s list table inet filter. A opção -s exclui os contadores, que não pertencem a um ficheiro de configuração.

Você deve ativar o firewall nativo do VPS?

Deixe o ufw como está, a menos que precise de algo que ele não consiga expressar. O ufw cobre a tarefa habitual de um VPS: negar por padrão e manter algumas portas abertas. Substituí-lo por um conjunto de regras escrito manualmente, sem outro motivo, deixa o mesmo firewall e acrescenta mais um componente para manter.

Use o firewall nativo quando precisar de algo fora do modelo do ufw: NAT e encaminhamento de portas, conjuntos atualizados em tempo de execução, uma regra que cubra as duas famílias de endereços ou prioridades de chains escolhidas por si. Esses são motivos reais, e o ufw não consegue expressar nenhum deles.

Se optar pelo firewall nativo, faça a mudança por completo. Execute sudo ufw disable e sudo systemctl disable --now ufw, confirme com sudo nft list ruleset que as tabelas do ufw desapareceram e depois carregue o seu próprio ficheiro. Um sistema que executa o ufw e uma tabela escrita manualmente em simultâneo continua a encaminhar tráfego, mas a política ativa passa a ser a união de dois conjuntos de regras avaliados pela ordem definida pelo arranque dos serviços. Ninguém que leia apenas um dos ficheiros consegue dizer o que o sistema realmente faz.

Migrar um ruleset existente do iptables

iptables-translate converte uma regra e apresenta a forma correspondente em nftables. Não altera nada no servidor.

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 faz o mesmo para um ruleset guardado completo. Trate o resultado como um primeiro rascunho. A conversão é mecânica, por isso recupera os nomes antigos de tabelas e chains e produz dois rulesets separados, para IPv4 e IPv6. Os únicos sets produzidos são anónimos. Isto acontece quando uma regra antiga já usava -m multiport e a lista de portas é apresentada entre chavetas. Portanto, não existem sets nomeados que possa atualizar em runtime. Algumas extensões do iptables não têm qualquer tradução para nftables. Analise o resultado à procura das regras que não puderam ser convertidas e escreva-as manualmente. Reescreva tudo manualmente como uma única tabela inet e valide-a com nft -c -f antes de a aplicar num servidor em produção.

Os endereços destes exemplos pertencem aos intervalos reservados para documentação 203.0.113.0/24 e 198.51.100.0/24, e enp1s0 é um nome de interface. Obtenha os seus valores através de ip route show default e ip -br addr, em vez de copiar os meus, porque as imagens atuais do Ubuntu raramente usam eth0 como nome.

FAQ

O iptables está obsoleto no Ubuntu?

O comando não vai desaparecer e continua a funcionar no Ubuntu 24.04. O que mudou é o que acontece internamente: iptables é uma interface que escreve regras nftables através do backend iptables-nft. Verifique o seu com iptables -V, que apresenta iptables v1.8.10 (nf_tables) no 24.04. O backend antigo x_tables continua disponível como iptables-legacy e mantém um conjunto de regras completamente separado. Por isso, coloque as regras num backend e não nos dois.

Preciso de uma segunda regra para desfazer o NAT no caminho de retorno?

Não. O acompanhamento de ligações guarda a tradução quando o primeiro pacote de uma ligação corresponde a uma regra nat. Depois, todos os pacotes seguintes, em ambas as direções, são reescritos com base nessa entrada guardada. sudo conntrack -L apresenta isto como dois tuplos por ligação: a direção original e, depois, a resposta já invertida. Uma regra escrita para a direção de retorno não ajuda, porque os pacotes de retorno nunca chegam a uma cadeia nat.

Posso executar ufw e as minhas próprias regras nftables ao mesmo tempo?

Funciona, mas cria um problema. Todas as cadeias base associadas a um hook são executadas. Assim, a política ativa resulta da combinação dos dois conjuntos de regras, ordenados pela prioridade e, quando a prioridade é igual, pela ordem em que os serviços foram iniciados. Um drop em qualquer um deles é definitivo, e um accept nas suas regras não impede o outro conjunto de descartar o mesmo pacote. Escolha uma ferramenta. Se for nftables, desative primeiro o ufw e confirme que as respetivas tabelas desapareceram de sudo nft list ruleset.

Como faço para as regras nftables persistirem depois de um reboot no Ubuntu?

Coloque o conjunto de regras em /etc/nftables.conf, verifique-o com sudo nft -c -f /etc/nftables.conf e execute sudo systemctl enable --now nftables. O serviço não fica ativado por predefinição, por isso vale a pena executar systemctl is-enabled nftables uma vez. Ao gerar esse ficheiro, descarregue apenas a sua própria tabela com sudo nft -s list table inet filter, porque um dump completo de list ruleset também inclui as tabelas que o ufw e o Docker gerem por si.

Este artigo foi útil?