c. Réplica e Pool de Conexões
Durante a venda, para cada fã que reserva um assento, dezenas olham o mapa de assentos. Essas leituras não precisam do primário: uma réplica de leitura — uma cópia do banco mantida atualizada pelo streaming do write-ahead log (WAL) do primário — pode atendê-las. Dois custos vêm junto: a cópia fica um pouco atrasada (atraso de replicação) e agora você roteia consultas para dois lugares. Este passo também adiciona o PgBouncer, porque cada réplica de cada serviço abrindo o seu próprio pool de conexões é como o PostgreSQL fica sem conexões.
1. Replicação por streaming
sequenceDiagram
autonumber
participant I as inventory
participant P as db (primário)
participant R as db-replica (hot standby)
Note over R: primeira inicialização: o pg_basebackup copia o primário
I->>P: BEGIN; UPDATE seats ...; COMMIT
P->>P: grava o registro no WAL, flush
P-->>I: COMMIT ok (replicação assíncrona: não espera R)
P->>R: streaming do WAL
R->>R: reaplica (depois de recovery_min_apply_delay)
I->>R: SELECT da disponibilidade (tx readOnly)
R-->>I: resultado, possivelmente alguns ms defasado O primário precisa de um usuário com permissão para replicar. Este script roda uma vez, quando o volume do primário é criado:
A réplica clona o primário na sua primeira inicialização e depois o acompanha:
Recrie o volume do banco
O 10-replication.sh só roda num diretório de dados vazio. O seu volume db-data existe desde o lab 1, então recrie-o (o Flyway popula tudo de novo na inicialização): docker compose down -v antes do primeiro up deste lab. Lembre-se de chmod +x infra/postgres/*.sh.
2. PgBouncer
Cada conexão do PostgreSQL é um processo do sistema operacional com a sua própria memória; algumas centenas vão bem, milhares não. Conte os clientes: 3 réplicas do catalog × 10 + auth × 10 + inventory × 20 × 2 pools… e no lab 10 o Kubernetes vai escalar réplicas automaticamente. O PgBouncer aceita muitas conexões de cliente baratas e as multiplexa sobre um pool pequeno de conexões reais.
flowchart LR
cat["catalog ×3<br/>3 × 10 conexões"] --> db[("db<br/>um processo por conexão")]
auth["auth<br/>10 conexões"] --> db
inv["inventory<br/>até 1.000 conexões de cliente"] --> pgb["pgbouncer :6432<br/>pooling por transação"]:::comp
pgb -->|"no máximo 20 conexões de servidor"| db
fly["migrações do Flyway"] -->|"direto: locks de sessão"| db | Modo de pool | Uma conexão de servidor é emprestada por… | Quebra |
|---|---|---|
session | toda a conexão do cliente | ✅ nada, mas economiza pouco |
transaction | uma transação | ⚠️ estado de sessão: SET, advisory locks de sessão, LISTEN, tabelas temporárias |
statement | um comando | ❌ transações com vários comandos |
O pooling por transação é o que torna o PgBouncer eficaz — e é por isso que o Flyway não passa por ele: as migrações usam locks de nível de sessão. Por isso o inventory tem dois hosts: DB_HOST=pgbouncer para a aplicação e DB_MIGRATION_HOST=db para o Flyway.
3. Compose
| compose.yaml | |
|---|---|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 | |
chmod +x infra/postgres/*.sh
docker compose down -v
docker compose up --build -d
docker compose exec db psql -U boxoffice -c "SELECT client_addr, state, sent_lsn, replay_lsn FROM pg_stat_replication"
docker compose exec db-replica psql -U boxoffice -c "SELECT pg_is_in_recovery(), now() - pg_last_xact_replay_timestamp() AS lag"
A coluna lag é o tempo desde que a réplica reaplicou a última transação: enquanto o primário está ocioso, ela continua crescendo, mesmo com a réplica totalmente em dia. Compare sent_lsn e replay_lsn no primário para ver a distância real.
-------------+-----------
172.22.0.4 | streamingdocker compose exec db-replica psql -U boxoffice -c "INSERT INTO inventory.holds VALUES (gen_random_uuid(), 1, 'x', 'ACTIVE', now(), now())"ERROR: cannot execute INSERT in a read-only transaction
4. Roteando leituras para a réplica
flowchart LR
tx["um método @Transactional começa"] --> lazy["LazyConnectionDataSourceProxy<br/>entrega um substituto"]
lazy --> first["o primeiro comando SQL"]
first --> q{"readOnly = true?"}
q -->|"sim: availability, seats"| rp[("pool da réplica<br/>db-replica")]
q -->|"não: hold, confirm, release, find, audit"| pp[("pool do primário<br/>pgbouncer → db")] O LazyConnectionDataSourceProxy entrega uma conexão provisória quando uma transação começa e busca a real no primeiro comando — a essa altura o Spring já sabe se a transação é readOnly e escolhe o pool. A regra vira uma anotação:
| Método | Anotação | Vai para | Por quê |
|---|---|---|---|
SeatQueries.availability, seats | @Transactional(readOnly = true) | réplica | navegação; alguns ms de defasagem não fazem mal |
HoldService.hold, confirm, release | @Transactional | primário | escritas |
HoldService.find | @Transactional | primário | read-your-writes: o fã acabou de criar esta reserva |
SeatQueries.doubleBookedSeats | @Transactional | primário | uma auditoria não pode estar defasada |
Os dois pools publicam métricas (hikaricp.connections.active{pool=primary|replica}): confira-as enquanto um teste roda, curl -s 'localhost:8083/actuator/metrics/hikaricp.connections.active?tag=pool:replica' | jq.
5. Experimentos
Alívio pela réplica. Rode a carga de leitura contra a réplica, depois aponte o pool "replica" para o primário e rode de novo — sem mudar código:
k6 run -q -e RATE=200 -e DURATION=30s load/availability.js > /dev/null # warm-up: the seat-map queries are still cold
k6 run -e RATE=200 load/availability.js # reads on db-replica
DB_REPLICA_HOST=db docker compose up -d --wait inventory # --wait: until the recreated inventory is healthy
k6 run -q -e RATE=200 -e DURATION=30s load/availability.js > /dev/null # warm-up: a new JVM
k6 run -e RATE=200 load/availability.js # reads on the primary
docker compose up -d --wait inventory # back to the replica
Deixe o docker stats aberto: a CPU passa do db para o db-replica. A latência do mapa de assentos quase não muda — uma réplica não deixa uma consulta mais rápida, ela acrescenta capacidade e impede que as leituras disputem recursos com as escritas da venda.
Read-your-writes. Um fã reserva um assento e recarrega na hora o mapa de assentos, atendido pela réplica:
bash scripts/reset-inventory.sh && k6 run load/read-your-writes.js # lag ~ milliseconds
REPLICA_DELAY=1s docker compose up -d db-replica && sleep 10
bash scripts/reset-inventory.sh && k6 run load/read-your-writes.js # lag of 1 second
REPLICA_DELAY=0 docker compose up -d db-replica
Mesmo sem atraso artificial, stale_reads não é zero: numa execução de teste deste lab, ficou em cerca de 6% — a réplica na mesma máquina está só milissegundos atrás, mas a próxima requisição do fã também chega em milissegundos. Com REPLICA_DELAY=1s, ficou em 98%: quase nenhum fã viu a própria reserva no mapa de assentos, embora o GET /inventory/holds/{id} (primário) a mostre. Em produção, o atraso cresce com o volume de escritas, a distância de rede e consultas longas na réplica — exatamente durante uma venda relâmpago.
Saídas: ler as suas próprias escritas recentes do primário (o que o find faz), rotear um usuário para o primário por alguns segundos depois de ele escrever (leituras "sticky"), ou esperar até a réplica ter reaplicado o LSN (log sequence number) da escrita.
Experimente
Sem Docker à mão, ou quer ver o atraso entre dois comandos? Aqui o simulador abre no experimento read-your-writes. O simulador parte da stack do passo 2: db primário, db-replica recebendo o WAL de forma assíncrona, todos os assentos à venda; play ou → roda os comandos do lab e os botões funcionam a qualquer momento. Em Réplica, com REPLICA_DELAY=1s, a reserva da Ana responde 201, mas o mapa lido logo depois ainda mostra o assento 1 AVAILABLE; 1 s depois ele está HELD. Em Síncrona, remote_apply faz a reserva levar 1,03 s e a leitura vir atualizada; com db-replica parado, a reserva do assento 10 recebe 504 depois de 5 s e mesmo assim o assento 10 está HELD. Em Queda, as sondas dão 200 para o mapa e 504 para o resto; depois de pg_promote() e do nome movido, 15 s depois todos os caminhos respondem e a reserva da Ana é 404. Em Split brain, dois primários discordam sobre o assento 20, o pg_rewind descarta a reserva da Ana e o switchback termina na timeline 3. No modo livre, tente o que o lab avisa: start em vez de up --no-deps, ou pg_rewind sem wal_log_hints.
PgBouncer. Conte as conexões durante a venda relâmpago, com e sem o pooler:
# during load/flash-sale.js:
docker compose exec db psql -U boxoffice -c "SELECT usename, application_name, count(*) FROM pg_stat_activity GROUP BY 1, 2"
docker compose exec -e PGPASSWORD=boxoffice db psql -h pgbouncer -p 6432 -U boxoffice pgbouncer -c "SHOW POOLS"
# without PgBouncer:
INVENTORY_DB_HOST=db INVENTORY_DB_PORT=5432 docker compose up -d inventory
Numa execução de teste deste lab, o pg_stat_activity mostrou cerca de 60 conexões da aplicação: 30 das três réplicas do catalog, 10 do auth e 20 do PgBouncer — que atendeu todas as conexões de cliente do inventory. O SHOW POOLS mostrou cl_active 20 contra sv_active + sv_idle + sv_used ≤ 20.
Force a barra: reinicie com DB_MAX_CONNECTIONS=80 INVENTORY_POOL_SIZE=40 docker compose up -d. Pelo PgBouncer tudo funciona (o PostgreSQL continua vendo no máximo 20 conexões vindas dele). Direto contra o db (acrescente INVENTORY_DB_HOST=db INVENTORY_DB_PORT=5432 a esse mesmo comando), 30 + 10 + 40 conexões, mais as ociosas que o PgBouncer ainda mantém abertas, passam de 80 (boxoffice é superusuário, então os slots reservados ao superusuário não ajudam): o PostgreSQL recusa toda conexão nova com FATAL: sorry, too many clients already (docker compose logs db). O pool do inventory para de crescer antes de 40 (31 numa execução de teste deste lab) e todo outro cliente novo também é recusado — inclusive o psql e o scripts/reset-inventory.sh. Um pooler transforma "clientes demais" em fila (cl_waiting). Depois, volte ao padrão: docker compose up -d --wait.
Na entrevista
"Adicionar réplicas de leitura" só é resposta para carga com muita leitura que tolera defasagem. Diga quais leituras vão para as réplicas, como você trata o read-your-writes e o que acontece com as escritas — as réplicas não fazem nada por elas; isso exige particionamento (aula 6) ou menos trabalho por escrita.
Próximo: 3. Índices e EXPLAIN.