# 特征工程伪代码
features = {
    'cpu_lag_1h': cpu.shift(1),      # 1小时前的 CPU
    'cpu_rolling_mean_24h': cpu.rolling(24).mean(),  # 24h滚动均值
    'cpu_diff_vs_yesterday': cpu - cpu.shift(24),     # 同比昨日变化
    'mem_cpu_ratio': memory / cpu.clip(lower=1),      # 内存-CPU 比率
    'qps_cpu_corr': qps.rolling(6).corr(cpu),         # QPS-CPU 相关系数
    'is_business_hours': ((hour >= 9) & (hour <= 18)).astype(int),
    'days_to_major_event': event_calendar.distance('today'),
}

# 自动扩容策略配置
auto_scale:
  trigger:
    condition: "predicted_cpu_7d > 80%"
    confidence: 0.85
  action:
    scale_up:
      current_replicas: 3
      target_replicas: 5
      method: rolling   # 滚动扩容，不中断服务
  safety:
    max_scale_factor: 2.0   # 单次最多扩容 2 倍
    approval_required_above: 8   # 超过 8 个副本需人工审批

# 效果验证伪代码
actual_p99 = get_metric('p99_latency', after='scale_up_time')
predicted_p99 = forecast['p99_after_scaling']
drift = abs(actual_p99 - predicted_p99) / predicted_p99

if drift > 0.15:  # 偏差超过 15%
    trigger_model_retrain("prediction_drift_detected")
    alert("容量预测偏差过大，已触发模型重新训练")

# 1. 部署 Prometheus 监控栈
kubectl apply -f https://raw.githubusercontent.com/prometheus-community/helm-charts/main/charts/kube-prometheus-stack/values.yaml

# 2. 配置业务指标 Exporter
# 在应用中加入 OpenTelemetry SDK，导出自定义指标
cat <<'EOF' > otel-config.yaml
resource_attributes:
  service.name: "order-service"
  environment: "production"
attributes:
  api_endpoint: "/api/v2/orders"
  method: "POST"
EOF

# 3. 安装 VictoriaMetrics（可选，替代 Prometheus TSDB）
helm install vm victoria-metrics/single-server-vminsert \
  --set retentionPeriod=30d

# capacity_forecaster.py
import pandas as pd
import numpy as np
from prophet import Prophet
from sklearn.ensemble import GradientBoostingRegressor
from sklearn.metrics import mean_absolute_percentage_error

