import pandas as pd
from prophet import Prophet

def build_capacity_model(metrics_df, forecast_days=30):
    """
    构建容量预测模型
    
    metrics_df: DataFrame with columns ['ds' (date), 'y' (metric value)]
    forecast_days: 预测未来多少天的容量需求
    """
    # 数据预处理：处理缺失值和异常值
    metrics_df = preprocess_time_series(metrics_df)
    
    # 初始化 Prophet 模型
    model = Prophet(
        yearly_seasonality=True,   # 年度周期性（如工作日/周末）
        weekly_seasonality=True,   # 周周期性
        daily_seasonality=False,   # 日级周期性（数据粒度为小时）
        changepoint_prior_scale=0.05,  # 趋势变化敏感度
    )
    
    # 添加外部回归量（如促销活动标记）
    if 'promo_event' in metrics_df.columns:
        model.add_regressor('promo_event')
    
    # 训练模型
    model.fit(metrics_df)
    
    # 生成预测
    future = model.make_future_dataframe(periods=forecast_days, freq='D')
    forecast = model.predict(future)
    
    return model, forecast

def generate_capacity_recommendation(
    current_metrics: dict,
    forecast: dict,
    budget_constraints: dict,
    slas: dict
) -> str:
    """
    生成容量规划建议和扩容方案
    """
    
    prompt = f"""
你是一个专业的云运维架构师，正在为一家快速增长的 SaaS 公司做容量规划。

【当前资源状态】
- CPU: {current_metrics['cpu']}%（趋势: {current_metrics['cpu_trend']}）
- 内存: {current_metrics['memory']}%（趋势: {current_metrics['memory_trend']}）
- 磁盘: {current_metrics['disk']}%（趋势: {current_metrics['disk_trend']}）
- 带宽: {current_metrics['bandwidth']}%（趋势: {current_metrics['bandwidth_trend']}）

【30 天预测】
- CPU 预计达到: {forecast['cpu_30d']}%
- 内存预计达到: {forecast['memory_30d']}%
- 磁盘预计达到: {forecast['disk_30d']}%

【约束条件】
- 月预算上限: ${budget_constraints['monthly_budget']}
- 目标 SLA: {sla_level} 可用性
- 最大可接受停机时间: {downtime_tolerance}

【当前配置】
- 当前 VPS: {current_specs}
- 当前月费: ${current_cost}

请分析并回答：
1. 哪个资源维度最先成为瓶颈？预计何时发生？
2. 推荐哪种扩容策略（垂直/横向/混合）？
3. 具体的资源配置建议是什么？
4. 预估扩容后的月成本是多少？在预算范围内吗？
5. 执行扩容需要注意哪些风险？

请用中文回答，格式清晰，给出可执行的建议。
"""
    
    response = call_llm(prompt)
    return response

def calculate_capacity_health(metrics: dict) -> dict:
    """
    计算容量健康度评分（0-100）
    100 = 非常充裕，0 = 立即扩容
    """
    scores = {}
    
    # CPU 健康度（考虑 iowait）
    cpu_score = max(0, 100 - metrics['cpu_usage'] * 1.2 - metrics['iowait'] * 0.5)
    scores['cpu'] = cpu_score
    
    # 内存健康度（考虑 swap 使用）
    memory_score = max(0, 100 - metrics['memory_usage'] * 1.5 - metrics['swap_usage'] * 2.0)
    scores['memory'] = memory_score
    
    # 磁盘健康度
    disk_score = max(0, 100 - metrics['disk_usage'] * 1.0)
    scores['disk'] = disk_score
    
    # 带宽健康度
    bandwidth_score = max(0, 100 - metrics['bandwidth_usage'] * 1.3)
    scores['bandwidth'] = bandwidth_score
    
    # 综合健康度（加权平均，I/O 密集型权重更高）
    weights = {
        'cpu': 0.25,
        'memory': 0.30,
        'disk': 0.25,
        'bandwidth': 0.20
    }
    overall = sum(scores[k] * weights[k] for k in weights)
    
    return {
        'overall': round(overall, 1),
        'breakdown': {k: round(v, 1) for k, v in scores.items()},
        'risk_level': classify_risk(overall),
        'bottleneck': identify_bottleneck(scores)
    }

def classify_risk(score: float) -> str:
    if score >= 70:
        return "正常"
    elif score >= 50:
        return "关注"
    elif score >= 30:
        return "预警"
    else:
        return "紧急"

