# Create Python virtual environment
python3 -m venv ~/ai-scaling-env
source ~/ai-scaling-env/bin/activate

# Install dependencies
pip install pandas numpy scikit-learn prophet matplotlib psutil

# For deep learning predictions
pip install torch tensorflow

#!/usr/bin/env python3
"""VPS System Metrics Collector"""

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

def collect_metrics():
    """Collect current system 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):
    """Store to SQLite database"""
    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__':
    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)  # Collect every minute

#!/usr/bin/env python3
"""VPS Traffic Prediction Based on Prophet"""

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

def load_history(days=90):
    """Load historical data from database"""
    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()
    
    # Convert to Prophet-required format
    df['ds'] = pd.to_datetime(df['timestamp'])
    df['y'] = df['total_network']  # Use total network traffic as prediction target
    
    return df[['ds', 'y']]

def train_and_predict(history_df, forecast_days=7):
    """Train model and predict future traffic"""
    
    # Add additional features: hour, day of week
    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)
    
    # Train Prophet model
    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)
    
    # Generate forecasts
    future = model.make_future_dataframe(periods=forecast_days * 24, freq='H')
    
    # Add regressors for prediction period
    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):
    """Generate scaling recommendations based on predictions"""
    
    recommendations = []
    
    for _, row in forecast.tail(168).iterrows():  # Next 7 days
        predicted_load = row['y'] / 1000000  # Normalize
        
        # If predicted load exceeds 80% of current capacity
        if predicted_load > 0.8:
            recommendations.append({
                'time': str(row['ds']),
                'action': 'scale_up',
                'reason': f'Predicted load {predicted_load:.1%} exceeds threshold',
                'suggested_cpu': min(int(current_cpu * 1.5), 32),
                'urgency': 'high' if predicted_load > 0.9 else 'medium',
            })
        # If predicted load below 20%, suggest scaling down
        elif predicted_load < 0.2 and current_cpu > 4:
            recommendations.append({
                'time': str(row['ds']),
                'action': 'scale_down',
                'reason': f'Predicted load {predicted_load:.1%} below threshold',
                '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))

# Edit crontab
crontab -e

# Collect metrics every 5 minutes
*/5 * * * * /root/ai-scaling-collector.sh >> /var/log/vps-metrics.log 2>&1

# Run prediction and decision every hour
0 * * * * /root/ai-scaling-decision.sh >> /var/log/vps-decision.log 2>&1

# Retrain model daily at 3 AM
0 3 * * * /root/ai-scaling-retrain.sh >> /var/log/vps-retrain.log 2>&1

#!/bin/bash
# ai-scaling-decision.sh - AI-driven scaling decision executor

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}] Scaling UP: Suggested CPU cores -> ${suggested_cpu}"
            
            # Option A: Vertical upgrade (Cloud API)
            if command -v curl &>/dev/null; then
                # Example: Call CloudVPS API
                # curl -X POST "https://api.cloudvps.com/v1/instances/$HOST_ID/resize" \
                #   -H "Authorization: Bearer *** \
                #   -d "{\"vcpus\": ${suggested_cpu}}"
                log "Vertical upgrade command generated (configure cloud vendor API)"
            fi
            
            # Option B: Horizontal expansion - start standby instance
            docker service scale web-frontend=$(( $(docker service ls --filter "name=web-frontend" --format "{{.Replicas}}" 2>/dev/null || echo 1) + 1 ))
            log "Horizontal scaling: Added one container instance"
            ;;
            
        scale_down)
            log "📉 [${urgency}] Scaling DOWN: Suggested CPU cores -> ${suggested_cpu}"
            
            # Graceful scale-down: drain then remove
            docker service scale web-frontend=$(max 1 $(docker service ls --filter "name=web-frontend" --format "{{.Replicas}}" 2>/dev/null | xargs -I{} expr {} - 1))
            log "Horizontal scale-down: Removed one container instance"
            ;;
            
        cache_warm)
            log "🔥 Cache Warming: Clear and pre-load popular data"
            redis-cli FLUSHDB
            python3 /root/scripts/warm-cache.py
            ;;
            
        degrade)
            log "⚠️  Degradation Strategy: Disable non-core features"
            # Disable comments, recommendations, etc.
            sed -i 's/ENABLE_FEATURES=all/ENABLE_FEATURES=core/' /etc/app/config.yml
            systemctl reload app
            ;;
    esac
}

# Read latest recommendations and execute
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 "Scaling decision execution completed"

# 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  # Database does not scale horizontally
      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 Auto-Scaling Controller"""

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,      # Scale up when CPU > 80%
            'cpu_low': 20,       # Scale down when CPU < 20%
            'mem_high': 85,      # Scale up when memory > 85%
            'min_replicas': 1,   # Minimum replicas
            'max_replicas': 10,  # Maximum replicas
        }
    
    def get_service_metrics(self, service_name):
        """Get service metrics"""
        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'):
        """Automatic scaling"""
        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()}] Scale UP: {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()}] Scale DOWN: {current_replicas} -> {new_replicas}")
        
        return metrics

if __name__ == '__main__':
    scaler = AutoScaler()
    
    # Monitor all services
    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)  # Check every minute

#!/usr/bin/env python3
"""AI-Driven VPS Instance Recommender"""

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):
    """Recommend optimal instance combination based on load characteristics"""
    
    # Calculate baseline demand (70th percentile)
    baseline_vcpu = max(1, int(avg_cpu * 2))  # Assume each vCPU handles 50% load
    baseline_ram = max(1, int(avg_ram_gb * 1.5))
    
    # Calculate peak demand
    peak_vcpu = max(baseline_vcpu, int(peak_cpu / 50 * baseline_vcpu))
    peak_ram = max(baseline_ram, int(peak_ram_gb * 1.3))
    
    # Strategy: Reserved base instances + on-demand elasticity
    base_instances = []
    remaining_budget = budget_yuan_month
    
    # Step 1: Find reserved instances meeting baseline
    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  # 30% annual discount
                if annual_cost <= remaining_budget:
                    base_instances.append(inst)
                    remaining_budget -= annual_cost
                    break
    
    # Step 2: Prepare elastic solution for peaks
    if peak_vcpu > baseline_vcpu or peak_ram > baseline_ram:
        extra_cost = remaining_budget * 0.3  # Reserve 30% budget for spikes
        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 configuration example
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 auto-scaling controller

groups:
  - name: ai-scaling-alerts
    rules:
      # CPU sustained high
      - alert: HighCPUUsage
        expr: avg_rate(cpu_usage_percent[5m]) > 80
        for: 10m
        labels:
          severity: warning
        annotations:
          summary: "VPS CPU sustained above 80%"
          description: "AI prediction model will trigger scaling within 30 minutes"
          
      # Memory pressure
      - alert: MemoryPressure
        expr: memory_used_percent > 85
        for: 5m
        labels:
          severity: critical
        annotations:
          summary: "VPS memory usage exceeds 85%"
          
      # Low prediction confidence
      - alert: LowPredictionConfidence
        expr: ai_prediction_confidence < 0.6
        for: 1h
        labels:
          severity: info
        annotations:
          summary: "AI prediction model confidence is low, manual review recommended"