CS Fundamentals Trainer · Guias
DNS, HTTP/2, HTTP/3 e CDNs
Como um nome é resolvido e guardado em cache, o que custa uma conexão nova, como a multiplexação do HTTP/2 e o HTTP/3 sobre QUIC removem o bloqueio de cabeça de fila, e como a taxa de acertos, as chaves de cache e os cabeçalhos de uma CDN decidem o seu valor.
34 min de leitura
Antes que um navegador possa mostrar uma página, ele precisa achar o servidor (DNS), abrir uma conexão e combinar a criptografia (TCP e TLS, ou QUIC), pedir a página e suas dezenas de subrecursos (HTTP), e os bytes precisam atravessar o mundo (a rede, ajudada por uma CDN). Cada passo acrescenta round trips, e um round trip através de um oceano custa mais que qualquer quantidade de código esperto de um lado ou do outro. Este guia segue a requisição nessa ordem e explica o que o cache de DNS, o HTTP/2, o HTTP/3 e as CDNs mudam, com experimentos que executei para obter os números.
O percurso mais curto de toda a jornada está em o que acontece quando você digita uma URL, e a parte da criptografia está em TLS e HTTPS. Este guia aprofunda os três lugares onde a performance e a operação são decididas.
1. DNS
O Domain Name System mapeia nomes para registros, na maioria das vezes um endereço IP. É um banco de dados distribuído, hierárquico e com cache.
Diagram: Resolving www.example.com through a recursive resolver
Percorra-o passo a passo, com e sem cache:
Interactive animation: dns lookup
Com o cache vazio, a consulta levou quatro round trips (navegador até o resolvedor, depois raiz, .com e o servidor autoritativo); com a resposta em cache no resolvedor, levou um. Os resolvedores reais também guardam em cache as delegações (os registros NS de .com), então uma consulta por um nome novo sob um domínio conhecido em geral pula os passos da raiz e do TLD.
O que vai pelo fio
Uma mensagem DNS é pequena. Montei à mão uma consulta por www.example.com seguindo a RFC 1035: um cabeçalho de 12 bytes (id, flags, contagens) seguido do nome como rótulos com prefixo de comprimento (03 www 07 example 03 com 00), depois o tipo de registro (1 para A) e a classe (1 para IN). A consulta inteira tem 33 bytes, e uma resposta com um registro A tem 49 bytes, porque o nome da resposta é um ponteiro de 2 bytes de volta para a pergunta (c0 0c) em vez de repeti-lo. O DNS normalmente viaja por UDP na porta 53, com um recurso de reserva em TCP quando a resposta é grande demais ou foi truncada. As variantes criptografadas (DNS sobre TLS na porta 853, DNS sobre HTTPS) escondem as consultas da rede entre o cliente e o resolvedor; o resolvedor ainda as vê.
Tipos de registro que vale conhecer
| Tipo | Significado |
|---|---|
| A / AAAA | endereço IPv4 / IPv6 |
| CNAME | um alias: "este nome é na verdade aquele outro nome". Não é permitido no ápice da zona ao lado de outros registros |
| NS | quais servidores são autoritativos para uma zona |
| MX | servidores de e-mail de um domínio |
| TXT | texto livre, usado para verificação de domínio, SPF, DKIM |
| SOA | metadados da zona, incluindo o TTL das respostas negativas |
| SRV / HTTPS (SVCB) | localização e parâmetros do serviço, como as portas e os protocolos (por exemplo HTTP/3) que um serviço suporta |
Uma resposta negativa (o nome não existe) também é guardada em cache, por um tempo dado pelo registro SOA da zona (RFC 2308), de modo que um erro de digitação em um hostname que o seu serviço repete agressivamente não chega ao servidor autoritativo todas as vezes.
TTL: o botão entre velocidade e agilidade
Todo registro tem um time to live que diz aos resolvedores por quanto tempo podem reutilizá-lo. Um TTL curto permite mover o tráfego rapidamente; um longo economiza consultas e acelera os clientes. Em uma simulação de um nome consultado cerca de duas vezes por segundo, um resolvedor recursivo enviou esta quantidade de consultas a montante em um dia:
| TTL | Consultas a montante por dia |
|---|---|
| 0 s (sem cache) | 172.304 (toda consulta) |
| 5 s | 15.702 |
| 60 s | 1.429 |
| 300 s | 288 |
| 3600 s | 24 |
E quando você muda um registro, a resposta antiga continua viva nos caches até o seu TTL expirar. Se as cópias dos resolvedores foram obtidas em momentos aleatórios, elas se atualizam de forma uniforme ao longo do TTL antigo: com um TTL de 300 segundos, metade vê o valor novo em cerca de 150 s e o último depois de 300 s; com um TTL de 24 horas, a mesma dispersão leva um dia. Navegadores, sistemas operacionais e algumas aplicações (a JVM é famosa por isso) acrescentam os seus próprios caches, e alguns resolvedores ignoram TTLs pequenos ou continuam servindo respostas obsoletas quando a autoridade está inalcançável (RFC 8767). Então:
- Reduza o TTL antes de uma mudança planejada, com pelo menos um TTL antigo de antecedência, e aumente-o depois.
- O failover baseado em DNS é lento e grosseiro. Uma verificação de saúde pode mudar a resposta, mas os clientes com a resposta antiga ficam com ela até expirar, e alguns nunca largam a conexão aberta. É uma camada útil, não rápida.
- Não ponha balanceamento de carga dinâmico em TTLs longos. Veja balanceamento de carga para as camadas que reagem mais rápido.
O DNS também é uma clássica dependência escondida: se o resolvedor é lento, toda requisição é lenta; se o provedor autoritativo cai, o seu site cai mesmo que os seus servidores estejam bem. Use mais de um servidor de nomes, idealmente em provedores independentes ou em um provedor que ele próprio se espalhe por várias redes, e aplique os timeouts e as repetições do guia de resiliência também às chamadas ao resolvedor.
2. Abrindo a conexão: round trips
Antes que o primeiro byte da página possa ser pedido, o cliente precisa montar um transporte e a criptografia. Contando os round trips (RTT) desde o início da conexão:
| Pilha | Round trips antes de a requisição poder ser enviada |
|---|---|
| HTTP/1.1 ou HTTP/2 sobre TCP e TLS 1.2 | 3 (TCP: 1, TLS 1.2: 2) |
| TCP e TLS 1.3 | 2 (TCP: 1, TLS: 1) |
| QUIC (HTTP/3), servidor novo | 1 (handshake de transporte e TLS 1.3 combinados) |
| QUIC com retomada 0-RTT | 0, com a requisição no primeiro voo (reproduzível, então só para requisições seguras) |
Se o round trip até o servidor é de 100 ms, a diferença entre 3 e 1 são 200 ms antes que qualquer coisa útil aconteça, em toda conexão nova, além da consulta DNS.
Leia a tabela como o mínimo idealizado para uma primeira conexão, porque ela supõe coisas que muitas vezes não são verdade:
- Nenhuma perda de pacotes. Um pacote de handshake perdido custa um timeout de retransmissão, bem mais longo que um round trip (um timeout inicial de um segundo mais ou menos é comum no TCP), então a cauda da distribuição do tempo de conexão é muito pior que a mediana.
- Um handshake completo sem nada lembrado. O TLS 1.2 com retomada de sessão precisa de um round trip, não dois. A retomada do TLS 1.3 economiza a troca de certificado, e o TLS 1.3 com early data permite uma requisição no primeiro voo (com o mesmo risco de replay do 0-RTT do QUIC). O TCP Fast Open pode carregar dados no SYN, embora raramente seja implantado na internet aberta.
- Uma cadeia de certificados que cabe. Uma cadeia longa ou um certificado grande pode exceder a janela de congestionamento inicial e custar um round trip extra, no TCP e no QUIC (os servidores QUIC podem enviar no máximo cerca de três vezes o que receberam de um endereço de cliente não validado, o que também limita o primeiro voo). As verificações de revogação (OCSP) e outros passos de validação podem acrescentar tempo, a menos que o servidor grampeie (staple) a resposta.
- O cliente já sabe que deve usar HTTP/3. Um navegador normalmente descobre que um servidor fala HTTP/3 por um cabeçalho
Alt-Svcou por um registro DNSHTTPS, então a primeira visita costuma ir por TCP e TLS, e as visitas seguintes usam QUIC. Alguns clientes fazem os dois competirem. - Uma conexão existente é reutilizada. O reuso de conexões, a multiplexação e a coalescência de conexões (usar uma conexão HTTP/2 ou HTTP/3 para vários hostnames que compartilham um certificado e um endereço) fazem a maioria das requisições de uma página real não precisar de nenhum handshake.
- O RTT não é a história toda. A criptografia, o processamento no servidor, os middleboxes, o DNS (uma consulta separada, em cache ou não) e os primeiros bytes do slow start se somam a ele, e o próprio round trip varia de uma requisição para a outra.
As contagens são, portanto, uma forma de raciocinar sobre onde o tempo vai, não uma previsão de quanto uma conexão vai levar. Para saber os seus próprios números, meça-os (ferramentas de desenvolvedor do navegador, curl -w com as suas variáveis de tempo, monitoramento de usuários reais), nos percentis que importam.
Duas consequências práticas: reutilize as conexões (keep-alive, multiplexação do HTTP/2, pools de conexões) e ponha o servidor perto do usuário, que é o que uma CDN faz.
3. HTTP/1.1, HTTP/2 e HTTP/3
Uma página não é uma requisição; é o HTML mais scripts, estilos, imagens e chamadas de API, muitas vezes 50 ou mais.
O HTTP/1.1 carrega uma requisição por vez por conexão. O pipelining existia no papel, mas nunca foi usável de forma confiável. Os navegadores contornaram o limite abrindo até seis conexões por host e fazendo "sharding" dos recursos em vários hostnames, e ambos custam handshakes e controle de congestionamento por conexão.
O HTTP/2 (RFC 9113) mantém a mesma semântica (métodos, códigos de status, cabeçalhos), mas muda o enquadramento:
- Enquadramento binário e multiplexação: muitos streams de requisição/resposta compartilham uma conexão, com os seus quadros intercalados.
- Compressão de cabeçalhos (HPACK): cabeçalhos repetidos, como cookies e user agents, são enviados como referências a uma tabela.
- Priorização de streams (uma dica ao servidor sobre quais recursos mais importam; as implementações diferem muito).
- O server push existia na especificação, mas se mostrou difícil de usar bem e os navegadores o removeram. Não projete em torno dele.
Para ver o efeito, servi 60 respostas pequenas, cada uma levando 50 ms para ser produzida no servidor, a partir de um servidor Node local, e busquei todas:
| Cliente | Tempo para 60 requisições |
|---|---|
| HTTP/1.1, uma conexão | 3.058 ms (60 vezes 50 ms, uma depois da outra) |
| HTTP/1.1, seis conexões | 515 ms (dez rodadas de seis) |
| HTTP/2, uma conexão | 59 ms (tudo em paralelo) |
Este teste usa um atraso fixo no servidor no lugar da latência de rede e roda em loopback sem criptografia (o HTTP/2 em texto claro só serve para testes; os navegadores o usam sobre TLS), então mostra o efeito de fila, não tempos reais de carregamento de página. Explica por que as práticas da era do HTTP/1.1 (sharding de domínios, juntar tudo em um só arquivo, spriting) importam menos ou atrapalham sob o HTTP/2.
O problema que resta: o bloqueio de cabeça de fila
O HTTP/2 multiplexa streams, mas é o transporte por baixo dele que causa o problema, não o enquadramento do próprio HTTP/2. Todos os streams viajam em uma conexão TCP, e o TCP entrega à aplicação um único fluxo ordenado de bytes. Se um segmento TCP se perde, o TCP segura todos os bytes que chegaram depois dele, pertencentes a qualquer stream, até que a retransmissão preencha a lacuna. O HTTP/2 não enxerga os segmentos, então streams que não perderam nada também travam. (Este é o bloqueio de cabeça de fila em nível de transporte. O HTTP/1.1 tinha o seu próprio, no nível do HTTP: uma resposta lenta bloqueava a seguinte na mesma conexão. O HTTP/2 removeu esse e deixou o do TCP.) Se uma única perda machuca muito depende de quantos dados de quantos streams estavam em trânsito atrás dela, e é por isso que as páginas com muitos streams paralelos em enlaces com perdas sofrem mais.
Diagram: One lost packet and what it blocks
Percorra passo a passo a mesma situação, primeiro com uma conexão ordenada e depois com streams independentes:
Interactive animation: head of line
Na animação, três streams enviam um pacote por tick e um pacote do stream A se perde. Streams independentes são melhores, não de graça: os dados perdidos ainda precisam ser retransmitidos, o stream que os perdeu ainda espera e (na próxima seção) todos os streams ainda compartilham o controle de congestionamento de uma única conexão. Com uma conexão ordenada, os pacotes passaram 26 ticks no total esperando atrás da perda de outro; com streams independentes, apenas 6, os do próprio stream A. Executei também uma simulação maior, com perda aleatória e um atraso de retransmissão de 5 ticks, e medi o tempo médio que um pacote espera entre chegar e ser entregue à aplicação:
| Perda de pacotes, 3 streams | Conexão ordenada (TCP) | Streams independentes (QUIC) |
|---|---|---|
| 0,5% | 0,32 ticks | 0,08 ticks |
| 1% | 0,54 | 0,15 |
| 2% | 0,72 | 0,22 |
| 5% | 1,63 | 0,55 |
E com 1% de perda, com um número crescente de streams, a conexão ordenada piora (0,10, 0,54, 1,33 e 2,67 ticks para 1, 3, 10 e 30 streams) enquanto os streams independentes ficam em torno de 0,10. Com um stream não há diferença: o dano é proporcional ao número de streams que precisam esperar uns pelos outros. Isto é um modelo, não uma medição de rede. Trata a perda como independente por pacote, dá a cada pacote um stream, ignora o controle de congestionamento (então não consegue mostrar que todos os streams desaceleram depois de uma perda em qualquer dos protocolos) e conta a espera em ticks. Os ganhos reais dependem do padrão de perda, do controle de congestionamento, do tamanho e do número dos streams e da página, e as medições de campo do HTTP/3 contra o HTTP/2 mostram benefícios reais mas modestos na mediana e maiores na cauda em redes ruins.
HTTP/3 e QUIC
O HTTP/3 (RFC 9114) roda o HTTP sobre o QUIC (RFC 9000), um transporte construído sobre UDP que oferece:
- Streams independentes, de modo que uma perda atrasa apenas os streams cujos dados estavam no pacote perdido. O QUIC ordena os dados por stream, não para a conexão inteira, então os dados de outro stream que chegaram podem ser entregues à aplicação de imediato. Três ressalvas impedem que isto seja uma cura completa: um pacote pode carregar quadros de vários streams, e então cada um deles espera pela sua retransmissão; todos os streams de uma conexão ainda compartilham um controlador de congestionamento e um controle de fluxo em nível de conexão, então uma perda faz o remetente desacelerar para todos os streams; e uma perda no handshake ou nos dados de controle da conexão pode travar a conexão inteira. O ganho é maior com vários streams simultâneos, em redes com perdas, com perdas em rajada evitadas por um bom controle de congestionamento.
- TLS 1.3 embutido: os handshakes de transporte e criptográfico são combinados, dando a configuração de conexão de 1 RTT (e 0-RTT) da tabela acima. Quase todo o pacote é criptografado, incluindo boa parte dos metadados do próprio transporte.
- IDs de conexão, para que uma conexão sobreviva a uma mudança de endereço IP, por exemplo um celular passando do Wi-Fi para os dados móveis, enquanto o TCP está preso à quádrupla de endereços e portas.
- Compressão de cabeçalhos com QPACK, a contrapartida do HPACK no HTTP/3, projetada para funcionar com streams que chegam fora de ordem.
Não é de graça. O QUIC roda no espaço do usuário e consome mais CPU que o TCP do kernel e seus offloads, algumas redes bloqueiam ou limitam o UDP, e os dados 0-RTT podem ser reproduzidos por um atacante, então os servidores só devem aceitá-los para requisições que sejam seguras de repetir. Os clientes, portanto, descobrem o HTTP/3 e recuam: um servidor o anuncia com um cabeçalho Alt-Svc (ou o registro DNS HTTPS), a primeira visita costuma usar HTTP/2 sobre TCP, e as seguintes tentam o QUIC e competem ou recuam se o UDP não funcionar. Para você, desenvolvedor de aplicações, a semântica não muda; o que muda é como você configura a borda e o que você monitora.
4. CDNs
Uma content delivery network é um conjunto de servidores de cache (edges ou pontos de presença) espalhados pelo mundo. Os usuários se conectam a um edge próximo; se o edge tem o objeto, responde na hora (um hit), e se não tem, busca-o na origem (um miss), guarda uma cópia e responde.
Diagram: A request through a CDN
Os edges trazem três benefícios: latência (os handshakes de TCP e TLS terminam em um servidor a poucos milissegundos, e o longo trecho até a origem usa uma conexão quente e reutilizada), alívio (a origem vê apenas os misses) e absorção de picos de tráfego e de alguns ataques. Um origin shield é uma camada de cache extra na frente da origem, de modo que cem edges pedindo o mesmo objeto ausente causem uma requisição à origem, não cem.
Como o usuário chega ao edge mais próximo
Ou o DNS responde de forma diferente conforme o lugar onde está o resolvedor (os servidores de nomes da CDN devolvem o endereço de um edge próximo), ou a CDN usa anycast, anunciando o mesmo endereço IP de muitos lugares para que o roteamento entregue os pacotes ao mais próximo. Muitas usam as duas coisas. Uma consequência da abordagem por DNS é que o "mais próximo" é escolhido pela localização do resolvedor, que nem sempre é a do usuário.
De que depende a taxa de acertos
A latência média é aritmética simples: com um hit a 20 ms e um miss a 140 ms (20 ms até o edge e 120 ms até a origem), uma taxa de acertos de 50% dá 80 ms, 80% dá 44 ms, 95% dá 26 ms e 99% dá 21 ms. A carga na origem é a parcela de misses: 50%, 20%, 5%, 1%. Os últimos pontos percentuais da taxa de acertos valem muito para a origem.
O que determina a taxa? Simulei 200.000 requisições a 10.000 objetos em que alguns são muito mais populares que outros (uma distribuição de Zipf), com um cache LRU em um edge:
| O cache do edge guarda | Taxa de acertos, popularidade muito concentrada | Taxa de acertos, popularidade mais plana |
|---|---|---|
| 0,1% do catálogo | 13,1% | não medido |
| 1% | 39,1% | 4,3% |
| 5% | 58,7% | 15,1% |
| 20% | 76,8% | 38,0% |
Um cache com 1% dos objetos serviu 39% das requisições quando a popularidade é concentrada, e apenas 4% quando é plana. É por isso que as CDNs são excelentes para recursos estáticos populares e muito menos para a cauda longa (um catálogo enorme de objetos raramente pedidos), em que o edge precisa perguntar à origem quase sempre, e por isso uma camada de shield e caches maiores importam nesse caso. A mesma simulação com um limite de tempo para os objetos em cache (um TTL medido em requisições, com um cache de 20%) fez a taxa de acertos cair de 76,8% para 69,1%, 46,2% e 23,3% para TTLs de 5000, 500 e 50 requisições: a expiração joga fora cópias úteis. Quando a origem não mudou, uma requisição condicional (If-None-Match com um ETag) deixa o edge revalidar barato, com uma resposta 304 e sem corpo, em vez de baixar de novo.
Controlando o cache
O edge obedece aos cabeçalhos de cache HTTP que a sua origem envia (RFC 9111):
Cache-Control: public, max-age=31536000, immutablepara recursos com impressão digital (um nome de arquivo com um hash do conteúdo): guarde em cache por um ano, nunca revalide.Cache-Control: s-maxage=60para definir uma duração diferente para os caches compartilhados (CDNs) e para os navegadores (max-age).stale-while-revalidateestale-if-errorpara servir uma cópia expirada enquanto a atualiza em segundo plano, ou quando a origem está falhando. É uma medida barata de resiliência.Varydiz aos caches que a resposta depende de um cabeçalho da requisição (Accept-Encoding,Accept-Language). Cada valor distinto é uma cópia separada em cache, entãoVary: CookieouVary: User-Agentdestrói a taxa de acertos.Cache-Control: privateouno-storepara respostas personalizadas ou sensíveis; um cache compartilhado que guarda uma resposta destinada a um usuário pode mostrá-la a outro, um bug clássico e sério. Observe também a chave de cache: se ela ignora algo de que a resposta depende (um parâmetro de query, um cabeçalho), os usuários recebem as variantes uns dos outros.
Invalidação: expurgar é lento, parcial e sujeito a corridas
A invalidação é a parte difícil (como sempre com caches; veja estratégias de cache). Uma CDN oferece várias ferramentas, e cada uma tem limites:
- Purge por URL, por prefixo ou por tag (também chamadas de surrogate keys: a origem rotula as respostas, e um purge por rótulo remove todas). Um purge é uma mensagem enviada a todos os edges e shields, então é aplicado eventualmente: de cerca de um segundo a minutos, conforme o provedor, e por um tempo curto alguns locais ainda servem a cópia antiga. Leia o que o seu provedor promete e não suponha que um purge é instantâneo nem que teve sucesso em todo lugar.
- O soft purge (marcar como obsoleto) mantém o objeto, mas faz o edge revalidá-lo ou buscá-lo de novo. Protege a origem de uma debandada e funciona bem com
stale-while-revalidate. - A corrida com a origem. Se você faz o purge antes de a origem servir a versão nova (uma réplica que ainda está atrasada, um deploy que ainda está sendo implantado), um edge busca o conteúdo antigo e o guarda de novo. Atualize primeiro a origem, garanta que está consistente, e só então faça o purge.
- Várias camadas de cache. O edge, o origin shield, o seu próprio proxy reverso e o navegador do usuário guardam cada um uma cópia. Um purge não alcança os navegadores, então uma página guardada lá por uma hora fica por uma hora. As camadas também precisam ser expurgadas em uma ordem que não reabasteça uma a partir de outra.
- As respostas negativas e de erro também podem ser guardadas em cache (um 404 ou uma página de erro por pouco tempo, o que em geral é bom para a origem e ruim se o erro era passageiro). Confira quais códigos de status a sua CDN guarda em cache e por quanto tempo.
- Colapso de requisições. Quando um objeto popular expira, centenas de requisições podem chegar de uma vez; as CDNs podem colapsá-las em uma só requisição à origem, mas as outras esperam por ela, e uma origem lenta significa respostas lentas para todas.
Então a estratégia mais segura é tornar os recursos imutáveis mudando a sua URL a cada versão, manter o HTML com durações curtas (ou stale-while-revalidate) e reservar o purge para os casos que realmente precisam (uma página incorreta, conteúdo removido, um pedido legal), com uma verificação de que funcionou (peça o objeto de várias regiões e compare o Age e o cabeçalho de status de cache da CDN).
Respostas personalizadas e privadas
Um cache compartilhado guarda uma resposta e a serve a muitas pessoas, o que é exatamente errado para qualquer coisa que dependa de quem está pedindo. Seja explícito:
- Marque as respostas com o seu público.
Cache-Control: privatepermite que só o navegador do próprio usuário a guarde;no-storesignifica que ninguém deve guardá-la (use para dados sensíveis, como páginas de conta, tokens, dados de saúde ou financeiros, porqueprivateainda deixa o navegador gravá-la em disco). Uma resposta a uma requisição com cabeçalhoAuthorizationnão é guardada por um cache compartilhado a menos que a origem o permita explicitamente (public,s-maxageoumust-revalidate), e as respostas que definem cookies devem ser tratadas com muito cuidado. Não confie nos padrões: muitas CDNs guardam em cache por extensão de arquivo ou regras de caminho se não forem instruídas de outro modo, e algumas sobrescrevem os cabeçalhos da origem pela sua própria configuração (uma regra de "TTL de cache no edge"), o que pode guardar em silêncio algo que a origem marcou como privado. - Faça a chave de cache corresponder à resposta. Se o conteúdo depende de um cookie, um cabeçalho, o idioma, o tipo de dispositivo ou um parâmetro de query, ou a chave o inclui (e cada valor distinto vira uma cópia separada, então mantenha o conjunto pequeno e normalizado), ou a resposta não deve ser guardada. Uma chave que ignora algo de que a resposta depende dá aos usuários o conteúdo uns dos outros.
- Conheça os dois ataques clássicos. Na web cache deception, um atacante faz uma vítima abrir uma URL como
/account/settings/x.css; a origem ignora o segmento extra e devolve a página privada da vítima, enquanto a CDN vê um arquivo "estático" e o guarda, de modo que o atacante então pede a mesma URL e recebe a página privada. Na web cache poisoning, um cabeçalho de requisição que a origem usa mas a chave de cache deixa de fora permite que um atacante guarde uma resposta nociva que depois é servida a outros. Defesas: não deixe sufixos de caminho ou extensões decidirem a possibilidade de cache, faça a origem devolver 404 para caminhos que não existem, envieCache-Control: no-storeem toda página autenticada por padrão e componha a chave com tudo o que a resposta usa. - Personalize na borda da página, não na página inteira. Guarde em cache a casca compartilhada (ou a resposta de API compartilhada) e carregue a parte pessoal (um nome de usuário, a contagem do carrinho) com uma requisição
no-storeseparada ou no navegador. Onde arquivos privados são servidos por uma CDN (faturas, downloads), use URLs ou cookies assinados de curta duração e faça a assinatura ser parte do controle de acesso, não só da chave de cache, e impeça que o cache os sirva a quem adivinhar a URL. - Os vazamentos também acontecem fora do cache. Os logs da CDN e do edge guardam URLs, endereços IP e cabeçalhos, então mantenha tokens e dados pessoais fora das URLs e das query strings, e confira as regras de retenção e de acesso desses logs.
- Teste. Peça a mesma URL como dois usuários diferentes e como um visitante anônimo; confira que o segundo usuário nunca recebe o conteúdo do primeiro e olhe o cabeçalho de status de cache (
Age,X-Cacheou o equivalente do provedor) nas rotas autenticadas: qualquerHITem uma página pessoal é um bug a corrigir antes de virar um incidente.
Muitas CDNs também terminam o TLS, aplicam um firewall de aplicação web e limites de taxa na borda (compare projetando um rate limiter) e executam pequenas funções no edge. Terminar o TLS significa que a CDN pode ler todo o tráfego, então ela faz parte da sua fronteira de confiança e das suas obrigações de privacidade. Para requisições dinâmicas e não armazenáveis em cache, a CDN ainda ajuda terminando o handshake perto do usuário e levando a requisição até a origem por uma conexão persistente e otimizada.
5. Erros comuns
- Definir um TTL de DNS muito longo em um registro que você talvez precise mover, ou esquecer de reduzi-lo antes de uma migração.
- Um único provedor de DNS ou um único servidor de nomes como um ponto único de falha escondido.
- Contar com o failover por DNS para uma recuperação rápida.
- Manter os contornos do HTTP/1.1 (muitos domínios, bundles gigantes) depois de passar para o HTTP/2 ou 3.
- Supor que o HTTP/3 torna tudo mais rápido; ele ajuda mais em redes com perdas e móveis e em conexões novas, e os ganhos para um cliente cabeado e rápido são pequenos.
- Guardar respostas personalizadas em cache no edge, ou uma chave de cache que omite um cabeçalho variável; deixar sufixos de caminho decidirem que uma página autenticada é "estática"; usar
privateonde é precisono-store. - Fazer o purge antes de a origem ser atualizada, supor que um purge é instantâneo, ou esquecer que os navegadores guardam a própria cópia.
Vary: Cookieou nenhum cabeçalho de cache, o que faz da CDN uma simples passagem.- Usar o purge como única estratégia de invalidação, em vez de URLs versionadas.
- Medir uma CDN com uma única requisição repetida: a primeira requisição a cada edge é um miss.
6. Coisas a mencionar em uma entrevista
- O caminho da resolução (stub, resolvedor recursivo, raiz, TLD, autoritativo) e que o cache com TTL é o que faz o DNS escalar; a troca entre TTLs curtos e longos.
- Round trips antes da primeira requisição: TCP mais TLS comparado com QUIC, e por que o reuso de conexões importa.
- O que o HTTP/2 corrige (multiplexação e compressão de cabeçalhos) e o que deixa (o bloqueio de cabeça de fila do TCP), e como o QUIC reduz isso com a ordenação por stream sobre UDP, com suas ressalvas (controle de congestionamento compartilhado, vários streams em um pacote).
- Uma CDN como um cache geograficamente espalhado: taxa de acertos, origin shield, chaves de cache e
Vary,Cache-Control, URLs versionadas contra purges, como o purge realmente se comporta e como manter respostas personalizadas e privadas fora dos caches compartilhados (incluindo cache deception e poisoning). - Que o benefício do cache depende da distribuição de popularidade, e que a cauda longa é o caso difícil.
Resumo rápido
- O DNS é uma hierarquia com cache: quatro round trips a frio (navegador até o resolvedor, raiz, TLD, autoritativo), um quando está em cache. O TTL troca agilidade por carga e velocidade (172.304 consultas por dia sem cache, 288 com 300 s), e uma mudança leva até o TTL antigo para ser vista em todo lugar.
- Uma conexão nova custa 2 RTT com TCP e TLS 1.3, 1 com QUIC e 0 com retomada (reproduzível), como mínimos idealizados que supõem nenhuma perda, nenhum estado em cache além do declarado e um certificado que cabe; o reuso de conexões remove a maioria dos handshakes na prática.
- O HTTP/2 multiplexa streams em uma conexão (59 ms contra 515 ms e 3.058 ms no teste), mas o fluxo único e ordenado de bytes do TCP deixa um segmento perdido travar todos os streams; o HTTP/3 sobre QUIC ordena os dados por stream, então streams não relacionados não são retidos, embora streams em um mesmo pacote e o controle de congestionamento compartilhado ainda liguem o seu destino.
- Uma CDN leva o conteúdo para perto dos usuários; seu valor é a taxa de acertos, que depende da concentração da popularidade, do tamanho do cache, dos TTLs e de uma chave de cache correta. A invalidação é eventual (então use URLs versionadas), e as respostas personalizadas ou privadas precisam de
no-storeouprivate, uma chave de cache correta e testes.
Apêndice: o código dos experimentos
Foram usados Python 3 (somente biblioteca padrão) e Node.js 22. As contagens de round trips da seção 2 são aritmética sobre os voos de mensagens do protocolo (veja as ressalvas ali), não medições. Os scripts de DNS, de bloqueio de cabeça de fila e de CDN usam sementes aleatórias fixas e dão os mesmos números a cada execução; o teste do HTTP/2 mede tempo real em loopback, então seus milissegundos variam um pouco entre execuções. O servidor HTTP/2 usa um atraso fixo de 50 ms por resposta no lugar da latência de rede, e HTTP/2 em texto claro (que os navegadores não usam); os scripts de bloqueio de cabeça de fila e de CDN são modelos simples. Eles ilustram os mecanismos e não são medições de nenhuma rede nem CDN real.
Nomes no fio, cache do resolvedor e TTL
import struct, random
# ---- 1. what a DNS query looks like on the wire (RFC 1035)
def encode_name(name):
return b"".join(bytes([len(p)]) + p.encode() for p in name.rstrip(".").split(".")) + b"\x00"
def build_query(name, qtype=1, txid=0x1234):
header = struct.pack("!HHHHHH", txid, 0x0100, 1, 0, 0, 0) # recursion desired, 1 question
return header + encode_name(name) + struct.pack("!HH", qtype, 1)
q = build_query("www.example.com")
print(len(q), "bytes:", q.hex(" "))
def build_response(name, ip, ttl):
header = struct.pack("!HHHHHH", 0x1234, 0x8180, 1, 1, 0, 0) # response, recursion available, 1 answer
question = encode_name(name) + struct.pack("!HH", 1, 1)
answer = b"\xc0\x0c" + struct.pack("!HHIH", 1, 1, ttl, 4) + bytes(map(int, ip.split("."))) # \xc0\x0c = pointer to offset 12
return header + question + answer
def parse_response(data):
txid, flags, qd, an, _, _ = struct.unpack("!HHHHHH", data[:12]); i = 12
while data[i]: i += data[i] + 1 # skip the question name
i += 1 + 4
out = []
for _ in range(an):
if data[i] & 0xC0 == 0xC0: i += 2 # compressed name: a pointer
else:
while data[i]: i += data[i] + 1
i += 1
typ, cls, ttl, rdlen = struct.unpack("!HHIH", data[i:i+10]); i += 10
out.append((typ, ttl, ".".join(map(str, data[i:i+rdlen])))); i += rdlen
return out
r = build_response("www.example.com", "93.184.216.34", 300)
print(len(r), "byte response ->", parse_response(r))
# ---- 2. a recursive resolver with a cache: how many upstream queries do a day of lookups cause?
def resolver_day(ttl, lookups_per_s=2, seconds=86400, seed=1):
rnd = random.Random(seed); cache_until = -1; upstream = 0; t = 0.0
while t < seconds:
t += rnd.expovariate(lookups_per_s)
if t >= cache_until: upstream += 1; cache_until = t + ttl
return upstream
for ttl in (0, 5, 60, 300, 3600):
print(f"TTL {ttl:>4} s: {resolver_day(ttl):>6} upstream queries in a day for one name at ~2 lookups/s")
# ---- 3. changing a record: how long until clients see it? worst case = the old TTL
def switch_time(old_ttl, clients=2000, seed=2):
rnd = random.Random(seed)
seen_old = [rnd.uniform(0, old_ttl) for _ in range(clients)] # remaining TTL of each resolver's cached copy
seen_old.sort()
return seen_old[int(0.5*clients)], seen_old[int(0.99*clients)], seen_old[-1]
for ttl in (60, 300, 3600, 86400):
med, p99, mx = switch_time(ttl); print(f"old TTL {ttl:>5} s: half of the resolvers update within {med:.0f} s, 99% within {p99:.0f} s, the last after {mx:.0f} s")
HTTP/1.1 contra HTTP/2 (Node.js)
import http from 'node:http';
import http2 from 'node:http2';
const DELAY = 50; // each response takes 50 ms to produce (stands in for one network round trip)
const N = 60; // a page with 60 small resources
const handler = (req, res) => setTimeout(() => { res.writeHead(200, { 'content-type': 'text/plain' }); res.end('x'.repeat(2000)); }, DELAY);
const s1 = http.createServer(handler).listen(0);
const s2 = http2.createServer(handler).listen(0); // HTTP/2 over cleartext (h2c); browsers require TLS, the multiplexing is the same
await new Promise((r) => setTimeout(r, 100));
async function h1(maxSockets) {
const agent = new http.Agent({ keepAlive: true, maxSockets });
const t = performance.now();
await Promise.all(Array.from({ length: N }, () => new Promise((ok) => http.get({ port: s1.address().port, agent, path: '/' }, (r) => { r.resume(); r.on('end', ok); }))));
const ms = performance.now() - t; agent.destroy(); return Math.round(ms);
}
async function h2run() {
const c = http2.connect(`http://localhost:${s2.address().port}`);
await new Promise((ok) => c.on('connect', ok));
const t = performance.now();
await Promise.all(Array.from({ length: N }, () => new Promise((ok) => { const r = c.request({ ':path': '/' }); r.resume(); r.on('end', ok); r.end(); })));
const ms = performance.now() - t; c.close(); return Math.round(ms);
}
await h1(6); await h2run(); // warm up
console.log(`HTTP/1.1, 1 connection : ${await h1(1)} ms for ${N} requests`);
console.log(`HTTP/1.1, 6 connections : ${await h1(6)} ms for ${N} requests`);
console.log(`HTTP/2, 1 connection : ${await h2run()} ms for ${N} requests`);
s1.close(); s2.close(); process.exit(0);
Bloqueio de cabeça de fila sob perda de pacotes
import random
def run(loss, independent, streams=3, packets=200, rtt=5, seed=0):
"""Each tick every stream sends one packet. A lost packet is detected and resent after `rtt` ticks.
Returns the average number of ticks a packet waits between arriving and being handed to the application."""
rnd = random.Random(seed); arrive = [] # (stream, seq, arrival tick, send order)
order = 0
for seq in range(packets):
for s in range(streams):
lost = rnd.random() < loss
arrive.append((s, seq, seq + (rtt if lost else 0), order)); order += 1
waits = []
if independent: # QUIC-like: each stream is ordered separately
for s in range(streams):
ready = 0
for (_, seq, at, _) in [a for a in arrive if a[0] == s]:
ready = max(ready, at); waits.append(ready - at)
else: # TCP-like: one byte stream; everything after a hole waits for it
ready = 0
for (_, seq, at, _) in sorted(arrive, key=lambda a: a[3]):
ready = max(ready, at); waits.append(ready - at)
return sum(waits) / len(waits), max(waits)
for loss in (0.0, 0.005, 0.01, 0.02, 0.05):
t = run(loss, False); q = run(loss, True)
print(f"loss {loss*100:>4.1f}%: ordered connection avg wait {t[0]:.2f} ticks (max {t[1]}), independent streams {q[0]:.2f} (max {q[1]})")
for streams in (1, 3, 10, 30):
t = run(0.01, False, streams=streams); q = run(0.01, True, streams=streams)
print(f"1% loss, {streams:>2} streams: ordered {t[0]:.2f} ticks on average, independent {q[0]:.2f}")
Um cache de CDN sob popularidade concentrada e plana
import random, bisect
from collections import OrderedDict
def zipf_sampler(n, s, rnd):
w = [1 / (i ** s) for i in range(1, n + 1)]; tot = sum(w); cum = []; a = 0
for x in w: a += x / tot; cum.append(a)
return lambda: bisect.bisect_left(cum, rnd.random())
def cdn(catalogue=10000, cache_share=0.05, requests=200000, s=1.0, ttl=None, seed=5):
rnd = random.Random(seed); pick = zipf_sampler(catalogue, s, rnd)
cap = int(catalogue * cache_share); cache = OrderedDict(); hits = 0; origin = 0
for t in range(requests):
k = pick()
if k in cache and (ttl is None or t - cache[k] < ttl):
hits += 1; cache.move_to_end(k)
else:
origin += 1; cache[k] = t; cache.move_to_end(k)
if len(cache) > cap: cache.popitem(last=False)
return hits / requests, origin
print("popular-heavy traffic (Zipf, s=1.0), 10,000 objects:")
for share in (0.001, 0.01, 0.05, 0.2):
h, o = cdn(cache_share=share); print(f" edge cache holds {share*100:>5.1f}% of the catalogue: hit ratio {h*100:4.1f}%, origin sees {o} of 200000 requests")
print("flatter traffic (Zipf, s=0.6):")
for share in (0.01, 0.05, 0.2):
h, o = cdn(cache_share=share, s=0.6); print(f" edge cache holds {share*100:>5.1f}% of the catalogue: hit ratio {h*100:4.1f}%")
print("short TTLs cost hits (cache 20%, s=1.0, TTL in requests):")
for ttl in (None, 5000, 500, 50):
h, o = cdn(cache_share=0.2, ttl=ttl); print(f" TTL {str(ttl):>5}: hit ratio {h*100:4.1f}%")
# average latency: hit 20 ms, miss 20 + 120 ms to the origin
for h in (0.5, 0.8, 0.95, 0.99):
print(f"hit ratio {h*100:.0f}%: mean latency {20*h + 140*(1-h):.0f} ms (hit 20 ms, miss 140 ms); origin load x{1-h:.2f}")
Fontes
- RFC 1034 e RFC 1035, Domain Names; RFC 2308, Negative Caching of DNS Queries; RFC 8767, Serving Stale Data to Improve DNS Resiliency; RFC 9460, Service Binding and Parameter Specification via the DNS (SVCB and HTTPS).
- RFC 9110 (HTTP Semantics), RFC 9111 (HTTP Caching), RFC 9113 (HTTP/2), RFC 9114 (HTTP/3), RFC 7541 (HPACK), RFC 9204 (QPACK); todas em rfc-editor.org.
- RFC 9000 (QUIC: A UDP-Based Multiplexed and Secure Transport) e RFC 9001 (Using TLS to Secure QUIC).
- Ilya Grigorik, High Performance Browser Networking, os capítulos sobre TCP, TLS, HTTP/2 e o contexto do HTTP/3.
- Os blogs de engenharia da Cloudflare e da Fastly sobre anycast, cache em camadas e origin shielding; MDN, HTTP caching.
- Omer Gil, Web Cache Deception Attack (2017), e James Kettle, Practical Web Cache Poisoning (PortSwigger Research, 2018); as páginas da OWASP Cache Poisoning e Web Cache Deception.
- Fastly, Purging (soft purge e surrogate keys), e Cloudflare, Purge cache: confira a documentação atual de cada provedor para o comportamento de propagação.
- RFC 9000 seção 8 (validação de endereço e o limite anti-amplificação) e RFC 8446 (TLS 1.3), para os voos do handshake e o 0-RTT.
Pratique este tema: Networking & APIs