🎯 왜 갑자기 서버가 다운될까?

친구야, 상상해봐. 너가 열심히 만든 쇼핑몰이 드디어 대박이 났어! 🎉
인플루언서가 SNS에 올려줬고, 주문이 폭주하기 시작했지.
근데 갑자기... "502 Bad Gateway" 에러가 뜬다면? 😱

이건 단순히 서버 성능만의 문제가 아니야.
트래픽 급증 상황에서 시스템이 자동으로 대응하지 못하면 어떤 고성능 서버도 무용지물이 되거든.

이 글에서는 쇼핑몰 개발자라면 반드시 알아야 할 트래픽 대응 전략을 친구처럼 쉽게 설명해줄게.
재능넷 같은 플랫폼에서 개발 재능을 공유할 때도 이런 지식은 정말 중요하거든! 💼

🔍 오토스케일링이 뭐길래?

오토스케일링(Auto Scaling)은 말 그대로 자동으로 규모를 조절하는 거야.
트래픽이 늘어나면 서버를 자동으로 추가하고, 줄어들면 다시 줄이는 똑똑한 시스템이지. 🧠

📌 오토스케일링의 핵심 개념

⚙️ 오토스케일링 작동 원리

자, 이제 실제로 어떻게 작동하는지 알아볼까? 🤔

1단계: 모니터링 📊
시스템이 계속해서 서버 상태를 체크해.
CPU 사용률, 메모리 사용량, 네트워크 트래픽, 응답 시간 등을 실시간으로 감시하지.

2단계: 임계값 도달 🚨
예를 들어 "CPU 사용률이 70% 이상이 5분간 지속되면"이라는 조건을 설정했다고 해봐.
실제로 CPU가 75%로 올라가고 5분이 지나면? 알람이 울려!

3단계: 스케일링 실행 🚀
자동으로 새 서버가 생성돼.
AWS라면 EC2 인스턴스가, Azure라면 VM이 자동으로 띄워지는 거지.
보통 1~3분 정도면 새 서버가 준비돼.

4단계: 로드밸런서 연결 🔗
새로 생긴 서버가 자동으로 로드밸런서에 등록돼.
그러면 트래픽이 새 서버로도 분산되기 시작해!

5단계: 안정화 및 모니터링 ✅
시스템이 안정되면 다시 모니터링 모드로 돌아가.
트래픽이 줄면 반대로 서버를 줄이는 과정이 진행되지.

📈 스케일링 정책 종류

⚖️ 로드밸런싱: 트래픽의 교통정리

오토스케일링으로 서버를 10대 늘렸다고 해보자.
그런데 사용자들이 어떻게 이 10대 서버에 골고루 접속할까? 🤷‍♂️
바로 여기서 로드밸런서(Load Balancer)가 필요해!

로드밸런서는 일종의 교통경찰이야. 🚦
들어오는 트래픽을 보고 "너는 1번 서버로, 너는 2번 서버로" 하면서 분산시켜주지.

🎯 로드밸런싱의 핵심 역할

1. 트래픽 분산 🌊
한 서버에 부하가 몰리지 않도록 여러 서버로 고르게 분배해.
10,000명의 사용자가 접속하면 서버 10대에 각각 1,000명씩 배분하는 식이지.

2. 고가용성 보장 🛡️
서버 한 대가 죽어도 다른 서버로 자동 전환돼.
사용자는 서버 장애를 전혀 느끼지 못해! 이게 진짜 중요한 거야.

3. 헬스체크 수행 💓
각 서버가 정상인지 계속 확인해.
응답이 없거나 에러가 나는 서버는 자동으로 제외시키지.

4. SSL/TLS 처리 🔐
HTTPS 암호화 작업을 로드밸런서가 대신 처리해줘.
각 서버의 부담을 줄여주는 거야!

🔄 로드밸런싱 알고리즘

로드밸런서가 트래픽을 분산하는 방법은 여러 가지야.
쇼핑몰 특성에 맞는 알고리즘을 선택하는 게 중요해! 🎲

🏗️ 로드밸런서 종류

로드밸런서도 여러 레벨이 있어. OSI 7계층 중 어느 레벨에서 작동하느냐에 따라 나뉘지. 📚

L4 로드밸런서 (Transport Layer) 🚛
IP 주소와 포트 번호를 보고 분산해.
빠르고 효율적이지만, HTTP 헤더나 쿠키 같은 건 못 봐.
TCP/UDP 레벨에서 작동하지.

장점:
• 처리 속도가 매우 빠름 ⚡
• 비용이 상대적으로 저렴
• 단순하고 안정적

단점:
• URL 기반 라우팅 불가
• 쿠키나 세션 인식 불가
• SSL 터미네이션 제한적

