BackendDevGuide0008

📚 학습 목차 — 이 가이드에서 배울 내용

⚡ 1장. 성능 최적화의 기초 — 왜 API가 느린가?

병목을 찾아내는 사고방식 + 프로파일링 방법

🍕 편의점 냉장고 비유로 이해하는 캐싱

손님이 편의점에 올 때마다 직원이 창고에서 물건을 꺼내온다면? 시간도 오래 걸리고 직원도 지칩니다.
냉장고(캐시)에 자주 팔리는 음료를 미리 진열해두면 → 손님은 즉시 가져갈 수 있고 → 창고(데이터베이스)를 자주 열 필요가 없습니다.
이것이 바로 캐싱의 핵심 원리입니다!

// 방법 1: console.time으로 간단 측정
console.time('getUserList');
const users = await getUserList();
console.timeEnd('getUserList'); // getUserList: 342ms

// 방법 2: Date.now()로 정밀 측정
const start = Date.now();
const result = await heavyOperation();
const elapsed = Date.now() - start;
console.log(`실행 시간: ${elapsed}ms`);

// 방법 3: NestJS Interceptor로 전체 API 측정
import { Injectable, NestInterceptor, ExecutionContext, CallHandler } from '@nestjs/common';
import { Observable } from 'rxjs';
import { tap } from 'rxjs/operators';

@Injectable()
export class LoggingInterceptor implements NestInterceptor {
  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    const start = Date.now();
    const { method, url } = context.switchToHttp().getRequest();
    
    return next.handle().pipe(
      tap(() => {
        const elapsed = Date.now() - start;
        console.log(`[${method}] ${url} — ${elapsed}ms`);
        // 1초 이상이면 경고
        if (elapsed > 1000) {
          console.warn(`⚠️ SLOW API: ${url} took ${elapsed}ms!`);
        }
      }),
    );
  }
}

📊 성능 측정 황금 법칙 — RAIL 모델

🔴 2장. Redis 완전 정복 — 설치부터 실전까지

세계에서 가장 빠른 인메모리 데이터 저장소

🏎️ Redis가 뭔가요? — 초고속 메모 장관 비유

회사에서 어떤 직원에게 같은 질문을 100번 한다고 상상해보세요.
매번 도서관(데이터베이스)에 가서 책을 찾아오면 시간이 오래 걸립니다.
하지만 그 직원이 메모장(Redis)에 자주 묻는 답변을 적어두면 → 즉시 대답할 수 있습니다!
Redis = 초고속 메모리 기반 저장소. RAM에 데이터를 저장하기 때문에 0.1ms 이하의 응답 속도!

# ---- Docker로 Redis 실행 (가장 빠른 방법) ----
docker run -d --name redis \
  -p 6379:6379 \
  -v redis_data:/data \
  redis:7-alpine redis-server --appendonly yes --requirepass yourpassword

# ---- 또는 로컬 직접 설치 ----
# macOS
brew install redis
brew services start redis

# Ubuntu/Linux
sudo apt-get install redis-server
sudo systemctl enable redis-server
sudo systemctl start redis-server

# Redis CLI 접속 테스트
redis-cli ping  # PONG 응답 오면 성공!
redis-cli -h localhost -p 6379 -a yourpassword

# NestJS Redis 패키지 설치
npm install @nestjs/cache-manager cache-manager cache-manager-redis-yet
npm install ioredis @types/ioredis

📊 Redis vs 다른 캐시 솔루션 비교

🏗️ 3장. NestJS + Redis 캐싱 실전 패턴

Cache-Aside, Write-Through, Write-Behind 전략 완전 구현

// app.module.ts — Redis 캐시 모듈 설정
import { CacheModule } from '@nestjs/cache-manager';
import * as redisStore from 'cache-manager-redis-yet';

