Arquitetura de Sistemas · Insper · Capítulo 8

Hands-on 7 — Mensageria Assíncrona

Outbox, Kafka, consumidores idempotentes, um tópico de mensagens mortas (DLT, dead-letter topic) e uma sala de espera para o BoxOffice

A história até aqui

antes · lab 6o assento está seguro: um lock ou uma versão decide
→
capítulo 8 · lab 7outbox, Kafka, consumidor idempotente, sala de espera
→
depois · lab 8capítulo 9: traces, dashboard, um alerta

O checkout ainda espera pelo e-mail: quando o provedor cai, ninguém compra. E a multidão é 30× grande demais: ~33.000 reservas/s para as ~1.100 que um banco recebe.

  • A requisição do fã deveria terminar no commit; o resto pode esperar numa fila.

O fã deve esperar pelo e-mail?

order chama notification por HTTP antes de responder. Um provedor de e-mail real leva de dezenas a
centenas de milissegundos e às vezes falha. Às 10:00 o show no estádio abre as vendas. O que pode dar errado?

  • Todo pedido fica tão lento quanto o provedor de e-mail.
  • Uma queda do e-mail vira uma queda de pedidos.
  • 2 M de fãs atingem todos os serviços de uma vez, inclusive o mais lento.

Arquitetura

Antes
fã
→
gateway
→
order
POST, espera →
notificationSMTP, depois 201
→
201 para o fãdepois do e-mail
Depois
sala de espera
→
orderorders + outbox, 1 tx
→
201 para o fãno commit
relay do outbox
publica →
order-eventsKafka, 6 partições
grupo →
notificationdedup, Mailpit
falhas →
order-events-dlt

Passo 1 · Kafka no Compose (KRaft, Kafka Raft)

Contêiner Porta Papel
kafka (apache/kafka:4.3.1) 9094 (host) broker + controlador, sem ZooKeeper
kafka-init — cria order-events e order-events-dlt, 6 partições cada
kafka-ui 8089 tópicos, mensagens, headers, lag
mailpit 8025 / 1025 provedor de e-mail falso com caixa de entrada
  • Dois listeners: contêineres usam kafka:9092, sua máquina localhost:9094.
  • Criação automática desligada: o padrão de 1 partição limitaria os consumidores a 1.

Dois listeners: vale o endereço anunciado

order (contêiner)
bootstrap →
kafka:9092PLAINTEXT
metadados →
líderes em kafka:9092resolve na rede
CLI no seu notebook
bootstrap →
localhost:9094EXTERNAL
metadados →
líderes em localhost:9094resolve no notebook
um listener para os dois
→
o notebook recebe kafka:9092conecta e depois dá timeout
  • O primeiro endereço só encontra o broker; o cliente se reconecta ao endereço anunciado.
  • Por isso o Kafka é a exceção à regra "mesma porta dentro e fora".

Um log, não uma fila

  • Consumir não apaga: cada grupo guarda um offset por partição.
  • Lag = offset do fim do log − offset confirmado → o sinal de saúde do consumidor.
  • Mesma chave → mesma partição → ordem por chave (a única ordem que o Kafka promete).
  • Partições = teto do paralelismo de consumo de um grupo: 8 instâncias em 6 partições → 2 ociosas.
  • Grupos podem voltar (--reset-offsets) → reprocessamento → consumidores precisam tolerar duplicatas.

Passo 2 · O problema da escrita dupla

banco, depois Kafka
queda no meio →
pedido sem o seu eventonunca sai e-mail
Kafka, depois banco
INSERT falha →
um pedido fantasmae-mail de nada
Outbox: pedido + linha do evento, 1 tx local
queda em qualquer ponto →
as duas linhas ou nenhumaum relay publica depois
  • O PostgreSQL não desfaz o Kafka; o Kafka não desfaz o PostgreSQL.
  • O relay publica as linhas não publicadas e só as marca depois do acks=all.

O relay

SELECT id, aggregate_id, event_type, payload::text AS payload
FROM outbox WHERE published_at IS NULL
ORDER BY created_at LIMIT 100
FOR UPDATE SKIP LOCKED
  • A cada 200 ms: envia tudo, espera cada ack (10 s), depois UPDATE ... published_at.
  • Kafka fora → cada execução falha depois de max.block.ms (5 s) e é desfeita → nenhum evento perdido.
  • Queda depois do ack → lote republicado: at-least-once.
  • SKIP LOCKED → várias réplicas fazem relay de lotes disjuntos.

