CS Fundamentals Trainer · Guias

Estimativa de capacidade: carga, armazenamento, largura de banda e memória no guardanapo

As constantes que valem ser memorizadas, o que uma máquina pequena realmente faz (medido), um método de sete passos com a lei de Little, exemplos resolvidos de um encurtador de URLs, compartilhamento de fotos e chat, quanto tempo os dados levam para se mover e os erros que deixam as estimativas erradas por dez.

36 min de leitura

"Quantos usuários? Quantas requisições por segundo? Quantos dados?" Essas são as primeiras perguntas de quase toda discussão de projeto, e não são conversa fiada. Um sistema para cem requisições por dia e um para cem milhões precisam de arquiteturas diferentes: o primeiro cabe em um servidor barato, e o segundo precisa de caches, dados particionados e uma CDN. A estimativa de capacidade (o "cálculo de guardanapo") é a habilidade de ir de poucas premissas declaradas até a ordem de grandeza de carga, armazenamento, largura de banda e memória, rápido o bastante para fazer em voz alta, e com precisão suficiente para escolher entre projetos.

Não se trata de precisão. Se a resposta é 3 TB, ninguém liga se são 2,7 ou 3,4. O que importa é se são 3 TB ou 3 PB, porque essa é a diferença entre "um banco de dados" e "um sistema de armazenamento distribuído". Este guia dá as constantes que valem ser memorizadas, um método que funciona sempre, três exemplos resolvidos, números medidos do que uma máquina pequena realmente faz e os erros que deixam as estimativas erradas por um fator de dez.

Uma nota sobre as medições. Os números marcados como "medidos" foram produzidos para este guia em uma VM pequena na nuvem (2 vCPUs de um Intel Xeon a 2,1 GHz, 8 GB de memória, Linux, Python 3.13, Go 1.24, SQLite 3.45); o código está no apêndice. O seu hardware será diferente, às vezes por um fator de dez, o que já é uma lição: use esses números para saber se você está na faixa certa e meça o seu próprio sistema antes de confiar neles. A aritmética dos exemplos resolvidos vem da calculadora do apêndice, então cada valor pode ser conferido.

1. Para que serve uma estimativa

Uma estimativa responde a uma pergunta sobre o projeto:

Se a estimativa diz……a pergunta de projeto é
algumas centenas de requisições por segundoum único serviço bem construído já dá conta? (em geral sim)
dezenas de milhares por segundouma camada sem estado atrás de um balanceador de carga, mais um cache e réplicas de leitura
escritas além do que um banco de dados confirmalotes, filas ou dividir os dados entre nós
dados na casa dos terabytesum nó com bons backups, ou sharding? Quanto tempo leva uma restauração?
dados na casa dos petabytes, ou largura de banda de centenas de Gbit/sarmazenamento de objetos, camadas de armazenamento e uma CDN
milhões de conexões abertasuma camada dedicada a conexões; a memória por conexão vira a restrição

A estimativa também encontra a restrição dominante. Todo sistema é limitado primeiro por uma coisa: consultas por segundo (uma caixa de busca), armazenamento (fotos), largura de banda (vídeo), memória (uma camada de conexões de chat) ou taxa de escrita (métricas). Saber qual é poupa você de projetar uma solução linda para o problema errado.

2. Os números que valem ser memorizados

Tempo

SegundosMemorize como
1 dia86.400cerca de 10^5 (arredonde para 100.000 quando precisar de velocidade)
1 mês (30 dias)2.592.000cerca de 2,6 milhões
1 ano31.536.000cerca de 3 × 10^7

Duas conversões valem ser sabidas de cor: 1 milhão de eventos por dia dá cerca de 12 por segundo (1.000.000 ÷ 86.400 ≈ 11,6), e portanto 100 milhões por dia dá cerca de 1.200 por segundo. Quase todo número "por dia" de um problema precisa virar "por segundo", e essas duas cobrem a maioria dos casos.

Tamanhos

As potências de dois são próximas das potências de dez, o que facilita a aritmética: 2^10 = 1.024 (cerca de mil, 1 KB), 2^20 ≈ um milhão (1 MB), 2^30 ≈ um bilhão (1 GB), 2^40 ≈ um trilhão (1 TB), 2^50 ≈ um quatrilhão (1 PB). Tamanhos típicos de itens: um caractere é 1 byte (mais em UTF-8 para não ASCII), um UUID tem 16 bytes em binário ou 36 como texto, uma mensagem do tamanho de um tuíte com metadados tem de 200 a 500 bytes, uma página web de 1 a 3 MB, uma foto de celular de 2 a 5 MB, um minuto de vídeo HD comprimido dezenas de MB.

Bits não são bytes. As velocidades de rede são dadas em bits por segundo, e o armazenamento em bytes: um link de 1 Gbit/s move no máximo 125 MB/s, e um de 10 Gbit/s no máximo 1,25 GB/s. Confundir os dois é um erro de fator oito.

Disponibilidade