L7 로드밸런서 (Application Layer) 🎯
HTTP 헤더, URL, 쿠키 등을 분석해서 똑똑하게 분산해.
/api/*는 API 서버로, /images/*는 이미지 서버로 보내는 식이지!

장점:
• URL 기반 라우팅 가능 🎯
• 쿠키/세션 기반 분산
• SSL 오프로딩 완벽 지원
• 콘텐츠 기반 스위칭
• 헬스체크가 더 정교함

단점:
• L4보다 느림 (하지만 체감 안 됨)
• 비용이 조금 더 비쌈
• 설정이 복잡할 수 있음

🔍 헬스체크 설정

로드밸런서의 핵심 기능 중 하나가 바로 헬스체크야.
서버가 정상인지 계속 확인해서 문제 있는 서버는 자동으로 제외시키지. 💓

헬스체크 방식:

1. HTTP/HTTPS 체크
특정 URL에 요청을 보내서 응답 코드를 확인해.
예: GET /health → 200 OK면 정상, 500이면 비정상

2. TCP 체크
포트가 열려있는지만 확인해. 간단하지만 덜 정확해.

3. 커스텀 체크
데이터베이스 연결, 캐시 상태 등을 종합적으로 확인하는 엔드포인트를 만들어.
이게 제일 정확해! 🎯

// Node.js + Express 예시
app.get('/health', async (req, res) => {
  try {
    // DB 연결 확인
    await db.ping();
    
    // Redis 연결 확인
    await redis.ping();
    
    // 메모리 사용률 확인
    const memUsage = process.memoryUsage();
    if (memUsage.heapUsed / memUsage.heapTotal > 0.9) {
      throw new Error('메모리 부족');
    }
    
    res.status(200).json({ 
      status: 'healthy',
      timestamp: new Date()
    });
  } catch (error) {
    res.status(503).json({ 
      status: 'unhealthy',
      error: error.message 
    });
  }
});

헬스체크 설정 팁:

• 간격(Interval): 30초마다 체크 (너무 짧으면 부하, 너무 길면 장애 감지 늦음)
• 타임아웃: 5초 이내 응답 없으면 실패로 간주
• 임계값: 연속 2회 실패 시 제외, 연속 3회 성공 시 복귀
• 경로: /health 또는 /healthcheck 사용

🛠️ 실전 구축: AWS 환경 예시

이론은 충분히 배웠으니, 이제 실제로 어떻게 구축하는지 알아볼까? 💪
AWS를 예시로 들겠지만, Azure나 GCP도 개념은 똑같아!

🏗️ 1단계: 기본 인프라 준비

⚙️ 2단계: Application Load Balancer 생성

ALB 기본 설정:

• 이름: my-shop-alb
• 스킴: Internet-facing (외부 접근 가능)
• IP 주소 유형: IPv4
• 리스너: HTTP(80), HTTPS(443)
• 가용 영역: 최소 2개 선택

타겟 그룹 설정:

• 타겟 유형: 인스턴스
• 프로토콜: HTTP
• 포트: 3000 (Node.js 기본 포트)
• 헬스체크 경로: /health
• 정상 임계값: 3회 연속 성공
• 비정상 임계값: 2회 연속 실패

🚀 3단계: Auto Scaling 그룹 생성

시작 템플릿 생성:

{
  "LaunchTemplateName": "my-shop-template",
  "VersionDescription": "v1.0",
  "LaunchTemplateData": {
    "ImageId": "ami-0c76973fbe0ee100c",
    "InstanceType": "t3.medium",
    "KeyName": "my-key-pair",
    "SecurityGroupIds": ["sg-0123456789abcdef"],
    "UserData": "IyEvYmluL2Jhc2gKY2QgL2hvbWUvZWMyLXVzZXIvYXBwCm5wbSBzdGFydA==",
    "IamInstanceProfile": {
      "Name": "EC2-CloudWatch-Role"
    },
    "TagSpecifications": [{
      "ResourceType": "instance",
      "Tags": [
        {"Key": "Name", "Value": "shop-web-server"},
        {"Key": "Environment", "Value": "production"}
      ]
    }]
  }
}

Auto Scaling 그룹 설정:

• 최소 용량: 2대 (항상 최소 2대는 유지)
• 원하는 용량: 4대 (평상시 4대 운영)
• 최대 용량: 20대 (최대 20대까지 확장)
• 가용 영역: 2개 이상 (고가용성)
• 로드밸런서: 위에서 만든 ALB 연결

📊 4단계: 스케일링 정책 설정

대상 추적 스케일링 정책 (추천!):

{
  "TargetTrackingScalingPolicyConfiguration": {
    "PredefinedMetricSpecification": {
      "PredefinedMetricType": "ASGAverageCPUUtilization"
    },
    "TargetValue": 50.0,
    "ScaleInCooldown": 300,
    "ScaleOutCooldown": 60
  }
}

이 설정은 "CPU 사용률을 50%로 유지해줘"라는 의미야.
CPU가 50% 넘으면 서버를 추가하고, 50% 밑으로 떨어지면 줄이는 거지! 🎯

단계 조정 정책 (세밀한 제어):

{
  "StepScalingPolicyConfiguration": {
    "AdjustmentType": "PercentChangeInCapacity",
    "MetricAggregationType": "Average",
    "StepAdjustments": [
      {
        "MetricIntervalLowerBound": 0,
        "MetricIntervalUpperBound": 10,
        "ScalingAdjustment": 10
      },
      {
        "MetricIntervalLowerBound": 10,
        "MetricIntervalUpperBound": 20,
        "ScalingAdjustment": 20
      },
      {
        "MetricIntervalLowerBound": 20,
        "ScalingAdjustment": 30
      }
    ]
  }
}

이건 더 똑똑해:
• CPU 60~70%: 용량 10% 증가
• CPU 70~80%: 용량 20% 증가
• CPU 80% 이상: 용량 30% 증가
상황에 맞게 탄력적으로 대응하는 거야! 🧠

예약 조정 (이벤트 대비):

{
  "ScheduledActionName": "scale-up-for-event",
  "StartTime": "2024-11-11T19:00:00Z",
  "EndTime": "2024-11-12T02:00:00Z",
  "MinSize": 10,
  "MaxSize": 50,
  "DesiredCapacity": 15
}

11월 11일(광군제) 저녁 8시부터 새벽 2시까지 미리 서버를 늘려놓는 거야.
트래픽 폭증을 예상할 수 있을 때 완벽한 전략이지! 🎉

🔐 5단계: SSL/TLS 설정

쇼핑몰은 결제 정보를 다루니까 HTTPS는 필수야! 🔒

AWS Certificate Manager로 인증서 발급:

1. ACM 콘솔에서 "인증서 요청" 클릭
2. 도메인 이름 입력 (예: www.myshop.com, myshop.com)
3. DNS 검증 또는 이메일 검증 선택
4. Route 53 사용 시 자동으로 DNS 레코드 추가 가능
5. 인증서 발급 완료! (무료야! 🎁)

ALB에 인증서 연결:

• ALB 리스너에서 HTTPS(443) 추가
• 위에서 발급받은 ACM 인증서 선택
• HTTP(80)는 HTTPS로 리다이렉트 설정
• 보안 정책: ELBSecurityPolicy-TLS-1-2-2017-01 (TLS 1.2 이상)

🎨 세션 관리 전략

오토스케일링 환경에서 가장 까다로운 게 바로 세션 관리야. 🤔
사용자가 서버 1에서 로그인했는데, 다음 요청이 서버 2로 가면? 로그인 정보가 없어져!

❌ 잘못된 방법: 서버 메모리에 세션 저장

// 이렇게 하면 안 돼!
const sessions = {}; // 서버 메모리에 저장

app.post('/login', (req, res) => {
  const sessionId = generateSessionId();
  sessions[sessionId] = { userId: req.body.userId };
  res.cookie('sessionId', sessionId);
});

이 방식은 단일 서버에서만 작동해.
서버가 여러 대면 각 서버마다 다른 세션 정보를 가지게 되지. 😵

✅ 올바른 방법 1: Redis 세션 스토어

// Redis를 중앙 세션 저장소로 사용
const redis = require('redis');
const session = require('express-session');
const RedisStore = require('connect-redis')(session);

const redisClient = redis.createClient({
  host: 'my-redis-cluster.abc123.ng.0001.apn2.cache.amazonaws.com',
  port: 6379
});

app.use(session({
  store: new RedisStore({ client: redisClient }),
  secret: 'my-secret-key',
  resave: false,
  saveUninitialized: false,
  cookie: {
    secure: true, // HTTPS only
    httpOnly: true,
    maxAge: 1000 * 60 * 60 * 24 // 24시간
  }
}));

이제 모든 서버가 같은 Redis를 바라보니까 세션이 공유돼! 🎉
사용자가 어느 서버로 연결되든 로그인 상태가 유지되지.

✅ 올바른 방법 2: JWT 토큰 기반 인증

const jwt = require('jsonwebtoken');

// 로그인 시 JWT 발급
app.post('/login', async (req, res) => {
  const user = await authenticateUser(req.body);
  
  const token = jwt.sign(
    { 
      userId: user.id,
      email: user.email,
      role: user.role
    },
    process.env.JWT_SECRET,
    { expiresIn: '24h' }
  );
  
  res.json({ token });
});

// 인증 미들웨어
const authenticateToken = (req, res, next) => {
  const token = req.headers['authorization']?.split(' ')[1];
  
  if (!token) {
    return res.status(401).json({ error: '인증 필요' });
  }
  
  jwt.verify(token, process.env.JWT_SECRET, (err, user) => {
    if (err) {
      return res.status(403).json({ error: '유효하지 않은 토큰' });
    }
    req.user = user;
    next();
  });
};

JWT는 서버에 세션을 저장하지 않아!
토큰 자체에 모든 정보가 들어있어서 완전히 무상태(Stateless)야.
오토스케일링 환경에 완벽하게 맞는 방식이지! 🎯

🛒 장바구니 데이터 관리

장바구니도 세션처럼 관리해야 해.
사용자가 상품을 담았는데 서버 바뀌면서 사라지면 큰일이잖아! 😱

방법 1: Redis에 저장

// 장바구니 추가
app.post('/cart/add', authenticateToken, async (req, res) => {
  const userId = req.user.userId;
  const { productId, quantity } = req.body;
  
  const cartKey = `cart:${userId}`;
  await redisClient.hset(cartKey, productId, quantity);
  await redisClient.expire(cartKey, 60 * 60 * 24 * 7); // 7일 유효
  
  res.json({ success: true });
});

// 장바구니 조회
app.get('/cart', authenticateToken, async (req, res) => {
  const userId = req.user.userId;
  const cartKey = `cart:${userId}`;
  
  const cart = await redisClient.hgetall(cartKey);
  res.json({ cart });
});

방법 2: 데이터베이스에 저장

// 장바구니 테이블 스키마
CREATE TABLE cart_items (
  id BIGINT PRIMARY KEY AUTO_INCREMENT,
  user_id BIGINT NOT NULL,
  product_id BIGINT NOT NULL,
  quantity INT NOT NULL,
  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
  updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
  INDEX idx_user_id (user_id),
  UNIQUE KEY uk_user_product (user_id, product_id)
);

// 장바구니 추가
app.post('/cart/add', authenticateToken, async (req, res) => {
  const userId = req.user.userId;
  const { productId, quantity } = req.body;
  
  await db.query(`
    INSERT INTO cart_items (user_id, product_id, quantity)
    VALUES (?, ?, ?)
    ON DUPLICATE KEY UPDATE quantity = quantity + ?
  `, [userId, productId, quantity, quantity]);
  
  res.json({ success: true });
});

📊 모니터링 및 알림 설정

시스템을 구축했으면 이제 제대로 작동하는지 감시해야지! 👀
문제가 생기면 즉시 알아채고 대응할 수 있어야 해.

📈 핵심 모니터링 지표

🔔 CloudWatch 알람 설정

// AWS SDK로 알람 생성
const cloudwatch = new AWS.CloudWatch();

// CPU 사용률 알람
await cloudwatch.putMetricAlarm({
  AlarmName: 'high-cpu-usage',
  ComparisonOperator: 'GreaterThanThreshold',
  EvaluationPeriods: 2,
  MetricName: 'CPUUtilization',
  Namespace: 'AWS/EC2',
  Period: 300,
  Statistic: 'Average',
  Threshold: 70.0,
  ActionsEnabled: true,
  AlarmActions: [
    'arn:aws:sns:ap-northeast-2:123456789012:alert-topic'
  ],
  AlarmDescription: 'CPU 사용률이 70% 이상 10분간 지속',
  Dimensions: [
    {
      Name: 'AutoScalingGroupName',
      Value: 'my-shop-asg'
    }
  ]
}).promise();

// 응답 시간 알람
await cloudwatch.putMetricAlarm({
  AlarmName: 'slow-response-time',
  ComparisonOperator: 'GreaterThanThreshold',
  EvaluationPeriods: 3,
  MetricName: 'TargetResponseTime',
  Namespace: 'AWS/ApplicationELB',
  Period: 60,
  Statistic: 'Average',
  Threshold: 0.5,
  ActionsEnabled: true,
  AlarmActions: [
    'arn:aws:sns:ap-northeast-2:123456789012:alert-topic'
  ],
  AlarmDescription: '평균 응답 시간이 500ms 초과',
  Dimensions: [
    {
      Name: 'LoadBalancer',
      Value: 'app/my-shop-alb/1234567890abcdef'
    }
  ]
}).promise();

📱 알림 채널 설정

SNS(Simple Notification Service) 활용:

// SNS 토픽 생성
const sns = new AWS.SNS();

await sns.createTopic({
  Name: 'shop-critical-alerts'
}).promise();

// 이메일 구독 추가
await sns.subscribe({
  Protocol: 'email',
  TopicArn: 'arn:aws:sns:ap-northeast-2:123456789012:shop-critical-alerts',
  Endpoint: 'admin@myshop.com'
}).promise();

// SMS 구독 추가 (긴급 알림용)
await sns.subscribe({
  Protocol: 'sms',
  TopicArn: 'arn:aws:sns:ap-northeast-2:123456789012:shop-critical-alerts',
  Endpoint: '+821012345678'
}).promise();

// Slack 웹훅 연동
await sns.subscribe({
  Protocol: 'https',
  TopicArn: 'arn:aws:sns:ap-northeast-2:123456789012:shop-critical-alerts',
  Endpoint: 'https://hooks.slack.com/services/T00000000/B00000000/XXXXXXXXXXXX'
}).promise();

📊 대시보드 구성

CloudWatch 대시보드로 한눈에 시스템 상태를 파악할 수 있어! 📺

// 대시보드 생성
await cloudwatch.putDashboard({
  DashboardName: 'shop-overview',
  DashboardBody: JSON.stringify({
    widgets: [
      {
        type: 'metric',
        properties: {
          metrics: [
            ['AWS/ApplicationELB', 'RequestCount', { stat: 'Sum' }],
            ['.', 'TargetResponseTime', { stat: 'Average' }]
          ],
          period: 300,
          stat: 'Average',
          region: 'ap-northeast-2',
          title: '트래픽 및 응답 시간'
        }
      },
      {
        type: 'metric',
        properties: {
          metrics: [
            ['AWS/EC2', 'CPUUtilization', { stat: 'Average' }],
            ['.', 'NetworkIn', { stat: 'Sum' }],
            ['.', 'NetworkOut', { stat: 'Sum' }]
          ],
          period: 300,
          stat: 'Average',
          region: 'ap-northeast-2',
          title: '서버 리소스 사용률'
        }
      },
      {
        type: 'metric',
        properties: {
          metrics: [
            ['AWS/AutoScaling', 'GroupDesiredCapacity'],
            ['.', 'GroupInServiceInstances'],
            ['.', 'GroupMinSize'],
            ['.', 'GroupMaxSize']
          ],
          period: 300,
          stat: 'Average',
          region: 'ap-northeast-2',
          title: '오토스케일링 상태'
        }
      }
    ]
  })
}).promise();

💰 비용 최적화 전략

오토스케일링은 편리하지만, 잘못 설정하면 청구서 폭탄을 맞을 수 있어! 💸
똑똑하게 비용을 관리하는 방법을 알아보자.

📊 비용 구조 이해하기

💡 비용 절감 꿀팁

📉 비용 모니터링 설정

// AWS Cost Explorer API로 비용 추적
const costexplorer = new AWS.CostExplorer();

// 일일 비용 조회
const response = await costexplorer.getCostAndUsage({
  TimePeriod: {
    Start: '2024-01-01',
    End: '2024-01-31'
  },
  Granularity: 'DAILY',
  Metrics: ['UnblendedCost'],
  GroupBy: [
    {
      Type: 'SERVICE',
      Key: 'SERVICE'
    }
  ]
}).promise();

// 예산 초과 알림 설정
const budgets = new AWS.Budgets();

await budgets.createBudget({
  AccountId: '123456789012',
  Budget: {
    BudgetName: 'monthly-shop-budget',
    BudgetLimit: {
      Amount: '500',
      Unit: 'USD'
    },
    TimeUnit: 'MONTHLY',
    BudgetType: 'COST'
  },
  NotificationsWithSubscribers: [
    {
      Notification: {
        NotificationType: 'ACTUAL',
        ComparisonOperator: 'GREATER_THAN',
        Threshold: 80,
        ThresholdType: 'PERCENTAGE'
      },
      Subscribers: [
        {
          SubscriptionType: 'EMAIL',
          Address: 'admin@myshop.com'
        }
      ]
    }
  ]
}).promise();

🚀 성능 최적화 고급 기법

인프라는 완벽하게 구축했어. 이제 한 단계 더 나아가볼까? 🎯
진짜 고수들이 쓰는 성능 최적화 기법들을 알려줄게!

⚡ 1. 데이터베이스 쿼리 최적화

아무리 서버를 늘려도 DB가 병목이면 소용없어!
쇼핑몰에서 가장 많이 실행되는 쿼리들을 최적화해보자. 🔍

상품 목록 조회 최적화:

-- ❌ 느린 쿼리 (인덱스 없음)
SELECT * FROM products 
WHERE category_id = 10 
AND status = 'active'
ORDER BY created_at DESC
LIMIT 20;

-- ✅ 빠른 쿼리 (복합 인덱스 활용)
CREATE INDEX idx_category_status_created 
ON products(category_id, status, created_at DESC);

SELECT 
  id, name, price, thumbnail_url, stock
FROM products 
WHERE category_id = 10 
AND status = 'active'
ORDER BY created_at DESC
LIMIT 20;

-- 필요한 컬럼만 SELECT! (SELECT * 금지)

주문 내역 조회 최적화:

-- ❌ N+1 쿼리 문제
// 주문 목록 조회
const orders = await db.query('SELECT * FROM orders WHERE user_id = ?', [userId]);

// 각 주문마다 상품 정보 조회 (N번 쿼리 발생!)
for (const order of orders) {
  order.items = await db.query('SELECT * FROM order_items WHERE order_id = ?', [order.id]);
}

-- ✅ JOIN으로 한 번에 조회
SELECT 
  o.id, o.order_number, o.total_amount, o.status,
  oi.product_id, oi.product_name, oi.quantity, oi.price
FROM orders o
LEFT JOIN order_items oi ON o.id = oi.order_id
WHERE o.user_id = ?
ORDER BY o.created_at DESC
LIMIT 10;

🗄️ 2. 캐싱 전략

DB 조회를 줄이는 가장 효과적인 방법은 캐싱이야!
Redis를 활용한 다층 캐싱 전략을 알아보자. 💾

상품 정보 캐싱:

// 캐시 우선 조회 패턴
async function getProduct(productId) {
  const cacheKey = `product:${productId}`;
  
  // 1. Redis 캐시 확인
  let product = await redis.get(cacheKey);
  
  if (product) {
    console.log('Cache HIT! ⚡');
    return JSON.parse(product);
  }
  
  console.log('Cache MISS, DB 조회 중...');
  
  // 2. DB에서 조회
  product = await db.query(
    'SELECT * FROM products WHERE id = ?',
    [productId]
  );
  
  // 3. Redis에 캐싱 (1시간 유효)
  await redis.setex(
    cacheKey,
    3600,
    JSON.stringify(product)
  );
  
  return product;
}

인기 상품 목록 캐싱:

// 자주 바뀌지 않는 데이터는 긴 TTL
async function getPopularProducts() {
  const cacheKey = 'products:popular';
  
  let products = await redis.get(cacheKey);
  
  if (products) {
    return JSON.parse(products);
  }
  
  // 복잡한 집계 쿼리
  products = await db.query(`
    SELECT 
      p.id, p.name, p.price, p.thumbnail_url,
      COUNT(oi.id) as order_count
    FROM products p
    JOIN order_items oi ON p.id = oi.product_id
    WHERE oi.created_at >= DATE_SUB(NOW(), INTERVAL 7 DAY)
    GROUP BY p.id
    ORDER BY order_count DESC
    LIMIT 20
  `);
  
  // 6시간 캐싱 (자주 안 바뀜)
  await redis.setex(
    cacheKey,
    21600,
    JSON.stringify(products)
  );
  
  return products;
}

캐시 무효화 전략:

// 상품 정보 업데이트 시 캐시 삭제
async function updateProduct(productId, data) {
  // 1. DB 업데이트
  await db.query(
    'UPDATE products SET ? WHERE id = ?',
    [data, productId]
  );
  
  // 2. 관련 캐시 모두 삭제
  await redis.del(`product:${productId}`);
  await redis.del('products:popular');
  await redis.del(`products:category:${data.category_id}`);
  
  // 3. 캐시 워밍 (선택적)
  await getProduct(productId); // 새 데이터로 캐시 재생성
}

🔄 3. API 응답 최적화

페이지네이션 최적화:

// ❌ OFFSET 방식 (페이지가 뒤로 갈수록 느려짐)
SELECT * FROM products 
ORDER BY id DESC 
LIMIT 20 OFFSET 10000; -- 10,000개를 스캔하고 버림!

// ✅ 커서 기반 페이지네이션 (항상 빠름)
SELECT * FROM products 
WHERE id < ? -- 마지막 조회 ID
ORDER BY id DESC 
LIMIT 20;

// API 구현
app.get('/api/products', async (req, res) => {
  const { cursor, limit = 20 } = req.query;
  
  const query = cursor
    ? 'SELECT * FROM products WHERE id < ? ORDER BY id DESC LIMIT ?'
    : 'SELECT * FROM products ORDER BY id DESC LIMIT ?';
  
  const params = cursor ? [cursor, limit] : [limit];
  const products = await db.query(query, params);
  
  const nextCursor = products.length > 0 
    ? products[products.length - 1].id 
    : null;
  
  res.json({
    data: products,
    nextCursor,
    hasMore: products.length === limit
  });
});

응답 압축:

// Express에서 gzip 압축 활성화
const compression = require('compression');

app.use(compression({
  level: 6, // 압축 레벨 (1~9, 6이 적당)
  threshold: 1024, // 1KB 이상만 압축
  filter: (req, res) => {
    // 이미지는 이미 압축되어 있으니 제외
    if (req.headers['x-no-compression']) {
      return false;
    }
    return compression.filter(req, res);
  }
}));

// 평균 70% 용량 감소! 🎉

부분 응답 (Partial Response):

// 클라이언트가 필요한 필드만 요청
app.get('/api/products/:id', async (req, res) => {
  const { fields } = req.query;
  
  let selectFields = '*';
  if (fields) {
    // fields=id,name,price
    selectFields = fields.split(',').join(', ');
  }
  
  const product = await db.query(
    `SELECT ${selectFields} FROM products WHERE id = ?`,
    [req.params.id]
  );
  
  res.json(product);
});

// 사용 예시:
// GET /api/products/123?fields=id,name,price
// → 필요한 데이터만 전송! 네트워크 비용 절감!

🖼️ 4. 이미지 최적화

쇼핑몰에서 이미지는 트래픽의 70% 이상을 차지해!
이미지 최적화는 필수야. 📸

CloudFront + Lambda@Edge로 실시간 리사이징:

// Lambda@Edge 함수
exports.handler = async (event) => {
  const request = event.Records[0].cf.request;
  const uri = request.uri;
  
  // URL에서 크기 파라미터 추출
  // 예: /images/product.jpg?w=300&h=300
  const params = new URLSearchParams(request.querystring);
  const width = params.get('w');
  const height = params.get('h');
  
  if (width || height) {
    // S3에서 원본 이미지 가져오기
    const s3 = new AWS.S3();
    const originalImage = await s3.getObject({
      Bucket: 'my-shop-images',
      Key: uri.substring(1)
    }).promise();
    
    // Sharp로 리사이징
    const sharp = require('sharp');
    const resizedImage = await sharp(originalImage.Body)
      .resize(parseInt(width), parseInt(height), {
        fit: 'cover',
        position: 'center'
      })
      .webp({ quality: 80 }) // WebP 변환!
      .toBuffer();
    
    return {
      status: '200',
      headers: {
        'content-type': [{ value: 'image/webp' }],
        'cache-control': [{ value: 'max-age=31536000' }]
      },
      body: resizedImage.toString('base64'),
      bodyEncoding: 'base64'
    };
  }
  
  return request;
};

프론트엔드에서 반응형 이미지:

<!-- 디바이스 크기에 맞는 이미지 자동 선택 -->
<picture>
  <source 
    srcset="https://cdn.myshop.com/product.jpg?w=400&h=400" 
    media="(max-width: 768px)">
  <source 
    srcset="https://cdn.myshop.com/product.jpg?w=800&h=800" 
    media="(max-width: 1200px)">
  <img 
    src="https://cdn.myshop.com/product.jpg?w=1200&h=1200" 
    alt="상품 이미지"
    loading="lazy"> <!-- 지연 로딩 -->
</picture>

🎯 실전 시나리오: 블랙프라이데이 대응

자, 이제 배운 걸 종합해서 실전 시나리오를 시뮬레이션해보자! 🎮
블랙프라이데이 같은 대규모 이벤트를 어떻게 준비하고 대응하는지 알아볼게.

📅 D-7: 사전 준비

// Apache JMeter 또는 k6로 부하 테스트
import http from 'k6/http';
import { check, sleep } from 'k6';

export let options = {
  stages: [
    { duration: '5m', target: 100 },   // 워밍업
    { duration: '10m', target: 1000 }, // 정상 부하
    { duration: '5m', target: 5000 },  // 피크 부하
    { duration: '10m', target: 5000 }, // 유지
    { duration: '5m', target: 0 },     // 쿨다운
  ],
};

export default function () {
  // 메인 페이지
  let res = http.get('https://myshop.com');
  check(res, { 'status is 200': (r) => r.status === 200 });
  
  sleep(1);
  
  // 상품 목록
  res = http.get('https://myshop.com/api/products');
  check(res, { 
    'status is 200': (r) => r.status === 200,
    'response time < 500ms': (r) => r.timings.duration < 500
  });
  
  sleep(2);
  
  // 상품 상세
  res = http.get('https://myshop.com/api/products/123');
  check(res, { 'status is 200': (r) => r.status === 200 });
  
  sleep(1);
}

// 주요 데이터 미리 캐싱
async function warmupCache() {
  console.log('캐시 워밍 시작...');
  
  // 인기 상품 100개
  const popularProducts = await db.query(`
    SELECT id FROM products 
    ORDER BY view_count DESC 
    LIMIT 100
  `);
  
  for (const product of popularProducts) {
    await getProduct(product.id); // 캐시에 저장
  }
  
  // 모든 카테고리
  const categories = await db.query('SELECT id FROM categories');
  for (const category of categories) {
    await getCategoryProducts(category.id);
  }
  
  console.log('캐시 워밍 완료! ✅');
}

// 이벤트 시작 1시간 전에 실행
schedule.scheduleJob('0 18 * * *', warmupCache);

// 이벤트 기간 동안 공격적인 스케일링
{
  "TargetTrackingScalingPolicyConfiguration": {
    "TargetValue": 40.0,  // 평소 50% → 40%로 낮춤
    "ScaleOutCooldown": 30,  // 평소 60초 → 30초로 단축
    "ScaleInCooldown": 600   // 축소는 신중하게
  }
}

📅 D-1: 최종 점검

🔥 D-Day: 실시간 대응

이벤트 시작 (19:00):

// 실시간 모니터링 스크립트
const monitor = setInterval(async () => {
  const metrics = await getMetrics();
  
  console.log(`
    ⏰ ${new Date().toLocaleTimeString()}
    👥 동시 접속자: ${metrics.activeUsers}
    🖥️  활성 서버: ${metrics.activeInstances}
    📊 CPU 평균: ${metrics.avgCPU}%
    ⚡ 응답 시간: ${metrics.avgResponseTime}ms
    💰 주문 수: ${metrics.orderCount}
    ❌ 에러율: ${metrics.errorRate}%
  `);
  
  // 이상 징후 감지
  if (metrics.errorRate > 1) {
    await sendAlert('🚨 에러율 1% 초과!', 'critical');
  }
  
  if (metrics.avgResponseTime > 1000) {
    await sendAlert('⚠️ 응답 시간 1초 초과', 'warning');
  }
  
  if (metrics.activeInstances >= 45) {
    await sendAlert('📈 서버 45대 도달, 최대치 임박', 'warning');
  }
}, 30000); // 30초마다 체크

19:30 - 트래픽 급증 감지:

// 자동 스케일링 로그
[19:30:15] 🚀 CPU 사용률 45% 도달
[19:30:45] ➕ 서버 2대 추가 시작 (총 6대 → 8대)
[19:31:20] ✅ 새 서버 2대 헬스체크 통과
[19:31:25] 🔗 로드밸런서에 연결 완료
[19:31:30] 📊 트래픽 분산 시작

[19:35:20] 🚀 CPU 사용률 50% 도달
[19:35:50] ➕ 서버 3대 추가 시작 (총 8대 → 11대)
[19:36:30] ✅ 새 서버 3대 준비 완료

[19:40:00] 📈 동시 접속자 10,000명 돌파!
[19:40:05] 🎉 시스템 안정적으로 작동 중
[19:40:10] 💰 분당 주문 수: 150건

20:00 - 피크 타임:

22:00 - 트래픽 감소 시작:

[22:00:00] 📉 트래픽 감소 감지
[22:00:05] ⏸️  스케일 인 대기 중 (쿨다운 10분)
[22:10:00] ➖ 서버 2대 제거 시작 (18대 → 16대)
[22:10:30] 🔌 로드밸런서에서 연결 해제
[22:11:00] 💾 서버 종료 전 세션 드레인 완료
[22:11:30] ✅ 서버 2대 안전하게 종료

[22:30:00] ➖ 서버 4대 추가 제거 (16대 → 12대)
[23:00:00] ➖ 서버 4대 추가 제거 (12대 → 8대)
[00:00:00] ➖ 서버 4대 추가 제거 (8대 → 4대)
[02:00:00] 🌙 최소 용량 2대로 복귀

📊 D+1: 사후 분석

// 이벤트 결과 리포트
{
  "event": "Black Friday 2024",
  "duration": "7 hours",
  "summary": {
    "peakConcurrentUsers": 15234,
    "totalOrders": 45678,
    "totalRevenue": "12억 원",
    "averageResponseTime": "285ms",
    "errorRate": "0.25%",
    "uptime": "100%"
  },
  "infrastructure": {
    "maxInstances": 18,
    "minInstances": 2,
    "averageInstances": 9.5,
    "totalScaleOutEvents": 12,
    "totalScaleInEvents": 10,
    "estimatedCost": "$180"
  },
  "performance": {
    "cacheHitRate": "92%",
    "databaseQueryTime": "45ms",
    "cdnHitRate": "88%",
    "apiSuccessRate": "99.75%"
  },
  "issues": [
    {
      "time": "19:45",
      "issue": "Redis 메모리 사용률 85% 도달",
      "action": "불필요한 캐시 삭제",
      "resolved": "19:47"
    },
    {
      "time": "20:15",
      "issue": "특정 API 응답 시간 1.2초",
      "action": "쿼리 최적화 및 캐시 추가",
      "resolved": "20:20"
    }
  ],
  "improvements": [
    "Redis 클러스터 메모리 증설 필요",
    "특정 상품 페이지 추가 최적화 필요",
    "결제 API 타임아웃 설정 조정 필요"
  ]
}

🛠️ 다양한 플랫폼별 구현 가이드

AWS만 있는 게 아니야! 다른 클라우드 플랫폼에서는 어떻게 구현하는지 알아보자. ☁️

🔷 Azure 구현

Azure Load Balancer + VM Scale Sets:

// Azure CLI로 구성
# 리소스 그룹 생성
az group create --name myshop-rg --location koreacentral

# 가상 네트워크 생성
az network vnet create \
  --resource-group myshop-rg \
  --name myshop-vnet \
  --address-prefix 10.0.0.0/16 \
  --subnet-name myshop-subnet \
  --subnet-prefix 10.0.1.0/24

# Application Gateway (L7 로드밸런서) 생성
az network application-gateway create \
  --name myshop-appgw \
  --resource-group myshop-rg \
  --vnet-name myshop-vnet \
  --subnet myshop-subnet \
  --capacity 2 \
  --sku Standard_v2 \
  --http-settings-cookie-based-affinity Disabled \
  --frontend-port 80 \
  --http-settings-port 3000 \
  --http-settings-protocol Http

# VM Scale Set 생성
az vmss create \
  --resource-group myshop-rg \
  --name myshop-vmss \
  --image UbuntuLTS \
  --upgrade-policy-mode automatic \
  --instance-count 2 \
  --admin-username azureuser \
  --generate-ssh-keys \
  --load-balancer myshop-appgw

# 오토스케일링 규칙 설정
az monitor autoscale create \
  --resource-group myshop-rg \
  --resource myshop-vmss \
  --resource-type Microsoft.Compute/virtualMachineScaleSets \
  --name autoscale-myshop \
  --min-count 2 \
  --max-count 20 \
  --count 4

# CPU 기반 스케일 아웃
az monitor autoscale rule create \
  --resource-group myshop-rg \
  --autoscale-name autoscale-myshop \
  --condition "Percentage CPU > 70 avg 5m" \
  --scale out 2

# CPU 기반 스케일 인
az monitor autoscale rule create \
  --resource-group myshop-rg \
  --autoscale-name autoscale-myshop \
  --condition "Percentage CPU < 30 avg 5m" \
  --scale in 1

🔶 Google Cloud Platform 구현

Cloud Load Balancing + Managed Instance Groups:

# 인스턴스 템플릿 생성
gcloud compute instance-templates create myshop-template \
  --machine-type=n1-standard-2 \
  --image-family=ubuntu-2004-lts \
  --image-project=ubuntu-os-cloud \
  --boot-disk-size=20GB \
  --tags=http-server \
  --metadata-from-file startup-script=startup.sh

# 관리형 인스턴스 그룹 생성
gcloud compute instance-groups managed create myshop-mig \
  --base-instance-name=myshop-vm \
  --template=myshop-template \
  --size=2 \
  --zone=asia-northeast3-a

# 오토스케일링 설정
gcloud compute instance-groups managed set-autoscaling myshop-mig \
  --zone=asia-northeast3-a \
  --min-num-replicas=2 \
  --max-num-replicas=20 \
  --target-cpu-utilization=0.6 \
  --cool-down-period=60

# HTTP 헬스체크 생성
gcloud compute health-checks create http myshop-health-check \
  --port=3000 \
  --request-path=/health \
  --check-interval=30s \
  --timeout=10s \
  --unhealthy-threshold=3 \
  --healthy-threshold=2

# 백엔드 서비스 생성
gcloud compute backend-services create myshop-backend \
  --protocol=HTTP \
  --health-checks=myshop-health-check \
  --global

# 인스턴스 그룹을 백엔드에 추가
gcloud compute backend-services add-backend myshop-backend \
  --instance-group=myshop-mig \
  --instance-group-zone=asia-northeast3-a \
  --balancing-mode=UTILIZATION \
  --max-utilization=0.8 \
  --global

# URL 맵 생성
gcloud compute url-maps create myshop-url-map \
  --default-service=myshop-backend

# HTTP 프록시 생성
gcloud compute target-http-proxies create myshop-http-proxy \
  --url-map=myshop-url-map

# 전역 전달 규칙 생성 (로드밸런서 IP)
gcloud compute forwarding-rules create myshop-forwarding-rule \
  --global \
  --target-http-proxy=myshop-http-proxy \
  --ports=80

🐳 Kubernetes 기반 구현

요즘 대세는 Kubernetes야! 클라우드 종속성 없이 어디서든 실행 가능해. 🚀

# Deployment 설정 (deployment.yaml)
apiVersion: apps/v1
kind: Deployment
metadata:
  name: myshop-deployment
spec:
  replicas: 4
  selector:
    matchLabels:
      app: myshop
  template:
    metadata:
      labels:
        app: myshop
    spec:
      containers:
      - name: myshop
        image: myshop:latest
        ports:
        - containerPort: 3000
        resources:
          requests:
            memory: "256Mi"
            cpu: "250m"
          limits:
            memory: "512Mi"
            cpu: "500m"
        livenessProbe:
          httpGet:
            path: /health
            port: 3000
          initialDelaySeconds: 30
          periodSeconds: 10
        readinessProbe:
          httpGet:
            path: /health
            port: 3000
          initialDelaySeconds: 5
          periodSeconds: 5
---
# HorizontalPodAutoscaler 설정
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: myshop-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: myshop-deployment
  minReplicas: 2
  maxReplicas: 20
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 50
  - type: Resource
    resource:
      name: memory
      target:
        type: Utilization
        averageUtilization: 70
  behavior:
    scaleDown:
      stabilizationWindowSeconds: 300
      policies:
      - type: Percent
        value: 50
        periodSeconds: 60
    scaleUp:
      stabilizationWindowSeconds: 0
      policies:
      - type: Percent
        value: 100
        periodSeconds: 30
      - type: Pods
        value: 4
        periodSeconds: 30
      selectPolicy: Max
---
# Service 설정 (LoadBalancer)
apiVersion: v1
kind: Service
metadata:
  name: myshop-service
spec:
  type: LoadBalancer
  selector:
    app: myshop
  ports:
  - protocol: TCP
    port: 80
    targetPort: 3000
---
# Ingress 설정 (L7 로드밸런싱)
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: myshop-ingress
  annotations:
    kubernetes.io/ingress.class: nginx
    cert-manager.io/cluster-issuer: letsencrypt-prod
    nginx.ingress.kubernetes.io/ssl-redirect: "true"
spec:
  tls:
  - hosts:
    - myshop.com
    secretName: myshop-tls
  rules:
  - host: myshop.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: myshop-service
            port:
              number: 80

🔧 온프레미스 환경 구현

클라우드를 못 쓰는 상황이라면? 온프레미스에서도 가능해! 💪

HAProxy + Keepalived 조합:

# HAProxy 설정 (/etc/haproxy/haproxy.cfg)
global
    log /dev/log local0
    maxconn 4096
    user haproxy
    group haproxy
    daemon

defaults
    log global
    mode http
    option httplog
    option dontlognull
    timeout connect 5000
    timeout client 50000
    timeout server 50000

frontend http_front
    bind *:80
    stats uri /haproxy?stats
    default_backend http_back

backend http_back
    balance roundrobin
    option httpchk GET /health
    http-check expect status 200
    
    server web1 192.168.1.101:3000 check inter 2000 rise 2 fall 3
    server web2 192.168.1.102:3000 check inter 2000 rise 2 fall 3
    server web3 192.168.1.103:3000 check inter 2000 rise 2 fall 3
    server web4 192.168.1.104:3000 check inter 2000 rise 2 fall 3 backup

수동 스케일링 스크립트:

#!/bin/bash
# auto_scale.sh - 간단한 오토스케일링 스크립트

THRESHOLD_HIGH=70
THRESHOLD_LOW=30
MAX_SERVERS=10
MIN_SERVERS=2

while true; do
  # 현재 CPU 사용률 확인
  CPU_USAGE=$(ssh web1 "top -bn1 | grep 'Cpu(s)' | awk '{print \$2}' | cut -d'%' -f1")
  ACTIVE_SERVERS=$(grep "^    server web" /etc/haproxy/haproxy.cfg | grep -v backup | wc -l)
  
  echo "[$(date)] CPU: ${CPU_USAGE}%, 활성 서버: ${ACTIVE_SERVERS}대"
  
  # 스케일 아웃 조건
  if (( $(echo "$CPU_USAGE > $THRESHOLD_HIGH" | bc -l) )) && [ $ACTIVE_SERVERS -lt $MAX_SERVERS ]; then
    echo "🚀 서버 추가 중..."
    NEXT_SERVER=$((ACTIVE_SERVERS + 1))
    
    # 새 VM 시작
    virsh start web${NEXT_SERVER}
    sleep 30
    
    # HAProxy에 추가
    sed -i "/backend http_back/a\    server web${NEXT_SERVER} 192.168.1.1${NEXT_SERVER}:3000 check" /etc/haproxy/haproxy.cfg
    systemctl reload haproxy
    
    echo "✅ web${NEXT_SERVER} 추가 완료"
  fi
  
  # 스케일 인 조건
  if (( $(echo "$CPU_USAGE < $THRESHOLD_LOW" | bc -l) )) && [ $ACTIVE_SERVERS -gt $MIN_SERVERS ]; then
    echo "➖ 서버 제거 중..."
    
    # HAProxy에서 제거
    sed -i "/server web${ACTIVE_SERVERS}/d" /etc/haproxy/haproxy.cfg
    systemctl reload haproxy
    
    sleep 60  # 드레인 시간
    
    # VM 종료
    virsh shutdown web${ACTIVE_SERVERS}
    
    echo "✅ web${ACTIVE_SERVERS} 제거 완료"
  fi
  
  sleep 60  # 1분마다 체크
done

🎓 마무리: 핵심 요약 및 체크리스트

와! 여기까지 읽었다면 정말 대단해! 👏
이제 쇼핑몰 트래픽 급증에 완벽하게 대응할 수 있는 지식을 갖췄어.
마지막으로 핵심 내용을 정리해볼게! 📝

🎯 핵심 개념 요약

✅ 구축 전 체크리스트

🚀 다음 단계

이제 기본은 마스터했어! 더 깊이 공부하고 싶다면: 📚

1. 고급 주제:
• 서비스 메시 (Istio, Linkerd)
• 서버리스 아키텍처 (Lambda, Cloud Functions)
• 마이크로서비스 패턴
• 이벤트 드리븐 아키텍처
• CQRS 및 Event Sourcing

2. 실습 프로젝트:
• 간단한 쇼핑몰 프로토타입 구축
• 부하 테스트 시나리오 작성
• 모니터링 대시보드 커스터마이징
• 비용 최적화 시뮬레이션
• 장애 대응 훈련

3. 커뮤니티 참여:
• AWS/Azure/GCP 사용자 그룹
• DevOps Korea 커뮤니티
• Stack Overflow 질문/답변
• 기술 블로그 운영
• 오픈소스 프로젝트 기여

🎉 마지막 한마디

친구야, 여기까지 정말 수고했어! 🎊
쇼핑몰 트래픽 급증 대응은 단순히 기술만의 문제가 아니야.
사용자 경험, 비용 효율, 안정성을 모두 고려해야 하는 종합 예술이지.

처음에는 복잡해 보이겠지만, 하나씩 차근차근 구현하다 보면
어느새 너도 인프라 전문가가 되어 있을 거야! 💪

기억해:
• 작게 시작해서 점진적으로 개선하기
• 모니터링과 측정을 통해 데이터 기반 의사결정
• 실패를 두려워하지 말고 빠르게 배우기
• 커뮤니티와 소통하며 지식 공유하기

이 글이 너의 쇼핑몰 개발 여정에 도움이 되었길 바라! 🚀
궁금한 점이 있으면 언제든 댓글로 물어봐.
함께 성장하는 개발자가 되자! 🌟

Happy Scaling! 🎯