Alternativa: captura de mudanças (CDC, change data capture) — o Debezium lê o log de escrita antecipada (WAL, write-ahead log): menos atraso, mais infraestrutura.

API idempotente, também

INSERT INTO orders (...) VALUES (...)
ON CONFLICT (hold_id) DO NOTHING
  • Uma reserva → no máximo um pedido: hold_id é UNIQUE.
  • Um clique duplo ou uma retentativa do gateway recebe o mesmo pedido (200) e nenhum segundo evento.
  • Kafka parado, pedido feito: 201 mesmo assim; numa execução de teste ele foi publicado 71 s depois, quando o Kafka voltou.

Idempotência é uma decisão de projeto em cada salto: API, relay, consumidor.

Passo 3 · Consumidor idempotente

  1. Reivindicar: INSERT INTO processed_events (event_id) ... ON CONFLICT DO NOTHING
  2. 0 linhas → duplicata → pular.
  3. Efeito: enviar o e-mail.
  4. Commit — se o e-mail lançar exceção, a reivindicação é desfeita e a retentativa pode tentar de novo.

E-mail enviado, commit falha → um segundo e-mail na reentrega. Efeitos externos precisam da chave
de idempotência
do provedor (eventId).

Retentativas e o tópico de mensagens mortas

registro
→
e-mail enviado, ou duplicatacommit, próximo registro
registro
MailSendException →
tenta de novo no lugar0,5 s, 1 s, 2 s
continua falhando →
order-events-dltmesma partição, exceção nos headers
registro
IllegalArgumentException, JacksonException →
order-events-dlt na horanão retentável
  • Só a partição que falha espera, no máximo 0,5 + 1 + 2 = 3,5 s; as outras continuam andando.
  • Alternativa não bloqueante: @RetryableTopic (tópicos de retentativa) — sem bloqueio, mas sem ordem.

Passo 3 · Os experimentos

  • Mensagens do passeio: o grupo novo começa no offset mais antigo → 3 × IllegalArgumentException → DLT, sem bloquear os eventos reais.
  • Reprocessamento (--reset-offsets --to-earliest): duplicate event … ignored, o Mailpit continua com 2 e-mails.
  • NOTIFY_IDEMPOTENT=false: cada reprocessamento envia todos os e-mails de novo.
  • Pedido envenenado (poison@example.com): 201 para o fã, o registro em order-events-dlt e em dead_letters.

Uma DLT que ninguém lê é perda de dados silenciosa: alerte quando ela crescer, corrija a causa e reprocesse — seguro porque o consumidor é idempotente.

Passo 4 · Sala de espera

2 M de fãs apertam "Comprar" para 60 mil assentos; um inventário fortemente consistente não atende 2 M de requisições por segundo. Quem entra primeiro?

2 M de fãs
entram →
sorted set do Redisscore = sequência do INCR
ZPOPMIN N, a cada 1 s →
ticket admitidotempo de vida (TTL) 5 min
X-Admission-Ticket →
POST /orders403 sem ele
  • Estimativa honesta de espera (ETA, estimated time of arrival) pela Lei de Little: espera = posição / taxa → 30 000 / 500 = 60 s.

Armadilhas da sala de espera

  • Um admissor só: 3 réplicas × N/s = 3N/s. Worker único, eleição de líder ou trava.
  • Proteja tudo o que é caro (reservas e pedidos) — em produção, na borda/gateway.
  • A sala também precisa escalar: 2 M de fãs consultando a cada segundo = 2 M req/s → consulte menos, página pela rede de distribuição de conteúdo (CDN, content delivery network).
  • Robôs entram muitas vezes: limite as entradas, desafio antes de entrar (WAF, web application firewall).

Passo 5 · Meça

# Experimento O que registrar
A NOTIFY_MODE sync vs outbox p50 / p95 / p99 do POST /orders
B parar notification por 20 s taxa de erro, pico de lag, tempo de drenagem
C 100 pedidos/s, concorrência 1 vs 6 lag, drenagem, atraso p95 do e-mail
D reset de offsets, idempotência desligada vs ligada e-mails por pedido
E sala de espera, 20 fãs/s, admite 10/s admitidos/s, espera p95, erro do ETA, robôs recusados

k6 em modelo aberto (constant-arrival-rate); lag pelo kafka-consumer-groups.sh; atrasos por SQL.

