캐싱 전략: 다층 캐시 아키텍처와 Redis 고급 활용

사용자 요청
    │
    ▼
L0: CDN / Edge Cache          ← 글로벌 엣지 (지연 시간 < 50ms)
    │ MISS
    ▼
L1: Reverse Proxy Cache        ← NGINX, Varnish
    │ MISS
    ▼
L2: API Gateway Cache          ← Kong, AWS API Gateway
    │ MISS
    ▼
L3: Application In-Process     ← Node.js Map, Caffeine (JVM)
    │ MISS
    ▼
L4: Distributed Cache          ← Redis, Memcached
    │ MISS
    ▼
L5: Primary Datastore          ← PostgreSQL, MongoDB

L3 TTL: 30초 (빠른 만료, 자주 갱신)
L4 TTL: 300초 (L3 미스 시 안전망)

읽기:
1. 캐시에서 조회 (GET key)
2. HIT → 캐시 데이터 반환
3. MISS → DB에서 조회 → 캐시에 저장 (SET key value EX ttl) → 데이터 반환
 
쓰기:
1. DB에 쓰기
2. 캐시 무효화 (DEL key)

async function getUser(userId: string): Promise<User> {
  // 1. 캐시 조회
  const cached = await redis.get(`user:${userId}`);
  if (cached) {
    return JSON.parse(cached);
  }
 
  // 2. DB 조회
  const user = await db.users.findById(userId);
  if (user) {
    // 3. 캐시에 저장 (TTL 5분)
    await redis.set(`user:${userId}`, JSON.stringify(user), 'EX', 300);
  }
 
  return user;
}

읽기:
1. 캐시에 요청
2. HIT → 반환
3. MISS → 캐시가 자체적으로 DB 조회 → 저장 → 반환

쓰기:
1. 캐시에 쓰기
2. 캐시가 DB에 쓰기 (동기)
3. 양쪽 모두 완료 후 응답

쓰기:
1. 캐시에 쓰기 → 즉시 응답
2. 백그라운드에서 DB에 쓰기 (배치 또는 지연)

SET user:123 '{"name":"홍길동"}' EX 300  # 5분 후 자동 만료

async function updateUser(userId: string, data: UpdateUserDto) {
  // 1. DB 업데이트
  const updatedUser = await db.users.update(userId, data);
 
  // 2. 캐시 무효화
  await redis.del(`user:${userId}`);
 
  // 3. 관련 캐시도 무효화
  await redis.del(`user-profile:${userId}`);
  await redis.del(`user-orders:${userId}`);
 
  return updatedUser;
}

캐시 만료 → 동시 요청 1000개 → DB에 1000개 동일 쿼리 → DB 과부하

async function getWithLock(key: string): Promise<any> {
  const cached = await redis.get(key);
  if (cached) return JSON.parse(cached);
 
  const lockKey = `lock:${key}`;
  // SET NX (존재하지 않을 때만 설정) - 원자적 잠금
  const acquired = await redis.set(lockKey, '1', 'EX', 10, 'NX');
 
  if (acquired) {
    try {
      const data = await fetchFromDatabase(key);
      await redis.set(key, JSON.stringify(data), 'EX', 300);
      return data;
    } finally {
      await redis.del(lockKey);
    }
  } else {
    // 잠금 대기 후 재시도
    await sleep(50);
    return getWithLock(key);
  }
}

function shouldRefresh(ttlRemaining: number, delta: number, beta: number = 1.0): boolean {
  // XFetch 알고리즘
  const random = -delta * beta * Math.log(Math.random());
  return ttlRemaining < random;
}
 
// ttlRemaining이 적을수록 갱신 확률이 높아짐
// delta: 캐시 재계산에 소요되는 시간
// beta: 조기 만료 정도 조절 (기본 1.0)

// Go의 singleflight 패턴
group := &singleflight.Group{}
 
result, err, shared := group.Do("user:123", func() (interface{}, error) {
    return fetchFromDatabase("user:123")
})
// shared == true이면 다른 호출자와 결과를 공유한 것

슬롯 0-5460     → Node A (+ Replica A')
슬롯 5461-10922 → Node B (+ Replica B')
슬롯 10923-16383 → Node C (+ Replica C')

[Sentinel 1] [Sentinel 2] [Sentinel 3]
     │            │            │
     └────────────┼────────────┘
                  │
     ┌────────────┼────────────┐
     ▼            ▼            ▼
 [Master]    [Replica 1]  [Replica 2]
 
Master 장애 감지 → Sentinel 투표 → Replica 1 승격 → 클라이언트 리다이렉트

# 점수 추가/갱신
ZADD game:leaderboard 1500 "player_A"
ZADD game:leaderboard 2300 "player_B"
ZADD game:leaderboard 1800 "player_C"
 
# 상위 10명 조회 (점수 내림차순)
ZREVRANGE game:leaderboard 0 9 WITHSCORES
 
# 특정 플레이어 순위 조회
ZREVRANK game:leaderboard "player_A"
 
# 점수 범위 조회
ZRANGEBYSCORE game:leaderboard 1000 2000

// 스타트업 워밍 예시
async function warmCache() {
  const popularProducts = await db.products.findPopular({ limit: 1000 });
 
  const pipeline = redis.pipeline();
  for (const product of popularProducts) {
    pipeline.set(
      `product:${product.id}`,
      JSON.stringify(product),
      'EX', 3600
    );
  }
  await pipeline.exec();
 
  console.log(`캐시 워밍 완료: ${popularProducts.length}개 상품`);
}

User Service가 사용자 정보 변경
    ↓
Kafka 이벤트: user.updated (userId: 123)
    ↓
├── Order Service: redis.del("user-orders:123")
├── Profile Service: redis.del("user-profile:123")
└── Recommendation Service: redis.del("user-recs:123")

사용자 (한국) → 서울 엣지 PoP → 캐시 HIT → 즉시 응답 (< 50ms)
사용자 (한국) → 서울 엣지 PoP → 캐시 MISS → 오리진 서버 → 캐싱 → 응답