🎯 왜 CORS는 우리를 괴롭힐까?

안녕! 혹시 웹 개발하다가 콘솔창에 빨간 글씨로 "Access to fetch at... has been blocked by CORS policy"라는 무시무시한 에러 메시지 본 적 있지? 😱 처음 보는 순간 정말 당황스럽지. 분명 코드는 제대로 짰는데, API 호출만 하면 막히는 이 상황!

사실 CORS(Cross-Origin Resource Sharing) 문제는 웹 개발자라면 누구나 한 번쯤 마주치는 통과의례 같은 거야. 특히 프론트엔드 개발을 하다 보면 외부 API를 호출할 일이 정말 많은데, 이때마다 CORS 에러가 튀어나와서 개발 진행을 막아버리거든. 😤

오늘은 이 골치 아픈 CORS 문제를 JavaScript 프록시 서버로 깔끔하게 해결하는 방법을 친구처럼 편하게 알려줄게! 재능넷에서 웹 개발 관련 재능을 공유하거나 배우려는 분들에게도 정말 유용한 내용이 될 거야. 💪

🤔 CORS가 정확히 뭘까?

CORS를 이해하려면 먼저 동일 출처 정책(Same-Origin Policy)을 알아야 해. 이건 웹 브라우저의 보안 메커니즘인데, 쉽게 말하면 "다른 출처의 리소스는 함부로 가져오지 마!"라는 규칙이야. 🛡️

여기서 '출처(Origin)'는 프로토콜, 도메인, 포트 번호의 조합을 말해. 예를 들어볼게:

브라우저는 기본적으로 다른 출처로의 요청을 차단해. 왜냐하면 악의적인 웹사이트가 사용자 몰래 다른 사이트의 데이터를 훔쳐갈 수 있거든. 이게 바로 보안을 위한 조치야! 🔒

하지만 현대 웹 개발에서는 다른 출처의 API를 호출하는 게 너무나 당연한 일이잖아? 그래서 등장한 게 CORS라는 메커니즘이야. 서버가 "이 출처에서 오는 요청은 괜찮아!"라고 명시적으로 허락해주는 방식이지.

🛠️ CORS 해결 방법들 총정리

CORS 문제를 해결하는 방법은 여러 가지가 있어. 상황에 따라 적절한 방법을 선택하면 돼! 각각의 장단점을 살펴보자. 🎯

이 중에서 오늘 우리가 집중할 건 바로 프록시 서버 방식이야! 왜냐하면:

방법 2: 직접 fetch로 프록시 구현하기

http-proxy-middleware 없이 직접 구현할 수도 있어. 더 세밀한 제어가 필요할 때 유용하지! 🎨

// simple-proxy.js
const express = require('express');
const cors = require('cors');
const fetch = require('node-fetch'); // Node.js 18 미만에서는 설치 필요

const app = express();
const PORT = 5000;

app.use(cors());
app.use(express.json()); // JSON 파싱

// GET 요청 프록시
app.get('/api/*', async (req, res) => {
  try {
    // 원본 경로에서 /api 제거
    const targetPath = req.path.replace('/api', '');
    const targetUrl = `https://api.example.com${targetPath}`;
    
    // 쿼리 파라미터 포함
    const queryString = new URLSearchParams(req.query).toString();
    const fullUrl = queryString ? `${targetUrl}?${queryString}` : targetUrl;
    
    console.log(`📡 요청 전달: ${fullUrl}`);
    
    // 외부 API 호출
    const response = await fetch(fullUrl, {
      method: 'GET',
      headers: {
        'Content-Type': 'application/json',
        // 필요한 경우 인증 헤더 추가
        // 'Authorization': 'Bearer YOUR_API_KEY'
      }
    });
    
    const data = await response.json();
    
    // 클라이언트에 응답
    res.status(response.status).json(data);
    
  } catch (error) {
    console.error('❌ 프록시 에러:', error);
    res.status(500).json({ 
      error: '서버 에러가 발생했습니다',
      message: error.message 
    });
  }
});

