Run Load Test

Execute comprehensive load tests to measure API performance, identify bottlenecks, and validate scalability under realistic traffic patterns.

Design Decisions

This command supports multiple load testing tools to accommodate different testing scenarios and team preferences:

• k6: Chosen for developer-friendly JavaScript API, excellent CLI output, and built-in metrics
• Artillery: Selected for YAML configuration simplicity and scenario-based testing
• Gatling: Included for enterprise-grade reporting and Scala DSL power users

Alternative approaches considered:

• JMeter: Excluded due to GUI-heavy approach and XML configuration complexity
• Locust: Considered but not included to limit Python dependencies
• Custom solutions: Avoided to leverage battle-tested tools with proven metrics accuracy

When to Use This Command

USE WHEN:

• Validating API performance before production deployment
• Establishing baseline performance metrics for SLAs
• Testing autoscaling behavior under load
• Identifying memory leaks or resource exhaustion issues
• Comparing performance across API versions
• Simulating Black Friday or high-traffic events

DON'T USE WHEN:

• Testing production APIs without permission (use staging environments)
• You need functional correctness testing (use integration tests instead)
• Testing third-party APIs you don't control
• During active development (use unit/integration tests first)

Prerequisites

Required:

• Node.js 18+ (for k6 and Artillery)
• Java 11+ (for Gatling)
• Target API endpoint accessible from your machine
• API authentication credentials (if required)

Recommended:

• Monitoring tools configured (Prometheus, Grafana, DataDog)
• Baseline metrics from previous test runs
• Staging environment that mirrors production capacity

Install Tools:

# k6 (recommended for most use cases)
brew install k6  # macOS
sudo apt-get install k6  # Ubuntu

# Artillery
npm install -g artillery

# Gatling
wget https://repo1.maven.org/maven2/io/gatling/highcharts/gatling-charts-highcharts-bundle/3.9.5/gatling-charts-highcharts-bundle-3.9.5.zip
unzip gatling-charts-highcharts-bundle-3.9.5.zip

Detailed Process

Step 1: Define Test Objectives

Establish clear performance targets before running tests:

• Response time: p95 < 200ms, p99 < 500ms
• Throughput: 1000 requests/second sustained
• Error rate: < 0.1% under normal load
• Concurrent users: Support 500 simultaneous users

Document expected behavior under different load levels:

• Normal load: 100-500 RPS
• Peak load: 1000-2000 RPS
• Stress test: 3000+ RPS until failure

Step 2: Configure Test Scenario

Create test scripts matching realistic user behavior patterns:

k6 test script (load-test.js):

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

export const options = {
  stages: [
    { duration: '2m', target: 100 },  // Ramp-up
    { duration: '5m', target: 100 },  // Sustained load
    { duration: '2m', target: 200 },  // Scale up
    { duration: '5m', target: 200 },  // Sustained peak
    { duration: '2m', target: 0 },    // Ramp-down
  ],
  thresholds: {
    http_req_duration: ['p(95)<200', 'p(99)<500'],
    http_req_failed: ['rate<0.01'],
  },
};

export default function () {
…

Artillery config (artillery.yml):

config:
  target: 'https://api.example.com'
  phases:
    - duration: 60
      arrivalRate: 10
      name: "Warm up"
    - duration: 300
      arrivalRate: 50
      name: "Sustained load"
    - duration: 120
      arrivalRate: 100
      name: "Peak load"
  processor: "./flows.js"
scenarios:
  - name: "Product browsing flow"
    flow:
      - get:
          url: "/v1/products"
…

Step 3: Execute Load Test

Run tests with appropriate parameters and monitor system resources:

# k6 test execution with custom parameters
k6 run load-test.js \
  --vus 100 \
  --duration 10m \
  --out json=results.json \
  --summary-export=summary.json

# Artillery with real-time reporting
artillery run artillery.yml \
  --output report.json

# Gatling test execution
./gatling.sh -s com.example.LoadTest \
  -rf results/

Monitor system metrics during execution:

• CPU utilization (should stay below 80%)
• Memory consumption (watch for leaks)
• Network I/O (bandwidth saturation)
• Database connections (connection pool exhaustion)

Step 4: Analyze Results

Review metrics to identify performance bottlenecks: