Arquitetura de Sistemas · Insper · Lab 6 · Capítulo 6

Lab 6 — Dados em escala

Reservas de assento sem venda duplicada, uma réplica de leitura, PgBouncer, EXPLAIN — e um failover à mão

A história até aqui

antes · lab 5o Redis responde as páginas de evento
→
capítulo 6 · lab 6inventory: reservas, locks, réplica, failover
→
depois · lab 7capítulo 8: order, outbox, sala de espera

Os serviços stateless empurram toda reserva para o banco. Às 10:00 chegam ~33.000 reservas/s para as ~1.100 que um PostgreSQL atende — e dois fãs clicam no mesmo assento no mesmo milissegundo.

  • Feito depois do capítulo 7: um assento, ao contrário de uma página de evento, nunca vem de uma cópia.

O único bug que não podemos entregar

Dois fãs clicam nos mesmos dois assentos no mesmo milissegundo. Os dois recebem "201 Created". Quem vai ao show?

  • Invariante: um assento pertence a no máximo uma reserva viva.
  • O catálogo pode ficar segundos defasado; os assentos nunca podem estar errados.

O que você vai construir

fãs do k6edge → gateway
→
inventory :8083assentos, reservas, 3 estratégias de lock
escritas, reservas · transações read-write
pgbouncer :6432pooling por transação
db · primário
log de escrita antecipada (WAL, write-ahead log) →
mapas de assentos · transações readOnly
db-replica :5433hot standby
  • Evento 1: 60.000 assentos (30 setores × 40 fileiras × 50); uma reserva dura 10 minutos, no máximo 6 assentos.
  • O catálogo ganha seus índices (V3__index_events.sql); o passo 4 derruba o db de propósito.

A corrida (READ COMMITTED)

A: SELECT status → AVAILABLE
B: SELECT status → AVAILABLE
A: UPDATE … hold_id = A        (locks the rows)
B: UPDATE … hold_id = B        (waits…)
A: COMMIT  →  B's UPDATE runs  →  overwrites A
  • Check-then-act sem lock = lost update.
  • Com FOR UPDATE, B espera já na leitura, depois relê HELD → 409.

Três estratégias

Estratégia Mecanismo Em conflito
naive lê, confere, atualiza ❌ venda duplicada
pessimistic SELECT … ORDER BY id FOR UPDATE ✅ espera, depois 409
optimistic UPDATE … WHERE version = :v ✅ 0 linhas → 409, rollback

Variante: UPDATE … WHERE status = 'AVAILABLE' e conferir a contagem de linhas.

O teste da venda relâmpago

INVENTORY_LOCKING=naive docker compose up -d inventory
bash scripts/reset-inventory.sh && k6 run load/flash-sale.js
naive162 reservas · auditoria: 9 assentos vendidos em dobro
pessimistic141 reservas · auditoria 0 · p99 1,77 s
optimistic141 reservas · auditoria 0 · p99 1,03 s
  • 200 fãs, 100 assentos, 2 assentos por reserva, 70% liberam; teardown: GET /inventory/audit/double-bookings.
  • Uma execução num laptop ocupado: as contagens variam, o formato não (a naive nunca dá 0 com confiança).

Pessimista ou otimista?

Pessimista

  • serializa as linhas disputadas
  • espera → p99 maior
  • trave em ordem de id (sem deadlocks)

Otimista

  • sem espera
  • conflitos → falha rápido
  • ótimo com contenção baixa

De qualquer forma, proteja as linhas quentes antes do banco: uma sala de espera (lab 7).

Reservas expiram

WITH expired AS (
  UPDATE inventory.holds SET status = 'EXPIRED'
  WHERE id IN (SELECT id FROM inventory.holds
               WHERE status = 'ACTIVE' AND expires_at < now()
               LIMIT 500 FOR UPDATE SKIP LOCKED)
  RETURNING id)
UPDATE inventory.seats SET status = 'AVAILABLE', hold_id = NULL
WHERE hold_id IN (SELECT id FROM expired);
  • SKIP LOCKED: várias réplicas dividem o job com segurança.

Uma réplica por streaming

  • pg_basebackup -R: clone + standby.signal.
  • O WAL é enviado de forma assíncrona; a réplica é somente leitura.
  • @Transactional(readOnly = true) → pool da réplica, via LazyConnectionDataSourceProxy.
  • O find (a reserva do próprio fã) e a auditoria ficam no primário.

Uma réplica acrescenta capacidade de leitura. Ela não faz nada pelas escritas.

Read-your-writes

REPLICA_DELAY=1s docker compose up -d db-replica
k6 run load/read-your-writes.js      # stale_reads ↑
  • Sem atraso artificial: ~6% de leituras defasadas — a próxima requisição também chega em milissegundos.
  • REPLICA_DELAY=1s: 98% — o fã reserva um assento… e o mapa de assentos diz AVAILABLE.
  • Correção: as próprias escritas recentes pelo primário, leituras sticky, ou esperar o número de sequência do log (LSN, log sequence number).

PgBouncer

clientes
catalog ×33 × 10 conexões
auth10 conexões
inventoryo pool inteiro
inventory →
pgbouncermodo transaction · ≤ 20 conexões de servidor
→
db~60 conexões numa execução de teste
  • max_connections=80, pool do inventory de 40, direto → FATAL: sorry, too many clients already; pelo PgBouncer → fila (cl_waiting).
  • O pooling por transação quebra o estado de sessão → o Flyway conecta direto.

