# A porta do Docker continua aberta com o ufw | Nuvits

Fonte: [https://nuvits.net/blog/porta-do-docker-aberta-com-ufw](https://nuvits.net/blog/porta-do-docker-aberta-com-ufw)

Publicado em 2026-11-18, atualizado em 2026-11-19, por Fernando Chagas.

Uma porta publicada com `docker run -p` continua acessível de fora mesmo com o ufw ativo e uma regra `deny` nessa porta. O teste abaixo foi feito em 18/11/2026 no Ubuntu 24.04.5 LTS, com o Docker Engine 29.10.0 e o ufw 0.36.2. O pedido veio de outro namespace de rede, com origem 203.0.113.10, que não está nas faixas privadas.

A [documentação do Docker](https://docs.docker.com/engine/network/packet-filtering-firewalls/#docker-and-ufw) descreve o motivo: o Docker desvia o pacote na tabela `nat` antes das cadeias `INPUT` e `OUTPUT`, que são as que o ufw usa. A [documentação de firewall do Coolify](https://coolify.io/docs/knowledge-base/server/firewall) repete o aviso e aponta o `ufw-docker` quando a VPS não tem firewall no provedor.

## O que o teste publicou

O contêiner é o Apache oficial, tag `httpd:2.4-alpine`, digest `sha256:32bd0639bcc4917ef1fd9363a1d9dd2dd9c498565118b062a10d51e43a5c3a24`. A porta 80 do contêiner fica na porta 8088 do servidor:

```bash
sudo docker pull httpd:2.4-alpine
sudo docker run -d --name porta-teste -p 8088:80 httpd:2.4-alpine
```

O ufw ficou assim, com a 8088 explicitamente negada. A política de encaminhamento também era deny:

```bash
sudo ufw allow 22/tcp
sudo ufw default deny incoming
sudo ufw default allow outgoing
sudo ufw --force enable
sudo ufw deny 8088/tcp
sudo ufw status verbose
```

```text
Status: active
Logging: on (low)
Default: deny (incoming), allow (outgoing), deny (routed)

     To                         Action      From
     --                         ------      ----
[ 1] 22/tcp                     ALLOW IN    Anywhere
[ 2] 8088/tcp                   DENY IN     Anywhere
[ 3] 22/tcp (v6)                ALLOW IN    Anywhere (v6)
[ 4] 8088/tcp (v6)              DENY IN     Anywhere (v6)
```

## O pedido que não deveria passar

Não dá para ver esse furo com `curl` em `127.0.0.1` no próprio servidor. O pedido precisa chegar de fora. No laboratório, um namespace `wan` fez esse papel. O endereço 203.0.113.0/24 é da faixa de documentação, e o ping entre os dois lados respondeu.

```bash
sudo ip netns add wan
sudo ip link add veth-wan type veth peer name veth-host
sudo ip link set veth-wan netns wan
sudo ip addr add 203.0.113.1/24 dev veth-host
sudo ip link set veth-host up
sudo ip netns exec wan ip link set lo up
sudo ip netns exec wan ip addr add 203.0.113.10/24 dev veth-wan
sudo ip netns exec wan ip link set veth-wan up
sudo ip netns exec wan ip route add default via 203.0.113.1
```

O pedido, saindo de 203.0.113.10:

```bash
sudo ip netns exec wan curl -sS -D - -o /dev/null --max-time 8 http://203.0.113.1:8088/
```

A resposta, com o ufw ativo e a regra `DENY` na 8088:

```text
HTTP/1.1 200 OK
Server: Apache/2.4.71 (Unix)
```

Na sua VPS, o equivalente é rodar o mesmo `curl` de outro computador na internet, trocando `203.0.113.1` pelo IPv4 público.

## A correção

O `ufw-docker` grava regras na cadeia `DOCKER-USER`, que o Docker consulta antes de aceitar o encaminhamento. A cópia testada é o commit `020a8699f95592561f254d8d4ad1bb40d401dfc7`. O SHA-256 do script foi `643e56b080567c567b4aa28650196849b2a2da5dd0473fd3e5216b0886035ab0`. O README do projeto aponta para `master`; o comando abaixo trava o arquivo que este teste executou.

```bash
sudo curl -fsSL -o /usr/local/bin/ufw-docker \
  https://raw.githubusercontent.com/chaifeng/ufw-docker/020a8699f95592561f254d8d4ad1bb40d401dfc7/ufw-docker
sudo chmod 755 /usr/local/bin/ufw-docker
sha256sum /usr/local/bin/ufw-docker
sudo ufw-docker install
sudo ufw reload
```

O `install` mostrou o diff de `/etc/ufw/after.rules` e de `/etc/ufw/after6.rules`, guardou uma cópia de cada arquivo e pediu `sudo systemctl restart ufw`. O `sudo ufw reload` bastou para o bloqueio valer. O mesmo `curl` de fora passou a falhar:

```text
curl: (28) Connection timed out after 8002 milliseconds
```

Do próprio servidor, `curl http://127.0.0.1:8088/` continuou respondendo `HTTP/1.1 200 OK`. O serviço não caiu. O que fechou foi o acesso novo vindo de fora.

As regras gravadas pelo `install` devolvem cedo o tráfego com origem em `10.0.0.0/8`, `172.16.0.0/12` e `192.168.0.0/16`. Um `curl` feito de um endereço dessas faixas, ou do próprio servidor, não mostra se a internet foi bloqueada. O timeout deste teste saiu de 203.0.113.10, fora delas.

Para abrir de propósito, a regra usa a porta do contêiner. Aqui o Apache escuta 80, e o host mostra 8088. A regra é na 80:

```bash
sudo ufw route allow proto tcp from any to any port 80
```

O `ufw status numbered` passou a ter `80/tcp ALLOW FWD` e manteve `8088/tcp DENY IN`. Mesmo assim o `curl` de fora para a porta 8088 voltou a receber `HTTP/1.1 200 OK` com `Server: Apache/2.4.71 (Unix)`. O `DENY IN` na porta do host não é o que decide.

> **`ufw allow 8088/tcp` não é a regra do contêiner.** Essa regra entra na cadeia de entrada do host. O pacote publicado pelo Docker não passa por ela. O que libera é `ufw route allow` na porta que o processo escuta dentro do contêiner.

## No Coolify

O mesmo furo aparece no painel. Com o ufw ativo e sem regra para a porta 8000, `http://203.0.113.1:8000/` ainda respondia `HTTP/1.1 302 Found` para `/login`. Depois do `ufw-docker` e do `ufw reload`, esse pedido passou a estourar o tempo, igual ao Apache.

O `docker ps` mostra `0.0.0.0:8000->8080/tcp` no contêiner do Coolify. A regra que reabriu o painel foi na 8080, não na 8000:

```bash
sudo ufw route allow proto tcp from any to any port 8080
```

A resposta voltou a ser `HTTP/1.1 302 Found` para `/login`.

As portas 80 e 443 do proxy e as portas 6001 e 6002 seguem o mesmo critério: a porta do `route allow` é a do contêiner. A lista que este teste abriu, e o que cada uma respondeu, está em [Como instalar o Coolify numa VPS Ubuntu](https://nuvits.net/blog/como-instalar-coolify-vps-ubuntu).

Se a VPS tem firewall no painel do provedor, use esse firewall e deixe o ufw como segunda camada. Ele descarta o pacote antes do Docker. O guia de instalação do n8n evita o problema de outro jeito: só o Caddy publica porta, e o resto fica na rede interna do Compose. O passo a passo é [Como instalar o n8n com Docker numa VPS](https://nuvits.net/blog/como-instalar-n8n-docker-vps).

## O que conferir

- De outro computador, a porta publicada deixa de conectar depois do `ufw reload`. Timeout é bloqueio. `200` é porta aberta.
- No próprio servidor, `curl http://127.0.0.1:PORTA/` ainda pode responder 200. Isso não prova que a internet alcança a porta, nem que deixou de alcançar.
- `ufw status` mostra `ALLOW FWD` na porta do contêiner quando a liberação é a do `ufw-docker`. Um `DENY IN` na porta do host pode continuar na lista e não mudar o resultado.
- Mantenha o SSH aberto numa sessão já conectada até confirmar o acesso por outra sessão. A regra `ufw allow 22/tcp` deste teste ficou no lugar, e a sessão seguiu.

O plano ao lado cobre uma VPS em que esse Docker roda. Se você ainda vai escolher a máquina, comece por [VPS com Docker](https://nuvits.net/vps-docker).
