1
def analyze_results(results):
2
    sorted_results = sorted(results)
3
    n = len(sorted_results)
4

5
    return {
6
        "qps": len(results) / duration,
7
        "avg": statistics.mean(results),
8
        "p50": sorted_results[int(n * 0.5)],
9
        "p90": sorted_results[int(n * 0.9)],
10
        "p99": sorted_results[int(n * 0.99)],
11
        "max": max(results),
12
    }

1
# Kubernetes VPA 配置
2
apiVersion: autoscaling.k8s.io/v1
3
kind: VerticalPodAutoscaler
4
metadata:
5
  name: my-app-vpa
6
spec:
7
  targetRef:
8
    apiVersion: apps/v1
9
    kind: Deployment
10
    name: my-app
11
  updatePolicy:
12
    updateMode: "Auto"

1
# Kubernetes HPA 配置
2
apiVersion: autoscaling/v2
3
kind: HorizontalPodAutoscaler
4
metadata:
5
  name: my-app-hpa
6
spec:
7
  scaleTargetRef:
8
    apiVersion: apps/v1
9
    kind: Deployment
10
    name: my-app
11
  minReplicas: 2
12
  maxReplicas: 10
13
  metrics:
14
    - type: Resource
15
      resource:
16
        name: cpu
17
        target:
18
          type: Utilization
19
          averageUtilization: 70

1
class TokenBucket:
2
    def __init__(self, rate, capacity):
3
        self.rate = rate
4
        self.capacity = capacity
5
        self.tokens = capacity
6
        self.last_refill = time.time()
7

8
    def allow_request(self, tokens=1):
9
        self._refill()
10
        if self.tokens >= tokens:
11
            self.tokens -= tokens
12
            return True
13
        return False
14

15
    def _refill(self):
16
        now = time.time()
17
        elapsed = now - self.last_refill
18
        self.tokens = min(self.capacity, self.tokens + elapsed * self.rate)
19
        self.last_refill = now

1
class ServiceDegradation:
2
    def __init__(self):
3
        self.fallbacks = {}
4
        self.degradation_enabled = {}
5

6
    def register_fallback(self, func_name, fallback_func):
7
        self.fallbacks[func_name] = fallback_func
8

9
    def execute(self, func_name, *args, **kwargs):
10
        if self.degradation_enabled.get(func_name):
11
            return self.fallbacks[func_name](*args, **kwargs)
12
        try:
13
            return self.execute_original(func_name, *args, **kwargs)
14
        except Exception:
15
            if func_name in self.fallbacks:
16
                return self.fallbacks[func_name](*args, **kwargs)
17
            raise

1
正常 → 失败率超过阈值 → 熔断（快速失败）
2
                          ↓
3
                    超时后探测 → 成功 → 恢复
4
                          ↓
5
                        失败 → 继续熔断

1
所需实例数 = 目标 QPS / 单实例 QPS
2
所需 CPU = 单实例 CPU * 实例数
3
所需内存 = 单实例内存 * 实例数

1
单实例基线：QPS=500, CPU=2核, 内存=4GB
2
目标 QPS：5000
3
所需实例数：5000 / 500 = 10
4
所需 CPU：2 * 10 = 20 核
5
所需内存：4 * 10 = 40 GB

1
加速比 = 1 / (串行比例 + 并行比例 / 实例数)

1
2 实例：加速比 = 1 / (0.1 + 0.9/2) = 1.82
2
4 实例：加速比 = 1 / (0.1 + 0.9/4) = 3.08
3
8 实例：加速比 = 1 / (0.1 + 0.9/8) = 4.71
4
无限实例：加速比 = 1 / 0.1 = 10（上限）

1
规划容量 = 预测峰值 * (1 + 安全裕度)
2
安全裕度建议：20-30%