Arquitetura de Sistemas · Insper

Mensageria e Arquitetura Orientada a Eventos

Envie uma mensagem, siga em frente — e trate o que isso implica

10:00 — dois milhões de fãs, sessenta mil lugares

A compra reserva lugares, cobra o cartão, envia o e-mail, atualiza busca e analytics — tudo em uma requisição.
O provedor de e-mail passa de 80 ms para 800 ms. O que acontece com o botão "Comprar"?

  • Cada compra fica 720 ms mais lenta; o order fica sem threads.
  • Fãs prestes a pagar veem um spinner e depois um erro.
  • Nada quebrou: cada passo só precisava terminar antes de alguém receber resposta.

Duas ligações da compra

Síncrono
fã
→
order
espera →
notification800 ms hoje
→
search
→
analytics
→ 201
Assíncrono
fã
→
order201 depois de salvar e publicar
publica →
KafkaOrderConfirmed
→
cada um no seu ritmo
notification
search
analytics
  • Síncrono: o fã espera a soma das chamadas e qualquer falha derruba a compra.
  • Assíncrono: o fã espera um salvamento e uma publicação; um consumidor lento só aumenta o backlog dele.

Cadeia síncrona vs eventos assíncronos

Cadeia síncrona Eventos assíncronos
Latência para o fã soma de todas as chamadas salvar + publicar uma mensagem
Disponibilidade do "Comprar" 0.9995 × 0.999³ ≈ 99.65% 0.9995 × 0.9995 ≈ 99.90%
Acoplamento order conhece cada consumidor order conhece um tópico + schema
Um consumidor falha a compra falha o backlog dele cresce
Consistência pronto quando o fã vê 201 consumidores alcançam depois (eventual)

Se quem chama precisa da resposta para continuar, chame. Se só precisa que o trabalho aconteça, envie uma mensagem.

O que um broker oferece — e quanto custa

Oferece

  • Desacoplamento temporal — o consumidor pode estar fora
  • Nivelamento de carga — um pico vira backlog
  • Fan-out — novos consumidores, produtor intacto
  • Escala independente e isolamento de falhas

Custa

  • Consistência eventual — "120 lugares restantes" por um tempo
  • Duplicatas e reordenação — consumidores idempotentes
  • Depuração mais difícil — tracing e métricas de lag
  • Mais um sistema crítico para operar

Nivelamento de carga em números

Pico de 6.000 req/s por 3 min, workers escoam 2.000 req/s.

  • O backlog cresce a λ − μ = 4,000/s → 4,000 × 180 = 720,000 mensagens.
  • O último fã espera backlog / μ = 720,000 / 2,000 = 360 s (Lei de Little).
  • Dobrar os workers → metade do pico e escoamento muito mais rápido.

Uma fila absorve picos, não uma falta permanente: se a chegada média passa da capacidade, o backlog cresce para sempre.

Playground: async-queue com o perfil spike — observe a profundidade da fila e o consumer lag.

A paleta de mensageria

Componente Forma Quem recebe uma mensagem Depois da leitura
queue ponto a ponto um consumidor do pool apagada
pubsub fan-out toda assinatura apagada por assinatura
stream log particionado (gerenciado) todo consumer group mantida até a retenção
kafka log particionado e replicado todo consumer group mantida (ou compactada)
  • Comando (GenerateTicketPdf) — faça algo; um receptor.
  • Evento (OrderConfirmed) — um fato, no passado; qualquer um pode reagir.

O que vai dentro de um evento

Notificação de evento

{ type, eventId, orderId, occurredAt }

  • Pequeno e estável.
  • Cada consumidor chama de volta GET /orders/o-7731: uma chamada a mais por consumidor e por evento, e o order precisa estar no ar.

Transferência de estado no evento

{ …, customer, event, seats, total }

  • Os consumidores nunca chamam de volta: desacoplados da disponibilidade do order.
  • Payload maior, schema mais difícil de mudar, dado pessoal (o e-mail) copiado para todo consumidor.

Dê nome aos eventos no passado (OrderConfirmed); SendConfirmationEmail é um comando disfarçado.

Chamada, fila, pub/sub ou log?

Quem chama precisa da resposta para continuar?
sim →
chamada síncronacom timeout: login, reservar lugares
não ↓
Quantos serviços precisam reagir?
um trabalho só →
queueconsumidores concorrentes: o PDF do ingresso
vários ↓
Precisa de replay, ordem por chave, alto throughput?
não →
pubsube-mail e push
sim →
stream · kafkawarehouse, busca

