> ## Content Index
> Fetch the complete content index at: https://www.azurebrasil.cloud/llms.txt
> Use this file to discover other available public pages before exploring further.

# O que o Linux faz com o pacote antes da sua aplicação saber que ele existe
- URL: https://www.azurebrasil.cloud/blog/o-que-o-linux-faz-com-o-pacote-antes-da-aplicacao/
- Published: 2026-11-18T12:00:00.000Z
- Updated: 2026-11-18T12:00:01.000Z
- Description: Nove passos dentro do kernel, da placa de rede até o TCP: sk_buff, validação do IP, netfilter, conntrack, NAT, decisão de rota e firewall. Seguindo um SYN para a porta 8080.
- Author: Bruno Brito
- Tags: networking, kubernetes

A requisição não aparece no log da API. O cliente jura que mandou. Você olha o APM, olha o log do Nginx, olha o log do container, e nada. Para a sua aplicação, aquele pacote nunca existiu.

E ela tem razão. Ele não existiu **para ela**.

Antes de qualquer `accept()`, antes de qualquer middleware, antes do primeiro byte chegar no seu código, o kernel do Linux já fez nove coisas com aquele pacote. Validou, carimbou, consultou tabelas, decidiu se o pacote era para esta máquina e passou por um firewall. Em qualquer um desses passos o pacote pode ser descartado em silêncio, e a sua aplicação nunca vai ficar sabendo.

Por muito tempo eu tratei essa parte como um cano: entra pacote de um lado, sai requisição do outro. Funciona, até o dia em que não funciona. E nesse dia o problema está exatamente no pedaço que ninguém olha.

Este post é o primeiro de uma série que sobe da placa de rede até a aplicação, um trecho por vez. Aqui o trecho é **do kernel até o TCP**.

## O pacote que vamos seguir

Vamos acompanhar um pacote só: o primeiro de uma conexão nova. Um `SYN` saindo de um cliente qualquer para a porta 8080 deste servidor.

```text
SYN · 203.0.113.7:51544 → 10.0.0.5:8080 · proto 6

```

Origem `203.0.113.7`, porta efêmera `51544`. Destino `10.0.0.5`, porta `8080`. Protocolo 6, que é TCP. Guarda essa linha, porque cada passo vai ler um pedaço dela.

Escolhi o primeiro pacote de propósito. Ele é o que dá mais trabalho para o kernel: ninguém conhece essa conexão ainda, então todas as tabelas são consultadas de verdade. Os pacotes seguintes pegam atalhos, e você vai ver onde.

O mapa é esse aí. Os passos em azul são o código de rede do kernel. Os roxos são os ganchos do **netfilter**. O âmbar no fim é o TCP. As caixas penduradas embaixo de cada passo são os desvios: cinza quando o pacote vai para outro caminho, vermelho quando ele é descartado.

Vamos lá.

## 1\. Chegou no kernel: o sk\_buff

A placa de rede recebe o quadro, copia para a memória via DMA e avisa o kernel. A partir daí, o pacote vive dentro de uma estrutura chamada **`struct sk_buff`** (todo mundo chama de skb).

O ponto importante sobre o `sk_buff` é que ele é **a mesma estrutura do começo ao fim**. O kernel não copia o pacote de camada em camada. Cada camada só ajusta ponteiros: este é o começo do cabeçalho Ethernet, este é o começo do IP, este é o começo do TCP. Quando uma camada termina, ela avança o ponteiro e passa o mesmo `sk_buff` adiante.

Na prática, é por isso que o Linux consegue empurrar milhões de pacotes por segundo numa máquina comum. Copiar dado é caro. Mexer em ponteiro é barato.

## 2\. Que protocolo é esse?

Primeira decisão. O cabeçalho Ethernet tem um campo de 2 bytes chamado **EtherType**, e é ele que diz para quem o kernel entrega o resto.

| EtherType | Protocolo | Quem recebe |
| --------- | --------- | ----------- |
| 0x0800    | IPv4      | ip\_rcv()   |
| 0x86DD    | IPv6      | ipv6\_rcv() |
| 0x0806    | ARP       | arp\_rcv()  |

O nosso pacote diz `0x0800`. Vai para `ip_rcv()`, o código do IPv4\. Se fosse IPv6 ou ARP, seguiria por outro caminho, com outras regras, e este post seria outro.

## 3\. O cabeçalho IP é válido?

Dentro de `ip_rcv()`, o kernel confere o cabeçalho IP antes de confiar em qualquer campo dele: versão 4, tamanho mínimo de 20 bytes, comprimento total coerente com o que chegou e checksum batendo.

Se alguma coisa não bate, o pacote é descartado. Sem resposta, sem ICMP, sem log. **Ninguém avisa o remetente.**

O único rastro é um contador. Se você suspeita de pacote corrompido chegando (placa com problema, cabo ruim, offload maluco), é aqui que você olha:

```bash
# Contadores de erro de cabeçalho IP e de checksum
nstat -az IpInHdrErrors IpExtInCsumErrors

# ou direto na fonte
grep '^Ip:' /proc/net/snmp

```