Os "noves" se traduzem no tempo de indisponibilidade permitido:

DisponibilidadePor anoPor mês de 30 dias
99%87,6 horas7,2 horas
99,9%8,8 horas43,2 minutos
99,99%52,6 minutos4,3 minutos
99,999%5,3 minutos26 segundos

Um sistema feito de várias partes em série é tão disponível quanto o produto das suas partes: três componentes com 99,9% cada dão cerca de 99,7%. É por isso que um requisito de quatro noves descarta um único banco de dados em uma única zona, não importa o que mais você faça.

Latência

A lista clássica "Latency Numbers Every Programmer Should Know", atribuída a Jeff Dean e compilada por Peter Norvig (a versão muito copiada é de cerca de 2012), dá a forma da hierarquia:

OperaçãoTempo (por volta de 2012)
Referência ao cache L10,5 ns
Referência à memória principal100 ns
Comprimir 1 KB3 µs
Enviar 1 KB por uma rede de 1 Gbit/s10 µs
Ler 4 KB aleatoriamente de um SSD150 µs
Ler 1 MB sequencialmente da memória250 µs
Ida e volta dentro do mesmo datacenter500 µs
Ler 1 MB sequencialmente de um SSD1 ms
Seek de disco10 ms
Ler 1 MB sequencialmente de um disco giratório20 ms
Pacote da Califórnia para a Holanda e de volta150 ms

Trate os valores individuais como defasados, mas as proporções como duradouras: a memória é cerca de mil vezes mais rápida que um seek de disco, uma ida e volta no datacenter é centenas de vezes mais lenta que um acesso à memória, e uma ida e volta por um oceano são uns cem e tantos milissegundos que nenhuma engenharia consegue remover (a velocidade da luz é o limite). Essas proporções são o que manda fazer cache, agrupar operações pequenas e colocar os dados perto dos usuários.

O que uma máquina faz (medido)

Os mesmos números medidos na VM descrita acima:

OperaçãoMedido
SHA-256, um núcleo (hashlib do Python)cerca de 1,2 GB/s
Codificar / decodificar JSON de um objeto de 620 bytes, Pythoncerca de 190.000 / 120.000 por segundo
Compressão zlib, texto JSON, nível 1 / nível 6cerca de 51 / 18 MB/s, saída de cerca de 48% / 43% da entrada
Leitura sequencial do cache de páginascerca de 7 GB/s
Leitura sequencial depois de descartar o cachecerca de 2,9 GB/s
Leitura aleatória de 4 KB depois de descartar o cachecerca de 37 µs cada
write de 4 KB seguido de fsynccerca de 0,12 ms, cerca de 8.400 por segundo
Ida e volta TCP em loopback, 1 byte, Python nas duas pontascerca de 37 µs
Abrir e fechar uma conexão TCP localcerca de 74 µs
"Hello world" do net/http do Go, 2 vCPUs compartilhadas com o gerador de carga25.000 requisições/s com 1 cliente, cerca de 40.000 a 43.000 com 8 a 256 clientes
Latência desse servidor com 64 clientes simultâneosp50 1,3 ms, p99 5,1 ms
Memória por conexão TCP ociosa em Go (uma goroutine e um buffer de 4 KB)cerca de 4,6 KB de memória do processo

Na mesma máquina, o SQLite com uma tabela de um milhão de linhas (um id, um número e 100 bytes de texto, com dois índices, cerca de 130 bytes por linha em disco):

OperaçãoMedido
Carga em massa em uma transaçãocerca de 205.000 linhas/s
Buscas por chave primária, uma conexão, a quentecerca de 200.000 por segundo
Buscas por um índice secundário (cerca de 10 linhas cada)cerca de 154.000 por segundo
Uma varredura completa com um filtro LIKE '%…%'cerca de 119 ms para 1.000.000 de linhas
Um insert por commit, synchronous=FULLcerca de 4.400 commits/s (0,23 ms cada)
Um insert por commit, WAL com synchronous=NORMALcerca de 27.000 commits/s

Leia isso com atenção, porque contém várias das lições deste guia:

3. O método