O que uma execução de teste deu (A e B)

Carga Modo p50 p99 vazão
50/s por 60 s sync 58 ms 352 ms 50/s
50/s por 60 s outbox 3,3 ms 1,7 s 49/s
200/s por 30 s sync 2,7 s 9,3 s ❌ 113/s
200/s por 30 s outbox 1,8 ms 95 ms ✅ 200/s
  • sync segura uma das 10 conexões do pool por e-mail: no máximo 10 / 0,055 s ≈ 180 pedidos/s.
  • B em sync: pelo menos um terço dos pedidos falha (54 % numa execução de teste); em outbox, nenhum.

Preveja antes de rodar

Concorrência 1, 50 ms por e-mail, 100 pedidos/s por 60 s. Lag no fim? Tempo para drenar?

  • Capacidade: 1 / 50 ms = 20/s por thread.
  • O backlog cresce a 100 − 20 = 80/s → ≈ 4 800 mensagens.
  • Drena a 20/s → ≈ 240 s. Com 6 threads (120/s) → lag ≈ 0. Uma 7ª thread: ociosa (6 partições).
  • Uma execução de teste: cerca de 4 900 e 320 s — cada e-mail custa um pouco mais que 50 ms.

Sem Docker: o gêmeo do lab

2 · Outbox200 na repetição · Kafka fora: a linha espera · queda do relay: 1 evento duas vezes
3 · Consumidorpasseio → DLT · reprocessamento: 2 e-mails seguem 2 · dedup desligado: 4
5 · Medir (B, C)sync: 1.000 de 3.000 falham · 1 thread: lag 4.800, 240 s · 6 threads: ≤ 17
  • Os passos 2, 3 e 5 o embutem: mesmo tópico, partições, threads, backoff e latência de e-mail do lab.
  • Play roda uma página; os botões (POST, parar o Kafka, parar o Mailpit, reset de offsets) funcionam a qualquer momento.
  • No 5, mude NOTIFY_CONCURRENCY: 4 ou 5 threads drenam tão devagar quanto 3 — a thread 1 continua lendo duas partições.

Experimente no playground

  • event-fanout: um produtor, vários serviços consumidores, cada um com sua cópia; aumente as requisições por segundo até um consumidor atrasar.
  • async-queue com o perfil spike: o backlog absorve o pico enquanto os workers seguem em ritmo constante.

Forme uma hipótese no simulador e depois confira com o k6 nos seus próprios serviços.

O que quebra em seguida

lab 7 · o e-mail saiuoutbox: p50 de 1,8 ms contra 2,7 s síncrono, num teste
→
o preço: visibilidaderequisição, linha, relay, registro, consumidor: onde o pedido parou?
→
lab 8 · capítulo 9um trace por pedido, um dashboard, um alerta
  • Falhas que não produzem 5xx são invisíveis para o k6, ainda o único instrumento.

Pontos-chave

  1. Tire o trabalho lento e falível do caminho da requisição: a requisição do fã termina no commit.
  2. Outbox: pedido + evento em uma transação local; um relay publica at-least-once.
  3. O Kafka ordena por partição; use o id do agregado como chave; partições limitam o paralelismo.
  4. Consumidores idempotentes: reivindique o eventId na mesma transação do efeito.
  5. Classifique os erros: transitório → retentativa com backoff; permanente → DLT, depois corrija e reprocesse.
  6. Uma sala de espera transforma um pico em taxa constante com um ETA honesto (Lei de Little).

Capítulo 8 da história da disciplina. Roteiro: (1) por que o e-mail precisa sair do caminho da requisição; (2) Kafka em modo KRaft; (3) o problema da escrita dupla e o outbox; (4) consumidor idempotente, retentativas e DLT; (5) sala de espera; (6) o que medimos e o simulador que repete o lab.

A história da disciplina (visão geral de 2027.1, "A história da disciplina"): o capítulo 8 abre com o caminho de escrita síncrono e a multidão 30x maior. O lab 6 deixou o assento seguro (o naive vendeu duas vezes, 9 e 11 assentos em execuções daquele lab; pessimistic e optimistic sempre 0).

A página desenha as duas arquiteturas como diagramas passo a passo (abas "Antes" e "Depois").

O passeio da página: order-1 cai duas vezes na partição 4, order-2 na partição 3. Guarde as três mensagens do passeio: elas viram as mensagens envenenadas do passo 3.