Previous slide Next slide Toggle fullscreen Toggle overview view Open presenter view
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 ;
emails.schedule(event);
}
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
Chame quando precisa da resposta; envie mensagem quando o trabalho pode acontecer depois.
Uma fila transforma um pico em backlog : dimensione workers com a Lei de Little e um objetivo de atraso.
Toda fila precisa de backpressure e de um alerta sobre a idade da mensagem mais antiga.
Kafka: chave = ordem + balanceamento; partições = paralelismo máximo; RF 3, acks=all, min ISR 2.
A entrega é at-least-once : consumidores idempotentes, DLQ, schemas compatíveis.
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.