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:
- Implantação e propriedade independentes: uma equipe entrega o seu serviço sem pedir às outras (se as fronteiras estiverem certas).
- Escalonamento independente: escale o serviço de redimensionamento de imagens, não a loja inteira.
- Isolamento de falhas e de tecnologia: uma queda ou um vazamento de memória fica em um serviço; um serviço pode usar outra linguagem ou outro banco de dados onde isso importa.
Custa:
- Latência e falha de rede em cada chamada, como medido abaixo.
- Nenhuma transação compartilhada: uma operação de negócio que atravessa serviços precisa de sagas ou de inconsistência aceita.
- Peso operacional: muitos pipelines, implantações, dashboards, alertas, versões e escalas de plantão.
- Depuração e testes mais difíceis: uma requisição é um trace através de processos, e muitos bugs só aparecem na interação.
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 é feita | Tempo por chamada | Em comparação com uma chamada de função |
|---|---|---|
| Chamada de função no mesmo processo | 19 ns | 1x |
| A mesma, com codificação e decodificação JSON do pedido (sem rede) | 4,7 µs | 251x |
| Uma requisição HTTP real sobre loopback com keep-alive, uma por vez | 89 µs de mediana, 562 µs no percentil 99 | cerca 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érie | Disponibilidade | Indisponibilidade por ano |
|---|---|---|
| 1 | 99,90% | cerca de 526 minutos |
| 3 | 99,70% | 1 575 minutos |
| 5 | 99,50% | 2 623 minutos |
| 10 | 99,00% | 5 232 minutos (3,6 dias) |
| 20 | 98,02% | 10 413 minutos |
| 50 | 95,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ão | Mediana | Percentil 99 |
|---|---|---|
| 1 chamada | 20 ms | 72 ms |
| uma cadeia de 3 chamadas síncronas | 66 ms | 145 ms |
| uma cadeia de 5 | 112 ms | 206 ms |
| uma cadeia de 8 | 181 ms | 296 ms |
| esperar pela mais lenta de 5 chamadas paralelas | 37 ms | 96 ms |
| a mais lenta de 10 chamadas paralelas | 45 ms | 108 ms |
| a mais lenta de 50 chamadas paralelas | 67 ms | 139 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:
- Comece pelas capacidades de negócio e pelos bounded contexts do domain-driven design: "pedidos", "catálogo", "pagamentos", "envio", cada um com sua própria linguagem e regras, e não pelas camadas técnicas ("o serviço de banco de dados", "o serviço de validação").
- Um serviço é dono dos seus dados. Nenhum outro serviço lê ou grava suas tabelas; eles usam a sua API ou os seus eventos. Um banco de dados compartilhado é um acoplamento oculto: qualquer mudança de schema vira uma negociação entre equipes.
- Otimize para alta coesão e baixo acoplamento: o que muda junto fica junto.
- Dimensione por propriedade da equipe e carga cognitiva, não por linhas de código. "Micro" não é uma meta.
Sinais de alerta de um monolito distribuído:
- As releases precisam ser coordenadas entre serviços (precisam sair em certa ordem ou juntas).
- Os serviços compartilham um banco de dados ou uma biblioteca com lógica de negócio.
- Uma única ação do usuário precisa de muitas chamadas síncronas entre serviços, de modo que um serviço lento atrasa todos.
- Mudar um campo exige edições em meia dúzia de repositórios.
- Tudo cai quando um serviço "pequeno" cai.
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:
- Uma equipe é dona de cada serviço de ponta a ponta: código, dados, pipeline, plantão e contrato da API. "Quem constrói, opera" importa porque a equipe acordada de madrugada é a que corrige a causa. Um serviço sem dono claro se deteriora; mantenha um catálogo de serviços com o dono, o caminho do plantão, o runbook, os SLOs e as dependências de cada um.
- Uma equipe é dona de alguns serviços, não de dezenas. Não há um limite medido, mas uma plataforma com muito mais serviços do que pessoas é um sinal de alerta: cada serviço carrega um custo fixo (pipeline, dashboards, alertas, correções, atualizações), e a falta de gente aparece como serviços que ninguém entende.
- Alinhe as equipes com capacidades de negócio, não com camadas. Uma "equipe de front-end", uma "equipe de back-end" e uma "equipe de banco de dados" obrigam cada funcionalidade a passar por três filas. Uma equipe alinhada ao fluxo (stream-aligned) que é dona de uma capacidade (checkout, busca) consegue entregar sozinha. Equipes especialistas de plataforma fornecem então o caminho pavimentado (deploy, observabilidade, um modelo de serviço) e equipes habilitadoras (enabling) espalham habilidades; esse é o vocabulário do livro Team Topologies.
- Seja dono do contrato, não só do código. Os consumidores dependem da sua API, dos seus eventos e do comportamento dos seus erros; as mudanças passam por versionamento e por um período de descontinuação, e o dono sabe quem o chama (um gateway e o tracing tornam isso visível).
- Cuidado com código compartilhado. Uma biblioteca compartilhada com lógica de negócio acopla os calendários de release e recria a coordenação do monólito. Compartilhe contratos e utilitários de infraestrutura, não lógica de domínio.
- Equipes pequenas e poucos serviços? Fique modular. Se uma equipe de oito pessoas é dona de tudo, um monólito bem estruturado dá a independência que importa (limites claros entre módulos) sem os custos de rede medidos acima. Divida ao longo de um limite quando surgir um limite de equipe.
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:
- Roteamento por caminho ou host para o serviço certo, e versionamento das APIs públicas.
- Terminação de TLS e autenticação: verifique o token uma vez na borda e repasse a identidade (veja autenticação e sessões). Os serviços internos ainda precisam verificar a autorização: não confie apenas em "veio do gateway".
- Limitação de taxa e cotas por cliente (projetando um rate limiter) e proteção contra tráfego abusivo.
- Cache de respostas e compressão, transformação de requisições e respostas.
- Agregação: uma chamada de um app móvel que o gateway distribui para vários serviços, poupando idas e voltas em redes lentas.
- Observabilidade: um trace id é criado aqui e propagado, e o log de acesso fica em um só lugar.
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:
- Baseada em DNS: um nome resolve para as instâncias (ou para um IP virtual). Simples, mas o cache do DNS faz as mudanças demorarem a aparecer (DNS e CDNs).
- Um registro (registry): as instâncias se registram e enviam heartbeats; os chamadores o consultam (Consul, etcd, ZooKeeper, que usam consenso para se manter consistentes). O Kubernetes faz isso com Services e endpoints.
- Balanceamento de carga do lado do cliente: o chamador recebe a lista e escolhe uma instância por conta própria (round robin, menos carregada ou power of two choices), evitando um salto extra.
- Balanceamento de carga do lado do servidor: um proxy no meio faz a escolha.
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:
- TLS mútuo entre serviços com rotação automática de certificados e políticas de autorização baseadas em identidade ("só o serviço de pedidos pode chamar pagamentos").
- Gestão de tráfego: retries, timeouts, circuit breaking, releases canary e deslocamento de tráfego (enviar 5% das requisições à nova versão), injeção de falhas para testes.
- Telemetria uniforme: taxa de requisições, taxa de erros e latência para cada par de serviços, e spans de trace (a aplicação ainda precisa repassar os cabeçalhos de trace).
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:
- Composição de API: um chamador (ou um gateway, ou um BFF) chama vários serviços e combina os resultados. Simples, mas a latência e a disponibilidade se multiplicam, e joins grandes são impraticáveis.
- Um read model (CQRS): um serviço mantém a sua própria cópia desnormalizada dos dados de que precisa dos outros, atualizada a partir dos eventos deles; a consulta fica então local e rápida, e os dados são eventualmente consistentes. O guia de event sourcing e CQRS cobre isso.
- Consistência eventual por design: aceite que "o pedido foi feito, mas os pontos de fidelidade chegam um segundo depois" e diga a verdade ao usuário na interface.
- O padrão outbox para publicar um evento atomicamente com uma mudança no banco de dados local, de modo que nenhum evento seja perdido ou inventado.
- Preocupações multi-tenant (isolamento, limites por tenant, vizinhos barulhentos) valem para a plataforma inteira: veja projetando um sistema multi-tenant.
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:
- 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.
- 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.
- 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.
- 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.
- 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.
- 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 é montada | Mediana | Percentil 99 |
|---|---|---|
| um join em SQL em um banco compartilhado | 0,040 ms | 0,077 ms |
| 50 chamadas HTTP, uma por pedido | 11,5 ms | 16,7 ms |
uma chamada HTTP em lote (ids=1,2,3,...) | 0,45 ms | 1,2 ms |
| um modelo de leitura local (o serviço de pedidos guarda uma cópia dos nomes) | 0,036 ms | 0,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ão | O que o substitui | O preço |
|---|---|---|
| joins através da fronteira | chamadas em lote, modelos de leitura, um repositório de relatórios | latência, dados desatualizados, dados duplicados |
| chaves estrangeiras através da fronteira | validaçã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ços | sagas e o outbox | compensações, estados intermediários visíveis aos usuários |
| um só lugar para consultar relatórios | eventos para um data warehouse ou índice de busca | um pipeline para construir e vigiar |
| um banco para fazer backup e atualizar | N bancos | trabalho 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
- Todo serviço precisa de um pipeline, um runbook, dashboards e alertas. Padronize-os com templates, ou o esforço cresce com o número de serviços.
- A observabilidade não é opcional: propague um trace id por todo salto e registre-o; sem isso, uma requisição lenta é uma busca em dezenas de logs. Veja observabilidade.
- Implante com segurança: releases graduais, blue-green ou canary, feature flags e rollback automático diante de regressões de taxa de erros ou de latência.
- Teste em vários níveis: testes unitários e de componente por serviço, testes de contrato entre eles e alguns testes de ponta a ponta das jornadas críticas (não centenas, são lentos e instáveis).
- Limite o raio da explosão: timeouts, bulkheads e circuit breakers em toda chamada; orçamentos para retries.
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):
- 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.
- 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.
- 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.
- 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).
- 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ção | Sucesso do checkout durante a falha | Sucesso da navegação durante a falha | Pedidos ao Payments (suporta 25/s) | Cobranças duplicadas | Cobrado, mas o cliente viu uma falha | Checkout saudável de novo após |
|---|---|---|---|---|---|---|
| A ingênua | 0,6% | 2,0% | 40/s | 320 | 3.733 | 8 s |
| B só pools separados (30 para o checkout, 10 para a navegação) | 1,8% | 100% | 30/s | 237 | 240 | 1 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/s | 403 | 3.933 | 9 s |
| D tudo isso, mais um circuit breaker, propagação de deadline e uma chave de idempotência | 0,0% | 100% | 1/s | 0 | 35 | 2 s |
| E D, e quando o Payments falha, aceitar o pedido como pendente e cobrar depois | 100% aceitos | 100% | 1/s | 0 | 0 | 0 s |
O que cada linha ensina:
- B (bulkhead) protege a funcionalidade não relacionada por completo e se recupera depressa porque menos trabalho se acumulou, mas o próprio checkout continua falhando, e as duplicatas continuam.
- C (timeout curto, orçamento de retentativas) é pior que o ingênuo para o Payments: os workers ficam livres de novo rapidamente, então mais tentativas chegam ao serviço em dificuldade (110 por segundo contra uma capacidade de 25), quase todas desperdiçadas, e o checkout continua falhando e continua produzindo milhares de cobranças duplicadas ou órfãs. Uma política de retentativas sozinha não protege uma dependência; um limite de concorrência ou um breaker, sim.
- D (breaker, deadlines, idempotência) reduz a carga sobre o Payments a quase nada, então a fila dele se esvazia e o checkout se recupera dois segundos depois que a falha termina; as chaves de idempotência eliminam as cobranças duplicadas; os poucos casos restantes de "cobrado, mas falhou" são requisições que já estavam em andamento quando o breaker abriu.
- E (degradar de propósito) é uma decisão de negócio, não técnica: aceitar um pedido cujo pagamento está pendente significa uma fila, um processo de reconciliação e uma regra para os pedidos que depois não puderem ser cobrados. Só é possível para operações que podem ser concluídas mais tarde.
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
- Começar com microsserviços para uma equipe pequena ou um produto não comprovado e gastar o esforço em infraestrutura.
- Dividir por camada técnica ou por entidade ("serviço de usuário", "serviço da tabela de pedidos") em vez de por capacidade de negócio.
- Um banco de dados compartilhado, ou uma biblioteca compartilhada cheia de lógica de negócio, entre serviços.
- Longas cadeias de chamadas síncronas e retries em todos os níveis.
- Sem timeouts, sem circuit breakers: um serviço lento derruba os outros.
- Tratar o gateway como o lugar da lógica de negócio.
- Adotar um service mesh antes de haver um problema que ele resolva.
- Ignorar o versionamento: mudanças incompatíveis entregues sem um caminho de migração.
- Subestimar a carga operacional: sem ferramentas padronizadas, sem rastreamento, sem dono para cada serviço.
11. Coisas a mencionar em uma entrevista
- Que os microsserviços tratam principalmente de equipes e independência de implantação, e que você começaria com um monolito modular, a menos que haja uma razão clara.
- O custo da rede: latência, falha parcial, a aritmética de disponibilidade (99,9% elevado a n) e a cauda do fan-out.
- Fronteiras de serviço a partir de bounded contexts, dados que pertencem a um serviço e os sintomas de um monolito distribuído.
- Comunicação síncrona contra assíncrona, sagas para processos entre serviços e o padrão outbox.
- O que um gateway faz (e não faz), a variação BFF e a diferença para um balanceador de carga.
- Descoberta e health checks; o que um service mesh acrescenta (mTLS, política de tráfego, telemetria) e o que custa.
- Um plano de migração com o strangler fig.
Resumo rápido
- Os microsserviços trocam chamadas de função por chamadas de rede para ganhar equipes e implantações independentes. Uma chamada sobre loopback foi cerca de 4 700 vezes mais lenta que uma chamada de função (19 ns contra 89 µs de mediana).
- A disponibilidade se multiplica (dez serviços de 99,9% em série dão 99,0%), a latência soma em uma cadeia e a cauda cresce com o fan-out (40% das requisições atingem uma chamada lenta ao esperar por 50 paralelas).
- Trace as fronteiras por capacidade de negócio, dê a cada serviço os seus próprios dados e fique atento a um monolito distribuído.
- Prefira eventos assíncronos para o trabalho que pode esperar, chamadas síncronas onde o usuário espera e sagas mais o padrão outbox para consistência entre serviços.
- O API gateway é a porta de entrada fina (roteamento, autenticação, limites, agregação, BFF por cliente); o service mesh leva retries, mTLS e telemetria para sidecars, ao custo de latência e complexidade.
- Migre com o strangler fig, padronize as operações e faça da observabilidade e da resiliência parte de todo serviço.
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
- Sam Newman, Building Microservices, 2ª edição (O'Reilly), e Monolith to Microservices (O'Reilly), para o strangler fig e os padrões de decomposição.
- Martin Fowler e James Lewis, Microservices: a definition of this new architectural term, e os artigos de Fowler MonolithFirst e StranglerFigApplication.
- Chris Richardson, microservices.io, a linguagem de padrões que inclui API gateway, banco de dados por serviço, saga e transactional outbox.
- Jeffrey Dean e Luiz André Barroso, The Tail at Scale (Communications of the ACM, 2013).
- Melvin Conway, How Do Committees Invent? (Datamation, 1968).
- A documentação do Envoy e do Istio para o modelo de sidecar e plano de controle, e a documentação do Kubernetes sobre Services e EndpointSlices.
- Eric Evans, Domain-Driven Design (Addison-Wesley, 2003), para os contextos delimitados (bounded contexts).
- Melvin Conway, How Do Committees Invent? (Datamation, 1968); Matthew Skelton e Manuel Pais, Team Topologies (IT Revolution, 2019).
- Site Reliability Engineering (Google), capítulo 22, Addressing Cascading Failures; Michael Nygard, Release It! (padrões de estabilidade: timeouts, circuit breakers, bulkheads).
- Chris Richardson, Database per service; Sam Newman, Monolith to Microservices (O'Reilly, 2019), os capítulos sobre a decomposição do banco de dados.
Pratique este tema: System Design System Design › Reliability and scale