Numa fila, ler é tirar; num log, ler é olhar, com um marcador por leitor. A tabela "Quando não ir para o assíncrono" da página classifica oito interações do BoxOffice assim.

A vida de uma mensagem na fila

receberworker 1 pega o o-7731
→
escondida 30 svisibility timeout
→
worker 1 caiantes do ack
→
visível de novo
→
worker 2entrega 2
ack →
apagada
  • O broker só apaga a mensagem no ack: nenhuma mensagem se perde quando um worker morre.
  • Com consumidores concorrentes não há ordem; filas FIFO (first-in, first-out) a mantêm por id de grupo.

At-least-once: um crash depois do upload faz o job rodar duas vezes → consumidor idempotente (tickets/o-7731.pdf é um nome determinístico). Um visibility timeout menor que o job faz todo job lento rodar duas vezes.

Dimensionando o pool de workers

workers ocupados = λ × S (Lei de Little)

  • ~30.000 pedidos confirmados em 3 min → λ ≈ 167/s; o PDF leva S = 0.4 s.
  • Em tempo real: 167 × 0.4 ≈ 67 ocupados → ~95 workers a 70% de utilização.
  • 20 workers (50/s): backlog ≈ 21.000, escoa em ~7 min depois da venda.

Trabalho assíncrono é dimensionado por um objetivo de atraso ("ingressos por e-mail em até 15 min"), não por latência de requisição.

Simulador queue: 95 workers (ρ = 0,70) dão conta; com 60 (ρ = 1,11) o backlog só cresce; um pico de 3× chega a cerca de 5.300 jobs.

Backpressure: o que acontece quando a fila enche?

Estratégia Exemplo no BoxOffice Custo
Buffer (limitado) a fila de PDF absorve a abertura o atraso cresce
Escalar consumidores KEDA (Kubernetes Event-driven Autoscaling) pelo tamanho da fila a carga vai para frente
Rejeitar na borda 429 / 503 + Retry-After erro rápido e honesto
Desacelerar o produtor o producer do Kafka bloqueia (max.block.ms) a latência vai para trás
Descartar / expirar "lugares restantes" velhos, tempo de vida (TTL, time to live) no push perda de dados por projeto
Descartar por prioridade confirmações antes de marketing filas separadas

Alerte sobre a idade da mensagem mais antiga, não só sobre a profundidade.

A sala de espera da flash sale

2 M de fãs
entram →
sala de esperasorted set do Redis: posição
admite N/s →
token de admissãovida curta, assinado
→
gatewayrejeita chamadas sem ele
→
inventory~1.100 reservas/s
  • N = capacidade medida × fator de segurança: 1.100 × 0,5 ≈ 500 fãs/s; espera honesta = posição / N.
  • Esgotou → "esgotado" pela borda, sem tocar no banco. Bots: desafio e limites por conta aqui.
  • Justiça: posição aleatória para quem chegou cedo, ordem de chegada depois.
  • Lab 7: o score vem de INCR (o servidor decide a ordem), 20 fãs/s por padrão, uma chave de admitido com TTL de 5 minutos, conferida pelo POST /orders.

Playground: flash-sale começa sem sala de espera — veja app e inventory-db saturarem às 10:00 e depois construa a fila.

Publish/subscribe

order
OrderConfirmed →
tópicoorder-events
uma cópia cada →
assinatura notification
notification #1
notification #2
assinatura search
indexador da busca
assinatura analytics
carregador do analytics
  • Dentro de uma assinatura os consumidores competem; entre assinaturas todos veem tudo.
  • Um consumidor de pontos de fidelidade = uma assinatura nova, order intacto e sem saber.
  • Pull: os consumidores pedem, controle de fluxo natural (workers). Push: o broker chama um endpoint HTTPS (serverless, webhooks).

Redis Pub/Sub e NATS core são efêmeros: assinantes desconectados perdem mensagens. Serve para "digitando…", não para pedidos.

O log: ler não apaga

  • Registros só de acréscimo e ordenados; cada um recebe um offset.
  • Cada leitor guarda a própria posição → muitos leitores independentes.
  • Replay: volte o offset (reindexar depois de um bug); comece um leitor novo do 0.
  • Um tópico = N partições, cada uma um log independente em um broker diferente.
  • A ordem é garantida só dentro de uma partição.

A chave decide a partição

