# HTTP/3 vale a pena? Os 108 ms que decidem a resposta

Como medir o seu próprio delta de appconnect com curl --http3, decidir pelo perfil de tráfego e ajustar buffer UDP, Alt-Svc e MTU sem quebrar o fallback.

> depende do RTT e do perfil de conexões. Medimos 108 ms de handshake TLS por conexão nova (108,7 ms no TLS 1.2 e 107,6 ms no TLS 1.3): o custo vem da conexão existir, não da versão. HTTP/3 corta cerca de 1 RTT, então só paga onde o RTT é alto ou há muita conexão nova.

João Rizzon · 2026-10-04 · Infraestrutura web

---

## O que o HTTP/3 elimina, e o que ele não toca

HTTP/3 não acelera o seu PHP, não reduz o tempo de query e não muda o tamanho do HTML. Ele mexe em uma coisa só: o custo de estabelecer e manter a conexão de transporte. QUIC junta o handshake de transporte e o handshake criptográfico em um único voo de pacotes, troca o controle de fluxo por stream do TCP por streams independentes dentro de um mesmo caminho UDP e carrega um connection ID que sobrevive à troca de IP do cliente.

Isso ataca três custos concretos:

- **Round trips de abertura.** TCP + TLS 1.3 custa tipicamente 2 RTT até o primeiro byte de aplicação. QUIC com TLS 1.3 custa 1 RTT, e 0 RTT quando o cliente já tem ticket de sessão. O 0-RTT tem preço: os dados do primeiro voo não têm proteção contra replay, então só é seguro para requisições idempotentes (GET e HEAD sem efeito colateral).
- **Head of line blocking do TCP.** Um segmento perdido trava todas as streams HTTP/2 multiplexadas na mesma conexão até a retransmissão. Em QUIC, só a stream afetada espera.
- **Mobilidade.** Mudança de rede (Wi-Fi para 4G, NAT rebind) mata a conexão TCP e obriga handshake novo. QUIC migra pelo connection ID.

Tudo o que está fora dessa lista continua igual. Se o seu TTFB é dominado por um `SELECT` de 600 ms, HTTP/3 não entrega nada.

**108 ms** custo mediano do handshake TLS por conexão HTTPS nova até um servidor LiteSpeed no Brasil: 108,7 ms no TLS 1.2 e 107,6 ms no TLS 1.3, um empate na prática que mostra que o custo real é a conexão nova existir, não a versão do protocolo (n=100, setembro de 2026)

## Os 108 ms de handshake que medimos, e o que eles indicam

Medimos o custo mediano do handshake TLS por conexão HTTPS nova até um servidor LiteSpeed no Brasil: **108,7 ms no TLS 1.2 e 107,6 ms no TLS 1.3**, com 100 execuções, em setembro de 2026. Ou seja, um delta de pouco mais de 1 ms entre as duas versões do protocolo.

A leitura importante não é "TLS 1.3 não serve". É que, nesse caminho de rede, **o custo é dominado pelo RTT e pelo fato de a conexão existir**, não pela versão negociada. Quando o tempo de handshake está nessa ordem de grandeza, o que você consegue cortar é o número de round trips, e é exatamente aí que HTTP/3 opera.

Um raciocínio de ordem de grandeza que você pode conferir no seu próprio ambiente: pegue o RTT médio do seu `ping` até o servidor. O ganho teórico máximo de QUIC sobre TCP+TLS 1.3 em conexão nova é cerca de 1 RTT. Com 0-RTT e ticket válido, pode chegar a 2 RTT, mas só para o subconjunto idempotente do tráfego e com early data explicitamente habilitado no servidor. Se o seu RTT é 8 ms porque o cliente está na mesma região, o ganho vive dentro do ruído. Se é 180 ms porque o cliente está do outro lado do Atlântico em rede móvel, o ganho é visível no campo.

## Medindo o seu próprio delta entre HTTP/2 e HTTP/3 com curl

Não aceite o número de ninguém, inclusive o nosso. O que interessa é o delta no seu caminho de rede. Use `curl` com saída de tempos e force cada versão.

Primeiro confira se o seu binário tem HTTP/3 compilado:

```
curl -V | grep -o HTTP3
```

Se não imprimir nada, o build não tem QUIC e `--http3` vai falhar. Builds oficiais do curl com `ngtcp2` ou `quiche` resolvem isso.

Um formato de saída enxuto, com o que importa:

