大数据+AI架构成本陷阱深度剖析：存储、计算与网络三重账单的生产级优化实战

一、AI创业公司的隐形成本杀手：为何账单总是比预期高3倍

AI创业公司的成本结构，与传统互联网公司完全不同。
传统公司的最大成本是人力（占60%~70%）。
AI公司的最大成本是云计算（占50%~70%），人力反而排第二。

以一家典型的AI创业公司为例。
10人团队，做对话AI产品。
用户量10万，每日对话100万次。
看起来规模不大，但月度云计算账单可能高达$5万~$10万。

钱花在哪里了？
存储账单：$5000/月（训练数据、模型文件、向量数据库）。
计算账单：$30000/月（GPU推理实例、训练集群、数据处理）。
网络账单：$15000/月（跨AZ流量、CDN、API调用）。

最可怕的是：其中30%~50%的成本是可以优化的。
但大多数团队在起步阶段不会关注成本优化。
等账单涨到$10万/月时，再优化就晚了。
架构已经固定，重构成本高昂。

成本优化的核心是三个动作。
第一：存储分层，热数据放SSD，冷数据放对象存储。
第二：计算调度，在线推理用按需实例，离线训练用Spot实例。
第三：网络优化，减少跨区流量，用CDN缓存静态资源。

这三板斧看似简单，但细节极多。
一个配置错误，成本翻倍。
本文提供完整的成本优化的生产方案。

pie title AI创业公司月度云计算成本构成（典型10万用户规模）
    "GPU推理实例" : 35
    "模型训练集群" : 20
    "向量数据库存储" : 15
    "对象存储" : 10
    "跨区网络流量" : 10
    "CDN" : 5
    "其他（监控、日志等）" : 5

flowchart TD
    A[月度云计算账单] --> B[存储成本]
    A --> C[计算成本]
    A --> D[网络成本]

    B --> B1[对象存储: 训练数据/日志]
    B --> B2[块存储: 数据库/ES索引]
    B --> B3[向量存储: Embedding索引]

    C --> C1[GPU推理: A10/A100按需实例]
    C --> C2[模型训练: 多GPU集群]
    C --> C3[数据处理: CPU集群]

    D --> D1[跨AZ流量: 数据库副本同步]
    D --> D2[出网流量: API响应]
    D --> D3[CDN: 静态资源加速]

    B1 --> E[优化方向]
    B2 --> E
    B3 --> E
    C1 --> E
    C2 --> E
    C3 --> E
    D1 --> E
    D2 --> E
    D3 --> E

    E --> F[存储分层: 热/温/冷]
    E --> G[计算调度: Spot+按需混合]
    E --> H[网络优化: CDN+压缩]

    F --> I[节省20%~40%]
    G --> I
    H --> I

    style I fill:#27ae60,color:#fff

成本优化的黄金法则：先监控，后优化。
没有细粒度的成本监控，优化就是盲人摸象。
AWS Cost Explorer、GCP Billing Reports、Azure Cost Management，
这些是成本优化的起点，不是可有可无的工具。

二、存储成本陷阱：对象存储、块存储与向量存储的完整优化方案

存储成本看似简单，实际上陷阱极多。
最常见的错误是：所有数据都存SSD块存储。
块存储（如AWS EBS GP3）每GB约$0.08/月。
对象存储（如AWS S3 Standard）每GB约$0.023/月。
价差3.5倍。

训练数据通常占存储成本的60%以上。
一个中等规模的LLM微调数据集，约100GB 1TB。
如果用块存储，每月$80$800。
用对象存储，每月$2.3~$23。
省下的钱足够再租一台GPU。

但对象存储的访问延迟高（几十毫秒）。
不适合数据库、ES索引等需要低延迟读写的场景。
正确的做法是存储分层。

热数据（频繁访问）：SSD块存储。
温数据（偶尔访问）：对象存储Standard。
冷数据（归档）：对象存储Glacier或归档存储。

向量存储是AI系统的特殊成本项。
Milvus默认用本地SSD存储向量索引。
1000万768维向量约占300GB SSD空间。
如果用AWS EBS GP3，每月约$24。
如果用本地NVMe，成本更低但需要考虑持久化。

生产环境推荐：热向量用本地NVMe（延迟最低），
冷向量用S3/Pinecone托管服务（成本最低）。