def calculate_time_to_exhaustion(
    current_usage: float,
    growth_rate_per_day: float,
    threshold: float = 85.0
) -> int:
    """
    计算距离达到阈值的天数
    """
    if growth_rate_per_day <= 0:
        return 999  # 不会耗尽
    
    remaining_capacity = threshold - current_usage
    days_to_threshold = int(remaining_capacity / growth_rate_per_day)
    
    return max(0, days_to_threshold)

def generate_expansion_plan(
    server_id: str,
    health: dict,
    forecast: dict,
    cloud_providers: list,
    current_config: dict
) -> dict:
    """
    生成扩容方案对比
    """
    
    scenarios = []
    
    # 方案一：垂直扩容（升级当前 VPS 配置）
    vertical_plan = {
        'type': 'vertical',
        'description': f"将当前 {current_config['specs']} 升级到 {current_config['specs']}_upgraded",
        'monthly_cost_increase': calculate_vertical_upgrade_cost(current_config, 'upgraded'),
        'downtime_required': False,
        'risk': '低（热升级）',
        'estimated_capacity_headroom_days': 180
    }
    scenarios.append(vertical_plan)
    
    # 方案二：横向扩容（增加副本）
    horizontal_plan = {
        'type': 'horizontal',
        'description': "增加一台相同配置的 VPS，配置负载均衡",
        'monthly_cost_increase': current_config['monthly_cost'],
        'downtime_required': False,
        'risk': '中（需配置路由）',
        'estimated_capacity_headroom_days': 365
    }
    scenarios.append(horizontal_plan)
    
    # 方案三：混合扩容（部分垂直 + 部分横向）
    hybrid_plan = {
        'type': 'hybrid',
        'description': f"当前 VPS 升级到 {current_config['specs']}_mid + 增加一台轻量实例",
        'monthly_cost_increase': (
            calculate_vertical_upgrade_cost(current_config, 'mid') + 
            current_config['monthly_cost'] * 0.5
        ),
        'downtime_required': False,
        'risk': '中',
        'estimated_capacity_headroom_days': 270
    }
    scenarios.append(hybrid_plan)
    
    return {
        'server_id': server_id,
        'current_health': health,
        'forecast': forecast,
        'scenarios': scenarios,
        'recommendation': select_best_scenario(scenarios, current_config['budget'])
    }

def analyze_cost_impact(
    current_cost: float,
    proposed_cost: float,
    projected_revenue_growth: float,
    service_type: str
) -> dict:
    """
    分析扩容的成本影响和 ROI
    """
    cost_increase = proposed_cost - current_cost
    cost_increase_pct = (cost_increase / current_cost) * 100
    
    # 计算每单位能力的成本效率
    current_efficiency = current_cost / current_utilization
    proposed_efficiency = proposed_cost / (current_utilization * 1.5)
    
    return {
        'current_monthly_cost': current_cost,
        'proposed_monthly_cost': proposed_cost,
        'cost_increase': cost_increase,
        'cost_increase_percentage': round(cost_increase_pct, 1),
        'annual_cost_increase': round(cost_increase * 12, 2),
        'cost_efficiency_change': '改善' if proposed_efficiency < current_efficiency else '恶化',
        'roi_days': calculate_roi_days(cost_increase, projected_revenue_growth),
        'budget_impact': classify_budget_impact(cost_increase, current_cost)
    }

# 1. 安装依赖
pip install prophet pandas numpy scikit-learn requests

# 2. 安装 Node Exporter（采集 VPS 指标）
wget https://github.com/prometheus/node_exporter/releases/download/v1.7.0/node_exporter-1.7.0.linux-amd64.tar.gz
tar xvfz node_exporter-1.7.0.linux-amd64.tar.gz
sudo cp node_exporter-1.7.0.linux-amd64/node_exporter /usr/local/bin/

# 3. 创建 systemd 服务
sudo tee /etc/systemd/system/node_exporter.service << 'EOF'
[Unit]
Description=Node Exporter
After=network.target

[Service]
User=node_exporter
ExecStart=/usr/local/bin/node_exporter

[Install]
WantedBy=multi-user.target
EOF

sudo systemctl enable node_exporter
sudo systemctl start node_exporter

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

scrape_configs:
  - job_name: 'vps-infra'
    static_configs:
      - targets: ['localhost:9100', 'vps2:9100', 'vps3:9100']
  
  - job_name: 'vps-app'
    static_configs:
      - targets: ['app-exporter:8080']

