网站架构与测试设计（高性能/高可用/可伸缩）

// k6 高性能测试脚本：多阶段负载模型
import http from 'k6/http';
import { check, sleep } from 'k6';
import { Trend, Rate } from 'k6/metrics';

// 自定义指标
const orderLatency = new Trend('order_latency');
const successRate = new Rate('success_rate');

export const options = {
  stages: [
    // 阶段1: 预热（2分钟，100 VU）
    { duration: '2m', target: 100 },

    // 阶段2: 正常负载（5分钟，500 VU）
    { duration: '5m', target: 500 },

    // 阶段3: 峰值负载（3分钟，2000 VU）
    { duration: '3m', target: 2000 },

    // 阶段4: 持续峰值（10分钟稳定性测试）
    { duration: '10m', target: 2000 },

    // 阶段5: 降温（2分钟，回到 100 VU）
    { duration: '2m', target: 100 },
  ],
  thresholds: {
    // 质量门禁
    'http_req_duration': ['p(99)<500'],           // P99 < 500ms
    'http_req_failed': ['rate<0.01'],              // 错误率 < 1%
    'success_rate': ['rate>0.99'],                 // 业务成功率 > 99%
    'order_latency': ['p(95)<300', 'p(99)<800'],  // 订单 P95 < 300ms
  },
};

export default function () {
  // 模拟用户行为：浏览 → 下单 → 支付
  const baseUrl = 'https://test.example.com';

  // 1. 浏览商品
  const skuResp = http.get(`${baseUrl}/api/skus/random`);
  check(skuResp, {
    '商品详情 200': (r) => r.status === 200,
  });

  // 2. 创建订单
  const orderResp = http.post(`${baseUrl}/api/orders`,
    JSON.stringify({ skuId: 'sku-test-001', qty: 1 }),
    { headers: { 'Content-Type': 'application/json' } }
  );

  orderLatency.add(orderResp.timings.duration);

  const orderSuccess = check(orderResp, {
    '订单创建 201': (r) => r.status === 201,
  });
  successRate.add(orderSuccess);

  // 3. 支付（仅部分用户）
  if (orderSuccess && Math.random() > 0.3) {
    const orderId = orderResp.json('id');
    const payResp = http.post(`${baseUrl}/api/orders/${orderId}/pay`);
    check(payResp, {
      '支付 200': (r) => r.status === 200,
    });
  }

  sleep(Math.random() * 2 + 1);  // 1-3 秒思考时间
}

# Prometheus 全链路性能监控告警规则
groups:
  - name: performance_alerts
    rules:
      # P99 延迟告警
      - alert: HighP99Latency
        expr: |
          histogram_quantile(0.99,
            sum(rate(http_request_duration_seconds_bucket[5m])) by (le, service)
          ) > 0.5
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "{{ $labels.service }} P99 延迟超过 500ms"
          description: "当前 P99: {{ $value }}s"

      # 错误率告警
      - alert: HighErrorRate
        expr: |
          sum(rate(http_requests_total{status=~"5.."}[5m])) by (service)
          / sum(rate(http_requests_total[5m])) by (service) > 0.01
        for: 2m
        labels:
          severity: critical
        annotations:
          summary: "{{ $labels.service }} 错误率超过 1%"

      # 缓存命中率告警
      - alert: LowCacheHitRate
        expr: |
          redis_keyspace_hits_total / (redis_keyspace_hits_total + redis_keyspace_misses_total) < 0.9
        for: 10m
        labels:
          severity: warning
        annotations:
          summary: "Redis 缓存命中率低于 90%"

      # 数据库连接池告警
      - alert: DBConnectionPoolExhausted
        expr: |
          hikaricp_connections_active / hikaricp_connections_max > 0.8
        for: 5m
        labels:
          severity: critical
        annotations:
          summary: "{{ $labels.pool }} 连接池使用率超过 80%"

# Chaos Mesh: 高可用故障演练实验组合
apiVersion: chaos-mesh.org/v1alpha1
kind: Workflow
metadata:
  name: ha-drill-experiment
spec:
  entry: ha-drill
  templates:
    # 实验1: 数据库主节点故障
    - name: db-master-failover
      templateType: PodChaos
      podChaos:
        action: pod-kill
        mode: fixed
        value: "1"
        selector:
          labelSelectors:
            app: postgres
            role: master
        duration: "0"

    # 实验2: 网络分区（模拟机房隔离）
    - name: network-partition
      templateType: NetworkChaos
      networkChaos:
        action: partition
        mode: all
        selector:
          labelSelectors:
            app: order-service
        direction: both
        target:
          selector:
            labelSelectors:
              app: payment-service
          mode: all
        duration: "3m"

    # 实验3: 依赖服务延迟（模拟慢依赖）
    - name: slow-dependency
      templateType: NetworkChaos
      networkChaos:
        action: delay
        mode: all
        selector:
          labelSelectors:
            app: order-service
        delay:
          latency: "2000ms"  # 2秒延迟
        direction: to
        target:
          selector:
            labelSelectors:
              app: inventory-service
          mode: all
        duration: "5m"

    # 串行编排
    - name: ha-drill
      templateType: Serial
      children:
        - db-master-failover
        - network-partition
        - slow-dependency