"""
AI系统存储成本监控与优化的生产级工具
自动分析存储使用模式，推荐分层策略
"""
import boto3
import json
from datetime import datetime, timedelta
from dataclasses import dataclass, field
from typing import Optional

@dataclass
class StorageCostReport:
    """存储成本报告"""
    service: str
    storage_type: str       # block | object | vector
    total_gb: float
    monthly_cost_usd: float
    access_frequency: str   # hot | warm | cold
    optimization: str       # 优化建议

class StorageCostAnalyzer:
    """
    存储成本分析器：
    连接到云厂商API，分析存储成本和访问模式
    推荐成本优化方案
    """

    def __init__(self, cloud_provider: str = "aws"):
        self.provider = cloud_provider
        if cloud_provider == "aws":
            self.s3 = boto3.client("s3")
            self.cloudwatch = boto3.client("cloudwatch")
            self.pricing = self._get_aws_pricing()

    def _get_aws_pricing(self) -> dict:
        """AWS存储价格（简化，实际应从AWS Price List API获取）"""
        return {
            "ebs_gp3_per_gb": 0.08,      # $/月
            "ebs_gp3_iops": 0.005,        # 超出3000 IOPS的部分
            "s3_standard_per_gb": 0.023,
            "s3_ia_per_gb": 0.0125,       # Infrequent Access
            "s3_glacier_per_gb": 0.004,
            "s3_put_1000": 0.0004,        # PUT请求价格
            "s3_get_1000": 0.00009,       # GET请求价格
        }

    def analyze_s3_bucket(
        self, bucket_name: str
    ) -> StorageCostReport:
        """分析S3桶的成本和访问模式"""

        # 获取桶大小
        total_size_bytes = 0
        total_objects = 0

        paginator = self.s3.get_paginator("list_objects_v2")
        for page in paginator.paginate(Bucket=bucket_name):
            for obj in page.get("Contents", []):
                total_size_bytes += obj["Size"]
                total_objects += 1

        total_gb = total_size_bytes / (1024 ** 3)

        # 获取访问频率（CloudWatch指标）
        access_count = self._get_s3_access_count(bucket_name)

        # 判断访问频率
        if access_count > total_objects * 10:
            freq = "hot"
        elif access_count > total_objects:
            freq = "warm"
        else:
            freq = "cold"

        # 计算成本
        storage_cost = total_gb * self.pricing["s3_standard_per_gb"]
        request_cost = (total_objects / 1000) * (
            self.pricing["s3_put_1000"] +
            self.pricing["s3_get_1000"] * 10  # 假设GET是PUT的10倍
        )

        # 优化建议
        optimization = ""
        if freq == "cold" and total_gb > 100:
            glacier_cost = total_gb * self.pricing["s3_glacier_per_gb"]
            savings = storage_cost - glacier_cost
            optimization = (f"转移到Glacier，"
                           f"节省${savings:.1f}/月")
        elif freq == "warm" and total_gb > 50:
            ia_cost = total_gb * self.pricing["s3_ia_per_gb"]
            savings = storage_cost - ia_cost
            optimization = (f"转移到S3 IA，"
                           f"节省${savings:.1f}/月")

        return StorageCostReport(
            service=f"S3:{bucket_name}",
            storage_type="object",
            total_gb=total_gb,
            monthly_cost_usd=storage_cost + request_cost,
            access_frequency=freq,
            optimization=optimization,
        )

    def _get_s3_access_count(self, bucket_name: str) -> int:
        """获取S3桶的访问次数（最近30天）"""
        try:
            response = self.cloudwatch.get_metric_statistics(
                Namespace="AWS/S3",
                MetricName="GetRequests",
                Dimensions=[{"Name": "BucketName",
                           "Value": bucket_name}],
                StartTime=datetime.utcnow() - timedelta(days=30),
                EndTime=datetime.utcnow(),
                Period=2592000,  # 30天
                Statistics=["Sum"],
            )
            datapoints = response.get("Datapoints", [])
            return int(datapoints[0]["Sum"]) if datapoints else 0
        except Exception:
            return 0

    def analyze_ebs_volumes(self) -> list[StorageCostReport]:
        """分析EBS卷的成本"""
        ec2 = boto3.client("ec2")
        reports = []

        volumes = ec2.describe_volumes()
        for vol in volumes["Volumes"]:
            size_gb = vol["Size"]
            vol_type = vol["VolumeType"]

            if vol_type == "gp3":
                cost = size_gb * self.pricing["ebs_gp3_per_gb"]
            elif vol_type == "io2":
                cost = size_gb * 0.125  # io2更贵
            else:
                cost = size_gb * 0.08

            # 检查是否挂载
            state = vol["State"]
            optimization = ""
            if state == "available" and not vol.get("Attachments"):
                optimization = ("卷未挂载但仍计费，"
                               "建议快照后删除")

            reports.append(StorageCostReport(
                service=f"EBS:{vol['VolumeId']}",
                storage_type="block",
                total_gb=size_gb,
                monthly_cost_usd=cost,
                access_frequency="hot",  # EBS默认认为热数据
                optimization=optimization,
            ))

        return reports

    def print_report(self) -> None:
        """打印完整成本报告"""
        print("========== 存储成本分析报告 ==========")

        # S3分析
        s3_response = self.s3.list_buckets()
        for bucket in s3_response["Buckets"]:
            report = self.analyze_s3_bucket(bucket["Name"])
            print(f"\nS3桶: {bucket['Name']}")
            print(f"  大小: {report.total_gb:.1f} GB")
            print(f"  月成本: ${report.monthly_cost_usd:.1f}")
            print(f"  访问频率: {report.access_frequency}")
            if report.optimization:
                print(f"  优化建议: {report.optimization}")

        # EBS分析
        ebs_reports = self.analyze_ebs_volumes()
        total_ebs_cost = sum(r.monthly_cost_usd for r in ebs_reports)
        print(f"\nEBS卷总数: {len(ebs_reports)}")
        print(f"EBS总月成本: ${total_ebs_cost:.1f}")
        for r in ebs_reports:
            if r.optimization:
                print(f"  {r.service}: {r.optimization}")

        print("=" * 50)