// POST 요청 프록시
app.post('/api/*', async (req, res) => {
  try {
    const targetPath = req.path.replace('/api', '');
    const targetUrl = `https://api.example.com${targetPath}`;
    
    console.log(`📤 POST 요청 전달: ${targetUrl}`);
    console.log('📦 요청 본문:', req.body);
    
    const response = await fetch(targetUrl, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      body: JSON.stringify(req.body)
    });
    
    const data = await response.json();
    res.status(response.status).json(data);
    
  } catch (error) {
    console.error('❌ 프록시 에러:', error);
    res.status(500).json({ 
      error: '서버 에러가 발생했습니다',
      message: error.message 
    });
  }
});

app.listen(PORT, () => {
  console.log(`🚀 커스텀 프록시 서버 실행 중: http://localhost:${PORT}`);
});

이 방법의 장점은 요청/응답을 완전히 제어할 수 있다는 거야. 예를 들어:

const data = await response.json();

// 데이터 가공 예시
const processedData = {
  ...data,
  timestamp: new Date().toISOString(),
  source: 'proxy-server'
};

res.json(processedData);

// 환경 변수에서 API 키 가져오기
const API_KEY = process.env.API_KEY;

const response = await fetch(targetUrl, {
  headers: {
    'Authorization': `Bearer ${API_KEY}`,
    'Content-Type': 'application/json'
  }
});

// 클라이언트는 API 키를 모르는 상태로 사용 가능!

🎨 실전 프록시 서버 고급 기능

기본적인 프록시는 만들었으니, 이제 실무에서 유용한 고급 기능들을 추가해보자! 재능넷에서 웹 개발 프로젝트를 진행할 때도 이런 기능들이 정말 유용할 거야. 💪

1️⃣ 캐싱 기능 추가하기

같은 요청을 반복하면 매번 외부 API를 호출하는 건 비효율적이야. 캐싱을 추가해서 성능을 높여보자! ⚡

// cache-proxy.js
const express = require('express');
const { createProxyMiddleware } = require('http-proxy-middleware');
const cors = require('cors');
const NodeCache = require('node-cache'); // npm install node-cache

const app = express();
const PORT = 5000;

// 캐시 설정 (TTL: 5분)
const cache = new NodeCache({ stdTTL: 300 });

app.use(cors());

// 캐시 미들웨어
const cacheMiddleware = (req, res, next) => {
  // GET 요청만 캐싱
  if (req.method !== 'GET') {
    return next();
  }
  
  const key = req.originalUrl;
  const cachedResponse = cache.get(key);
  
  if (cachedResponse) {
    console.log(`✅ 캐시 히트: ${key}`);
    return res.json(cachedResponse);
  }
  
  console.log(`❌ 캐시 미스: ${key}`);
  
  // 원래 res.json을 저장
  const originalJson = res.json.bind(res);
  
  // res.json을 오버라이드해서 캐시에 저장
  res.json = (data) => {
    cache.set(key, data);
    console.log(`💾 캐시 저장: ${key}`);
    return originalJson(data);
  };
  
  next();
};

// 캐시 미들웨어 적용
app.use('/api', cacheMiddleware);

// 프록시 설정
app.use('/api', createProxyMiddleware({
  target: 'https://api.example.com',
  changeOrigin: true,
  pathRewrite: { '^/api': '' }
}));

// 캐시 초기화 엔드포인트
app.delete('/cache', (req, res) => {
  cache.flushAll();
  res.json({ message: '캐시가 모두 삭제되었습니다' });
});

// 캐시 상태 확인
app.get('/cache/stats', (req, res) => {
  const stats = cache.getStats();
  res.json({
    keys: cache.keys().length,
    hits: stats.hits,
    misses: stats.misses,
    hitRate: stats.hits / (stats.hits + stats.misses)
  });
});

app.listen(PORT, () => {
  console.log(`🚀 캐싱 프록시 서버 실행 중: ${PORT}`);
});

2️⃣ Rate Limiting (요청 제한)