Os mesmos sete passos funcionam para qualquer sistema. Anote cada premissa e a sua unidade, e arredonde sem medo.

  1. Esclareça o escopo e a mistura. O que o produto faz, para quantos usuários, com que proporção de leitura e escrita, qual retenção, quais metas de qualidade? Pergunte e, quando não puder, declare a sua premissa em voz alta. Uma premissa errada é aceitável; uma escondida não é.
  2. Tráfego. DAU × ações por usuário por dia ÷ 86.400 dá as requisições por segundo médias. Multiplique por um fator de pico (2 a 3 para um produto de consumo estável, 5 a 10 ou mais para os de picos, como venda de ingressos ou notícias) para obter o pico. Dimensione para o pico, não para a média.
  3. Armazenamento. registros × tamanho por registro × retenção, e depois multiplique pela replicação (tipicamente 3 cópias, ou cerca de 1,5 com erasure coding para objetos frios) e pelo overhead (índices, cabeçalhos de linha e espaço livre: bancos de dados raramente rodam acima de 70 a 80% de ocupação). No meu teste com SQLite, os dados e dois índices ocuparam 130 bytes para uma linha com cerca de 105 bytes de campos, então conte com um overhead perceptível; meça o do seu esquema.
  4. Largura de banda. requisições por segundo × bytes por resposta para o tráfego de saída, e o mesmo para o de entrada. Converta para bits e compare com o que uma interface de rede carrega (1, 10 ou 25 Gbit/s).
  5. Memória. Para caches, estime o conjunto de trabalho (os dados que de fato estão quentes) e não o conjunto de dados inteiro. Uma suposição comum é que 20% dos itens recebem 80% das leituras. É uma regra prática e não uma lei; os logs de acesso reais costumam mostrar outra assimetria, então confira-os quando os tiver. Para camadas de conexão, conexões × memória por conexão.
  6. Servidores. carga de pico ÷ capacidade de um servidor, em que a capacidade é um número medido e reduzido a uma utilização-alvo (50 a 70% deixa espaço para picos, deploys e falhas), e some redundância (N+1, ou N+2 para pools grandes, ou o bastante para sobreviver à perda de uma zona inteira).
  7. Confira e encontre o gargalo. Verifique por um segundo caminho (por exemplo, de baixo para cima, a partir das máquinas de que você precisaria, contra de cima para baixo, a partir dos usuários) e nomeie o recurso que acaba primeiro.

A lei de Little: quantas requisições estão em andamento

Uma fórmula vale ser guardada além dos sete passos. A lei de Little diz que o número médio de itens em um sistema estável é igual à taxa de chegada vezes o tempo médio que cada um passa nele: L = λ × W. Para um serviço, isso é requisições em andamento = requisições por segundo × segundos por requisição.

TaxaTempo por requisiçãoRequisições em andamento
1.000 por segundo50 ms50
12.000 por segundo50 ms600
12.000 por segundo500 ms6.000
100.000 por segundo20 ms2.000

Ela diz quantas conexões, threads ou conexões de banco de dados simultâneas uma carga exige, e mostra o efeito cruel da lentidão: se o mesmo serviço fica dez vezes mais lento, dez vezes mais requisições se acumulam nele, então a memória, as threads e as vagas no pool de conexões que ele segura também crescem dez vezes, que é como uma lentidão vira uma indisponibilidade.

4. Exemplo resolvido 1: um encurtador de URLs

Premissas. 100 milhões de links curtos novos por mês, 100 leituras para cada escrita, 500 bytes guardados por link (o código curto, a URL longa, a data de criação e alguns contadores), links mantidos por 5 anos, 3 cópias, pico em 3 vezes a média.

GrandezaCálculoResultado
Escritas por segundo, média100.000.000 ÷ (30 × 86.400)39 por segundo
Escritas por segundo, pico× 3cerca de 120
Leituras por segundo, média× 100cerca de 3.900
Leituras por segundo, pico× 3cerca de 11.600
Links após 5 anos100 M × 12 × 56 bilhões
Armazenamento bruto6 × 10^9 × 500 B3 TB
Com 3 cópias× 39 TB
Leituras por dia3.858 × 86.400333 milhões
Cache para os links quentessuponha 1 link distinto a cada 100 leituras: 3,3 M distintos por dia, os 20% mais quentes deles, a 500 Bcerca de 333 MB
Servidores de aplicação11.600 ÷ 5.000 por servidor = 3, mais um reserva4

O que isso diz. A taxa de escrita é minúscula (dezenas por segundo), então escalar escritas não é o problema. A taxa de leitura é moderada, e os dados quentes cabem em algumas centenas de MB de cache, então um cache elimina a maior parte das leituras do banco de dados. O armazenamento, 3 TB para a cópia principal, cabe nos discos de um servidor de banco de dados moderno, então o particionamento é opcional no começo e vira uma questão de crescimento, não um requisito do primeiro dia. O trabalho interessante de projeto está em outro lugar (gerar códigos curtos únicos sem colisões e manter os redirecionamentos rápidos e disponíveis). A estimativa disse onde o esforço não deve ir.

5. Exemplo resolvido 2: compartilhamento de fotos

Premissas. 50 milhões de usuários ativos por dia; 10% postam uma foto por dia; cada upload é um original de 2 MB mais 0,2 MB de miniaturas; cada usuário vê 50 fotos por dia com média de 300 KB cada (imagens do tamanho do feed).

GrandezaCálculoResultado
Uploads por dia50 M × 10%5 milhões (58 por segundo em média)
Armazenamento novo por dia5 M × 2,2 MB11 TB
Armazenamento novo por ano× 3654 PB
Com 3 cópias completas× 312 PB por ano
Com erasure coding (cerca de 1,5×)× 1,56 PB por ano
Dados de saída por dia50 M × 50 × 300 KB750 TB
Largura de banda de saída média750 TB × 8 ÷ 86.40069 Gbit/s
No pico de 3×× 3cerca de 208 Gbit/s
Links de 10 Gbit/s necessáriosmédia, pico7, 21

