CS Fundamentals Trainer · Guias

Microsserviços, API gateways e service meshes

O que dividir em serviços realmente custa em latência e disponibilidade, como traçar fronteiras, comunicação síncrona contra assíncrona, o API gateway e o BFF, a descoberta de serviços e o service mesh, e a migração strangler fig.

43 min de leitura

"Devemos usar microsserviços?" é uma das perguntas de arquitetura mais comuns, e a resposta honesta começa pelo que a pergunta realmente faz: devemos transformar chamadas de função em chamadas de rede para que equipes possam construir, implantar e escalar partes do sistema de forma independente? Essa troca pode ser a certa, e tem um preço fácil de subestimar: cada salto acrescenta latência e uma nova forma de falhar, e a consistência entre serviços passa a ser problema seu. Este guia dá os números desse preço e depois os padrões que o tornam gerenciável: fronteiras de serviço, estilos de comunicação, o API gateway, a descoberta de serviços e o service mesh.

Medi a sobrecarga da chamada no Node.js sobre loopback e simulei a aritmética de disponibilidade e latência em Python (código no apêndice). Ele se apoia em padrões de resiliência, observabilidade e transações distribuídas, que fornecem as ferramentas de que você precisa quando há uma rede entre os seus componentes.

1. Que problema os microsserviços resolvem?

Principalmente um problema organizacional. Um único artefato implantável (um monolito) é simples de construir, testar, executar e depurar, e rápido: as chamadas são chamadas de função e uma transação de banco de dados pode cobrir tudo. Começa a doer quando muitas equipes precisam mudar a mesma base de código: os builds ficam lentos, uma release significa coordenar todo mundo, o bug de uma equipe derruba tudo e um componente quente obriga a escalar o todo.

Dividir o sistema em serviços implantáveis de forma independente traz:

Custa:

A lei de Conway diz que os sistemas espelham a estrutura de comunicação da organização que os constrói. Trate-a como uma ferramenta de design: escolha as fronteiras de serviço para corresponder às fronteiras das equipes, e não o contrário. Uma equipe de oito pessoas com um produto raramente precisa de trinta serviços. Um caminho comum e sensato é um monolito modular primeiro (um artefato implantável com fronteiras de módulo estritas e cada módulo dono de suas tabelas) e extrair um serviço somente quando surgir uma necessidade concreta (um perfil de escalonamento diferente, uma cadência de release diferente, uma fronteira de equipe).

2. O preço de um salto de rede

Medi a mesma operação pequena, somar um pedido de dez itens, de três maneiras no Node.js em uma máquina virtual de dois núcleos:

Como a chamada é feitaTempo por chamadaEm comparação com uma chamada de função
Chamada de função no mesmo processo19 ns1x
A mesma, com codificação e decodificação JSON do pedido (sem rede)4,7 µs251x
Uma requisição HTTP real sobre loopback com keep-alive, uma por vez89 µs de mediana, 562 µs no percentil 99cerca de 4 700x

Mesmo no loopback, sem fio, sem TLS e sem roteamento, uma chamada de serviço é milhares de vezes mais lenta que uma chamada de função, e a maior parte do custo é serialização, protocolo e trocas de contexto, não a distância. Uma rede real acrescenta mais: aproximadamente de 0,1 a 1 ms dentro de um data center, de 10 a 100 ms através de um continente ou oceano (números típicos, não medidos aqui), além de TLS, balanceadores de carga e filas. E um único par de núcleos atendeu cerca de 13 000 dessas requisições por segundo no total, cliente e servidor juntos, o que mostra que as chamadas também consomem CPU nos dois lados.

A disponibilidade se multiplica

Se uma requisição precisa de n serviços em série e cada um tem 99,9% de disponibilidade, a requisição só fica disponível 99,9% elevado a n:

Serviços em sérieDisponibilidadeIndisponibilidade por ano
199,90%cerca de 526 minutos
399,70%1 575 minutos
599,50%2 623 minutos
1099,00%5 232 minutos (3,6 dias)
2098,02%10 413 minutos
5095,12%25 646 minutos (18 dias)

Isso supõe que as falhas são independentes, então é uma estimativa otimista. As correções são as do guia de resiliência: tornar as dependências opcionais (a página funciona sem recomendações: com 3 de 10 opcionais, a disponibilidade vai de 99,004% para 99,302%, com 6 opcionais para 99,601%), usar redundância (duas réplicas independentes de um serviço de 99% dão 99,99%, três dão 99,9999%) e evitar cadeias síncronas longas (abaixo).

A latência soma, e a cauda se multiplica

Modelei cada chamada com uma mediana de 20 ms e uma cauda longa (percentil 99 de 72 ms, uma distribuição lognormal) e medi o tempo de ponta a ponta:

PadrãoMedianaPercentil 99
1 chamada20 ms72 ms
uma cadeia de 3 chamadas síncronas66 ms145 ms
uma cadeia de 5112 ms206 ms
uma cadeia de 8181 ms296 ms
esperar pela mais lenta de 5 chamadas paralelas37 ms96 ms
a mais lenta de 10 chamadas paralelas45 ms108 ms
a mais lenta de 50 chamadas paralelas67 ms139 ms

