# 创建 Prometheus 目录
mkdir -p ~/ai-vps-monitor/{prometheus,node-exporter,grafana}
cd ~/ai-vps-monitor

# docker-compose.yml
cat > docker-compose.yml << 'EOF'
version: "3.8"

services:
  node-exporter:
    image: prom/node-exporter:latest
    container_name: node-exporter
    restart: unless-stopped
    network_mode: host
    pid: host
    volumes:
      - /proc:/host/proc:ro
      - /sys:/host/sys:ro
      - /:/rootfs:ro
    command:
      - '--path.procfs=/host/proc'
      - '--path.sysfs=/host/sys'
      - '--collector.filesystem.mount-points-exclude=^/(sys|proc|dev|host|etc)($$|/)'

  prometheus:
    image: prom/prometheus:latest
    container_name: prometheus
    restart: unless-stopped
    network_mode: host
    volumes:
      - ./prometheus/prometheus.yml:/etc/prometheus/prometheus.yml
      - ./prometheus/data:/prometheus
    command:
      - '--config.file=/etc/prometheus/prometheus.yml'
      - '--storage.tsdb.path=/prometheus'
      - '--storage.tsdb.retention.time=30d'
      - '--web.enable-lifecycle'

  alertmanager:
    image: prom/alertmanager:latest
    container_name: alertmanager
    restart: unless-stopped
    network_mode: host
    volumes:
      - ./prometheus/alertmanager.yml:/etc/alertmanager/alertmanager.yml
    command:
      - '--config.file=/etc/alertmanager/alertmanager.yml'
      - '--storage.path=/alertmanager'

volumes:
  prometheus-data:
EOF

# Prometheus 配置
mkdir -p prometheus
cat > prometheus/prometheus.yml << 'EOF'
global:
  scrape_interval: 15s
  evaluation_interval: 15s

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

  - job_name: 'prometheus'
    static_configs:
      - targets: ['localhost:9090']
EOF

# 告警规则
cat > prometheus/alertmanager.yml << 'EOF'
route:
  receiver: 'default'

receivers:
  - name: 'default'
    webhook_configs:
      - url: 'http://localhost:8080/webhook'
EOF

# 启动
docker compose up -d

# 检查 Node Exporter 是否正常运行
curl http://localhost:9100/metrics | head -20

# 检查 Prometheus 是否采集到了数据
curl http://localhost:9090/api/v1/targets | python3 -m json.tool

# 查询 CPU 使用率
curl 'http://localhost:9090/api/v1/query?query=100-(avg(irate(node_cpu_seconds_total{mode="idle"}[5m]))*100)'

# 使用 Ollama 部署本地推理模型
curl -fsSL https://ollama.com/install.sh | sh
ollama pull llama3.2:3b

# 创建自定义系统提示
ollama create ai-resource-manager -f << 'EOF'
FROM llama3.2:3b

SYSTEM """你是一个专业的 VPS 资源管理专家。你的职责是：
1. 分析系统指标数据（CPU、内存、磁盘、网络）
2. 识别负载模式和异常
3. 基于成本约束生成最优资源配置建议
4. 预测未来 24-72 小时的资源需求

输出格式必须为 JSON：
{
  "status": "optimal|warning|critical",
  "recommendations": [
    {
      "action": "scale_up|scale_down|migrate|optimize",
      "detail": "具体建议",
      "priority": 1,
      "estimated_savings_pct": 15,
      "risk_level": "low|medium|high"
    }
  ],
  "forecast": {
    "next_24h_avg_cpu": 35,
    "next_24h_peak_cpu": 72,
    "next_24h_avg_memory_pct": 58,
    "next_72h_recommended_config": "2C4G"
  },
  "cost_analysis": {
    "current_monthly_cost": 12.5,
    "optimized_monthly_cost": 8.75,
    "potential_savings_pct": 30
  }
}
"""
EOF

