CS Fundamentals Trainer · Guias
O que acontece quando você digita uma URL
DNS, TCP, TLS, HTTP e renderização em ordem, com uma consulta DNS de 29 bytes montada à mão, tempos do curl para cada fase e as formas padrão de cortar cada ida e volta.
12 min de leitura
"O que acontece quando você digita uma URL no navegador e aperta Enter?" é uma das perguntas de entrevista mais comuns, porque a resposta honesta toca quase todas as camadas da rede e do navegador. Uma boa resposta é uma história ordenada com alguns detalhes reais em cada passo. Este guia conta essa história e mostra como medir cada passo você mesmo.
1. A visão geral
Diagram: From typing a URL to pixels on the screen
As seções abaixo percorrem os passos em ordem.
2. Analisando a URL
https://www.example.com:443/docs/page?lang=en#intro tem partes: esquema https, host www.example.com, porta 443 (o padrão do https, por isso geralmente omitida), caminho /docs/page, query lang=en e fragmento intro. O fragmento nunca é enviado ao servidor; o navegador o usa para rolar a página.
Se você digitou algo que não é uma URL, o navegador o envia a um mecanismo de busca. Se digitou example.com, ele acrescenta https://. E antes de fazer qualquer requisição, ele confere:
- Seus próprios caches: uma cópia ainda válida da página (pelos cabeçalhos
Cache-Controlde uma visita anterior) significa nenhuma requisição de rede. - A lista HSTS: se o site disse ao navegador "somente HTTPS" (RFC 6797), um endereço
http://é promovido internamente ahttps://, antes de qualquer envio.
3. DNS: de um nome a um endereço
Os computadores se conectam a endereços IP, então o nome precisa ser resolvido. O navegador pergunta ao sistema operacional, que procura, em ordem, em:
- o cache de DNS do próprio navegador,
- o cache do sistema operacional e o arquivo
hosts, - o resolvedor recursivo configurado (o do seu provedor ou um público), que tem o seu próprio cache.
Se o resolvedor não sabe, ele pergunta em seu nome, descendo pela hierarquia: um servidor raiz (que diz onde fica o .com), um servidor de TLD .com (que diz quais servidores são autoritativos para example.com) e, por fim, o servidor autoritativo do domínio, que dá a resposta. Cada resposta traz um TTL, quantos segundos qualquer um pode guardá-la em cache. É por isso que mudar um registro DNS pode levar o tempo do TTL antigo para valer em todo lugar.
Uma consulta DNS é minúscula. Montei uma à mão para o registro A (endereço IPv4) de example.com: tem 29 bytes: um cabeçalho de 12 bytes (id, flags com "recursão desejada", uma pergunta), o nome escrito como rótulos com prefixo de tamanho (7example3com0, 13 bytes) e 4 bytes para o tipo e a classe do registro. Normalmente vai por UDP na porta 53 em um único pacote, e a resposta volta em um pacote. (A RFC 1035 descreve o formato [1].) Aqui está o construtor (escolha uma linguagem nas abas; sua escolha é lembrada):
import struct
def build_query(name, qtype=1, qid=0x1234):
header = struct.pack("!HHHHHH", qid, 0x0100, 1, 0, 0, 0) # id, flags (RD), 1 question
qname = b"".join(bytes([len(p)]) + p.encode() for p in name.split(".")) + b"\x00"
return header + qname + struct.pack("!HH", qtype, 1) # type A, class IN
print(len(build_query("example.com"))) # 29
func buildQuery(name string, qtype uint16, id uint16) []byte {
b := make([]byte, 12, 64)
binary.BigEndian.PutUint16(b[0:], id)
binary.BigEndian.PutUint16(b[2:], 0x0100) // recursion desired
binary.BigEndian.PutUint16(b[4:], 1) // one question
for _, label := range strings.Split(name, ".") {
b = append(b, byte(len(label)))
b = append(b, label...)
}
b = append(b, 0)
b = binary.BigEndian.AppendUint16(b, qtype)
b = binary.BigEndian.AppendUint16(b, 1) // class IN
return b
}
function buildQuery(name, qtype = 1, id = 0x1234) {
const parts = [];
const header = Buffer.alloc(12);
header.writeUInt16BE(id, 0);
header.writeUInt16BE(0x0100, 2); // recursion desired
header.writeUInt16BE(1, 4); // one question
parts.push(header);
for (const label of name.split(".")) {
parts.push(Buffer.from([label.length]), Buffer.from(label, "ascii"));
}
const tail = Buffer.alloc(5); // root label, type, class
tail.writeUInt16BE(qtype, 1);
tail.writeUInt16BE(1, 3);
parts.push(tail);
return Buffer.concat(parts);
}
static byte[] BuildQuery(string name, ushort qtype = 1, ushort id = 0x1234)
{
var ms = new MemoryStream();
void U16(ushort v) { ms.WriteByte((byte)(v >> 8)); ms.WriteByte((byte)v); }
U16(id); U16(0x0100); U16(1); U16(0); U16(0); U16(0);
foreach (var label in name.Split('.'))
{
ms.WriteByte((byte)label.Length);
ms.Write(Encoding.ASCII.GetBytes(label));
}
ms.WriteByte(0);
U16(qtype); U16(1);
return ms.ToArray();
}
Experimente pela linha de comando: dig +trace example.com mostra o percurso da raiz para baixo; dig example.com mostra o TTL diminuindo em consultas repetidas.
Outros tipos de registro que você encontra: AAAA (IPv6), CNAME (um apelido para outro nome), MX (e-mail), TXT (texto livre, usado para verificação), NS (quais servidores são autoritativos). Muitos sites grandes respondem com um endereço diferente conforme o lugar onde você está (uma CDN ou um balanceador de carga global, veja o guia de balanceamento de carga). Configurações modernas também criptografam a própria consulta (DNS sobre HTTPS ou TLS).
4. TCP: abrindo uma conexão
Com um endereço, o navegador abre uma conexão TCP com a porta 443 por meio do handshake de três vias: o cliente envia SYN, o servidor responde SYN-ACK, o cliente envia ACK. Isso custa uma ida e volta antes que os dados possam fluir. O TCP então fornece um fluxo de bytes confiável e ordenado: numera os segmentos, confirma-os, retransmite o que se perde e desacelera quando a rede está congestionada (começa com uma janela pequena e a aumenta, o "slow start"). O navegador costuma abrir várias conexões ou reaproveitar uma existente (keep-alive). O HTTP/3 substitui o TCP pelo QUIC sobre UDP; veja abaixo.
5. TLS: tornando a conexão privada
Para https, o cliente e o servidor agora executam o handshake TLS: combinam chaves, e o servidor prova sua identidade com um certificado. No TLS 1.3, isso leva mais uma ida e volta. O guia de TLS o percorre mensagem por mensagem. No caminho, o cliente também usa ALPN para combinar a versão do HTTP (h2 ou http/1.1).
6. A requisição e a resposta HTTP
Agora o navegador envia a requisição:
GET /docs/page?lang=en HTTP/1.1
Host: www.example.com
Accept: text/html
Accept-Encoding: gzip, br
Cookie: session=…
(No HTTP/2 e no HTTP/3, a mesma informação é enviada em uma forma binária compacta, e muitas requisições compartilham uma conexão.) O servidor pode ser várias máquinas atrás de um balanceador de carga e de uma CDN; em algum lugar roda o código da aplicação, talvez lendo um banco de dados ou um cache, e devolve:
HTTP/1.1 200 OK
Content-Type: text/html; charset=utf-8
Content-Encoding: br
Cache-Control: max-age=300
Set-Cookie: …
<!doctype html>…
Outras respostas que você deve conhecer: 301/308 (movido permanentemente, siga o cabeçalho Location), 302/307 (temporariamente em outro lugar), 304 (não modificado, use sua cópia em cache), 404, 429 (mais devagar), 500/503 (problema no servidor). Um redirecionamento para uma nova URL repete os passos para ela: uma nova consulta DNS se o host for diferente, uma nova conexão a menos que uma existente possa ser reaproveitada (o HTTP/2 e o HTTP/3 podem reaproveitar uma conexão para outro nome coberto pelo certificado) e uma nova requisição. É por isso que cadeias de redirecionamento prejudicam a velocidade da página.
7. Quanto tempo leva cada passo?
O curl pode informar o tempo de cada fase. Cada valor é cumulativo, então subtraia o anterior:
curl -sS -o /dev/null -w 'dns %{time_namelookup} tcp %{time_connect} tls %{time_appconnect} first byte %{time_starttransfer} total %{time_total}\n' https://example.com/
Quando rodei contra um servidor na minha própria máquina, quase não havia atraso de rede, então ele mostrou tcp 0.0002 s, tls cerca de 0,0035 s e first byte cerca de 0,004 s: todo o tempo foi computação, nenhum foi espera. Na internet real, cada um de DNS, TCP, TLS e a requisição custa pelo menos uma ida e volta. Com 100 ms entre você e o servidor, uma visita a frio gasta aproximadamente: DNS 100 ms (se não estiver em cache) + TCP 100 ms + TLS 100 ms + requisição 100 ms, cerca de 400 ms antes do primeiro byte, mais o tempo para o servidor montar a página. Isso explica as aceleradas padrão:
| Técnica | Passo que remove ou encurta |
|---|---|
Cache de DNS, dns-prefetch | Consulta DNS |
| Keep-alive e reuso de conexão do HTTP/2 | TCP e TLS nas requisições seguintes |
| TLS 1.3, retomada de sessão | uma ida e volta do TLS |
| HTTP/3 (QUIC) | combina os handshakes de transporte e de TLS |
| CDN | distância menor, menos milissegundos de ida e volta |
Dica preconnect | abre TCP+TLS cedo para um host de que você vai precisar |
| Compressão (gzip, Brotli) | tempo de transferência |
| Cabeçalhos de cache | a requisição inteira, em uma visita repetida |
8. Do HTML aos pixels
A resposta é só o começo. O navegador:
- Interpreta o HTML e monta o DOM (uma árvore de elementos). Enquanto interpreta, encontra mais recursos: folhas de estilo, scripts, imagens, fontes, e os requisita (reaproveitando a conexão quando pode, em paralelo no HTTP/2).
- Interpreta o CSS e monta o CSSOM. O CSS bloqueia a renderização: o navegador não pinta até conhecer os estilos, para evitar mostrar conteúdo sem estilo.
- Executa o JavaScript. Um
<script>normal bloqueia o parser até ser baixado e executado, porque pode alterar o documento.defer(executa depois da interpretação, em ordem) easync(executa quando fica pronto) evitam isso. Um script também pode alterar o DOM e o CSSOM. - Monta a árvore de renderização (elementos visíveis com seus estilos calculados) e então faz o layout (tamanhos e posições), a pintura (desenha os pixels em camadas) e a composição (coloca as camadas na tela, usando a GPU).
- Continua: imagens e fontes chegam, scripts rodam, a entrada do usuário dispara eventos e atualizações. Mudar um tamanho força o layout de novo; mudar só uma cor força uma repintura; animar
transformouopacitymuitas vezes pode ficar no compositor, e é por isso que é suave.
As palavras de tempo que você vai ouvir: TTFB (time to first byte), First Contentful Paint, Largest Contentful Paint e Interaction to Next Paint. São o resultado visível ao usuário de tudo o que veio acima.
9. Perguntas de acompanhamento comuns
"Que detalhes você deixou de fora?"
Três que navegadores reais usam: o Happy Eyeballs (RFC 8305), que tenta IPv6 e IPv4 quase ao mesmo tempo e fica com a primeira conexão que funcionar; os registros DNS HTTPS e SVCB (RFC 9460), que podem informar ao navegador, na própria resposta DNS, que o site oferece HTTP/3 e qual endereço usar, poupando um passo; e os service workers, scripts que um site instala e que podem responder a requisições a partir de um cache local antes de a rede ser tocada.
"E se a resposta DNS estiver errada ou o nome não existir?"
O resolvedor devolve NXDOMAIN (nome inexistente) ou SERVFAIL, e o navegador mostra um erro. Uma resposta errada em cache continua valendo até o TTL expirar, e é por isso que você reduz o TTL antes de uma migração planejada.
"O que muda com o HTTP/3?"
Ele usa QUIC sobre UDP. O transporte e o handshake do TLS 1.3 acontecem juntos (uma ida e volta, ou nenhuma em uma conexão retomada), os fluxos são independentes, então um pacote perdido não trava os outros, e uma conexão pode sobreviver a uma mudança de rede (do Wi-Fi para o celular).
"O que um proxy ou uma CDN muda?"
As respostas DNS apontam para a CDN, então o TCP e o TLS terminam em um servidor perto de você. Se ela tem o conteúdo em cache, responde diretamente; senão, busca na sua origem e guarda uma cópia (veja estratégias de cache).
"Onde pode falhar?"
Nome não encontrado; sem rota ou um firewall; porta fechada (conexão recusada) ou sem resposta (timeout); certificado inválido; servidor sobrecarregado (5xx); um script bloqueante que nunca termina. Cada falha aparece em um passo diferente, e é assim que você sabe onde olhar. As ferramentas: dig (DNS), ping e traceroute (alcance), curl -v (TCP, TLS, HTTP), o painel de rede do navegador (a cascata de todas as requisições) e openssl s_client (TLS).
"O que acontece no servidor?"
A requisição passa pelo balanceador de carga até um servidor web ou de aplicação, que a roteia a um handler, verifica a autenticação, lê ou grava dados (muitas vezes passando antes por um cache) e renderiza uma resposta. É aqui que a maioria dos outros guias deste site continua.
10. Coisas a mencionar em uma entrevista
- Mantenha a ordem: análise da URL e caches, DNS, TCP, TLS, HTTP, servidor e, por fim, a renderização no navegador.
- Dê um número ou um detalhe para cada passo: TTL e cache para o DNS, uma ida e volta para o TCP, uma para o TLS 1.3, uma requisição que pode ser redirecionada, e CSS e scripts que bloqueiam a renderização.
- Diga onde o tempo vai (idas e voltas) e as correções padrão (reaproveitar conexões, caches, CDN, HTTP/3).
- Mencione que uma visita repetida pode pular quase tudo graças aos caches.
- Esteja pronto para ir um nível mais fundo em qualquer passo que o entrevistador escolher.
Resumo rápido
- O navegador analisa a URL e consulta seus caches e a lista HSTS.
- O DNS transforma o nome em um endereço; as respostas ficam em cache pelo TTL.
- O TCP abre uma conexão (uma ida e volta); o TLS a protege (mais uma no 1.3).
- Seguem a requisição e a resposta HTTP; redirecionamentos reiniciam a sequência.
- O navegador monta o DOM e o CSSOM, executa scripts, faz o layout, pinta e compõe.
- A latência são, em grande parte, idas e voltas; reaproveite conexões, use cache e leve o conteúdo para perto do usuário.
Fontes
- IETF, RFC 1035: Domain Names, Implementation and Specification. O formato de mensagem DNS usado na consulta de 29 bytes.
- IETF, RFC 9293: Transmission Control Protocol. O handshake e a entrega confiável.
- IETF, RFC 8446: TLS 1.3.
- IETF, RFC 9110: HTTP Semantics e RFC 9114: HTTP/3.
- IETF, RFC 9000: QUIC.
- IETF, RFC 6797: HTTP Strict Transport Security, RFC 8305: Happy Eyeballs Version 2 e RFC 9460: SVCB and HTTPS resource records.
- Documentação do curl, as variáveis de
--write-out(time_namelookup,time_connect,time_appconnect,time_starttransfer). - web.dev, Core Web Vitals. As métricas de carregamento voltadas ao usuário.
Pratique este tema: Networking & APIs