@Module({
  imports: [
    CacheModule.registerAsync({
      isGlobal: true,
      useFactory: async () => ({
        store: redisStore,
        socket: {
          host: process.env.REDIS_HOST || 'localhost',
          port: +process.env.REDIS_PORT || 6379,
        },
        password: process.env.REDIS_PASSWORD,
        ttl: 60 * 60, // 기본 TTL: 1시간
      }),
    }),
  ],
})
export class AppModule {}

// .env
REDIS_HOST=localhost
REDIS_PORT=6379
REDIS_PASSWORD=yourpassword

// users.service.ts — Cache-Aside 패턴 구현
import { Injectable, Inject } from '@nestjs/common';
import { Cache } from 'cache-manager';
import { CACHE_MANAGER } from '@nestjs/cache-manager';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';

@Injectable()
export class UsersService {
  constructor(
    @Inject(CACHE_MANAGER) private cacheManager: Cache,
    @InjectRepository(User) private userRepo: Repository<User>,
  ) {}

  // ✅ Cache-Aside 패턴으로 사용자 조회
  async findOne(id: number): Promise<User> {
    const cacheKey = `user:${id}`;
    
    // 1️⃣ 캐시 확인
    const cached = await this.cacheManager.get<User>(cacheKey);
    if (cached) {
      console.log(`✅ 캐시 히트: ${cacheKey}`);
      return cached;
    }
    
    // 2️⃣ 캐시 미스 → DB 조회
    console.log(`❌ 캐시 미스: ${cacheKey} → DB 조회`);
    const user = await this.userRepo.findOne({ where: { id } });
    if (!user) throw new NotFoundException(`User ${id} not found`);
    
    // 3️⃣ 캐시 저장 (TTL: 5분)
    await this.cacheManager.set(cacheKey, user, 300);
    return user;
  }

  // ✅ 업데이트 시 캐시 무효화 (Cache Invalidation)
  async update(id: number, dto: UpdateUserDto): Promise<User> {
    const user = await this.userRepo.save({ id, ...dto });
    
    // ⚠️ 수정 시 기존 캐시 삭제 (Stale 데이터 방지)
    await this.cacheManager.del(`user:${id}`);
    // 목록 캐시도 삭제
    await this.cacheManager.del('users:list');
    
    return user;
  }

  // ✅ 목록 조회 캐싱 (페이지네이션 포함)
  async findAll(page = 1, limit = 10) {
    const cacheKey = `users:list:page${page}:limit${limit}`;
    const cached = await this.cacheManager.get(cacheKey);
    if (cached) return cached;

    const [data, total] = await this.userRepo.findAndCount({
      skip: (page - 1) * limit,
      take: limit,
      order: { createdAt: 'DESC' },
    });
    
    const result = { data, total, page, totalPages: Math.ceil(total / limit) };
    await this.cacheManager.set(cacheKey, result, 60); // 1분 캐시
    return result;
  }
}

// ✅ @CacheKey 데코레이터 방식 (단순한 경우)
import { CacheKey, CacheTTL } from '@nestjs/cache-manager';

@Controller('products')
export class ProductsController {
  @Get()
  @CacheKey('products_all')   // 캐시 키
  @CacheTTL(30 * 60)           // TTL: 30분
  findAll() {
    return this.productsService.findAll();
  }
}

⚠️ 캐시 무효화 전략 — 가장 어려운 부분!

컴퓨터 과학에서 가장 어려운 두 가지: "캐시 무효화"와 "이름 짓기".
• TTL 기반: 일정 시간 후 자동 만료 (단순, 데이터 일시적 불일치 가능)
• 이벤트 기반: 데이터 변경 시 즉시 캐시 삭제 (정확하지만 코드 복잡)
• 패턴 삭제: Redis KEYS 패턴으로 관련 캐시 일괄 삭제 (대규모 서비스에서 주의)

🗄️ 4장. 데이터베이스 쿼리 최적화 — 인덱스 완전 정복