pip install litellm psutil prometheus-api-client

# 配置 .env
cat > .env << 'EOF'
OPENAI_API_KEY=sk-your-key
OPENAI_API_BASE=https://api.openai.com/v1
MODEL_NAME=gpt-4o-mini
PROMETHEUS_URL=http://localhost:9090
TELEGRAM_BOT_TOKEN=your-bot-token
TELEGRAM_CHAT_ID=your-chat-id
EOF

#!/usr/bin/env python3
"""AI 驱动的 VPS 资源优化 Agent"""

import os
import sys
import json
import subprocess
import requests
from datetime import datetime, timedelta
from pathlib import Path
import psutil
import prometheus_api_client
import time

# 配置
PROMETHEUS_URL = os.getenv("PROMETHEUS_URL", "http://localhost:9090")
OLLAMA_URL = os.getenv("OLLAMA_URL", "http://localhost:11434")
TELEGRAM_TOKEN = os.getenv("TELEGRAM_BOT_TOKEN", "")
TELEGRAM_CHAT_ID = os.getenv("TELEGRAM_CHAT_ID", "")
CLOUD_API_KEY = os.getenv("CLOUD_API_KEY", "")  # 你的云服务商 API Key
MIN_CPU = 1  # 最小 CPU 核心数
MIN_MEMORY_GB = 1  # 最小内存 GB
COST_PER_CPU = 5.0  # 每个 CPU 核心的月成本（美元）
COST_PER_GB = 3.0  # 每个 GB 内存的月成本（美元）

