# 使用 Node Exporter + Prometheus 采集
docker run -d \
  --name node-exporter \
  --pid=host \
  --network=host \
  -v "/proc:/host/proc:ro" \
  -v "/sys:/host/sys:ro" \
  -v "/:/rootfs:ro" \
  prom/node-exporter:latest

# docker-compose.yml — 应用监控配置
services:
  prometheus:
    image: prom/prometheus:latest
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml
      - prometheus_data:/prometheus
    ports:
      - "9090:9090"

  grafana:
    image: grafana/grafana:latest
    ports:
      - "3001:3000"
    volumes:
      - grafana_data:/var/lib/grafana

# prometheus.yml
global:
  scrape_interval: 15s
  evaluation_interval: 30s

scrape_configs:
  - job_name: 'vps-infra'
    static_configs:
      - targets: ['node-exporter:9100']

  - job_name: 'docker-containers'
    docker_sd_configs:
      - host: unix:///var/run/docker.sock
    metrics_path: /metrics
    relabel_configs:
      - source_labels: [__meta_docker_container_name]
        regex: '/(.*)'
        target_label: container

# features.py — 特征工程
import pandas as pd
import numpy as np
from datetime import timedelta

def extract_features(df):
    """
    从时序数据中提取关键特征
    
    df 包含以下列:
    - timestamp: 时间戳
    - cpu_usage: CPU 使用率
    - memory_usage: 内存使用率
    - network_in: 入站带宽
    - network_out: 出站带宽
    - active_connections: 活跃连接数
    """
    df = df.sort_values('timestamp')
    
    # === 时间特征 ===
    df['hour_of_day'] = df['timestamp'].dt.hour
    df['day_of_week'] = df['timestamp'].dt.dayofweek
    df['is_weekend'] = (df['day_of_week'] >= 5).astype(int)
    df['is_business_hours'] = ((df['hour_of_day'] >= 9) & 
                                  (df['hour_of_day'] <= 18)).astype(int)
    
    # === 滞后特征（过去 N 个时间点的值）===
    for lag in [1, 2, 3, 6, 12, 24]:
        df[f'cpu_lag_{lag}h'] = df['cpu_usage'].shift(lag)
        df[f'memory_lag_{lag}h'] = df['memory_usage'].shift(lag)
    
    # === 滚动统计特征 ===
    for window in [3, 6, 12, 24]:
        df[f'cpu_roll_mean_{window}h'] = df['cpu_usage'].rolling(window).mean()
        df[f'cpu_roll_std_{window}h'] = df['cpu_usage'].rolling(window).std()
        df[f'memory_roll_mean_{window}h'] = df['memory_usage'].rolling(window).mean()
    
    # === 差分特征（变化率）===
    df['cpu_diff'] = df['cpu_usage'].diff()
    df['cpu_diff_pct'] = df['cpu_usage'].pct_change()
    df['network_diff'] = df['network_in'].diff()
    
    # === 周期性特征 ===
    # 正弦/余弦编码小时，保留周期性信息
    df['hour_sin'] = np.sin(2 * np.pi * df['hour_of_day'] / 24)
    df['hour_cos'] = np.cos(2 * np.pi * df['hour_of_day'] / 24)
    df['day_sin'] = np.sin(2 * np.pi * df['day_of_week'] / 7)
    df['day_cos'] = np.cos(2 * np.pi * df['day_of_week'] / 7)
    
    # 删除因滞后产生的 NaN 行
    df = df.dropna()
    
    return df

# predictor.py — AI 预测引擎
import numpy as np
import pandas as pd
from prophet import Prophet
import tensorflow as tf
from sklearn.ensemble import RandomForestRegressor, GradientBoostingRegressor
from sklearn.preprocessing import StandardScaler
from datetime import timedelta