외부 API가 요청 횟수 제한이 있다면? 프록시 서버에서 미리 제어할 수 있어! 🚦

// rate-limit-proxy.js
const express = require('express');
const rateLimit = require('express-rate-limit'); // npm install express-rate-limit
const { createProxyMiddleware } = require('http-proxy-middleware');

const app = express();

// Rate Limiter 설정
const limiter = rateLimit({
  windowMs: 15 * 60 * 1000, // 15분
  max: 100, // 최대 100개 요청
  message: {
    error: '너무 많은 요청을 보냈습니다. 잠시 후 다시 시도해주세요.',
    retryAfter: '15분'
  },
  standardHeaders: true, // RateLimit-* 헤더 추가
  legacyHeaders: false,
  handler: (req, res) => {
    console.log(`⚠️ Rate limit 초과: ${req.ip}`);
    res.status(429).json({
      error: '요청 한도를 초과했습니다',
      message: '15분 후에 다시 시도해주세요'
    });
  }
});

// 특정 경로에만 적용
app.use('/api', limiter);

// 프록시 설정
app.use('/api', createProxyMiddleware({
  target: 'https://api.example.com',
  changeOrigin: true
}));

app.listen(5000, () => {
  console.log('🚀 Rate Limiting 프록시 서버 실행 중');
});

3️⃣ 인증 & 보안 강화

API 키를 클라이언트에 노출하지 않고 서버에서 관리하는 방법! 🔐

// secure-proxy.js
const express = require('express');
const { createProxyMiddleware } = require('http-proxy-middleware');
require('dotenv').config(); // npm install dotenv

const app = express();

// 환경 변수에서 API 키 로드
const API_KEY = process.env.EXTERNAL_API_KEY;
const ALLOWED_ORIGINS = process.env.ALLOWED_ORIGINS?.split(',') || [];

// CORS 설정 (특정 출처만 허용)
app.use((req, res, next) => {
  const origin = req.headers.origin;
  
  if (ALLOWED_ORIGINS.includes(origin)) {
    res.setHeader('Access-Control-Allow-Origin', origin);
    res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE');
    res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization');
  }
  
  if (req.method === 'OPTIONS') {
    return res.sendStatus(200);
  }
  
  next();
});

// 간단한 인증 미들웨어
const authenticate = (req, res, next) => {
  const token = req.headers.authorization?.split(' ')[1];
  
  // 실제로는 JWT 검증 등을 수행
  if (!token || token !== process.env.CLIENT_TOKEN) {
    return res.status(401).json({ error: '인증이 필요합니다' });
  }
  
  next();
};

// 인증 적용
app.use('/api', authenticate);

// 프록시 설정 (API 키 자동 추가)
app.use('/api', createProxyMiddleware({
  target: 'https://api.example.com',
  changeOrigin: true,
  onProxyReq: (proxyReq, req, res) => {
    // 모든 요청에 API 키 자동 추가
    proxyReq.setHeader('X-API-Key', API_KEY);
    console.log('🔑 API 키 자동 추가됨');
  }
}));

app.listen(5000);

.env 파일 예시:

# .env
EXTERNAL_API_KEY=your_secret_api_key_here
CLIENT_TOKEN=your_client_token_here
ALLOWED_ORIGINS=http://localhost:3000,https://yourdomain.com

4️⃣ 로깅 & 모니터링

모든 요청을 기록하고 분석할 수 있게 만들어보자! 📊

// logging-proxy.js
const express = require('express');
const { createProxyMiddleware } = require('http-proxy-middleware');
const morgan = require('morgan'); // npm install morgan
const fs = require('fs');
const path = require('path');

const app = express();

// 로그 디렉토리 생성
const logDirectory = path.join(__dirname, 'logs');
if (!fs.existsSync(logDirectory)) {
  fs.mkdirSync(logDirectory);
}

// 로그 파일 스트림
const accessLogStream = fs.createWriteStream(
  path.join(logDirectory, 'access.log'),
  { flags: 'a' }
);

