k6 완전 정복: 개발자를 위한 차세대 부하 테스트 도구 가이드 🚀

# macOS (Homebrew)
brew install k6

# Windows (Chocolatey)
choco install k6

# Windows (Winget)
winget install k6

# Linux (Debian/Ubuntu)
sudo gpg -k
sudo gpg --no-default-keyring --keyring /usr/share/keyrings/k6-archive-keyring.gpg --keyserver hkp://keyserver.ubuntu.com:80 --recv-keys C5AD17C747E3415A3642D57D77C6C491D6AC1D69
echo "deb [signed-by=/usr/share/keyrings/k6-archive-keyring.gpg] https://dl.k6.io/deb stable main" | sudo tee /etc/apt/sources.list.d/k6.list
sudo apt-get update
sudo apt-get install k6

# Docker
docker pull grafana/k6

import http from 'k6/http';
import { check, sleep } from 'k6';

// 테스트 옵션 설정
export const options = {
  vus: 10,        // 10개의 가상 사용자
  duration: '30s', // 30초간 실행
};

// 기본 테스트 함수
export default function () {
  const response = http.get('https://test-api.example.com/users');
  
  // 응답 검증
  check(response, {
    'status is 200': (r) => r.status === 200,
    'response time < 500ms': (r) => r.timings.duration < 500,
  });
  
  sleep(1); // 1초 대기
}

k6 run first-test.js

export const options = {
  stages: [
    { duration: '2m', target: 100 },   // Ramp-up: 2분 동안 100 VU까지 증가
    { duration: '5m', target: 100 },   // Steady state: 5분간 100 VU 유지
    { duration: '2m', target: 400 },   // Spike: 2분 동안 400 VU로 급증
    { duration: '5m', target: 400 },   // Spike sustain: 5분간 400 VU 유지
    { duration: '3m', target: 0 },     // Ramp-down: 3분 동안 종료
  ],
  thresholds: {
    http_req_duration: ['p(95)<500'],  // 95% 요청이 500ms 미만
    http_req_failed: ['rate<0.1'],     // 실패율 0.1% 미만
  },
};

export const options = {
  scenarios: {
    // 시나리오 1: 일반 브라우저 사용자
    browsing: {
      executor: 'constant-vus',
      vus: 50,
      duration: '10m',
      exec: 'browseProducts',
    },
    // 시나리오 2: 구매 전환 사용자 (더 높은 우선순위)
    purchasing: {
      executor: 'ramping-vus',
      startVUs: 0,
      stages: [
        { duration: '2m', target: 10 },
        { duration: '8m', target: 10 },
      ],
      exec: 'completePurchase',
      gracefulRampDown: '30s',
    },
    // 시나리오 3: API 클라이언트 (도착률 기반)
    api_calls: {
      executor: 'constant-arrival-rate',
      rate: 1000,
      timeUnit: '1m', // 분당 1000 요청
      duration: '10m',
      preAllocatedVUs: 20,
      maxVUs: 100,
      exec: 'apiRequests',
    },
  },
};

export function browseProducts() {
  http.get('https://shop.example.com/products');
  sleep(Math.random() * 3 + 1); // 1-4초 랜덤 대기
}

export function completePurchase() {
  const payload = JSON.stringify({ product: 'laptop', qty: 1 });
  http.post('https://shop.example.com/cart', payload, {
    headers: { 'Content-Type': 'application/json' },
  });
  sleep(2);
}

export function apiRequests() {
  http.get('https://api.example.com/v1/data');
}

import { SharedArray } from 'k6/data';
import papaparse from 'https://jslib.k6.io/papaparse/5.1.1/index.js';

// CSV 파일 로드
const csvData = new SharedArray('users', function () {
  return papaparse.parse(open('./users.csv'), { header: true }).data;
});

export default function () {
  const user = csvData[Math.floor(Math.random() * csvData.length)];
  
  const payload = JSON.stringify({
    username: user.username,
    password: user.password,
  });
  
  const response = http.post('https://api.example.com/login', payload, {
    headers: { 'Content-Type': 'application/json' },
  });
  
  check(response, {
    'login successful': (r) => r.status === 200 && r.json('token') !== '',
  });
}

import { Trend, Rate, Counter, Gauge } from 'k6/metrics';

// 커스텀 메트릭 정의
const loginDuration = new Trend('login_duration');
const checkoutErrorRate = new Rate('checkout_errors');
const itemsAdded = new Counter('items_added_to_cart');
const activeUsers = new Gauge('concurrent_shoppers');

