blog
Infraestrutura web

O handshake TLS custa 108 ms, e trocar de versão não resolve

O que o visitante paga em DNS, TCP e TLS antes do primeiro byte, medido com curl em 100 conexões, e as três mudanças que realmente reduzem esse tempo.

JR · · 9 min de leitura · 3 tabelas · 8 blocos de código

Resposta curta: o handshake TLS custa cerca de 108 ms por conexão HTTPS nova (108,7 ms no TLS 1.2 contra 107,6 ms no TLS 1.3, em 100 conexões medidas). Quem corta esse tempo não é a versão do protocolo: é a conexão nova não precisar existir, com HTTP/2 ativo, keep-alive preservado e menos domínios de terceiros.

Neste artigo
  1. O que o visitante paga antes de ver o primeiro pixel
  2. TLS 1.2 e TLS 1.3 deram empate em 100 conexões
  3. Medir o handshake do seu próprio site com curl
  4. Conferir se o HTTP/2 está mesmo ativo
  5. A conexão que já existe custa zero de handshake
  6. Cada domínio de terceiro é um pedágio inteiro
  7. Por onde começar e o que deixar para o final

O que o visitante paga antes de ver o primeiro pixel

Antes de o servidor sequer ler o pedido, o navegador precisa cumprir três etapas em série numa origem que ele nunca visitou:

  1. DNS: descobrir o IP do domínio.
  2. TCP: abrir a conexão com esse IP (o famoso three-way handshake).
  3. TLS: negociar cifra, validar o certificado e derivar as chaves.

Só depois disso a requisição HTTP sai. TTFB, otimização de banco, cache de página: nada disso é acionado enquanto essas três etapas não terminam. É tempo morto do ponto de vista da aplicação e tempo bem vivo do ponto de vista de quem está olhando a tela branca.

Neste artigo, sempre que falamos em custo do handshake TLS, é a definição que o curl mede: time_appconnect menos time_connect, ou seja, o intervalo entre a conexão TCP estabelecida e o handshake TLS concluído. Não inclui DNS, não inclui TCP, não inclui a resposta do servidor. É só o pedágio criptográfico.

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

TLS 1.2 e TLS 1.3 deram empate em 100 conexões

A promessa que circula em quase todo conteúdo sobre o assunto é que trocar TLS 1.2 por TLS 1.3 acelera o site. A justificativa teórica existe: o handshake completo do TLS 1.2 gasta dois round trips, o do TLS 1.3 gasta um. Em uma rota longa, um round trip a menos aparece.

Em 100 conexões novas contra um servidor LiteSpeed hospedado no Brasil, em setembro de 2026, o resultado foi este:

Versão do protocolo Custo mediano do handshake
TLS 1.2 108,7 ms
TLS 1.3 107,6 ms
Diferença 1,1 ms

Um round trip a menos rendeu 1,1 ms de mediana. Para efeito prático, empate. O ganho está dentro do ruído de qualquer página real, onde uma imagem mal comprimida custa dez vezes mais que isso.

O que essa medição não diz, e é importante ser explícito:

A conclusão que a amostra sustenta é limitada e útil: em uma rota nacional, mudar a versão do TLS não é a alavanca de performance. O que custa é a conexão nova existir. Cada origem nova que a página aciona paga esse pedágio de novo, e paga integralmente.

TLS 1.3 continua valendo a pena. Só que pelo motivo certo: ele remove cifras e modos de negociação problemáticos e simplifica a superfície de ataque. Ative por segurança, não por velocidade.

Medir o handshake do seu próprio site com curl

O curl expõe todos os marcos de tempo da conexão. Cada valor é contado desde o início da requisição, então a duração de cada etapa é a subtração de dois marcos.

Uma requisição, com o tempo de cada etapa

curl -s -o /dev/null \
  -w 'dns=%{time_namelookup} tcp=%{time_connect} tls=%{time_appconnect} ttfb=%{time_starttransfer} total=%{time_total}\n' \
  https://exemplo.com.br/

Os valores saem em segundos, com casas decimais. Leia assim:

