# 创建 Python 虚拟环境
python3 -m venv ~/ai-scaling-env
source ~/ai-scaling-env/bin/activate

# 安装依赖
pip install pandas numpy scikit-learn prophet matplotlib psutil

# 如果使用深度学习预测
pip install torch tensorflow

#!/usr/bin/env python3
"""VPS 系统指标采集器"""

import psutil
import json
import time
from datetime import datetime
import sqlite3

def collect_metrics():
    """采集当前系统指标"""
    metrics = {
        "timestamp": datetime.now().isoformat(),
        "cpu_percent": psutil.cpu_percent(interval=1),
        "cpu_count": psutil.cpu_count(),
        "memory": {
            "total": psutil.virtual_memory().total,
            "used": psutil.virtual_memory().used,
            "percent": psutil.virtual_memory().percent,
        },
        "disk": {
            "usage_percent": psutil.disk_usage("/").percent,
            "io_read": psutil.disk_io_counters().read_bytes if psutil.disk_io_counters() else 0,
            "io_write": psutil.disk_io_counters().write_bytes if psutil.disk_io_counters() else 0,
        },
        "network": {
            "bytes_sent": psutil.net_io_counters().bytes_sent,
            "bytes_recv": psutil.net_io_counters().bytes_recv,
            "connections": len(psutil.net_connections(kind='inet')),
        },
        "load_avg": os.getloadavg() if hasattr(os, 'getloadavg') else (0, 0, 0),
    }
    return metrics

def store_to_db(metrics):
    """存储到 SQLite 数据库"""
    conn = sqlite3.connect('/var/lib/vps-metrics/metrics.db')
    cursor = conn.cursor()
    
    cursor.execute('''
        CREATE TABLE IF NOT EXISTS metrics (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            timestamp TEXT NOT NULL,
            cpu_percent REAL,
            memory_percent REAL,
            disk_percent REAL,
            network_in_bytes INTEGER,
            network_out_bytes INTEGER,
            active_connections INTEGER,
            load_avg_1 REAL,
            load_avg_5 REAL,
            load_avg_15 REAL
        )
    ''')
    
    cursor.execute('''
        INSERT INTO metrics 
        (timestamp, cpu_percent, memory_percent, disk_percent,
         network_in_bytes, network_out_bytes, active_connections,
         load_avg_1, load_avg_5, load_avg_15)
        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
    ''', (
        metrics['timestamp'],
        metrics['cpu_percent'],
        metrics['memory']['percent'],
        metrics['disk']['usage_percent'],
        metrics['network']['bytes_recv'],
        metrics['network']['bytes_sent'],
        metrics['network']['connections'],
        metrics['load_avg'][0],
        metrics['load_avg'][1],
        metrics['load_avg'][2],
    ))
    
    conn.commit()
    conn.close()

if __name__ == '__main__':
    import os
    os.makedirs('/var/lib/vps-metrics', exist_ok=True)
    
    while True:
        try:
            m = collect_metrics()
            store_to_db(m)
        except Exception as e:
            print(f"Error: {e}")
        time.sleep(60)  # 每分钟采集一次

#!/usr/bin/env python3
"""基于 Prophet 的 VPS 流量预测"""

import pandas as pd
from fbprophet import Prophet
import sqlite3
import json

def load_history(days=90):
    """从数据库加载历史数据"""
    conn = sqlite3.connect('/var/lib/vps-metrics/metrics.db')
    
    query = f"""
        SELECT timestamp, cpu_percent, memory_percent, 
               network_in_bytes + network_out_bytes as total_network,
               active_connections
        FROM metrics 
        WHERE timestamp >= datetime('now', '-{days} days')
        ORDER BY timestamp
    """
    
    df = pd.read_sql_query(query, conn)
    conn.close()
    
    # 转换为 Prophet 所需格式
    df['ds'] = pd.to_datetime(df['timestamp'])
    df['y'] = df['total_network']  # 以总网络流量作为预测目标
    
    return df[['ds', 'y']]

def train_and_predict(history_df, forecast_days=7):
    """训练模型并预测未来流量"""
    
    # 添加额外特征：小时、星期几
    history_df['hour'] = history_df['ds'].dt.hour
    history_df['dayofweek'] = history_df['ds'].dt.dayofweek
    history_df['is_weekend'] = history_df['dayofweek'].isin([5, 6]).astype(int)
    
    # 训练 Prophet 模型
    model = Prophet(
        daily_seasonality=True,
        weekly_seasonality=True,
        yearly_seasonality=False,
        changepoint_prior_scale=0.05,
    )
    
    model.add_regressor('hour')
    model.add_regressor('is_weekend')
    
    model.fit(history_df)
    
    # 生成预测
    future = model.make_future_dataframe(periods=forecast_days * 24, freq='H')
    
    # 为预测期添加回归变量
    future['hour'] = future['ds'].dt.hour
    future['is_weekend'] = future['ds'].dt.dayofweek.isin([5, 6]).astype(int)
    
    forecast = model.predict(future)
    
    return model, forecast

