Motor de Pagamentos: de Locks ao Write-Behind
Análise de concorrência em Spring Boot, Postgres e Redis sob 10k VUs no k6. O sistema evoluiu de locks síncronos (27 req/s) para Write-Behind (1.013 req/s).
Queria estudar um pouco sobre sistemas de pagamento — especificamente como lidar com concorrência, duplicidade de requisições e persistência sob carga real. Para isso, montei um microsserviço em Java 21 / Spring Boot 3.x, com PostgreSQL 18 para persistência e Redis 8.10 para controle de concorrência, e testei tudo com Grafana k6, aplicando picos de 10.000 usuários virtuais simultâneos (VUs) contra um único endpoint de pagamento. O que começou como um estudo pontual sobre locks e idempotência virou uma investigação de cinco ciclos, cada um revelando um gargalo diferente.
A arquitetura de partida
O ponto de partida era direto: o cliente envia
POST /api/v1/payments com um header X-Idempotency-Key . A aplicação usa esse valor para evitar processar a mesma operação duas vezes, e a persistência final acontece no PostgreSQL. A primeira versão fazia tudo de forma síncrona — validação, lock e escrita no banco dentro do mesmo ciclo de requisição.Ciclo 1: colapso sob 10.000 VUs
Sem nenhum ajuste prévio, o sistema não sustentou a carga:
- 84,12% de falhas HTTP (2.067 de 2.457 requisições)
- 27,29 req/s de vazão
- Latência p95 e máxima em torno de 1 minuto (timeout)
- 7.931 iterações interrompidas
A causa não era um bug isolado, mas um efeito cascata: as threads HTTP do Tomcat ficavam ocupadas esperando o banco, o pool do HikariCP saturava, e um lock pessimista segurava transações concorrentes na mesma chave:
@Lock(LockModeType.PESSIMISTIC_WRITE)@Query("SELECT p FROM Payment p WHERE p.idempotencyKey = :idempotencyKey")Optional<Payment> findByIdempotencyKeyForUpdate(String idempotencyKey);Ciclo 2: tunagem de threads e conexões
Ajustar o pool de threads do Tomcat e o HikariCP (mais threads, mais conexões, timeout de conexão mais curto) elevou a vazão para 133,56 req/s — um crescimento de 389% — e reduziu as falhas para 64,10%. Ainda assim, o resultado deixou uma lição clara: aumentar a capacidade da aplicação não resolveu o problema, apenas deslocou o gargalo para a camada seguinte, o PostgreSQL, onde o mesmo lock pessimista (
SELECT ... FOR UPDATE ) passou a ser disputado por um volume maior de transações simultâneas.Ciclo 3: Redis como escudo de idempotência
A ideia seguinte foi interceptar duplicidade antes que ela chegasse ao banco, usando uma operação atômica em memória:
Boolean isSaved = redisTemplate.opsForValue() .setIfAbsent("idempotency:" + key, "PROCESSING", Duration.ofHours(24));O resultado, porém, ficou praticamente estagnado: 137,18 req/s (variação de ~2,7% sobre o ciclo anterior) e falhas subindo levemente para 65,27%. O diagnóstico apontou para o driver Lettuce, usado pelo Spring Data Redis, que estava sem pool de conexões configurado — sob 10.000 VUs concorrentes, a contenção simplesmente migrou para a comunicação com o próprio Redis.
Ciclo 4: o pool resolvido, e um gargalo inesperado
Adicionar
commons-pool2 e configurar o pool do Lettuce eliminou a contenção na camada Redis:spring: data: redis: lettuce: pool: max-active: 100 max-idle: 50 min-idle: 20 max-wait: 2000msAinda assim, a falha continuou em 61,76%, com latência travada perto de 43 segundos. A explicação veio da própria natureza do cenário de teste: o k6 gerava 10.000 chaves de idempotência únicas por VU. Como nenhuma chave se repetia, o Redis aceitava quase todas as requisições — e todas chegavam ao PostgreSQL ao mesmo tempo como inserts concorrentes. Na prática, o Redis protegia contra duplicidade, mas não controlava o volume de escrita legítima.
Nesse ponto, o plano original era mudar o cenário de carga do k6 — usar poucas chaves compartilhadas para forçar colisões e isolar o comportamento do Redis como mecanismo de rejeição. Ao investigar o porquê da estagnação, no entanto, ficou claro que o problema não era do teste, e sim da arquitetura: o Redis por si só não reduz a pressão sobre o banco quando cada operação é legítima e inédita. Decidi então mudar de rota — em vez de ajustar o cenário de teste, redesenhar a arquitetura para tirar o PostgreSQL do caminho síncrono da requisição.
Ciclo 5: Write-Behind — persistência assíncrona
A mudança foi desacoplar o recebimento da requisição da sua persistência física. O Redis passou a acumular duas funções: validar a chave de idempotência e publicar o evento aceito em uma fila (
payment-processing-queue ). A API responde 201 PROCESSING imediatamente, e um PaymentQueueConsumer em background processa a gravação no PostgreSQL em ritmo controlado, com rollback atômico em caso de falha.Os resultados, sob a mesma carga de 10.000 VUs:
- 1.013,34 req/s de vazão (+638,7% sobre o ciclo 3)
- 3,65% de falhas HTTP (antes, 65,27%)
- 434,05 ms de latência mediana (antes, 17 s)
- 15,77 s de latência máxima (antes, ~44 s)
- 91.111 requisições processadas no total
Evolução completa
Métrica | Ciclo 1 | Ciclo 2 | Ciclo 3 | Ciclo 5 |
|---|---|---|---|---|
Vazão | 27,29 req/s | 133,56 req/s | 137,18 req/s | 1.013,34 req/s |
Falhas HTTP | 84,12% | 64,10% | 65,27% | 3,65% |
Latência mediana | Timeout | 17,16 s | 17,00 s | 434,05 ms |
Considerações finais
O maior ganho do estudo não veio de um ajuste isolado de infraestrutura, mas da mudança estrutural: tirar o PostgreSQL do caminho síncrono da requisição HTTP. Threads, pools de conexão e locks pessimistas importam — e resolvê-los foi necessário para expor o próximo gargalo — mas o salto real de throughput só apareceu quando a persistência deixou de estar no caminho crítico da resposta.
Vale o alerta: os testes foram feitos em ambiente local (Docker, uma única máquina), então os números absolutos não devem ser extrapolados diretamente para produção ou para infraestrutura em nuvem. Os 3,65% de falhas residuais no ciclo 5 também ainda precisam de investigação — podem estar ligados a CPU, I/O de disco, ou ao próprio comportamento do cenário de carga do k6.
Os próximos passos
Estudar outras arquiteturas de concorrência para os gargalos de escrita e reescrever o motor em Golang para fazer um teste comparativo direto contra o Spring Boot. Também planejo avaliar testes com carga sustentada de longa duração, forçar colisões de chaves repetidas e analisar o comportamento de backpressure no escalonamento horizontal. Por fim, o foco será implementar melhorias corporativas como observabilidade distribuída e tolerância a falhas com Circuit Breaker.
Referências de Estudo
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article