// Morgan 로깅 설정
app.use(morgan('combined', { stream: accessLogStream }));
app.use(morgan('dev')); // 콘솔에도 출력

// 커스텀 로깅 미들웨어
app.use((req, res, next) => {
  const start = Date.now();
  
  res.on('finish', () => {
    const duration = Date.now() - start;
    const log = {
      timestamp: new Date().toISOString(),
      method: req.method,
      url: req.originalUrl,
      status: res.statusCode,
      duration: `${duration}ms`,
      ip: req.ip,
      userAgent: req.get('user-agent')
    };
    
    console.log('📝 요청 로그:', JSON.stringify(log));
    
    // 파일에 JSON 형식으로 저장
    fs.appendFileSync(
      path.join(logDirectory, 'requests.json'),
      JSON.stringify(log) + '\n'
    );
  });
  
  next();
});

// 프록시 설정
app.use('/api', createProxyMiddleware({
  target: 'https://api.example.com',
  changeOrigin: true,
  onProxyReq: (proxyReq, req, res) => {
    console.log(`➡️  프록시 요청: ${req.method} ${req.path}`);
  },
  onProxyRes: (proxyRes, req, res) => {
    console.log(`⬅️  프록시 응답: ${proxyRes.statusCode}`);
  },
  onError: (err, req, res) => {
    console.error('❌ 프록시 에러:', err.message);
    
    // 에러 로그 저장
    const errorLog = {
      timestamp: new Date().toISOString(),
      error: err.message,
      url: req.originalUrl,
      method: req.method
    };
    
    fs.appendFileSync(
      path.join(logDirectory, 'errors.json'),
      JSON.stringify(errorLog) + '\n'
    );
  }
}));

// 로그 조회 API
app.get('/logs/recent', (req, res) => {
  const logs = fs.readFileSync(
    path.join(logDirectory, 'requests.json'),
    'utf-8'
  )
    .split('\n')
    .filter(line => line)
    .map(line => JSON.parse(line))
    .slice(-50); // 최근 50개
  
  res.json(logs);
});

app.listen(5000);

🌐 실전 배포: 프록시 서버 운영하기

개발 환경에서는 잘 작동하는데, 실제 배포는 어떻게 할까? 프로덕션 환경에서 프록시 서버를 안정적으로 운영하는 방법을 알아보자! 🚀

배포 옵션 비교

Heroku에 배포하기 (가장 쉬운 방법)

Heroku는 정말 간단해! Git push만 하면 자동으로 배포돼. 😎

{
  "name": "cors-proxy-server",
  "version": "1.0.0",
  "main": "server.js",
  "scripts": {
    "start": "node server.js"
  },
  "engines": {
    "node": "18.x"  // Node.js 버전 명시
  },
  "dependencies": {
    "express": "^4.18.0",
    "http-proxy-middleware": "^2.0.0",
    "cors": "^2.8.5"
  }
}

web: node server.js

// server.js
const PORT = process.env.PORT || 5000;  // Heroku가 포트를 자동 할당

app.listen(PORT, () => {
  console.log(`Server running on port ${PORT}`);
});

# Heroku CLI 설치 후
heroku login
heroku create my-cors-proxy
git push heroku main

# 환경 변수 설정
heroku config:set API_KEY=your_api_key_here

Vercel Serverless Functions 사용하기

Vercel은 서버리스 방식으로 프록시를 구현할 수 있어. 트래픽이 적을 때 비용 효율적이야! 💰

// api/proxy.js (Vercel Functions)
const fetch = require('node-fetch');

module.exports = async (req, res) => {
  // CORS 헤더 설정
  res.setHeader('Access-Control-Allow-Origin', '*');
  res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE');
  
  if (req.method === 'OPTIONS') {
    return res.status(200).end();
  }
  
  try {
    // 쿼리 파라미터에서 타겟 URL 가져오기
    const { url } = req.query;
    
    if (!url) {
      return res.status(400).json({ error: 'URL 파라미터가 필요합니다' });
    }
    
    // 외부 API 호출
    const response = await fetch(url, {
      method: req.method,
      headers: {
        'Content-Type': 'application/json',
        'Authorization': `Bearer ${process.env.API_KEY}`
      },
      body: req.method !== 'GET' ? JSON.stringify(req.body) : undefined
    });
    
    const data = await response.json();
    res.status(response.status).json(data);
    
  } catch (error) {
    console.error('Proxy error:', error);
    res.status(500).json({ error: error.message });
  }
};