# ============ 存储分层自动迁移脚本 ============
def setup_s3_lifecycle_policy(bucket_name: str) -> None:
    """
    设置S3生命周期策略：自动分层存储
    30天未访问→S3 IA，90天未访问→Glacier
    """
    s3 = boto3.client("s3")

    lifecycle_config = {
        "Rules": [
            {
                "ID": "auto-tiering",
                "Status": "Enabled",
                "Transitions": [
                    {
                        "Days": 30,
                        "StorageClass": "STANDARD_IA",
                    },
                    {
                        "Days": 90,
                        "StorageClass": "GLACIER",
                    },
                ],
                "NoncurrentVersionTransitions": [
                    {
                        "NoncurrentDays": 30,
                        "StorageClass": "STANDARD_IA",
                    },
                ],
            }
        ]
    }

    s3.put_bucket_lifecycle_configuration(
        Bucket=bucket_name,
        LifecycleConfiguration=lifecycle_config
    )
    print(f"已为桶{bucket_name}设置生命周期策略")

if __name__ == "__main__":
    analyzer = StorageCostAnalyzer(cloud_provider="aws")
    analyzer.print_report()

三、计算成本陷阱：GPU实例选型、Spot实例与弹性伸缩的成本优化

计算成本是AI系统的最大账单项。
以GPU推理为例，一台A10 GPU实例（AWS G5.xlarge），
按需价格约$1.006/小时，月度约$730。
如果部署10台，月度$7300。

但同样的A10 GPU，Spot实例价格约$0.30/小时。
月度约$220，节省70%。

Spot实例的问题是：可能被随时回收（2分钟通知）。
适合离线训练、批量推理等容错场景。
不适合在线推理（用户会感受到中断）。

在线推理的成本优化方案是：弹性伸缩+混合实例池。
平时用按需实例承载基线流量。
流量高峰时，优先扩Spot实例。
Spot实例被回收时，自动回退到按需实例。

另一个陷阱是：GPU利用率低。
很多团队的GPU推理实例利用率不到30%。
剩余的70%算力被浪费，但费用照常支付。

提高GPU利用率的方法：

1. 模型合并（多个小模型合并到一个GPU）。
2. 批处理（累积请求批量推理，提高吞吐量）。
3. 量化（INT8量化后，同样GPU可以跑更大Batch）。