O que isso diz. A taxa de requisições (58 uploads por segundo) é trivial. O armazenamento (petabytes por ano) e, acima de tudo, a largura de banda (centenas de Gbit/s no pico) dominam. Nenhuma fazenda de servidores de origem deve servir isso: as imagens pertencem ao armazenamento de objetos, entregues por uma CDN que absorve a maior parte do tráfego perto dos usuários, com camadas que movem as fotos antigas para um armazenamento mais barato. Compare com o exemplo anterior, em que o mesmo método apontou para um cache e um banco de dados modesto. O método é o mesmo, e a conclusão é completamente diferente.

6. Exemplo resolvido 3: chat

Premissas. 100 milhões de usuários ativos por dia, cada um enviando 40 mensagens por dia; 200 bytes guardados por mensagem (texto e metadados); 20% dos usuários online no pico; cada usuário online mantém uma conexão aberta que custa cerca de 8 KB no total; um gateway suporta até 100.000 conexões.

GrandezaCálculoResultado
Mensagens por dia100 M × 404 bilhões
Mensagens por segundo, média÷ 86.400cerca de 46.000
Mensagens por segundo, pico× 3cerca de 139.000
Armazenamento por dia4 B × 200 B800 GB
Armazenamento por ano× 365292 TB (876 TB com 3 cópias)
Conexões no pico20% de 100 M20 milhões
Memória para manter as conexões20 M × 8 KB160 GB
Gateways20 M ÷ 100.000200 (mais capacidade de reserva)
Se um gateway cai100.000 clientes se reconectam; em 30 scerca de 3.300 conexões por segundo nos demais

Os 8 KB por conexão são um valor medido: manter 18.000 conexões ociosas em um servidor Go custou cerca de 4,6 KB de memória do processo cada (uma goroutine e um buffer de leitura de 4 KB); a máquina inteira usou cerca de 12 KB por conexão contando as pontas de cliente e de servidor de cada uma, o que deixa cerca de 4 KB de memória do kernel por ponta (uma estimativa: supus que as duas pontas custam o mesmo). Uma conexão de chat de verdade ainda carrega estado por usuário, então 8 KB é um piso.

O que isso diz. A taxa de mensagens é alta, mas comum para um log particionado ou um banco de dados com sharding. A restrição que se destaca são as conexões: 20 milhões delas, 160 GB de memória só para mantê-las abertas, distribuídos por centenas de máquinas. Esse é o motivo de os projetos de chat terem uma camada de gateways separada que só mantém conexões, e uma consulta de "qual gateway guarda este usuário". É também por que a falha de um gateway importa: os seus 100.000 clientes se reconectam de uma vez, então as reconexões precisam de jitter e os gateways restantes precisam de folga. Veja o guia sobre projetar um sistema de chat para saber como essas peças se encaixam.

7. Mover dados leva tempo

Capacidade não é só "cabe", mas também "quanto tempo leva para copiar". Uma nova réplica, uma restauração de backup ou uma migração para hardware novo precisa mover o conjunto de dados inteiro:

DadosA 1 Gbit/sA 10 Gbit/s
1 TB2,2 horas13 minutos
10 TB22 horas2,2 horas
100 TB9,3 dias22 horas

(Supondo que o link seja usado por completo, o que nunca acontece de todo.) São os números por trás de conselhos como "mantenha cada nó de banco de dados em poucos terabytes". Acima disso, uma réplica que falha leva um dia para ser reconstruída, durante o qual você opera com menos redundância, e uma restauração depois de um desastre se mede em dias. Quando uma estimativa dá dezenas de terabytes em um só lugar, pergunte não só se cabe, mas também como você o reconstruiria.

8. Regras práticas e armadilhas

9. Apresentando uma estimativa

Em uma entrevista ou em uma revisão de projeto, a estimativa também é comunicação.

10. Erros comuns

11. O que mencionar em uma entrevista

Resumo rápido

Apêndice: o código

Os números vêm de quatro programas. A calculadora estimate.py imprime todos os exemplos resolvidos acima. O bench.py produziu os valores de CPU, disco, SQLite e loopback (rode python3 bench.py cpu disk db net; ele precisa de alguns GB de disco livre e tenta descartar o cache de páginas, o que exige root). Os dois programas em Go mediram a taxa de HTTP e o custo de conexões ociosas (compile cada um com go build; inicie conns_bin server em um terminal e conns_bin client 18000 em outro, com o limite de descritores de arquivo elevado se quiser mais de cerca de 18.000 conexões).

estimate.py

"""Back-of-the-envelope calculator for the capacity-estimation guide. Every number printed in the worked examples comes from here."""
import math