class CapacityForecaster:
    def __init__(self, metrics_df: pd.DataFrame):
        self.df = metrics_df
        self.prophet_model = None
        self.gb_model = None
        self.baseline_stats = None
    
    def compute_baseline(self):
        """计算资源使用基线"""
        self.baseline_stats = {
            'cpu_mean_7d': self.df['cpu'].rolling(7*24*4).mean().iloc[-1],
            'cpu_p95_7d': self.df['cpu'].rolling(7*24*4).quantile(0.95).iloc[-1],
            'mem_mean_7d': self.df['memory'].rolling(7*24*4).mean().iloc[-1],
            'seasonal_pattern': self._extract_seasonality(),
        }
        return self.baseline_stats
    
    def _extract_seasonality(self):
        """提取日内/周度周期模式"""
        df = self.df.copy()
        df['hour'] = df.index.hour
        df['dayofweek'] = df.index.dayofweek
        hourly_pattern = df.groupby('hour')['cpu'].mean()
        weekly_pattern = df.groupby('dayofweek')['cpu'].mean()
        return {'hourly': hourly_pattern, 'weekly': weekly_pattern}
    
    def forecast_prophet(self, days: int = 7) -> pd.DataFrame:
        """使用 Prophet 进行短期预测"""
        prophet_df = self.df.reset_index()
        prophet_df = prophet_df.rename(columns={
            prophet_df.columns[0]: 'ds',
            'cpu': 'y'
        })
        
        model = Prophet(
            yearly_seasonality=True,
            weekly_seasonality=True,
            daily_seasonality=True,
            changepoint_prior_scale=0.05
        )
        model.fit(prophet_df)
        self.prophet_model = model
        
        future = model.make_future_dataframe(periods=days * 4 * 24)  # 15min 间隔
        forecast = model.predict(future)
        return forecast
    
    def forecast_xgboost(self, features: pd.DataFrame, target_col: str = 'cpu', 
                         horizon: int = 48) -> np.ndarray:
        """使用 XGBoost 进行多步预测"""
        # 构造训练样本
        train_data = self._build_training_samples(features, target_col)
        
        model = GradientBoostingRegressor(
            n_estimators=200,
            max_depth=5,
            learning_rate=0.05,
            subsample=0.8
        )
        model.fit(train_data['X'], train_data['y'])
        self.gb_model = model
        
        # 滚动预测
        predictions = []
        last_window = train_data['X'].iloc[-1]
        for _ in range(horizon):
            pred = model.predict(last_window.reshape(1, -1))[0]
            predictions.append(pred)
            # 滚动更新特征窗口
            last_window = np.roll(last_window, -1)
            last_window[-1] = pred
        
        return np.array(predictions)
    
    def generate_recommendation(self, forecast: pd.DataFrame, 
                                 cost_per_core: float = 50.0) -> dict:
        """生成容量规划建议"""
        latest_cpu = self.df['cpu'].iloc[-1]
        predicted_cpu_7d = forecast['yhat'].iloc[-48:].mean()  # 未来7天均值
        predicted_cpu_peak = forecast['yhat'].iloc[-48:].max()
        
        current_cores = self._get_current_cores()
        
        # 计算所需资源
        safety_margin = 1.2  # 20% 安全余量
        required_cores = int(np.ceil(predicted_cpu_peak * current_cores / latest_cpu * safety_margin))
        
        # 成本分析
        current_cost = current_cores * cost_per_core
        recommended_cost = required_cores * cost_per_core
        cost_increase_pct = (recommended_cost - current_cost) / current_cost * 100
        
        # 生成自然语言建议（简化版，实际由 LLM 生成）
        if predicted_cpu_peak > 90:
            urgency = "紧急"
            action = "立即扩容"
        elif predicted_cpu_peak > 75:
            urgency = "中等"
            action = "本周内完成扩容"
        else:
            urgency = "低"
            action = "持续监控，暂不需要扩容"
        
        return {
            'urgency': urgency,
            'action': action,
            'current_cores': current_cores,
            'recommended_cores': required_cores,
            'predicted_peak_cpu': round(predicted_cpu_peak, 1),
            'cost_increase_pct': round(cost_increase_pct, 1),
            'recommendation': (
                f"预测未来7天 CPU 峰值 {predicted_cpu_peak:.1f}%，"
                f"建议从 {current_cores} 核扩容至 {required_cores} 核，"
                f"成本增加 {cost_increase_pct:.1f}%。"
                f"优先级：{urgency}——{action}。"
            )
        }
    
    def _get_current_cores(self) -> int:
        """获取当前配置核心数"""
        # 实际实现中从 K8s 或云厂商 API 获取
        return 4
    
    def _build_training_samples(self, features: pd.DataFrame, target: str,
                                 lookback: int = 168) -> dict:
        """构建训练样本：用过去 N 个时间点预测未来 M 个时间点"""
        X, y = [], []
        for i in range(lookback, len(features) - 48):
            X.append(features.iloc[i-lookback:i].values.flatten())
            y.append(features[target].iloc[i:i+48].values)
        return {'X': np.array(X), 'y': np.array(y)}

# llm_capacity_advisor.py
from openai import OpenAI
import json

