2026년 Next.js에서 Redis로 API 응답 캐싱 구현하기

• 초고속 응답 - 메모리 기반이라 밀리초 단위의 빠른 데이터 접근이 가능해요
• 영구성 보장 - 서버 재시작해도 캐시 데이터가 유지되죠
• 분산 환경 지원 - 여러 Next.js 인스턴스가 하나의 Redis를 공유할 수 있어요
• 자동 만료 기능 - TTL 설정으로 오래된 데이터를 자동으로 제거해줘요

# Redis 설치
brew install redis

# Redis 서버 시작
brew services start redis

# Redis 연결 테스트
redis-cli ping
# PONG 응답이 오면 성공!

# 패키지 업데이트
sudo apt update

# Redis 설치
sudo apt install redis-server

# Redis 서비스 시작
sudo systemctl start redis-server

# 자동 시작 설정
sudo systemctl enable redis-server

# 상태 확인
sudo systemctl status redis-server

# 최신 Redis 이미지 다운로드 및 실행
docker run -d \
  --name my-redis \
  -p 6379:6379 \
  redis:7.2-alpine

# Redis CLI로 접속
docker exec -it my-redis redis-cli

# 데이터 영속성을 위한 볼륨 마운트
docker run -d \
  --name my-redis \
  -p 6379:6379 \
  -v redis-data:/data \
  redis:7.2-alpine redis-server --appendonly yes

• maxmemory: Redis가 사용할 최대 메모리 제한. 이거 안 설정하면 서버 메모리 다 먹어버려요.
• maxmemory-policy: 메모리 가득 찼을 때 어떤 데이터를 삭제할지 정책 설정. allkeys-lru가 캐싱에 적합해요.
• bind: 기본값이 127.0.0.1인데, 외부 접속이 필요하면 변경해야 해요.
• requirepass: 비밀번호 설정. 프로덕션에선 필수예요!

# redis.conf 주요 설정
maxmemory 256mb
maxmemory-policy allkeys-lru
bind 127.0.0.1
port 6379
requirepass your_strong_password_here
timeout 300
tcp-keepalive 60

# 영속성 설정 (선택)
save 900 1
save 300 10
save 60 10000
appendonly yes
appendfsync everysec

# Redis CLI 실행
redis-cli

# 연결 확인
127.0.0.1:6379> PING
PONG

# 간단한 데이터 저장/조회
127.0.0.1:6379> SET test:key "Hello Redis"
OK
127.0.0.1:6379> GET test:key
"Hello Redis"

# 서버 정보 확인
127.0.0.1:6379> INFO server

# 현재 설정 확인
127.0.0.1:6379> CONFIG GET maxmemory

// lib/redis.ts
import Redis from 'ioredis';

const redis = new Redis({
  host: process.env.REDIS_HOST || 'localhost',
  port: parseInt(process.env.REDIS_PORT || '6379'),
  password: process.env.REDIS_PASSWORD,
  retryStrategy: (times) => {
    const delay = Math.min(times * 50, 2000);
    return delay;
  },
  maxRetriesPerRequest: 3,
});

redis.on('error', (err) => {
  console.error('Redis 연결 오류:', err);
});

redis.on('connect', () => {
  console.log('✅ Redis 연결 성공!');
});

export default redis;

// lib/cache.ts
import redis from './redis';

interface CacheOptions {
  key: string;
  ttl?: number; // 초 단위
  fetchData: () => Promise<any>;
}

export async function getOrSetCache<T>({
  key,
  ttl = 3600, // 기본 1시간
  fetchData,
}: CacheOptions): Promise<T> {
  try {
    // 1. 캐시에서 먼저 조회
    const cached = await redis.get(key);
    
    if (cached) {
      console.log(`✅ 캐시 히트: ${key}`);
      return JSON.parse(cached);
    }

    // 2. 캐시 미스 - 실제 데이터 가져오기
    console.log(`❌ 캐시 미스: ${key} - 새로 가져옵니다`);
    const data = await fetchData();

    // 3. Redis에 저장
    await redis.setex(key, ttl, JSON.stringify(data));
    
    return data;
  } catch (error) {
    console.error('캐싱 오류:', error);
    // Redis 오류 시 원본 데이터 반환
    return await fetchData();
  }
}