DAY = 86_400
def fmt(n, unit=""):
    for div, name in ((1e15, "P"), (1e12, "T"), (1e9, "G"), (1e6, "M"), (1e3, "k")):
        if abs(n) >= div: return f"{n / div:.3g} {name}{unit}"
    return f"{n:.3g} {unit}".strip()

def rule(title): print(f"\n== {title}")

def constants():
    rule("time")
    for name, s in (("minute", 60), ("hour", 3600), ("day", DAY), ("month (30 days)", 30 * DAY), ("year", 365 * DAY)):
        print(f"   {name:16s} {s:>12,} s   ~ {s:.1e}")
    rule("availability: downtime allowed per year and per 30-day month")
    for nines in (0.99, 0.999, 0.9999, 0.99999):
        y = (1 - nines) * 365 * DAY; m = (1 - nines) * 30 * DAY
        h = lambda s: f"{s / 3600:.1f} h" if s >= 3600 else (f"{s / 60:.1f} min" if s >= 60 else f"{s:.0f} s")
        print(f"   {nines * 100:g}%   {h(y):>9} per year   {h(m):>9} per month")
    rule("powers of two")
    for e, n in ((10, "KB"), (20, "MB"), (30, "GB"), (40, "TB"), (50, "PB")):
        print(f"   2^{e} = {2 ** e:>20,}  ~ 10^{e * 0.30103:.1f}  (1 {n})")

def littles_law():
    rule("Little's law: requests in flight = rate x time in the system")
    for rps, ms in ((1_000, 50), (12_000, 50), (12_000, 500), (100_000, 20)):
        print(f"   {rps:>7,} requests/s x {ms:>3} ms = {rps * ms / 1000:>7,.0f} requests in flight")

def example_url_shortener():
    rule("Example 1: URL shortener")
    new_per_month, read_write, record, years, replicas, peak = 100e6, 100, 500, 5, 3, 3
    w = new_per_month / (30 * DAY); r = w * read_write
    print(f"   writes: {new_per_month:,.0f} / month = {w:.1f} per second on average; peak x{peak} = {w * peak:.0f} per second")
    print(f"   reads:  x{read_write} = {r:,.0f} per second on average; peak = {r * peak:,.0f} per second")
    total = new_per_month * 12 * years
    raw = total * record
    print(f"   links after {years} years: {total:,.0f}; {record} bytes each = {fmt(raw, 'B')} raw, {fmt(raw * replicas, 'B')} with {replicas} copies")
    reads_day = r * DAY
    print(f"   reads per day: {reads_day:,.0f}; if 20% of links get 80% of the reads, cache the hot 20% of one day's links:")
    print(f"      assume 1 distinct link per 100 reads -> {reads_day / 100:,.0f} distinct per day; 20% of that = {reads_day / 100 * 0.2:,.0f} x {record} B = {fmt(reads_day / 100 * 0.2 * record, 'B')} of cache")
    per_server = 5_000
    print(f"   app servers: peak {r * peak:,.0f} / {per_server:,} per server = {math.ceil(r * peak / per_server)}, plus one spare = {math.ceil(r * peak / per_server) + 1}")

def example_photos():
    rule("Example 2: photo sharing")
    dau, post_share, orig, thumb, views, avg_view = 50e6, 0.10, 2e6, 0.2e6, 50, 0.3e6
    posts = dau * post_share
    per_day = posts * (orig + thumb)
    print(f"   uploads: {dau:,.0f} DAU x {post_share:.0%} post once = {posts:,.0f} photos/day = {posts / DAY:.0f} per second on average")
    print(f"   storage: {posts:,.0f} x ({orig / 1e6:g} MB + {thumb / 1e6:g} MB thumbnails) = {fmt(per_day, 'B')} per day, {fmt(per_day * 365, 'B')} per year")
    print(f"      with 3 full copies {fmt(per_day * 365 * 3, 'B')} per year; with erasure coding ~1.5x: {fmt(per_day * 365 * 1.5, 'B')} per year")
    egress = dau * views * avg_view
    print(f"   reads: {dau:,.0f} x {views} views x {avg_view / 1e3:.0f} KB = {fmt(egress, 'B')} per day = {egress * 8 / DAY / 1e9:.0f} Gbit/s on average, {egress * 8 / DAY / 1e9 * 3:.0f} Gbit/s at 3x peak")
    print(f"   one 10 Gbit/s server link carries {10 / 8:.2f} GB/s; the average needs {egress * 8 / DAY / 1e9 / 10:.0f} of them, the peak {egress * 8 / DAY / 1e9 * 3 / 10:.0f}")