def generate_scaling_recommendations(forecast, current_cpu=50):
    """根据预测生成扩缩容建议"""
    
    recommendations = []
    
    for _, row in forecast.tail(168).iterrows():  # 未来7天
        predicted_load = row['y'] / 1000000  # 归一化
        
        # 如果预测负载超过当前容量的 80%
        if predicted_load > 0.8:
            recommendations.append({
                'time': str(row['ds']),
                'action': 'scale_up',
                'reason': f'预测负载 {predicted_load:.1%} 超过阈值',
                'suggested_cpu': min(int(current_cpu * 1.5), 32),
                'urgency': 'high' if predicted_load > 0.9 else 'medium',
            })
        # 如果预测负载低于 20%，建议缩减
        elif predicted_load < 0.2 and current_cpu > 4:
            recommendations.append({
                'time': str(row['ds']),
                'action': 'scale_down',
                'reason': f'预测负载 {predicted_load:.1%} 低于阈值',
                'suggested_cpu': max(int(current_cpu * 0.7), 2),
                'urgency': 'low',
            })
    
    return recommendations

if __name__ == '__main__':
    history = load_history(days=90)
    model, forecast = train_and_predict(history, forecast_days=7)
    recs = generate_scaling_recommendations(forecast)
    
    print(json.dumps(recs[:5], indent=2, ensure_ascii=False))

# 编辑 crontab
crontab -e

# 每 5 分钟采集一次指标
*/5 * * * * /root/ai-scaling-collector.sh >> /var/log/vps-metrics.log 2>&1

# 每小时运行一次预测和决策
0 * * * * /root/ai-scaling-decision.sh >> /var/log/vps-decision.log 2>&1

# 每天凌晨重新训练模型
0 3 * * * /root/ai-scaling-retrain.sh >> /var/log/vps-retrain.log 2>&1

#!/bin/bash
# ai-scaling-decision.sh - AI 驱动的扩缩容决策执行器

RECOMMENDATIONS_FILE="/var/lib/ai-scaling/recommendations.json"
LOG_FILE="/var/log/vps-decision.log"

log() {
    echo "$(date '+%Y-%m-%d %H:%M:%S') $1" | tee -a "$LOG_FILE"
}

execute_scaling_action() {
    local action=$1
    local suggested_cpu=$2
    local urgency=$3
    
    case "$action" in
        scale_up)
            log "📈 [${urgency}] 执行扩容: 建议 CPU 核心数 -> ${suggested_cpu}"
            
            # 方案 A: 垂直升级 (Cloud API)
            if command -v curl &>/dev/null; then
                # 示例：调用 CloudVPS API
                # curl -X POST "https://api.cloudvps.com/v1/instances/$HOST_ID/resize" \
                #   -H "Authorization: Bearer $API_KEY" \
                #   -d "{\"vcpus\": ${suggested_cpu}}"
                log "垂直升级指令已生成 (需配置云厂商 API)"
            fi
            
            # 方案 B: 水平扩展 - 启动备用实例
            docker service scale web-frontend=$(( $(docker service ls --filter "name=web-frontend" --format "{{.Replicas}}" 2>/dev/null || echo 1) + 1 ))
            log "水平扩展: 增加一个容器实例"
            ;;
            
        scale_down)
            log "📉 [${urgency}] 执行缩容: 建议 CPU 核心数 -> ${suggested_cpu}"
            
            # 平滑缩容：先 draining 再移除
            docker service scale web-frontend=$(max 1 $(docker service ls --filter "name=web-frontend" --format "{{.Replicas}}" 2>/dev/null | xargs -I{} expr {} - 1))
            log "水平缩容: 减少一个容器实例"
            ;;
            
        cache_warm)
            log "🔥 缓存预热: 清理并预加载热门数据"
            redis-cli FLUSHDB
            python3 /root/scripts/warm-cache.py
            ;;
            
        degrade)
            log "⚠️  降级策略: 关闭非核心功能"
            # 关闭评论、推荐等非核心功能
            sed -i 's/ENABLE_FEATURES=all/ENABLE_FEATURES=core/' /etc/app/config.yml
            systemctl reload app
            ;;
    esac
}

# 读取最新推荐并执行
if [ -f "$RECOMMENDATIONS_FILE" ]; then
    python3 << 'PYEOF'
