性能与负载测试：k6 / Locust / JMeter 工具链与生产级实践

                             ┌──────────────────┐
                             │ 你想测什么？      │
                             └────────┬─────────┘
                                      │
          ┌───────────────────────────┼───────────────────────────┐
          ▼                           ▼                           ▼
    正常负载下
    能不能撑住？                  极限在哪？                  长时间运行
          │                           │                       会不会挂？
          ▼                           ▼                           ▼
    ┌──────────┐              ┌──────────┐              ┌──────────┐
    │ Load Test │              │ Stress   │              │ Soak Test│
    │ 负载测试  │              │ Test     │              │ 浸泡测试  │
    └──────────┘              │ 压力测试  │              └──────────┘
                              └──────────┘
          │                           │
          ▼                           ▼
    并发 1000 用户               CPU 到 90% 时
    持续 1 小时                  吞吐量不再增长
                                  = 容量上限

请求延迟分布图（典型场景）

P50  (中位数) │███                      │  50ms   ← 50% 请求在此完成
P90           │███████                  │  120ms  ← 90% 请求在此完成
P95           │█████████                │  180ms  ← 95% 请求在此完成
P99           │██████████████           │  500ms  ← 长尾请求（需关注）
P99.9         │████████████████████████ │  2000ms ← 异常值（排查根因）

为什么关心 P95/P99 而非平均值？
  平均延迟 = (50+50+50+500+50)/5 = 140ms（被 500ms 异常值拉偏）
  P95 = 180ms（反映绝大多数用户的真实体验）

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

// 配置选项
export const options = {
  stages: [
    { duration: '2m', target: 100 },    // 2min 内从 0 升到 100 VU
    { duration: '5m', target: 100 },    // 保持 100 VU 持续 5min
    { duration: '2m', target: 200 },    // 加压到 200 VU
    { duration: '5m', target: 200 },    // 保持
    { duration: '2m', target: 0 },      // 缓慢降压
  ],
  thresholds: {
    http_req_duration: ['p(95)<300'],    // P95 延迟 < 300ms
    http_req_failed: ['rate<0.01'],      // 错误率 < 1%
    http_req_duration: ['p(99)<1000'],   // P99 延迟 < 1s
  },
};

export default function () {
  // 模拟真实用户行为：浏览 -> 搜索 -> 下单
  
  // 1. 浏览商品列表
  let browse = http.get('https://api.shop.example.com/products?page=1&limit=20');
  check(browse, {
    'browse status is 200': (r) => r.status === 200,
    'browse response time < 200ms': (r) => r.timings.duration < 200,
  });
  sleep(Math.random() * 3 + 1);  // 1-4 秒思考时间
  
  // 2. 搜索商品
  let search = http.get('https://api.shop.example.com/products/search?q=laptop');
  check(search, {
    'search status is 200': (r) => r.status === 200,
    'search returns results': (r) => JSON.parse(r.body).items.length > 0,
  });
  sleep(Math.random() * 2 + 1);
  
  // 3. 查看商品详情（10% 概率）
  if (Math.random() < 0.1) {
    let detail = http.get('https://api.shop.example.com/products/p-12345');
    check(detail, {
      'detail status is 200': (r) => r.status === 200,
    });
  }
  sleep(Math.random() * 2 + 1);
  
  // 4. 下单（5% 概率）
  if (Math.random() < 0.05) {
    let order = http.post('https://api.shop.example.com/orders', JSON.stringify({
      items: [{ productId: 'p-12345', quantity: 1 }],
    }), {
      headers: { 'Content-Type': 'application/json' },
    });
    check(order, {
      'order created': (r) => r.status === 201,
      'order has id': (r) => JSON.parse(r.body).orderId !== undefined,
    });
  }
  sleep(Math.random() * 3 + 2);
}

# 本地执行
k6 run load_test.js

# 输出 JSON 结果用于 CI
k6 run --out json=results.json load_test.js

# 集成 Prometheus
k6 run --out experimental-prometheus-rw load_test.js

# 结果解读
# http_req_duration..........: avg=145ms  min=23ms   med=98ms   max=2.34s
#                            p(90)=320ms  p(95)=480ms  p(99)=1.2s
# http_req_failed............: 0.23%      ✗ 23 / 10000
# iterations.................: 10000      83.33/s
# vus_max....................: 200        min=0 max=200

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

