# 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.

> 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.

João Rizzon · 2026-10-31 · Servidores

---

## 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.

**114 ms** a mais, em mediana, para atender um usuário brasileiro a partir de Miami em vez de São Paulo (n=1440, julho de 2026)

## 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_connect` menos `time_namelookup` é o RTT de TCP. É o seu RTT puro de rede.
- `time_appconnect` menos `time_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_starttransfer` menos `time_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 em `time_connect` menos `time_namelookup`. O que sobra (PHP, Node, banco) **não melhora** migrando de região; o round-trip embutido, esse sim, melhora.
- `num_connects` maior 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 fetch` pagou 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 `rsync` de 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 com `curl -IL` e confira `num_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 como `New`, e as reconexões seguintes como `Reused`. Variante em dois passos: `-sess_out /tmp/s.pem` na primeira conexão e `-sess_in /tmp/s.pem` na segunda. Com resumption ativa, a segunda conexão corta um round-trip de `time_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_starttransfer` menos `time_pretransfer` e desconte o RTT (`time_connect` menos `time_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.