클라이언트에서 사용:

// 클라이언트 코드
const targetUrl = encodeURIComponent('https://api.example.com/users');
fetch(`https://your-app.vercel.app/api/proxy?url=${targetUrl}`)
  .then(res => res.json())
  .then(data => console.log(data));

Docker로 컨테이너화하기

Docker를 사용하면 어디서든 동일하게 실행할 수 있어! 🐳

# Dockerfile
FROM node:18-alpine

WORKDIR /app

# 의존성 파일 복사
COPY package*.json ./

# 의존성 설치
RUN npm ci --only=production

# 소스 코드 복사
COPY . .

# 포트 노출
EXPOSE 5000

# 헬스체크 추가
HEALTHCHECK --interval=30s --timeout=3s \
  CMD node healthcheck.js || exit 1

# 실행
CMD ["node", "server.js"]

# docker-compose.yml
version: '3.8'

services:
  proxy:
    build: .
    ports:
      - "5000:5000"
    environment:
      - NODE_ENV=production
      - API_KEY=${API_KEY}
    restart: unless-stopped
    volumes:
      - ./logs:/app/logs
    networks:
      - proxy-network

networks:
  proxy-network:
    driver: bridge

실행 방법:

# 이미지 빌드
docker build -t cors-proxy .

# 컨테이너 실행
docker run -p 5000:5000 -e API_KEY=your_key cors-proxy

# 또는 docker-compose 사용
docker-compose up -d

PM2로 프로세스 관리하기

서버가 죽으면 자동으로 재시작되게 만들자! PM2는 Node.js 프로세스 매니저의 표준이야. 🔄

# PM2 설치
npm install -g pm2

# 서버 시작
pm2 start server.js --name "cors-proxy"

# 클러스터 모드 (멀티 코어 활용)
pm2 start server.js -i max --name "cors-proxy"

# 자동 재시작 설정
pm2 startup
pm2 save

# 모니터링
pm2 monit

# 로그 확인
pm2 logs cors-proxy

ecosystem.config.js 파일로 설정 관리:

// ecosystem.config.js
module.exports = {
  apps: [{
    name: 'cors-proxy',
    script: './server.js',
    instances: 'max',  // CPU 코어 수만큼 인스턴스 생성
    exec_mode: 'cluster',
    env: {
      NODE_ENV: 'production',
      PORT: 5000
    },
    error_file: './logs/err.log',
    out_file: './logs/out.log',
    log_date_format: 'YYYY-MM-DD HH:mm:ss',
    max_memory_restart: '500M',  // 메모리 500MB 초과 시 재시작
    watch: false,  // 프로덕션에서는 watch 비활성화
    ignore_watch: ['node_modules', 'logs'],
    max_restarts: 10,
    min_uptime: '10s'
  }]
};

# ecosystem 파일로 실행
pm2 start ecosystem.config.js

🎓 실전 예제: 완전한 프록시 서버

지금까지 배운 모든 내용을 종합한 완전한 프록시 서버 코드야! 실무에서 바로 사용할 수 있어. 💼

// production-proxy-server.js
const express = require('express');
const { createProxyMiddleware } = require('http-proxy-middleware');
const cors = require('cors');
const helmet = require('helmet');  // 보안 헤더
const compression = require('compression');
const rateLimit = require('express-rate-limit');
const morgan = require('morgan');
const NodeCache = require('node-cache');
require('dotenv').config();

const app = express();
const PORT = process.env.PORT || 5000;

// ==================== 보안 설정 ====================
app.use(helmet());  // 보안 헤더 자동 설정