As cadeias somam: oito saltos custam 9 vezes uma única chamada. O fan-out é mais brando com a mediana, mas prejudica a cauda: quando uma requisição espera por 50 chamadas paralelas, 39,6% das requisições atingem pelo menos uma chamada mais lenta que o pior caso de um em cem de uma única chamada, e a mediana é mais de três vezes a de uma única chamada. Esse é o efeito "tail at scale" (Dean e Barroso): quanto mais serviços uma requisição toca, mais vezes ela encontra o mau momento de alguém. Defesas: menos saltos, cache, timeouts com fallbacks e requisições hedged (enviar uma duplicata a outra réplica quando a primeira está lenta) para leituras idempotentes.

3. Traçando as fronteiras

Boas fronteiras fazem a maioria das mudanças ser local a um serviço. As ruins criam um monolito distribuído: o custo dos microsserviços sem nenhum dos benefícios.

Orientações para achar as fronteiras:

Sinais de alerta de um monolito distribuído:

Quem é o dono de um serviço?

Os limites entre serviços também são limites entre pessoas. A lei de Conway diz que a estrutura de um sistema tende a copiar a estrutura de comunicação da organização que o constrói; se quatro equipes precisam concordar antes de uma mudança ser entregue, a arquitetura terá quatro partes interligadas, seja qual for o diagrama. Microsserviços funcionam quando os limites são traçados de propósito nas duas linhas (a "manobra inversa de Conway": moldar as equipes para obter a arquitetura que se quer). Na prática:

4. Como os serviços conversam

Diagram: Synchronous calls and asynchronous events

Síncrona (REST, gRPC): simples de raciocinar, resposta imediata, mas o chamador depende de o chamado estar no ar e rápido agora, então a disponibilidade e a latência se multiplicam como mostrado. Use para consultas que precisam de uma resposta para prosseguir. O gRPC (HTTP/2 com Protocol Buffers) é mais compacto e rápido que JSON sobre HTTP/1.1, aceita deadlines e streaming e dá um contrato tipado; o REST é mais universal para APIs externas (veja projetando uma API REST).

Assíncrona (eventos ou comandos por um broker): o produtor não espera, os serviços ficam desacoplados no tempo, os picos são absorvidos pela fila e novos consumidores podem ser adicionados sem tocar no produtor. Os custos são consistência eventual, rastreamento mais difícil, entrega duplicada e fora de ordem (veja filas de mensagens e garantias de entrega) e um broker para operar.

Uma divisão pragmática: síncrona para consultas e para a única chamada em que o usuário está esperando, assíncrona para tudo o que pode acontecer depois da resposta. Um serviço de pedidos pode responder "pedido feito" depois de salvá-lo e publicar um evento; o e-mail, o analytics, os pontos de fidelidade e as reações do envio vêm depois, por conta própria.

Para um processo de negócio que atravessa serviços, use uma saga: ou coreografia (cada serviço reage a eventos e emite o seguinte: desacoplada, mas o fluxo geral é difícil de ver) ou orquestração (um coordenador diz a cada serviço o que fazer e trata a compensação: mais fácil de acompanhar e de mudar, com o coordenador como um novo componente). O guia anterior sobre transações distribuídas cobre ambas e os limites das chaves de idempotência.

Contratos e versões

Os serviços evoluem separadamente, então a interface é um contrato. Mude-a de forma compatível: adicione campos opcionais, não remova nem reinterprete os existentes e use o padrão expandir e contrair para mudanças incompatíveis (adicione a forma nova, migre todos os consumidores, remova a antiga). Os testes de contrato dirigidos pelo consumidor deixam cada consumidor publicar as requisições e respostas em que se apoia, e o pipeline do provedor falha quando uma mudança as quebraria. Use um schema (OpenAPI, protobuf, Avro) e uma verificação de compatibilidade no CI.

5. O API gateway

Os clientes (um navegador, um app de celular, um parceiro) não devem conhecer os seus serviços internos. Um API gateway é um ponto de entrada único que roteia as requisições externas para os serviços por trás dele e trata as preocupações transversais em um só lugar:

Diagram: An API gateway in front of the services

Trabalhos típicos:

Uma variação é o Backend for Frontend (BFF): um gateway separado por tipo de cliente (web, mobile, parceiro), de propriedade da equipe desse cliente e moldado às suas necessidades, em vez de um gateway de uso geral que atende mal a todos.

Armadilhas: o gateway está no caminho de toda requisição, então precisa ter alta disponibilidade e ser escalado horizontalmente; ele vira um gargalo e uma dependência de deploy se a lógica de negócio se acumular nele (mantenha-o fino: endpoints inteligentes, canos burros); e seus timeouts, retries e limites exigem o mesmo cuidado que os de qualquer chamador (padrões de resiliência). Não o confunda com um balanceador de carga, que distribui o tráfego entre instâncias de um serviço (balanceamento de carga); um gateway costuma ficar por cima de balanceadores de carga.

6. Encontrando serviços: descoberta e balanceamento de carga

As instâncias vêm e vão (deploys, autoscaling, quedas), então seus endereços mudam. Os chamadores precisam de uma forma de encontrar as saudáveis:

Qualquer que seja o seu uso, acrescente health checks (readiness e liveness são perguntas diferentes), reuso de conexões e timeouts e orçamentos de retry; uma lista desatualizada envia tráfego a instâncias mortas.

7. O service mesh