// app/api/products/route.ts
import { NextRequest, NextResponse } from 'next/server';
import { getOrSetCache } from '@/lib/cache';

interface Product {
  id: string;
  name: string;
  price: number;
}

export async function GET(request: NextRequest) {
  try {
    const searchParams = request.nextUrl.searchParams;
    const category = searchParams.get('category') || 'all';
    
    // 카테고리별로 다른 캐시 키 사용
    const cacheKey = `products:${category}`;
    
    const products = await getOrSetCache<Product[]>({
      key: cacheKey,
      ttl: 1800, // 30분
      fetchData: async () => {
        // 실제 DB 조회 또는 외부 API 호출
        const response = await fetch(
          `https://api.example.com/products?category=${category}`
        );
        return response.json();
      },
    });

    return NextResponse.json({
      success: true,
      data: products,
      cached: true,
    });
  } catch (error) {
    return NextResponse.json(
      { success: false, error: '상품 조회 실패' },
      { status: 500 }
    );
  }
}

// lib/cache.ts (추가)
export async function invalidateCache(pattern: string): Promise<number> {
  try {
    const keys = await redis.keys(pattern);
    
    if (keys.length === 0) {
      return 0;
    }

    const deleted = await redis.del(...keys);
    console.log(`?️ ${deleted}개의 캐시 삭제: ${pattern}`);
    
    return deleted;
  } catch (error) {
    console.error('캐시 삭제 오류:', error);
    return 0;
  }
}

// 특정 캐시 삭제
export async function deleteCache(key: string): Promise<boolean> {
  try {
    await redis.del(key);
    console.log(`?️ 캐시 삭제: ${key}`);
    return true;
  } catch (error) {
    console.error('캐시 삭제 오류:', error);
    return false;
  }
}

// app/api/products/[id]/route.ts
import { invalidateCache, deleteCache } from '@/lib/cache';

export async function PUT(
  request: NextRequest,
  { params }: { params: { id: string } }
) {
  try {
    // 상품 업데이트 로직
    const body = await request.json();
    await updateProduct(params.id, body);

    // 관련 캐시 모두 삭제
    await invalidateCache('products:*');
    await deleteCache(`product:${params.id}`);

    return NextResponse.json({
      success: true,
      message: '상품이 업데이트되었습니다',
    });
  } catch (error) {
    return NextResponse.json(
      { success: false, error: '업데이트 실패' },
      { status: 500 }
    );
  }
}

// app/products/page.tsx
import { getOrSetCache } from '@/lib/cache';

interface Product {
  id: string;
  name: string;
  price: number;
}

async function getProducts(): Promise<Product[]> {
  return getOrSetCache<Product[]>({
    key: 'products:featured',
    ttl: 3600,
    fetchData: async () => {
      // DB 조회 또는 외부 API
      const products = await db.product.findMany({
        where: { featured: true },
      });
      return products;
    },
  });
}

export default async function ProductsPage() {
  const products = await getProducts();

  return (
    <div>
      <h1>인기 상품</h1>
      {products.map((product) => (
        <div key={product.id}>
          {product.name} - {product.price}원
        </div>
      ))}
    </div>
  );
}

// app/api/cache/stats/route.ts
import redis from '@/lib/redis';
import { NextResponse } from 'next/server';

export async function GET() {
  try {
    const info = await redis.info('stats');
    const keys = await redis.keys('*');
    
    // Redis 메모리 정보
    const memory = await redis.info('memory');
    
    const stats = {
      totalKeys: keys.length,
      keysByPrefix: {} as Record<string, number>,
      memoryUsage: parseMemoryInfo(memory),
      uptime: parseUptime(info),
    };

    // 프리픽스별로 키 개수 집계
    keys.forEach((key) => {
      const prefix = key.split(':')[0];
      stats.keysByPrefix[prefix] = 
        (stats.keysByPrefix[prefix] || 0) + 1;
    });

    return NextResponse.json({ success: true, data: stats });
  } catch (error) {
    return NextResponse.json(
      { success: false, error: '통계 조회 실패' },
      { status: 500 }
    );
  }
}

