블로그

한 건씩 보내던 Redis 적재를 파이프라이닝으로 바꿔 부하 테스트 기준 4배 단축

RedisTemplate의 opsForZSet().add()로 Redis 명령을 한 건씩 보내며 명령마다 왕복(RTT)이 누적되는 문제를 확인하고, Lettuce 비동기 API로 묶어 보내 100만 건 처리 시간을 240초에서 60초로(부하 테스트 기준) 줄인 경험을 공유합니다.

RedisLettuceSpringPerformanceGmarket

문제 발견

Gmarket 랭킹 시스템을 Spring Webflux + MongoDB 기반으로 재설계하는 과정에서, 100만 건의 랭킹 데이터를 Redis에 배치 업데이트하는 작업이 예상보다 훨씬 느리다는 것을 발견했습니다.

측정 결과 (부하 테스트 기준):

  • 100만 건 처리 시간: 240초 (4분)
  • 예상 처리 시간: 약 60초 이내

원인 분석

원인: 한 건씩 동기 호출

100만 건을 단계별로 나눠 재 보니 Redis Sorted Set에 적재하는 구간이 가장 오래 걸렸습니다. 그래서 서버 증설보다 앱이 Redis를 부르는 방식을 먼저 봤습니다.

원인은 RedisTemplate을 부르는 방식에 있었습니다. opsForZSet().add()로 한 건씩 호출하고 있었습니다. Spring Data Redis의 Lettuce 연결은 기본적으로 네이티브 커넥션을 공유하므로 명령마다 TCP 연결을 새로 맺지는 않습니다. 문제는 명령을 하나씩 보내고 응답을 기다리면서 명령마다 왕복(RTT)이 누적된다는 점이었습니다.

// 이 코드가 100만 번 실행되면?
redisTemplate.opsForZSet().add(key, member, score);
// → 명령 전송 → 응답 대기 (왕복 1회) → 다음 명령
// → 왕복 대기가 100만 번 누적

100만 건에 대해 매번 왕복을 기다리니, Redis가 실제로 일하는 시간보다 네트워크를 오가며 기다리는 시간이 더 커졌습니다.

해결: Lettuce 비동기 API로 묶어 보내기

문제는 RedisTemplate 자체가 아니라 호출 방식이었습니다. RedisTemplate에도 executePipelined가 있어 묶어 보낼 수 있지만, 결과를 한 리스트로 모두 모아 돌려주기 때문에 대량이면 메모리를 많이 씁니다. 그래서 묶음 크기를 직접 조절할 수 있는 Lettuce 비동기 API로 파이프라이닝했습니다.

구현

@Configuration
class RedisConfig {
    @Bean
    fun lettuceConnectionFactory(): LettuceConnectionFactory {
        val config = LettuceClientConfiguration.builder()
            .commandTimeout(Duration.ofSeconds(30))
            .build()
        return LettuceConnectionFactory(redisStandaloneConfig, config)
    }
}

@Component
class RankingRedisRepository(
    private val connectionFactory: LettuceConnectionFactory
) {
    fun batchZadd(key: String, entries: List<Pair<Double, String>>, chunk: Int = 1000) {
        // 전용 커넥션: 서비스 요청이 쓰는 공유 커넥션과 분리
        (connectionFactory.nativeClient as RedisClient).connect().use { conn ->
            val commands = conn.async()
            commands.setAutoFlushCommands(false) // 버퍼에 모았다가 flush 때 한 번에 쓰기

            entries.chunked(chunk).forEach { batch ->
                val futures = batch.map { (score, member) -> commands.zadd(key, score, member) }
                commands.flushCommands() // 묶음 한 번에 전송
                LettuceFutures.awaitAll(30, TimeUnit.SECONDS, *futures.toTypedArray())
            }
        }
    }
}

핵심: 파이프라이닝

핵심은 응답을 기다리지 않고 다음 명령을 보내는 것입니다. Lettuce 비동기 API는 명령을 보내면 결과 대신 Future를 바로 돌려줘서 이미 이렇게 동작하고, setAutoFlushCommands(false)를 쓰면 명령을 버퍼에 모았다가 flushCommands()에서 한 번에 써서 소켓 쓰기 횟수까지 줄어듭니다.

[한 건씩 동기 호출: 명령마다 기다림]
Client → ZADD 1 → Redis
       ← OK
Client → ZADD 2 → Redis
       ← OK
...  왕복 대기 100만 번

[파이프라이닝: 묶음마다 한 번 기다림]
Client → ZADD 1 … ZADD 1000 (묶음 1) → Redis
       ← OK × 1000 (보낸 순서대로)
Client → ZADD 1001 … ZADD 2000 (묶음 2) → Redis
       ← OK × 1000
...  왕복 대기: 100만 번 → 묶음 수만큼

Redis가 하는 일의 양은 같고, 기다리는 횟수만 묶음 수만큼으로 줄어듭니다.

결과

항목 한 건씩 동기 호출 묶음 단위 파이프라이닝
100만 건 처리 시간 (부하 테스트 기준) 240초 60초
성능 개선 - 4배 향상

정리

대량 처리에서는 도구를 바꾸기 전에 **"명령마다 응답을 기다리고 있는가"**부터 봅니다.

  • 수십만 건 이상을 한 건씩 보내고 있다면 묶어 보내기부터 (executePipelined 또는 Lettuce 비동기 API)
  • 묶음이 크면 앱과 Redis 양쪽 버퍼에 메모리가 쌓이니 적당한 크기로 나누기
  • autoFlush를 끌 때는 서비스 요청이 쓰는 공유 커넥션이 아니라 전용 커넥션에서

단건 조회와 수정에는 RedisTemplate이 그대로 편합니다.

이후 Redis는 랭킹 서빙 경로에서 빠졌습니다.