AWS Builder Center

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: 2000ms
Ainda 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

Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article