partição = murmur2(chave) mod N

  • Mesma chave → mesma partição → em ordem. Chave por orderId.
  • Chave pelo show na abertura do estádio → uma partição recebe ~60% do tráfego.
  • Escolha a chave mais fina que preserve a ordem de que você precisa.

Mudar N move as chaves (hash mod N muda) — dimensione as partições com folga desde o início.

Consumer groups e lag

order-events · 6 partições
P0 · P1
P2 · P3
P4 · P5
um leitor por
partição, por grupo →
grupo notification · 3 consumidores
notification #1P0, P1
notification #2P2, P3
notification #3P4, P5
grupo analytics
analytics #1as 6, com offsets próprios
  • Paralelismo máximo de um grupo = número de partições: 8 consumidores em 6 partições → 2 ociosos.
  • Lag = offset do fim do log − offset confirmado, por partição: uma partição quente = chave quente, consumidor travado ou mensagem venenosa.
  • Rebalance quando membros entram, saem ou param de fazer poll (max.poll.interval.ms).

Simulador kafka (as 6 partições e os 3 consumidores do lab 7): chave pelo show → ev-1 cai na P5, que fica para trás. Playground: event-fanout.

Replicação e durabilidade

acks Confirmado quando… Uma falha de broker pode…
0 enviado ❌ perder registros em silêncio
1 a líder gravou ⚠️ perder registros confirmados
all toda réplica sincronizada (ISR, in-sync replica) tem ✅ não perdê-los, com min ISR ≥ 2
  • Fator de replicação (RF, replication factor) 3 entre zonas de disponibilidade (AZs, availability zones) + min.insync.replicas=2 + acks=all: um broker fora, as escritas continuam; nada confirmado vive em uma só máquina.
  • O lab 7 roda um broker com RF 1: ali acks: all espera exatamente uma réplica — a armadilha acima.
  • Metadados com controllers KRaft (Raft); ZooKeeper removido no Kafka 4.0.

Retenção, compactação e por que o Kafka é rápido

0 · ev-8821:00
1 · ev-90Jazz Night
2 · ev-8820:00
3 · ev-91Theater
4 · ev-90null (tombstone)
compacta →
2 · ev-8820:00
3 · ev-91Theater
  • Apagar por tempo (retention.ms, 7 dias para order-events: replay e o warehouse) ou por tamanho.
  • Compactar (event-catalog): sobrevive o registro mais recente de cada chave, com seu offset; um tombstone apaga uma chave.
  • Tiered storage: segmentos antigos vão para object storage — meses de retenção, barato.
  • Rápido: acréscimos sequenciais, o page cache do sistema operacional, zero-copy com sendfile, lotes comprimidos com zstd. O preço: alguns ms de linger.ms.

Dimensionando partições

N ≥ max(T / p, T / c) e depois adicione folga

  • Pico: 30.000 pedidos × 10 eventos / 180 s ≈ 1.700 eventos/s — trivial para os produtores.
  • notification: 50 ms por e-mail → c = 20/s por partição.
  • OrderConfirmed ≈ 167/s → N ≥ 167 / 20 ≈ 9 → crie 24.
  • Lab 7: um broker, 6 partições → no máximo 6 × 20 = 120/s; uma 7ª thread fica ociosa.

O consumidor costuma ser o gargalo. Alternativas a mais partições: lotes, concorrência por chave.

Onde uma mensagem se perde ou se duplica

orderprodutor
1 · envia →
Kafka2 · replica
3 · entrega →
notificationconsumidor
4 · e-mail →
provedor
5 · commit do offset ↩
Trecho Falha Efeito Defesa
1 ack perdido, o produtor tenta de novo duplicata no log produtor idempotente
1 crash antes de enviar perda (Bruno) transactional outbox
2 a líder morre com acks=1 perda de registro confirmado acks=all, min ISR 2
3–5 crash entre o e-mail e o commit duplicata (Ana, três vezes) consumidor idempotente

Semântica de entrega

Garantia Consumidor Kafka Um crash significa
At-most-once commit antes de processar ❌ mensagem perdida
At-least-once commit depois de processar ⚠️ mensagem repetida
Exactly-once transações do Kafka — só dentro do Kafka ✅ nenhum dos dois

Efetivamente uma vez = at-least-once + processamento idempotente. O Kafka não desenvia um e-mail.

Simulador delivery: cobra → commit com um crash → 7 cobranças para 6 pedidos; commit → cobra → o pedido se perde; a chave de idempotência resolve a repetição, não a perda.

