# Download and install Node Exporter
wget https://github.com/prometheus/node_exporter/releases/download/v1.8.2/node_exporter-1.8.2.linux-amd64.tar.gz
tar xzf node_exporter-1.8.2.linux-amd64.tar.gz
sudo cp node_exporter-1.8.2.linux-amd64/node_exporter /usr/local/bin/

# Create systemd service
sudo tee /etc/systemd/system/node_exporter.service << 'EOF'
[Unit]
Description=Node Exporter
Wants=network-online.target
After=network-online.target

[Service]
Type=simple
User=node_exporter
ExecStart=/usr/local/bin/node_exporter \
  --web.listen-address=:9100 \
  --collector.filesystem.mount-points-exclude="^/(sys|proc|dev|host|etc)($$|/)"

[Install]
WantedBy=multi-user.target
EOF

sudo systemctl enable --now node_exporter

# Download Prometheus
wget https://github.com/prometheus/prometheus/releases/download/v2.53.0/prometheus-2.53.0.linux-amd64.tar.gz
tar xzf prometheus-2.53.0.linux-amd64.tar.gz

# Configure prometheus.yml
sudo tee /etc/prometheus/prometheus.yml << 'EOF'
global:
  scrape_interval: 15s
  evaluation_interval: 15s

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

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

  - job_name: 'application'
    metrics_path: '/metrics'
    static_configs:
      - targets: ['localhost:8080']
EOF

# Start Prometheus
sudo tee /etc/systemd/system/prometheus.service << 'EOF'
[Unit]
Description=Prometheus
Wants=network-online.target
After=network-online.target

[Service]
Type=simple
User=prometheus
ExecStart=/usr/local/bin/prometheus \
  --config.file=/etc/prometheus/prometheus.yml \
  --storage.tsdb.path=/var/lib/prometheus \
  --storage.tsdb.retention.time=30d \
  --web.listen-address=:9090

[Install]
WantedBy=multi-user.target
EOF

sudo systemctl enable --now prometheus

#!/usr/bin/env python3
"""AI-Predictive Resource Scaling - Prophet Forecasting Module"""

import requests
import pandas as pd
import numpy as np
from prophet import Prophet
import json
import os
from datetime import datetime, timedelta

# ==================== Configuration ====================
PROMETHEUS_URL = os.getenv("PROMETHEUS_URL", "http://localhost:9090")
FORECAST_HOURS = 4          # Forecast next N hours
SCALE_UP_THRESHOLD = 0.80   # Scale up if CPU > 80%
SCALE_DOWN_THRESHOLD = 0.20 # Scale down if CPU < 20%
CHECK_INTERVAL_MINUTES = 30 # Check every 30 minutes

# ==================== Data Collection ====================
def query_prometheus(query, start=None, end=None):
    """Send a query to Prometheus"""
    params = {"query": query}
    if start:
        params["start"] = start
    if end:
        params["end"] = end

    resp = requests.get(f"{PROMETHEUS_URL}/api/v1/query", params=params)
    data = resp.json()["data"]["result"]

    results = []
    for item in data:
        metric = item["metric"]
        values = [(float(ts), float(val)) for ts, val in item["value"]]
        results.append({
            "metric": metric,
            "values": values
        })
    return results

def fetch_cpu_history(hours=720):
    """
    Collect CPU usage data for the past 30 days (sampled every 15 seconds)
    For efficiency, aggregate to minute-level averages.
    """
    end_time = datetime.utcnow().isoformat() + "Z"
    start_ts = datetime.utcnow() - timedelta(hours=hours)
    start_time = start_ts.isoformat() + "Z"

    # PromQL query: node average CPU usage
    query = (
        f'100 - (avg(rate(node_cpu_seconds_total{{mode="idle"}}[{hours//60}m])) * 100)'
    )

    results = query_prometheus(query, start_time, end_time)
    if not results:
        # Fallback query
        query = '100 - (avg(rate(node_cpu_seconds_total{mode="idle"}[5m])) * 100)'
        results = query_prometheus(query)

    return results