class VPSOptimizer:
    def __init__(self):
        self.prom = prometheus_api_client.PrometheusConnect(
            url=PROMETHEUS_URL, disable_ssl=True
        )

    def collect_metrics(self):
        """采集当前系统指标"""
        now = datetime.now()

        # 从 Prometheus 获取时序数据
        cpu_query = "100 - (avg(irate(node_cpu_seconds_total{mode='idle'}[5m])) * 100)"
        cpu_result = self.prom.custom_query(query=cpu_query)
        current_cpu = float(cpu_result[0]['value'][1]) if cpu_result else psutil.cpu_percent()

        memory_query = "(node_memory_MemTotal_bytes - node_memory_MemAvailable_bytes) / node_memory_MemTotal_bytes * 100"
        mem_result = self.prom.custom_query(query=memory_query)
        current_memory = float(mem_result[0]['value'][1]) if mem_result else psutil.virtual_memory().percent

        disk_query = "100 - (node_filesystem_avail_bytes{mountpoint='/'} / node_filesystem_size_bytes{mountpoint='/'}) * 100"
        disk_result = self.prom.custom_query(query=disk_query)
        current_disk = float(disk_result[0]['value'][1]) if disk_result else psutil.disk_usage('/').percent

        network_query = "irate(node_network_receive_bytes_total[5m]) * 8 / 1000000"
        net_result = self.prom.custom_query(query=network_query)
        current_network = float(net_result[0]['value'][1]) if net_result else 0

        # 获取进程级资源排行
        top_processes = []
        for proc in psutil.process_iter(['pid', 'name', 'cpu_percent', 'memory_percent']):
            pinfo = proc.info
            if pinfo['cpu_percent'] and pinfo['cpu_percent'] > 1:
                top_processes.append({
                    "pid": pinfo['pid'],
                    "name": pinfo['name'],
                    "cpu": round(pinfo['cpu_percent'], 1),
                    "memory": round(pinfo['memory_percent'], 1)
                })
        top_processes.sort(key=lambda x: x['cpu'], reverse=True)

        return {
            "timestamp": now.isoformat(),
            "cpu_percent": round(current_cpu, 1),
            "memory_percent": round(current_memory, 1),
            "disk_percent": round(current_disk, 1),
            "network_mbps": round(current_network, 2),
            "top_processes": top_processes[:5],
            "uptime_hours": psutil.boot_time() and (now - datetime.fromtimestamp(psutil.boot_time())).total_seconds() / 3600
        }

    def get_historical_data(self, hours=24):
        """获取历史数据用于趋势分析"""
        end_time = datetime.now()
        start_time = end_time - timedelta(hours=hours)

        metrics = {}
        for metric in ["cpu", "memory", "disk"]:
            query_map = {
                "cpu": "100 - (avg(irate(node_cpu_seconds_total{mode='idle'}[5m])) * 100)",
                "memory": "(node_memory_MemTotal_bytes - node_memory_MemAvailable_bytes) / node_memory_MemTotal_bytes * 100"
            }
            if metric in query_map:
                result = self.prom.query_range(
                    query=query_map[metric],
                    start_time=start_time.strftime("%Y-%m-%dT%H:%M:%SZ"),
                    end_time=end_time.strftime("%Y-%m-%dT%H:%M:%SZ"),
                    step="300s"  # 5 分钟间隔
                )
                if result:
                    values = [float(v[1]) for v in result[0]['values']]
                    metrics[metric] = {
                        "avg": round(sum(values) / len(values), 1) if values else 0,
                        "max": round(max(values), 1) if values else 0,
                        "min": round(min(values), 1) if values else 0,
                        "data_points": len(values)
                    }

        return metrics

    def generate_llm_prompt(self, current, history):
        """为 LLM 生成分析提示"""
        prompt = f"""你是一个 VPS 资源管理专家。请分析以下系统数据并给出优化建议。

## 当前状态
- CPU 使用率: {current['cpu_percent']}%
- 内存使用率: {current['memory_percent']}%
- 磁盘使用率: {current['disk_percent']}%
- 网络带宽: {current['network_mbps']} Mbps
- 已运行时间: {current['uptime_hours']:.1f} 小时
- 最占资源的进程: {', '.join([p['name'] + f'({p["cpu"]:.1f}%)' for p in current['top_processes'][:3]])}

## 过去 {history.get('cpu', {}).get('data_points', 0)} 个数据点的历史统计
- CPU: 平均 {history.get('cpu', {}).get('avg', 'N/A')}% | 最高 {history.get('cpu', {}).get('max', 'N/A')}% | 最低 {history.get('cpu', {}).get('min', 'N/A')}%
- 内存: 平均 {history.get('memory', {}).get('avg', 'N/A')}% | 最高 {history.get('memory', {}).get('max', 'N/A')}% | 最低 {history.get('memory', {}).get('min', 'N/A')}%

## 约束条件
- 最小配置: {MIN_CPU} CPU 核心, {MIN_MEMORY_GB} GB 内存
- 每个 CPU 核心月成本: ${COST_PER_CPU}
- 每 GB 内存月成本: ${COST_PER_GB}
- 当前配置: 2 CPU, 4 GB（月费 $19）

请输出 JSON 格式的分析结果（不要包含任何其他文本）：
{{
  "status": "optimal | warning | critical",
  "recommendations": [...],
  "forecast": {...},
  "cost_analysis": {{
    "current_monthly_cost": 19,
    "optimized_monthly_cost": ?,
    "potential_savings_pct": ?
  }}
}}"""
        return prompt

    def query_llm(self, prompt):
        """查询 LLM 获取分析结果"""
        try:
            response = requests.post(
                f"{OLLAMA_URL}/api/generate",
                json={
                    "model": "ai-resource-manager",
                    "prompt": prompt,
                    "stream": False,
                    "options": {
                        "temperature": 0.3,
                        "num_predict": 1024
                    }
                },
                timeout=60
            )
            result = response.json()
            # 尝试解析 JSON 输出
            output = result.get('response', '')
            # 提取 JSON 部分
            if "```json" in output:
                output = output.split("```json")[1].split("```")[0].strip()
            elif "```" in output:
                output = output.split("```")[1].split("```")[0].strip()
            return json.loads(output)
        except Exception as e:
            return {
                "status": "unknown",
                "error": str(e),
                "fallback_analysis": "需要人工审核"
            }

    def evaluate_resources(self, llm_result, current):
        """根据 LLM 结果生成执行指令"""
        actions = []
        recommendations = llm_result.get("recommendations", [])

        for rec in recommendations:
            action = rec.get("action", "")
            priority = rec.get("priority", 3)
            detail = rec.get("detail", "")

            if action == "scale_down" and current['cpu_percent'] < 30 and current['memory_percent'] < 40:
                actions.append({
                    "type": "scale_down",
                    "detail": detail,
                    "confidence": "high",
                    "action": "建议降级到更低配置"
                })
            elif action == "scale_up" and current['cpu_percent'] > 80:
                actions.append({
                    "type": "scale_up",
                    "detail": detail,
                    "confidence": "high",
                    "action": "建议升级到更高配置"
                })
            elif action == "optimize":
                # 自动执行一些优化
                optimized = self.auto_optimize(current)
                actions.append({
                    "type": "auto_optimize",
                    "detail": optimized,
                    "confidence": "medium",
                    "action": "已自动执行资源优化"
                })

        return actions

    def auto_optimize(self, current):
        """自动执行安全优化"""
        optimizations = []

        # 1. 清理僵尸进程
        for proc in psutil.process_iter(['name', 'status']):
            try:
                if proc.info['status'] == psutil.STATUS_ZOMBIE:
                    optimizations.append(f"发现僵尸进程 PID {proc.info['pid']}，已标记清理")
            except (psutil.NoSuchProcess, psutil.AccessDenied):
                pass

        # 2. 释放磁盘空间 - 清理 Docker 无用资源
        try:
            subprocess.run(["docker", "system", "prune", "-f"], capture_output=True)
            optimizations.append("已清理未使用的 Docker 镜像和容器")
        except Exception:
            pass

        # 3. 清理系统日志
        try:
            subprocess.run(["journalctl", "--vacuum-time", "7d"], capture_output=True)
            optimizations.append("已清理 7 天前的系统日志")
        except Exception:
            pass

        # 4. 重启高内存泄漏进程
        for proc_info in current.get('top_processes', []):
            if proc_info.get('memory', 0) > 50:
                optimizations.append(f"进程 {proc_info['name']} (PID {proc_info['pid']}) 内存占用过高({proc_info['memory']}%)，建议监控")

        return "; ".join(optimizations) if optimizations else "无需优化"

    def send_notification(self, result):
        """发送 Telegram 通知"""
        if not TELEGRAM_TOKEN or not TELEGRAM_CHAT_ID:
            return

        status_emoji = {"optimal": "✅", "warning": "⚠️", "critical": "🚨", "unknown": "❓"}
        status = result.get("status", "unknown")
        emoji = status_emoji.get(status, "❓")

        cost_analysis = result.get("cost_analysis", {})
        savings = cost_analysis.get("potential_savings_pct", 0)

        forecast = result.get("forecast", {})

        message = f"""{emoji} *AI VPS 资源优化报告*

📊 *状态*: {status.upper()}
💰 *潜在节省*: {savings}%
💵 *当前月费*: ${cost_analysis.get('current_monthly_cost', 'N/A')}
💵 *优化后月费*: ${cost_analysis.get('optimized_monthly_cost', 'N/A')}

📈 *24 小时预测*:
- CPU 平均: {forecast.get('next_24h_avg_cpu', 'N/A')}%
- CPU 峰值: {forecast.get('next_24h_peak_cpu', 'N/A')}%
- 推荐配置: {forecast.get('next_72h_recommended_config', 'N/A')}

🔧 *建议*:
"""
        for rec in result.get("recommendations", []):
            message += f"- {rec.get('action', '')}: {rec.get('detail', '')}\n"

        requests.post(
            f"https://api.telegram.org/bot{TELEGRAM_TOKEN}/sendMessage",
            json={"chat_id": TELEGRAM_CHAT_ID, "text": message, "parse_mode": "Markdown"}
        )

    def run_cycle(self):
        """执行一轮完整的优化分析"""
        print(f"[{datetime.now().isoformat()}] 开始 AI 资源优化分析...")

        # 1. 采集指标
        current = self.collect_metrics()
        print(f"  当前 CPU: {current['cpu_percent']}%, 内存: {current['memory_percent']}%")

        # 2. 获取历史数据
        history = self.get_historical_data(hours=24)

        # 3. 生成 LLM 提示
        prompt = self.generate_llm_prompt(current, history)

        # 4. 查询 LLM
        llm_result = self.query_llm(prompt)
        print(f"  LLM 分析结果: {llm_result.get('status', 'unknown')}")

        # 5. 评估并生成执行动作
        actions = self.evaluate_resources(llm_result, current)

        # 6. 发送通知
        self.send_notification(llm_result)

        # 7. 保存分析报告
        report = {
            "timestamp": datetime.now().isoformat(),
            "metrics": current,
            "history": history,
            "llm_result": llm_result,
            "actions": actions
        }

        Path("reports").mkdir(exist_ok=True)
        report_path = f"reports/ai-report-{datetime.now().strftime('%Y%m%d-%H%M%S')}.json"
        with open(report_path, "w") as f:
            json.dump(report, f, indent=2, ensure_ascii=False)

        print(f"  报告已保存: {report_path}")
        return report