O consumidor idempotente

@KafkaListener(topics = "order-events", groupId = "notification")
@Transactional
public void on(OrderConfirmed event) {
    int inserted = jdbc.update("""
        INSERT INTO processed_events (consumer, event_id)
        VALUES ('notification', ?) ON CONFLICT DO NOTHING
        """, event.eventId());
    if (inserted == 0) return;       // duplicate: already handled
    emails.schedule(event);          // same transaction
}
  • Linha de deduplicação e mudança de negócio em uma transação; offset confirmado depois.
  • Chamadas externas levam uma chave de idempotência; o id do evento é criado uma vez, pelo produtor.
  • Lab 7: processed_events (event_id), mas o e-mail é enviado dentro da transação — um crash depois do envio o repete.

Ordenação, retries e dead letters

  • A ordem quebra com: retries do produtor (resolvido pela idempotência), tópicos diferentes, pools de threads, tópicos de retry.
  • Visões entre serviços: versão por entidade, aplique só as mais novas (WHERE version < :v).
  • Erro transitório → retries bloqueantes no lugar (lab 7: 0,5 s, 1 s, 2 s — a partição espera, a ordem se mantém) ou tópicos de retry (1 s, 4 s, 16 s — a partição segue, eventos posteriores ultrapassam).
  • Mensagem venenosa → a fila de mensagens mortas (DLQ, dead letter queue; no Kafka, um dead letter topic) depois de N tentativas — ou na hora, para erros de parsing — e um alerta.

Uma DLQ que ninguém lê é um jeito mais lento de perder mensagens. O redrive só é seguro porque os consumidores são idempotentes.

O simulador: retry no lugar ou em tópicos de retry?

Bloqueante
o-1005 falhanos primeiros 2 s
→
espera 0,5 s, 1 s, 2 sno lugar
→
enviado na tentativa 4parada 3,5 s · atraso 8 · ordem mantida ✅
Tópicos de retry
o-1005 falha
→
retry-0 · 1 sfalha de novo
→
retry-1 · 4 s
→
enviadonunca parou · Cancelled 4,1 s antes ❌
  • Venenosa sem classificação: o bloqueante chega à DLQ depois de 3,5 s, os tópicos de retry depois de 21,2 s; para sempre nunca larga — 53 registros esperam depois de 30 s.
  • Classifique os erros permanentes (lab 7: IllegalArgumentException): direto para a DLQ, sem espera.

Evolução de schema

Compatibilidade Mudanças seguras Implante primeiro
Backward remover campos; adicionar campos com default consumidores
Forward adicionar campos; remover campos com default produtores
Full adicionar/remover campos opcionais com default qualquer ordem
  • Nunca: renomear, mudar tipo, mudar significado (reais → centavos).
  • Avro/Protobuf + schema registry; envelope CloudEvents; mudança incompatível → order-events.v2.

Escrita dupla → transactional outbox

orderPOST /orders
uma transação →
banco do order
INSERT orders
INSERT outbox
relay faz polling →
SKIP LOCKED
Kafkachave = orderId, acks=all
ack →
marca como publicado
  • Escrita dupla: COMMIT, crash, evento nunca publicado (Bruno); publicar antes, rollback, evento fantasma.
  • Um crash depois do ack e antes da marcação republica: pelo menos uma vez, nunca perdido.
  • Relay por polling (lab 7) ou por captura de mudanças (CDC, change data capture) com Debezium, que lê o write-ahead log. Lab 7 a 200 pedidos/s: p50 do POST /orders 2,7 s (sync) → 1,8 ms (outbox).

O CDC também mantém busca, cache e warehouse sincronizados a partir do banco do catalog — mas CDC bruto vaza o schema das suas tabelas; use eventos projetados para outros times.

A saga de compra

Passo Serviço Transação local Compensação
1 order cria o pedido PENDING cancela
2 inventory reserva lugares (10 min) libera
3 payment cobra o cartão (chave = id do pedido) — pivô estorna
4 inventory marca lugares SOLD — repetido
5 order CONFIRMED, publica OrderConfirmed — repetido

Uma saga é atômica, consistente e durável, mas não isolada: mostre o estado intermediário ("lugares reservados — processando pagamento"). Num timeout do pagamento, reconcilie com o provedor antes de compensar.

A saga como máquina de estados