function parseMemoryInfo(memory: string) {
  const lines = memory.split('\r
');
  const usedMemory = lines.find(l => 
    l.startsWith('used_memory_human')
  );
  return usedMemory?.split(':')[1] || 'N/A';
}

function parseUptime(info: string) {
  const lines = info.split('\r
');
  const uptime = lines.find(l => 
    l.startsWith('uptime_in_seconds')
  );
  return uptime?.split(':')[1] || '0';
}

// app/api/posts/[id]/route.ts
import { NextRequest, NextResponse } from 'next/server';
import { redis } from '@/lib/redis';

export async function PATCH(
  request: NextRequest,
  { params }: { params: { id: string } }
) {
  try {
    const data = await request.json();
    const postId = params.id;
    
    // 1. 데이터베이스 업데이트
    await db.post.update({
      where: { id: postId },
      data
    });
    
    // 2. 관련 캐시 삭제
    const cacheKeys = [
      `post:${postId}`,           // 개별 게시글 캐시
      `posts:list`,               // 목록 캐시
      `posts:user:${data.userId}` // 사용자별 게시글 캐시
    ];
    
    await Promise.all(
      cacheKeys.map(key => redis.del(key))
    );
    
    return NextResponse.json({ 
      success: true,
      message: '게시글이 수정되었습니다' 
    });
    
  } catch (error) {
    console.error('Post update error:', error);
    return NextResponse.json(
      { error: '수정 실패' },
      { status: 500 }
    );
  }
}

// lib/cache-utils.ts
import { redis } from './redis';

export async function deleteByPattern(pattern: string) {
  let cursor = 0;
  const keysToDelete: string[] = [];
  
  do {
    // SCAN으로 패턴 매칭 키 찾기
    const result = await redis.scan(
      cursor, 
      'MATCH', 
      pattern, 
      'COUNT', 
      100
    );
    
    cursor = parseInt(result[0]);
    const keys = result[1] as string[];
    
    if (keys.length > 0) {
      keysToDelete.push(...keys);
    }
  } while (cursor !== 0);
  
  // 찾은 키들 일괄 삭제
  if (keysToDelete.length > 0) {
    await redis.del(...keysToDelete);
    console.log(`삭제된 캐시: ${keysToDelete.length}개`);
  }
  
  return keysToDelete.length;
}

// 사용 예시
export async function invalidatePostCaches(postId: string) {
  await Promise.all([
    deleteByPattern(`post:${postId}*`),  // 해당 게시글 관련
    deleteByPattern('posts:list*'),      // 모든 목록 캐시
    deleteByPattern('posts:recent*')     // 최신 게시글 캐시
  ]);
}

SCAN은 키가 많을수록 느려질 수 있어요. 프로덕션에서는 패턴을 최대한 구체적으로 지정하는 게 좋아요. 그리고 KEYS 명령어는 절대 사용하지 마세요. 서버 전체가 멈출 수 있거든요!

// lib/tagged-cache.ts
import { redis } from './redis';

class TaggedCache {
  // 태그와 함께 캐시 저장
  async set(
    key: string, 
    value: any, 
    tags: string[], 
    ttl: number = 3600
  ) {
    const multi = redis.multi();
    
    // 1. 데이터 저장
    multi.setex(key, ttl, JSON.stringify(value));
    
    // 2. 각 태그에 키 추가
    tags.forEach(tag => {
      multi.sadd(`tag:${tag}`, key);
      multi.expire(`tag:${tag}`, ttl + 3600); // 태그는 조금 더 길게
    });
    
    await multi.exec();
  }
  
  // 태그로 캐시 무효화
  async invalidateTag(tag: string) {
    // 1. 해당 태그의 모든 키 가져오기
    const keys = await redis.smembers(`tag:${tag}`);
    
    if (keys.length === 0) return 0;
    
    // 2. 모든 키와 태그 세트 삭제
    const multi = redis.multi();
    keys.forEach(key => multi.del(key));
    multi.del(`tag:${tag}`);
    
    await multi.exec();
    
    console.log(`태그 '${tag}'로 ${keys.length}개 캐시 삭제`);
    return keys.length;
  }
  
  // 여러 태그 동시 무효화
  async invalidateTags(tags: string[]) {
    return Promise.all(
      tags.map(tag => this.invalidateTag(tag))
    );
  }
}

export const taggedCache = new TaggedCache();

// 사용 예시
await taggedCache.set(
  'post:123',
  postData,
  ['posts', 'user:456', 'category:tech'],
  3600
);

// 특정 카테고리 전체 무효화
await taggedCache.invalidateTag('category:tech');

// app/actions/posts.ts
'use server';

import { revalidatePath, revalidateTag } from 'next/cache';
import { taggedCache } from '@/lib/tagged-cache';

export async function updatePost(postId: string, data: any) {
  try {
    // 1. 데이터베이스 업데이트
    const updatedPost = await db.post.update({
      where: { id: postId },
      data
    });
    
    // 2. Redis 캐시 무효화
    await taggedCache.invalidateTags([
      'posts',
      `user:${updatedPost.userId}`,
      `post:${postId}`
    ]);
    
    // 3. Next.js 캐시 무효화
    revalidatePath('/posts');
    revalidatePath(`/posts/${postId}`);
    revalidateTag('posts-list');
    
    return { success: true, post: updatedPost };
    
  } catch (error) {
    console.error('Update failed:', error);
    return { success: false, error: '업데이트 실패' };
  }
}

export async function deletePost(postId: string) {
  try {
    const post = await db.post.findUnique({
      where: { id: postId }
    });
    
    if (!post) {
      return { success: false, error: '게시글을 찾을 수 없습니다' };
    }
    
    // 삭제 전에 관련 정보 저장
    const userId = post.userId;
    
    await db.post.delete({ where: { id: postId } });
    
    // Redis와 Next.js 캐시 모두 무효화
    await Promise.all([
      taggedCache.invalidateTags([
        'posts',
        `user:${userId}`,
        `post:${postId}`
      ]),
      revalidatePath('/posts'),
      revalidateTag('posts-list')
    ]);
    
    return { success: true };
    
  } catch (error) {
    console.error('Delete failed:', error);
    return { success: false, error: '삭제 실패' };
  }
}

• TTL 기반 + 수동 삭제 조합
• 간단한 키 네이밍 전략
• CRUD 작업 후 직접 캐시 삭제
• 복잡도 낮게 유지하는 게 핵심

• 태그 기반 캐시 관리 도입
• 패턴 매칭으로 일괄 삭제
• 서버 액션에 캐시 로직 통합
• 모니터링 시스템 구축

• 이벤트 기반 아키텍처 (Kafka, RabbitMQ)
• 분산 캐시 무효화 시스템
• 캐시 워밍 전략 (미리 채우기)
• A/B 테스트로 최적 TTL 찾기

// lib/safe-cache-update.ts
import { redis } from './redis';

export async function safeUpdateCache(
  key: string,
  updateFn: () => Promise
) {
  const lockKey = `lock:${key}`;
  const lockValue = Date.now().toString();
  
  try {
    // 1. 락 획득 (10초 타임아웃)
    const acquired = await redis.set(
      lockKey, 
      lockValue, 
      'EX', 
      10, 
      'NX'
    );
    
    if (!acquired) {
      // 다른 요청이 처리 중이면 기다림
      await new Promise(resolve => setTimeout(resolve, 100));
      return null;
    }
    
    // 2. 캐시 삭제
    await redis.del(key);
    
    // 3. 새 데이터 가져오기
    const newData = await updateFn();
    
    // 4. 캐시 저장
    await redis.setex(key, 3600, JSON.stringify(newData));
    
    return newData;
    
  } finally {
    // 5. 락 해제 (자기가 건 락만 해제)
    const currentValue = await redis.get(lockKey);
    if (currentValue === lockValue) {
      await redis.del(lockKey);
    }
  }
}

// 사용 예시
const post = await safeUpdateCache(
  'post:123',
  async () => {
    return await db.post.findUnique({
      where: { id: '123' }
    });
  }
);

// lib/cache/tags.ts
export class TaggedCache {
  constructor(private redis: Redis) {}

  async set(key: string, value: any, tags: string[], ttl = 3600) {
    const pipeline = this.redis.pipeline();
    
    // 데이터 저장
    pipeline.setex(key, ttl, JSON.stringify(value));
    
    // 각 태그에 키 등록
    tags.forEach(tag => {
      pipeline.sadd(`tag:${tag}`, key);
      pipeline.expire(`tag:${tag}`, ttl + 86400);
    });
    
    await pipeline.exec();
  }

  async invalidateByTag(tag: string) {
    const keys = await this.redis.smembers(`tag:${tag}`);
    
    if (keys.length > 0) {
      const pipeline = this.redis.pipeline();
      keys.forEach(key => pipeline.del(key));
      pipeline.del(`tag:${tag}`);
      await pipeline.exec();
    }
  }
}

// app/api/posts/route.ts
import { taggedCache } from '@/lib/cache/tags';

export async function GET() {
  const cached = await redis.get('posts:list');
  if (cached) return Response.json(JSON.parse(cached));

  const posts = await db.posts.findMany();
  
  // 여러 태그로 관리
  await taggedCache.set('posts:list', posts, ['posts', 'content'], 3600);
  
  return Response.json(posts);
}

// 포스트 업데이트 시
export async function PUT() {
  await db.posts.update(/* ... */);
  
  // 'posts' 태그 관련 캐시 전부 삭제
  await taggedCache.invalidateByTag('posts');
}

// lib/cache/swr.ts
export async function fetchWithSWR(
  key: string,
  fetcher: () => Promise,
  options = { ttl: 3600, staleTime: 300 }
) {
  const cacheKey = `swr:${key}`;
  const timestampKey = `${cacheKey}:ts`;
  
  // 캐시된 데이터 확인
  const [cached, timestamp] = await Promise.all([
    redis.get(cacheKey),
    redis.get(timestampKey)
  ]);
  
  if (cached) {
    const age = Date.now() - parseInt(timestamp || '0');
    const isStale = age > options.staleTime * 1000;
    
    if (isStale) {
      // Stale 데이터지만 일단 반환하고 백그라운드 갱신
      setImmediate(async () => {
        try {
          const fresh = await fetcher();
          await Promise.all([
            redis.setex(cacheKey, options.ttl, JSON.stringify(fresh)),
            redis.setex(timestampKey, options.ttl, Date.now().toString())
          ]);
        } catch (error) {
          console.error('Background revalidation failed:', error);
        }
      });
    }
    
    return JSON.parse(cached) as T;
  }
  
  // 캐시 없으면 새로 가져오기
  const data = await fetcher();
  await Promise.all([
    redis.setex(cacheKey, options.ttl, JSON.stringify(data)),
    redis.setex(timestampKey, options.ttl, Date.now().toString())
  ]);
  
  return data;
}

// 사용 예시
export async function GET() {
  const products = await fetchWithSWR(
    'products:featured',
    async () => await db.products.findMany({ where: { featured: true } }),
    { ttl: 3600, staleTime: 600 } // 10분 후부터 stale
  );
  
  return Response.json(products);
}

// lib/cache/multi-layer.ts
import { LRUCache } from 'lru-cache';

const memoryCache = new LRUCache({
  max: 500, // 최대 500개 항목
  ttl: 60000, // 1분
});

export async function getWithMultiLayer(
  key: string,
  fetcher: () => Promise,
  ttl = 3600
): Promise {
  // L1: 메모리 체크
  const memCached = memoryCache.get(key);
  if (memCached) {
    console.log('✅ Memory cache hit');
    return memCached as T;
  }
  
  // L2: Redis 체크
  const redisCached = await redis.get(key);
  if (redisCached) {
    console.log('✅ Redis cache hit');
    const data = JSON.parse(redisCached);
    memoryCache.set(key, data); // L1에도 저장
    return data as T;
  }
  
  // L3: Database에서 가져오기
  console.log('❌ Cache miss - fetching from DB');
  const data = await fetcher();
  
  // 모든 레이어에 저장
  await redis.setex(key, ttl, JSON.stringify(data));
  memoryCache.set(key, data);
  
  return data;
}

// 사용 예시
export async function GET(req: Request) {
  const { searchParams } = new URL(req.url);
  const userId = searchParams.get('userId');
  
  const profile = await getWithMultiLayer(
    `profile:${userId}`,
    async () => await db.users.findUnique({ where: { id: userId } }),
    3600
  );
  
  return Response.json(profile);
}

Lock 타임아웃을 너무 길게 설정하면 오히려 성능이 나빠질 수 있어요. 보통 5-10초 정도가 적당해요.

// lib/cache/safe-fetch.ts
export async function safeFetchWithLock(
  key: string,
  fetcher: () => Promise,
  ttl = 3600
): Promise {
  const lockKey = `lock:${key}`;
  const lockTimeout = 10; // 10초
  
  // 캐시 확인
  const cached = await redis.get(key);
  if (cached) return JSON.parse(cached) as T;
  
  // Lock 획득 시도
  const locked = await redis.set(lockKey, '1', 'EX', lockTimeout, 'NX');
  
  if (locked) {
    try {
      // 이 요청이 데이터를 가져옴
      const data = await fetcher();
      await redis.setex(key, ttl, JSON.stringify(data));
      return data;
    } finally {
      await redis.del(lockKey);
    }
  } else {
    // 다른 요청이 데이터를 가져오는 중
    // 최대 10초 동안 대기하면서 캐시 확인
    for (let i = 0; i < 20; i++) {
      await new Promise(resolve => setTimeout(resolve, 500));
      const cached = await redis.get(key);
      if (cached) return JSON.parse(cached) as T;
    }
    
    // 타임아웃 되면 그냥 가져오기
    return await fetcher();
  }
}

처음부터 복잡한 패턴 쓰지 마세요. 단순 캐싱으로 시작해서 문제가 생길 때마다 패턴을 추가하는 게 좋아요. 저도 그렇게 배웠거든요. 오버 엔지니어링 하면 오히려 디버깅이 힘들어져요.

Redis 연결 문제는 개발 환경과 프로덕션 환경에서 다르게 나타날 수 있어요. 로컬에서는 잘 되는데 배포하면 안 되는 경우도 많거든요.

// lib/redis-health.ts
import redis from './redis';

export async function checkRedisConnection() {
  try {
    const startTime = Date.now();
    await redis.ping();
    const responseTime = Date.now() - startTime;
    
    return {
      status: 'healthy',
      responseTime: `${responseTime}ms`,
      timestamp: new Date().toISOString()
    };
  } catch (error) {
    console.error('Redis 연결 실패:', error);
    return {
      status: 'unhealthy',
      error: error.message,
      timestamp: new Date().toISOString()
    };
  }
}

// API Route에서 사용
export async function GET() {
  const health = await checkRedisConnection();
  return Response.json(health);
}

캐시 디버깅할 때는 항상 로그를 남기세요. "캐시 HIT"인지 "캐시 MISS"인지 확인할 수 있어야 문제를 찾기 쉬워요.

// lib/cache-debug.ts
export async function cacheWithDebug(
  key: string,
  fetcher: () => Promise,
  ttl: number = 300
): Promise {
  const startTime = Date.now();
  
  // 캐시 확인
  const cached = await redis.get(key);
  if (cached) {
    console.log(`✅ 캐시 HIT: ${key}`);
    return {
      data: JSON.parse(cached),
      cacheHit: true,
      timing: Date.now() - startTime
    };
  }
  
  console.log(`❌ 캐시 MISS: ${key}`);
  
  // 데이터 가져오기
  const data = await fetcher();
  
  // 캐싱
  await redis.setex(key, ttl, JSON.stringify(data));
  
  console.log(`? 캐시 저장 완료: ${key} (TTL: ${ttl}초)`);
  
  return {
    data,
    cacheHit: false,
    timing: Date.now() - startTime
  };
}

// lib/compressed-cache.ts
import { gzip, gunzip } from 'zlib';
import { promisify } from 'util';

const gzipAsync = promisify(gzip);
const gunzipAsync = promisify(gunzip);

export async function setCompressed(
  key: string,
  data: any,
  ttl: number
) {
  const json = JSON.stringify(data);
  const compressed = await gzipAsync(json);
  await redis.setex(key, ttl, compressed.toString('base64'));
}

export async function getCompressed(key: string) {
  const compressed = await redis.get(key);
  if (!compressed) return null;
  
  const buffer = Buffer.from(compressed, 'base64');
  const decompressed = await gunzipAsync(buffer);
  return JSON.parse(decompressed.toString());
}

// lib/cache-with-lock.ts
export async function cacheWithLock(
  key: string,
  fetcher: () => Promise,
  ttl: number = 300
): Promise {
  const lockKey = `lock:${key}`;
  const lockTTL = 30; // 30초 락
  
  // 캐시 확인
  const cached = await redis.get(key);
  if (cached) return JSON.parse(cached);
  
  // 락 획득 시도
  const lockAcquired = await redis.set(
    lockKey, 
    '1', 
    'EX', 
    lockTTL, 
    'NX'
  );
  
  if (lockAcquired) {
    try {
      // 데이터 가져오기
      const data = await fetcher();
      await redis.setex(key, ttl, JSON.stringify(data));
      return data;
    } finally {
      // 락 해제
      await redis.del(lockKey);
    }
  } else {
    // 다른 요청이 처리 중이면 잠시 대기 후 재시도
    await new Promise(resolve => setTimeout(resolve, 100));
    return cacheWithLock(key, fetcher, ttl);
  }
}

• 환경 변수 모두 설정됐는지 확인
• Redis 서버가 외부 접속을 허용하는지 확인
• TLS/SSL 인증서 설정 (프로덕션 필수)
• 에러 로깅 및 모니터링 설정
• 캐시 워밍업 전략 수립

// lib/cache-with-monitoring.ts
import redis from './redis';

interface CacheMetrics {
  hits: number;
  misses: number;
  errors: number;
  avgResponseTime: number;
}

const metrics: CacheMetrics = {
  hits: 0,
  misses: 0,
  errors: 0,
  avgResponseTime: 0
};

export async function monitoredCache(
  key: string,
  fetcher: () => Promise,
  ttl: number = 300
): Promise {
  const startTime = Date.now();
  
  try {
    const cached = await redis.get(key);
    
    if (cached) {
      metrics.hits++;
      console.log(`✅ 캐시 HIT [${key}]`, {
        timestamp: new Date().toISOString(),
        responseTime: Date.now() - startTime
      });
      return JSON.parse(cached);
    }
    
    metrics.misses++;
    console.log(`❌ 캐시 MISS [${key}]`);
    
    const data = await fetcher();
    await redis.setex(key, ttl, JSON.stringify(data));
    
    const responseTime = Date.now() - startTime;
    metrics.avgResponseTime = 
      (metrics.avgResponseTime + responseTime) / 2;
    
    return data;
    
  } catch (error) {
    metrics.errors++;
    console.error(`? 캐시 에러 [${key}]`, {
      error: error.message,
      stack: error.stack,
      timestamp: new Date().toISOString()
    });
    
    // 에러 발생 시 원본 데이터 반환
    return fetcher();
  }
}

export function getCacheMetrics() {
  return {
    ...metrics,
    hitRate: metrics.hits / (metrics.hits + metrics.misses) * 100
  };
}