Etapa Cálculo
DNS time_namelookup
TCP time_connect menos time_namelookup
TLS time_appconnect menos time_connect
Servidor + rede até o 1º byte time_starttransfer menos time_appconnect

Cem conexões novas e a mediana do handshake

Uma requisição isolada não vale nada: cache de DNS, variação de rota e concorrência no servidor mexem muito no número. Repita e tire a mediana. Cada invocação do curl abre uma conexão nova, que é exatamente o cenário que queremos medir.

for i in $(seq 1 100); do
  curl -s -o /dev/null \
    -w '%{time_connect} %{time_appconnect}\n' \
    https://exemplo.com.br/
done | awk '{print ($2-$1)*1000}' | sort -n | sed -n '50,51p'

As duas linhas impressas são os valores centrais da amostra, em milissegundos. A mediana é a média entre elas. Use mediana, não média: um único pico de 900 ms distorce a média e não representa a experiência típica.

Comparar TLS 1.2 e TLS 1.3 no seu servidor

Para reproduzir a comparação, force a versão em cada rodada:

# TLS 1.2
curl -s -o /dev/null --tlsv1.2 --tls-max 1.2 \
  -w '%{time_connect} %{time_appconnect}\n' https://exemplo.com.br/

# TLS 1.3
curl -s -o /dev/null --tlsv1.3 \
  -w '%{time_connect} %{time_appconnect}\n' https://exemplo.com.br/

Se o comando com --tlsv1.3 falhar, ou o seu curl foi compilado com uma biblioteca TLS antiga, ou o servidor não oferece 1.3. curl -V mostra a biblioteca e a versão.

Rode as duas séries intercaladas, não uma depois da outra. Se você medir TLS 1.2 às 3h e TLS 1.3 às 15h, está medindo carga do servidor, não protocolo.

Conferir se o HTTP/2 está mesmo ativo

HTTP/2 multiplexa várias requisições dentro de uma única conexão. Em HTTP/1.1 o navegador também reaproveita conexões, mas precisa abrir várias em paralelo para não serializar os downloads: o limite típico é de seis conexões por origem. São seis handshakes na mesma origem, e mais uma fila de espera quando a página tem dezenas de arquivos. Com HTTP/2, uma conexão por origem dá conta de todas as requisições ao mesmo tempo. Só que ele precisa estar ligado, e em mais de um servidor ele não vem ligado por padrão.

Descobrir a versão do HTTP negociada pelo terminal

curl -s -o /dev/null --http2 -w '%{http_version}\n' https://exemplo.com.br/

A saída é 2 quando o servidor negociou HTTP/2 e 1.1 quando caiu para HTTP/1.1. O --http2 só autoriza o curl a tentar; quem decide é o servidor, via ALPN, durante o handshake TLS.

Ler a coluna Protocol na aba Network do navegador

Abra o DevTools, vá em Network, recarregue a página. A coluna que interessa é Protocol, e ela costuma vir oculta: clique com o botão direito na linha de cabeçalho da tabela e marque Protocol. Os valores são h2 (HTTP/2), h3 (HTTP/3 sobre QUIC) e http/1.1.

Olhe linha a linha, não só a primeira. É comum o HTML principal vir em h2 e um subdomínio de imagens ou um endpoint de API da mesma casa continuar em http/1.1.

No Nginx, HTTP/2 é opt-in e a diretiva mudou na 1.25.1

No Nginx, HTTP/2 é opt-in. A partir da versão 1.25.1 a forma correta é a diretiva própria:

server {
    listen 443 ssl;
    http2 on;

    server_name exemplo.com.br;
    # ...
}

Em versões anteriores a 1.25.1, o parâmetro ia no listen:

listen 443 ssl http2;

Confira a sua versão com nginx -v antes de editar. Depois de aplicar, valide com nginx -t e recarregue. E confirme com o comando curl acima, não com a leitura do arquivo: um server block mais específico ou um proxy na frente pode estar respondendo no lugar do que você editou.

No Apache, HTTP/2 depende do mod_http2 carregado e da diretiva Protocols h2 http/1.1. No LiteSpeed e no OpenLiteSpeed, a negociação é configurada no listener. Em qualquer um dos três, a verificação final é a mesma: o %{http_version} que voltou.