느린 쿼리를 100배 빠르게 만드는 실전 기술

📚 인덱스란? — 도서관 색인 비유

100만 권의 책이 있는 도서관에서 "홍길동이 쓴 책"을 찾으려면?
색인(인덱스) 없이: 책 100만 권을 하나씩 확인 → 엄청난 시간 소요 (Full Table Scan)
색인(인덱스) 있으면: "저자 색인" → H섹션 → 홍길동 → 해당 위치 즉시 이동! (B-Tree 탐색)
인덱스 = 데이터 위치를 미리 정리해둔 정렬된 자료구조

-- 쿼리 실행 계획 확인 (MySQL/PostgreSQL)
EXPLAIN SELECT * FROM users WHERE email = 'hong@test.com';

-- 결과 (인덱스 없을 때 - 느림)
+------+-------------+-------+------+------+------+-------+
| type | table       | rows  | key  | Extra               |
+------+-------------+-------+------+------+------+-------+
| ALL  | users       | 100000| NULL | Using where         | <-- Full Scan!
+------+-------------+-------+------+------+------+-------+

-- 인덱스 생성
CREATE INDEX idx_users_email ON users(email);

-- 결과 (인덱스 있을 때 - 빠름)
+------+------+-------+------------------+
| type | key  | rows  | Extra            |
+------+------+-------+------------------+
| ref  | idx_users_email | 1 | Using index | <-- 인덱스 사용!
+------+------+-------+------------------+

-- EXPLAIN ANALYZE (PostgreSQL) — 실제 실행 시간 포함
EXPLAIN ANALYZE SELECT * FROM posts
WHERE author_id = 42 AND published = true
ORDER BY created_at DESC LIMIT 10;

// TypeORM - 엔티티에 인덱스 추가
import { Entity, Index, Column, PrimaryGeneratedColumn } from 'typeorm';

@Entity()
@Index(['authorId', 'published'])  // 복합 인덱스
@Index(['createdAt'])              // 단순 인덱스
export class Post {
  @PrimaryGeneratedColumn()
  id: number;

  @Index()  // 단일 컬럼 인덱스
  @Column({ unique: true })
  slug: string;

  @Column()
  authorId: number;

  @Column({ default: false })
  published: boolean;

  @Index()
  @Column()
  createdAt: Date;
}

// Prisma - schema.prisma에 인덱스 추가
model Post {
  id         Int      @id @default(autoincrement())
  slug       String   @unique              // 유니크 인덱스
  authorId   Int
  published  Boolean  @default(false)
  createdAt  DateTime @default(now())
  
  @@index([authorId, published])           // 복합 인덱스
  @@index([createdAt])                     // 단순 인덱스
}

// ✅ 효율적인 쿼리 작성 — TypeORM QueryBuilder
async findPublishedByAuthor(authorId: number, page = 1, limit = 10) {
  return this.postRepo
    .createQueryBuilder('post')
    .select(['post.id', 'post.title', 'post.createdAt'])  // 필요한 컬럼만!
    .where('post.authorId = :authorId', { authorId })
    .andWhere('post.published = :published', { published: true })
    .orderBy('post.createdAt', 'DESC')
    .skip((page - 1) * limit)
    .take(limit)
    .getManyAndCount();
}

⚠️ 인덱스 사용 시 주의사항

🔗 5장. N+1 문제 완전 해결 — ORM 최적화

가장 흔한 성능 킬러를 완전히 제거하는 방법

🍕 N+1 문제란? — 배달 주문 비유

100명의 고객 목록을 가져온 뒤, 각 고객의 주문 내역을 하나씩 조회한다면?
→ 고객 목록 조회 1번 + 각 고객 주문 조회 100번 = 총 101번의 DB 쿼리!
→ N명의 고객이면 N+1번 쿼리 = "N+1 문제"
해결책: 처음부터 JOIN으로 한 번에 가져오는 "Eager Loading"!

