스파이크 테스트(Spike Test)

스파이크 테스트는 시스템에 갑작스럽고 극단적인 부하를 주어 시스템의 반응을 측정하는 성능 테스트의 한 유형이다.
이는 마치 갑자기 많은 사람들이 한 번에 몰려드는 상황을 시뮬레이션하는 것과 비슷하다.

웹 서비스의 스파이크 테스트 예시:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

import time
from concurrent.futures import ThreadPoolExecutor
from monitoring import SystemMonitor

class SpikeTest:
    def __init__(self):
        self.monitor = SystemMonitor()
        self.base_load = 100  # 기본 사용자 수
        self.spike_load = 5000  # 스파이크 시 사용자 수
        
    def run_spike_test(self):
        """스파이크 테스트 실행"""
        print("스파이크 테스트 시작…")
        
        # 1. 기본 부하 상태 측정
        print("기본 부하 상태 측정 중…")
        base_metrics = self.measure_system_state(self.base_load)
        
        # 2. 스파이크 부하 생성
        print(f"스파이크 발생: {self.spike_load}명의 동시 사용자 생성")
        spike_metrics = self.generate_spike_load()
        
        # 3. 복구 과정 모니터링
        print("시스템 복구 과정 모니터링 중…")
        recovery_metrics = self.monitor_recovery()
        
        # 4. 결과 분석
        self.analyze_results(base_metrics, spike_metrics, recovery_metrics)
    
    def measure_system_state(self, user_count):
        """시스템 상태 측정"""
        with ThreadPoolExecutor(max_workers=user_count) as executor:
            # 동시 요청 생성
            futures = [
                executor.submit(self.simulate_user_request)
                for _ in range(user_count)
            ]
            
            # 응답 수집
            responses = [f.result() for f in futures]
            
        return {
            'response_times': [r['response_time'] for r in responses],
            'error_count': sum(1 for r in responses if r['error']),
            'system_metrics': self.monitor.get_current_metrics()
        }

특징과 목적

스파이크 테스트의 주요 특징과 목적은 다음과 같다:

  1. 급격한 부하 증가: 짧은 시간 동안 사용자 수를 급격히 증가시킨다.
  2. 시스템 회복력 평가: 극단적인 상황에서 시스템이 얼마나 빠르게 회복되는지 확인한다.
  3. 성능 병목 현상 식별: 급격한 부하 증가 시 발생하는 성능 저하의 원인을 파악한다.
  4. 장애 대비: 예상치 못한 트래픽 급증 상황에 대한 대비책을 마련한다.

테스트 범위

스파이크 테스트는 다음과 같은 범위를 포함한다:

  1. 웹 서버 및 애플리케이션 서버
  2. 데이터베이스 시스템
  3. 네트워크 인프라
  4. 로드 밸런서

종류

  1. 순수 스파이크 테스트: 갑작스러운 부하 증가 후 바로 감소하는 패턴을 테스트

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

    def pure_spike_test():
    """순수 스파이크 패턴 테스트"""
    # 기본 부하 상태
    simulate_base_load(100)

    # 갑작스러운 부하 증가
    print("스파이크 시작")
    spike_metrics = simulate_load(5000)  # 50배 증가

    # 부하 감소 및 복구 확인
    print("부하 감소")
    recovery_metrics = monitor_recovery()

    return analyze_spike_impact(spike_metrics, recovery_metrics)

  2. 복합 스파이크 테스트: 여러 번의 연속적인 스파이크를 테스트

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

    def multiple_spike_test():
    """복합 스파이크 패턴 테스트"""
    spike_patterns = [
        {"users": 1000, "duration": 60},  # 1분간 1000명
        {"users": 3000, "duration": 30},  # 30초간 3000명
        {"users": 5000, "duration": 15}   # 15초간 5000명
    ]

    results = []
    for pattern in spike_patterns:
        # 스파이크 생성
        metrics = generate_spike(pattern['users'], pattern['duration'])
        results.append(metrics)

        # 회복 시간 제공
        time.sleep(120)  # 2분 회복 시간

    return analyze_multiple_spikes(results)

