AI 辅助的云原生容量规划：从负载预测到资源推荐的自适应策略

一、容量规划的"过度与不足"：资源浪费与性能瓶颈的两难困境

云原生环境下的容量规划是一个持续的博弈：资源配置过高导致成本浪费，配置过低导致性能瓶颈。某电商团队在促销活动前将集群资源翻倍扩容，活动结束后忘记缩容，导致月度云成本超支 40%。另一个团队则走向反面——为了控制成本，始终保持最低资源配置，结果在流量高峰时服务响应时间从 200ms 飙升到 3s，用户体验严重受损。

传统的容量规划依赖经验判断和简单线性外推。运维人员根据历史峰值乘以安全系数来预估资源需求，但这种方式有两个缺陷：一是安全系数通常偏高（1.5x-2x），导致常态下大量资源闲置；二是无法捕捉突发流量模式——促销、热点事件、竞品故障导致的流量涌入，线性外推完全无法预测。

AI 辅助的容量规划引入时序预测模型，基于历史负载数据（CPU、内存、QPS、连接数）训练预测模型，输出未来 1-7 天的资源需求预测值。结合业务日历（促销计划、节假日）和外部事件（竞品动态、社交媒体热度）作为特征增强预测精度。最终输出不是单一的预测值，而是置信区间——给出资源需求的上下界，让运维团队在成本和性能之间做有据可依的权衡。

二、容量规划架构：从数据采集到资源推荐的四阶段流程

flowchart TB
    subgraph S1["阶段一：数据采集与特征工程"]
        A["指标数据<br/>CPU/Memory/QPS"] --> B["特征提取<br/>• 小时级聚合<br/>• 日周期特征<br/>• 周周期特征"]
        C["业务日历<br/>促销/节假日"] --> D["事件编码<br/>• 促销强度等级<br/>• 历史影响系数"]
        E["外部信号<br/>流量趋势"] --> F["特征融合<br/>多源特征对齐"]
        B --> G["训练数据集"]
        D --> G
        F --> G
    end

    subgraph S2["阶段二：负载预测"]
        G --> H["时序预测模型<br/>Prophet + LSTM 混合"]
        H --> I["预测输出<br/>• 点估计<br/>• 置信区间<br/>• 异常概率"]
    end

    subgraph S3["阶段三：资源映射"]
        I --> J["资源需求计算<br/>• Pod 规格 → 副本数<br/>• 节点规格 → 节点数<br/>• 预留缓冲比例"]
        J --> K["成本估算<br/>按需/预留/Spot 混合"]
    end

    subgraph S4["阶段四：策略推荐"]
        K --> L["推荐方案生成<br/>• 保守方案（高可用）<br/>• 均衡方案（性价比）<br/>• 激进方案（低成本）"]
        L --> M["自动伸缩配置<br/>HPA/VPA Manifest"]
    end

    style H fill:#f96,stroke:#333
    style J fill:#9cf,stroke:#333
    style L fill:#9f9,stroke:#333

四阶段流程的设计逻辑：

阶段一：数据采集与特征工程。从 Prometheus 采集历史指标数据，按小时聚合生成时间序列。提取三类特征：时间特征（小时、星期、是否工作日）、周期特征（日周期、周周期、月周期）、事件特征（促销强度等级、历史影响系数）。业务日历和外部信号通过事件编码转化为数值特征，与时间序列特征对齐后融合为训练数据集。

阶段二：负载预测。采用 Prophet + LSTM 混合模型。Prophet 擅长捕捉趋势和季节性（日/周/年周期），LSTM 擅长捕捉非线性依赖和突发事件。Prophet 的输出作为 LSTM 的输入特征之一，两个模型的预测结果加权融合。输出包含点估计、80% 和 95% 置信区间，以及异常概率（预测值超出历史范围的概率）。

阶段三：资源映射。将预测的负载数值映射为具体的 K8s 资源配置。根据 Pod 的资源请求（Request）和限制（Limit），计算所需的副本数。根据节点规格，计算所需的节点数。预留 20% 的缓冲比例应对预测误差和突发流量。同时计算成本——按需实例、预留实例和 Spot 实例的混合配比。

阶段四：策略推荐。基于资源映射结果生成三套推荐方案：保守方案（95% 置信区间上界 + 30% 缓冲）、均衡方案（80% 置信区间上界 + 20% 缓冲）、激进方案（点估计 + 10% 缓冲）。每套方案附带成本估算和风险评级。最终输出可直接应用的 HPA 和 VPA 配置。

三、容量规划引擎的代码实现

from dataclasses import dataclass, field
from typing import Optional
import numpy as np