if __name__ == "__main__":
    import sys
    optimizer = VPSOptimizer()
    result = optimizer.run_cycle()

    # 命令行模式下可多次运行
    if "--daemon" in sys.argv:
        while True:
            time.sleep(300)  # 每 5 分钟执行一次
            try:
                optimizer.run_cycle()
            except Exception as e:
                print(f"错误: {e}")

# 安装依赖
pip3 install psutil prometheus-api-client requests

# 创建运行脚本
cat > /usr/local/bin/ai-vps-optimizer << 'SCRIPT'
#!/bin/bash
cd /root/ai-vps-optimizer
source venv/bin/activate
python3 optimizer.py
SCRIPT

chmod +x /usr/local/bin/ai-vps-optimizer

# 添加到 crontab
crontab -e
# 每小时执行一次
0 * * * * /usr/local/bin/ai-vps-optimizer >> /var/log/ai-vps-optimizer.log 2>&1

# 每日生成详细报告
0 9 * * * /usr/local/bin/ai-vps-optimizer --daily-report >> /var/log/ai-vps-optimizer.log 2>&1

# /etc/systemd/system/ai-vps-optimizer.service
[Unit]
Description=AI VPS Resource Optimizer
After=network-online.target prometheus.service
Wants=prometheus.service

[Service]
Type=simple
User=root
WorkingDirectory=/root/ai-vps-optimizer
EnvironmentFile=/root/ai-vps-optimizer/.env
ExecStart=/root/ai-vps-optimizer/venv/bin/python3 optimizer.py --daemon
Restart=on-failure
RestartSec=30
StandardOutput=append:/var/log/ai-vps-optimizer.log
StandardError=append:/var/log/ai-vps-optimizer.log