"""
GPU推理成本优化的生产级工具
包含：实例选型建议、Spot/按需混合调度、GPU利用率监控
"""
import json
from dataclasses import dataclass
from typing import Optional

@dataclass
class GPUInstance:
    """GPU实例规格"""
    name: str
    gpu_type: str
    gpu_count: int
    vcpu: int
    memory_gb: float
    price_per_hour: float
    spot_price_per_hour: float

# AWS GPU实例价格参考（us-east-1，简化）
AWS_GPU_INSTANCES = [
    GPUInstance("g4dn.xlarge", "T4", 1, 4, 16, 0.526, 0.158),
    GPUInstance("g5.xlarge", "A10", 1, 4, 16, 1.006, 0.302),
    GPUInstance("g5.2xlarge", "A10", 1, 8, 32, 2.012, 0.604),
    GPUInstance("p4d.24xlarge", "A100", 8, 96, 1152, 32.77, 9.83),
]

class GPUCostOptimizer:
    """
    GPU成本优化器：
    - 根据模型大小和QPS推荐实例类型
    - 计算Spot vs 按需的成本差异
    - 建议弹性伸缩配置
    """

    def __init__(self, region: str = "us-east-1"):
        self.region = region
        self.instances = AWS_GPU_INSTANCES

    def recommend_instance(
        self,
        model_size_mb: float,
        qps: float,
        latency_sla_ms: float,
        budget_per_month_usd: float,
    ) -> list[tuple[str, float, str]]:
        """
        推荐实例类型
        返回: [(实例类型, 月度成本, 推荐理由), ...]
        """
        results = []

        for inst in self.instances:
            # 检查GPU显存是否够加载模型
            if not self._check_memory_fit(inst, model_size_mb):
                continue

            # 估算该实例能支持的QPS
            supported_qps = self._estimate_qps(inst, model_size_mb)
            if supported_qps < qps:
                continue

            # 计算成本（按需 vs Spot）
            on_demand_monthly = inst.price_per_hour * 730
            spot_monthly = inst.spot_price_per_hour * 730

            if on_demand_monthly <= budget_per_month_usd:
                results.append((
                    inst.name, on_demand_monthly,
                    f"QPS支持{supported_qps:.0f}, 按需"
                ))

            if spot_monthly <= budget_per_month_usd:
                results.append((
                    inst.name, spot_monthly,
                    f"QPS支持{supported_qps:.0f}, Spot(节省{on_demand_monthly-spot_monthly:.0f}/月)"
                ))

        # 按成本排序
        results.sort(key=lambda x: x[1])
        return results

    def _check_memory_fit(
        self, inst: GPUInstance, model_mb: float
    ) -> bool:
        """检查GPU显存是否够加载模型（简化：假设显存一半用于模型）"""
        gpu_memory_gb = {
            "T4": 16,
            "A10": 24,
            "A100": 80,
        }.get(inst.gpu_type, 16)

        available_mb = gpu_memory_gb * 1024 * 0.5  # 50%用于模型
        return model_mb < available_mb

    def _estimate_qps(
        self, inst: GPUInstance, model_mb: float
    ) -> float:
        """估算实例支持的QPS（简化模型）"""
        # 假设A10推理延迟约30ms/batch（batch=4）
        base_qps_per_gpu = 1000 / 30 * 4  # 约133 QPS/GPU
        return base_qps_per_gpu * inst.gpu_count

    def optimize_spot_mix(
        self,
        baseline_qps: float,
        peak_qps: float,
        instance_type: str,
    ) -> dict:
        """
        计算Spot/按需混合部署的成本优化方案
        基线流量用按需实例，峰值流量优先用Spot
        """
        inst = next(i for i in self.instances if i.name == instance_type)
        qps_per_inst = self._estimate_qps(inst, 1000)  # 假设模型1GB

        baseline_instances = max(1, int(baseline_qps / qps_per_inst))
        peak_instances = max(baseline_instances,
                           int(peak_qps / qps_per_inst))

        # 方案1：全按需
        cost_all_ondemand = (peak_instances * inst.price_per_hour * 730)

        # 方案2：基线按需 + 峰值Spot
        spot_instances = peak_instances - baseline_instances
        cost_mixed = (
            baseline_instances * inst.price_per_hour * 730 +
            spot_instances * inst.spot_price_per_hour * 730
        )

        # 方案3：全Spot（风险高，适合离线任务）
        cost_all_spot = peak_instances * inst.spot_price_per_hour * 730

        return {
            "all_ondemand": {
                "cost": cost_all_ondemand,
                "instances": peak_instances,
                "risk": "low",
            },
            "mixed": {
                "cost": cost_mixed,
                "baseline_instances": baseline_instances,
                "spot_instances": spot_instances,
                "risk": "medium",
                "savings": cost_all_ondemand - cost_mixed,
            },
            "all_spot": {
                "cost": cost_all_spot,
                "instances": peak_instances,
                "risk": "high",
            },
        }

