VPS em Miami custa 114 ms a mais. Quando isso importa
A conta por camada de handshake, redirect e round-trip de API, com o script curl que você roda contra o seu próprio VPS antes de trocar de provedor.

Resposta curta: em mediana, atender um usuário brasileiro a partir de Miami custa 114 ms a mais por round-trip que a partir de São Paulo. Isso vira ~342 ms só em handshake TCP+TLS+GET numa conexão nova, mas não aparece de forma perceptível em build, cron, worker e backup.
Neste artigo
- Por que 114 ms viram 684 ms antes do HTML aparecer
- O que paga RTT por round-trip e o que não paga
- Como medir o RTT do seu VPS com curl e tcpdump
- Quando 114 ms não justificam migrar
- Quando 114 ms justificam migrar, e o que fazer antes
- Front no Brasil, worker e backup no VPS barato
- O que os 114 ms não dizem sobre cauda e horário de pico
Por que 114 ms viram 684 ms antes do HTML aparecer
A diferença de mediana entre atender um usuário brasileiro a partir de Miami e a partir de São Paulo é de 114 ms. A medição: 1440 amostras em julho de 2026, uma por minuto ao longo de 24 horas, feitas com curl a partir de uma conexão residencial brasileira contra o mesmo arquivo estático servido por dois hosts idênticos, um em São Paulo e um em Miami; o valor é a mediana da diferença de time_connect menos time_namelookup entre os dois destinos. Esse é o número que importa, mas ele raramente aparece sozinho no navegador do usuário. Ele aparece multiplicado.
RTT é o custo de um round-trip. Quase nada na web moderna acontece em um único round-trip. A conexão nova de um HTTPS com TLS 1.3 gasta 1 RTT para o handshake TCP (SYN, SYN-ACK) e 1 RTT para o handshake TLS antes do primeiro byte de requisição sair. Com TLS 1.2 sem session ticket, são 2 RTTs só de TLS. Depois disso, o GET ainda precisa de mais 1 RTT para o primeiro byte voltar.
A aritmética, usando 114 ms como delta por round-trip:
| Etapa | RTTs extras | Custo adicional vindo de Miami |
|---|---|---|
| Handshake TCP | 1 | 114 ms |
| Handshake TLS 1.3 (full) | 1 | 114 ms |
| Handshake TLS 1.2 (full) | 2 | 228 ms |
| GET até o primeiro byte | 1 | 114 ms |
| Cada redirect 301/302 que abre conexão nova | 3 ou 4 | 342 ms a 456 ms |
| Cada chamada de API sequencial do front | 1 | 114 ms |
Um site que faz http://dominio → https://dominio → https://www.dominio antes de servir HTML paga a conta duas vezes antes de existir qualquer renderização: dois redirects que abrem conexão nova, cerca de 684 ms a mais que a mesma cadeia servida de São Paulo, sem que o servidor tenha ficado mais lento em nada.
O que paga RTT por round-trip e o que não paga
Separe o que é sensível a RTT do que é sensível a CPU, I/O ou banda.
Sensível a RTT (paga 114 ms por round-trip):
- Handshake de conexão nova, inclusive de cada origem de terceiro servida do seu domínio.
- Primeiro byte de HTML dinâmico.
- Cada requisição XHR/fetch sequencial que depende da resposta anterior.
- Queries de banco atravessando região (app em Miami, banco no Brasil, ou o contrário).
Insensível a RTT:
- Throughput de download depois que a janela de congestionamento abriu. Um asset de 2 MB em conexão já estabelecida é dominado por banda, não por RTT.
- Tempo de CPU do PHP, do Node, do build.
- Jobs de fila, cron, backup, compressão de imagem, transcodificação.
- Qualquer coisa servida por CDN com cache HIT na borda brasileira, porque a conexão do usuário termina no POP, não no seu VPS.
Essa separação é a decisão inteira. Se o seu tráfego de usuário final é HTML dinâmico com conexão nova a cada visita, 114 ms entram multiplicados. Se o VPS é um worker que consome fila e escreve no S3, 114 ms não aparecem em lugar nenhum que alguém observe.
Como medir o RTT do seu VPS com curl e tcpdump
Não aceite o número de ninguém, inclusive o meu, sem rodar contra o seu host. O curl entrega a decomposição por fase sem ferramenta extra.
Crie o arquivo de formato:
cat > curl-format.txt <<'EOF'
dns: %{time_namelookup}s
tcp_cnx: %{time_connect}s
tls: %{time_appconnect}s
pretrns: %{time_pretransfer}s
redirect: %{time_redirect}s
ttfb: %{time_starttransfer}s
total: %{time_total}s
saltos: %{num_connects} conexoes, %{num_redirects} redirects
EOF
Rode 30 vezes. Cada iteração é um processo curl novo, então não há reuso de conexão, nem cache de ticket TLS, nem cache de DNS entre elas: cada medição paga DNS, TCP e TLS do zero.
for i in $(seq 1 30); do
curl -sS -o /dev/null -w "@curl-format.txt" \
-L "https://seu-dominio.com.br/"
echo "---"
done
Não use --no-keepalive achando que ele força handshake novo: essa flag só desliga as probes de TCP keepalive (SO_KEEPALIVE) do socket. Ela não impede reuso de conexão dentro do mesmo processo nem session resumption de TLS. Quem garante conexão nova aqui é o fork a cada volta do laço.
O que ler em cada linha:
time_connectmenostime_namelookupé o RTT de TCP. É o seu RTT puro de rede.time_appconnectmenostime_connecté o handshake TLS. Se esse valor for próximo do dobro do RTT de TCP, você está em TLS 1.2 full handshake ou sem resumption.time_starttransfermenostime_pretransferé o tempo de aplicação mais 1 RTT: o GET sobe e o primeiro byte volta. Para isolar a aplicação, desconte desse delta o RTT medido emtime_connectmenostime_namelookup. O que sobra (PHP, Node, banco) não melhora migrando de região; o round-trip embutido, esse sim, melhora.num_connectsmaior que 1 significa que algum redirect abriu conexão nova. Cada uma custa handshake completo de novo.
Para separar RTT de rede de qualquer coisa de aplicação, use um ping de camada 4 direto na porta:
sudo tcpdump -i any -n 'host SEU_IP and tcp port 443' -ttt
E, em outro terminal, um único curl -sS -o /dev/null https://seu-dominio.com.br/. O delta entre o SYN e o SYN-ACK capturado é o RTT de rede sem contaminação de DNS, TLS ou aplicação. Repita a partir de uma conexão residencial brasileira, não de um shell em outro datacenter: medir de um servidor em São Paulo contra um VPS em Miami dá um número de backbone, não o número que o seu usuário vive.
Compare Miami e Brasil com o mesmo stack dos dois lados
Se você já tem o VPS em Miami e quer avaliar um host no Brasil, suba o mesmo stack nos dois, com o mesmo TLS, o mesmo HTTP/2 ou HTTP/3 e o mesmo conteúdo estático de teste (um arquivo de 1 KB basta). Medir index dinâmico de um lado e /healthz do outro produz comparação inútil, porque o tempo de aplicação domina.
Quando 114 ms não justificam migrar
São cargas onde a borda é irrelevante e a economia de um VPS barato vence sem discussão:
- Runner de CI/CD e build. O que importa é vCPU, RAM e disco. Um build de 6 minutos não fica perceptivelmente pior porque o
git fetchpagou RTT a mais. - Workers de fila. Se o consumidor está colado no broker na mesma região, o RTT interno é intra-datacenter. O usuário espera o job terminar, não o pacote voltar.
- Cron e ETL noturno. Ninguém mede latência de um job que roda às 3h.
- Destino de backup. Throughput e custo por TB mandam. 114 ms somem num
rsyncde uma hora. - API consumida por outro servidor, não por browser, com paralelismo e keep-alive. Com conexão persistente, o handshake é pago uma vez e amortizado em milhares de requisições.
- Ambiente de staging e homologação. Você está testando lógica, não percepção.
- Site institucional estático atrás de CDN com cache de HTML na borda. O usuário brasileiro fala com o POP brasileiro. O seu VPS só é consultado em MISS e em revalidação.
Nesses casos, migrar para ganhar 114 ms é pagar por um ganho que ninguém mede e ninguém sente.
Quando 114 ms justificam migrar, e o que fazer antes
O delta pesa de verdade quando o usuário final espera HTML dinâmico com conexão nova: e-commerce, checkout, painel autenticado, LMS, portal com busca. Aí os 114 ms chegam multiplicados por handshake mais redirect mais chamadas sequenciais.
Antes de trocar de provedor, esgote o que é de graça e reversível:
- Elimine redirects em cadeia. Faça o
http://ir direto para o host canônico final, em um salto só. Verifique comcurl -ILe confiranum_redirects. - Garanta TLS 1.3 e session resumption. Habilite tickets e teste com
openssl s_client -connect host:443 -tls1_3 -reconnect </dev/null 2>&1 | grep -E 'New|Reused': a primeira linha deve sair comoNew, e as reconexões seguintes comoReused. Variante em dois passos:-sess_out /tmp/s.pemna primeira conexão e-sess_in /tmp/s.pemna segunda. Com resumption ativa, a segunda conexão corta um round-trip detime_appconnect. - Ligue HTTP/2 ou HTTP/3. Sem multiplexação, cada asset sequencial do mesmo domínio vira round-trip extra.
- Enxugue origens de terceiro. Cada domínio novo no HTML paga DNS, TCP e TLS do zero. Cinco origens que carregam no caminho crítico custam mais que a região do seu servidor.
- Coloque uma CDN com POP no Brasil na frente, e cacheie HTML quando o conteúdo permitir. Isso resolve o problema de borda sem mexer no VPS.
- Olhe o tempo de aplicação. Calcule
time_starttransfermenostime_pretransfere desconte o RTT (time_connectmenostime_namelookup), que está embutido aí como round-trip do GET. Se o que sobra ainda for maior que 114 ms, o gargalo está na aplicação, provavelmente uma query lenta, não no Atlântico. Ligue o slow query log antes de ligar para qualquer provedor.
Se depois disso o TTFB ainda estiver dominado por rede, a migração passa a ser o próximo ganho disponível. Se não estiver, migrar dá um ganho que o seu próprio log já mostrava ser secundário.
Front no Brasil, worker e backup no VPS barato
A escolha não precisa ser binária. O arranjo que mais vezes se paga:
| Componente | Onde fica | Por quê |
|---|---|---|
| Front dinâmico / checkout | Brasil | É aqui que o usuário paga 114 ms por round-trip |
| Banco de dados primário | Junto do front | Query cross-region multiplica o delta por consulta |
| Workers, cron, ETL | VPS barato | Sem usuário na ponta |
| Runner de CI/CD | VPS barato | Dominado por CPU e disco |
| Backup e arquivamento | VPS barato | Dominado por banda e custo por TB |
| Estático e mídia | CDN com POP no Brasil | Entrega da borda, origem irrelevante |
Um erro recorrente: manter o app no Brasil e o banco lá fora para economizar. Cada query sequencial do request paga o RTT inteiro. Uma página com 20 queries em série fica inviável, e o perfil de time_starttransfer denuncia isso em dois minutos de medição. Mantenha app e banco sempre na mesma região.
O que os 114 ms não dizem sobre cauda e horário de pico
Os 114 ms são uma mediana. Eles não dizem nada sobre cauda: perda de pacote, reordenação ou congestionamento de peering em horário de pico mudam a experiência de quem está na cauda, e nada disso está nesse número. Também não medimos throughput, jitter, nem rota por operadora específica, e a sua rota pode ser diferente.
Por isso o protocolo acima importa mais que o número. Rode o curl com a decomposição por fase contra o seu domínio, a partir de uma conexão residencial brasileira, durante uma semana e em horários diferentes. Compare time_connect, time_appconnect e a diferença entre time_starttransfer e time_pretransfer já descontado o RTT. Se a maior parte do seu TTFB estiver na terceira, o Atlântico não é o seu problema e a troca de provedor não vai consertar nada.
Como medimos
Sondas em São Paulo, Rio de Janeiro, Belo Horizonte e Porto Alegre, em redes residenciais de operadoras diferentes, não em datacenter. Isso importa: medir de datacenter para datacenter dá números bonitos que o visitante nunca vai experimentar. Cada amostra é o tempo até o primeiro byte de uma requisição HTTPS a um arquivo de 1 KB, com conexão nova, sem reaproveitar sessão TLS. Descartamos as amostras com erro de rede, que foram 0,3% do total. Usamos mediana em vez de média porque picos isolados de roteamento distorcem a média e não representam a experiência comum.