수행 시점

스파이크 테스트는 주로 다음과 같은 시점에 수행된다:

  1. 대규모 이벤트나 프로모션 전
  2. 시스템 업그레이드 후
  3. 계절적 트래픽 급증이 예상될 때

검증 대상

주요 검증 대상은 다음과 같다:

  1. 응답 시간
  2. 오류율
  3. 시스템 복구 시간
  4. 리소스 사용률 (CPU, 메모리, 디스크 I/O)

진행 방식

스파이크 테스트는 다음과 같은 단계로 진행된다:

  1. 테스트 시나리오 설계: 예상되는 급격한 부하 증가 상황을 모델링한다.

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

    def prepare_spike_test():
    """스파이크 테스트 준비"""
    test_plan = {
        "기본_부하": 100,  # 일반적인 사용자 수
        "스파이크_부하": [
            1000,  # 첫 번째 스파이크
            3000,  # 두 번째 스파이크
            5000   # 세 번째 스파이크
        ],
        "측정_지표": [
            "응답시간",
            "에러율",
            "시스템_자원_사용률",
            "복구_시간"
        ],
        "성공_기준": {
            "최대_응답시간": "5초",
            "최대_에러율": "5%",
            "복구_시간": "3분 이내"
        }
    }
    return test_plan

  2. 기준 성능 측정: 정상 부하에서의 시스템 성능을 측정한다.

  3. 스파이크 부하 적용: 짧은 시간 동안 극단적인 부하를 가한다.

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

    def execute_spike_test():
    """스파이크 테스트 실행"""
    # 모니터링 시작
    monitoring = start_monitoring()

    try:
        # 기본 상태 측정
        baseline = measure_baseline_performance()

        # 스파이크 생성
        for spike_load in test_plan['스파이크_부하']:
            # 스파이크 부하 생성
            generate_spike_load(spike_load)

            # 시스템 반응 측정
            spike_impact = measure_system_response()

            # 복구 과정 모니터링
            recovery = monitor_system_recovery()

            # 결과 기록
            record_test_results(spike_load, spike_impact, recovery)

    finally:
        # 모니터링 종료
        stop_monitoring(monitoring)

  4. 시스템 모니터링: 부하 중 및 부하 후 시스템의 반응을 관찰한다.

  5. 결과 분석: 시스템의 성능 저하 및 복구 과정을 분석한다.

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

    def analyze_spike_test_results(test_data):
    """스파이크 테스트 결과 분석"""
    analysis = {
        "부하_영향": {
            "최대_응답시간": calculate_max_response_time(test_data),
            "평균_응답시간": calculate_avg_response_time(test_data),
            "에러_발생률": calculate_error_rate(test_data)
        },
        "복구_능력": {
            "복구_시간": calculate_recovery_time(test_data),
            "자원_정상화": analyze_resource_normalization(test_data)
        },
        "시스템_안정성": {
            "임계점": identify_breaking_point(test_data),
            "취약_구성요소": identify_weak_points(test_data)
        }
    }
    return generate_report(analysis)

예시

온라인 티켓 예매 시스템의 스파이크 테스트를 예로 들어보자:

  1. 시나리오: 인기 콘서트 티켓 오픈 1분 전, 10만 명의 사용자가 동시에 접속
  2. 테스트 실행:
    • 정상 상태에서 1,000명의 동시 접속자로 시작
    • 30초 만에 10만 명으로 급격히 증가
    • 5분간 유지 후 다시 정상 상태로 감소
  3. 모니터링 포인트:
    • 웹 서버의 응답 시간
    • 데이터베이스 쿼리 처리 속도
    • 오류 발생률
    • 시스템 복구 시간
  4. 결과 분석:
    • 최대 부하 시 응답 시간이 10초 이상으로 증가
    • 데이터베이스 연결 초과로 인한 오류 발생
    • 부하 감소 후 2분 내에 정상 상태로 복구

참고 및 출처