#!/usr/bin/env python3
"""
AI 容量规划与预测脚本
用法: python3 capacity_planner.py --server vps1 --forecast-days 30
"""

import argparse
import json
import requests
from datetime import datetime, timedelta
import pandas as pd
from prophet import Prophet

PROMETHEUS_URL = "http://localhost:9090"

def fetch_metrics(query: str, time_range: str = "30d") -> pd.DataFrame:
    """从 Prometheus 获取指标数据"""
    url = f"{PROMETHEUS_URL}/api/v1/query"
    params = {
        "query": query,
        "time": datetime.now().isoformat(),
        "range": time_range
    }
    response = requests.get(url, params=params)
    data = response.json()
    
    # 转换为 DataFrame
    records = []
    for series in data['data']['result']:
        for timestamp, value in series['values']:
            records.append({
                'ds': pd.to_datetime(float(timestamp), unit='s'),
                'y': float(value),
                'instance': series['metric'].get('instance', 'unknown')
            })
    
    return pd.DataFrame(records)

def analyze_capacity(server: str, forecast_days: int = 30):
    """分析单台服务器的容量状况"""
    
    metrics_to_analyze = [
        ("cpu_usage", '100 - (avg by(instance) (rate(node_cpu_seconds_total{mode="idle"}[5m])) * 100)'),
        ("memory_usage", '(1 - (node_memory_MemAvailable_bytes / node_memory_MemTotal_bytes)) * 100'),
        ("disk_usage", '(1 - (node_filesystem_avail_bytes / node_filesystem_size_bytes)) * 100'),
        ("iowait", 'avg by(instance) (rate(node_cpu_seconds_total{mode="iowait"}[5m])) * 100'),
    ]
    
    results = {}
    
    for metric_name, promql in metrics_to_analyze:
        df = fetch_metrics(promql)
        if df.empty:
            continue
        
        # 构建 Prophet 模型
        model = Prophet(
            yearly_seasonality=True,
            weekly_seasonality=True
        )
        model.fit(df)
        
        # 预测
        future = model.make_future_dataframe(periods=forecast_days)
        forecast = model.predict(future)
        
        # 提取关键数据
        last_value = df['y'].iloc[-1]
        trend_slope = forecast['trend'].diff().mean()
        predicted_30d = forecast['yhat'].iloc[-forecast_days]
        
        results[metric_name] = {
            'current': round(last_value, 1),
            'trend': round(trend_slope * 30, 2),  # 30 天趋势
            'predicted_30d': round(float(predicted_30d), 1),
            'data_points': len(df)
        }
    
    # 计算健康度
    health = calculate_capacity_health(results)
    
    return {
        'server': server,
        'timestamp': datetime.now().isoformat(),
        'metrics': results,
        'health': health,
        'forecast_days': forecast_days
    }

def main():
    parser = argparse.ArgumentParser(description='AI 容量规划工具')
    parser.add_argument('--server', required=True, help='服务器标识')
    parser.add_argument('--forecast-days', type=int, default=30, help='预测天数')
    parser.add_argument('--output', help='输出文件')
    args = parser.parse_args()
    
    result = analyze_capacity(args.server, args.forecast_days)
    
    if args.output:
        with open(args.output, 'w') as f:
            json.dump(result, f, indent=2, ensure_ascii=False)
        print(f"结果已保存到 {args.output}")
    else:
        print(json.dumps(result, indent=2, ensure_ascii=False))

if __name__ == '__main__':
    main()

#!/usr/bin/env python3
"""
LLM 容量规划决策引擎
"""

import json
import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ.get('LLM_API_KEY'),
    base_url=os.environ.get('LLM_BASE_URL', 'http://localhost:11434/v1')
)

SYSTEM_PROMPT = """
你是一位资深云运维架构师，擅长 VPS 容量规划和成本优化。
你的任务是分析服务器容量数据，给出专业、可执行的扩容建议。

要求：
1. 数据驱动，基于实际指标做判断
2. 考虑成本约束，给出性价比最优方案
3. 风险评估要具体，不泛泛而谈
4. 输出格式清晰，便于运维人员执行
"""

def get_capacity_recommendation(capacity_report: dict) -> dict:
    """获取 LLM 生成的扩容建议"""
    
    user_message = f"""
分析以下服务器容量报告，给出扩容建议：

```json
{json.dumps(capacity_report, indent=2, ensure_ascii=False)}