负载测试

负载测试的基本概念

负载测试是评估系统在特定负载下的性能表现。通过模拟真实用户行为，观察系统响应时间、吞吐量、资源利用率等指标。Node.js作为异步事件驱动平台，其负载测试需要特别关注事件循环延迟和内存泄漏问题。

const loadTest = require('loadtest');

const options = {
    url: 'http://localhost:3000/api',
    maxRequests: 1000,
    concurrency: 50,
    method: 'POST',
    body: {
        userId: 'test123',
        data: 'sample payload'
    },
    contentType: 'application/json'
};

loadTest.loadTest(options, (error, results) => {
    if (error) return console.error('测试失败:', error);
    console.log('测试结果:', results);
});

Node.js负载测试工具选择

Artillery

Artillery是专业的负载测试工具，支持HTTP和WebSocket协议。其YAML配置文件易于编写和维护：

config:
  target: "http://api.example.com"
  phases:
    - duration: 60
      arrivalRate: 50
      name: "Warm up phase"
    - duration: 120
      arrivalRate: 100
      rampTo: 200
      name: "Stress test"
scenarios:
  - flow:
    - post:
        url: "/login"
        json:
          username: "user"
          password: "pass"
    - get:
        url: "/profile"

Autocannon

Autocannon是纯JavaScript编写的高性能负载测试工具，特别适合测试Node.js服务：

const autocannon = require('autocannon');

autocannon({
    url: 'http://localhost:3000',
    connections: 100, // 并发连接数
    pipelining: 10,  // 每个连接的流水线请求数
    duration: 30     // 测试持续时间(秒)
}, console.log);

测试指标分析

关键性能指标

1. 请求延迟：P95、P99延迟更能反映真实用户体验
2. 吞吐量：RPS(每秒请求数)是核心指标
3. 错误率：HTTP非2xx/3xx响应比例
4. 资源使用：CPU、内存、事件循环延迟

// 使用perf_hooks监控事件循环延迟
const { monitorEventLoopDelay } = require('perf_hooks');

const histogram = monitorEventLoopDelay({ resolution: 10 });
histogram.enable();

setTimeout(() => {
    histogram.disable();
    console.log(`P50延迟: ${histogram.percentile(50)}ms`);
    console.log(`P99延迟: ${histogram.percentile(99)}ms`);
}, 10000);

测试场景设计

渐进式负载测试

从低负载开始逐步增加压力，观察系统行为变化：

const stages = [
    { duration: '30s', target: 50 },  // 热身阶段
    { duration: '1m', target: 100 },  // 正常负载
    { duration: '2m', target: 250 },  // 压力测试
    { duration: '30s', target: 50 }   // 恢复阶段
];

尖峰测试

模拟突发流量场景，测试系统弹性：

config:
  phases:
    - duration: 10
      arrivalRate: 5
    - duration: 1
      arrivalRate: 500  # 瞬间高峰
    - duration: 30
      arrivalRate: 50

Node.js特有优化点

连接池管理

数据库连接池配置直接影响系统负载能力：

const pool = mysql.createPool({
    connectionLimit: 50,          // 重要参数
    queueLimit: 1000,             // 等待队列长度
    acquireTimeout: 30000,        // 获取连接超时
    waitForConnections: true      // 无可用连接时等待
});

集群模式测试

利用Node.js集群模块测试多进程表现：

const cluster = require('cluster');
const numCPUs = require('os').cpus().length;

if (cluster.isMaster) {
    for (let i = 0; i < numCPUs; i++) {
        cluster.fork();
    }
} else {
    require('./server'); // 启动应用
}

常见问题排查

内存泄漏检测

使用heapdump和Chrome DevTools分析内存问题：

const heapdump = require('heapdump');

setInterval(() => {
    if (process.memoryUsage().heapUsed > 500 * 1024 * 1024) {
        heapdump.writeSnapshot(`heap-${Date.now()}.heapsnapshot`);
    }
}, 5000);

事件循环阻塞

长时间同步操作会阻塞事件循环：

// 错误示例：同步加密操作
const crypto = require('crypto');
function hashPassword(password) {
    // 同步操作会阻塞事件循环
    return crypto.createHash('sha256').update(password).digest('hex');
}

// 正确示例：异步加密
async function hashPasswordAsync(password) {
    return new Promise((resolve) => {
        crypto.pbkdf2(password, 'salt', 100000, 64, 'sha256', (err, derivedKey) => {
            resolve(derivedKey.toString('hex'));
        });
    });
}

持续集成中的负载测试

在CI/CD管道中加入负载测试阶段：

# GitHub Actions示例
name: Load Test
on: [push]
jobs:
  load-test:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v2
    - run: npm install
    - run: npm install -g artillery
    - run: artillery run test.yml
      env:
        CI: true

云服务负载测试

利用AWS Distributed Load Testing等服务进行大规模测试：

const { LambdaClient, InvokeCommand } = require('@aws-sdk/client-lambda');

const client = new LambdaClient({ region: 'us-east-1' });

async function triggerLoadTest() {
    const command = new InvokeCommand({
        FunctionName: 'load-test-worker',
        InvocationType: 'Event',
        Payload: JSON.stringify({
            targetUrl: 'https://api.example.com',
            duration: 300,
            rate: 1000
        })
    });
    await client.send(command);
}

测试结果可视化

使用Grafana+Prometheus构建监控看板：

const client = require('prom-client');

// 定义指标
const httpRequestDurationMicroseconds = new client.Histogram({
    name: 'http_request_duration_ms',
    help: 'HTTP请求持续时间(ms)',
    labelNames: ['method', 'route', 'code'],
    buckets: [50, 100, 200, 300, 400, 500, 1000]
});

// 在中间件中记录指标
app.use((req, res, next) => {
    const end = httpRequestDurationMicroseconds.startTimer();
    res.on('finish', () => {
        end({ 
            method: req.method,
            route: req.route.path,
            code: res.statusCode
        });
    });
    next();
});

真实案例：电商API测试

模拟电商促销场景的测试配置：

config:
  target: "https://api.shop.com"
  phases:
    - duration: 300
      arrivalRate: 50
      name: "正常流量"
    - duration: 600
      arrivalRate: 200
      rampTo: 1000
      name: "秒杀活动"
scenarios:
  - name: "商品浏览"
    flow:
      - get:
          url: "/products"
      - think: 3
      - get:
          url: "/products/{{ $randomNumber(1,1000) }}"
  - name: "下单流程"
    flow:
      - post:
          url: "/cart"
          json:
            productId: "{{ $randomNumber(1,1000) }}"
            quantity: 1
      - think: 1
      - post:
          url: "/checkout"
          json:
            userId: "user-{{ $randomNumber(1,10000) }}"

Node.js性能调优

根据测试结果进行针对性优化：

// HTTP服务器优化
const server = http.createServer(app);
server.keepAliveTimeout = 65000;  // 保持连接超时
server.headersTimeout = 70000;    // 头信息超时

// 使用compression中间件
app.use(require('compression')({
    threshold: 1024,  // 大于1KB才压缩
    filter: (req) => !req.headers['x-no-compression']
}));

// 连接复用优化
const httpAgent = new http.Agent({
    keepAlive: true,
    maxSockets: 100,
    maxFreeSockets: 10,
    timeout: 60000
});
axios.defaults.httpAgent = httpAgent;