Se o `IpInHdrErrors` está subindo, a sua aplicação não tem nada a ver com isso. O problema está antes dela.

## 4\. Entra o netfilter: o gancho PREROUTING

Aqui está o ponto que mais confunde. Muita gente fala do **netfilter** como se fosse "o firewall" ou "um passo" do caminho. Ele não é um passo. É um **conjunto de ganchos** espalhados pelo caminho.

Em cada gancho, o kernel para e executa tudo que estiver registrado ali: regras de firewall, rastreamento de conexão, NAT, marcação de pacote. O `iptables`, o `nftables`, o conntrack, o kube-proxy e o Docker são todos clientes desses ganchos. Nenhum deles é o gancho.

No caminho de entrada, os ganchos que importam para o nosso pacote são dois:

- **PREROUTING**: antes da decisão de rota. É onde o pacote chega primeiro.
- **INPUT**: depois da decisão de rota, só para pacotes destinados a esta máquina.

Dentro do PREROUTING, as coisas rodam numa ordem fixa, definida por prioridade no kernel:

```text
PREROUTING:  raw (-300) → conntrack (-200) → mangle (-150) → nat/DNAT (-100)

```

Essa ordem não é detalhe. Ela explica por que o conntrack já sabe da conexão quando o NAT roda, e por que a tabela `raw` é o lugar para dizer "não rastreia isso aqui" (`NOTRACK`). Os próximos dois passos acontecem dentro desse gancho.

## 5\. conntrack: eu conheço essa conexão?

O **conntrack** (connection tracking) procura o pacote numa tabela, usando a tupla de origem e destino: IP de origem, porta de origem, IP de destino, porta de destino e protocolo.

Como este é o primeiro pacote, ninguém conhece. O kernel marca a conexão como **NEW** e cria uma entrada. Os próximos pacotes dessa mesma conexão vão ser encontrados ali e marcados como **ESTABLISHED**.

Um detalhe que pouca gente sabe: essa entrada nova só é confirmada na tabela quando o pacote termina o caminho (no fim do INPUT, no nosso caso). Se o firewall descartar o pacote no passo 8, a entrada some junto. Faz sentido: não tem por que guardar uma conexão que o próprio servidor recusou.

Você consegue ver a tabela ao vivo:

```bash
# Quantas entradas existem e qual é o limite
sysctl net.netfilter.nf_conntrack_count net.netfilter.nf_conntrack_max

# As entradas da porta 8080 (precisa do pacote conntrack-tools)
conntrack -L -p tcp --dport 8080

```

Guarda o `nf_conntrack_max`. Essa tabela tem tamanho. Quando ela enche, o pacote novo é descartado antes de chegar em qualquer lugar, e o único aviso é uma linha no `dmesg`. Esse é o assunto do próximo post da série.

## 6\. NAT de destino: troca o destino? Só no primeiro pacote

Ainda dentro do PREROUTING, a tabela `nat` pode trocar o destino do pacote. Isso se chama **DNAT**, e você usa todo dia sem perceber.

É assim que o Docker faz o `-p 8080:80` funcionar: uma regra na cadeia `DOCKER` troca `host:8080` por `IP-do-container:80`. É assim que o kube-proxy (no modo iptables) faz um Service funcionar: o IP virtual do Service, tipo `10.96.0.20:80`, é trocado pelo IP de um pod de verdade, tipo `10.244.1.7:8080`.

```bash
# As regras de DNAT do Docker
iptables -t nat -L DOCKER -n --line-numbers

# A porta de entrada das regras do kube-proxy
iptables -t nat -L KUBE-SERVICES -n | head -20

```

Agora o detalhe que muda a forma como você pensa sobre NAT: **a tabela `nat` só é lida no primeiro pacote da conexão**. O resultado da tradução fica guardado na entrada do conntrack, e os pacotes seguintes recebem a mesma troca direto, sem passar pelas regras de novo.

O que significa que, se você mudar uma regra de DNAT, as conexões que já existem continuam indo para o destino antigo até fecharem. Já vi gente jurar que a regra "não pegou" quando, na verdade, ela pegou perfeitamente para toda conexão nova. Depende do contexto, mas um `conntrack -D` na conexão certa resolve a dúvida em segundos.

No nosso pacote, nenhuma regra de DNAT bate. O destino continua `10.0.0.5:8080`.

## 7\. Decisão de rota: é pra mim?

Com o destino definido, o kernel decide para onde o pacote vai. A primeira tabela consultada é a `local`, que lista os IPs que pertencem a esta máquina.

```bash
# A ordem das tabelas: local primeiro, depois main
ip rule show
# 0:      from all lookup local
# 32766:  from all lookup main
# 32767:  from all lookup default

# Os IPs desta máquina
ip route show table local

```

`10.0.0.5` está lá. O pacote é para cá e segue para o gancho INPUT.

Se não estivesse, sobram duas saídas. Se a máquina está configurada como roteador (`net.ipv4.ip_forward=1`), o pacote vai para o gancho **FORWARD** e segue viagem. Se não está, é descartado.