def example_chat():
    rule("Example 3: chat")
    dau, msgs, size, online, bytes_conn, per_gw = 100e6, 40, 200, 0.2, 8_000, 100_000
    per_day = dau * msgs; rate = per_day / DAY
    print(f"   messages: {dau:,.0f} x {msgs} = {per_day:,.0f} per day = {rate:,.0f} per second on average, {rate * 3:,.0f} at 3x peak")
    print(f"   storage:  {per_day:,.0f} x {size} B = {fmt(per_day * size, 'B')} per day, {fmt(per_day * size * 365, 'B')} per year, x3 copies = {fmt(per_day * size * 365 * 3, 'B')}")
    conns = dau * online
    print(f"   connections at peak: {online:.0%} of DAU = {conns:,.0f}; at {bytes_conn / 1e3:g} KB each = {fmt(conns * bytes_conn, 'B')} of memory just to hold them")
    print(f"   gateways: {conns:,.0f} / {per_gw:,} per gateway = {math.ceil(conns / per_gw)} (plus spare capacity so one lost gateway's {per_gw:,} reconnects can be absorbed)")
    print(f"   if a gateway fails, {per_gw:,} clients reconnect at once; spread over 30 s that is {per_gw / 30:,.0f} connections per second to the rest")

def copy_time():
    rule("how long it takes to move data (a new replica, a restore, a migration)")
    for size_tb in (1, 10, 100):
        row = []
        for name, gbit in (("1 Gbit/s", 1), ("10 Gbit/s", 10)):
            secs = size_tb * 1e12 / (gbit * 1e9 / 8)
            row.append(f"{name}: {secs / 3600:6.1f} h" if secs < 3 * DAY else f"{name}: {secs / DAY:6.1f} days")
        print(f"   {size_tb:>4} TB   " + "   ".join(row) + "   (link fully used, no overhead)")

def headroom():
    rule("headroom: how many servers for a load, at a target utilisation")
    peak, per_server = 12_000, 4_000
    for util in (1.0, 0.7, 0.5):
        n = math.ceil(peak / (per_server * util))
        print(f"   peak {peak:,} rps, {per_server:,} rps per server at 100% -> at {util:.0%} target utilisation: {n} servers; with N+1: {n + 1}; losing one of {n + 1} leaves {(n) * 100 / (n + 1):.0f}% of the pool")

if __name__ == "__main__":
    constants(); littles_law(); example_url_shortener(); example_photos(); example_chat(); copy_time(); headroom()

bench.py

"""Calibration numbers for the capacity-estimation guide: what one small machine does. Standard library only."""
import hashlib, json, os, random, socket, sqlite3, threading, time, uuid, zlib

D = "/var/tmp/g3/bench"
os.makedirs(D, exist_ok=True)

def timeit(f, n):
    t = time.perf_counter(); f(n); return time.perf_counter() - t

def part_cpu():
    print("CPU-bound work in one Python thread (the interpreter is slower than C or Go, so read these as floors)")
    buf = os.urandom(1 << 20)
    n = 200; dt = timeit(lambda n: [hashlib.sha256(buf).digest() for _ in range(n)], n)
    print(f"   SHA-256 of 1 MB blocks:           {n / dt:7.0f} MB/s")
    random.seed(5)
    words = [hashlib.md5(str(i).encode()).hexdigest()[:random.randint(3, 9)] for i in range(3000)]
    def make():
        return {"id": str(uuid.UUID(int=random.getrandbits(128), version=4)), "user": random.randrange(10**7),
                "text": " ".join(random.choice(words) for _ in range(60)), "tags": random.sample(words, 3), "n": [random.randrange(1000) for _ in range(20)]}
    doc = make(); raw = json.dumps(doc); n = 100_000
    print(f"   JSON object of {len(raw)} bytes:        {n / timeit(lambda n: [json.dumps(doc) for _ in range(n)], n):7.0f} encodes/s, "
          f"{n / timeit(lambda n: [json.loads(raw) for _ in range(n)], n):7.0f} decodes/s")
    text = ("\n".join(json.dumps(make()) for _ in range(3000))).encode()
    for lvl in (1, 6):
        t = time.perf_counter(); c = zlib.compress(text, lvl); dt = time.perf_counter() - t
        print(f"   zlib level {lvl} on JSON text:       {len(text) / dt / 1e6:7.0f} MB/s, size {len(c) / len(text):.0%} of the original")

def part_disk():
    print("Disk and memory")
    p = f"{D}/seq.bin"; size = 1 << 30
    with open(p, "wb") as f:
        blk = os.urandom(1 << 20)
        t = time.perf_counter()
        for _ in range(size >> 20): f.write(blk)
        f.flush(); os.fsync(f.fileno())
    print(f"   write 1 GB sequentially + fsync:  {size / (time.perf_counter() - t) / 1e6:7.0f} MB/s")
    for label in ("page cache (warm)", "after dropping caches (cold)"):
        if "cold" in label:
            try:
                os.sync(); open("/proc/sys/vm/drop_caches", "w").write("3")
            except Exception as e:
                print("   (could not drop caches:", e, ")"); continue
        t = time.perf_counter(); got = 0
        with open(p, "rb", buffering=0) as f:
            while True:
                b = f.read(1 << 20)
                if not b: break
                got += len(b)
        print(f"   read 1 GB sequentially, {label:28s}: {got / (time.perf_counter() - t) / 1e6:7.0f} MB/s")
    # random 4 KB reads, cold
    try:
        os.sync(); open("/proc/sys/vm/drop_caches", "w").write("3")
    except Exception: pass
    fd = os.open(p, os.O_RDONLY); n = 2000; random.seed(1)
    t = time.perf_counter()
    for _ in range(n): os.pread(fd, 4096, random.randrange(0, size - 4096) & ~4095)
    dt = time.perf_counter() - t
    print(f"   random 4 KB reads, cold:          {dt / n * 1e6:7.0f} us each ({n / dt:,.0f} per second, one at a time)")
    os.close(fd); os.remove(p)
    # fsync latency
    fd = os.open(f"{D}/sync.bin", os.O_WRONLY | os.O_CREAT); n = 500
    t = time.perf_counter()
    for i in range(n): os.pwrite(fd, b"x" * 4096, 0); os.fsync(fd)
    dt = time.perf_counter() - t; os.close(fd)
    print(f"   write 4 KB + fsync:               {dt / n * 1e3:7.2f} ms each ({n / dt:,.0f} per second)")