def print_optimization_report() -> None:
    """打印成本优化报告"""
    optimizer = GPUCostOptimizer()

    print("========== GPU推理成本优化报告 ==========")

    # 推荐实例
    recommendations = optimizer.recommend_instance(
        model_size_mb=2000,  # 2GB模型
        qps=50,
        latency_sla_ms=200,
        budget_per_month_usd=5000,
    )

    print("\n推荐实例类型:")
    for inst, cost, reason in recommendations[:3]:
        print(f"  {inst}: ${cost:.0f}/月, {reason}")

    # Spot混合方案
    print("\nSpot/按需混合部署方案:")
    mix = optimizer.optimize_spot_mix(
        baseline_qps=20, peak_qps=100, instance_type="g5.xlarge"
    )
    for name, data in mix.items():
        print(f"  {name}: ${data['cost']:.0f}/月, 风险={data['risk']}")
        if "savings" in data:
            print(f"    节省: ${data['savings']:.0f}/月")

    print("\n========== 优化建议 ==========")
    print("1. 基线流量（20 QPS）：用2台按需实例")
    print("2. 峰值流量（100 QPS）：额外扩8台Spot实例")
    print("3. Spot实例被回收时：自动回退到按需实例")
    print("4. 预计节省: $X/月（约为全按需成本的40%~60%）")

if __name__ == "__main__":
    print_optimization_report()

四、网络成本陷阱：跨区流量、出网带宽与CDN的优化方案

网络成本是最容易被忽视的成本项。
它不像存储和计算那样直观。
但一旦账单来了，往往是最贵的一项。

网络成本的三大陷阱。
第一：跨可用区（AZ）流量费。
AWS同一Region内，不同AZ之间的数据传输收费。
$0.01/GB，看起来不多。
但如果有10台数据库副本，每台每秒同步1MB数据，
月度流量费就超过$2500。

第二：出网流量费。
API响应、文件下载，都算出网流量。
AWS出网流量$0.09/GB（前10TB/月）。
如果一个AI应用每天生成1TB的出网流量（如视频、大文件），
月度费用$2700。

第三：CDN配置不当。
CDN可以大幅降低出网流量成本（CDN流量费约$0.02/GB，比出网流量便宜78%）。
但如果缓存命中率低（<50%），反而增加成本（CDN费+源站流量费）。

#!/bin/bash
# 网络成本优化的生产级部署脚本
# 适用场景：AI应用的网络成本优化（CDN、压缩、连接复用）
# 执行前需确认：1. 域名 2. CDN提供商 3. 流量模式

set -euo pipefail

DOMAIN="${1:-api.example.com}"
REGION="${2:-us-east-1}"

echo "===== 网络成本优化部署 ====="
echo "域名: ${DOMAIN}"
echo "区域: ${REGION}"

# ============ 第一步：部署CDN（Cloudfront） ============
echo ""
echo "步骤1: 配置CDN（Cloudfront）..."