class AIPredictor:
    """
    混合 AI 预测器
    
    组合三种模型的优势：
    - Prophet: 擅长捕捉周期性和趋势
    - LSTM: 擅长捕捉非线性时序依赖
    - XGBoost/RF: 擅长处理多维特征
    """
    
    def __init__(self, forecast_horizon=24):
        self.forecast_horizon = forecast_horizon  # 预测未来 24 小时
        self.prophet_model = None
        self.lstm_model = None
        self.rf_model = None
        self.scaler = StandardScaler()
        
    def train_prophet(self, df):
        """训练 Prophet 模型 — 基于时间序列分解"""
        # Prophet 需要的格式: ds (日期), y (目标值)
        prophet_df = df[['timestamp', 'cpu_usage']].copy()
        prophet_df.columns = ['ds', 'y']
        
        self.prophet_model = Prophet(
            daily_seasonality=True,
            weekly_seasonality=True,
            yearly_seasonality=False,
            changepoint_prior_scale=0.05,
            seasonality_prior_scale=10
        )
        self.prophet_model.fit(prophet_df)
        print("✅ Prophet 模型训练完成")
        
    def train_lstm(self, df, sequence_length=48):
        """训练 LSTM 模型 — 深度学习时序预测"""
        # 准备序列数据
        values = df['cpu_usage'].values.reshape(-1, 1)
        scaled = self.scaler.fit_transform(values)
        
        # 创建序列
        X, y = [], []
        for i in range(sequence_length, len(scaled)):
            X.append(scaled[i-sequence_length:i])
            y.append(scaled[i])
        
        X, y = np.array(X), np.array(y)
        
        # 构建 LSTM 模型
        model = tf.keras.Sequential([
            tf.keras.layers.LSTM(64, return_sequences=True, 
                                input_shape=(sequence_length, 1)),
            tf.keras.layers.Dropout(0.2),
            tf.keras.layers.LSTM(32, return_sequences=False),
            tf.keras.layers.Dropout(0.2),
            tf.keras.layers.Dense(16, activation='relu'),
            tf.keras.layers.Dense(1)
        ])
        
        model.compile(optimizer='adam', loss='mse')
        model.fit(X, y, epochs=30, batch_size=32, verbose=0)
        
        self.lstm_model = model
        print("✅ LSTM 模型训练完成")
        
    def train_random_forest(self, df):
        """训练随机森林 — 基于特征工程"""
        feature_cols = [col for col in df.columns 
                       if col not in ['timestamp', 'cpu_usage']]
        
        X = df[feature_cols].values
        y = df['cpu_usage'].values
        
        self.rf_model = GradientBoostingRegressor(
            n_estimators=200,
            max_depth=5,
            learning_rate=0.1,
            random_state=42
        )
        self.rf_model.fit(X, y)
        print("✅ 梯度提升模型训练完成")
        
    def predict_next_24h(self, last_data_points):
        """
        融合三个模型的预测结果
        
        返回: (predictions, confidence_intervals)
        """
        # Prophet 预测
        future_df = self.prophet_model.make_future_dataframe(periods=24, freq='h')
        prophet_pred = self.prophet_model.predict(future_df)
        prophet_forecast = prophet_pred['yhat'].tail(24).values
        
        # LSTM 预测（滚动预测）
        lstm_predictions = []
        current_seq = last_data_points[-48:]  # 最后 48 个时间点
        for _ in range(24):
            current_seq = current_seq.reshape(1, 48, 1)
            pred = self.lstm_model.predict(current_seq, verbose=0)[0][0]
            pred = self.scaler.inverse_transform([[pred]])[0][0]
            lstm_predictions.append(pred)
            current_seq = np.append(current_seq[0][1:], pred)
        
        # 加权融合
        weights = {'prophet': 0.4, 'lstm': 0.3, 'rf': 0.3}
        
        # RF 预测（用最后时间点的特征）
        rf_pred = self.rf_model.predict(last_data_points.iloc[[-1]])[0]
        rf_forecast = np.full(24, rf_pred)  # 简化：RF 给出基准值
        
        fused = (weights['prophet'] * prophet_forecast + 
                weights['lstm'] * np.array(lstm_predictions) +
                weights['rf'] * rf_forecast)
        
        # 计算置信区间（基于各模型的方差）
        std_dev = np.std([prophet_forecast, lstm_predictions, [rf_pred]*24], axis=0)
        upper_bound = fused + 1.96 * std_dev
        lower_bound = fused - 1.96 * std_dev
        
        return fused, lower_bound, upper_bound