import json
import subprocess

with open('/var/lib/ai-scaling/recommendations.json', 'r') as f:
    recs = json.load(f)

for rec in recs:
    if rec.get('urgency') == 'high':
        cmd = [
            '/bin/bash', '-c',
            f'echo "HIGH_PRIORITY: {rec["action"]} cpu={rec.get("suggested_cpu", "")}" >> /tmp/scaling-queue.txt'
        ]
        subprocess.run(cmd)
PYEOF
fi

log "扩缩容决策执行完成"

# docker-compose.swarm.yml
version: '3.8'

services:
  web-frontend:
    image: nginx:alpine
    deploy:
      replicas: 2
      resources:
        limits:
          cpus: '1.0'
          memory: 512M
        reservations:
          cpus: '0.25'
          memory: 128M
      update_config:
        parallelism: 1
        delay: 10s
      rollback_config:
        parallelism: 1
        delay: 5s
      restart_policy:
        condition: on-failure
        delay: 5s
        max_attempts: 3
        window: 120s
    ports:
      - "80:80"
    networks:
      - frontend

  api-backend:
    image: myapp/api:latest
    deploy:
      replicas: 2
      resources:
        limits:
          cpus: '2.0'
          memory: 1G
        reservations:
          cpus: '0.5'
          memory: 256M
    depends_on:
      - web-frontend
    networks:
      - frontend
      - backend

  database:
    image: postgres:16-alpine
    deploy:
      replicas: 1  # 数据库不水平扩展
      resources:
        limits:
          cpus: '2.0'
          memory: 2G
    volumes:
      - pgdata:/var/lib/postgresql/data
    networks:
      - backend

networks:
  frontend:
  backend:

volumes:
  pgdata:

#!/usr/bin/env python3
"""Docker Swarm 自动扩缩容控制器"""

import docker
import time
from datetime import datetime

class AutoScaler:
    def __init__(self, client=None):
        self.client = client or docker.from_env()
        self.scale_thresholds = {
            'cpu_high': 80,      # CPU > 80% 触发扩容
            'cpu_low': 20,       # CPU < 20% 触发缩容
            'mem_high': 85,      # 内存 > 85% 触发扩容
            'min_replicas': 1,   # 最少副本数
            'max_replicas': 10,  # 最多副本数
        }
    
    def get_service_metrics(self, service_name):
        """获取服务指标"""
        service = self.client.services.get(service_name)
        tasks = service.tasks()
        
        cpu_total = 0
        mem_total = 0
        task_count = len(tasks)
        
        for task in tasks:
            if task.get('Stats'):
                stats = task['Stats']
                cpu_total += stats.get('cpu_stats', {}).get('cpu_usage', {}).get('total_usage', 0)
                mem_total += stats.get('memory_stats', {}).get('usage', 0)
        
        avg_cpu = cpu_total / task_count if task_count > 0 else 0
        avg_mem = mem_total / task_count if task_count > 0 else 0
        
        return {
            'avg_cpu': avg_cpu,
            'avg_mem': avg_mem,
            'active_tasks': task_count,
        }
    
    def auto_scale(self, service_name, direction='auto'):
        """自动扩缩容"""
        metrics = self.get_service_metrics(service_name)
        service = self.client.services.get(service_name)
        
        current_replicas = service.attrs['Spec']['ReplicaSpec']['Replicas']
        
        if direction == 'auto':
            if metrics['avg_cpu'] > self.scale_thresholds['cpu_high']:
                new_replicas = min(current_replicas + 1, self.scale_thresholds['max_replicas'])
                if new_replicas > current_replicas:
                    service.scale(replicas=new_replicas)
                    print(f"[{datetime.now()}] 扩容: {current_replicas} -> {new_replicas}")
                    
            elif metrics['avg_cpu'] < self.scale_thresholds['cpu_low']:
                new_replicas = max(current_replicas - 1, self.scale_thresholds['min_replicas'])
                if new_replicas < current_replicas:
                    service.scale(replicas=new_replicas)
                    print(f"[{datetime.now()}] 缩容: {current_replicas} -> {new_replicas}")
        
        return metrics

if __name__ == '__main__':
    scaler = AutoScaler()
    
    # 监控所有服务
    for service in scaler.client.services.list():
        metrics = scaler.auto_scale(service.name, direction='auto')
        print(f"Service: {service.name}, Metrics: {metrics}")
    
    time.sleep(60)  # 每分钟检查一次

#!/usr/bin/env python3
"""AI 驱动的 VPS 实例推荐器"""

import json

