Redis Caching Strategy 완벽 가이드: Node.js Backend 최적화

현대 웹 애플리케이션에서 성능 최적화는 필수 요소입니다. 특히 데이터베이스 조회 비용이 높거나 복잡한 연산이 필요한 경우, Redis를 활용한 캐싱 전략은 응답 속도를 획기적으로 개선할 수 있습니다. 이 글에서는 Node.js 백엔드 환경에서 Redis 캐싱 전략을 효과적으로 구현하는 방법을 실무 중심으로 알아보겠습니다.

Redis 캐싱 기본 개념과 아키텍처

Redis(Remote Dictionary Server)는 인메모리 데이터 구조 저장소로, 캐시, 메시지 브로커, 세션 저장소 등 다양한 용도로 활용됩니다. 백엔드 시스템에서 Redis를 캐시로 사용할 때의 기본 아키텍처는 다음과 같습니다:

Client → API Server → Redis Cache → Database
                  ↓
              Cache Hit/Miss

Node.js에서 Redis 클라이언트를 설정하는 기본 코드입니다:

const redis = require('redis');

class CacheManager {
  constructor() {
    this.client = redis.createClient({
      host: process.env.REDIS_HOST || 'localhost',
      port: process.env.REDIS_PORT || 6379,
      password: process.env.REDIS_PASSWORD,
      retry_strategy: (options) => {
        if (options.error && options.error.code === 'ECONNREFUSED') {
          return new Error('Redis server connection refused');
        }
        if (options.total_retry_time > 1000 * 60 * 60) {
          return new Error('Retry time exhausted');
        }
        return Math.min(options.attempt * 100, 3000);
      }
    });
  }

  async connect() {
    await this.client.connect();
    console.log('Redis connected successfully');
  }
}

Cache-Aside 패턴 구현

Cache-Aside는 가장 일반적인 캐싱 패턴입니다. 애플리케이션이 직접 캐시를 관리하며, 캐시 미스 시 데이터베이스에서 데이터를 조회하여 캐시에 저장합니다:

class UserService {
  constructor(cacheManager, database) {
    this.cache = cacheManager;
    this.db = database;
  }

  async getUserById(userId) {
    const cacheKey = `user:${userId}`;
    
    // 1. 캐시에서 조회 시도
    try {
      const cachedUser = await this.cache.client.get(cacheKey);
      if (cachedUser) {
        console.log('Cache hit for user:', userId);
        return JSON.parse(cachedUser);
      }
    } catch (error) {
      console.error('Cache read error:', error);
    }

    // 2. 캐시 미스 시 데이터베이스 조회
    console.log('Cache miss for user:', userId);
    const user = await this.db.findUserById(userId);
    
    if (user) {
      // 3. 조회된 데이터를 캐시에 저장
      try {
        await this.cache.client.setex(
          cacheKey, 
          3600, // 1시간 TTL
          JSON.stringify(user)
        );
      } catch (error) {
        console.error('Cache write error:', error);
      }
    }
    
    return user;
  }

  async updateUser(userId, updateData) {
    const user = await this.db.updateUser(userId, updateData);
    
    // 캐시 무효화
    const cacheKey = `user:${userId}`;
    try {
      await this.cache.client.del(cacheKey);
    } catch (error) {
      console.error('Cache invalidation error:', error);
    }
    
    return user;
  }
}

Write-Through와 Write-Behind 패턴

Write-Through 패턴은 데이터 쓰기 시 캐시와 데이터베이스를 동시에 업데이트합니다:

class WritethroughCache {
  async updateUserProfile(userId, profileData) {
    const cacheKey = `user:${userId}`;
    
    // 1. 데이터베이스 업데이트
    const updatedUser = await this.db.updateUser(userId, profileData);
    
    // 2. 캐시 동시 업데이트
    await this.cache.client.setex(
      cacheKey,
      3600,
      JSON.stringify(updatedUser)
    );
    
    return updatedUser;
  }
}

Write-Behind(Write-Back) 패턴은 캐시를 먼저 업데이트하고, 비동기적으로 데이터베이스를 업데이트합니다:

class WriteBehindCache {
  constructor() {
    this.writeQueue = [];
    this.processQueue();
  }

  async updateUserProfile(userId, profileData) {
    const cacheKey = `user:${userId}`;
    
    // 1. 캐시 즉시 업데이트
    await this.cache.client.setex(
      cacheKey,
      3600,
      JSON.stringify(profileData)
    );
    
    // 2. 데이터베이스 업데이트를 큐에 추가
    this.writeQueue.push({
      type: 'update',
      userId,
      data: profileData,
      timestamp: Date.now()
    });
    
    return profileData;
  }

  async processQueue() {
    setInterval(async () => {
      if (this.writeQueue.length === 0) return;
      
      const batch = this.writeQueue.splice(0, 10); // 배치 처리
      
      for (const operation of batch) {
        try {
          await this.db.updateUser(operation.userId, operation.data);
        } catch (error) {
          console.error('Write-behind error:', error);
          // 실패한 작업을 다시 큐에 추가하거나 별도 처리
        }
      }
    }, 5000); // 5초마다 처리
  }
}

캐시 무효화 전략

효과적인 캐시 무효화는 데이터 일관성을 보장하는 핵심 요소입니다:

class CacheInvalidationService {
  constructor(cache) {
    this.cache = cache;
  }

