UFW e Docker no Ubuntu: como fechar as portas que o Docker abre sem avisar
17/10/2026 às 22:24

Você configura o UFW com default deny incoming, sobe um container com -p 8080:80 e acha que a porta está protegida. Ela não está. Qualquer pessoa na internet consegue acessar http://SEU_IP:8080, mesmo com o UFW ativo e sem nenhuma regra liberando a 8080.
Este artigo explica por que isso acontece, como corrigir do jeito certo e mostra exemplos reais de aplicação.
1. O problema: o Docker passa por cima do UFW
Reproduzindo
bash
sudo ufw default deny incoming
sudo ufw allow 22/tcp
sudo ufw enable
docker run -d --name teste -p 8080:80 nginx
De outra máquina:
bash
curl http://IP_DO_SERVIDOR:8080
# Retorna a página do nginx. O UFW não bloqueou.
Por que acontece
O UFW é só uma interface para o iptables. As regras dele (ufw allow ...) ficam na chain INPUT, que trata pacotes destinados ao próprio host.
Quando você publica uma porta, o Docker cria uma regra de DNAT na tabela nat (chain PREROUTING). O pacote que chega na porta 8080 tem o destino reescrito para o IP do container (ex.: 172.17.0.2:80) antes da decisão de roteamento. A partir daí, o kernel não o vê mais como destinado ao host, e sim como pacote a ser encaminhado para outra interface (docker0).
Resultado: o pacote vai para a chain FORWARD, nunca passa pela INPUT, e as regras do UFW nunca são avaliadas.
Internet ──► PREROUTING (DNAT do Docker: :8080 → 172.17.0.2:80)
│
▼
decisão de roteamento ──► FORWARD ──► container
(UFW INPUT nunca é consultado)
2. O que NÃO fazer
❌ "iptables": false no /etc/docker/daemon.json
É a "solução" mais citada, e ela quebra coisas:
- Os containers perdem acesso à internet, porque o Docker deixa de criar o MASQUERADE/NAT de saída.
- A comunicação entre redes e o port publishing param de funcionar de forma consistente.
- Você passa a manter manualmente regras que o Docker deveria gerenciar.
❌ Mexer nas chains DOCKER ou FORWARD diretamente
O Docker recria essas chains quando o serviço reinicia. Suas regras somem.
✅ O ponto de extensão oficial: a chain DOCKER-USER
O Docker cria a chain DOCKER-USER e avalia ela antes das próprias regras, sem nunca apagar o que você colocar lá. É por ela que vamos integrar o UFW.
3. Solução A (a mais simples): não publique na interface pública
Se o serviço só precisa ser acessado localmente ou por um reverse proxy no mesmo host, faça o bind em 127.0.0.1:
bash
docker run -d -p 127.0.0.1:8080:80 nginx
No Compose:
yaml
services:
app:
image: nginx
ports:
- "127.0.0.1:8080:80"
Agora a porta só existe no loopback. Não há nada a filtrar.
Regra de ouro: banco de dados, Redis, painéis administrativos e APIs internas nunca deveriam ter
ports:apontando para0.0.0.0. Use rede interna do Docker ou127.0.0.1.
A Solução A resolve muitos casos, mas não todos. Às vezes você precisa expor algo e controlar quem acessa. Para isso existe a Solução B.
4. Solução B: fazer o UFW controlar o tráfego dos containers
A ideia (baseada no projeto ufw-docker):
- Enviar o tráfego da
DOCKER-USERpara a chainufw-user-forward, onde ficam as regras doufw route. - Permitir tráfego vindo de redes privadas (LAN e redes dos próprios containers).
- Bloquear e logar novas conexões vindas de fora para os containers, a menos que uma regra
ufw route allowlibere.
4.1. Pré-requisitos
bash
sudo apt update
sudo apt install ufw
# Docker instalado pelo repositório oficial (docker-ce)
# GARANTA o SSH antes de mexer no firewall
sudo ufw allow OpenSSH
4.2. Edite o /etc/ufw/after.rules
Faça backup:
bash
sudo cp /etc/ufw/after.rules /etc/ufw/after.rules.bak
Adicione no final do arquivo, depois do COMMIT que já existe:
# BEGIN UFW AND DOCKER
*filter
:ufw-user-forward - [0:0]
:ufw-docker-logging-deny - [0:0]
:DOCKER-USER - [0:0]
-A DOCKER-USER -j ufw-user-forward
-A DOCKER-USER -j RETURN -s 10.0.0.0/8
-A DOCKER-USER -j RETURN -s 172.16.0.0/12
-A DOCKER-USER -j RETURN -s 192.168.0.0/16
-A DOCKER-USER -p udp -m udp --sport 53 --dport 1024:65535 -j RETURN
-A DOCKER-USER -j ufw-docker-logging-deny -p tcp -m tcp --tcp-flags FIN,SYN,RST,ACK SYN -d 192.168.0.0/16
-A DOCKER-USER -j ufw-docker-logging-deny -p tcp -m tcp --tcp-flags FIN,SYN,RST,ACK SYN -d 10.0.0.0/8
-A DOCKER-USER -j ufw-docker-logging-deny -p tcp -m tcp --tcp-flags FIN,SYN,RST,ACK SYN -d 172.16.0.0/12
-A DOCKER-USER -j ufw-docker-logging-deny -p udp -m udp --dport 0:32767 -d 192.168.0.0/16
-A DOCKER-USER -j ufw-docker-logging-deny -p udp -m udp --dport 0:32767 -d 10.0.0.0/8
-A DOCKER-USER -j ufw-docker-logging-deny -p udp -m udp --dport 0:32767 -d 172.16.0.0/12
-A DOCKER-USER -j RETURN
-A ufw-docker-logging-deny -m limit --limit 3/min --limit-burst 10 -j LOG --log-prefix "[UFW DOCKER BLOCK] "
-A ufw-docker-logging-deny -j DROP
COMMIT
# END UFW AND DOCKER
4.3. O que cada bloco faz
| Bloco | Função |
|---|---|
-j ufw-user-forward | Avalia primeiro suas regras ufw route allow/deny |
RETURN -s 10/8, 172.16/12, 192.168/16 | Libera tráfego vindo de redes privadas (LAN, containers entre si) |
--sport 53 ... RETURN | Libera respostas de DNS para os containers |
ufw-docker-logging-deny (TCP SYN / UDP) | Bloqueia novas conexões de origem externa para IPs dos containers |
RETURN final | Deixa passar o restante (ex.: respostas de conexões que os containers iniciaram) |
⚠️ Atenção: com essa configuração, qualquer host em rede privada (sua LAN) acessa as portas publicadas. Isso costuma ser o desejado em home lab. Em VPS ou ambiente com LAN não confiável, remova as linhas
RETURN -s 192.168.0.0/16(e/ou10.0.0.0/8) e controle tudo viaufw route. Teste antes, porque a rede padrão do Docker usa172.17.0.0/16.
4.4. Aplique
bash
sudo ufw reload
# Se as regras não aparecerem, reinicie o serviço ou o servidor:
sudo systemctl restart ufw
Confira:
bash
sudo iptables -L DOCKER-USER -n -v
Agora o mesmo curl http://IP:8080 de fora deve dar timeout.
4.5. A pegadinha mais importante: libere a porta do CONTAINER, não a do host
Lembra do DNAT? Quando o pacote chega na DOCKER-USER, o destino já foi reescrito para IP_do_container:porta_interna. Então:
bash
# Container publicado com -p 8080:80
sudo ufw route allow proto tcp from any to any port 80 # ✅ porta INTERNA (80)
sudo ufw route allow proto tcp from any to any port 8080 # ❌ não funciona
E use ufw route, não ufw allow. ufw allow vai para INPUT, que o tráfego dos containers nunca atravessa.
5. Exemplos de aplicação
Exemplo 1: Web server público (Nginx nas portas 80/443)
yaml
# docker-compose.yml
services:
web:
image: nginx:stable
ports:
- "80:80"
- "443:443"
restart: unless-stopped
bash
docker compose up -d
sudo ufw route allow proto tcp from any to any port 80
sudo ufw route allow proto tcp from any to any port 443
Exemplo 2: Painel administrativo só para o seu IP (Portainer)
yaml
services:
portainer:
image: portainer/portainer-ce:latest
ports:
- "9443:9443"
volumes:
- /var/run/docker.sock:/var/run/docker.sock
- portainer_data:/data
restart: unless-stopped
volumes:
portainer_data:
bash
# Somente o IP do administrador (exemplo: 203.0.113.10)
sudo ufw route allow proto tcp from 203.0.113.10 to any port 9443
Qualquer outro IP público leva DROP e aparece no log com [UFW DOCKER BLOCK].
Exemplo 3: Banco de dados que NUNCA deve ser exposto
O melhor firewall é não publicar a porta:
yaml
services:
app:
image: minha-app:latest
environment:
DATABASE_URL: postgres://app:senha@db:5432/app
networks: [interna, publica]
ports:
- "127.0.0.1:3000:3000"
db:
image: postgres:16
environment:
POSTGRES_USER: app
POSTGRES_PASSWORD: senha
POSTGRES_DB: app
volumes:
- pgdata:/var/lib/postgresql/data
networks: [interna]
# SEM "ports:". Só a app enxerga o banco.
networks:
interna:
internal: true # sem saída para a internet
publica:
volumes:
pgdata:
Se você precisar acessar o banco a partir do host (DBeaver via túnel SSH, por exemplo), use 127.0.0.1:5432:5432. Nunca 5432:5432.
Exemplo 4: Stack com reverse proxy, só 80/443 abertos
Só o proxy (Nginx Proxy Manager, Traefik, Caddy...) publica portas. Os apps ficam numa rede compartilhada sem ports:.
yaml
services:
proxy:
image: caddy:2
ports:
- "80:80"
- "443:443"
volumes:
- ./Caddyfile:/etc/caddy/Caddyfile
- caddy_data:/data
networks: [proxy]
blog:
image: ghost:5
networks: [proxy]
# sem ports
wiki:
image: requarks/wiki:2
networks: [proxy]
# sem ports
networks:
proxy:
volumes:
caddy_data:
bash
sudo ufw route allow proto tcp from any to any port 80
sudo ufw route allow proto tcp from any to any port 443
Uma superfície de ataque, duas regras de firewall.
Exemplo 5: Liberar a porta só para UM container específico
ufw route allow ... port 80 libera a porta 80 de qualquer container. Para ser específico, fixe o IP do container:
yaml
services:
web:
image: nginx
ports:
- "8080:80"
networks:
rede_web:
ipv4_address: 172.30.0.10
networks:
rede_web:
ipam:
config:
- subnet: 172.30.0.0/24
bash
sudo ufw route allow proto tcp from any to 172.30.0.10 port 80
Exemplo 6: Remover uma regra
bash
sudo ufw status numbered
sudo ufw delete <número>
6. Verificação e diagnóstico
bash
# Regras do UFW (as "route" aparecem como "ALLOW FWD")
sudo ufw status verbose
# Chain DOCKER-USER e contadores de pacotes
sudo iptables -L DOCKER-USER -n -v --line-numbers
# Bloqueios em tempo real
sudo journalctl -kf | grep "UFW DOCKER BLOCK"
# Teste EXTERNO (de outra máquina, fora da LAN)
nmap -Pn -p 80,443,8080,9443 IP_DO_SERVIDOR
Testar a partir do próprio servidor ou da sua LAN não vale: o tráfego local e o de redes privadas são liberados pela configuração. Use um celular no 4G, uma VPS ou um scanner online.
7. Problemas comuns
As regras não pegaram depois do ufw reload.
Reinicie com sudo systemctl restart ufw, ou o servidor. Confira com iptables -L DOCKER-USER.
Os containers perderam internet.
Verifique se não sobrou "iptables": false no /etc/docker/daemon.json. Remova e reinicie o Docker.
Liberei a porta e continua bloqueado.
Quase sempre é a pegadinha da seção 4.5: você liberou a porta do host em vez da porta interna, ou usou ufw allow em vez de ufw route allow.
IPv6.
Tudo acima cobre IPv4. Se você habilitou IPv6 no Docker, a mesma lógica precisa ir para /etc/ufw/after6.rules com os ranges IPv6 equivalentes. Se você não usa IPv6 nos containers, deixe desabilitado no Docker.
Alternativa automatizada.
O script ufw-docker aplica exatamente essas regras (ufw-docker install) e oferece comandos como ufw-docker allow <container> 80. Vale usar depois que você entendeu o que ele faz por baixo.
Resumo
- O Docker publica portas via DNAT. O tráfego vai para FORWARD e ignora o UFW.
- Não desligue o iptables do Docker.
- Primeira linha de defesa: não publique o que não precisa (
127.0.0.1:ou rede interna). - Para o que precisa ser exposto: integre o UFW pela chain
DOCKER-USERno/etc/ufw/after.rules. - Libere com
ufw route allow, usando a porta interna do container. - Teste sempre de fora da sua rede.