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 segundo | um único serviço bem construído já dá conta? (em geral sim) |
| dezenas de milhares por segundo | uma 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 confirma | lotes, filas ou dividir os dados entre nós |
| dados na casa dos terabytes | um 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/s | armazenamento de objetos, camadas de armazenamento e uma CDN |
| milhões de conexões abertas | uma 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
| Segundos | Memorize como | |
|---|---|---|
| 1 dia | 86.400 | cerca de 10^5 (arredonde para 100.000 quando precisar de velocidade) |
| 1 mês (30 dias) | 2.592.000 | cerca de 2,6 milhões |
| 1 ano | 31.536.000 | cerca 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:
| Disponibilidade | Por ano | Por mês de 30 dias |
|---|---|---|
| 99% | 87,6 horas | 7,2 horas |
| 99,9% | 8,8 horas | 43,2 minutos |
| 99,99% | 52,6 minutos | 4,3 minutos |
| 99,999% | 5,3 minutos | 26 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ção | Tempo (por volta de 2012) |
|---|---|
| Referência ao cache L1 | 0,5 ns |
| Referência à memória principal | 100 ns |
| Comprimir 1 KB | 3 µs |
| Enviar 1 KB por uma rede de 1 Gbit/s | 10 µs |
| Ler 4 KB aleatoriamente de um SSD | 150 µs |
| Ler 1 MB sequencialmente da memória | 250 µs |
| Ida e volta dentro do mesmo datacenter | 500 µs |
| Ler 1 MB sequencialmente de um SSD | 1 ms |
| Seek de disco | 10 ms |
| Ler 1 MB sequencialmente de um disco giratório | 20 ms |
| Pacote da Califórnia para a Holanda e de volta | 150 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ção | Medido |
|---|---|
SHA-256, um núcleo (hashlib do Python) | cerca de 1,2 GB/s |
| Codificar / decodificar JSON de um objeto de 620 bytes, Python | cerca de 190.000 / 120.000 por segundo |
| Compressão zlib, texto JSON, nível 1 / nível 6 | cerca de 51 / 18 MB/s, saída de cerca de 48% / 43% da entrada |
| Leitura sequencial do cache de páginas | cerca de 7 GB/s |
| Leitura sequencial depois de descartar o cache | cerca de 2,9 GB/s |
| Leitura aleatória de 4 KB depois de descartar o cache | cerca de 37 µs cada |
write de 4 KB seguido de fsync | cerca de 0,12 ms, cerca de 8.400 por segundo |
| Ida e volta TCP em loopback, 1 byte, Python nas duas pontas | cerca de 37 µs |
| Abrir e fechar uma conexão TCP local | cerca de 74 µs |
"Hello world" do net/http do Go, 2 vCPUs compartilhadas com o gerador de carga | 25.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âneos | p50 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ção | Medido |
|---|---|
| Carga em massa em uma transação | cerca de 205.000 linhas/s |
| Buscas por chave primária, uma conexão, a quente | cerca 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=FULL | cerca de 4.400 commits/s (0,23 ms cada) |
Um insert por commit, WAL com synchronous=NORMAL | cerca de 27.000 commits/s |
Leia isso com atenção, porque contém várias das lições deste guia:
- Uma máquina barata faz muito, se o trabalho é simples. Quarenta mil requisições triviais por segundo em duas CPUs compartilhadas significam que um serviço pequeno raramente tem como gargalo o framework web. O gargalo é o que cada requisição faz: um handler que consulta um banco de dados, chama outros serviços e monta uma resposta é cem vezes mais pesado que um vazio. O número honesto para planejar é de centenas a poucos milhares de requisições por segundo por servidor para um trabalho típico, e o seu você descobre com teste de carga.
- A durabilidade domina as taxas de escrita. A mesma tabela confirma 4.400 transações independentes por segundo quando cada commit espera o disco e 27.000 quando não espera, e uma carga em massa (muitas linhas por transação) chega a 205.000. "Quantas escritas por segundo um banco de dados aguenta?" não tem uma única resposta; depende do agrupamento e do rigor da durabilidade.
- Um índice é a diferença entre microssegundos e uma varredura. A busca por um índice custa de 5 a 7 µs; varrer a mesma tabela atrás de um trecho de texto custa 119 ms, cerca de 20.000 vezes mais.
- Os números absolutos variam com o hardware, e o ranking também. A leitura aleatória a frio de 37 µs está muito abaixo dos 150 µs clássicos, porque um disco NVMe local moderno (ou o cache do host por trás de um virtual) é muito mais rápido que o SSD de 2012. Um volume de rede na nuvem pode ser mais lento que os dois. Por isso a tabela acima é uma calibração, não uma especificação.
3. O método
Os mesmos sete passos funcionam para qualquer sistema. Anote cada premissa e a sua unidade, e arredonde sem medo.
- 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 é.
- Tráfego.
DAU × ações por usuário por dia ÷ 86.400dá 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. - 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. - Largura de banda.
requisições por segundo × bytes por respostapara 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). - 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. - 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). - 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.
| Taxa | Tempo por requisição | Requisições em andamento |
|---|---|---|
| 1.000 por segundo | 50 ms | 50 |
| 12.000 por segundo | 50 ms | 600 |
| 12.000 por segundo | 500 ms | 6.000 |
| 100.000 por segundo | 20 ms | 2.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.
| Grandeza | Cálculo | Resultado |
|---|---|---|
| Escritas por segundo, média | 100.000.000 ÷ (30 × 86.400) | 39 por segundo |
| Escritas por segundo, pico | × 3 | cerca de 120 |
| Leituras por segundo, média | × 100 | cerca de 3.900 |
| Leituras por segundo, pico | × 3 | cerca de 11.600 |
| Links após 5 anos | 100 M × 12 × 5 | 6 bilhões |
| Armazenamento bruto | 6 × 10^9 × 500 B | 3 TB |
| Com 3 cópias | × 3 | 9 TB |
| Leituras por dia | 3.858 × 86.400 | 333 milhões |
| Cache para os links quentes | suponha 1 link distinto a cada 100 leituras: 3,3 M distintos por dia, os 20% mais quentes deles, a 500 B | cerca de 333 MB |
| Servidores de aplicação | 11.600 ÷ 5.000 por servidor = 3, mais um reserva | 4 |
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).
| Grandeza | Cálculo | Resultado |
|---|---|---|
| Uploads por dia | 50 M × 10% | 5 milhões (58 por segundo em média) |
| Armazenamento novo por dia | 5 M × 2,2 MB | 11 TB |
| Armazenamento novo por ano | × 365 | 4 PB |
| Com 3 cópias completas | × 3 | 12 PB por ano |
| Com erasure coding (cerca de 1,5×) | × 1,5 | 6 PB por ano |
| Dados de saída por dia | 50 M × 50 × 300 KB | 750 TB |
| Largura de banda de saída média | 750 TB × 8 ÷ 86.400 | 69 Gbit/s |
| No pico de 3× | × 3 | cerca de 208 Gbit/s |
| Links de 10 Gbit/s necessários | média, pico | 7, 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.
| Grandeza | Cálculo | Resultado |
|---|---|---|
| Mensagens por dia | 100 M × 40 | 4 bilhões |
| Mensagens por segundo, média | ÷ 86.400 | cerca de 46.000 |
| Mensagens por segundo, pico | × 3 | cerca de 139.000 |
| Armazenamento por dia | 4 B × 200 B | 800 GB |
| Armazenamento por ano | × 365 | 292 TB (876 TB com 3 cópias) |
| Conexões no pico | 20% de 100 M | 20 milhões |
| Memória para manter as conexões | 20 M × 8 KB | 160 GB |
| Gateways | 20 M ÷ 100.000 | 200 (mais capacidade de reserva) |
| Se um gateway cai | 100.000 clientes se reconectam; em 30 s | cerca 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:
| Dados | A 1 Gbit/s | A 10 Gbit/s |
|---|---|---|
| 1 TB | 2,2 horas | 13 minutos |
| 10 TB | 22 horas | 2,2 horas |
| 100 TB | 9,3 dias | 22 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
- Pico não é média. O tráfego segue o dia, a semana e os eventos. Um produto que tem média de 1.000 requisições por segundo pode ver 3.000 no pico da noite e 10.000 em um lançamento. Diga qual dos dois você está dimensionando.
- Leituras e escritas são problemas diferentes. As leituras escalam com caches e réplicas; as escritas exigem particionamento ou lotes. A proporção (100:1 para um encurtador, 1:1 para um chat, muita escrita para métricas) decide qual dos dois é difícil.
- O fan-out multiplica. Um post de uma conta com um milhão de seguidores é uma escrita e um milhão de atualizações de feed se você empurra na escrita. Estime o fan-out, não só o número de posts.
- Replicação e overhead são multiplicadores, não notas de rodapé. Três cópias, índices, espaço livre e backups podem transformar 3 TB em 15 TB.
- Crescimento. Estime para o período de retenção e para um a três anos de crescimento de usuários, e diga o que acontece quando a estimativa for superada.
- As médias escondem a cauda. Se uma requisição em cem é dez vezes mais lenta, um usuário que faz cinquenta requisições por página vê uma lenta em cerca de 40% das páginas (1 − 0,99^50). As metas de latência são percentis, e a aritmética do fan-out torna a cauda mais importante, não menos.
- Utilização não é capacidade. Um servidor levado a 100% não tem espaço para um pico, um deploy ou um vizinho perdido, e as filas crescem bruscamente quando a utilização chega perto de 100%. Planeje 50 a 70%.
- Domínios de falha. Capacidade é o que sobra quando algo falha. Pergunte se o sistema ainda aguenta o pico depois de perder um servidor, um rack ou uma zona.
- Meça, depois confie. Todo número por servidor em uma estimativa é um palpite até ser medido sob carga realista. Os valores medidos aqui mostram a distância entre um "hello world" e um handler de verdade.
9. Apresentando uma estimativa
Em uma entrevista ou em uma revisão de projeto, a estimativa também é comunicação.
- Declare as premissas primeiro, com unidades: "Vou supor 100 milhões de usuários diários, 40 mensagens cada, 200 bytes por mensagem."
- Arredonde para facilitar a conta (86.400 vira 100.000 quando você precisa fazer de cabeça) e diga que arredondou. Um algarismo significativo basta.
- Vá do pequeno ao grande e mostre o significado do resultado: "São cerca de 46.000 mensagens por segundo em média, então uns 140.000 no pico, o que um banco de dados não aguenta, mas um log particionado aguenta."
- Termine com a consequência de projeto, não com o número: qual restrição domina e o que você fará por causa disso.
- Confira por outro caminho: "Pelo lado das máquinas, 200 gateways com 100.000 conexões cada dão os mesmos 20 milhões."
- Convide à correção. Se o entrevistador muda uma premissa, refaça a única linha que ela afeta. É para isso que servem as premissas escritas.
10. Erros comuns
- Estimar antes de entender os requisitos, de modo que os números respondem a uma pergunta que ninguém fez.
- Usar a média onde o pico importa, ou o contrário.
- Misturar bits e bytes, ou MB e MiB quando a precisão importa, ou meses de 30 e 31 dias onde não importa.
- Esquecer replicação, índices, espaço livre e retenção ao dimensionar o armazenamento.
- Contar usuários em vez de usuários simultâneos, ou usuários simultâneos em vez de requisições.
- Supor a capacidade de um servidor sem uma medição ou uma fonte clara, e depois construir um plano em cima disso.
- Falsa precisão: "47.917 requisições por segundo" diz ao ouvinte que quem fala não entende a incerteza das entradas.
- Parar no número e nunca dizer o que ele significa para o projeto.
- Superdimensionar para uma escala imaginária ou subdimensionar para uma real. A estimativa existe para decidir qual dos dois.
11. O que mencionar em uma entrevista
- Por que estimar: para encontrar a restrição dominante e decidir entre projetos, não para ser exato.
- As constantes: 86.400 segundos em um dia (1 milhão por dia ≈ 12 por segundo), potências de dois e de dez, bits contra bytes, os noves de disponibilidade.
- A hierarquia de latência e as suas proporções; o que um cache, uma CDN e o agrupamento mudam.
- Os sete passos: escopo, tráfego com fator de pico, armazenamento com replicação e overhead, largura de banda, memória/conjunto de trabalho, servidores com folga, conferência.
- A lei de Little para a concorrência, e o efeito de uma lentidão nas requisições em andamento.
- Que a movimentação de dados (reconstruções, restaurações) tem um custo de tempo que limita o tamanho dos nós.
- Que as estimativas devem ser conferidas por outro caminho, arredondadas, declaradas com as premissas e seguidas de uma consequência de projeto.
Resumo rápido
- Uma estimativa decide a arquitetura ao encontrar a restrição dominante (requisições, armazenamento, largura de banda, memória, conexões ou taxa de escrita). A precisão não é o objetivo; a ordem de grandeza é.
- Memorize 86.400 s por dia (1 M por dia ≈ 12 por segundo), as potências de dois, bits contra bytes, os noves e as proporções de latência. Medido em uma VM pequena: cerca de 40.000 requisições HTTP triviais por segundo, 200.000 buscas indexadas por segundo, 4.400 commits com fsync por segundo e cerca de 4,6 KB de memória por conexão ociosa.
- O método: escopo → tráfego (× fator de pico) → armazenamento (× réplicas × overhead × retenção) → largura de banda → memória → servidores (÷ utilização-alvo, + reserva) → conferência.
- O mesmo método deu três respostas diferentes: o encurtador de URLs (3 TB, 4 servidores: um cache e um banco de dados), o compartilhamento de fotos (4 PB por ano, 208 Gbit/s no pico: armazenamento de objetos e uma CDN) e o chat (20 milhões de conexões, 160 GB: uma camada de conexões com cerca de 200 gateways).
- A lei de Little (
L = λW) dá as requisições em andamento; o tempo de cópia (10 TB levam 22 horas a 1 Gbit/s) limita o tamanho que um nó pode ter. - Declare as premissas com unidades, arredonde, confira por outro caminho e termine com o que o número significa para o projeto.
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
- Jeff Dean, "Numbers Everyone Should Know" (Google), conforme compilado e atualizado no gist da comunidade Latency Numbers Every Programmer Should Know, e Peter Norvig, Teach Yourself Programming in Ten Years (a lista original).
- Martin Kleppmann, Designing Data-Intensive Applications (O'Reilly), capítulo 1, "Reliable, Scalable, and Maintainable Applications": descrever a carga, percentis e o efeito do fan-out.
- John D. C. Little, "A Proof for the Queuing Formula: L = λW", Operations Research 9(3), 1961 (a lei de Little).
- Alex Xu, System Design Interview: An Insider's Guide (2020), capítulo 2, "Back-of-the-envelope estimation".
- Donne Martin, The System Design Primer, apêndice sobre potências de dois, números de latência e métricas úteis.
- Wikipedia, High availability, a tabela de porcentagens de disponibilidade e indisponibilidade permitida.
- Beyer, Jones, Petoff, Murphy (orgs.), Site Reliability Engineering (O'Reilly, 2016), sobre objetivos de nível de serviço e folga.
Pratique este tema: System Design System Design › Reliability and scale