// CORS 설정
const allowedOrigins = process.env.ALLOWED_ORIGINS?.split(',') || ['http://localhost:3000'];
app.use(cors({
  origin: (origin, callback) => {
    if (!origin || allowedOrigins.includes(origin)) {
      callback(null, true);
    } else {
      callback(new Error('CORS 정책에 의해 차단되었습니다'));
    }
  },
  credentials: true
}));

// ==================== 미들웨어 설정 ====================
app.use(compression());  // 응답 압축
app.use(express.json({ limit: '10mb' }));
app.use(express.urlencoded({ extended: true, limit: '10mb' }));
app.use(morgan('combined'));  // 로깅

// ==================== Rate Limiting ====================
const limiter = rateLimit({
  windowMs: 15 * 60 * 1000,  // 15분
  max: 100,  // 최대 100개 요청
  message: { error: '너무 많은 요청입니다. 잠시 후 다시 시도해주세요.' }
});
app.use('/api', limiter);

// ==================== 캐싱 설정 ====================
const cache = new NodeCache({ 
  stdTTL: 300,  // 5분
  checkperiod: 60 
});

const cacheMiddleware = (req, res, next) => {
  if (req.method !== 'GET') return next();
  
  const key = req.originalUrl;
  const cachedData = cache.get(key);
  
  if (cachedData) {
    console.log(`✅ 캐시 히트: ${key}`);
    return res.json(cachedData);
  }
  
  const originalJson = res.json.bind(res);
  res.json = (data) => {
    cache.set(key, data);
    return originalJson(data);
  };
  
  next();
};

// ==================== 헬스체크 ====================
app.get('/health', (req, res) => {
  res.json({
    status: 'healthy',
    uptime: process.uptime(),
    timestamp: new Date().toISOString(),
    cache: {
      keys: cache.keys().length,
      stats: cache.getStats()
    }
  });
});

// ==================== 캐시 관리 API ====================
app.delete('/cache', (req, res) => {
  const authHeader = req.headers.authorization;
  if (authHeader !== `Bearer ${process.env.ADMIN_TOKEN}`) {
    return res.status(401).json({ error: '권한이 없습니다' });
  }
  
  cache.flushAll();
  res.json({ message: '캐시가 초기화되었습니다' });
});

// ==================== 프록시 설정 ====================
app.use('/api', 
  cacheMiddleware,  // 캐싱 적용
  createProxyMiddleware({
    target: process.env.API_TARGET || 'https://api.example.com',
    changeOrigin: true,
    pathRewrite: { '^/api': '' },
    timeout: 30000,
    proxyTimeout: 30000,
    
    // 요청 전 처리
    onProxyReq: (proxyReq, req, res) => {
      // API 키 자동 추가
      if (process.env.API_KEY) {
        proxyReq.setHeader('Authorization', `Bearer ${process.env.API_KEY}`);
      }
      
      console.log(`➡️  ${req.method} ${req.path}`);
    },
    
    // 응답 후 처리
    onProxyRes: (proxyRes, req, res) => {
      console.log(`⬅️  ${proxyRes.statusCode} ${req.path}`);
    },
    
    // 에러 처리
    onError: (err, req, res) => {
      console.error('❌ 프록시 에러:', err.message);
      res.status(502).json({
        error: '외부 API 호출 실패',
        message: err.message,
        timestamp: new Date().toISOString()
      });
    }
  })
);

// ==================== 404 처리 ====================
app.use((req, res) => {
  res.status(404).json({
    error: '요청한 엔드포인트를 찾을 수 없습니다',
    path: req.path
  });
});

// ==================== 에러 핸들러 ====================
app.use((err, req, res, next) => {
  console.error('서버 에러:', err);
  res.status(500).json({
    error: '서버 내부 오류',
    message: process.env.NODE_ENV === 'development' ? err.message : undefined
  });
});

// ==================== 서버 시작 ====================
const server = app.listen(PORT, () => {
  console.log(`
🚀 프록시 서버가 시작되었습니다!
📍 포트: ${PORT}
🌍 환경: ${process.env.NODE_ENV || 'development'}
🎯 타겟: ${process.env.API_TARGET || 'https://api.example.com'}
  `);
});

