k6とGrafanaによる分散負荷テストとパフォーマンスプロファイリング

// Example: Basic k6 load testing script with custom thresholds and checks
import http from 'k6/http';
import { check, sleep } from 'k6';

export const options = {
  stages: [
    { duration: '30s', target: 50 },  // Ramp-up to 50 Virtual Users
    { duration: '1m', target: 200 },  // Stay at 200 VUs for peak load test
    { duration: '30s', target: 0 },   // Ramp-down to 0 VUs
  ],
  thresholds: {
    http_req_duration: ['p(95)<250', 'p(99)<500'], // 95% of requests must complete under 250ms
    http_req_failed: ['rate<0.01'],                 // Error rate must remain under 1%
  },
};

export default function () {
  const res = http.get('https://api.example.com/v1/catalog');
  
  check(res, {
    'status is 200': (r) => r.status === 200,
    'response body contains catalog': (r) => r.body.includes('products'),
  });

  sleep(1); // Simulating realistic user think-time between requests
}

# Kubernetes Spec: Distributed load test using k6-operator Custom Resource
apiVersion: k6.io/v1alpha1
kind: K6
metadata:
  name: distributed-black-friday-test
  namespace: load-testing
spec:
  parallelism: 4 # Spawns 4 parallel worker pods running k6
  script:
    configMap:
      name: k6-test-scripts
      file: load-test.js
  arguments: --tag testid=black-friday-sim
  runner:
    resources:
      limits:
        cpu: "2"
        memory: "2Gi"
      requests:
        cpu: "1"
        memory: "1Gi"

// Example: Testing gRPC endpoints under load using k6/net/grpc
import grpc from 'k6/net/grpc';
import { check, sleep } from 'k6';

const client = new grpc.Client();
client.load(['definitions'], 'user_service.proto');

export const options = {
  vus: 50,
  duration: '1m',
};

export default function () {
  client.connect('grpc.example.com:443', { plaintext: false });

  const response = client.invoke('user.UserService/GetUserProfile', { userId: 101 });
  check(response, {
    'status is OK': (r) => r && r.status === grpc.StatusOK,
  });

  client.close();
  sleep(1);
}

// Advanced multi-scenario k6 load test script
import http from 'k6/http';
import { check, group, sleep } from 'k6';
import { Rate, Trend } from 'k6/metrics';

// Custom Prometheus metrics registered in k6
const checkoutErrorRate = new Rate('checkout_failure_rate');
const DBProcessingTrend = new Trend('db_query_duration_ms');

export const options = {
  scenarios: {
    constant_browsing: {
      executor: 'constant-vus',
      vus: 100,
      duration: '3m',
    },
    checkout_spike: {
      executor: 'ramping-arrival-rate',
      startRate: 10,
      timeUnit: '1s',
      preAllocatedVUs: 50,
      maxVUs: 300,
      stages: [
        { duration: '1m', target: 50 },  // 50 checkouts/sec
        { duration: '2m', target: 200 }, // Spike to 200 checkouts/sec
      ],
    },
  },
  thresholds: {
    'checkout_failure_rate': ['rate<0.005'], // Checkout errors must stay under 0.5%
    'http_req_duration{scenario:checkout_spike}': ['p(95)<400'],
  },
};

export default function () {
  group('Browsing Catalog', function () {
    const res = http.get('https://api.example.com/v1/products');
    check(res, { 'catalog status 200': (r) => r.status === 200 });
  });

  group('Executing Checkout', function () {
    const payload = JSON.stringify({ cartId: 'cart_9912', paymentToken: 'tok_test' });
    const params = { headers: { 'Content-Type': 'application/json' } };
    
    const res = http.post('https://api.example.com/v1/checkout', payload, params);
    const success = check(res, { 'checkout success': (r) => r.status === 201 });
    
    checkoutErrorRate.add(!success);
    if (res.headers['X-DB-Duration']) {
      DBProcessingTrend.add(parseFloat(res.headers['X-DB-Duration']));
    }
  });

  sleep(2);
}

// Parameterizing test dataset inputs using SharedArray in k6
import { SharedArray } from 'k6/data';

