UFW e Docker no Ubuntu: como fechar as portas que o Docker abre sem avisar

17/10/2026 às 22:24

Capa do post (1200×630)@1x

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 para 0.0.0.0. Use rede interna do Docker ou 127.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):

  1. Enviar o tráfego da DOCKER-USER para a chain ufw-user-forward, onde ficam as regras do ufw route.
  2. Permitir tráfego vindo de redes privadas (LAN e redes dos próprios containers).
  3. Bloquear e logar novas conexões vindas de fora para os containers, a menos que uma regra ufw route allow libere.
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
BlocoFunção
-j ufw-user-forwardAvalia primeiro suas regras ufw route allow/deny
RETURN -s 10/8, 172.16/12, 192.168/16Libera tráfego vindo de redes privadas (LAN, containers entre si)
--sport 53 ... RETURNLibera 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 finalDeixa 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/ou 10.0.0.0/8) e controle tudo via ufw route. Teste antes, porque a rede padrão do Docker usa 172.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

  1. O Docker publica portas via DNAT. O tráfego vai para FORWARD e ignora o UFW.
  2. Não desligue o iptables do Docker.
  3. Primeira linha de defesa: não publique o que não precisa (127.0.0.1: ou rede interna).
  4. Para o que precisa ser exposto: integre o UFW pela chain DOCKER-USER no /etc/ufw/after.rules.
  5. Libere com ufw route allow, usando a porta interna do container.
  6. Teste sempre de fora da sua rede.