# autoscaler.py — 自动伸缩控制器
import requests
import json
from datetime import datetime, timedelta

class VPSAutoscaler:
    """
    VPS 自动伸缩控制器
    
    根据 AI 预测结果自动调整资源配置
    支持多种云平台 API
    """
    
    def __init__(self, config):
        self.config = config
        self.cloud_provider = config.get('provider', 'hetzner')
        self.min_vcpus = config.get('min_vcpus', 1)
        self.max_vcpus = config.get('max_vcpus', 8)
        self.min_memory_gb = config.get('min_memory_gb', 1)
        self.max_memory_gb = config.get('max_memory_gb', 16)
        
    def evaluate_scaling_action(self, predictions, current_usage):
        """
        评估是否需要伸缩以及伸缩幅度
        
        Args:
            predictions: 未来 24 小时的预测值
            current_usage: 当前资源使用情况
            
        Returns:
            action: 'scale_up', 'scale_down', 'no_change'
            target_vcpus: 目标 CPU 核心数
            target_memory: 目标内存 (GB)
            urgency: 'low', 'medium', 'high'
        """
        peak_prediction = np.max(predictions[:6])  # 未来 6 小时峰值
        avg_prediction = np.mean(predictions[:6])
        
        # 预留 30% 缓冲
        buffer_factor = 1.3
        
        required_cpu = int(np.ceil(avg_prediction * buffer_factor / 10))
        required_memory = int(np.ceil(peak_prediction * buffer_factor / 20))
        
        # 限制在最小/最大值范围内
        required_cpu = max(self.min_vcpus, min(self.max_vcpus, required_cpu))
        required_memory = max(self.min_memory_gb, 
                             min(self.max_memory_gb, required_memory))
        
        # 判断动作
        current_cpu = current_usage.get('current_vcpus', 2)
        current_memory = current_usage.get('current_memory_gb', 2)
        
        if required_cpu > current_cpu or required_memory > current_memory:
            action = 'scale_up'
            urgency = 'high' if (required_cpu > current_cpu * 2) else 'medium'
        elif required_cpu < current_cpu * 0.7 and required_memory < current_memory * 0.7:
            action = 'scale_down'
            urgency = 'low'
        else:
            action = 'no_change'
            urgency = 'none'
            
        return {
            'action': action,
            'target_vcpus': required_cpu,
            'target_memory_gb': required_memory,
            'urgency': urgency,
            'reason': f"预测峰值: CPU {peak_prediction:.1f}%, 内存 {np.max(predictions[:6]):.1f}%"
        }
    
    def execute_scaling(self, scaling_decision):
        """执行伸缩决策"""
        action = scaling_decision['action']
        
        if action == 'no_change':
            print(f"ℹ️ 无需伸缩: {scaling_decision['reason']}")
            return {'status': 'skipped'}
        
        print(f"🔄 执行伸缩操作: {action}")
        print(f"   目标: CPU={scaling_decision['target_vcpus']}核, "
              f"内存={scaling_decision['target_memory_gb']}GB")
        print(f"   原因: {scaling_decision['reason']}")
        
        if action == 'scale_up':
            return self._scale_up(scaling_decision)
        elif action == 'scale_down':
            return self._scale_down(scaling_decision)
    
    def _scale_up(self, decision):
        """向上伸缩 — 切换更高配置的实例"""
        # 方案 A: 云 API 直接变更配置
        if self.cloud_provider == 'hetzner':
            return self._hetzner_upgrade(decision)
        elif self.cloud_provider == 'aliyun':
            return self._aliyun_upgrade(decision)
        elif self.cloud_provider == 'tencent':
            return self._tencent_upgrade(decision)
        return {'status': 'unsupported_provider'}
    
    def _hetzner_upgrade(self, decision):
        """Hetzner 升级方案"""
        # Hetzner 不支持在线升级，需要迁移策略
        target_plan = self._find_cheapest_plan(
            vcpus=decision['target_vcpus'],
            memory_gb=decision['target_memory_gb']
        )
        
        # 实际执行需要：
        # 1. 创建新实例
        # 2. rsync 数据迁移
        # 3. DNS 切换
        # 4. 销毁旧实例
        print(f"📋 Hetzner 升级计划: {target_plan}")
        print("   ⚠️ 需要人工确认或配置自动化迁移脚本")
        return {'status': 'planned', 'plan': target_plan}
    
    def _find_cheapest_plan(self, vcpus, memory_gb):
        """查找最便宜的匹配方案"""
        plans = [
            {'name': 'cx22', 'vcpus': 2, 'memory': 4, 'price': 4.15},
            {'name': 'cx32', 'vcpus': 4, 'memory': 8, 'price': 8.85},
            {'name': 'cx42', 'vcpus': 4, 'memory': 16, 'price': 14.09},
            {'name': 'cx52', 'vcpus': 8, 'memory': 16, 'price': 27.38},
        ]
        for plan in plans:
            if plan['vcpus'] >= vcpus and plan['memory'] >= memory_gb:
                return plan
        return plans[-1]  # 返回最大配置

    def _scale_down(self, decision):
        """向下伸缩 — 切换更低配置的实例"""
        # 类似 _scale_up 的逻辑，反向操作
        print("📋 降级计划生成中...")
        return {'status': 'planned'}

