# Typical over-provisioned configuration
services:
  mysql:
    image: mysql:8.0
    deploy:
      resources:
        limits:
          cpus: "4.0"
          memory: 8G
        reservations:
          cpus: "2.0"
          memory: 4G
  redis:
    image: redis:7
    deploy:
      resources:
        limits:
          cpus: "2.0"
          memory: 4G
  nginx:
    image: nginx:latest
    deploy:
      resources:
        limits:
          cpus: "2.0"
          memory: 4G

# Deploy the data collection stack
docker compose up -d prometheus grafana cadvisor node-exporter

# Verify data collection
curl http://localhost:9090/api/v1/query?query=container_cpu_usage_seconds_total

import pandas as pd
from sklearn.cluster import KMeans
from sklearn.preprocessing import StandardScaler

def analyze_container_patterns(metrics_df, container_name):
    """Analyze container resource usage patterns"""
    features = metrics_df[[
        'cpu_usage_percent', 'memory_usage_percent',
        'network_rx_bytes', 'network_tx_bytes'
    ]].values

    scaler = StandardScaler()
    features_scaled = scaler.fit_transform(features)

    # Cluster to identify usage patterns
    kmeans = KMeans(n_clusters=3, random_state=42)
    patterns = kmeans.fit_predict(features_scaled)

    pattern_labels = {0: 'idle', 1: 'steady', 2: 'burst'}

    return {
        'container': container_name,
        'dominant_pattern': pattern_labels[patterns[0]],
        'cpu_avg': metrics_df['cpu_usage_percent'].mean(),
        'cpu_p99': metrics_df['cpu_usage_percent'].quantile(0.99),
        'mem_avg': metrics_df['memory_usage_percent'].mean(),
        'mem_p99': metrics_df['memory_usage_percent'].quantile(0.99),
    }

from prophet import Prophet
import numpy as np

def detect_anomalies(series, threshold=2.0):
    """Anomaly detection based on Prophet"""
    df = pd.DataFrame({
        'ds': pd.date_range(end=pd.Timestamp.now(), periods=len(series), freq='10min'),
        'y': series.values
    })

    model = Prophet(yearly_seasonality=False, weekly_seasonality=True, daily_seasonality=True)
    model.fit(df)

    future = model.make_future_dataframe(periods=6)
    forecast = model.predict(future)

    residuals = df['y'].values - forecast['yhat'].values[:len(df)]
    std_resid = np.std(residuals)
    mean_resid = np.mean(residuals)

    anomalies = []
    for i, r in enumerate(residuals):
        if abs(r - mean_resid) > threshold * std_resid:
            anomalies.append({
                'timestamp': df['ds'].iloc[i],
                'type': 'spike' if r > 0 else 'drop',
                'magnitude': abs(r - mean_resid) / std_resid
            })

    return anomalies

from openai import OpenAI

client = OpenAI(base_url="http://localhost:11434/v1", api_key="ollama")

def llm_root_cause_analysis(container_name, anomaly_data, system_context):
    """LLM analyzes container resource anomaly root cause"""
    prompt = f"""You are a VPS operations expert. Analyze the following container resource anomaly
and provide root cause and remediation suggestions.

Container: {container_name}
Anomaly Type: {anomaly_data['type']}
Anomaly Magnitude: {anomaly_data['magnitude']:.1f} standard deviations
System Context:
{system_context}

Please analyze:
1. What is the most likely root cause?
2. Does this require immediate action?
3. What are the recommended remediation steps?

Respond concisely in English."""

    response = client.chat.completions.create(
        model="qwen2.5:7b",
        messages=[{"role": "user", "content": prompt}],
        temperature=0.3
    )
    return response.choices[0].message.content

