blog
Infraestrutura web

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.

JR · · 8 min de leitura · 2 tabelas · 10 blocos de código

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

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 100 amostras · setembro de 2026 · medido pela Napoleon Host

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.

Handshake por conexão nova: TLS 1.2 contra TLS 1.3TLS 1.2108,7TLS 1.3107,6
Handshake TLS mediano por conexão nova até servidor LiteSpeed no Brasil, 100 execuções, setembro de 2026. Delta de pouco mais de 1 ms entre as versões: o custo é a conexão nova existir, não o protocolo negociado.

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.

Triagem: quando abrir UDP/443 compensaTTFB dominado por app ou bancoResolva query e cache antesRTT de poucos ms, fibra nacionalGanho dentro do ruído, não mexaConexões longas, keep-aliveHandshake amortizado, ganho perto de zeroRTT alto, perda, rede móvelGanho de 1 RTT por aberturaMuitas conexões novas por sessãoAbra UDP/443 e publique Alt-Svc
Ordem de triagem antes de abrir UDP/443. As três primeiras condições encerram a decisão: o gargalo não está no transporte.

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.

Leia também