// 自定义指标
const paymentLatency = new Trend('payment_duration');
const inventoryErrors = new Counter('inventory_errors');
const cacheHitRate = new Rate('cache_hits');
const activeConnections = new Gauge('active_db_connections');

export default function () {
  const start = Date.now();
  
  let res = http.post('https://api.shop.example.com/payments', ...);
  paymentLatency.add(Date.now() - start);
  
  if (res.status !== 200) {
    inventoryErrors.add(1);
  }
  
  // 从响应头判断缓存状态
  cacheHitRate.add(res.headers['X-Cache'] === 'HIT');
}

# locustfile.py
from locust import HttpUser, task, between, events
import random

class ShopUser(HttpUser):
    """模拟电商用户行为。"""
    wait_time = between(1, 5)  # 任务间等待 1-5 秒
    
    def on_start(self):
        """每个用户启动时登录。"""
        resp = self.client.post("/api/auth/login", json={
            "email": f"user_{self.user_id}@test.com",
            "password": "testpass123"
        })
        self.token = resp.json()["access_token"]
        self.headers = {"Authorization": f"Bearer {self.token}"}
    
    @task(10)  # 权重 10
    def browse_products(self):
        page = random.randint(1, 10)
        self.client.get(
            f"/api/products?page={page}&limit=20",
            headers=self.headers
        )
    
    @task(5)
    def search_products(self):
        keywords = ["laptop", "phone", "headphones", "watch"]
        q = random.choice(keywords)
        self.client.get(
            f"/api/products/search?q={q}",
            headers=self.headers
        )
    
    @task(3)
    def view_product_detail(self):
        product_id = random.choice(["p-001", "p-002", "p-003", "p-004"])
        self.client.get(
            f"/api/products/{product_id}",
            headers=self.headers
        )
    
    @task(1)  # 权重最低
    def place_order(self):
        """下单流程。"""
        # 先获取购物车
        cart = self.client.get("/api/cart", headers=self.headers)
        
        # 创建订单
        resp = self.client.post(
            "/api/orders",
            headers=self.headers,
            json={
                "items": [{"productId": "p-001", "quantity": 1}],
                "address": {
                    "street": "中山路 100 号",
                    "city": "上海",
                    "zip": "200000"
                }
            }
        )
        
        if resp.status_code != 201:
            # 自定义失败事件
            events.request.fire(
                request_type="POST",
                name="/api/orders",
                response_time=0,
                response_length=0,
                exception=Exception(f"Order failed: {resp.status_code}")
            )

# 主节点
locust --master --web-host 0.0.0.0 --web-port 8089

# 工作节点（多台机器）
locust --worker --master-host <master-ip>

# 无 UI 模式（用于 CI）
locust --headless \
  --users 1000 \
  --spawn-rate 10 \
  --run-time 10m \
  --host https://api.shop.example.com \
  --csv results

Stage 1: 基线测试 ──────► 单用户，记录延迟基线
              │
Stage 2: 负载测试 ──────► 模拟生产流量，确认 SLA
              │
Stage 3: 容量测试 ──────► 阶梯加压，找到拐点
              │
Stage 4: 压力测试 ──────► 持续加压到崩溃，验证恢复
              │
Stage 5: 浸泡测试 ──────► 持续运行，发现泄漏

# .github/workflows/perf-baseline.yml
name: Performance Baseline
on:
  schedule:
    - cron: '0 2 * * *'  # 每晚 2 点
  push:
    branches: [main]

jobs:
  perf-test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      
      - name: Deploy to staging
        run: ./scripts/deploy-staging.sh
      
      - name: Run k6 baseline
        run: |
          k6 run \
            --out json=results.json \
            --summary-export=summary.json \
            tests/perf/baseline.js
      
      - name: Compare with baseline
        run: |
          # 读取上次基线并与本次比较
          python scripts/compare_perf.py \
            --current summary.json \
            --baseline .perf-baseline.json \
            --threshold 10%  # 性能回退 10% 即失败
      
      - name: Update baseline
        if: github.ref == 'refs/heads/main'
        run: cp summary.json .perf-baseline.json