Quando há muitos serviços, cada um deles precisa da mesma infraestrutura: TLS mútuo, retries, timeouts, circuit breaking, balanceamento de carga, métricas e traces. Escrever isso em uma biblioteca para cada linguagem é caro e difícil de manter consistente. Um service mesh tira isso da aplicação e o leva para a infraestrutura: um pequeno proxy (um sidecar, muitas vezes o Envoy) roda ao lado de cada instância de serviço e trata todo o seu tráfego de entrada e de saída, e um plano de controle os configura.

Diagram: Sidecar proxies and a control plane

O que ele oferece, sem mudar o código da aplicação:

O que custa: latência e CPU extras em cada salto (dois proxies por chamada, tipicamente um milissegundo ou menos, mas não de graça), memória para cada sidecar, um plano de controle complexo para operar e atualizar e uma nova classe de falhas e configurações erradas difíceis de depurar. Designs mais novos executam o proxy por nó ou sem sidecars para reduzir essa sobrecarga. Um mesh também não corrige problemas de design: retries configurados no mesh e na aplicação se multiplicam (veja o guia de resiliência), e ele não consegue tornar rápido um design tagarela.

Você precisa de um? Muitas vezes não, no começo. Com um punhado de serviços, uma boa biblioteca cliente, um gateway e as network policies do Kubernetes bastam. Considere um mesh quando tiver dezenas de serviços em várias linguagens, uma exigência firme de TLS mútuo em todo lugar e uma equipe de plataforma para operá-lo.

8. Dados, consultas e consistência

Com um banco de dados por serviço, você perde joins e transações entre serviços:

Migrando para um banco de dados por serviço, passo a passo

Dividir os dados costuma ser mais difícil do que dividir o código, porque o banco compartilhado é onde o acoplamento se esconde: joins, chaves estrangeiras, tabelas compartilhadas e transações que atravessam o que virarão vários serviços. Uma migração que funciona em um sistema ao vivo é feita em passos pequenos e reversíveis:

  1. Mapeie a propriedade. Para cada tabela, decida qual capacidade é dona dela (quem pode escrever nela). As tabelas escritas por várias partes do monólito são o primeiro problema a resolver, não o último.
  2. Separe primeiro dentro do banco. Dê a cada futuro serviço o seu próprio schema e o seu próprio usuário de banco, e revogue o acesso aos outros schemas. As violações passam a falhar de forma barulhenta, enquanto ainda é um só banco e um só deploy.
  3. Substitua cada join e cada chave estrangeira que cruza a fronteira. Opções: uma chamada de API, uma chamada de API em lote, um modelo de leitura local preenchido a partir de eventos, ou aceitar que os dados são duplicados e que a chave estrangeira vira um job de reconciliação.
  4. Sincronize durante a mudança. Use change data capture ou o padrão outbox (event sourcing e CQRS); evite escritas duplas feitas pelo código da aplicação, que se desencontram quando uma das escritas falha.
  5. Mude as leituras e depois as escritas, atrás de uma flag, comparando os resultados antigo e novo (leituras em sombra, shadow reads) antes da troca. Guarde os dados antigos por um período de rollback.
  6. Mova os dados fisicamente (um servidor separado ou uma instância gerenciada) por último. Muitos serviços podem ficar em um só servidor de banco, com schemas separados, por bastante tempo.

No que um join se transforma. Medi uma página de 50 pedidos com o nome do cliente, com 100.000 pedidos e 10.000 clientes. Em um único banco é um só join em SQL. Depois da divisão, os dados dos clientes ficam atrás de um serviço HTTP (HTTP de verdade no loopback, então não há latência de rede nestes números):

Como a página é montadaMedianaPercentil 99
um join em SQL em um banco compartilhado0,040 ms0,077 ms
50 chamadas HTTP, uma por pedido11,5 ms16,7 ms
uma chamada HTTP em lote (ids=1,2,3,...)0,45 ms1,2 ms
um modelo de leitura local (o serviço de pedidos guarda uma cópia dos nomes)0,036 ms0,062 ms

A versão ingênua é cerca de 290 vezes mais lenta e, com uma rede real entre os serviços, ainda acrescentaria 50 viagens de ida e volta; o lote traz o custo de volta para cerca de 11 vezes o do join; um modelo de leitura local custa o mesmo que o join, em troca de consistência eventual (um cliente renomeado mostra o nome antigo até o evento chegar) e de uma cópia dos dados a manter correta. A mesma troca aparece em todo lugar:

O que você abre mãoO que o substituiO preço
joins através da fronteirachamadas em lote, modelos de leitura, um repositório de relatórioslatência, dados desatualizados, dados duplicados
chaves estrangeiras através da fronteiravalidação na hora da escrita, eventos, jobs de reconciliaçãoórfãos são possíveis e precisam ser detectados
uma transação ACID entre serviçossagas e o outboxcompensações, estados intermediários visíveis aos usuários
um só lugar para consultar relatórioseventos para um data warehouse ou índice de buscaum pipeline para construir e vigiar
um banco para fazer backup e atualizarN bancostrabalho operacional para cada um

O que você ganha: cada serviço pode escolher e escalar o seu armazenamento, uma mudança de schema em um serviço não consegue quebrar outro, e uma queda ou uma consulta lenta em um banco fica contida. Não pague o preço sem um motivo: se duas partes do sistema precisam sempre mudar juntas e ser consistentes, provavelmente pertencem ao mesmo serviço.