def right_size_container(container_name, metrics_history, current_config):
    """Intelligent resource right-sizing"""
    cpu_p95 = metrics_history['cpu_usage_percent'].quantile(0.95)
    mem_p95 = metrics_history['memory_usage_percent'].quantile(0.95)

    # Recommended: 20% headroom for bursts
    recommended_cpu = max(0.25, cpu_p95 * 1.2)
    recommended_mem = max(128, mem_p95 * 1.2)

    current_cpu = float(current_config.get('cpus', '1.0'))
    current_mem_gb = float(current_config.get('memory', '1G').replace('G', ''))

    return {
        'container': container_name,
        'recommended': {'cpus': round(recommended_cpu, 2), 'memory': f"{int(recommended_mem)}M"},
        'current': current_config,
        'savings': {
            'cpu_cores': round(max(0, current_cpu - recommended_cpu), 2),
            'memory_gb': round(max(0, current_mem_gb - recommended_mem / 1024), 2)
        }
    }

def detect_resource_conflicts(container_configs, host_capacity):
    """Detect resource conflicts between containers"""
    total_cpu = sum(float(c['cpus']) for c in container_configs.values())
    total_mem = sum(
        float(c['memory'].replace('G', '')) for c in container_configs.values()
    )

    conflicts = []
    if total_cpu > host_capacity['cpu_cores']:
        conflicts.append({
            'type': 'cpu_overcommit', 'severity': 'high',
            'detail': f"Total CPU {total_cpu:.1f} > Host {host_capacity['cpu_cores']}",
            'recommendation': 'Reduce high-CPU container quotas or upgrade host'
        })
    if total_mem > host_capacity['memory_gb']:
        conflicts.append({
            'type': 'memory_overcommit', 'severity': 'critical',
            'detail': f"Total memory {total_mem:.1f}G > Host {host_capacity['memory_gb']}G",
            'recommendation': 'Immediately adjust memory configs to prevent OOM'
        })
    return conflicts

# docker-compose.yml - AI Container Resource Optimizer
version: '3.8'

services:
  cadvisor:
    image: gcr.io/cadvisor/cadvisor:v0.47.0
    container_name: cadvisor
    ports: ["8080:8080"]
    volumes:
      - /:/rootfs:ro
      - /var/run:/var/run:ro
      - /sys:/sys:ro
      - /var/lib/docker/:/var/lib/docker:ro
    restart: unless-stopped

  node-exporter:
    image: prom/node-exporter:v1.7.0
    container_name: node-exporter
    ports: ["9100:9100"]
    volumes:
      - /proc:/host/proc:ro
      - /sys:/host/sys:ro
    command: ['--path.procfs=/host/proc', '--path.sysfs=/host/sys']
    restart: unless-stopped

  prometheus:
    image: prom/prometheus:v2.51.0
    container_name: prometheus
    ports: ["9090:9090"]
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml
      - prometheus-data:/prometheus
    restart: unless-stopped

  grafana:
    image: grafana/grafana:10.3.3
    container_name: grafana
    ports: ["3000:3000"]
    environment:
      - GF_SECURITY_ADMIN_PASSWORD=admin
    volumes:
      - grafana-data:/var/lib/grafana
    restart: unless-stopped

  ai-optimizer:
    build: ./ai-optimizer
    container_name: ai-optimizer
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock:ro
      - ./config:/app/config
    environment:
      - OLLAMA_HOST=http://host.docker.internal:11434
      - PROMETHEUS_URL=http://prometheus:9090
      - AUTO_FIX=false
    depends_on:
      - prometheus
    restart: unless-stopped

volumes:
  prometheus-data:
  grafana-data:

# ai-optimizer/main.py
import asyncio
import json
import docker
from datetime import datetime
from pathlib import Path
import yaml

