Spring Boot 벤치마크 리포트

1. 테스트 방법론

테스트 환경

애플리케이션	Spring PetClinic 4.0.0 (GitHub)
Spring Boot	4.0.1
Java	OpenJDK 21.0.9
JVM 옵션	-XX:MaxRAMPercentage=60.0 -XX:+UseG1GC
플랫폼	Amazon EKS 1.34
노드 프로비저닝	Karpenter 1.5.0
노드 격리	podAntiAffinity (단일 노드 보장)

wrk 벤치마크 설정

wrk 버전	4.2.0 (epoll)
테스트 1	50 conn, 60초 (Light Load)
테스트 2	100 conn, 60초 (Normal Load)
테스트 3	200 conn, 30초 (High Load)
반복 횟수	5회
인스턴스	51종 (xlarge, 4 vCPU)

🌐 네트워크 구성 - Same Zone 배치

wrk 클라이언트와 Spring Boot 서버는 같은 Availability Zone에 배치
podAffinity를 사용하여 wrk 클라이언트가 서버와 동일한 Zone에 스케줄링
네트워크 지연 최소화로 순수 애플리케이션 성능 측정

측정 메트릭

Requests/sec: 초당 처리 HTTP 요청 수 - 높을수록 좋음
Latency P50: 50% 요청 응답 시간 - 낮을수록 좋음
Latency P99: 99% 요청 응답 시간 - 낮을수록 좋음
Cold Start: JVM + Spring Boot + PetClinic 초기화 시간 - 낮을수록 좋음

2. wrk 테스트 시나리오별 결과

Top 20 인스턴스 - High Load (200 conn, 30s)

Top 20 인스턴스 - Normal Load (100 conn, 60s)

Top 20 인스턴스 - Light Load (50 conn, 60s)

시나리오별 성능 비교

인스턴스별 3가지 부하 시나리오 비교

핵심 인사이트

c7i-flex가 모든 시나리오 1위 - 50 conn: 87.5k, 100 conn: 94.6k, 200 conn: 101.7k req/sec
부하 증가에 따른 성능 변화: 7세대 Flex는 부하 증가 시 성능이 더 향상되는 패턴
8세대 Standard: 안정적인 성능, 부하 증가에 따른 성능 향상 폭이 큼
c5d의 역설적 패턴: 5세대 C-series 중 가장 낮은 latency(3.2ms)를 보이지만 throughput은 중하위권. 50→100 conn에서 성능 상승 후 200 conn에서 급락(38k→27k). NVMe 로컬 스토리지의 I/O 인터럽트가 CPU와 경쟁하여 고부하 시 스케일링 한계 발생

3. 세대별 아키텍처 성능 비교

5세대: Intel + AMD | 6~8세대: Intel + Graviton

아키텍처별 세대별 성능 비교

세대별 wrk Throughput 평균 (200 conn, 아키텍처 구분)

세대별 100 conn 성능

세대별 50 conn 성능

세대별 성능 향상

Intel 5세대 → 8세대: +171% 향상 (34k → 93k req/sec)
Graviton 6세대 → 8세대: +137% 향상 (31k → 74k req/sec)
Intel 7세대 Flex: 특이 케이스 - Standard보다 높은 성능 (재테스트 확인됨)

4. Latency 분석 (200 conn)

Latency P50 (중앙값) - 낮을수록 좋음

Latency P99 (99퍼센타일) - 낮을수록 좋음

Throughput vs Latency

처리량 대비 Latency (버블 크기 = P99 Latency)

Latency 인사이트

c7i-flex: 최고 처리량 + 낮은 latency (P50: 1.7ms, P99: 4.6ms)
8세대 Intel: P50 1.9-2.0ms로 안정적인 응답 시간
c6in 주의: P99 latency가 184ms로 매우 높음 (tail latency 문제)

5. Flex 인스턴스 성능 분석

✅ 재테스트 결과: 7세대 Flex 고성능 확인

c7i-flex 재테스트: 104,649 req/sec (기존 101,657) → 고성능 재현 확인
m7i-flex 재테스트: 105,512 req/sec (기존 97,607) → 고성능 재현 확인
7세대 Flex가 8세대 Flex보다 wrk 처리량에서 더 높은 성능은 실제 현상

Flex 인스턴스 상세 비교

인스턴스	50 conn	100 conn	200 conn	P99 Latency	Cold Start
c7i-flex.xlarge	87,512	94,639	101,658	4.59ms	5.08초
m7i-flex.xlarge	79,660	88,417	97,607	5.02ms	5.35초
c8i-flex.xlarge	61,541	80,121	91,741	4.76ms	4.51초
r8i-flex.xlarge	62,212	80,328	91,191	4.72ms	4.69초

Flex vs Standard wrk 비교 (200 conn)

Flex Cold Start 비교

분석 및 결론

7세대 Flex 고성능 원인 추정: AWS의 물리 호스트 할당 정책, 특정 CPU bin 선택 등
8세대 Flex Cold Start 우수: JVM 초기화에서는 8세대가 확실히 빠름
워크로드별 선택: 지속적 고부하는 7세대 Flex, Cold Start 중요하면 8세대