INSTANCE_CATALOG = {
    "general": [
        {"name": "t6-small", "vcpu": 1, "ram_gb": 1, "price_yuan_hr": 0.02, "burst": True},
        {"name": "t6-medium", "vcpu": 2, "ram_gb": 2, "price_yuan_hr": 0.05, "burst": True},
        {"name": "c6-standard", "vcpu": 2, "ram_gb": 4, "price_yuan_hr": 0.08, "burst": False},
        {"name": "c6-large", "vcpu": 4, "ram_gb": 8, "price_yuan_hr": 0.16, "burst": False},
    ],
    "compute": [
        {"name": "c7-xlarge", "vcpu": 8, "ram_gb": 16, "price_yuan_hr": 0.32, "burst": False},
        {"name": "c7-2xlarge", "vcpu": 16, "ram_gb": 32, "price_yuan_hr": 0.64, "burst": False},
    ],
    "memory": [
        {"name": "r6-standard", "vcpu": 2, "ram_gb": 16, "price_yuan_hr": 0.12, "burst": False},
        {"name": "r6-large", "vcpu": 4, "ram_gb": 32, "price_yuan_hr": 0.24, "burst": False},
    ],
}

def recommend_instance(peak_cpu, peak_ram_gb, avg_cpu, avg_ram_gb, budget_yuan_month=200):
    """根据负载特征推荐最优实例组合"""
    
    # 计算基线需求（70% 分位数）
    baseline_vcpu = max(1, int(avg_cpu * 2))  # 假设每个 vCPU 承载 50% 负载
    baseline_ram = max(1, int(avg_ram_gb * 1.5))
    
    # 计算峰值需求
    peak_vcpu = max(baseline_vcpu, int(peak_cpu / 50 * baseline_vcpu))
    peak_ram = max(baseline_ram, int(peak_ram_gb * 1.3))
    
    # 推荐策略：包年基础实例 + 按需弹性
    base_instances = []
    remaining_budget = budget_yuan_month
    
    # 第一步：找到满足基线需求的包年实例
    for category, instances in INSTANCE_CATALOG.items():
        for inst in sorted(instances, key=lambda x: x['price_yuan_hr']):
            if inst['vcpu'] >= baseline_vcpu and inst['ram_gb'] >= baseline_ram:
                annual_cost = inst['price_yuan_hr'] * 24 * 30 * 0.7  # 包年 7 折
                if annual_cost <= remaining_budget:
                    base_instances.append(inst)
                    remaining_budget -= annual_cost
                    break
    
    # 第二步：为峰值准备弹性方案
    if peak_vcpu > baseline_vcpu or peak_ram > baseline_ram:
        extra_cost = remaining_budget * 0.3  # 预留 30% 预算应对突发
        base_instances.append({
            "type": "on_demand_scaling",
            "extra_vcpu_needed": peak_vcpu - baseline_vcpu,
            "extra_ram_gb": peak_ram - baseline_ram,
            "estimated_monthly_cost": extra_cost,
        })
    
    return {
        "baseline": base_instances,
        "scaling_strategy": "on_demand",
        "estimated_monthly_savings": f"{round((1 - remaining_budget / budget_yuan_month) * 100)}%",
        "total_estimated_cost": round(budget_yuan_month - remaining_budget, 2),
    }

if __name__ == '__main__':
    result = recommend_instance(
        peak_cpu=90, peak_ram_gb=8,
        avg_cpu=25, avg_ram_gb=2,
        budget_yuan_month=200
    )
    print(json.dumps(result, indent=2, ensure_ascii=False))

# prometheus 监控配置示例
scrape_configs:
  - job_name: 'vps-metrics'
    static_configs:
      - targets: ['localhost:9100']  # node_exporter
    
  - job_name: 'ai-scaling'
    metrics_path: '/metrics'
    static_configs:
      - targets: ['localhost:8080']  # AI 弹性伸缩控制器

groups:
  - name: ai-scaling-alerts
    rules:
      # CPU 持续高位
      - alert: HighCPUUsage
        expr: avg_rate(cpu_usage_percent[5m]) > 80
        for: 10m
        labels:
          severity: warning
        annotations:
          summary: "VPS CPU 持续高于 80%"
          description: "AI 预测模型将在 30 分钟内触发扩容"
          
      # 内存不足
      - alert: MemoryPressure
        expr: memory_used_percent > 85
        for: 5m
        labels:
          severity: critical
        annotations:
          summary: "VPS 内存使用率超过 85%"
          
      # AI 预测置信度低
      - alert: LowPredictionConfidence
        expr: ai_prediction_confidence < 0.6
        for: 1h
        labels:
          severity: info
        annotations:
          summary: "AI 预测模型置信度偏低，建议人工复核"