class ContainerResourceOptimizer:
    def __init__(self, config_path="config/optimizer.yaml"):
        self.docker_client = docker.from_env()
        self.config = self._load_config(config_path)

    async def collect_metrics(self):
        """Collect resource metrics for all containers"""
        metrics = {}
        for container in self.docker_client.containers.list():
            try:
                stats = container.stats(stream=False)
                cpu_delta = stats['cpu_stats']['cpu_usage']['total_usage'] - \
                           stats['precpu_stats']['cpu_usage']['total_usage']
                system_delta = stats['cpu_stats']['system_cpu_usage'] - \
                              stats['precpu_stats']['system_cpu_usage']
                cpu_percent = (cpu_delta / system_delta) * 100 * stats['cpu_stats']['online_cpus']

                mem_usage = stats['memory_stats']['usage']
                mem_limit = stats['memory_stats']['limit']
                mem_percent = (mem_usage / mem_limit) * 100 if mem_limit > 0 else 0

                metrics[container.name] = {
                    'timestamp': datetime.utcnow().isoformat(),
                    'cpu_percent': round(cpu_percent, 2),
                    'memory_percent': round(mem_percent, 2),
                    'memory_usage_mb': round(mem_usage / 1024 / 1024, 2),
                }
            except Exception as e:
                print(f"Failed to get stats for {container.name}: {e}")
        return metrics

    def generate_report(self, metrics, recommendations):
        """Generate optimization report"""
        return {
            'generated_at': datetime.utcnow().isoformat(),
            'summary': {
                'total_containers': len(metrics),
                'recommendations_count': len(recommendations),
            },
            'metrics': metrics,
            'recommendations': recommendations
        }


async def main():
    optimizer = ContainerResourceOptimizer()
    print("Collecting baseline metrics...")

    # Collect 5 rounds for trend analysis
    all_metrics = []
    for i in range(5):
        metrics = await optimizer.collect_metrics()
        all_metrics.append(metrics)
        await asyncio.sleep(30)

    # Average metrics
    averaged = {}
    for name in all_metrics[0].keys():
        averaged[name] = {
            'cpu_avg': sum(m[name]['cpu_percent'] for m in all_metrics) / len(all_metrics),
            'cpu_max': max(m[name]['cpu_percent'] for m in all_metrics),
            'mem_avg': sum(m[name]['memory_percent'] for m in all_metrics) / len(all_metrics),
            'mem_max': max(m[name]['memory_percent'] for m in all_metrics),
        }

    # Generate recommendations
    recommendations = []
    for name, m in averaged.items():
        if m['cpu_avg'] < 10 and m['mem_avg'] < 20:
            recommendations.append({
                'container': name,
                'type': 'downsize',
                'severity': 'info',
                'message': f"Low utilization: CPU {m['cpu_avg']:.1f}%, Memory {m['mem_avg']:.1f}%—suggest reducing",
            })
        elif m['cpu_max'] > 85 or m['mem_max'] > 85:
            recommendations.append({
                'container': name,
                'type': 'resize_up',
                'severity': 'warning',
                'message': f"High utilization: CPU peak {m['cpu_max']:.1f}%, Memory peak {m['mem_max']:.1f}%—suggest increasing",
            })

    report = optimizer.generate_report(averaged, recommendations)
    output_path = Path("/app/config/optimization_report.json")
    with open(output_path, 'w') as f:
        json.dump(report, f, indent=2)

    print(f"\nOptimization report: {output_path}")
    for rec in recommendations:
        print(f"[{rec['severity'].upper()}] {rec['container']}: {rec['message']}")


if __name__ == "__main__":
    asyncio.run(main())

# 1. Generate optimization recommendations
python3 /opt/ai-optimizer/main.py

# 2. Review the recommendation report
cat /opt/ai-optimizer/config/optimization_report.json | jq '.recommendations'

# 3. Generate updated Docker Compose
python3 /opt/ai-optimizer/generate_compose.py \
  --input docker-compose.yml \
  --report optimization_report.json \
  --output docker-compose.optimized.yml

# 4. Apply gradually (start with non-critical containers)
docker compose -f docker-compose.optimized.yml up -d nginx redis worker

# 5. Monitor for 24 hours, then apply remaining containers

# ai-agent-config.yaml
agent:
  name: "container-optimizer-agent"
  mode: "auto"  # auto | review | off
  schedule: "0 2 * * *"  # Daily at 2 AM
  confidence_threshold: 0.85  # Below this, require manual approval
  rollback_on_failure: true    # Auto-rollback on failure

policies:
  safe_to_auto_apply:
    - "downsize low-utilization containers"
    - "fix memory overcommit"
    - "adjust cpu limits for idle containers"
  require_approval:
    - "resize database containers"
    - "change container image versions"
    - "modify network configuration"