5.1 지속 부하 테스트 (Time-Series) - 핵심 분석

왜 이 테스트가 중요한가?

단발성 벤치마크(wrk 30-60초)는 burst 성능을 측정합니다. 실제 프로덕션 워크로드는 12분, 1시간, 24시간 이상 지속됩니다. 이 테스트는 지속적인 부하 상황에서의 실제 성능을 측정합니다.

테스트 조건: 600초(10분) 지속 부하 × 5회 반복, 30초 warmup (JIT 컴파일), 2 threads, 100 connections, 10초 간격 샘플링
데이터 소스: results/springboot-flex/timeseries-all.csv (5 runs × 60 points per run)

Flex vs Standard vs Graviton4 시간별 Throughput (600초 지속 부하, Run 2)

c7i-flex 평균

92,551

req/sec | CV 8.9%

c8i-flex 평균

84,409

req/sec | CV 8.2%

c7i가 더 빠름

+8.9%

burst 성능 우수

r8i-flex 평균

84,270

req/sec | CV 8.1%

평균 Throughput 비교

변동계수(CV%) - 낮을수록 안정적

Flex vs Standard 인스턴스 상세 비교 (5회 측정 통계)

인스턴스	평균 Throughput	최소값	최대값	표준편차	변동계수(CV)	패턴
c7i-flex.xlarge 7세대 Flex	92,551	53,507	107,657	8,198	8.9%	Burst
c8i-flex.xlarge 8세대 Flex	84,409	70,069	93,348	6,911	8.2%	Moderate
m7i-flex.xlarge 7세대 Flex	71,188	60,396	78,627	3,303	4.6%	Steady
r8i-flex.xlarge 8세대 Flex	84,270	66,486	92,189	6,811	8.1%	Moderate
c8i.xlarge 8세대 Standard	80,526	70,121	87,515	5,098	6.3%	Steady
c8g.xlarge Graviton4	64,393	59,737	68,495	2,432	3.8%	Most Stable

CV% (변동계수) 해석 - Same-AZ 측정 (수정됨)

c8g Graviton4 (3.8%): 가장 안정적 - 낮은 throughput이지만 일관된 성능
m7i-flex (4.6%): 매우 안정적 - 예측 가능한 성능
c8i Standard (6.3%): 안정적 - Burst 없이 꾸준한 80K 유지
c8i-flex, r8i-flex (8%): 보통 수준 - 10% 이내 등락
c7i-flex (8.8%): Burst 패턴 - 높은 피크(107K), 넓은 변동폭

⚠ 관찰 결과: 7세대 Flex가 8세대보다 더 높은 Throughput 기록

1. 측정된 Throughput 차이

c7i-flex: 평균 92,551 req/sec, 피크 107K
c8i-flex: 평균 84,409 req/sec, 피크 93K
차이: 7세대가 약 9% 더 높은 평균 Throughput

2. 성능 변동 패턴 차이

c7i-flex: CV 8.9% - 넓은 변동폭 (Burst 패턴)
c8i-flex: CV 8.2% - 상대적으로 안정적
m7i-flex: CV 4.6% - 가장 안정적인 성능

3. Standard vs Flex (Same-AZ 수정)

c8i.xlarge (Standard): 80,526 req/sec, CV 6.3%
c8i-flex.xlarge: 84,409 req/sec, CV 8.2%
결론: Flex가 ~5% 높지만 Standard가 더 안정적

4. c8g Graviton4 (Same-AZ 수정)

평균 Throughput: 64,393 req/sec
CV%: 3.8% - 가장 안정적인 성능
특징: 낮은 throughput이지만 가장 예측 가능

CPU Burst Behavior 분석 (Same-AZ 수정)

c7i-flex: Higher burst ceiling - 피크 107K+ req/sec, 더 넓은 변동폭 (CV 8.8%)
c8i-flex: More conservative burst - 피크 93K, steadier at 84K (CV 8.2%)
c8i Standard: No burst - stable at 80K with lowest CV (6.3%)
c8g Graviton4: Lowest throughput (64K) but most stable (CV 3.8%)

권장: Burst-tolerant workloads는 c7i-flex, 안정성 중시는 c8i 또는 c8g 선택

데이터 기반 증거 (Same-AZ Time-Series 5회 측정, Run 2 대표값)

c7i-flex 패턴 (평균 92,551, CV 8.8%):

10초: 79,393 (warmup 직후)
50초: 105,713 (피크)
150초: 78,571 (급락 -26%)
360초: 107,350 (최고점)
패턴: 70K-107K 넓은 진폭 반복

c8i-flex 패턴 (평균 84,409, CV 8.2%):

10초: 92,240 (높은 시작)
90초: 72,840 (최저점)
200초: 93,347 (최고점)
변동폭: ~20,000 (CV 8.2%)
패턴: c7i보다 안정, 73K-93K

c8i Standard 패턴 (평균 80,526, CV 6.3%):

10초: 87,343 (높은 시작)
90초: 70,997 (최저점)
390초: 86,768 (최고점)
변동폭: ~16,000 (CV 6.3%)
패턴: Flex보다 안정적, 71K-87K