  // 태그 기반 무효화
  async invalidateByTags(tags) {
    const pipeline = this.cache.client.pipeline();
    
    for (const tag of tags) {
      const keys = await this.cache.client.smembers(`tag:${tag}`);
      for (const key of keys) {
        pipeline.del(key);
      }
      pipeline.del(`tag:${tag}`);
    }
    
    await pipeline.exec();
  }

  // 패턴 기반 무효화
  async invalidateByPattern(pattern) {
    const keys = await this.cache.client.keys(pattern);
    if (keys.length > 0) {
      await this.cache.client.del(keys);
    }
  }

  // 계층적 무효화
  async invalidateUserData(userId) {
    const patterns = [
      `user:${userId}`,
      `user:${userId}:*`,
      `posts:user:${userId}`,
      `comments:user:${userId}`
    ];
    
    for (const pattern of patterns) {
      await this.invalidateByPattern(pattern);
    }
  }
}

캐시 워밍 전략

시스템 시작 시 또는 캐시 무효화 후 자주 조회되는 데이터를 미리 캐시에 로드하는 전략입니다:

class CacheWarmingService {
  constructor(cache, database) {
    this.cache = cache;
    this.db = database;
  }

  async warmPopularUsers() {
    console.log('Starting cache warming for popular users...');
    
    const popularUsers = await this.db.getPopularUsers(100);
    const pipeline = this.cache.client.pipeline();
    
    for (const user of popularUsers) {
      const cacheKey = `user:${user.id}`;
      pipeline.setex(cacheKey, 7200, JSON.stringify(user)); // 2시간 TTL
    }
    
    await pipeline.exec();
    console.log(`Warmed cache for ${popularUsers.length} users`);
  }

  async warmCategoryData() {
    const categories = await this.db.getAllCategories();
    await this.cache.client.setex(
      'categories:all',
      86400, // 24시간
      JSON.stringify(categories)
    );
  }

  // 스케줄링된 캐시 워밍
  startScheduledWarming() {
    // 매일 새벽 2시에 캐시 워밍 실행
    const schedule = require('node-cron');
    
    schedule.schedule('0 2 * * *', async () => {
      await this.warmPopularUsers();
      await this.warmCategoryData();
    });
  }
}

분산 캐시와 일관성 관리

여러 서버 인스턴스에서 Redis 캐시를 공유할 때의 일관성 관리 방법입니다:

class DistributedCacheManager {
  constructor() {
    this.cache = new CacheManager();
    this.pubsub = redis.createClient();
  }

  async setWithNotification(key, value, ttl = 3600) {
    // 캐시 설정
    await this.cache.client.setex(key, ttl, JSON.stringify(value));
    
    // 다른 인스턴스에 무효화 알림
    await this.pubsub.publish('cache:invalidate', JSON.stringify({
      action: 'set',
      key,
      timestamp: Date.now()
    }));
  }

  async deleteWithNotification(key) {
    await this.cache.client.del(key);
    
    await this.pubsub.publish('cache:invalidate', JSON.stringify({
      action: 'delete',
      key,
      timestamp: Date.now()
    }));
  }

  setupInvalidationListener() {
    this.pubsub.subscribe('cache:invalidate');
    
    this.pubsub.on('message', (channel, message) => {
      if (channel === 'cache:invalidate') {
        const data = JSON.parse(message);
        console.log(`Cache invalidation received: ${data.key}`);
        
        // 로컬 캐시가 있다면 무효화
        if (this.localCache) {
          this.localCache.del(data.key);
        }
      }
    });
  }
}

성능 모니터링과 최적화

Redis 캐시의 성능을 모니터링하고 최적화하는 방법입니다:

class CacheMetrics {
  constructor(cache) {
    this.cache = cache;
    this.metrics = {
      hits: 0,
      misses: 0,
      errors: 0
    };
  }

  async getWithMetrics(key) {
    try {
      const value = await this.cache.client.get(key);
      
      if (value) {
        this.metrics.hits++;
        return JSON.parse(value);
      } else {
        this.metrics.misses++;
        return null;
      }
    } catch (error) {
      this.metrics.errors++;
      throw error;
    }
  }

  getHitRatio() {
    const total = this.metrics.hits + this.metrics.misses;
    return total > 0 ? (this.metrics.hits / total) * 100 : 0;
  }

  async getRedisInfo() {
    const info = await this.cache.client.info('memory');
    return {
      usedMemory: this.parseInfo(info, 'used_memory_human'),
      maxMemory: this.parseInfo(info, 'maxmemory_human'),
      evictedKeys: this.parseInfo(info, 'evicted_keys')
    };
  }

  parseInfo(info, key) {
    const lines = info.split('\r\n');
    const line = lines.find(l => l.startsWith(key));
    return line ? line.split(':')[1] : null;
  }
}

마무리

Redis를 활용한 캐싱 전략은 백엔드 시스템의 성능을 크게 향상시킬 수 있는 강력한 도구입니다. Cache-Aside, Write-Through, Write-Behind 등 다양한 패턴을 상황에 맞게 적용하고, 적절한 무효화 전략과 모니터링을 통해 데이터 일관성과 성능을 동시에 확보할 수 있습니다. 실제 운영 환경에서는 캐시 히트율, 메모리 사용량, 응답 시간 등을 지속적으로 모니터링하여 최적의 캐싱 전략을 유지하는 것이 중요합니다.