9. Operando muitos serviços

Migrando de um monolito: o strangler fig

Diagram: The strangler fig: route by route, behind a facade

Não reescreva tudo de uma vez. Ponha uma fachada na frente, extraia uma capacidade por vez (começando por uma pouco acoplada e valiosa), roteie o tráfego dela para o novo serviço, migre os dados dela e aposente essa parte do monolito. A cada passo o sistema funciona e você pode parar.

9.1 Uma falha completa, de ponta a ponta: uma dependência lenta derruba o resto

As seções anteriores mediram efeitos isolados (disponibilidade, latência, retentativas). Quedas reais combinam todos eles. Simulei um sistema pequeno em tempo simulado (script no apêndice; um modelo, não um deployment real): os clientes chamam o Orders; o Orders tem 40 workers e chama o Inventory (rápido) e o Payments (que consegue concluir 20 cobranças ao mesmo tempo, de 50 ms cada, ou seja, cerca de 400 por segundo); a navegação também é atendida pelo Orders e nunca chama o Payments. Carga: 100 checkouts e 200 navegações por segundo. Os clientes desistem após 3 segundos. Durante 30 segundos o Payments fica lento (800 ms por cobrança, como com um banco de dados degradado), e passa a concluir apenas cerca de 25 cobranças por segundo, enquanto 100 são pedidas.

Diagram: The simulated system: browsing and checkout share Orders' workers

O que acontece com as configurações ingênuas (timeout de 1 s, 3 retentativas sem espera, um pool compartilhado, sem circuit breaker, sem chave de idempotência):

  1. A fila do Payments cresce e as chamadas começam a passar do timeout de 1 s. Quem chama desiste, mas o Payments continua fazendo o trabalho: 97% das cobranças que ele concluiu durante a falha já não tinham ninguém esperando.
  2. Cada checkout passa a prender um worker do Orders por até 4 segundos (4 tentativas de 1 s). Os 40 workers ficam todos ocupados em instantes.
  3. A navegação, que nunca toca o Payments, também falha: ela entra na fila atrás dos checkouts bloqueados, e apenas 2% das navegações tiveram sucesso durante a falha. Esta é a cascata: a falha de uma dependência virou a falha de tudo o que divide um pool com ela.
  4. Sucesso parcial: as cobranças terminam depois que quem chamou já deu timeout, então os clientes são cobrados e informados de que falhou (cerca de 3.700 deles), e as retentativas de uma cobrança inacabada cobram de novo (cerca de 320 duplicatas).
  5. Depois que o Payments se recupera, o atraso acumulado e as retentativas na fila mantêm o checkout quebrado por mais uns 8 segundos.

Corrigindo uma coisa de cada vez (média de três execuções; as contagens são da execução inteira de 70 segundos):

ConfiguraçãoSucesso do checkout durante a falhaSucesso da navegação durante a falhaPedidos ao Payments (suporta 25/s)Cobranças duplicadasCobrado, mas o cliente viu uma falhaCheckout saudável de novo após
A ingênua0,6%2,0%40/s3203.7338 s
B só pools separados (30 para o checkout, 10 para a navegação)1,8%100%30/s2372401 s
C só um timeout de 250 ms e um orçamento de retentativas (no máximo uma retentativa a cada dez requisições)0,0%100%110/s4033.9339 s
D tudo isso, mais um circuit breaker, propagação de deadline e uma chave de idempotência0,0%100%1/s0352 s
E D, e quando o Payments falha, aceitar o pedido como pendente e cobrar depois100% aceitos100%1/s000 s

O que cada linha ensina:

As lições gerais são as do guia de padrões de resiliência, agora vistas juntas: toda chamada precisa de um timeout menor que o de quem a chama, retentativas precisam de um orçamento e de backoff, dê a cada dependência o seu próprio pool, pare de chamar uma dependência que está falhando, torne as operações idempotentes para que uma retentativa não as repita e decida de antemão o que o sistema faz no lugar. Limites do modelo: o Payments real também descartaria carga, os clientes fazem retentativas por conta própria, e os tamanhos de pool, os timeouts e a duração da falha aqui são escolhas minhas; mude-os no script e a tabela muda, mas a ordem dos efeitos (pool compartilhado primeiro, retentativas depois, duplicatas em terceiro) é o que se deve procurar.

10. Erros comuns

11. Coisas a mencionar em uma entrevista

Resumo rápido

Apêndice: o código dos experimentos

O primeiro script (Python 3, apenas a biblioteca padrão, sementes fixas) calcula a tabela de disponibilidade e simula a latência de cadeias e fan-outs a partir de uma distribuição lognormal com mediana de 20 ms; a distribuição é uma suposição escolhida para ter uma cauda longa realista, não a medição de nenhum serviço real, e trata as chamadas como independentes, o que as chamadas reais muitas vezes não são. O segundo script (Node.js 22) mede uma chamada de função, uma ida e volta de JSON e uma requisição HTTP sobre loopback em uma pequena máquina virtual de dois núcleos, então os nanossegundos serão diferentes no seu hardware; o que importa é a razão. Ele inicia o seu próprio servidor HTTP e não precisa da internet.

Aritmética de disponibilidade e latência de cauda

import random, math