// ❌ 나쁜 예: N+1 문제 발생
async getBadPosts() {
  const posts = await this.postRepo.find();  // 쿼리 1번
  for (const post of posts) {
    post.author = await this.userRepo.findOne(post.authorId); // 쿼리 N번!
  }
  return posts;
  // 총 쿼리: 1 + N번 = N+1 ← 최악!
}

// ✅ 좋은 예 1: TypeORM relations 사용
async getGoodPosts() {
  return this.postRepo.find({
    relations: { author: true },  // LEFT JOIN 자동 생성
    select: {
      id: true,
      title: true,
      author: { id: true, name: true },  // 필요한 필드만
    },
  });
  // 총 쿼리: 1번 (JOIN으로 한 번에!) ← 최고!
}

// ✅ 좋은 예 2: QueryBuilder로 정밀 제어
async getPostsWithDetails() {
  return this.postRepo
    .createQueryBuilder('post')
    .leftJoinAndSelect('post.author', 'author')
    .leftJoinAndSelect('post.tags', 'tag')
    .select([
      'post.id', 'post.title', 'post.createdAt',
      'author.id', 'author.name',     // 이름만, 비밀번호 제외!
      'tag.id', 'tag.name',
    ])
    .where('post.published = :published', { published: true })
    .orderBy('post.createdAt', 'DESC')
    .getMany();
}

// ✅ Prisma - include로 관계 데이터 한 번에
async findAllPrisma() {
  return this.prisma.post.findMany({
    where: { published: true },
    include: {
      author: { select: { id: true, name: true } },  // 필요한 필드만
      _count: { select: { comments: true } },      // 댓글 수 카운트
    },
    orderBy: { createdAt: 'desc' },
    take: 10,
  });
}

// ✅ DataLoader 패턴 — GraphQL에서 N+1 해결
import DataLoader from 'dataloader';

const userLoader = new DataLoader<number, User>(async (ids) => {
  const users = await userRepo.findByIds([...ids]);  // 한 번에 조회!
  return ids.map(id => users.find(u => u.id === id));
});

// ❌ 오프셋 페이징 — 대용량에서 느림
async offsetPagination(page: number, limit: number) {
  return this.prisma.post.findMany({
    skip: (page - 1) * limit,  // 100만 번째 페이지: 999,990개를 건너뜀 → 느림!
    take: limit,
  });
}

// ✅ 커서 기반 페이징 — 대용량에 강함 (무한 스크롤)
async cursorPagination(cursor?: number, limit = 10) {
  const posts = await this.prisma.post.findMany({
    take: limit + 1,  // 1개 더 가져와서 다음 페이지 여부 확인
    ...(cursor ? { cursor: { id: cursor }, skip: 1 } : {}),
    orderBy: { id: 'desc' },
  });

  const hasNextPage = posts.length > limit;
  const data = hasNextPage ? posts.slice(0, limit) : posts;
  const nextCursor = hasNextPage ? data[data.length - 1].id : null;

  return { data, nextCursor, hasNextPage };
}

🌐 6장. HTTP 캐시 완전 정복 — Cache-Control 마스터

브라우저·CDN·프록시의 캐시 동작 원리와 설정

🚦 HTTP 캐시 — 우편물 택배 비유

서울에서 부산까지 매번 택배를 보내는 대신, 부산 창고(CDN/브라우저 캐시)에 미리 물건을 보내두면?
→ 부산 사람은 서울까지 가지 않고 가까운 창고에서 즉시 받을 수 있습니다!
HTTP 캐시 = 클라이언트나 중간 서버(CDN)에 응답을 저장해두는 메커니즘

// products.controller.ts — 상황별 캐시 전략

@Controller('products')
export class ProductsController {

  // ✅ 공개 API — CDN 캐시 (1시간)
  @Get()
  @Header('Cache-Control', 'public, max-age=3600, stale-while-revalidate=600')
  findAll() {
    return this.productsService.findAll();
  }