def part_db():
    print("SQLite, one table of 1,000,000 rows (id, user, 100-byte payload) with indexes on id and user")
    p = f"{D}/db.sqlite"
    for f in (p, p + "-wal", p + "-shm"):
        if os.path.exists(f): os.remove(f)
    c = sqlite3.connect(p, isolation_level=None); c.execute("PRAGMA journal_mode=WAL")
    c.execute("CREATE TABLE t (id INTEGER PRIMARY KEY, user INTEGER, payload TEXT)")
    c.execute("CREATE INDEX t_user ON t (user)")
    pay = "p" * 100; N = 1_000_000
    t = time.perf_counter(); c.execute("BEGIN")
    c.executemany("INSERT INTO t (user, payload) VALUES (?, ?)", ((random.randrange(100_000), pay) for _ in range(N)))
    c.execute("COMMIT"); dt = time.perf_counter() - t
    size = os.path.getsize(p)
    print(f"   bulk load in one transaction:     {N / dt:8,.0f} rows/s; file {size / 1e6:.0f} MB = {size / N:.0f} bytes per row (data + 2 indexes)")
    n = 100_000; ids = [random.randrange(1, N) for _ in range(n)]
    t = time.perf_counter()
    for i in ids: c.execute("SELECT payload FROM t WHERE id=?", (i,)).fetchone()
    print(f"   primary-key lookups, warm:        {n / (time.perf_counter() - t):8,.0f} per second, one connection")
    n = 20_000; t = time.perf_counter()
    for _ in range(n): c.execute("SELECT COUNT(*) FROM t WHERE user=?", (random.randrange(100_000),)).fetchone()
    print(f"   lookups via the user index:       {n / (time.perf_counter() - t):8,.0f} per second (about {N // 100_000} rows each)")
    n = 50; t = time.perf_counter()
    for _ in range(n): c.execute("SELECT COUNT(*) FROM t WHERE payload LIKE '%zzz%'").fetchone()
    dt = (time.perf_counter() - t) / n
    print(f"   one full scan (no index):         {dt * 1e3:8.0f} ms for {N:,} rows")
    # commits with fsync
    c.execute("PRAGMA synchronous=FULL"); n = 300; t = time.perf_counter()
    for _ in range(n): c.execute("INSERT INTO t (user, payload) VALUES (1, 'x')")
    dt = time.perf_counter() - t
    print(f"   one insert per commit (synchronous=FULL): {n / dt:6,.0f} commits/s ({dt / n * 1e3:.2f} ms each)")
    c.execute("PRAGMA synchronous=NORMAL"); t = time.perf_counter()
    for _ in range(n * 10): c.execute("INSERT INTO t (user, payload) VALUES (1, 'x')")
    dt = time.perf_counter() - t
    print(f"   one insert per commit (synchronous=NORMAL, WAL): {n * 10 / dt:6,.0f} commits/s")

def part_net():
    print("Loopback TCP, one byte back and forth (this is the floor: a real network adds distance)")
    srv = socket.socket(); srv.bind(("127.0.0.1", 0)); srv.listen()
    def echo():
        s, _ = srv.accept(); s.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
        while True:
            b = s.recv(1)
            if not b: return
            s.sendall(b)
    threading.Thread(target=echo, daemon=True).start()
    c = socket.create_connection(srv.getsockname()); c.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
    n = 20_000; t = time.perf_counter()
    for _ in range(n): c.sendall(b"x"); c.recv(1)
    dt = time.perf_counter() - t
    print(f"   round trip: {dt / n * 1e6:6.1f} us (includes Python's own overhead on both ends)")
    srv2 = socket.socket(); srv2.bind(("127.0.0.1", 0)); srv2.listen(1024)
    threading.Thread(target=lambda: [srv2.accept()[0].close() for _ in range(2000)], daemon=True).start()
    t = time.perf_counter()
    for _ in range(2000):
        s = socket.create_connection(srv2.getsockname()); s.close()
    print(f"   opening and closing a connection: {(time.perf_counter() - t) / 2000 * 1e6:6.0f} us")