# 1. availability of a request that needs n services in series, each 99.9% available
print("n services in series, each 99.9% available:")
for n in (1, 3, 5, 10, 20, 50):
    a = 0.999 ** n
    print(f"  n={n:>2}: {a*100:.2f}% available = {(1-a)*365*24*60:,.0f} minutes of downtime per year")
# with a fallback (degraded answer) on a share of the dependencies
print("10 services, 99.9% each, when k of them are optional (the page still works without them):")
for k in (0, 3, 6, 9):
    a = 0.999 ** (10 - k); print(f"  {k} optional: {a*100:.3f}%")
# replicas: an instance 99% available, r replicas behind a load balancer
for r in (1, 2, 3): print(f"  one service at 99%: {r} independent replicas -> {(1-(0.01)**r)*100:.4f}%")

# 2. tail latency: a request that calls n services in parallel and waits for all of them
rnd = random.Random(3)
def call():  # lognormal: median 20 ms, a long tail (1% of calls above ~ 85 ms)
    return math.exp(rnd.gauss(math.log(20), 0.55))
def pct(v, p): v = sorted(v); return v[int(len(v) * p) - 1]
single = [call() for _ in range(100000)]
P99 = pct(single, .99)
print(f"one call: median {pct(single, .5):.0f} ms, 99th percentile {pct(single, .99):.0f} ms")
for n in (1, 5, 10, 50):
    fan = [max(call() for _ in range(n)) for _ in range(20000)]
    slow = sum(x > P99 for x in fan) / len(fan)
    print(f"  wait for the slowest of {n:>2} parallel calls: median {pct(fan, .5):.0f} ms, 99th {pct(fan, .99):.0f} ms; {slow*100:.1f}% of requests hit at least one 'p99-slow' call")

# 3. a synchronous chain against parallel and asynchronous designs
chain = lambda n: [sum(call() for _ in range(n)) for _ in range(20000)]
for n in (1, 3, 5, 8):
    c = chain(n); print(f"  chain of {n} synchronous calls: median {pct(c, .5):.0f} ms, 99th {pct(c, .99):.0f} ms")

O custo de uma chamada: função, JSON e HTTP (Node.js)

import http from 'node:http';
const handler = (req, res) => { let b = ''; req.on('data', (c) => (b += c)); req.on('end', () => { const o = JSON.parse(b); res.setHeader('content-type', 'application/json'); res.end(JSON.stringify({ total: o.items.reduce((s, i) => s + i.price * i.qty, 0) })); }); };
const server = http.createServer(handler).listen(0);
await new Promise((r) => setTimeout(r, 100));
const order = { id: 7, items: Array.from({ length: 10 }, (_, i) => ({ sku: 'sku-' + i, price: 10 + i, qty: 2 })) };
const total = (o) => o.items.reduce((s, i) => s + i.price * i.qty, 0);

// 1. a function call
let s = 0; const N1 = 2_000_000; let t = performance.now();
for (let i = 0; i < N1; i++) s += total(order);
const fn = ((performance.now() - t) / N1) * 1e6;
// 2. the same call with the JSON encode and decode a network call needs, but no network
t = performance.now(); const N2 = 200_000;
for (let i = 0; i < N2; i++) s += total(JSON.parse(JSON.stringify(order)));
const ser = ((performance.now() - t) / N2) * 1e6;
// 3. a real HTTP request over loopback, keep-alive, one at a time
const agent = new http.Agent({ keepAlive: true, maxSockets: 1 });
const call = () => new Promise((ok) => { const r = http.request({ port: server.address().port, method: 'POST', agent, headers: { 'content-type': 'application/json' } }, (res) => { let b = ''; res.on('data', (c) => (b += c)); res.on('end', () => ok(JSON.parse(b))); }); r.end(JSON.stringify(order)); });
for (let i = 0; i < 2000; i++) await call();
const lat = []; for (let i = 0; i < 10000; i++) { const t0 = performance.now(); await call(); lat.push(performance.now() - t0); }
lat.sort((a, b) => a - b);
console.log(`in-process function call: ${fn.toFixed(0)} ns`);
console.log(`function call plus JSON encode and decode of the order: ${ser.toFixed(0)} ns (${(ser / fn).toFixed(0)}x)`);
console.log(`HTTP call over loopback, keep-alive, one at a time: median ${(lat[5000] * 1000).toFixed(0)} us, 99th percentile ${(lat[9900] * 1000).toFixed(0)} us (${((lat[5000] * 1e6) / fn).toFixed(0)}x the function call)`);
// 4. concurrency: requests per second with a pool of connections
const t2 = performance.now(); const agent2 = new http.Agent({ keepAlive: true, maxSockets: 32 });
const call2 = () => new Promise((ok) => { const r = http.request({ port: server.address().port, method: 'POST', agent: agent2, headers: { 'content-type': 'application/json' } }, (res) => { res.resume(); res.on('end', ok); }); r.end(JSON.stringify(order)); });
let done = 0; await Promise.all(Array.from({ length: 32 }, async () => { for (let i = 0; i < 1000; i++) { await call2(); done++; } }));
console.log(`32 concurrent connections: ${(done / ((performance.now() - t2) / 1000)).toFixed(0)} requests per second, client and server on the same two cores`);
if (s === 42) console.log(); server.close(); agent.destroy(); agent2.destroy(); process.exit(0);

Uma falha em cascata: timeouts, retentativas, pools, um circuit breaker e idempotência