  // ✅ 개인화 데이터 — 브라우저만 캐시 (5분)
  @Get('my-wishlist')
  @UseGuards(JwtAuthGuard)
  @Header('Cache-Control', 'private, max-age=300')
  getMyWishlist(@CurrentUser() user: User) {
    return this.productsService.getWishlist(user.id);
  }

  // ✅ 결제/민감 정보 — 캐시 완전 금지
  @Get('payment-history')
  @Header('Cache-Control', 'no-store')
  getPaymentHistory() {
    return this.paymentsService.getHistory();
  }
}

// ✅ ETag로 조건부 요청 처리 — 변경된 경우만 응답
import { createHash } from 'crypto';

@Get(':id')
async findOne(@Param('id') id: string, @Req() req, @Res() res) {
  const product = await this.productsService.findOne(+id);
  
  // 데이터 해시로 ETag 생성
  const etag = `"${createHash('md5').update(JSON.stringify(product)).digest('hex')}"`;
  
  // 클라이언트 ETag와 비교
  if (req.headers['if-none-match'] === etag) {
    return res.status(304).send();  // 변경 없음 → 데이터 전송 없이 캐시 사용!
  }
  
  res.setHeader('ETag', etag);
  res.setHeader('Cache-Control', 'public, max-age=60');
  return res.json(product);
}

// ✅ Nginx에서 정적 파일 캐시 설정
// nginx.conf
location /static/ {
  alias /app/public/;
  expires 1y;                                      # 1년 캐시
  add_header Cache-Control "public, immutable";    # 변경 없음 보장
  add_header Vary Accept-Encoding;                 # 압축 방식별 캐시
  gzip_static on;                                  # 미리 압축된 .gz 파일 서빙
}

🎯 상황별 Cache-Control 전략 정리

⚙️ 7장. Node.js 성능 튜닝 — 이벤트 루프 최적화

싱글 스레드의 약점을 극복하는 실전 기법

🏪 이벤트 루프란? — 카페 직원 비유

카페 직원 1명(싱글 스레드)이 여러 손님을 응대합니다.
• 손님 A에게 커피 주문받음 → 커피 기계에 올려놓음 (비동기 I/O 시작)
• 기계가 커피 내리는 동안 → 손님 B, C 주문 받기 (다른 요청 처리)
• 커피 완성 신호 옴 → 손님 A에게 제공 (콜백 실행)
핵심: 기다리는 시간에 다른 일을 처리! 하지만 계산이 복잡한 일(CPU 집약)을 하면 다른 손님 모두 기다려야 함!

// ❌ 이벤트 루프 블로킹 — 절대 금지!
@Get('heavy')
badExample() {
  // 동기 파일 읽기 — 이벤트 루프 블로킹!
  const data = fs.readFileSync('./big-file.csv');  // ❌ 블로킹!
  
  // CPU 집약 작업 — 이벤트 루프 블로킹!
  let result = 0;
  for (let i = 0; i < 1000000000; i++) result += i;  // ❌ 수십초 블로킹!
  
  return result;
}

// ✅ Worker Threads — CPU 집약 작업 분리
import { Worker, isMainThread, parentPort } from 'worker_threads';

// worker.js — 별도 스레드에서 실행
if (!isMainThread) {
  const { data } = workerData;
  let result = 0;
  for (let i = 0; i < data; i++) result += i;
  parentPort.postMessage(result);
}

// main.ts — 메인 스레드에서 워커 실행
function runHeavyTask(data: number): Promise<number> {
  return new Promise((resolve, reject) => {
    const worker = new Worker('./worker.js', { workerData: { data } });
    worker.on('message', resolve);
    worker.on('error', reject);
  });
}

@Get('compute')
async heavyCompute() {
  const result = await runHeavyTask(1000000); // 이벤트루프 블로킹 없음!
  return { result };
}