EXPLAIN antes do cache

antes
Limit 20
←
Sortstarts_at, id
←
Seq Scan em events200.000 linhas
36,8 ms+ 13,9 ms do count(*)
depois
Limit 20
←
Nested Loop
←
Index Scan events_starts_at_idx189 entradas, em ordem de data
0,62 mscount(*): 4 ms, Index Only Scan
CREATE INDEX events_starts_at_idx ON catalog.events (starts_at, id);
  • Índices custam em toda escrita; indexe o que você mediu.

Replicação síncrona: quanto custa

synchronous_commit (réplica 1 s atrás) leituras defasadas por iteração
on: WAL no disco do standby ⚠️ 93–100% ~0,05–0,4 s
remote_apply: reaplicado no standby ✅ 0% ⚠️ 2 s
  • Réplica parada → a reserva recebe 504 depois de 5 s e mesmo assim o assento 10 está HELD: "already committed locally".
  • Um standby síncrono só = ponto único de falha para as escritas → ANY 1 sobre dois.

O primário morre com uma reserva no ar

réplica paradareserva da Ana → 201
→
kill db
→
sondasmapa 200 · reserva, login, catálogo 504
→
pg_promote()timeline 2
→
mover o nome dbum alias de rede do Docker
→
reserva da Ana: 404
  • 15 s depois da troca todos os caminhos voltam a responder: os pools reconectam, nenhum arquivo mudou, nenhum serviço reiniciou.
  • A reserva existia só no WAL do primário morto: o objetivo de ponto de recuperação (RPO, recovery point objective) da replicação assíncrona.
  • Um banco gerenciado faz o mesmo com o seu endpoint (Amazon RDS: um nome no sistema de nomes de domínio, DNS, Domain Name System), um IP virtual ou um proxy.

Split brain, e o caminho de volta

história comumtimeline 1
→
depois da bifurcação
db antigo, iniciado como estavaprimário · assento 20 HELD (a reserva perdida da Ana)
db-replicaprimário, timeline 2 · assento 20 AVAILABLE
→
isolar, depois pg_rewindexige wal_log_hints; db segue a timeline 2
  • Dois primários atrás de um nome: cada conexão nova cai em qualquer um deles.
  • Volta ao original: LSNs iguais, pare o db-replica, promova o db (timeline 3), clone uma réplica nova.

O que você fez à mão

Passo Neste lab Em produção
Detectar você o matou health checks com timeout
Escolher o novo primário a única réplica o standby mais atualizado, por consenso
Mover os clientes um alias de rede do Docker endpoint de DNS, IP virtual, proxy, strings multi-host
Isolar o antigo primário docker compose stop db expiração da chave de líder, STONITH ("shoot the other node in the head"), fencing tokens
Trazê-lo de volta pg_rewind + standby.signal o gerenciador de failover
Decidir o que pode se perder assíncrono: a última reserva ANY 1 (…) sobre dois standbys: RPO 0

Uma pessoa às 10:01 é lenta demais: Patroni + etcd decidem o líder por consenso.

Sem Docker: o simulador

RéplicaREPLICA_DELAY 1 s: o assento 1 ainda AVAILABLE no mapa
Síncronaremote_apply: 1,03 s · standby fora: 504, assento 10 HELD
Quedamapa 200, o resto 504 · reserva da Ana 404
Split braino pg_rewind descarta a reserva · timeline 3
  • As páginas de Réplica e de Failover trazem os dois bancos do lab: mesmos nomes, mesmos comandos, mesmas saídas.
  • Modo livre: start em vez de up --no-deps, ou pg_rewind sem wal_log_hints.

O que quebra em seguida

lab 6 · o assento está seguronaive vende duas vezes; pessimistic e optimistic: 0
→
ainda síncronoo checkout espera pagamento e e-mail · 30× mais fãs do que a capacidade
→
lab 7 · capítulo 8order, um outbox até o Kafka, uma sala de espera
  • Uma reserva ainda não é uma compra: nada nesta pilha a transforma em uma.

Pontos-chave

  1. Nomeie o invariante; garanta-o de forma atômica (locks, versões, updates condicionais).
  2. Audite a corretude sob carga, não só a latência.
  3. Réplicas escalam leituras que toleram defasagem; roteie o read-your-writes para o primário.
  4. Faça pool de conexões (PgBouncer) antes que o autoescalonamento as multiplique.
  5. EXPLAIN primeiro: um índice pode vencer um cache.
  6. Saiba o que um failover perde (RPO) e quem decide o líder; isole o antigo primário.

Capítulo 6 da história da disciplina, feito depois do capítulo 7. Roteiro: (1) o invariante; (2) a corrida do lost update; (3) três estratégias; (4) o teste da venda relâmpago e a auditoria; (5) réplica por streaming e roteamento; (6) read-your-writes; (7) PgBouncer; (8) índices; (9) replicação síncrona, uma queda, failover, split brain, pg_rewind; (10) o simulador.

A história da disciplina (visão geral de 2027.1, "A história da disciplina"): o capítulo 6 abre com os serviços stateless empurrando toda decisão para o banco. Os labs o fazem depois do cache do lab 5 (cerca de 70% de hits em um minuto de um cache frio, numa execução daquele lab).

O simulador fica depois do experimento read-your-writes, no topo de Failover (abrindo na queda) e no fim da seção 5 (split brain, volta do primário, switchback).