# 典型的过度分配配置
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

# 部署数据采集栈
docker compose up -d prometheus grafana cadvisor node-exporter

# 验证数据采集
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):
    """分析容器资源使用模式"""
    features = metrics_df[[
        'cpu_usage_percent', 'memory_usage_percent',
        'network_rx_bytes', 'network_tx_bytes'
    ]].values

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

    # 聚类识别使用模式
    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),
        'pattern_distribution': dict(zip(*np.unique(patterns, return_counts=True)))
    }

from prophet import Prophet
import numpy as np

def detect_anomalies(series, threshold=2.0):
    """基于 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 分析容器资源异常根因"""
    prompt = f"""你是 VPS 运维专家。分析以下容器资源异常并给出根因和修复建议。

容器: {container_name}
异常类型: {anomaly_data['type']}
异常幅度: {anomaly_data['magnitude']:.1f} 个标准差
系统上下文:
{system_context}

请分析：
1. 最可能的根因是什么？
2. 是否需要立即处理？
3. 推荐的修复步骤是什么？

用简洁的中文回答。"""

    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):
    """智能资源右 sizing"""
    cpu_avg = metrics_history['cpu_usage_percent'].mean()
    cpu_p95 = metrics_history['cpu_usage_percent'].quantile(0.95)
    cpu_p99 = metrics_history['cpu_usage_percent'].quantile(0.99)

    mem_avg = metrics_history['memory_usage_percent'].mean()
    mem_p95 = metrics_history['memory_usage_percent'].quantile(0.95)
    mem_p99 = metrics_history['memory_usage_percent'].quantile(0.99)

    # 推荐配置：保留 20% headroom 应对突发
    recommended_cpu = max(0.25, cpu_p95 * 1.2)
    recommended_mem = max(128, mem_p95 * 1.2)  # 至少 128MB

    # 计算节省
    current_cpu = float(current_config.get('cpus', '1.0'))
    current_mem_gb = float(current_config.get('memory', '1G').replace('G', ''))

    cpu_saving = max(0, current_cpu - recommended_cpu)
    mem_saving_gb = max(0, current_mem_gb - recommended_mem / 1024)

    return {
        'container': container_name,
        'recommended': {
            'cpus': round(recommended_cpu, 2),
            'memory': f"{int(recommended_mem)}M"
        },
        'current': current_config,
        'savings': {
            'cpu_cores': round(cpu_saving, 2),
            'memory_gb': round(mem_saving_gb, 2),
            'utilization_improvement': f"{(cpu_avg / max(current_cpu, 0.01)) * 100:.1f}%"
        }
    }

def detect_resource_conflicts(container_configs, host_capacity):
    """检测容器间资源冲突"""
    total_cpu = sum(float(c['cpus']) for c in container_configs.values())
    total_mem = sum(
        float(c['memory'].replace('G', '')) * 1024 +
        float(c['memory'].replace('M', '')) * 1 if 'M' in c['memory'] else 0
        for c in container_configs.values()
    ) / 1024  # Convert to GB

    conflicts = []

    # CPU 超配检测
    if total_cpu > host_capacity['cpu_cores']:
        conflicts.append({
            'type': 'cpu_overcommit',
            'severity': 'high',
            'detail': f"总 CPU 需求 {total_cpu:.1f} 核 > 宿主机 {host_capacity['cpu_cores']} 核",
            'recommendation': '减少高 CPU 容器配额或扩容宿主机'
        })

    # 内存超配检测
    if total_mem > host_capacity['memory_gb']:
        conflicts.append({
            'type': 'memory_overcommit',
            'severity': 'critical',
            'detail': f"总内存需求 {total_mem:.1f}G > 宿主机 {host_capacity['memory_gb']}G",
            'recommendation': '立即调整内存配置，防止 OOM'
        })

    # IO 争抢检测
    io_intensive = [
        name for name, cfg in container_configs.items()
        if 'mysql' in name or 'postgres' in name or 'elasticsearch' in name
    ]
    if len(io_intensive) > 1:
        conflicts.append({
            'type': 'io_contention',
            'severity': 'medium',
            'detail': f"多个 IO 密集型容器: {', '.join(io_intensive)}",
            'recommendation': '考虑分离 IO 密集型容器到不同磁盘或独立 VPS'
        })

    return conflicts

