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.

Resposta curta: 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.
Neste artigo
- O que o HTTP/3 elimina, e o que ele não toca
- Os 108 ms de handshake que medimos, e o que eles indicam
- Medindo o seu próprio delta entre HTTP/2 e HTTP/3 com curl
- Onde o ganho aparece e onde ele fica dentro da margem de erro
- Habilitando QUIC no LiteSpeed e no nginx
- O que quebra fora do servidor web: firewall, buffer UDP e MTU
- Antes de ligar QUIC, olhe o que custa mais que o handshake
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.
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.