Python 3, apenas biblioteca padrão; ele simula o tempo, então uma execução leva alguns segundos e é repetível a partir das sementes.

"""A cascading failure across three services, in simulated time (milliseconds).
Clients -> Orders (a worker pool) -> Inventory (fast) and Payments (a service with limited capacity).
Payments becomes slow for 30 s. Which settings of timeouts, retries, pools, a circuit breaker and idempotency keys decide what happens?"""
import heapq, itertools, random, collections, statistics

CLIENT_TIMEOUT = 3000          # the browser or the gateway gives up after 3 s
FAULT = (15_000, 45_000)       # Payments is slow in this window; the run lasts 70 s
UNTIL = 70_000
CHECKOUT_RPS, BROWSE_RPS = 100, 200
PAY_CAPACITY, PAY_MS, PAY_SLOW_FACTOR = 20, 50, 16   # 20 concurrent charges of 50 ms, or 800 ms when slow

class Sim:
    def __init__(s, seed): s.t = 0.0; s.q = []; s.n = itertools.count(); s.rnd = random.Random(seed)
    def at(s, dt, fn): heapq.heappush(s.q, (s.t + dt, next(s.n), fn))
    def run(s, until):
        while s.q and s.q[0][0] <= until:
            s.t, _, fn = heapq.heappop(s.q); fn()

class Pool:
    """A fixed number of workers and a FIFO queue (optionally bounded: extra requests are rejected at once)."""
    def __init__(s, size, max_queue=None): s.size, s.busy, s.wait, s.max_queue = size, 0, collections.deque(), max_queue
    def submit(s, job, reject):
        if s.busy < s.size: s.busy += 1; job(s.release)
        elif s.max_queue is not None and len(s.wait) >= s.max_queue: reject()
        else: s.wait.append(job)
    def release(s):
        s.busy -= 1
        if s.wait and s.busy < s.size: s.busy += 1; s.wait.popleft()(s.release)

class Breaker:
    """Opens when at least half of the last 20 outcomes failed; after 5 s lets one probe through."""
    def __init__(s): s.hist = collections.deque(maxlen=20); s.open_until = 0; s.probing = False
    def allow(s, t):
        if t < s.open_until: return False
        if s.open_until and not s.probing: s.probing = True; return True    # half-open: a single probe
        return not s.open_until
    def record(s, ok, t):
        if s.probing: s.probing = False; s.hist.clear(); s.open_until = 0 if ok else t + 5000; return
        s.hist.append(ok)
        if len(s.hist) >= 10 and s.hist.count(False) >= len(s.hist) / 2: s.open_until = t + 5000; s.hist.clear()

CONFIGS = {
    "A naive: 1 s timeout, 3 retries, one shared pool": dict(timeout=1000, attempts=4, backoff=0, budget=False, breaker=False, bulkhead=False, idem=False, deadline=False, fallback=False),
    "B only separate pools (bulkhead)": dict(timeout=1000, attempts=4, backoff=0, budget=False, breaker=False, bulkhead=True, idem=False, deadline=False, fallback=False),
    "C only short timeout and a retry budget": dict(timeout=250, attempts=2, backoff=100, budget=True, breaker=False, bulkhead=False, idem=False, deadline=False, fallback=False),
    "D all together, plus breaker and idempotency": dict(timeout=250, attempts=2, backoff=100, budget=True, breaker=True, bulkhead=True, idem=True, deadline=True, fallback=False),
    "E all of D, and when Payments fails accept the order as pending": dict(timeout=250, attempts=2, backoff=100, budget=True, breaker=True, bulkhead=True, idem=True, deadline=True, fallback=True),
}