# docker-compose.yml - AI 容器资源优化系统
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
      - ./grafana/dashboards:/etc/grafana/provisioning/dashboards
    restart: unless-stopped

  # AI 分析引擎
  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  # 设为 true 启用自动修复
    depends_on:
      - prometheus
    restart: unless-stopped

volumes:
  prometheus-data:
  grafana-data:

# ai-optimizer/main.py
import asyncio
import json
import docker
import requests
from datetime import datetime, timedelta
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)
        self.metrics_store = {}
        self.recommendations = []

    def _load_config(self, path):
        with open(path) as f:
            return yaml.safe_load(f)

    async def collect_metrics(self):
        """采集所有容器资源指标"""
        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),
                    'memory_limit_mb': round(mem_limit / 1024 / 1024, 2),
                    'network_rx': stats.get('networks', {}).get('eth0', {}).get('rx_bytes', 0),
                    'network_tx': stats.get('networks', {}).get('eth0', {}).get('tx_bytes', 0),
                }
            except Exception as e:
                print(f"Failed to get stats for {container.name}: {e}")

        return metrics

    def analyze_and_recommend(self, metrics):
        """分析指标并生成优化建议"""
        recommendations = []

        for name, m in metrics.items():
            # 获取当前配置
            container = self.docker_client.containers.get(name)
            current_config = {
                'cpus': str(container.host_config.get('NanoCpus', 1000000000) / 1e9),
                'memory': f"{container.host_config.get('Memory', 1073741824) // (1024*1024*1024)}G"
            }

            # 基于当前使用率生成建议
            if m['cpu_percent'] < 10 and m['memory_percent'] < 20:
                recommendations.append({
                    'container': name,
                    'type': 'downsize',
                    'severity': 'info',
                    'message': f"低负载容器：CPU {m['cpu_percent']:.1f}%，内存 {m['memory_percent']:.1f}%，建议缩减资源",
                    'current': current_config,
                    'suggested': {'cpus': '0.5', 'memory': '512M'}
                })
            elif m['cpu_percent'] > 85 or m['memory_percent'] > 85:
                recommendations.append({
                    'container': name,
                    'type': 'resize_up',
                    'severity': 'warning',
                    'message': f"高负载容器：CPU {m['cpu_percent']:.1f}%，内存 {m['memory_percent']:.1f}%，建议增加资源",
                    'current': current_config,
                    'suggested': {'cpus': str(float(current_config['cpus']) * 1.5),
                                 'memory': f"{int(current_config['memory'].replace('G','')) * 2}G"}
                })

        return recommendations

    def generate_report(self, metrics, recommendations):
        """生成优化报告"""
        report = {
            'generated_at': datetime.utcnow().isoformat(),
            'summary': {
                'total_containers': len(metrics),
                'recommendations_count': len(recommendations),
                'potential_cpu_savings': sum(
                    float(r.get('suggested', {}).get('cpus', 0)) -
                    float(r.get('current', {}).get('cpus', 0))
                    for r in recommendations if r['type'] == 'downsize'
                ),
                'potential_mem_savings_gb': sum(
                    float(r.get('suggested', {}).get('memory', '0G').replace('G','')) -
                    float(r.get('current', {}).get('memory', '0G').replace('G',''))
                    for r in recommendations if r['type'] == 'downsize'
                )
            },
            'metrics': metrics,
            'recommendations': recommendations
        }
        return report

    def apply_recommendations(self, report):
        """应用优化建议（需确认）"""
        applied = []
        for rec in report['recommendations']:
            if rec['type'] == 'downsize':
                try:
                    container = self.docker_client.containers.get(rec['container'])
                    # Docker Compose 方式更可靠，这里演示 API 方式
                    print(f"[APPLY] {rec['container']}: {rec['suggested']}")
                    applied.append(rec)
                except Exception as e:
                    print(f"[ERROR] Failed to apply {rec['container']}: {e}")
        return applied