[Install]
WantedBy=multi-user.target

systemctl daemon-reload
systemctl enable --now ai-vps-optimizer
systemctl status ai-vps-optimizer

class AutoScaler:
    """安全自动扩缩容执行器"""

    def __init__(self):
        self.safe_actions = {
            "clear_docker_cache": True,    # 始终执行
            "vacuum_journals": True,        # 始终执行
            "restart_high_memory_process": False,  # 需要确认
            "scale_cpu": False,             # 需要确认
            "scale_memory": False,          # 需要确认
        }

    def execute_safe_actions(self, current_metrics):
        """自动执行安全操作"""
        results = []

        if current_metrics['disk_percent'] > 85:
            try:
                subprocess.run(["docker", "system", "prune", "-af"], capture_output=True)
                results.append("清理 Docker 缓存")
            except Exception as e:
                results.append(f"Docker 清理失败: {e}")

        if current_metrics['disk_percent'] > 90:
            try:
                subprocess.run(["journalctl", "--vacuum-size", "50M"], capture_output=True)
                results.append("清理系统日志")
            except Exception as e:
                results.append(f"日志清理失败: {e}")

        return results

    def estimate_config_cost(self, cpu_cores, memory_gb):
        """估算配置成本"""
        cpu_cost = cpu_cores * COST_PER_CPU
        mem_cost = memory_gb * COST_PER_GB
        base_cost = 2.0  # 基础费用
        return base_cost + cpu_cost + mem_cost

    def recommend_config_change(self, history, current):
        """基于历史数据推荐配置变更"""
        cpu_avg = history.get('cpu', {}).get('avg', 50)
        cpu_peak = history.get('cpu', {}).get('max', 80)
        mem_avg = history.get('memory', {}).get('avg', 60)
        mem_peak = history.get('memory', {}).get('max', 90)

        # 保留 30% 缓冲空间
        recommended_cpu = max(MIN_CPU, int(cpu_peak / 25) + 1)
        recommended_mem_gb = max(MIN_MEMORY_GB, int(mem_peak / 20) + 1)

        current_cost = self.estimate_config_cost(2, 4)  # 当前 2C4G
        recommended_cost = self.estimate_config_cost(recommended_cpu, recommended_mem_gb)
        savings_pct = round((1 - recommended_cost / current_cost) * 100, 1)

        return {
            "current_config": "2C4G",
            "current_monthly_cost": current_cost,
            "recommended_config": f"{recommended_cpu}C{recommended_mem_gb}G",
            "recommended_monthly_cost": recommended_cost,
            "savings_pct": savings_pct,
            "reasoning": (
                f"过去 24 小时 CPU 平均 {cpu_avg}%，峰值 {cpu_peak}%；"
                f"内存平均 {mem_avg}%，峰值 {mem_peak}%。"
                f"当前配置过剩，可降级到 {recommended_cpu}C{recommended_mem_gb}G。"
            )
        }