// ✅ Stream으로 대용량 파일 처리
@Get('download-report')
async downloadReport(@Res() res) {
  res.setHeader('Content-Type', 'application/octet-stream');
  res.setHeader('Content-Disposition', 'attachment; filename=report.csv');
  
  // 전체를 메모리에 올리지 않고 스트림으로 전송
  const stream = fs.createReadStream('./reports/big-report.csv');
  stream.pipe(res);  // 메모리 절약!
}

// ✅ 병렬 처리 — Promise.all 활용
async getDashboardData(userId: number) {
  // ❌ 순차 처리: 100ms + 150ms + 80ms = 330ms
  // const user = await getUser(userId);
  // const orders = await getOrders(userId);
  // const notifications = await getNotifications(userId);
  
  // ✅ 병렬 처리: max(100ms, 150ms, 80ms) = 150ms
  const [user, orders, notifications] = await Promise.all([
    getUser(userId),          // 동시 실행!
    getOrders(userId),
    getNotifications(userId),
  ]);
  
  return { user, orders, notifications };
}

🎯 Node.js 성능 최적화 체크리스트

📬 8장. 메시지 큐 — Bull/BullMQ로 비동기 처리

이메일 발송, 이미지 리사이즈, 결제 처리 등 무거운 작업을 백그라운드로

🏭 메시지 큐란? — 맥도날드 주문 시스템 비유

맥도날드에서 주문을 받고 즉시 음식이 나오지 않습니다.
→ 주문(Job)을 큐(Queue)에 쌓아두고 → 주방(Worker)이 순서대로 처리 → 완성되면 알림
메시지 큐 = API가 즉시 응답하되, 무거운 작업(이메일, 영상처리, 결제)은 백그라운드에서 처리

# 설치
npm install @nestjs/bull bull
npm install @types/bull -D
# 또는 최신 BullMQ 사용
npm install @nestjs/bullmq bullmq

// app.module.ts — Bull 모듈 등록
import { BullModule } from '@nestjs/bull';

@Module({
  imports: [
    BullModule.forRoot({
      redis: {
        host: process.env.REDIS_HOST,
        port: +process.env.REDIS_PORT,
        password: process.env.REDIS_PASSWORD,
      },
    }),
    BullModule.registerQueue(
      { name: 'email' },     // 이메일 큐
      { name: 'image' },     // 이미지 처리 큐
      { name: 'notification' }, // 알림 큐
    ),
  ],
})
export class AppModule {}

// email.processor.ts — Job 처리기 (Worker)
import { Process, Processor, OnQueueFailed, OnQueueCompleted } from '@nestjs/bull';
import { Job } from 'bull';

@Processor('email')
export class EmailProcessor {

  @Process('send-welcome')
  async handleWelcomeEmail(job: Job) {
    const { to, name } = job.data;
    // 이메일 발송 로직
    await this.mailerService.sendWelcome(to, name);
    console.log(`✅ 환영 이메일 발송 완료: ${to}`);
  }

  @Process('send-password-reset')
  async handlePasswordReset(job: Job) {
    const { email, resetToken } = job.data;
    await this.mailerService.sendPasswordReset(email, resetToken);
  }

  // 실패 시 자동 재시도 (3번)
  @OnQueueFailed()
  onFailed(job: Job, error: Error) {
    console.error(`❌ Job ${job.id} 실패 (시도: ${job.attemptsMade}/3): ${error.message}`);
  }

  @OnQueueCompleted()
  onCompleted(job: Job) {
    console.log(`✅ Job ${job.id} 완료`);
  }
}

// auth.service.ts — Job 추가 (Producer)
@Injectable()
export class AuthService {
  constructor(
    @InjectQueue('email') private emailQueue: Queue,
  ) {}