def run(cfg, seed):
    sim = Sim(seed); rnd = sim.rnd
    pay = Pool(PAY_CAPACITY)
    if cfg["bulkhead"]: pools = {"checkout": Pool(30, 30), "browse": Pool(10, 30)}   # the same 40 workers, split
    else: pools = {"checkout": (shared := Pool(40)), "browse": shared}
    breaker = Breaker(); tokens = [10.0]
    charges = collections.Counter(); attempts = []; reqs = []; waste = [0, 0]      # waste: [charges nobody waited for, charges done], during the fault

    def pay_call(req_id, reply):
        def job(release):
            slow = FAULT[0] <= sim.t < FAULT[1]
            svc = PAY_MS * (PAY_SLOW_FACTOR if slow else 1) * (0.8 + 0.4 * rnd.random())
            def done():
                if not (cfg["idem"] and charges[req_id]): charges[req_id] += 1     # an idempotency key makes the repeat a no-op
                release(); used = reply()
                if FAULT[0] <= sim.t < FAULT[1]: waste[1] += 1; waste[0] += (not used)
            sim.at(svc, done)
        pay.submit(job, lambda: None)

    def finish(r, ok, why=""):
        if "done" in r: return
        r["done"] = True; r["ok"] = ok and sim.t - r["t0"] <= CLIENT_TIMEOUT; r["why"] = why; r["lat"] = sim.t - r["t0"]

    def fail(r, why):
        if cfg["fallback"]: finish(r, True, "pending")           # accept the order now, charge it later from a queue
        else: finish(r, False, why)

    def checkout(r):
        def job(release):
            if cfg["deadline"] and sim.t - r["t0"] > CLIENT_TIMEOUT: release(); finish(r, False, "expired"); return
            def attempt(n):
                if cfg["breaker"] and not breaker.allow(sim.t): release(); fail(r, "breaker"); return
                st = {"over": False}; attempts.append(sim.t)
                def reply():
                    if st["over"]: return False                  # the caller gave up: this work was wasted
                    st["over"] = True; breaker.record(True, sim.t); release(); finish(r, True); return True
                def timeout():
                    if st["over"]: return
                    st["over"] = True; breaker.record(False, sim.t)
                    if n < cfg["attempts"] and (not cfg["budget"] or tokens[0] >= 1):
                        if cfg["budget"]: tokens[0] -= 1
                        sim.at(cfg["backoff"] * 2 ** (n - 1) * (0.5 + rnd.random()), lambda: attempt(n + 1))
                    else: release(); fail(r, "timeout")
                if n == 1 and cfg["budget"]: tokens[0] = min(10.0, tokens[0] + 0.1)
                pay_call(r["id"], reply); sim.at(cfg["timeout"], timeout)
            sim.at(10, lambda: attempt(1))                      # the inventory check
        pools["checkout"].submit(job, lambda: finish(r, False, "shed"))

    def browse(r):
        def job(release):
            if cfg["deadline"] and sim.t - r["t0"] > CLIENT_TIMEOUT: release(); finish(r, False, "expired"); return
            def done(): release(); finish(r, True)
            sim.at(5, done)
        pools["browse"].submit(job, lambda: finish(r, False, "shed"))

    def arrivals(kind, rps, fn):
        t = 0.0
        while True:
            t += rnd.expovariate(rps / 1000)
            if t > UNTIL - CLIENT_TIMEOUT: break                # do not count requests whose outcome would be cut off by the end of the run
            r = {"id": len(reqs), "kind": kind, "t0": t}; reqs.append(r); sim.at(t, lambda r=r: fn(r))
    arrivals("checkout", CHECKOUT_RPS, checkout); arrivals("browse", BROWSE_RPS, browse)
    sim.run(UNTIL)
    return reqs, charges, attempts, waste

def phase(t0):
    return "before" if t0 < FAULT[0] else "during" if t0 < FAULT[1] else "after"

def summarise(cfg, seeds=(1, 2, 3)):
    acc = collections.defaultdict(list)
    for seed in seeds:
        reqs, charges, attempts, waste = run(cfg, seed)
        for ph in ("before", "during", "after"):
            for kind in ("checkout", "browse"):
                rs = [r for r in reqs if r["kind"] == kind and phase(r["t0"]) == ph]
                acc[(ph, kind, "ok")].append(100 * sum(bool(r.get("ok")) for r in rs) / len(rs))
                lat = sorted(r["lat"] for r in rs if r.get("ok"))
                acc[(ph, kind, "p99")].append(lat[int(len(lat) * .99)] if lat else float("nan"))
        co = [r for r in reqs if r["kind"] == "checkout" and FAULT[0] <= r["t0"] < FAULT[1]]
        att = [a for a in attempts if FAULT[0] <= a < FAULT[1]]
        acc["amp"].append(len(att) / len(co)); acc["rate"].append(len(att) / ((FAULT[1] - FAULT[0]) / 1000)); acc["waste"].append(100 * waste[0] / max(1, waste[1]))
        acc["pend"].append(100 * sum(r.get("why") == "pending" for r in co) / len(co))
        acc["dup"].append(sum(1 for r in reqs if r["kind"] == "checkout" and charges[r["id"]] > 1))
        acc["lost"].append(sum(1 for r in reqs if r["kind"] == "checkout" and charges[r["id"]] >= 1 and not r.get("ok")))
        # recovery: seconds after the fault ends until a 5-second window of checkouts is at least 95% successful
        rec = None
        for s in range(0, 25):
            w = [r for r in reqs if r["kind"] == "checkout" and FAULT[1] + s * 1000 <= r["t0"] < FAULT[1] + s * 1000 + 5000]
            if w and sum(bool(r.get("ok")) for r in w) / len(w) >= .95: rec = s; break
        acc["rec"].append(rec if rec is not None else 25)
    m = lambda k: statistics.mean(acc[k])
    return m, acc

if __name__ == "__main__":
    print(f"Payments is slow ({PAY_MS} ms -> {PAY_MS*PAY_SLOW_FACTOR} ms per charge, capacity {PAY_CAPACITY} at a time) from {FAULT[0]//1000} s to {FAULT[1]//1000} s; {CHECKOUT_RPS} checkouts/s and {BROWSE_RPS} browses/s (browsing never calls Payments).")
    print("Success = the client got a good answer within 3 s. Average of 3 seeds.\n")
    for name, cfg in CONFIGS.items():
        m, _ = summarise(cfg)
        print(name)
        print(f"   checkout success %  before {m(('before','checkout','ok')):5.1f}  during {m(('during','checkout','ok')):5.1f}  after {m(('after','checkout','ok')):5.1f}")
        print(f"   browse   success %  before {m(('before','browse','ok')):5.1f}  during {m(('during','browse','ok')):5.1f}  after {m(('after','browse','ok')):5.1f}   (unrelated to Payments)")
        print(f"   Payments during the fault: {m('rate'):.0f} attempts/s offered (it can finish 25/s), {m('waste'):.0f}% of its finished charges had no caller waiting; {m('pend'):.0f}% of checkouts answered 'accepted, pending'")
        print(f"   duplicate charges: {m('dup'):.0f} | charged but the client saw a failure: {m('lost'):.0f} | checkout back to >=95% after the fault ends: {m('rec'):.0f} s")