cat > cloudfront-config.json <<EOF
{
  "CallerReference": "cost-optimization-$(date +%s)",
  "Origins": {
    "Quantity": 1,
    "Items": [
      {
        "Id": "api-origin",
        "DomainName": "${DOMAIN}",
        "CustomOriginConfig": {
          "HTTPPort": 80,
          "HTTPSPort": 443,
          "OriginProtocolPolicy": "https-only"
        }
      }
    ]
  },
  "DefaultCacheBehavior": {
    "TargetOriginId": "api-origin",
    "ViewerProtocolPolicy": "redirect-to-https",
    "CachePolicyId": "4135ea2d-6df8-44a3-9df3-4d9a0e5b3f8a",
    "Compress": true
  },
  "CacheBehaviors": {
    "Quantity": 1,
    "Items": [
      {
        "PathPattern": "/static/*",
        "TargetOriginId": "api-origin",
        "ViewerProtocolPolicy": "redirect-to-https",
        "CachePolicyId": "4135ea2d-6df8-44a3-9df3-4d9a0e5b3f8a",
        "DefaultTTL": 86400,
        "MaxTTL": 604800,
        "Compress": true
      }
    ]
  },
  "Comment": "成本优化CDN配置"
}
EOF

echo "  CDN配置已生成: cloudfront-config.json"
echo "  部署命令: aws cloudfront create-distribution --distribution-config file://cloudfront-config.json"

# ============ 第二步：启用Brotli压缩 ============
echo ""
echo "步骤2: 启用Brotli压缩（减少传输流量50%~70%）..."

cat > nginx-compression.conf <<'EOF'
# Nginx压缩配置（添加到nginx.conf）
# 可以节省50%~70%的传输流量，直接降低出网流量费

http {
    # Gzip压缩（兼容性更好）
    gzip on;
    gzip_vary on;
    gzip_proxied any;
    gzip_comp_level 6;
    gzip_types text/plain text/css application/json application/javascript;

    # Brotli压缩（压缩率更高，需要nginx-brotli模块）
    # 编译nginx时加上 --add-module=/path/to/ngx_brotli
    brotli on;
    brotli_comp_level 6;
    brotli_types text/plain text/css application/json;
}
EOF

echo "  Nginx压缩配置已生成"
echo "  注意: Brotli需要额外编译nginx模块"

# ============ 第三步：减少跨AZ流量 ============
echo ""
echo "步骤3: 减少跨AZ流量（数据库副本配置优化）..."

cat > db-cross-az-optimization.md <<'EOF'
# 数据库跨AZ流量优化指南

## 问题
多AZ部署的数据库（如RDS Multi-AZ），副本同步产生跨AZ流量费。
10台副本，每台每秒同步1MB，月度费用> $2500。

## 解决方案

### 方案1：减少副本数量
- 只读副本：同AZ内保留2个，跨AZ保留1个（用于容灾）
- 同步频率：从实时降为5秒延迟（可接受的范围内）

### 方案2：使用Aurora Serverless v2
- 按需扩展，无空闲副本成本
- 跨AZ流量费仍产生，但副本数更少

### 方案3：应用层缓存
- 用ElastiCache缓存热点数据
- 减少直接查询数据库的次数
- 间接减少跨AZ同步流量

## 监控跨AZ流量
aws cloudwatch get-metric-statistics \
  --namespace AWS/EC2 \
  --metric-name NetworkPacketsOut \
  --dimensions Name=InstanceId,Value=<id> \
  --start-time $(date -u -d '7 days ago' +%Y-%m-%dT%H:%M:%S) \
  --end-time $(date -u +%Y-%m-%dT%H:%M:%S) \
  --period 3600 --statistics Sum
EOF

echo "  跨AZ优化指南已生成"

# ============ 第四步：API响应优化（减少出网流量） ============
echo ""
echo "步骤4: API响应优化..."

cat > api-response-optimization.py <<'EOF'
"""
API响应优化：减少出网流量的生产级方案
1. 分页（避免一次返回过多数据）
2. 字段过滤（只返回客户端需要的字段）
3. 压缩（Gzip/Brotli）
4. 增量更新（只返回变更的数据）
"""

from fastapi import FastAPI, Query
from fastapi.responses import JSONResponse
import gzip
import json

app = FastAPI()