  async register(dto: RegisterDto) {
    const user = await this.usersService.create(dto);
    
    // 이메일 발송을 큐에 추가 (즉시 응답 가능!)
    await this.emailQueue.add(
      'send-welcome',
      { to: user.email, name: user.name },
      {
        attempts: 3,              // 실패 시 3번 재시도
        backoff: { type: 'exponential', delay: 1000 }, // 지수 백오프
        removeOnComplete: 100,  // 완료된 job 100개만 유지
        removeOnFail: 50,       // 실패한 job 50개만 유지
      }
    );
    
    return { message: '회원가입 완료! 이메일을 확인하세요.' }; // 즉시 응답!
  }
}

// ✅ 정기 스케줄링 (Cron Job)
@Processor('email')
export class EmailProcessor {
  @Cron('0 9 * * *')  // 매일 오전 9시
  async sendDailyDigest() {
    const users = await this.usersService.getSubscribers();
    for (const user of users) {
      await this.emailQueue.add('daily-digest', { userId: user.id });
    }
  }
}

📊 메시지 큐 사용 케이스

📊 9장. 부하 테스트 — k6 + Artillery 성능 측정

실제 배포 전에 서버 한계를 파악하는 방법

🏋️ 부하 테스트란? — 다리 내하중 검사 비유

다리를 만들면 실제 개통 전에 얼마나 많은 차가 지나가도 버티는지 테스트합니다.
부하 테스트 = 가상 사용자 수천 명이 동시에 접속할 때 서버가 버티는지 확인
→ API 응답 시간, 에러율, 최대 처리량(TPS)을 측정하여 배포 전에 문제를 발견!

# k6 설치
brew install k6          # macOS
# 또는 Docker 사용
docker run --rm -i grafana/k6 run - < test.js

// load-test.js — 종합 부하 테스트 스크립트
import http from 'k6/http';
import { check, sleep } from 'k6';
import { Rate, Trend } from 'k6/metrics';

const errorRate = new Rate('errors');
const loginDuration = new Trend('login_duration');

export const options = {
  stages: [
    { duration: '30s', target: 10 },   // 30초 동안 10명까지 증가
    { duration: '1m', target: 100 },   // 1분 동안 100명 유지 (일반 부하)
    { duration: '30s', target: 500 },  // 30초 동안 500명 (스파이크)
    { duration: '1m', target: 100 },   // 1분 동안 100명 (회복)
    { duration: '30s', target: 0 },    // 30초 동안 0명 (종료)
  ],
  thresholds: {
    http_req_duration: ['p(95)<500'],  // 95%의 요청이 500ms 이하
    errors: ['rate<0.01'],          // 에러율 1% 미만
    http_req_failed: ['rate<0.05'],   // 실패율 5% 미만
  },
};

export default function () {
  const baseUrl = 'http://localhost:3000';
  
  // 1. 제품 목록 조회
  const listRes = http.get(`${baseUrl}/api/products`);
  check(listRes, {
    'status 200': (r) => r.status === 200,
    '응답 500ms 이하': (r) => r.timings.duration < 500,
  });
  errorRate.add(listRes.status !== 200);
  
  sleep(1);  // 1초 대기 (실제 사용자 패턴)
  
  // 2. 로그인 API 테스트
  const loginStart = Date.now();
  const loginRes = http.post(
    `${baseUrl}/api/auth/login`,
    JSON.stringify({ email: 'test@test.com', password: 'password123' }),
    { headers: { 'Content-Type': 'application/json' } }
  );
  loginDuration.add(Date.now() - loginStart);
  
  const token = JSON.parse(loginRes.body).accessToken;
  
  // 3. 인증 필요한 API 테스트
  http.get(`${baseUrl}/api/users/me`, {
    headers: { 'Authorization': `Bearer ${token}` }
  });
  
  sleep(2);
}

# 실행 및 결과 확인
k6 run load-test.js