No que um join se transforma depois da divisão: join em SQL, chamadas HTTP por linha, uma chamada em lote e um modelo de leitura local

Python 3 com sqlite3 e http.server, no loopback. Os tempos absolutos dependem da máquina; o que importa são as proporções.

"""What a join becomes after 'database per service': listing 50 orders with the customer's name.
Orders and customers live in separate SQLite databases; the customer service answers over real HTTP on loopback (stdlib only)."""
import http.client, http.server, json, random, socket, sqlite3, statistics, threading, time

N_CUSTOMERS, N_ORDERS, PAGE = 10_000, 100_000, 50
rnd = random.Random(4)

# one shared database (before the split)
shared = sqlite3.connect(":memory:", check_same_thread=False)
shared.executescript("create table customers(id integer primary key, name text); create table orders(id integer primary key, customer_id int, total int);")
shared.executemany("insert into customers values (?,?)", ((i, f"customer {i}") for i in range(N_CUSTOMERS)))
shared.executemany("insert into orders values (?,?,?)", ((i, rnd.randrange(N_CUSTOMERS), rnd.randrange(1, 500)) for i in range(N_ORDERS)))
shared.execute("create index o_c on orders(customer_id)")

# after the split: the customer service owns `customers`, the order service owns `orders`
cust_db = sqlite3.connect(":memory:", check_same_thread=False)
cust_db.execute("create table customers(id integer primary key, name text)")
cust_db.executemany("insert into customers values (?,?)", shared.execute("select id, name from customers"))
ord_db = sqlite3.connect(":memory:", check_same_thread=False)
ord_db.execute("create table orders(id integer primary key, customer_id int, total int)")
ord_db.executemany("insert into orders values (?,?,?)", shared.execute("select id, customer_id, total from orders"))

class H(http.server.BaseHTTPRequestHandler):
    protocol_version = "HTTP/1.1"
    def setup(self): super().setup(); self.connection.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)   # avoid the 40 ms delayed-ACK stall
    def log_message(self, *a): pass
    def do_GET(self):
        if self.path.startswith("/customers/"):
            row = cust_db.execute("select id, name from customers where id=?", (int(self.path.split("/")[2]),)).fetchone()
            out = {"id": row[0], "name": row[1]}
        else:                                                    # /customers?ids=1,2,3
            ids = [int(x) for x in self.path.split("=")[1].split(",")]
            out = [{"id": i, "name": n} for i, n in cust_db.execute(f"select id, name from customers where id in ({','.join('?'*len(ids))})", ids)]
        b = json.dumps(out).encode()
        self.send_response(200); self.send_header("Content-Length", str(len(b))); self.end_headers(); self.wfile.write(b)
srv = http.server.ThreadingHTTPServer(("127.0.0.1", 8120), H); threading.Thread(target=srv.serve_forever, daemon=True).start()
conn = http.client.HTTPConnection("127.0.0.1", 8120); conn.connect(); conn.sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
def get(path): conn.request("GET", path); return json.loads(conn.getresponse().read())

def a_join():
    return shared.execute("select o.id, o.total, c.name from orders o join customers c on c.id=o.customer_id order by o.id desc limit ?", (PAGE,)).fetchall()
def b_one_call_per_order():
    rows = ord_db.execute("select id, customer_id, total from orders order by id desc limit ?", (PAGE,)).fetchall()
    return [(i, t, get(f"/customers/{c}")["name"]) for i, c, t in rows]
def c_one_batched_call():
    rows = ord_db.execute("select id, customer_id, total from orders order by id desc limit ?", (PAGE,)).fetchall()
    names = {c["id"]: c["name"] for c in get("/customers?ids=" + ",".join(str(c) for _, c, _ in rows))}
    return [(i, t, names[c]) for i, c, t in rows]
replica = {}
def d_local_read_model():
    """The order service keeps its own copy of the customer names, filled from customer events."""
    rows = ord_db.execute("select id, customer_id, total from orders order by id desc limit ?", (PAGE,)).fetchall()
    return [(i, t, replica[c]) for i, c, t in rows]
replica.update(dict(cust_db.execute("select id, name from customers")))

def bench(fn, reps=200):
    fn(); xs = []
    for _ in range(reps):
        t = time.perf_counter(); fn(); xs.append((time.perf_counter() - t) * 1000)
    xs.sort(); return statistics.median(xs), xs[int(len(xs) * .99)]
assert sorted(a_join()) == sorted(b_one_call_per_order()) == sorted(c_one_batched_call()) == sorted(d_local_read_model())
print(f"A page of {PAGE} orders with the customer name; {N_ORDERS:,} orders, {N_CUSTOMERS:,} customers. Milliseconds per page (median / 99th percentile, 200 runs):")
for label, fn in (("one SQL join in a shared database", a_join), (f"separate databases: {PAGE} HTTP calls, one per order", b_one_call_per_order),
                  ("separate databases: one batched HTTP call", c_one_batched_call), ("separate databases: local read model (copy of the names)", d_local_read_model)):
    m, p = bench(fn); print(f"  {label:<58} {m:7.3f} / {p:7.3f} ms")
srv.shutdown()

Fontes

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

Mais guias