export default function () {
  const start = Date.now();
  
  const loginRes = http.post('https://shop.example.com/login', credentials);
  loginDuration.add(Date.now() - start);
  
  if (loginRes.status !== 200) {
    checkoutErrorRate.add(1);
  }
  
  // 장바구니에 아이템 추가
  const cartRes = http.post('https://shop.example.com/cart/add', item);
  if (cartRes.status === 200) {
    itemsAdded.add(1);
  }
  
  activeUsers.add(1);
  sleep(5);
  activeUsers.add(-1);
}

# xk6 설치
go install go.k6.io/xk6/cmd/xk6@latest

# 브라우저 확장 포함된 k6 빌드
xk6 build --with github.com/grafana/xk6-browser

# 여러 확장 동시 포함
xk6 build \
  --with github.com/grafana/xk6-browser \
  --with github.com/grafana/xk6-sql \
  --with github.com/grafana/xk6-faker

# .github/workflows/performance.yml
name: Performance Tests

on:
  pull_request:
    branches: [main, develop]
  push:
    branches: [main]

jobs:
  smoke-test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      
      - name: Setup k6
        uses: grafana/setup-k6-action@v1
      
      - name: Run smoke tests
        uses: grafana/run-k6-action@v1
        with:
          path: ./tests/smoke.js
          flags: --env ENV=staging
        env:
          K6_CLOUD_TOKEN: ${{ secrets.K6_CLOUD_TOKEN }}
      
      - name: Upload results
        if: always()
        uses: actions/upload-artifact@v4
        with:
          name: k6-report
          path: ./summary.html

# .gitlab-ci.yml
performance_test:
  image: grafana/k6:latest
  stage: test
  script:
    - k6 run --out json=results.json tests/load.js
  artifacts:
    paths:
      - results.json
    expire_in: 1 week
  only:
    - merge_requests
    - main

// Jenkinsfile
pipeline {
    agent any
    
    environment {
        K6_TOKEN = credentials('k6-cloud-token')
    }
    
    stages {
        stage('Performance Test') {
            steps {
                sh '''
                    docker run --rm -v $(pwd):/tests \
                      -e K6_CLOUD_TOKEN=$K6_TOKEN \
                      grafana/k6:latest cloud /tests/load.js
                '''
            }
        }
    }
    
    post {
        always {
            publishHTML([
                allowMissing: false,
                alwaysLinkToLastBuild: true,
                keepAll: true,
                reportDir: 'results',
                reportFiles: 'index.html',
                reportName: 'k6 Performance Report'
            ])
        }
    }
}

export const options = {
  thresholds: {
    // HTTP 요청 기준
    http_req_duration: ['p(95)<500', 'p(99)<1000'],
    http_req_failed: ['rate<0.05'],
    
    // 비즈니스 로직 기준
    checks: ['rate>=0.95'],
    
    // 커스텀 메트릭 기준
    login_duration: ['avg<300', 'p(95)<600'],
    checkout_errors: ['rate<0.01'],
  },
  
  // Threshold 실패 시 테스트 중단
  abortOnFail: true,
};

# 로그인
k6 cloud login --token YOUR_TOKEN

# 클라우드에서 테스트 실행
k6 cloud script.js

# 특정 로드 존에서 실행
k6 cloud --ext-load-impact distribution='{"amazon:us:ashburn": 0.5, "amazon:de:frankfurt": 0.5}' script.js

// ❌ 잘못된 예: 메모리 누수 발생
const allResponses = [];

export default function () {
  const res = http.get('https://api.example.com/data');
  allResponses.push(res); // VU당 메모리 계속 증가
}

// ✅ 올바른 예: 필요한 데이터만 추출
export default function () {
  const res = http.get('https://api.example.com/data');
  
  // 필요한 값만 추출하고 바로 검증
  check(res, {
    'has valid data': (r) => r.json('status') === 'ok',
  });
  
  // 글로벌 메트릭에만 기록
  myMetric.add(res.timings.duration);
}

export const options = {
  // DNS 캐싱 활성화
  dns: {
    ttl: '5m', // 5분간 캐싱
    select: 'first', // 첫 번째 IP만 사용
    policy: 'preferIPv4',
  },
};

export const options = {
  // 연결 유지 설정
  batch: 20, // 배치 요청
  batchPerHost: 6, // 호스트당 최대 동시 연결
  noConnectionReuse: false, // 연결 재사용 활성화
  tlsAuth: null, // TLS 상호 인증 비활성화 (필요시)
};

# 상세 로그 출력
k6 run --verbose script.js

# HTTP 디버깅
k6 run --http-debug="full" script.js

# 특정 VU만 실행 (디버깅용)
k6 run --vus 1 --iterations 1 script.js

# 결과를 JSON으로 내보내기
k6 run --out json=results.json script.js