async def main():
    optimizer = ContainerResourceOptimizer()

    # 采集 5 轮数据用于分析趋势
    print("Collecting baseline metrics...")
    all_metrics = []
    for i in range(5):
        metrics = await optimizer.collect_metrics()
        all_metrics.append(metrics)
        await asyncio.sleep(30)  # 30秒间隔

    # 分析趋势
    averaged_metrics = {}
    for name in all_metrics[0].keys():
        averaged_metrics[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),
        }

    # 生成建议
    recommendations = optimizer.analyze_and_recommend(averaged_metrics)
    report = optimizer.generate_report(averaged_metrics, recommendations)

    # 输出报告
    output_path = Path("/app/config/optimization_report.json")
    with open(output_path, 'w') as f:
        json.dump(report, f, indent=2, ensure_ascii=False)

    print(f"\n{'='*60}")
    print(f"优化报告已生成: {output_path}")
    print(f"{'='*60}")

    # 打印摘要
    for rec in recommendations:
        print(f"\n[{rec['severity'].upper()}] {rec['container']}")
        print(f"  {rec['message']}")
        print(f"  当前: {rec['current']} → 建议: {rec['suggested']}")


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

{
  "dashboard": {
    "title": "VPS Container Resource Optimization",
    "panels": [
      {
        "title": "CPU 使用率趋势",
        "type": "graph",
        "targets": [
          {
            "expr": "container_cpu_usage_seconds_total",
            "legendFormat": "{{container_name}}"
          }
        ]
      },
      {
        "title": "内存使用率趋势",
        "type": "graph",
        "targets": [
          {
            "expr": "container_memory_usage_bytes / container_memory_limit_bytes",
            "legendFormat": "{{container_name}}"
          }
        ]
      },
      {
        "title": "资源浪费评分",
        "type": "gauge",
        "targets": [
          {
            "expr": "avg(container_cpu_usage_seconds_total) / 3600",
            "legendFormat": "avg_cpu"
          }
        ]
      }
    ]
  }
}

# 1. 生成优化建议
python3 /opt/ai-optimizer/main.py

# 2. 审查建议报告
cat /opt/ai-optimizer/config/optimization_report.json | jq '.recommendations'

# 3. 生成 Docker Compose 更新
python3 /opt/ai-optimizer/generate_compose.py \
  --input docker-compose.yml \
  --report optimization_report.json \
  --output docker-compose.optimized.yml

# 4. 灰度应用（先应用非关键容器）
docker compose -f docker-compose.optimized.yml up -d nginx redis worker

# 5. 观察 24 小时，确认无异常后应用剩余容器

# ai-agent-config.yaml
agent:
  name: "container-optimizer-agent"
  mode: "auto"  # auto | review | off
  schedule: "0 2 * * *"  # 每天凌晨 2 点执行
  confidence_threshold: 0.85  # 低于此置信度需人工确认
  rollback_on_failure: true    # 自动回滚失败变更

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"

notifications:
  channel: "wechat"
  on_recommendation: true
  on_apply: true
  on_failure: true

# ai-agent 核心逻辑
class ContainerOptimizationAgent:
    def __init__(self):
        self.optimizer = ContainerResourceOptimizer()
        self.llm_client = OpenAI(base_url=os.environ["OLLAMA_HOST"])

    def run_optimization_cycle(self):
        """执行完整的优化循环"""
        # 1. 采集数据
        metrics = asyncio.run(self.optimizer.collect_metrics())

        # 2. AI 分析
        analysis = self.llm_client.chat.completions.create(
            model="qwen2.5:7b",
            messages=[{
                "role": "user",
                "content": f"""分析以下容器资源数据并生成优化建议。
                数据: {json.dumps(metrics, indent=2)}
                要求: 只返回 JSON 格式的优化建议，包含容器名、当前配置、建议配置、理由。"""
            }]
        )

        # 3. 评估置信度
        recommendations = json.loads(analysis.choices[0].message.content)
        for rec in recommendations:
            rec['confidence'] = self._assess_confidence(rec, metrics)

        # 4. 执行或待审批
        for rec in recommendations:
            if rec['confidence'] >= 0.85 and rec['type'] in self.safe_policies:
                self._apply_recommendation(rec)
            else:
                self._send_notification(rec)

    def _assess_confidence(self, rec, metrics):
        """基于历史数据评估建议置信度"""
        name = rec['container']
        if name not in metrics:
            return 0.5

        m = metrics[name]
        # 基于数据量和稳定性评分
        data_points = len(m.get('history', []))
        stability = 1.0 - (m.get('variance', 0.1))

        return min(1.0, (data_points / 100) * stability)