# 결과 예시:
# ✓ http_req_duration............: avg=87ms  min=12ms  p(90)=210ms  p(95)=320ms
# ✓ http_req_failed...............: 0.00%
# ✓ errors........................: 0.00%
# ✓ iterations....................: 3,240/s

📈 성능 결과 해석 방법

🔧 10장. Redis 고급 패턴 — 세션, 분산 락, Pub/Sub

Redis를 단순 캐시 이상으로 활용하는 실전 패턴

// auth.service.ts — JWT + Redis 세션 패턴
@Injectable()
export class AuthService {
  constructor(
    @Inject(CACHE_MANAGER) private cache: Cache,
    private jwtService: JwtService,
  ) {}

  async login(user: User) {
    const payload = { sub: user.id, email: user.email, role: user.role };
    const accessToken = this.jwtService.sign(payload, { expiresIn: '1h' });
    const refreshToken = this.jwtService.sign({ sub: user.id }, { expiresIn: '7d' });
    
    // Refresh Token을 Redis에 저장 (7일 만료)
    await this.cache.set(
      `refresh:${user.id}`,
      refreshToken,
      7 * 24 * 60 * 60  // 7일
    );
    
    return { accessToken, refreshToken };
  }

  // 로그아웃 — Access Token 블랙리스트에 추가
  async logout(userId: number, accessToken: string) {
    // Access Token 남은 유효 시간 계산
    const decoded = this.jwtService.decode(accessToken) as any;
    const ttl = decoded.exp - Math.floor(Date.now() / 1000);
    
    if (ttl > 0) {
      // 남은 시간 동안 블랙리스트에 등록
      await this.cache.set(`blacklist:${accessToken}`, 1, ttl);
    }
    
    // Refresh Token 삭제
    await this.cache.del(`refresh:${userId}`);
    
    return { message: '로그아웃 완료' };
  }

  // JWT Guard에서 블랙리스트 확인
  async isTokenBlacklisted(token: string): Promise<boolean> {
    const blacklisted = await this.cache.get(`blacklist:${token}`);
    return !!blacklisted;
  }
}

// ✅ 분산 락 (Distributed Lock) — 동시 주문 처리 문제 해결
import Redlock from 'redlock';

@Injectable()
export class OrderService {
  private redlock: Redlock;
  
  constructor(private redis: Redis) {
    this.redlock = new Redlock([redis], { retryCount: 3, retryDelay: 200 });
  }

  async processOrder(productId: number, quantity: number) {
    const lockKey = `lock:product:${productId}`;
    
    // 분산 락 획득 (5초 TTL)
    const lock = await this.redlock.acquire([lockKey], 5000);
    
    try {
      // 재고 확인 및 차감 (동시에 여러 요청이 와도 안전!)
      const product = await this.productRepo.findOne(productId);
      if (product.stock < quantity) throw new Error('재고 부족');
      
      await this.productRepo.update(productId, {
        stock: product.stock - quantity
      });
      
      return await this.orderRepo.create({ productId, quantity });
    } finally {
      await lock.release();  // 반드시 락 해제!
    }
  }
}

// ✅ Redis Pub/Sub — 실시간 알림
@Injectable()
export class NotificationService {
  constructor(private redisPublisher: Redis, private redisSubscriber: Redis) {
    // 채널 구독
    this.redisSubscriber.subscribe('order-updates');
    this.redisSubscriber.on('message', (channel, message) => {
      console.log(`📨 ${channel}: ${message}`);
      this.broadcastToWebSocket(message);
    });
  }

  async publishOrderUpdate(orderId: number, status: string) {
    await this.redisPublisher.publish(
      'order-updates',
      JSON.stringify({ orderId, status, timestamp: Date.now() })
    );
  }
}

💡 Redis 실전 패턴 요약

🎯 11장. 면접 Q&A + 실전 체크리스트 + 로드맵

현업 개발자가 묻는 진짜 질문들과 완벽한 대답