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

TipoSignificado
A / AAAAendereço IPv4 / IPv6
CNAMEum alias: "este nome é na verdade aquele outro nome". Não é permitido no ápice da zona ao lado de outros registros
NSquais servidores são autoritativos para uma zona
MXservidores de e-mail de um domínio
TXTtexto livre, usado para verificação de domínio, SPF, DKIM
SOAmetadados 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:

TTLConsultas a montante por dia
0 s (sem cache)172.304 (toda consulta)
5 s15.702
60 s1.429
300 s288
3600 s24

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:

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:

PilhaRound trips antes de a requisição poder ser enviada
HTTP/1.1 ou HTTP/2 sobre TCP e TLS 1.23 (TCP: 1, TLS 1.2: 2)
TCP e TLS 1.32 (TCP: 1, TLS: 1)
QUIC (HTTP/3), servidor novo1 (handshake de transporte e TLS 1.3 combinados)
QUIC com retomada 0-RTT0, 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:

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:

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:

ClienteTempo para 60 requisições
HTTP/1.1, uma conexão3.058 ms (60 vezes 50 ms, uma depois da outra)
HTTP/1.1, seis conexões515 ms (dez rodadas de seis)
HTTP/2, uma conexão59 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 streamsConexão ordenada (TCP)Streams independentes (QUIC)
0,5%0,32 ticks0,08 ticks
1%0,540,15
2%0,720,22
5%1,630,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:

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 guardaTaxa de acertos, popularidade muito concentradaTaxa de acertos, popularidade mais plana
0,1% do catálogo13,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):

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:

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:

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

6. Coisas a mencionar em uma entrevista

Resumo rápido

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

Pratique este tema: Networking & APIs

Mais guias