#!/bin/bash
# deploy-autoscaler.sh — 一键部署 AI 预测伸缩系统

set -euo pipefail

echo "🤖 正在部署 AI 预测伸缩系统..."

# 1. 创建项目目录
PROJECT_DIR="/opt/ai-autoscaler"
mkdir -p $PROJECT_DIR/{data,models,logs,scripts}

# 2. 安装依赖
pip3 install prophet tensorflow scikit-learn pandas numpy requests

# 3. 创建 systemd 服务
cat > /etc/systemd/system/ai-autoscaler.service << 'EOF'
[Unit]
Description=AI VPS Autoscaler
After=network.target prometheus.service

[Service]
Type=simple
User=root
WorkingDirectory=/opt/ai-autoscaler
ExecStart=/usr/bin/python3 /opt/ai-autoscaler/scripts/predict_and_scale.py
Restart=always
RestartSec=60
StandardOutput=append:/opt/ai-autoscaler/logs/autoscaler.log
StandardError=append:/opt/ai-autoscaler/logs/autoscaler-error.log

[Install]
WantedBy=multi-user.target
EOF

# 4. 创建 Cron 定时任务
crontab -l 2>/dev/null | grep -v "ai-autoscaler" | crontab -
(crontab -l 2>/dev/null; echo "*/15 * * * * /opt/ai-autoscaler/scripts/predict_and_scale.py >> /opt/ai-autoscaler/logs/cron.log 2>&1") | crontab -

# 5. 启动服务
systemctl daemon-reload
systemctl enable ai-autoscaler
systemctl start ai-autoscaler

echo "✅ AI 预测伸缩系统部署完成！"
echo "   查看状态: systemctl status ai-autoscaler"
echo "   查看日志: tail -f /opt/ai-autoscaler/logs/autoscaler.log"

#!/usr/bin/env python3
# predict_and_scale.py — 每日预测与伸缩决策

import sys
import os
import json
import requests
import numpy as np
from datetime import datetime, timedelta
from pathlib import Path

# 添加项目路径
sys.path.insert(0, str(Path(__file__).parent))

from predictor import AIPredictor
from autoscaler import VPSAutoscaler
from features import extract_features

# === 配置 ===
PROMETHEUS_URL = os.getenv('PROMETHEUS_URL', 'http://localhost:9090')
AUTOSCALER_CONFIG = {
    'provider': 'hetzner',
    'min_vcpus': 1,
    'max_vcpus': 4,
    'min_memory_gb': 1,
    'max_memory_gb': 8,
}
TELEGRAM_BOT_TOKEN = os.getenv('TELEGRAM_BOT_TOKEN', '')
TELEGRAM_CHAT_ID = os.getenv('TELEGRAM_CHAT_ID', '')

