조회수 API의 DB 병목을 Redis로 해결하기

배경

UPDATE posts SET view_count = view_count + 1 WHERE id = ?

가설 검증

문제 원인

문제 해결

후보 1. 인메모리

• 서버가 여러 대로 확장될 경우 인스턴스 간 데이터 공유가 어렵다.

• 조회수 증가 연산에서 동시성 문제가 발생할 수 있다.

• NestJS 서버 재시작 시 데이터가 유실된다.

• TTL과 같은 만료 정책을 직접 구현해야 하므로, 중복 조회 방지 로직 관리가 복잡해진다.

후보 2. Redis

• 네트워크 기반 인메모리 저장소로 여러 서버 인스턴스 간 데이터 공유가 가능하다.

• INCR 연산을 통해 조회수를 원자적으로 증가시킬 수 있어 동시성 문제를 효과적으로 처리할 수 있다.

• NestJS 서버 재시작 시 Redis는 데이터가 유실되지 않는다.

• TTL 기능을 제공해준다.

설계

조회수 증가분 누적

조회수 증가분 DB에 반영 (배치 처리)

구현

Redis 명령어 정리

• INCR : 해당 key의 값을 1 증가시키는 명령어로, 조회수 증가 시 사용

• GET : 배치 작업에서 누적된 조회수 값을 가져오기 위해 사용

• DEL : DB 반영 이후 Redis에 저장된 값을 초기화하기 위해 사용

• SADD : 변경이 발생한 게시글 ID를 Set에 저장하여, 이후 배치 처리 대상에 포함시키기 위해 사용

• SMEMBERS : Set에 저장된 게시글 ID 목록을 조회하여, 실제로 변경된 데이터만 처리하기 위해 사용

의존성 설치

npm install ioredis @nestjs/schedule

Redis 설정

// redis.provider.ts
import Redis from 'ioredis';
import { ConfigService } from '@nestjs/config';

export const REDIS = Symbol('REDIS');

export const redisProvider = {
  provide: REDIS,
  inject: [ConfigService],
  useFactory: (config: ConfigService) => {
    return new Redis({
      host: config.getOrThrow('REDIS_HOST'),
      port: Number(config.getOrThrow('REDIS_PORT')),
      password: config.get('REDIS_PASSWORD') || undefined,
    });
  },
};

// redis.module.ts
import { Module } from '@nestjs/common';
import { redisProvider } from './redis.provider';

@Module({
  providers: [redisProvider],
  exports: [redisProvider],
})
export class RedisModule {}

constructor(@Inject(REDIS) private readonly redis: Redis) {}

조회수 증가분 누적

// view-count.service.ts
import { Injectable } from '@nestjs/common';
import { RedisService } from './redis.service';

@Injectable()
export class ViewCountService {
  constructor(private readonly redisService: RedisService) {}

  async incrementViewCount(resourceId: number) {
    const countKey = `view:count:${resourceId}`;
    const dirtyKey = `view:dirty`;

    await this.redisService.client
      .pipeline()
      .incr(countKey)
      .sadd(dirtyKey, String(resourceId))
      .exec();
  }
}

// post.service.ts
import { Injectable } from '@nestjs/common';
import { ViewCountService } from './view-count.service';

@Injectable()
export class PostService {
  constructor(
    private readonly viewCountService: ViewCountService,
  ) {}

  async incrementPostView(postId: number) {
    const post = await this.findPostById(postId);
    if (!post) { 
	    throw new NotFoundException();
    }
    
    this.viewCountService.incrementViewCount(postId);
  }
}

조회수 배치 반영 구현

// view-flush.service.ts
@Injectable()
export class ViewFlushService {
  constructor(
    @Inject(REDIS) private readonly redis: Redis,
    private readonly prisma: PrismaService,
  ) {}

  @Interval(5000) // 5초마다 실행
  async flush() {
    const dirtyKey = `view:dirty`;

    // 1. 변경된 게시글 ID 조회
    const ids = await this.redis.smembers(dirtyKey);
    if (ids.length === 0) return;

    // 2. Redis에서 조회수 증가분 조회 (pipeline)
    const pipeline = this.redis.pipeline();
    for (const id of ids) {
      pipeline.get(`view:count:${id}`);
    }
    const results = await pipeline.exec();

    const updates: { id: number; delta: number }[] = [];

    if (results) {
      for (let i = 0; i < ids.length; i++) {
        const [, raw] = results[i];
        if (!raw) continue;

        const delta = Number(raw);
        if (delta > 0) {
          updates.push({ id: Number(ids[i]), delta });
        }
      }
    }

    // 3. DB 반영
    await this.prisma.$transaction(
      updates.map(({ id, delta }) =>
        this.prisma.post.update({
          where: { id },
          data: { viewCount: { increment: delta } },
        }),
      ),
    );

    // 4. Redis 정리
    const delPipeline = this.redis.pipeline();
    for (const { id } of updates) {
      delPipeline.del(`view:count:${id}`);
    }
    await delPipeline.exec();

    await this.redis.srem(dirtyKey, ...ids);
  }
}

1. 변경된 게시글 ID 조회

const dirtyKey = `view:dirty`;
const ids = await this.redis.smembers(dirtyKey);

if (ids.length === 0) return;

2. Redis에서 조회수 증가분 조회

const pipeline = this.redis.pipeline();
for (const id of ids) {
  pipeline.get(`view:count:${id}`);
}
const results = await pipeline.exec();

3. DB 반영 (batch update)

await this.prisma.$transaction(
  updates.map(({ id, delta }) =>
    this.prisma.post.update({
      where: { id },
      data: { viewCount: { increment: delta } },
    }),
  ),
);

4. Redis 데이터 정리

const delPipeline = this.redis.pipeline();
for (const { id } of updates) {
  delPipeline.del(`view:count:${id}`);
}
await delPipeline.exec();

await this.redis.srem(dirtyKey, ...ids);

• 조회수 증가분 key 삭제 (DEL)

• dirty set에 처리된 ID 제거 (SREM)

전체 흐름 정리

1. 조회 요청 시 Redis에 조회수 증가분 누적 (INCR)

2. 변경된 ID를 dirty set에 기록 (SADD)

3. 배치 작업이 주기적으로 실행

4. dirty set 기반으로 변경된 데이터 조회

5. DB에 +N 형태로 반영

6. Redis 데이터 정리

결과

트레이드오프

1) 조회수가 바로 반영되지 않는다.

2) Redis 장애 시 데이터 유실 가능성이 있다.

3) Redis 메모리 사용량이 증가한다.

4) DB와 Redis는 하나의 트랜잭션으로 묶을 수 없다.