class CapacityAdvisor:
    def __init__(self, llm_client: OpenAI, model: str = "deepseek-chat"):
        self.client = llm_client
        self.model = model
        self.knowledge_base = self._load_knowledge_base()
    
    def analyze_forecast(self, forecast_data: dict, context: dict) -> str:
        """调用 LLM 分析预测结果，生成运维建议"""
        
        system_prompt = """你是一位资深的 SRE 工程师和容量规划专家。
你的任务是根据 AI 预测结果，为 VPS 运维团队提供可操作的容量规划建议。
要求：
1. 用简洁清晰的中文表达
2. 给出明确的优先级和行动建议
3. 考虑成本、风险和收益的平衡
4. 如果风险较低，说明理由；如果风险较高，详细说明应对措施"""
        
        user_message = f"""## 当前状态
- 当前 CPU 使用率：{context.get('current_cpu', 'N/A')}%
- 当前内存使用率：{context.get('current_memory', 'N/A')}%
- 当前实例配置：{context.get('current_config', 'N/A')}

## 预测结果（未来7天）
{json.dumps(forecast_data, ensure_ascii=False, indent=2)}

## 已知业务事件
{context.get('upcoming_events', '无')}

## 历史容量事件
{context.get('historical_incidents', '无')}

请分析以上数据，给出你的容量规划建议。"""
        
        response = self.client.chat.completions.create(
            model=self.model,
            messages=[
                {"role": "system", "content": system_prompt},
                {"role": "user", "content": user_message}
            ],
            temperature=0.3
        )
        
        return response.choices[0].message.content
    
    def generate_change_plan(self, recommendation: dict, infra_config: dict) -> str:
        """生成具体的变更执行方案"""
        
        system_prompt = """你是一位经验丰富的 DevOps 工程师。
根据容量规划建议，生成详细的变更执行方案，包括：
1. 变更前检查清单
2. 分步骤执行计划
3. 回滚预案
4. 验证标准"""
        
        user_message = f"""## 容量规划建议
{json.dumps(recommendation, ensure_ascii=False, indent=2)}

## 当前基础设施配置
{json.dumps(infra_config, ensure_ascii=False, indent=2)}

请生成详细的变更执行方案。"""
        
        response = self.client.chat.completions.create(
            model=self.model,
            messages=[
                {"role": "system", "content": system_prompt},
                {"role": "user", "content": user_message}
            ],
            temperature=0.3
        )
        
        return response.choices[0].message.content
    
    def write_weekly_report(self, week_data: dict) -> str:
        """生成周报"""
        
        system_prompt = """你是一位 SRE 团队的技术写作者。
根据本周的容量数据和 AI 分析结果，生成一份专业、简洁的周报。
风格要求：数据驱动、重点突出、 actionable。"""
        
        response = self.client.chat.completions.create(
            model=self.model,
            messages=[
                {"role": "system", "content": system_prompt},
                {"role": "user", "content": f"本周容量数据：{json.dumps(week_data, ensure_ascii=False)}"}
            ],
            temperature=0.3
        )
        
        return response.choices[0].message.content

# auto_scaler_config.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: capacity-planning-agent
spec:
  replicas: 1
  template:
    spec:
      containers:
      - name: capacity-agent
        image: selfvps/capacity-planner:latest
        env:
        - name: PROMETHEUS_URL
          value: "http://prometheus.monitoring.svc:9090"
        - name: LLM_API_ENDPOINT
          value: "http://ollama:11434/v1"
        - name: LLM_MODEL
          value: "deepseek-r1:8b"
        - name: ALERT_THRESHOLD_CPU
          value: "80"
        - name: ALERT_THRESHOLD_MEMORY
          value: "85"
        - name: AUTO_SCALE_ENABLED
          value: "true"
        - name: MAX_SCALE_FACTOR
          value: "2.0"
        volumeMounts:
        - name: config
          mountPath: /etc/capacity-planner
      volumes:
      - name: config
        configMap:
          name: capacity-planner-config
---
# CronJob：每日运行容量预测
apiVersion: batch/v1
kind: CronJob
metadata:
  name: daily-capacity-forecast
spec:
  schedule: "0 6 * * *"  # 每天早6点执行
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: forecaster
            image: selfvps/capacity-planner:latest
            command: ["python3", "/app/forecast.py", "--horizon", "7", "--notify"]
          restartPolicy: OnFailure
---
# CronJob：每周生成容量报告
apiVersion: batch/v1
kind: CronJob
metadata:
  name: weekly-capacity-report
spec:
  schedule: "0 8 * * 1"  # 每周一早8点
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: reporter
            image: selfvps/capacity-planner:latest
            command: ["python3", "/app/report.py", "--period", "week", "--channel", "telegram"]
          restartPolicy: OnFailure