@app.get("/api/documents")
def get_documents(
    page: int = Query(1, ge=1),
    page_size: int = Query(20, le=100),  # 限制每页最多100条
    fields: str = Query(None),  # 字段过滤: ?fields=id,title
):
    """优化的文档列表API"""
    # 分页：避免一次返回所有数据
    offset = (page - 1) * page_size

    # 字段过滤：只查询需要的字段
    if fields:
        requested_fields = fields.split(",")
    else:
        requested_fields = ["id", "title", "created_at"]

    # 模拟查询
    docs = [
        {"id": i, "title": f"Doc {i}", "content": "..."}
        for i in range(offset, offset + page_size)
    ]

    # 字段过滤：只返回请求的字段
    if fields:
        filtered = []
        for doc in docs:
            filtered.append(
                {k: v for k, v in doc.items()
                 if k in requested_fields}
            )
        docs = filtered

    response = JSONResponse(content={
        "page": page,
        "page_size": page_size,
        "data": docs,
    })

    # 启用压缩（需要在Nginx或CDN层面做，这里仅示意）
    return response

EOF

echo "  API优化示例代码已生成"

# ============ 成本节省估算 ============
echo ""
echo "===== 成本节省估算 ====="
echo "假设当前状态:"
echo "  - 出网流量: 10TB/月 @ \$0.09/GB = \$920"
echo "  - CDN后: 10TB/月 @ \$0.02/GB = \$205"
echo "  - 节省: \$715/月 (78%)"
echo ""
echo "  - 跨AZ流量: 5TB/月 @ \$0.01/GB = \$51"
echo "  - 优化后: 1TB/月 = \$10"
echo "  - 节省: \$41/月 (80%)"
echo ""
echo "总节省: ~\$756/月"

五、总结

1. AI创业公司云计算成本的三重账单与优化空间：存储成本（占15%~20%，陷阱是用SSD块存储存训练数据，优化方案是存储分层：热数据SSD、温数据S3 Standard、冷数据S3 Glacier，节省20%~40%）、计算成本（占50%~60%，陷阱是GPU利用率<30%和全按需实例，优化方案是Spot/按需混合调度+模型量化+批处理推理，GPU利用率提升至70%以上，计算成本降低40%~70%）、网络成本（占20%~25%，陷阱是跨AZ流量费和CDN缓存命中率低，优化方案是减少跨AZ副本+CDN缓存静态资源+API响应压缩，节省50%~80%），三者协同优化可将总云计算成本降低50%~70%

2. 存储成本优化的生产级实施清单：①训练数据从EBS迁移到S3（节省70%存储费）、②设置S3生命周期策略（30天未访问自动转S3 IA，90天转Glacier）、③向量索引用本地NVMe+定时快照到S3（延迟最低且成本可控）、④未挂载的EBS卷立即快照后删除（空闲EBS照常计费是常见浪费）、⑤用aws s3 ls --recursive --human-readable定期审计S3桶大小，超过1TB的数据集评估是否需全量存储

3. GPU计算成本优化的Spot/按需混合部署架构：基线流量（占全天80%时间）用按需实例保证稳定性、峰值流量优先扩Spot实例（节省70%扩容成本）、Spot实例被回收时用Kubernetes Pod Disruption Budget自动迁移、离线训练任务100%用Spot实例（被回收可从Checkpoint恢复，成本降低70%）、GPU推理用Elastic Inference（AWS）或vLLM的KVCache共享（开源）提高GPU利用率从30%到70%，同等QPS下GPU数量减少一半

4. 网络成本优化的三个关键杠杆：CDN缓存静态资源（出网流量费从$0.09/GB降至$0.02/GB，节省78%，缓存命中率目标>80%）、启用Brotli压缩（文本响应压缩率比Gzip高20%，出网流量相应减少20%）、减少跨AZ数据同步（数据库副本尽量部署在同AZ，跨AZ仅用于容灾，跨AZ流量费$0.01/GB看似不多但高副本场景下月度可超$2500），三者叠加可将网络成本降低50% 80%，对于日活>10万的应用节省金额非常可观（$5000$20000/月）

5. AI创业公司成本控制的完整管理体系：①成本监控（AWS Cost Explorer按服务/按环境拆分账单，设置月度预算告警阈值为预期的120%）、②资源标签（所有资源打Tag：Environment=prod/dev、Team=AI/Backend、Project=RAG，便于成本分摊和问责）、③定期成本评审（每月一次，评审每项服务的Unit Economics，如每千次API调用的云计算成本）、④架构评审（新功能上线前做成本预估，避免上线后发现成本不可接受）、⑤FinOps文化（让每个工程师都对成本负责，而非仅财务团队关注），这五点构成完整的云计算成本管理闭环，是AI创业公司从MVP到规模化必须建立的体系