# ==================== Model Training ====================
def train_prophet_model(cpu_data, metric_name="cpu_percent"):
    """
    Train a time-series forecasting model using Prophet
    
    Args:
        cpu_data: Prometheus query results
        metric_name: Column name for Prophet
    
    Returns:
        Trained Prophet model
    """
    if not cpu_data:
        raise ValueError("No data collected. Cannot train model.")

    # Convert Prometheus data to Prophet format
    all_points = []
    for item in cpu_data:
        for ts, val in item["values"]:
            all_points.append({
                "ds": datetime.utcfromtimestamp(ts),
                metric_name: min(max(val, 0), 100)  # Clamp to 0-100
            })

    df = pd.DataFrame(all_points)
    df = df.sort_values("ds").reset_index(drop=True)

    # Aggregate to hourly averages to reduce computation
    df["hour"] = df["ds"].dt.floor("h")
    df = df.groupby("hour")[metric_name].mean().reset_index()
    df = df.rename(columns={"hour": "ds"})

    if len(df) < 24:
        raise ValueError(f"Insufficient data points ({len(df)}), need at least 24")

    # Train Prophet model
    model = Prophet(
        daily_seasonality=True,   # Enable daily cycle
        weekly_seasonality=True,  # Enable weekly cycle
        yearly_seasonality=False, # VPS usually has no yearly cycle
        changepoint_prior_scale=0.05,  # Smooth change points
        seasonality_prior_scale=10,
    )

    model.fit(df)

    # Validation: test on last 10% of data
    split_idx = int(len(df) * 0.9)
    train_df = df.iloc[:split_idx]
    test_df = df.iloc[split_idx:]

    train_model = Prophet(
        daily_seasonality=True,
        weekly_seasonality=True,
    ).fit(train_df)

    future = train_model.make_future_dataframe(periods=len(test_df), freq="h")
    forecast = train_model.predict(future)

    # Calculate MAPE (Mean Absolute Percentage Error)
    mape = np.mean(
        np.abs((test_df[metric_name].values - forecast.iloc[-len(test_df):][metric_name].values)
               / test_df[metric_name].values)
    ) * 100

    print(f"Model training complete. MAPE: {mape:.2f}%")
    return model

# ==================== Forecasting & Decision ====================
def forecast_and_decide(model, hours=FORECAST_HOURS):
    """
    Forecast future resource needs and make scaling decisions
    
    Returns:
        dict: Forecast results and scaling recommendations
    """
    future = model.make_future_dataframe(periods=hours, freq="h")
    forecast = model.predict(future)

    # Extract future predictions
    predictions = forecast[["ds", "cpu_percent", "cpu_percent_lower", "cpu_percent_upper"]].tail(hours)

    # Get predicted mean and upper bound
    max_predicted_cpu = predictions["cpu_percent"].max()
    max_predicted_upper = predictions["cpu_percent_upper"].max()

    # Find peak time
    peak_hour = predictions.loc[predictions["cpu_percent"].idxmax(), "ds"]

    decision = {
        "current_time": datetime.utcnow().isoformat(),
        "forecast_window_hours": hours,
        "max_predicted_cpu": round(max_predicted_cpu, 2),
        "max_predicted_cpu_upper_bound": round(max_predicted_upper, 2),
        "peak_time": peak_hour.isoformat(),
        "recommendation": None,
        "urgency": "normal"
    }

    # Decision logic
    if max_predicted_upper > SCALE_UP_THRESHOLD * 100:
        # High confidence of exceeding threshold → scale up immediately
        decision["recommendation"] = "scale_up_immediately"
        decision["urgency"] = "high"
        decision["reason"] = (
            f"Predicted peak CPU at {max_predicted_upper:.1f}%, "
            f"expected at {peak_hour.strftime('%H:%M')}"
        )
    elif max_predicted_cpu > SCALE_UP_THRESHOLD * 0.85:
        # Likely to exceed → prepare scaling
        decision["recommendation"] = "scale_up_prepared"
        decision["urgency"] = "medium"
        decision["reason"] = (
            f"Predicted peak CPU at {max_predicted_cpu:.1f}%, "
            f"expected at {peak_hour.strftime('%H:%M')}"
        )
    elif max_predicted_cpu < SCALE_DOWN_THRESHOLD * 100:
        # Resources are abundant → consider scaling down
        decision["recommendation"] = "consider_scale_down"
        decision["urgency"] = "low"
        decision["reason"] = f"Predicted CPU peak for next {hours}h is only {max_predicted_cpu:.1f}%"
    else:
        decision["recommendation"] = "no_action"
        decision["reason"] = "Resource usage is within normal range"

    return decision

# ==================== Execute Scaling ====================
def execute_scaling(decision):
    """
    Execute scaling operations based on decisions
    
    In production, this calls cloud provider APIs:
    - AWS: modify_autoscaling_group
    - GCP: update_instance_group
    - Self-hosted: change instance size / adjust container replicas
    """
    rec = decision["recommendation"]

    if rec == "no_action":
        print(f"[INFO] {decision['reason']}")
        return

    print(f"\n{'='*50}")
    print(f"[Decision] {decision['reason']}")
    print(f"{'='*50}")

    if rec == "scale_up_immediately":
        print("-> Action: Immediately scale up to higher instance class")
        # Example: call cloud provider API
        # cloud_provider.scale_up(instance_id, new_flavor="c7.xlarge")
    elif rec == "scale_up_prepared":
        print("-> Action: Pre-scale (prepare 30 minutes in advance)")
        # Example: launch standby instance, warm caches
        # cloud_provider.prepare_scaling(instance_id, lead_time_minutes=30)
    elif rec == "consider_scale_down":
        print("-> Action: Schedule scale down during next maintenance window")
        # Example: mark instance for scaling, wait for off-peak
        # cloud_provider.schedule_scale_down(instance_id, window="02:00-04:00")