A conexão que já existe custa zero de handshake

Keep-alive é a conexão TCP/TLS ficar aberta depois da resposta, esperando a próxima requisição. Quando ela é reaproveitada, o custo de handshake da segunda requisição é zero, porque não há handshake.

Dá para ver isso acontecendo. Passe duas URLs para o mesmo curl, que reutiliza a conexão entre elas:

curl -s -o /dev/null -o /dev/null \
  -w 'tls=%{time_appconnect} total=%{time_total}\n' \
  https://exemplo.com.br/ https://exemplo.com.br/sobre/

A primeira linha traz um time_appconnect diferente de zero. A segunda traz 0.000000. Não é bug do curl: é a definição. Sem conexão nova, não há tempo de handshake para contar.

Se a segunda linha vier com valor diferente de zero, alguma coisa está fechando a conexão. Suspeitos, em ordem de frequência:

Inspecione o cabeçalho direto:

curl -sI https://exemplo.com.br/ | grep -i '^connection'

Um detalhe que engana muita gente: em HTTP/2 o cabeçalho Connection é proibido pelo protocolo, e a persistência é intrínseca. Se você está em h2, não procure Connection: keep-alive. Procure o time_appconnect zerado na segunda requisição.

Cada domínio de terceiro é um pedágio inteiro

Multiplexação e keep-alive resolvem o custo dentro da sua origem. Não fazem nada por um domínio diferente. Fonte externa, gerenciador de tags, widget de chat, pixel de rede social, player de vídeo, mapa: cada origem distinta paga a sequência completa de DNS, TCP e TLS antes de entregar o primeiro byte dela.

Como contar quantas origens a sua página aciona, sem instalar nada:

  1. DevTools, aba Network, recarregue com o cache desativado.
  2. Ordene pela coluna Domain.
  3. Conte os domínios distintos. Esse é o número de pedágios que a sua página cobra do visitante.

O que costuma render mais, em ordem de esforço contra retorno:

Para as origens que precisam ficar, <link rel="preconnect"> antecipa DNS, TCP e TLS para o começo do carregamento. Ele não elimina o custo, só o tira do caminho crítico. Use com parcimônia, em duas ou três origens que você sabe que serão usadas. Preconnect em domínio que a página não chega a acionar é desperdício de conexão e de bateria no celular.

Por onde começar e o que deixar para o final

Ação Efeito no tempo até o primeiro byte Como confirmar
Ativar HTTP/2 Alto, se estava em HTTP/1.1 com muitos assets %{http_version} retorna 2
Preservar keep-alive Alto em navegação de várias páginas time_appconnect zerado na 2ª requisição
Remover origens de terceiros Proporcional ao número de origens cortadas Contagem de domínios na aba Network
Hospedar a fonte localmente Uma origem a menos, mais fim do texto invisível Aba Network, sem o domínio da fonte
Trocar TLS 1.2 por TLS 1.3 Praticamente nulo na rota medida Comparação com --tlsv1.2 e --tlsv1.3
Preconnect em origem essencial Tira o custo do caminho crítico, não o elimina Waterfall, conexão iniciada mais cedo

A ordem prática: confirme HTTP/2 primeiro, porque é uma linha de configuração e pode estar desligada sem ninguém ter notado. Depois confirme keep-alive, porque a segunda página da navegação depende dele. Só então mexa em terceiros, que é o trabalho mais chato e o de maior retorno em páginas pesadas de marketing.

Deixe a versão do TLS para o final da lista de performance e trate como item de segurança. Se um fornecedor está vendendo migração de plano com a promessa de que TLS 1.3 vai acelerar o seu site, peça o número medido dele. A nossa amostra de 100 conexões, em setembro de 2026, contra um LiteSpeed no Brasil, deu 1,1 ms de diferença mediana entre as duas versões.

E meça antes de mudar. Rode o loop de 100 conexões hoje, guarde a mediana, aplique uma mudança de cada vez e rode de novo. Sem linha de base, qualquer resultado depois parece bom.

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