@dataclass
class LoadPrediction:
    """负载预测结果"""
    timestamp: float
    cpu_cores: float               # 预测 CPU 核心数
    memory_gb: float               # 预测内存 GB
    qps: float                     # 预测 QPS
    cpu_lower: float               # CPU 下界 (80% CI)
    cpu_upper: float               # CPU 上界 (80% CI)
    memory_lower: float
    memory_upper: float
    anomaly_prob: float            # 异常概率

@dataclass
class ResourcePlan:
    """资源规划方案"""
    plan_name: str                 # conservative/balanced/aggressive
    pod_replicas: int
    node_count: int
    cpu_request_per_pod: float     # 核心数
    memory_request_per_pod: float  # GB
    monthly_cost: float            # 月度成本估算
    risk_level: str                # low/medium/high
    hpa_config: dict               # HPA 配置
    buffer_ratio: float            # 缓冲比例

class CapacityPlanner:
    """容量规划引擎"""

    def __init__(
        self,
        pod_cpu_request: float = 0.5,
        pod_memory_request: float = 1.0,
        node_cpu_capacity: float = 32.0,
        node_memory_capacity: float = 128.0,
    ):
        self.pod_cpu_request = pod_cpu_request
        self.pod_memory_request = pod_memory_request
        self.node_cpu_capacity = node_cpu_capacity
        self.node_memory_capacity = node_memory_capacity

    def generate_plans(
        self, predictions: list[LoadPrediction]
    ) -> list[ResourcePlan]:
        """基于预测结果生成三套资源规划方案"""
        # 取预测峰值作为基准
        peak_cpu = max(p.cpu_upper for p in predictions)
        peak_memory = max(p.memory_upper for p in predictions)

        plans = [
            self._build_plan(
                "conservative", peak_cpu, peak_memory,
                buffer_ratio=0.3, ci_multiplier=1.0,
            ),
            self._build_plan(
                "balanced", peak_cpu, peak_memory,
                buffer_ratio=0.2, ci_multiplier=0.85,
            ),
            self._build_plan(
                "aggressive", peak_cpu, peak_memory,
                buffer_ratio=0.1, ci_multiplier=0.7,
            ),
        ]
        return plans

    def _build_plan(
        self,
        name: str,
        peak_cpu: float,
        peak_memory: float,
        buffer_ratio: float,
        ci_multiplier: float,
    ) -> ResourcePlan:
        """构建单个资源规划方案"""
        # 应用置信区间乘数和缓冲比例
        target_cpu = peak_cpu * ci_multiplier * (1 + buffer_ratio)
        target_memory = peak_memory * ci_multiplier * (1 + buffer_ratio)

        # 计算 Pod 副本数（取 CPU 和内存的较大需求）
        replicas_by_cpu = max(
            1, int(np.ceil(target_cpu / self.pod_cpu_request))
        )
        replicas_by_memory = max(
            1, int(np.ceil(target_memory / self.pod_memory_request))
        )
        pod_replicas = max(replicas_by_cpu, replicas_by_memory)

        # 计算节点数
        total_cpu = pod_replicas * self.pod_cpu_request
        total_memory = pod_replicas * self.pod_memory_request
        nodes_by_cpu = max(
            1, int(np.ceil(total_cpu / self.node_cpu_capacity * 1.1))
        )
        nodes_by_memory = max(
            1, int(np.ceil(total_memory / self.node_memory_capacity * 1.1))
        )
        node_count = max(nodes_by_cpu, nodes_by_memory)

        # 成本估算（按需实例单价：CPU $0.05/核/小时, Memory $0.01/GB/小时）
        cpu_cost = total_cpu * 0.05 * 730
        memory_cost = total_memory * 0.01 * 730
        monthly_cost = cpu_cost + memory_cost

        # 风险评级
        risk_map = {
            "conservative": "low",
            "balanced": "medium",
            "aggressive": "high",
        }

        # HPA 配置
        hpa_config = {
            "minReplicas": max(1, pod_replicas // 2),
            "maxReplicas": pod_replicas,
            "targetCPUUtilizationPercentage": 70,
            "targetMemoryUtilizationPercentage": 80,
            "scaleUpStabilizationWindowSeconds": 60,
            "scaleDownStabilizationWindowSeconds": 300,
        }

        return ResourcePlan(
            plan_name=name,
            pod_replicas=pod_replicas,
            node_count=node_count,
            cpu_request_per_pod=self.pod_cpu_request,
            memory_request_per_pod=self.pod_memory_request,
            monthly_cost=round(monthly_cost, 2),
            risk_level=risk_map[name],
            hpa_config=hpa_config,
            buffer_ratio=buffer_ratio,
        )

    def generate_hpa_manifest(
        self, plan: ResourcePlan, deployment_name: str
    ) -> str:
        """生成 Kubernetes HPA Manifest"""
        return f"""apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: {deployment_name}-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: {deployment_name}
  minReplicas: {plan.hpa_config["minReplicas"]}
  maxReplicas: {plan.hpa_config["maxReplicas"]}
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: {plan.hpa_config["targetCPUUtilizationPercentage"]}
  - type: Resource
    resource:
      name: memory
      target:
        type: Utilization
        averageUtilization: {plan.hpa_config["targetMemoryUtilizationPercentage"]}
  behavior:
    scaleUp:
      stabilizationWindowSeconds: {plan.hpa_config["scaleUpStabilizationWindowSeconds"]}
      policies:
      - type: Percent
        value: 50
        periodSeconds: 60
    scaleDown:
      stabilizationWindowSeconds: {plan.hpa_config["scaleDownStabilizationWindowSeconds"]}
      policies:
      - type: Percent
        value: 10
        periodSeconds: 60
"""

# ===== 使用示例 =====
def demo_capacity_planning():
    """容量规划示例"""
    planner = CapacityPlanner(
        pod_cpu_request=0.5,
        pod_memory_request=1.0,
        node_cpu_capacity=32.0,
        node_memory_capacity=128.0,
    )

    # 模拟预测结果（实际由 Prophet + LSTM 模型产出）
    predictions = [
        LoadPrediction(
            timestamp=1718300000,
            cpu_cores=8.5, memory_gb=24.0, qps=5000,
            cpu_lower=7.0, cpu_upper=10.0,
            memory_lower=20.0, memory_upper=28.0,
            anomaly_prob=0.05,
        ),
        LoadPrediction(
            timestamp=1718386400,
            cpu_cores=15.0, memory_gb=42.0, qps=12000,
            cpu_lower=12.0, cpu_upper=18.0,
            memory_lower=36.0, memory_upper=48.0,
            anomaly_prob=0.15,
        ),
    ]

    plans = planner.generate_plans(predictions)
    for plan in plans:
        print(f"方案: {plan.plan_name}")
        print(f"  副本数: {plan.pod_replicas}")
        print(f"  节点数: {plan.node_count}")
        print(f"  月成本: ${plan.monthly_cost}")
        print(f"  风险: {plan.risk_level}")
        print()

关键设计决策：资源映射采用"取 CPU 和内存需求的较大值"策略，确保不会因为单一维度不足导致瓶颈。节点数计算增加 10% 的余量（1.1 倍），为系统组件（kubelet、kube-proxy）预留资源。HPA 的缩容稳定窗口设为 300 秒（5 分钟），防止流量波动导致的频繁缩容。成本估算使用按需实例单价，实际可结合预留实例和 Spot 实例降低成本。

四、容量规划方案的边界与权衡

预测精度与数据依赖：时序预测模型的精度高度依赖历史数据的质量和长度。新服务上线初期（不足 2 周数据），预测结果不可靠。此时应降级为基于资源请求的静态规划，而非依赖预测。此外，"黑天鹅"事件（如社交媒体病毒式传播）无法通过历史数据预测，需要人工介入调整。

成本与可用性的权衡：三套方案本质上是在成本和可用性之间做选择。保守方案成本最高但风险最低，激进方案成本最低但风险最高。实践中建议采用"均衡方案 + 手动干预"模式——日常使用均衡方案，在已知的高流量事件前手动切换到保守方案。

多服务协同：当前方案对单个服务做容量规划，但实际生产中多个服务共享节点资源。一个服务的扩容可能挤占其他服务的资源。需要集群级别的容量规划——在节点池维度统筹资源分配，而非单服务维度独立规划。

模型漂移：业务模式变化会导致预测模型漂移——例如从 B 端转向 C 端后，流量模式从工作日高峰变为全天均匀。需要定期（至少每月）用最新数据重新训练模型，并监控预测误差。当预测误差持续超过 20% 时，应触发模型重训练。

五、总结

AI 辅助的云原生容量规划通过四阶段流程——数据采集与特征工程、负载预测、资源映射、策略推荐——将容量规划从经验判断升级为数据驱动。Prophet + LSTM 混合模型兼顾趋势季节性和非线性依赖，三套推荐方案在成本与可用性之间提供明确选择，HPA Manifest 可直接应用到 K8s 集群。落地时需注意三点：一是新服务数据不足时应降级为静态规划；二是日常使用均衡方案，高流量事件前手动切换保守方案；三是定期重训练模型应对业务模式变化。容量规划的目标不是"精准预测"，而是"在不确定中做出有据可依的决策"。