// ==================== Graceful Shutdown ====================
process.on('SIGTERM', () => {
  console.log('SIGTERM 신호 수신, 서버 종료 중...');
  server.close(() => {
    console.log('서버가 정상적으로 종료되었습니다');
    process.exit(0);
  });
});

process.on('SIGINT', () => {
  console.log('SIGINT 신호 수신, 서버 종료 중...');
  server.close(() => {
    console.log('서버가 정상적으로 종료되었습니다');
    process.exit(0);
  });
});

module.exports = app;  // 테스트를 위해 export

환경 변수 설정 (.env):

# .env
NODE_ENV=production
PORT=5000
API_TARGET=https://api.example.com
API_KEY=your_secret_api_key_here
ADMIN_TOKEN=your_admin_token_here
ALLOWED_ORIGINS=https://yourdomain.com,https://www.yourdomain.com

🧪 테스트 코드 작성하기

프록시 서버도 테스트가 필요해! Jest와 Supertest로 테스트를 작성해보자. 🧪

// proxy-server.test.js
const request = require('supertest');
const app = require('./production-proxy-server');

describe('프록시 서버 테스트', () => {
  
  test('헬스체크 엔드포인트', async () => {
    const response = await request(app).get('/health');
    
    expect(response.status).toBe(200);
    expect(response.body).toHaveProperty('status', 'healthy');
    expect(response.body).toHaveProperty('uptime');
  });
  
  test('존재하지 않는 경로 404', async () => {
    const response = await request(app).get('/nonexistent');
    
    expect(response.status).toBe(404);
    expect(response.body).toHaveProperty('error');
  });
  
  test('Rate Limiting 테스트', async () => {
    // 100번 이상 요청
    const requests = Array(101).fill().map(() => 
      request(app).get('/api/test')
    );
    
    const responses = await Promise.all(requests);
    const tooManyRequests = responses.filter(r => r.status === 429);
    
    expect(tooManyRequests.length).toBeGreaterThan(0);
  });
  
  test('캐싱 동작 확인', async () => {
    const path = '/api/users';
    
    // 첫 번째 요청
    const response1 = await request(app).get(path);
    
    // 두 번째 요청 (캐시에서 가져와야 함)
    const response2 = await request(app).get(path);
    
    expect(response1.body).toEqual(response2.body);
  });
  
});

🔐 보안 강화 추가 팁

프록시 서버의 보안을 더욱 강화하는 방법들이야! 🛡️

const jwt = require('jsonwebtoken');

const verifyToken = (req, res, next) => {
  const token = req.headers.authorization?.split(' ')[1];
  
  if (!token) {
    return res.status(401).json({ error: '토큰이 필요합니다' });
  }
  
  try {
    const decoded = jwt.verify(token, process.env.JWT_SECRET);
    req.user = decoded;
    next();
  } catch (error) {
    res.status(401).json({ error: '유효하지 않은 토큰' });
  }
};

app.use('/api', verifyToken);

const allowedIPs = process.env.ALLOWED_IPS?.split(',') || [];

const ipFilter = (req, res, next) => {
  const clientIP = req.ip || req.connection.remoteAddress;
  
  if (!allowedIPs.includes(clientIP)) {
    console.log(`차단된 IP: ${clientIP}`);
    return res.status(403).json({ error: '접근 거부' });
  }
  
  next();
};

app.use('/api', ipFilter);

const validateApiKey = (req, res, next) => {
  const apiKey = req.headers['x-api-key'];
  
  if (!apiKey || apiKey !== process.env.CLIENT_API_KEY) {
    return res.status(401).json({ error: 'API 키가 유효하지 않습니다' });
  }
  
  next();
};

app.use('/api', validateApiKey);

const xss = require('xss-clean');
const mongoSanitize = require('express-mongo-sanitize');

app.use(xss());  // XSS 공격 방지
app.use(mongoSanitize());  // NoSQL Injection 방지