def fetch_prometheus_data(metric, start_hours=168):
    """从 Prometheus 获取指标数据"""
    end = datetime.now()
    start = end - timedelta(hours=start_hours)
    
    query = f'{metric}{{instance=~".*"}}'
    url = f'{PROMETHEUS_URL}/api/v1/query_range'
    params = {
        'query': query,
        'start': int(start.timestamp()),
        'end': int(end.timestamp()),
        'step': '300',  # 5 分钟粒度
    }
    
    resp = requests.get(url, params=params, timeout=10)
    resp.raise_for_status()
    data = resp.json()['data']
    
    if not data['result']:
        print("⚠️ Prometheus 无数据返回，使用默认值")
        return None
    
    # 解析为 DataFrame
    timestamps = data['result'][0]['values']
    values = [float(v[1]) for v in timestamps]
    times = [datetime.fromtimestamp(int(v[0])) for v in timestamps]
    
    df = pd.DataFrame({'timestamp': times, 'cpu_usage': values})
    return df

def get_current_resource_usage():
    """获取当前资源使用情况"""
    # 从 Node Exporter 实时获取
    try:
        resp = requests.get(
            'http://localhost:9100/metrics',
            timeout=5
        )
        metrics = {}
        for line in resp.text.split('\n'):
            if line.startswith('#'):
                continue
            parts = line.split()
            if len(parts) >= 2:
                key = parts[0].split('{')[0]
                metrics[key] = float(parts[1])
        
        # 解析 CPU 和内存
        cpu_usage = 100 - (
            metrics.get('node_cpu_seconds_total{mode="idle"}', 0) * 100
        )
        mem_total = metrics.get('node_memory_MemTotal_bytes', 1)
        mem_available = metrics.get('node_memory_MemAvailable_bytes', mem_total)
        memory_usage = (1 - mem_available / mem_total) * 100
        
        return {
            'current_vcpus': 2,  # 当前配置
            'current_memory_gb': 4,
            'cpu_usage_percent': cpu_usage,
            'memory_usage_percent': memory_usage,
        }
    except Exception as e:
        print(f"⚠️ 获取当前资源失败: {e}")
        return {'current_vcpus': 2, 'current_memory_gb': 4}

def send_notification(message):
    """发送 Telegram 通知"""
    if not TELEGRAM_BOT_TOKEN or not TELEGRAM_CHAT_ID:
        return
    
    url = f"https://api.telegram.org/bot{TELEGRAM_BOT_TOKEN}/sendMessage"
    requests.post(url, json={
        'chat_id': TELEGRAM_CHAT_ID,
        'text': message,
        'parse_mode': 'HTML'
    }, timeout=10)