c8g Graviton4 패턴 (평균 64,393, CV 3.8%):

10초: 64,311 (안정 시작)
280초: 60,926 (최저점)
330초: 68,495 (최고점)
변동폭: ~8,000 (CV 3.8%)
패턴: 가장 안정적, 60K-68K

용도별 권장 선택 (Same-AZ 기준)

최대 Throughput 필요	c7i-flex.xlarge - 평균 92.5K req/sec, 피크 107K
일관된 성능 (SLA)	c8g.xlarge - CV 3.8% 가장 안정 또는 m7i-flex CV 4.6%
균형 (Throughput + 안정성)	c8i.xlarge - 80.5K req/sec, CV 6.3%로 안정적
Auto-scaling 환경	c8i-flex/r8i-flex - CV 8%대로 예측 가능한 성능
비용 효율 (Graviton)	c8g.xlarge - 낮은 throughput이지만 최고 안정성 + 저렴한 가격

5.2 Standard vs Flex 인스턴스 비교 (c8i, c8g)

Redis Time-Series와 비교를 위한 추가 테스트

c8i.xlarge(Intel 8세대)와 c8g.xlarge(Graviton4)를 동일 조건(600초 × 5회)으로 테스트하여 Flex 인스턴스와 비교합니다.

c8i.xlarge (Standard)

80,526

req/sec (CV 6.3%, 안정적)

c8g.xlarge (Graviton)

64,393

req/sec (CV 3.8%, 가장 안정)

Flex vs Standard

+5%

c8i-flex: 84K vs c8i: 80K

Standard 인스턴스 상세 통계 (Same-AZ 5회 측정)

인스턴스	평균	최소값	최대값	CV%	특징
c8i.xlarge Intel 8세대	80,526	70,121	87,515	6.3%	Steady pattern, Burst 없이 안정적
c8g.xlarge Graviton4	64,393	59,737	68,495	3.8%	가장 안정적, 낮은 throughput

핵심 인사이트 (Same-AZ 수정)

Flex vs Standard 차이 축소: Same-AZ에서 c8i-flex(84K) vs c8i(80K)는 ~5% 차이로 축소됨
c8g Graviton4: CV 3.8%로 가장 안정적 - 낮은 throughput(64K)이지만 예측 가능한 성능
c8i Standard: CV 6.3%로 Flex(8.2%)보다 안정적 - Burst 없이 꾸준한 80K 유지
권장: 최대 성능은 Flex, 안정성 중시는 Standard 또는 Graviton

6. Cold Start 성능 분석

측정 대상: Spring PetClinic (실제 프로덕션급 샘플 앱) 시작 시간
JVM 부팅 → Spring Context 초기화 → JPA/Hibernate 설정 → 웹 서버 시작까지 전체 시간

Cold Start Top 20 (낮을수록 좋음)

세대별 Cold Start 평균 (아키텍처 구분)

아키텍처별 Cold Start 평균

Cold Start 인사이트

Graviton4가 최고 - c8g 4.29초로 가장 빠른 시작
8세대 Intel: 4.3-4.8초대로 7세대(5.0-5.8초) 대비 15-20% 개선
5세대 AMD: 11초대로 가장 느림 - 서버리스/오토스케일링에 부적합

7. 가격 대비 성능 (Cost Efficiency)

시간당 비용 대비 성능 분석 - HTTP 처리량 및 Cold Start 효율

가격 vs 처리량 (RPS@200conn) - 우상단이 고성능, 좌측이 저가격

가성비 인사이트

최고 가성비: c8g.xlarge - Graviton4 + 최저가로 압도적 효율
Flex 모델 강점: c7i-flex, c8i-flex가 일반 모델 대비 가성비 우수
Graviton 효율: 낮은 가격 + 안정적 성능으로 가성비 상위권 독점
비용 최적화: 고성능이 필요하면 c7i-flex, 가성비 우선이면 c8g 권장

8. 전체 결과

인스턴스 ↕	아키텍처	세대	50 conn ↕	100 conn ↕	200 conn ↕	P50 ↕	P99 ↕	Cold Start ↕

8. 결론 및 권장사항

✅ 권장 인스턴스

최고 Throughput (Burst): c7i-flex.xlarge (101,658 req/sec)
최고 Throughput (Sustained): c7i-flex.xlarge (79K avg)
최고 Cold Start: c8g.xlarge (4.29초)
안정적 성능: c8i-flex.xlarge (CV 1.1%)
비용 효율: c8g.xlarge (Graviton4)

⚠️ 주의사항

c6in P99 Latency: 184ms로 매우 높음 - 피하세요
5세대 AMD: Cold Start가 11초대 - 서버리스에 부적합
Flex 선택: Burst 워크로드는 7세대, SLA 필요시 8세대

📊 Time-Series 핵심 결론 (5회 × 600초 측정)

7세대 vs 8세대 (Flex)

7세대가 9% 빠름

c7i-flex 92K vs c8i-flex 84K

가장 안정적

m7i-flex

CV: 4.6% (가장 낮음)