```
cat > fmt.txt <<'EOF'
namelookup:  %{time_namelookup}\n
connect:     %{time_connect}\n
appconnect:  %{time_appconnect}\n
starttransfer: %{time_starttransfer}\n
total:       %{time_total}\n
version:     %{http_version}\n
EOF

curl -sS -o /dev/null -w "@fmt.txt" --http1.1 https://seudominio.com.br/
curl -sS -o /dev/null -w "@fmt.txt" --http2   https://seudominio.com.br/
curl -sS -o /dev/null -w "@fmt.txt" --http3   https://seudominio.com.br/
```

O que cada campo significa aqui, e isto importa para não comparar coisas diferentes:

| Campo do curl | TCP + TLS | QUIC (HTTP/3) |
|---|---|---||
| `time_connect` | fim do handshake TCP | fim da fase UDP inicial, costuma ficar muito próximo de `namelookup` |
| `time_appconnect` | fim do handshake TLS | fim do handshake QUIC + TLS, que é o mesmo evento |
| `appconnect - connect` | custo isolado do TLS | custo do handshake criptográfico combinado |
| `time_starttransfer` | primeiro byte de resposta | primeiro byte de resposta |

Em TCP, `appconnect - connect` é o número comparável ao que medimos. Em QUIC, a separação entre transporte e cripto deixa de existir, então compare **`time_appconnect` absoluto** entre as três execuções, não a subtração.

Para mediana em vez de amostra única, repita e ordene:

```
for i in $(seq 1 50); do
  curl -sS -o /dev/null -w "%{time_appconnect}\n" --http3 https://seudominio.com.br/
done | sort -n | awk '{a[NR]=$1} END {print "mediana:", a[int(NR/2)+1]}'
```

Troque `--http3` por `--http2` e rode de novo. O delta entre as duas medianas é a sua resposta, não a nossa.

### Por que o navegador só tenta HTTP/3 depois de ver o Alt-Svc

`curl --http3` força. O navegador não: ele só migra depois de ver o cabeçalho `Alt-Svc` em uma resposta sobre TCP e guardar isso. Confira que o cabeçalho sai:

```
curl -sI --http2 https://seudominio.com.br/ | grep -i alt-svc
```

Se não aparecer `h3=":443"`, nenhum navegador vai tentar QUIC, por mais que a porta esteja aberta.

## Onde o ganho aparece e onde ele fica dentro da margem de erro

| Perfil de tráfego | Expectativa | Vale abrir UDP/443 |
|---|---|---||
| Audiência móvel, 3G/4G, RTT alto e perda de pacote | Maior ganho, por 0-RTT e ausência de head of line blocking | Sim |
| Visitantes internacionais, RTT acima de 150 ms | Ganho de 1 RTT por conexão nova, perceptível | Sim |
| Muitas conexões novas por sessão (tráfego de campanha, bounce alto) | Ganho proporcional ao número de aberturas | Sim |
| API server to server, conexões longas e keep-alive | Handshake amortizado, ganho próximo de zero | Não compensa |
| Tráfego nacional em fibra, RTT de poucos ms | Diferença dentro da variação entre execuções | Não compensa |
| TTFB dominado por aplicação ou banco | Irrelevante, o gargalo é outro | Não compensa |

Se o seu caso cai nas três últimas linhas, a recomendação honesta é não mexer. Abrir UDP/443 adiciona superfície, buffer de kernel para ajustar e um caminho de fallback a monitorar, em troca de um delta que você não vai conseguir distinguir do ruído na própria medição.

## Habilitando QUIC no LiteSpeed e no nginx

### LiteSpeed e OpenLiteSpeed já vêm com QUIC, falta liberar o listener

QUIC vem compilado. O que falta normalmente é liberar a porta e confirmar o listener. No painel admin, em **Configuration > Tuning**, a seção QUIC controla ativação e versões. Por virtual host, verifique que o listener em 443 tem QUIC habilitado e que o certificado está no mesmo listener: QUIC exige TLS 1.3, então um vhost preso a TLS 1.2 não vai subir h3.

### nginx 1.25 em diante, bloco mínimo e a armadilha do ssl_protocols

A partir do nginx 1.25, o módulo QUIC está no mainline sem patch externo, mas depende de uma biblioteca TLS com suporte a QUIC no build. Confirme antes de editar:

```
nginx -V 2>&1 | tr ' ' '\n' | grep -E 'http_v3|quic|ssl'
```

O bloco mínimo:

```
server {
    listen 443 quic reuseport;
    listen 443 ssl;
    http2 on;

    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_certificate     /etc/ssl/fullchain.pem;
    ssl_certificate_key /etc/ssl/privkey.pem;

    add_header Alt-Svc 'h3=":443"; ma=86400' always;
}
```