# 安装 Grafana（如果还没有）
docker run -d \
  --name grafana \
  -p 3000:3000 \
  -v ~/grafana-data:/var/lib/grafana \
  -e GF_SECURITY_ADMIN_PASSWORD=admin123 \
  grafana/grafana:latest

# CPU 利用率历史（用于计算是否资源过剩）
100 - (avg(irate(node_cpu_seconds_total{mode="idle"}[5m])) * 100)

# 内存利用率
(node_memory_MemTotal_bytes - node_memory_MemAvailable_bytes) / node_memory_MemTotal_bytes * 100

# 磁盘利用率
100 - (node_filesystem_avail_bytes{mountpoint="/"} / node_filesystem_size_bytes{mountpoint="/"} * 100)

# 每日费用估算（基于历史资源使用百分位）
# 第 95 百分位 CPU 决定所需的 CPU 核心数

# 在 .env 中设置
MAX_MONTHLY_COST=30  # 月费不超过 $30
MIN_RELIABILITY_SCORE=0.95  # 降级操作前必须达到此可靠性分数

# 查看最近的分析报告
ls -lt reports/ | head -10

# 查看 AI 建议的采纳率
grep -r '"action"' reports/ | wc -l  # 总建议数
grep -r '"executed"' reports/ | wc -l  # 已执行数

# 一键回滚到上一周的配置
curl -X POST http://localhost:8080/api/rollback \
  -H "Authorization: Bearer your-secret-token"

# 查看回滚历史
cat reports/rollback-history.json