const userCredentials = new SharedArray('user credentials pool', function () {
  // SharedArray parses heavy JSON fixtures once into shared V8 memory
  return JSON.parse(open('data/users.json'));
});

export default function () {
  const user = userCredentials[Math.floor(Math.random() * userCredentials.length)];
  const res = http.post('https://api.example.com/v1/login', JSON.stringify(user), {
    headers: { 'Content-Type': 'application/json' },
  });
  check(res, { 'login ok': (r) => r.status === 200 });
}

# Executing k6 test with direct Prometheus Remote Write output integration
K6_PROMETHEUS_REMOTE_URL="http://prometheus.monitoring.svc:9090/api/v1/write" \
K6_PROMETHEUS_FLUSH_INTERVAL="2s" \
k6 run \
  -o experimental-prometheus-rw \
  --tag test_run_id="build-4091" \
  load-test.js

# PromQL Query Examples for Grafana Dashboard Panels

# 1. Real-time Requests Per Second (RPS) by HTTP Status Code
sum(rate(k6_http_reqs_total[30s])) by (status)

# 2. 95th Percentile Response Latency in Milliseconds by Endpoint Path
histogram_quantile(0.95, sum(rate(k6_http_req_duration_bucket[1m])) by (le, expected_response, url))

# 3. Virtual User (VU) Active Worker Count Over Time
k6_vus_active

# 4. Custom Error Rate Percentage
(sum(rate(k6_checkout_failure_rate_total{result="true"}[1m])) / sum(rate(k6_checkout_failure_rate_total[1m]))) * 100

// Grafana Panel JSON Snippet: 95th Percentile Latency Alert Rule
{
  "title": "95th Percentile API Latency Alert",
  "type": "timeseries",
  "targets": [
    {
      "expr": "histogram_quantile(0.95, sum(rate(k6_http_req_duration_bucket[1m])) by (le))",
      "legendFormat": "p95 latency (ms)"
    }
  ],
  "fieldConfig": {
    "defaults": {
      "thresholds": {
        "mode": "absolute",
        "steps": [
          { "color": "green", "value": null },
          { "color": "yellow", "value": 250 },
          { "color": "red", "value": 500 }
        ]
      }
    }
  }
}

// k6 script injecting OpenTelemetry Trace Context headers for request tracing
import http from 'k6/http';
import { check } from 'k6';
import crypto from 'k6/crypto';

function generateTraceparent() {
  const version = '00';
  const traceId = crypto.hexDigest('sha256', `${Math.random()}`).substring(0, 32);
  const parentId = crypto.hexDigest('sha256', `${Math.random()}`).substring(0, 16);
  const flags = '01'; // Sampled flag enabled
  return `${version}-${traceId}-${parentId}-${flags}`;
}

export default function () {
  const params = {
    headers: {
      'Content-Type': 'application/json',
      'traceparent': generateTraceparent(), // Propagate trace header to backend
    },
  };

  const res = http.get('https://api.example.com/v1/orders/recent', params);
  check(res, { 'status is 200': (r) => r.status === 200 });
}

# Executing Go pprof CPU profile during k6 load test run
go tool pprof -http=:8081 http://backend-service:6060/debug/pprof/profile?seconds=30

// Example: Node.js Express server middleware tracking internal execution stages
import { Request, Response, NextFunction } from 'express';

export function performanceHeaderMiddleware(req: Request, res: Response, next: NextFunction) {
  const start = process.hrtime();
  
  res.on('finish', () => {
    const diff = process.hrtime(start);
    const timeInMs = (diff[0] * 1e3 + diff[1] * 1e-6).toFixed(2);
    // Expose internal server processing time in header for k6 analysis
    res.setHeader('X-Server-Execution-Time', `${timeInMs}ms`);
  });
  
  next();
}

# GitHub Actions workflow executing automated k6 performance regression gate
name: Performance Testing Gate
on:
  pull_request:
    branches: [main]

jobs:
  k6-load-test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Pull k6 Docker Image
        run: docker pull grafana/k6:latest

      - name: Run k6 Load Test
        run: |
          docker run --rm \
            -v $(pwd):/ci \
            -w /ci \
            grafana/k6:latest run \
            --thresholds "http_req_duration=p(95)<300" \
            e2e/load-tests/smoke-test.js