PENDING
SeatsHeld →
SEATS_HELD
PaymentCaptured →
(o pivô)
PAID
SeatsSold →
repetido até dar certo
CONFIRMED
SEATS_HELD
PaymentFailed / timeout →
RELEASING
SeatsReleased →
CANCELLED
  • Antes do pivô todo passo pode ser compensado; depois dele, os passos são repetidos, nunca desfeitos.
  • O status do pedido é o estado da saga: mude-o com updates condicionais (WHERE status = 'PENDING_PAYMENT').
  • O fã recebe 202 Accepted e "lugares reservados — processando pagamento" (um bloqueio semântico), não um spinner.

Coreografia ou orquestração?

Coreografia Orquestração
Coordenação serviços reagem a eventos orquestrador envia comandos
Visibilidade do fluxo espalhada pelos serviços uma máquina de estados
Risco espaguete de eventos um orquestrador "deus"
Bom para 2–3 passos simples 4+ passos, timers, ramificações

Motores de execução durável — Temporal, AWS Step Functions, Azure Durable Functions, Camunda — persistem o estado da saga, timers e retries.

Segregação de comando e consulta (CQRS) e event sourcing

CQRS

  • Modelo de escrita para invariantes; projeções para leitura.
  • "Meus ingressos" = uma tabela indexada alimentada por eventos.
  • Custo: lag → tratar read-your-writes (devolver o estado novo ou um token de versão).

Event sourcing

  • Os eventos são a fonte da verdade; estado = replay.
  • Auditoria, viagem no tempo, novos modelos de leitura a partir do histórico.
  • Custo: eventos são um contrato para sempre.

Use quando os requisitos pedem (livro-razão de pagamentos, leituras muito diferentes) — não por padrão.

O mapa de conceitos de mensageria

Componente Pergunta que responde Conceitos-chave
app (produtor) chamar e esperar, ou enviar? síncrono vs assíncrono, consistência eventual
queue quem faz este trabalho, em que taxa? consumidores concorrentes, ack, backpressure, sala de espera
pubsub como cada serviço recebe uma cópia? assinaturas, push/pull, filtros
stream · kafka quem precisa de histórico, replay, ordem por chave? partições, chaves, grupos, lag, RF 3
worker + consumidores e se chegar duas vezes ou quebrar? pelo menos uma vez, idempotência, DLQ, schemas
sql + kafka alterar dados e publicar, entre serviços? outbox, CDC, sagas, CQRS, event sourcing

O produtor só conhece um tópico e um schema; cada consumidor paga por essa liberdade com idempotência e monitoramento de lag.

Conclusões

  1. Chame quando precisa da resposta; envie mensagem quando o trabalho pode acontecer depois.
  2. Uma fila transforma um pico em backlog: dimensione workers com a Lei de Little e um objetivo de atraso.
  3. Toda fila precisa de backpressure e de um alerta sobre a idade da mensagem mais antiga.
  4. Kafka: chave = ordem + balanceamento; partições = paralelismo máximo; RF 3, acks=all, min ISR 2.
  5. A entrega é at-least-once: consumidores idempotentes, DLQ, schemas compatíveis.
  6. Outbox para publicar, sagas com compensações entre serviços, CQRS/ES só quando necessário.

Roteiro: (1) síncrono vs assíncrono e o que um broker oferece; (2) filas, backpressure e a sala de espera; (3) pub/sub; (4) Kafka: log, partições, chaves, grupos, replicação, dimensionamento; (5) semântica de entrega, idempotência, DLQ, schemas; (6) outbox, CDC, sagas, CQRS, event sourcing.

Deixe a turma responder. O ponto: o e-mail não é necessário para responder ao fã, mas está no caminho crítico. Essa é toda a motivação da mensageria.

A página desenha os dois como diagramas de sequência passo a passo (as duas abas de "Síncrono vs assíncrono").

A reserva de lugares continua síncrona: o fã precisa da resposta agora e ela precisa ser fortemente consistente.

Fila: ler é tirar. Log: ler é olhar, com um marcador por leitor.

Os três pedidos do gancho: carregador do warehouse (histórico), correção da busca (replay), fraude (ordem por pedido). Uma fila não faz nenhum deles.

Os três e-mails da Ana: crash entre o envio e o commit, duas vezes. O e-mail que faltou para o Bruno: crash entre o commit no banco e a publicação (lado do produtor) — resolvido pelo outbox.

O simulador está na página Semântica de entrega, em "Retries e dead letter queues" (retry-topics). Os mesmos números da dica dele.