if __name__ == "__main__":
    import sys
    for p in (sys.argv[1:] or ["cpu", "disk", "db", "net"]): globals()["part_" + p]()

http/main.go

// A "hello world" HTTP server and a closed-loop client on the same machine: how many requests per second one small VM serves.
package main

import (
	"fmt"
	"io"
	"net"
	"net/http"
	"runtime"
	"sort"
	"sync"
	"sync/atomic"
	"time"
)

func main() {
	ln, _ := net.Listen("tcp", "127.0.0.1:0")
	go http.Serve(ln, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { io.WriteString(w, "ok") }))
	url := "http://" + ln.Addr().String() + "/"
	for _, workers := range []int{1, 8, 64, 256} {
		client := &http.Client{Transport: &http.Transport{MaxIdleConnsPerHost: workers, MaxConnsPerHost: workers}}
		var n atomic.Int64
		var mu sync.Mutex
		var lat []time.Duration
		stop := time.Now().Add(4 * time.Second)
		var wg sync.WaitGroup
		for i := 0; i < workers; i++ {
			wg.Add(1)
			go func() {
				defer wg.Done()
				var mine []time.Duration
				for time.Now().Before(stop) {
					t := time.Now()
					resp, err := client.Get(url)
					if err != nil {
						continue
					}
					io.Copy(io.Discard, resp.Body)
					resp.Body.Close()
					mine = append(mine, time.Since(t))
					n.Add(1)
				}
				mu.Lock()
				lat = append(lat, mine...)
				mu.Unlock()
			}()
		}
		wg.Wait()
		sort.Slice(lat, func(i, j int) bool { return lat[i] < lat[j] })
		fmt.Printf("  %3d concurrent clients: %7.0f requests/s, p50 %v, p99 %v\n", workers, float64(n.Load())/4, lat[len(lat)/2].Round(time.Microsecond), lat[len(lat)*99/100].Round(time.Microsecond))
		client.CloseIdleConnections()
	}
	fmt.Println("  (GOMAXPROCS =", runtime.GOMAXPROCS(0), "; the client and the server share the same CPUs)")
}

conns/main.go

// Memory cost of holding many idle TCP connections, one goroutine per connection (the usual Go server shape).
// Run "server" in one process and "client N" in another.
package main

import (
	"bufio"
	"fmt"
	"net"
	"os"
	"strconv"
	"strings"
	"time"
)

func meminfo(key string) int64 {
	b, _ := os.ReadFile("/proc/meminfo")
	for _, l := range strings.Split(string(b), "\n") {
		if strings.HasPrefix(l, key+":") {
			f := strings.Fields(l)
			v, _ := strconv.ParseInt(f[1], 10, 64)
			return v // kB
		}
	}
	return 0
}
func rss() int64 {
	b, _ := os.ReadFile("/proc/self/status")
	for _, l := range strings.Split(string(b), "\n") {
		if strings.HasPrefix(l, "VmRSS:") {
			v, _ := strconv.ParseInt(strings.Fields(l)[1], 10, 64)
			return v
		}
	}
	return 0
}

const ports = 6

func main() {
	if os.Args[1] == "server" {
		base := int(meminfo("MemAvailable"))
		r0 := rss()
		var count int64
		for p := 0; p < ports; p++ {
			ln, err := net.Listen("tcp", fmt.Sprintf("127.0.0.1:%d", 9100+p))
			if err != nil {
				panic(err)
			}
			go func() {
				for {
					c, err := ln.Accept()
					if err != nil {
						return
					}
					count++
					go func() { // one goroutine and one 4 KB read buffer per connection
						r := bufio.NewReaderSize(c, 4096)
						r.ReadByte()
						c.Close()
					}()
				}
			}()
		}
		fmt.Println("server ready")
		last := int64(-1)
		for {
			time.Sleep(2 * time.Second)
			if count != last && count > 0 {
				last = count
				fmt.Printf("server: %6d connections, process RSS +%6.1f MB (%.2f KB each), system memory used +%6.1f MB (%.2f KB each)\n",
					count, float64(rss()-r0)/1024, float64(rss()-r0)/float64(count),
					float64(int64(base)-meminfo("MemAvailable"))/1024, float64(int64(base)-meminfo("MemAvailable"))/float64(count))
			}
		}
	}
	n, _ := strconv.Atoi(os.Args[2])
	var keep []net.Conn
	for i := 0; i < n; i++ {
		c, err := net.Dial("tcp", fmt.Sprintf("127.0.0.1:%d", 9100+i%ports))
		if err != nil {
			fmt.Println("client stopped at", i, err)
			break
		}
		keep = append(keep, c)
	}
	fmt.Println("client holds", len(keep), "connections")
	time.Sleep(6 * time.Second)
}

Fontes

Pratique este tema: System Design System Design › Reliability and scale

Mais guias