# 简化的 LSTM 预测示例
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dense

def build_predictor(history_data, lookback=168):
    """lookback=168 表示过去一周的小时级数据"""
    model = Sequential([
        LSTM(64, return_sequences=True, input_shape=(lookback, 5)),
        LSTM(32),
        Dense(16, activation='relu'),
        Dense(1)  # 预测下一小时 CPU 需求
    ])
    model.compile(optimizer='adam', loss='mse')
    model.fit(history_data, history_data[:, -1:], epochs=50, batch_size=32)
    return model

# Karpenter Provisioner 配置
apiVersion: karpenter.sh/v1beta1
kind: Provisioner
metadata:
  name: ai-optimized
spec:
  requirements:
    - key: node.kubernetes.io/instance-type
      operator: In
      values: ["m5.large", "m5.xlarge", "m5.2xlarge"]
  taints:
    - key: workloads.ai-optimized
      effect: NoSchedule
  limits:
    resources:
      cpu: 100
      memory: 200Gi
  weight: 10  # 优先级

# 安装 AI 预测指标适配器
helm install ai-scaler ./charts/ai-scaler \
  --set predictor.modelPath=/models/lstm-cpu-predictor \
  --set predictor.lookbackHours=168 \
  --set predictor.updateInterval=300 \
  --set metrics.targetCPU=70  # AI 认为安全的 CPU 阈值

# AWS 示例：AMI (Application Auto Scaling) + 自定义指标
# 1. 部署自定义指标导出器
docker run -d \
  --name ai-metrics-exporter \
  -p 9100:9100 \
  --restart always \
  ourregistry/ai-scaling-metrics:v1

# 2. 配置 ASG 基于自定义指标扩缩
aws autoscaling put-scaling-policy \
  --auto-scaling-group-name my-asg \
  --policy-name ai-predictive-scale-up \
  --policy-type StepScaling \
  --step-adjustments \
    MetricIntervalLowerBound=0 \
    ScalingAdjustment=1 \
    MetricIntervalUpperBound=100

# 3. AI 预测器每 5 分钟更新自定义指标
# /cpu-predicted-next-hour -> 供 ASG 查询

#!/usr/bin/env python3
"""
AI-Driven VPS Auto-Scaler
基于历史数据的简单预测性扩缩容
"""
import time
import json
import requests
from datetime import datetime, timedelta

class AIVPSScaler:
    def __init__(self, config_path="config.json"):
        self.config = self._load_config(config_path)
        self.metrics_history = []
        
    def _load_config(self, path):
        with open(path) as f:
            return json.load(f)
    
    def collect_metrics(self):
        """收集当前资源指标"""
        # 从 Node Exporter 或 cloud provider API 获取
        response = requests.get("http://localhost:9100/metrics")
        # 解析 CPU、内存、磁盘等...
        return {
            "timestamp": datetime.now().isoformat(),
            "cpu_percent": 45.2,
            "memory_percent": 62.1,
            "disk_io": 120,
            "network_in": 5000,
            "network_out": 12000
        }
    
    def predict_next_hour(self):
        """简单线性回归预测"""
        if len(self.metrics_history) < 24:
            return None
        
        recent = self.metrics_history[-24:]
        cpu_values = [m["cpu_percent"] for m in recent]
        
        # 简单移动平均 + 趋势外推
        avg = sum(cpu_values) / len(cpu_values)
        trend = (cpu_values[-1] - cpu_values[0]) / len(cpu_values)
        
        predicted = min(avg + trend * 2, 100)  # 2 小时后的预测
        return round(predicted, 1)
    
    def should_scale_up(self, predicted_cpu):
        """判断是否需要扩容"""
        threshold = self.config.get("scale_up_threshold", 75)
        budget = self.config.get("monthly_budget", 100)
        current_spend = self._get_current_spend()
        
        if predicted_cpu > threshold and current_spend < budget:
            return True
        return False
    
    def should_scale_down(self, predicted_cpu):
        """判断是否可以缩容"""
        cooldown = self.config.get("scale_down_cooldown_minutes", 15)
        min_instances = self.config.get("min_instances", 1)
        
        if predicted_cpu < 30 and min_instances > 1:
            return True
        return False
    
    def execute_scaling(self, action, target_spec):
        """执行扩缩操作"""
        print(f"[{datetime.now()}] 执行: {action}")
        # 调用 cloud provider API 或 SSH 到新实例
        # ...
        
    def run(self):
        """主循环"""
        while True:
            metrics = self.collect_metrics()
            self.metrics_history.append(metrics)
            
            prediction = self.predict_next_hour()
            if prediction:
                if self.should_scale_up(prediction):
                    self.execute_scaling("SCALE_UP", {"instance_type": "larger"})
                elif self.should_scale_down(prediction):
                    self.execute_scaling("SCALE_DOWN", {"instance_type": "smaller"})
            
            time.sleep(self.config.get("check_interval_seconds", 300))

if __name__ == "__main__":
    scaler = AIVPSScaler()
    scaler.run()