def main():
    print(f"\n{'='*60}")
    print(f"🤖 AI 预测伸缩系统 — {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
    print(f"{'='*60}\n")
    
    # Step 1: 获取历史数据
    print("📊 步骤 1/4: 获取历史数据...")
    history_df = fetch_prometheus_data('node_cpu_seconds_total')
    if history_df is None or len(history_df) < 168:
        print("⚠️ 历史数据不足 7 天，使用模拟数据")
        # 生成模拟数据用于演示
        hours = pd.date_range(end=datetime.now(), periods=168, freq='h')
        np.random.seed(42)
        cpu_data = 30 + 20*np.sin(2*np.pi*hours.hour/24) + \
                   15*np.sin(2*np.pi*hours.dayofweek/7) + \
                   np.random.normal(0, 5, 168)
        history_df = pd.DataFrame({
            'timestamp': hours,
            'cpu_usage': np.clip(cpu_data, 5, 95)
        })
    
    print(f"   ✅ 获取 {len(history_df)} 条历史记录")
    
    # Step 2: 特征工程
    print("\n🔧 步骤 2/4: 特征工程...")
    features_df = extract_features(history_df)
    print(f"   ✅ 生成 {len(features_df.columns)} 个特征")
    
    # Step 3: 训练模型并预测
    print("\n🧠 步骤 3/4: AI 预测...")
    predictor = AIPredictor(forecast_horizon=24)
    predictor.train_prophet(features_df)
    predictor.train_random_forest(features_df)
    
    predictions, lower, upper = predictor.predict_next_24h(features_df)
    
    print(f"   ✅ 未来 24 小时预测:")
    peak_hour_idx = np.argmax(predictions[:6])
    peak_value = predictions[peak_hour_idx]
    print(f"   📈 未来 6 小时峰值: {peak_value:.1f}% (预计 {peak_hour_idx}:00)")
    print(f"   📉 未来 6 小时均值: {np.mean(predictions[:6]):.1f}%")
    
    # Step 4: 评估并执行
    print("\n⚙️  步骤 4/4: 评估伸缩决策...")
    current_usage = get_current_resource_usage()
    autoscaler = VPSAutoscaler(AUTOSCALER_CONFIG)
    
    decision = autoscaler.evaluate_scaling_action(predictions, current_usage)
    print(f"   📋 决策: {decision['action']} (紧急度: {decision['urgency']})")
    print(f"   💬 原因: {decision['reason']}")
    
    # 执行决策
    result = autoscaler.execute_scaling(decision)
    
    # 生成报告
    report = {
        'timestamp': datetime.now().isoformat(),
        'prediction': {
            'peak_6h': float(peak_value),
            'avg_6h': float(np.mean(predictions[:6])),
            'forecast': [float(p) for p in predictions],
        },
        'decision': decision,
        'result': result,
        'cost_estimate': estimate_savings(decision),
    }
    
    # 保存报告
    log_dir = Path('/opt/ai-autoscaler/logs')
    log_dir.mkdir(parents=True, exist_ok=True)
    with open(log_dir / f"decision-{datetime.now().strftime('%Y%m%d-%H%M%S')}.json", 'w') as f:
        json.dump(report, f, indent=2, default=str)
    
    # 发送通知
    notification_msg = format_notification(report)
    send_notification(notification_msg)
    
    print(f"\n{'='*60}")
    print(f"✅ 预测伸缩周期完成")
    print(f"   报告已保存至: {log_dir}")
    print(f"{'='*60}\n")

def estimate_savings(decision):
    """估算成本节省"""
    base_cost = 15.0  # 基础月费 (Hetzner CX22)
    
    if decision['action'] == 'scale_down':
        saved = base_cost * 0.3  # 降级可省 30%
        return {'monthly_saving': saved, 'annual_saving': saved * 12}
    elif decision['action'] == 'scale_up':
        extra = base_cost * 0.5  # 升级增加 50%
        return {'monthly_extra': extra, 'avoided_overload': True}
    return {'savings_note': '当前配置合理'}

def format_notification(report):
    """格式化通知消息"""
    msg = f"<b>🤖 AI 伸缩报告</b>\n\n"
    msg += f"⏰ {report['timestamp']}\n"
    msg += f"📈 预测峰值 (6h): {report['prediction']['peak_6h']:.1f}%\n"
    msg += f"📊 决策: {report['decision']['action']}\n"
    msg += f"💬 {report['decision']['reason']}\n"
    
    if 'monthly_saving' in report.get('cost_estimate', {}):
        saving = report['cost_estimate']['monthly_saving']
        msg += f"💰 预估月省: ¥{saving:.2f}\n"
    
    return msg

if __name__ == '__main__':
    main()

# 冷启动保护
if days_of_history < 7:
    buffer_factor = 1.5  # 更保守
    mode = 'monitoring_only'  # 仅监控，不执行
elif days_of_history < 14:
    buffer_factor = 1.4
    mode = 'approved_auto'  # 需审批后自动
else:
    buffer_factor = 1.3
    mode = 'fully_auto'  # 全自动

# dashboard-config.json — 关键面板
panels:
  - title: "CPU 预测 vs 实际"
    type: graph
    queries:
      - prediction: "predictor_cpu_forecast"
      - actual: "node_cpu_usage_actual"
  
  - title: "伸缩决策历史"
    type: table
    columns:
      - 时间
      - 决策类型
      - 预测峰值
      - 执行结果
  
  - title: "成本趋势"
    type: stat
    metrics:
      - monthly_spend
      - predicted_savings
      - roi_percentage