# ==================== Main Loop ====================
def main():
    print("🤖 AI-Predictive Resource Scaling System Started")
    print(f"   Forecast window: {FORECAST_HOURS} hours")
    print(f"   Check interval: {CHECK_INTERVAL_MINUTES} minutes")
    print()

    # First run: train the model
    print("📊 Collecting historical data...")
    cpu_data = fetch_cpu_history(hours=720)  # 30 days

    print("🧠 Training forecasting model...")
    model = train_prophet_model(cpu_data)

    # Continuous monitoring loop
    while True:
        print(f"\n⏰ [{datetime.now().strftime('%Y-%m-%d %H:%M')}] Running forecast check...")

        decision = forecast_and_decide(model)
        execute_scaling(decision)

        # Save decision log
        log_entry = {
            "timestamp": datetime.utcnow().isoformat(),
            **decision
        }
        with open("/var/log/ai-scaling.log", "a") as f:
            f.write(json.dumps(log_entry) + "\n")

        print(f"\n💤 Next check in {CHECK_INTERVAL_MINUTES} minutes")
        import time
        time.sleep(CHECK_INTERVAL_MINUTES * 60)

if __name__ == "__main__":
    main()

"""LSTM Forecasting Module - For complex traffic patterns"""

import tensorflow as tf
import numpy as np
from sklearn.preprocessing import MinMaxScaler

class LSTMForecaster:
    def __init__(self, lookback=168, forecast_horizon=24):
        """
        Args:
            lookback: How many hours of history to use (7 days = 168 hours)
            forecast_horizon: How many hours to predict ahead
        """
        self.lookback = lookback
        self.forecast_horizon = forecast_horizon
        self.model = None
        self.scaler = MinMaxScaler()

    def build_model(self, input_dim=1):
        """Build LSTM model"""
        model = tf.keras.Sequential([
            tf.keras.layers.LSTM(64, return_sequences=True,
                                input_shape=(self.lookback, input_dim)),
            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(self.forecast_horizon)
        ])

        model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=0.001),
                     loss='mse')
        self.model = model
        return model

    def prepare_data(self, history_series):
        """
        Convert time-series data to LSTM input format
        
        history_series: pandas Series with DatetimeIndex
        """
        scaled = self.scaler.fit_transform(history_series.values.reshape(-1, 1))

        X, y = [], []
        for i in range(self.lookback, len(scaled) - self.forecast_horizon + 1):
            X.append(scaled[i - self.lookback:i])
            y.append(scaled[i:i + self.forecast_horizon].flatten())

        return np.array(X), np.array(y)

    def train(self, history_series, epochs=50, batch_size=32):
        """Train the model"""
        X, y = self.prepare_data(history_series)

        if self.model is None:
            self.build_model(input_dim=1)

        self.model.fit(
            X, y,
            epochs=epochs,
            batch_size=batch_size,
            validation_split=0.1,
            verbose=1
        )

    def predict(self, history_series):
        """Predict based on latest data"""
        scaled = self.scaler.transform(history_series.values.reshape(-1, 1))
        last_sequence = scaled[-self.lookback:].reshape(1, self.lookback, 1)

        pred_scaled = self.model.predict(last_sequence)[0]
        pred_original = self.scaler.inverse_transform(pred_scaled.reshape(-1, 1)).flatten()

        return pred_original

apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: app-predictive-scaler
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: my-app
  minReplicas: 2
  maxReplicas: 20
  metrics:
  - type: Pods
    pods:
      metric:
        name: ai_cpu_forecast
      target:
        type: Value
        averageValue: "80"

# Export AI predictions as Prometheus metrics
curl -X POST http://localhost:9090/api/v1/write \
  --data-binary 'ai_cpu_forecast{job="predictive-scaler"} 75.3'

import boto3

asg = boto3.client('autoscaling')

def scale_up(asg_name, desired_capacity):
    asg.set_desired_capacity(
        AutoScalingGroupName=asg_name,
        DesiredCapacity=desired_capacity,
        HonorCooldown=True
    )

def scale_down(asg_name, desired_capacity):
    asg.set_desired_capacity(
        AutoScalingGroupName=asg_name,
        DesiredCapacity=desired_capacity,
        HonorCooldown=True
    )

from alibabacloud_ecs20140526.client import Client
from alibabacloud_tea_openapi.models import Config

config = Config(
    access_key_id=os.environ['ALI_ACCESS_KEY'],
    access_key_secret=os.environ['ALI_ACCESS_SECRET'],
    endpoint='ecs.aliyuncs.com'
)
client = Client(config)

# Change instance type
client.modify_instance_spec(
    instance_id='i-xxx',
    instance_type='ecs.g7.xlarge'
)

# Don't wait until predicted value > 80% to scale
# Instead, start preparing when predicted value > 65%
SAFE_MARGIN = 0.15  # 15% safety buffer

trigger_threshold = SCALE_UP_THRESHOLD * (1 - SAFE_MARGIN)
# i.e., trigger scaling prep when prediction > 68%