Gatling으로 시작하는 성능 최적화 여행기

plugins {
    id 'java'
    id("io.gatling.gradle") version "3.13.1" // Gatling Gradle 플러그인 추가
}

dependencies {
    implementation 'io.gatling:gatling-core-java:3.13.1' // Java용 Gatling Core
    implementation 'io.gatling:gatling-http-java:3.13.1' // HTTP 프로토콜 지원
}

$ sudo vim /Library/LaunchDaemons/limit.maxfiles.plist

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
    <key>Label</key>
    <string>limit.maxfiles</string>
    <key>ProgramArguments</key>
    <array>
        <string>launchctl</string>
        <string>limit</string>
        <string>maxfiles</string>
        <string>8192</string>
        <string>65536</string>
    </array>
    <key>RunAtLoad</key>
    <true/>
</dict>
</plist>

$ sudo chmod 644 /Library/LaunchDaemons/limit.maxfiles.plist
$ sudo chown root:wheel /Library/LaunchDaemons/limit.maxfiles.plist

$ sudo reboot

launchctl limit

package payment;

import io.gatling.javaapi.core.ScenarioBuilder;

import java.util.Iterator;

import static io.gatling.javaapi.core.CoreDsl.*;

public class PaymentSimulations extends BasePaymentSimulation {
    // 1. 일일 기본 부하 테스트 시나리오
    ScenarioBuilder dailyLoadTest = scenario("일일_기본_부하_테스트")
            .feed(Iterator.class.cast(feeder))
            .exec(paymentRequest("일일_기본_결제_요청"));

    // 2. 이벤트성 부하 테스트 시나리오
    ScenarioBuilder eventLoadTest = scenario("이벤트_부하_테스트")
            .feed(Iterator.class.cast(feeder))
            .exec(paymentRequest("이벤트_결제_요청"));

    // 3. 스트레스 테스트 시나리오
    ScenarioBuilder stressTest = scenario("스트레스_테스트")
            .feed(Iterator.class.cast(feeder))
            .exec(paymentRequest("스트레스_결제_요청"));

    // 4. 단계적 증가 테스트 시나리오
    ScenarioBuilder incrementalLoadTest = scenario("단계적_증가_테스트")
            .feed(Iterator.class.cast(feeder))
            .exec(paymentRequest("단계적_증가_결제_요청"));


    {
        setUp(
                dailyLoadTest.injectOpen(
                        // 일일 부하 테스트 시나리오
                        rampUsers(50).during(10),                      // 10초 동안 50명 점진적 증가
                        constantUsersPerSec(80).during(15),           // 초당 80명으로 15초 유지
                        rampUsersPerSec(80).to(150).during(10),      // 10초 동안 80명에서 150명으로 증가
                        constantUsersPerSec(150).during(20),          // 초당 150명으로 20초 유지
                        rampUsersPerSec(150).to(80).during(10)       // 10초 동안 150명에서 80명으로 감소
                ).andThen(
                        eventLoadTest.injectOpen(
                                // 이벤트 부하 테스트 시나리오
                                rampUsers(80).during(10),              // 10초 동안 80명 점진적 증가
                                constantUsersPerSec(120).during(15),   // 초당 120명으로 15초 유지
                                rampUsersPerSec(120).to(200).during(10), // 10초 동안 120명에서 200명으로 증가
                                constantUsersPerSec(200).during(20),    // 초당 200명으로 20초 유지
                                rampUsersPerSec(200).to(120).during(10)  // 10초 동안 200명에서 120명으로 감소
                        )
                ).andThen(
                        stressTest.injectOpen(
                                // 스트레스 테스트 시나리오
                                rampUsers(150).during(5),              // 5초 동안 150명 급격히 증가
                                constantUsersPerSec(150).during(15),   // 초당 150명으로 15초 유지
                                stressPeakUsers(250).during(5),        // 5초 동안 250명까지 스파이크
                                constantUsersPerSec(150).during(15),   // 다시 초당 150명으로 15초 유지
                                rampUsersPerSec(150).to(80).during(10) // 10초 동안 150명에서 80명으로 감소
                        )
                ).andThen(
                        incrementalLoadTest.injectOpen(
                                // 단계별 부하 증가 테스트
                                incrementUsersPerSec(60)              // 초당 60명씩 증가
                                        .times(3)                     // 3단계로 진행
                                        .eachLevelLasting(10)         // 각 단계는 10초 유지
                                        .separatedByRampsLasting(8)   // 단계 사이 8초 동안 점진적 증가
                                        .startingFrom(60)             // 초당 60명부터 시작
                        )
                )
        )
                .protocols(httpProtocol)
                .assertions(
                        global().responseTime().percentile3().lt(1000),   // 95%의 응답이 1000ms 이하
                        global().responseTime().percentile4().lt(1500),   // 99%의 응답이 1500ms 이하
                        global().responseTime().max().lt(2500),           // 최대 응답시간 2500ms 이하
                        global().successfulRequests().percent().gt(98d),  // 성공률 98% 이상
                        global().failedRequests().count().lt(200L)        // 실패 요청 200건 미만
                );
    }
}

...
bootRun {
    jvmArgs = [
            '-Xms2g', // 두 옵션은 맞춰주고 미리 설정해줘야 힙 리사이징 발생 안함
            '-Xmx2g',
            '-XX:+UseParallelGC',                       // Throughput에 최적화된 Parallel GC 사용
            '-XX:ParallelGCThreads=8',                  // 병렬 GC를 위한 스레드 수 (코어 수에 따라 조정)
            '-XX:InitiatingHeapOccupancyPercent=70',    // 70% 사용 시 GC 시작 (힙 활용률 증가)
            '-XX:MaxHeapFreeRatio=30',                  // 힙의 여유 공간 비율 최소화
            '-XX:MinHeapFreeRatio=10',                  // 힙의 여유 공간 비율 최소화
            '-XX:MaxMetaspaceSize=1g',                  // 메타스페이스 크기 최대 1GB로 설정
            '-XX:MetaspaceSize=128m',                   // 초기 메타스페이스 크기
            '-XX:+UseStringDeduplication',              // 문자열 중복 제거 활성화
            '-Xlog:gc*:file=gc.log:time,uptime,level,tags', // GC 로그 파일 저장
            '-XX:+UnlockExperimentalVMOptions',         // 실험적 옵션 활성화
            '-XX:+AlwaysPreTouch'                       // 애플리케이션 시작 시 힙 메모리 미리 할당
    ]
}

bootJar {
    launchScript()
}
...

server:
  tomcat:
    threads:
      max: 200                    # 더 많은 동시 요청 처리
      min-spare: 50             # 더 많은 대기 스레드 유지
    max-connections: 20000       # 더 많은 TCP 연결 허용
    accept-count: 500          # 더 큰 대기열
    connection-timeout: 3000    # 더 빠른 타임아웃으로 실패 빠르게 감지
    keep-alive-timeout: 10000   # Keep-Alive 시간 감소로 리소스 빠른 해제

  # 추가 서버 설정
  compression:
    enabled: true               # 응답 압축 활성화
    min-response-size: 1024     # 최소 압축 크기
  max-http-request-header-size: 40KB # HTTP 헤더 크기 제한

# 추가적인 Spring 설정
spring:
  mvc:
    async:
      request-timeout: 10000    # 비동기 요청 타임아웃 감소
  datasource:
    hikari:
      maximum-pool-size: 50     # DB 커넥션 풀 크기 증가
      minimum-idle: 20
      connection-timeout: 3000  # DB 연결 타임아웃 감소