E agora a ordem dos passos 6 e 7 faz sentido: **o NAT vem antes da rota justamente para que a rota seja decidida com o destino já trocado**. É por isso que um pacote para o IP de um Service do Kubernetes, que não pertence a máquina nenhuma, chega no pod. Quando a rota é decidida, o destino já é o IP do pod. Num nó do Kubernetes, `ip_forward` está ligado exatamente por causa disso.

## 8\. Gancho INPUT: aqui fica o firewall

O pacote é local, então passa pelo segundo gancho do netfilter, o **INPUT**. É aqui que mora o firewall de entrada da máquina, a tabela `filter`.

As regras são lidas em ordem, de cima para baixo, e **a primeira que bate com um alvo final decide**. No nosso exemplo, a regra 1 aceita conexões já estabelecidas (não é o caso, a nossa é NEW). A regra 2 aceita TCP na porta 8080\. Bate. ACCEPT.

```bash
iptables -L INPUT -n -v --line-numbers
# 1  ACCEPT  all  --  0.0.0.0/0  0.0.0.0/0  ctstate RELATED,ESTABLISHED
# 2  ACCEPT  tcp  --  0.0.0.0/0  0.0.0.0/0  tcp dpt:8080

```

(Se a sua distro usa `nftables`, o comando é `nft list ruleset`. O gancho é o mesmo; muda a ferramenta que escreve nele.)

O que acontece quando a regra que bate não é ACCEPT é o que mais importa para quem debuga, porque os dois jeitos de recusar parecem coisas completamente diferentes do lado do cliente:

| Alvo   | O que o servidor faz                                                                         | O que o cliente vê                                                                                                                                       |
| ------ | -------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------- |
| ACCEPT | Deixa passar                                                                                 | A conexão segue normalmente                                                                                                                              |
| DROP   | Descarta sem responder                                                                       | O cliente reenvia o SYN várias vezes até dar timeout. No Linux, com o padrão tcp\_syn\_retries=6, isso leva uns dois minutos. Parece servidor fora do ar |
| REJECT | Descarta e avisa (ICMP port unreachable por padrão, ou TCP RST com \--reject-with tcp-reset) | connection refused na hora                                                                                                                               |

Lembra do pacote que nunca chegou no log da API? Se o cliente recebe timeout, um dos suspeitos é um `DROP` no INPUT. Se recebe `connection refused` com o serviço de pé, o suspeito é um `REJECT`. Saber essa diferença economiza horas de olhar log de aplicação que nunca vai mostrar nada.

E se nenhuma regra bate? Vale a **política padrão** da cadeia, aquele `policy ACCEPT` ou `policy DROP` que aparece no cabeçalho do `iptables -L`. Cuidado com ela: muita gente escreve regras de ACCEPT com a política em DROP e esquece de liberar alguma coisa.

## 9\. Entrega ao TCP

Último passo dentro da camada IP. O kernel lê o campo de protocolo do cabeçalho IP para saber quem recebe o pacote.

| Protocolo | Quem recebe          |
| --------- | -------------------- |
| 6         | TCP → tcp\_v4\_rcv() |
| 17        | UDP → udp\_rcv()     |
| 1         | ICMP → icmp\_rcv()   |

O nosso diz 6\. O kernel avança o ponteiro do `sk_buff` para depois do cabeçalho IP (lembra do passo 1? sem copiar nada) e entrega o pacote para o código do TCP.

É aqui que este trecho da série termina. A sua aplicação ainda não sabe que esse pacote existe. Para ela saber, o TCP ainda vai precisar fazer o handshake, colocar a conexão numa fila e esperar alguém chamar `accept()`. Isso vem nos próximos posts.

## Então, o que o Linux faz antes da aplicação?

Recapitulando, na ordem em que o kernel executa:

1. Guarda o pacote num `sk_buff`, que vai ser o mesmo até o fim.
2. Lê o EtherType e manda para o código do IPv4.
3. Valida o cabeçalho IP e descarta em silêncio o que não bate.
4. Entra no gancho PREROUTING do netfilter.
5. O conntrack procura a conexão e cria uma entrada NEW.
6. A tabela `nat` pode trocar o destino, e isso fica guardado no conntrack.
7. Decide a rota com o destino já trocado.
8. Passa pelo firewall no gancho INPUT.
9. Entrega ao TCP.

Em pelo menos quatro desses passos o pacote pode morrer sem a sua aplicação ficar sabendo: cabeçalho inválido, destino que não é desta máquina, regra de DROP ou REJECT, e a tabela do conntrack cheia. Nenhum deles aparece no log da aplicação. Todos aparecem em algum contador ou tabela do kernel, se você souber onde olhar.

Na prática, a lição é simples: quando a requisição "não chegou", pare de olhar só para a aplicação. Desce um andar. Os comandos deste post são um bom começo.

No próximo post, a tabela do conntrack: ela tem tamanho, e quando enche, o pacote novo some antes de chegar aqui.

> Comportamento e valores padrão do Linux 6.x. Podem variar conforme a distribuição e a versão do kernel.

E aí, gostou? Se o seu tráfego some no caminho entre o load balancer e a aplicação, ou se o seu cluster Kubernetes está descartando conexão sem explicar por quê, a gente na **AzureBrasil.cloud** pode te ajudar.