Cuidado com `ssl_protocols`: a diretiva vale para o bloco inteiro, inclusive para o listener TCP/TLS. Fixar `ssl_protocols TLSv1.3;` só porque QUIC exige 1.3 derruba todo cliente TLS 1.2 que hoje funciona sobre TCP, e QUIC negocia 1.3 de qualquer forma, independentemente de 1.2 estar na lista. Mantenha `TLSv1.2 TLSv1.3` enquanto precisar de clientes antigos, ou separe os vhosts se quiser endurecer só um deles.

Se for usar 0-RTT, ele não vem de graça: no nginx é `ssl_early_data on;` e a aplicação (ou o upstream) precisa ler `$ssl_early_data` e recusar ou reprocessar requisições não idempotentes, porque early data é replicável por um atacante que capture o voo inicial. Sem esse tratamento, deixe desligado.

Dois detalhes que quebram em produção: `reuseport` só pode aparecer uma vez por par endereço/porta em toda a configuração, senão o nginx recusa o reload. E `add_header` sem `always` some nas respostas de erro, o que atrasa a adoção pelos navegadores que caem em 404 e 304.

Recarregue com teste prévio e tenha a reversão pronta:

```
nginx -t && nginx -s reload
```

A reversão é comentar a linha `listen 443 quic` e o `Alt-Svc`, e recarregar. Clientes com `Alt-Svc` em cache ainda tentarão UDP por até `ma` segundos antes de voltar a TCP, por isso um `ma` curto durante o piloto, algo como 600, reduz o tempo de exposição a um rollback.

## O que quebra fora do servidor web: firewall, buffer UDP e MTU

### Abrir UDP/443 nos dois sentidos, ou a falha fica silenciosa

UDP/443 precisa estar aberto nos dois sentidos, no host e em qualquer firewall à frente.

```
ufw allow 443/udp
# ou
iptables -A INPUT -p udp --dport 443 -j ACCEPT
```

Se a porta estiver fechada, nada quebra visivelmente: o navegador tenta QUIC, falha e cai em TCP. O sintoma é uma latência extra silenciosa, o pior tipo de regressão.

### Buffer de socket UDP para não perder datagrama em rajada

QUIC roda em espaço de usuário sobre sockets UDP. Com buffers de kernel pequenos, você perde datagramas sob rajada e o servidor loga aviso de buffer insuficiente. Valores de partida:

```
sysctl -w net.core.rmem_max=8388608
sysctl -w net.core.wmem_max=8388608
```

Persista em `/etc/sysctl.d/` depois de validar. Verifique descarte com `nstat -az | grep -i udp` ou `netstat -su`, olhando os contadores de receive errors e buffer errors antes e depois de um pico.

### MTU insuficiente derruba o handshake sem mensagem de erro clara

QUIC não fragmenta: o handshake inicial usa datagramas grandes e exige caminho com MTU suficiente. Túnel, PPPoE ou VPN no caminho podem derrubar o handshake sem mensagem clara. Se `--http3` falha mas TCP funciona, teste o caminho com pacote grande e DF ativo:

```
ping -M do -s 1400 seudominio.com.br
```

Se isso falha e com `-s 1200` passa, o problema é MTU, não QUIC.

## Antes de ligar QUIC, olhe o que custa mais que o handshake

Se o seu `time_starttransfer` menos `time_appconnect` é de centenas de milissegundos, HTTP/3 não é a próxima tarefa. Nessa faixa, o retorno está no log de query lenta, em cache de objeto, em OPcache dimensionado e em compressão. Mexer no transporte só paga depois que o tempo de aplicação cabe no mesmo orçamento do handshake.

E quando o handshake está na casa dos 108 ms que medimos, a pergunta certa não é qual versão de TLS negociar, já que a diferença entre 1.2 e 1.3 ficou em pouco mais de 1 ms na nossa amostra. É quantas conexões novas a sua sessão típica abre, e se dá para abrir menos: keep-alive bem configurado, consolidação de domínios, preconnect nos recursos críticos. Esses ajustes reduzem o número de handshakes, e isso vale para HTTP/2 e HTTP/3 igualmente.

---

## Como medimos

100 conexões HTTPS novas de um VPS externo a um servidor LiteSpeed da Napoleon: 50 negociando TLS 1.2 e 50 negociando TLS 1.3. Em cada conexão o curl registrou time_connect (fim do TCP) e time_appconnect (fim do TLS); o custo do handshake é a diferença entre os dois, isolando o TLS do TCP. Medianas: 108,7 ms no TLS 1.2 e 107,6 ms no TLS 1.3.
