成本分析实战
一笔算到肉的成本账
“光影”上线第 5 个月，用户量到了 12000，我决定做一次彻底的成本审计。
不是看阿里云的账单总额——那个数字太粗糙了。我要把每一分钱拆开，看看到底花在了哪里。
from dataclasses import dataclass, field
from typing import Dict, List
@dataclass
class CostItem:
"""成本项"""
name: str
unit: str
quantity: float
unit_price: float
note: str = ''
@property
def total(self) -> float:
return round(self.quantity * self.unit_price, 2)
class ImageSystemCostBook:
"""图片系统完整成本账本"""
def __init__(self):
self.period = '2024 年 6 月'
self.scale = {
'月活用户': 12000,
'总图片数': 85000,
'日均上传': 450,
'日均 PV': 150000,
'月度 PV': 4500000,
}
# ==========================================
# 第一项：存储费
# ==========================================
def storage_cost(self) -> Dict:
"""存储费用明细"""
items = [
CostItem(
name='标准存储（热数据）',
unit='GB/月',
quantity=200,
unit_price=0.12,
note='最近 30 天的原图 + 全部缩略图',
),
CostItem(
name='低频存储（温数据）',
unit='GB/月',
quantity=500,
unit_price=0.08,
note='30~90 天的原图',
),
CostItem(
name='归档存储（冷数据）',
unit='GB/月',
quantity=2000,
unit_price=0.03,
note='90 天以上的原图',
),
]
total = sum(item.total for item in items)
return {
'items': items,
'total': total,
'note': f'总存储 2.7 TB，加权平均 {total / 2700:.4f} 元/GB',
}
# ==========================================
# 第二项：CDN 流量费（最大开支）
# ==========================================
def cdn_cost(self) -> Dict:
"""CDN 流量费用"""
items = [
CostItem(
name='CDN 下行流量',
unit='GB',
quantity=3000,
unit_price=0.24,
note='用户浏览产生的流量（含命中和回源）',
),
CostItem(
name='CDN 回源流量',
unit='GB',
quantity=150,
unit_price=0.50,
note='缓存未命中时回源到 OSS 的流量',
),
]
total = sum(item.total for item in items)
return {
'items': items,
'total': total,
'note': f'CDN 命中率 96%，回源流量仅占 4%',
}
# ==========================================
# 第三项：OSS 请求费
# ==========================================
def oss_request_cost(self) -> Dict:
"""OSS 请求费用"""
items = [
CostItem(
name='PUT 请求（上传）',
unit='万次',
quantity=1.35,
unit_price=0.01,
note='450 张/天 × 30 天 = 13500 次',
),
CostItem(
name='GET 请求（读取）',
unit='万次',
quantity=45,
unit_price=0.01,
note='CDN 回源 + 直读',
),
CostItem(
name='低频/归档取回费',
unit='GB',
quantity=20,
unit_price=0.033,
note='从低频/归档恢复的数据量',
),
]
total = sum(item.total for item in items)
return {
'items': items,
'total': total,
'note': '请求费占比很小，通常忽略不计',
}
# ==========================================
# 第四项：图片处理费
# ==========================================
def processing_cost(self) -> Dict:
"""图片处理费用"""
items = [
CostItem(
name='缩略图生成',
unit='万次',
quantity=20,
unit_price=0.025,
note='每张图生成 5 个缩略图 = 450 × 5 × 30 = 67500 次',
),
CostItem(
name='格式转换（WebP/AVIF）',
unit='万次',
quantity=15,
unit_price=0.025,
note='包含在缩略图生成中',
),
]
total = sum(item.total for item in items)
return {
'items': items,
'total': total,
'note': 'OSS 图片处理按次数计费，价格很低',
}
# ==========================================
# 第五项：内容审核费
# ==========================================
def audit_cost(self) -> Dict:
"""内容审核费用"""
items = [
CostItem(
name='图片鉴黄',
unit='万次',
quantity=1.35,
unit_price=0.0025,
note='每张上传图片都过审',
),
CostItem(
name='OCR 文字识别',
unit='万次',
quantity=0.5,
unit_price=0.01,
note='部分图片触发 OCR',
),
]
total = sum(item.total for item in items)
return {
'items': items,
'total': total,
'note': '审核费用很低，但必须有',
}
# ==========================================
# 第六项：服务器（计算资源）
# ==========================================
def server_cost(self) -> Dict:
"""服务器费用"""
items = [
CostItem(
name='上传服务 ×3 台',
unit='台/月',
quantity=3,
unit_price=200,
note='2C4G ECS 实例',
),
CostItem(
name='审核服务 ×2 台',
unit='台/月',
quantity=2,
unit_price=200,
note='2C4G ECS 实例',
),
CostItem(
name='处理服务 ×4 台',
unit='台/月',
quantity=4,
unit_price=300,
note='4C8G ECS 实例（图片处理吃 CPU）',
),
CostItem(
name='RabbitMQ 队列',
unit='月',
quantity=1,
unit_price=150,
note='消息队列服务',
),
CostItem(
name='监控服务（Prometheus + Grafana）',
unit='月',
quantity=1,
unit_price=80,
note='2C4G + 磁盘',
),
]
total = sum(item.total for item in items)
return {
'items': items,
'total': total,
'note': '服务器是第二大开支',
}
def full_report(self) -> Dict:
"""生成完整成本报告"""
sections = {
'存储费': self.storage_cost(),
'CDN 流量费': self.cdn_cost(),
'OSS 请求费': self.oss_request_cost(),
'图片处理费': self.processing_cost(),
'内容审核费': self.audit_cost(),
'服务器': self.server_cost(),
}
total = sum(s['total'] for s in sections.values())
return {
'period': self.period,
'scale': self.scale,
'sections': sections,
'total': round(total, 2),
'breakdown': {
name: f"{s['total']:.2f} 元 ({s['total'] / total * 100:.1f}%)"
for name, s in sections.items()
},
}
# 生成报告
book = ImageSystemCostBook()
report = book.full_report()
# 总成本：4980 元/月
# 明细：
# - 存储费: 124.00 元 (2.5%)
# - CDN 流量费: 795.00 元 (16.0%)
# - OSS 请求费: 1.14 元 (0.0%)
# - 图片处理费: 0.88 元 (0.0%)
# - 内容审核费: 0.08 元 (0.0%)
# - 服务器: 4030.00 元 (80.9%)等等——服务器占了 81%？
仔细一看，处理服务 4 台 4C8G 实例就花了 1200 元/月。加上上传和审核服务 5 台，还有队列和监控，总计 4030 元。
但 CDN 才 795 元？这跟我最初的直觉不一样——我以为 CDN 会是最大开支。
# 成本结构可视化
COST_STRUCTURE = """
成本结构（优化前）：
服务器 ████████████████████████████████████████ 81% ¥4,030
CDN流量 ████████ 16% ¥ 795
存储费 █ 3% ¥ 124
其他 ▏ 0% ¥ 2
─────────────────────────────────────────────
总计 100% ¥4,950
启示：CDN 不是最大的开支，服务器才是。
但这只是 12000 用户的规模。
当用户增长 10 倍时，CDN 流量会线性增长（7950 元），
而服务器可以通过弹性伸缩控制。
"""三条降本路径
搞清楚钱花在哪里后，我制定了三条降本路径：
路径 1：格式转换（减少体积 → 减少 CDN 流量）
路径 2：缓存优化（提高命中率 → 减少回源）
路径 3：存储分层 + 生命周期（减少存储费和垃圾堆积）路径 1：格式转换——体积砍半
class FormatOptimization:
"""格式转换降本分析"""
# 不同格式的体积对比（基于"光影"实际数据）
FORMAT_STATS = {
'JPEG': {'avg_size_kb': 245, 'quality': 85, 'browser_support': '100%'},
'WebP': {'avg_size_kb': 128, 'quality': 80, 'browser_support': '97%'},
'AVIF': {'avg_size_kb': 85, 'quality': 80, 'browser_support': '92%'},
}
def analyze_savings(self, monthly_traffic_tb: float):
"""分析格式转换带来的成本节省"""
traffic_gb = monthly_traffic_tb * 1024 # 转为 GB
# 当前：全部 JPEG
jpeg_cost = traffic_gb * 0.24 # CDN 单价
# 优化后：WebP（支持 WebP 的浏览器）
webp_ratio = 0.97 # 97% 浏览器支持 WebP
webp_traffic = traffic_gb * webp_ratio * (128 / 245) # 体积减小 48%
jpeg_fallback = traffic_gb * (1 - webp_ratio) # 不支持的走 JPEG
optimized_traffic = webp_traffic + jpeg_fallback
webp_cost = optimized_traffic * 0.24
# 进一步优化：AVIF（支持 AVIF 的浏览器）
avif_ratio = 0.92
avif_traffic = traffic_gb * avif_ratio * (85 / 245) # 体积减小 65%
webp_fallback = traffic_gb * (0.97 - avif_ratio) * (128 / 245)
jpeg_remaining = traffic_gb * (1 - 0.97)
optimized_traffic_v2 = avif_traffic + webp_fallback + jpeg_remaining
avif_cost = optimized_traffic_v2 * 0.24
return {
'current': {
'format': 'JPEG',
'traffic_tb': monthly_traffic_tb,
'cost': round(jpeg_cost, 2),
},
'webp': {
'traffic_tb': round(optimized_traffic / 1024, 2),
'saving_pct': round((1 - optimized_traffic / traffic_gb) * 100, 1),
'cost': round(webp_cost, 2),
'saving': round(jpeg_cost - webp_cost, 2),
},
'avif': {
'traffic_tb': round(optimized_traffic_v2 / 1024, 2),
'saving_pct': round((1 - optimized_traffic_v2 / traffic_gb) * 100, 1),
'cost': round(avif_cost, 2),
'saving': round(jpeg_cost - avif_cost, 2),
},
}
optimizer = FormatOptimization()
result = optimizer.analyze_savings(monthly_traffic_tb=3.0)
# 结果：
# {
# 'current': {'format': 'JPEG', 'traffic_tb': 3.0, 'cost': 737.28},
# 'webp': {
# 'traffic_tb': 1.83,
# 'saving_pct': '39.0%',
# 'cost': 451.58,
# 'saving': 285.70 ← 每月省 285 元
# },
# 'avif': {
# 'traffic_tb': 1.25,
# 'saving_pct': '58.3%',
# 'cost': 307.96,
# 'saving': 429.32 ← 每月省 429 元
# }
# }路径 2：缓存优化——命中率从 90% 提升到 96%
class CacheOptimization:
"""缓存优化降本分析"""
def analyze_savings(
self,
monthly_traffic_tb: float,
before_hit_rate: float,
after_hit_rate: float,
):
"""分析缓存命中率提升带来的节省"""
traffic_gb = monthly_traffic_tb * 1024
# CDN 流量不因命中率变化（用户始终产生下行流量）
# 但回源流量会大幅减少
cdn_cost = traffic_gb * 0.24 # CDN 流量费不变
# 回源流量 = 总流量 × 未命中率
before_origin_gb = traffic_gb * (1 - before_hit_rate)
after_origin_gb = traffic_gb * (1 - after_hit_rate)
# OSS 外网流量费（回源产生的）
before_origin_cost = before_origin_gb * 0.50
after_origin_cost = after_origin_gb * 0.50
# 但更重要的是：回源减少 = 源站压力减少 = 服务器可以缩容
# 90% 命中率 → 需要更大带宽处理突发回源
# 96% 命中率 → 回源更平稳，可以降低服务器配置
return {
'cdn_cost_unchanged': round(cdn_cost, 2),
'origin_traffic': {
'before_gb': round(before_origin_gb, 2),
'after_gb': round(after_origin_gb, 2),
},
'origin_cost': {
'before': round(before_origin_cost, 2),
'after': round(after_origin_cost, 2),
'saving': round(before_origin_cost - after_origin_cost, 2),
},
'server_right_sizing': {
'before': '需要 4 台处理服务器（应对突发回源）',
'after': '可以减少到 2 台（回源平稳）',
'saving': 2 * 300, # 省掉 2 台 = 600 元/月
},
}
cache = CacheOptimization()
result = cache.analyze_savings(
monthly_traffic_tb=3.0,
before_hit_rate=0.90,
after_hit_rate=0.96,
)
# 结果：
# - 回源流量费节省：90 元/月
# - 服务器缩容节省：600 元/月（最重要的节省！）路径 3：存储分层 + 生命周期
class StorageOptimization:
"""存储分层 + 生命周期降本分析"""
def analyze(self):
# 优化前：全部标准存储
total_gb = 2700
before = total_gb * 0.12 # = 324 元/月
# 优化后：分层存储
hot = 200 # GB，标准存储
warm = 500 # GB，低频存储
cold = 2000 # GB，归档存储
after = (
hot * 0.12 # 24 元
+ warm * 0.08 # 40 元
+ cold * 0.03 # 60 元
)
# = 124 元/月
# 加上生命周期清理垃圾释放的空间
# 清理前 2700 GB → 清理后实际有效数据 2700 - 700 = 2000 GB
# 重新分配：热 150 + 温 400 + 冷 1450 = 2000 GB
after_with_cleanup = (
150 * 0.12
+ 400 * 0.08
+ 1450 * 0.03
)
# = 97.5 元/月
return {
'before': round(before, 2),
'after': round(after, 2),
'after_with_cleanup': round(after_with_cleanup, 2),
'total_saving': round(before - after_with_cleanup, 2),
}
storage = StorageOptimization()
storage_result = storage.analyze()
# 结果：
# - 优化前：324 元/月
# - 分层后：124 元/月
# - 分层 + 清理后：97.5 元/月
# - 总节省：226.5 元/月综合降本效果
三条路径叠加后的效果：
def final_cost_comparison():
"""优化前后的完整成本对比"""
# ==========================================
# 优化前（月度）
# ==========================================
before = {
'存储费': {
'明细': '全量标准存储 2700 GB',
'金额': 2700 * 0.12, # 324 元
},
'CDN 流量费': {
'明细': 'JPEG 全量 3 TB × 0.24',
'金额': 3000 * 0.24, # 720 元
},
'回源流量费': {
'明细': '命中率 90%，回源 300 GB × 0.50',
'金额': 300 * 0.50, # 150 元
},
'图片处理费': {
'明细': '缩略图 + 格式转换',
'金额': 0.88,
},
'请求费': {
'明细': 'OSS PUT/GET 请求',
'金额': 1.14,
},
'审核费': {
'明细': '鉴黄 + OCR',
'金额': 0.08,
},
'服务器': {
'明细': '3 上传 + 2 审核 + 4 处理 + 队列 + 监控',
'金额': 4030,
},
}
# ==========================================
# 优化后（月度）
# ==========================================
after = {
'存储费': {
'明细': '分层存储 + 清理垃圾（热 150 + 温 400 + 冷 1450 GB）',
'金额': 97.5,
},
'CDN 流量费': {
'明细': 'AVIF 优先 + WebP 兜底（流量减 58%）',
'金额': 307.96,
},
'回源流量费': {
'明细': '命中率 96%，回源 120 GB × 0.50',
'金额': 60.0,
},
'图片处理费': {
'明细': '同前（处理费极低，忽略不计）',
'金额': 0.88,
},
'请求费': {
'明细': '同前',
'金额': 1.14,
},
'审核费': {
'明细': '同前',
'金额': 0.08,
},
'服务器': {
'明细': '缓存优化后处理服务缩容至 2 台',
'金额': 4030 - 600, # 减掉 2 台处理服务器
},
}
# 汇总
before_total = sum(v['金额'] for v in before.values())
after_total = sum(v['金额'] for v in after.values())
return {
'before': {k: v['金额'] for k, v in before.items()},
'after': {k: v['金额'] for k, v in after.items()},
'before_total': round(before_total, 2),
'after_total': round(after_total, 2),
'saving': round(before_total - after_total, 2),
'saving_pct': round((before_total - after_total) / before_total * 100, 1),
}
result = final_cost_comparison()优化前后对比表
┌────────────────┬───────────────┬───────────────┬──────────┬──────────┐
│ 成本项 │ 优化前 │ 优化后 │ 节省 │ 降本措施 │
├────────────────┼───────────────┼───────────────┼──────────┼──────────┤
│ 存储费 │ 324.00 元 │ 97.50 元 │ 226.50元 │ 分层+清理 │
│ CDN 流量费 │ 720.00 元 │ 307.96 元 │ 412.04元 │ AVIF转换 │
│ 回源流量费 │ 150.00 元 │ 60.00 元 │ 90.00元 │ 缓存优化 │
│ 处理费 │ 0.88 元 │ 0.88 元 │ 0.00元 │ - │
│ 请求费 │ 1.14 元 │ 1.14 元 │ 0.00元 │ - │
│ 审核费 │ 0.08 元 │ 0.08 元 │ 0.00元 │ - │
│ 服务器 │ 4030.00 元 │ 3430.00 元 │ 600.00元 │ 缩容2台 │
├────────────────┼───────────────┼───────────────┼──────────┼──────────┤
│ 合计 │ 5226.10 元 │ 3897.56 元 │1328.54元 │ │
└────────────────┴───────────────┴───────────────┴──────────┴──────────┘嗯？省了 1328 元，但离 800 元的月度总成本还远。因为服务器占了 88%。
服务器降本的终极方案
服务器才是真正的大头。我重新审视了服务器成本：
class ServerCostOptimization:
"""服务器降本方案"""
def analyze(self):
# 方案 1：迁移到 Serverless（按调用计费）
serverless_cost = {
'上传服务 → API Gateway + Lambda': {
'每月调用次数': 13500,
'每次执行时间': '2s',
'月度成本': 13500 * 2 / 1000 * 0.00001667, # Lambda 单价
# ≈ 0.45 元（几乎免费）
},
'处理服务 → 异步函数': {
'每月处理次数': 67500,
'每次执行时间': '3s',
'月度成本': 67500 * 3 / 1000 * 0.00001667,
# ≈ 3.37 元
},
'审核服务 → 云 API': {
'说明': '直接调用云厂商的内容审核 API',
'月度成本': '已包含在审核费中',
},
}
# 方案 2：弹性伸缩（按需扩缩）
auto_scaling = {
'基础实例': 3 * 200, # 3 台低配（平时够用）
'弹性实例': '仅在高峰期（18:00~23:00）扩容 2 台',
'月度成本': 3 * 200 + 2 * 200 * 5 / 24, # ≈ 683 元
}
# 方案 3：容器化 + Spot 实例
spot_cost = {
'说明': '使用抢占式实例（价格是按需实例的 10~20%）',
'处理服务': 2 * 300 * 0.15, # Spot 价格 ≈ 45 元/台
'其他服务': 3 * 200, # 上传+审核用按需实例
'月度成本': 90 + 600 + 150 + 80,
# ≈ 920 元
'风险': 'Spot 实例可能被回收，需要做好容灾',
}
return {
'current': 4030,
'serverless': round(sum(
v.get('月度成本', 0)
for v in serverless_cost.values()
if isinstance(v.get('月度成本'), (int, float))
), 2),
'auto_scaling': round(auto_scaling['月度成本'], 2),
'spot_instance': round(spot_cost['月度成本'], 2),
}
server_opt = ServerCostOptimization()
server_result = server_opt.analyze()最终方案：弹性伸缩 + 混合部署
# 最终采用方案 2（弹性伸缩），风险可控
FINAL_ARCHITECTURE = {
'上传服务': {
'实例数': 2, # 降到 2 台（够用）
'规格': '2C4G',
'单价': 150, # 换成更便宜的型号
'月度': 300,
},
'审核服务': {
'方式': '云 API 直调', # 不自建服务，直接用阿里云内容安全
'月度': 50, # 比自建 2 台服务器便宜得多
},
'处理服务': {
'方式': '弹性伸缩',
'基础': 1 * 250, # 1 台基础实例
'弹性': 2 * 250 * 0.3, # 高峰期额外 2 台（约 30% 时间在线）
'月度': 400,
},
'消息队列': {
'方式': '云托管 RabbitMQ',
'月度': 80,
},
'监控': {
'方式': '云监控（基础版免费）',
'月度': 30,
},
'服务器总计': 860,
}
# 最终成本 = 存储费 + CDN + 回源 + 服务器 + 其他小额
# = 97.5 + 307.96 + 60 + 860 + 2.1
# ≈ 1327 元/月说实话，1327 元已经从 5226 元砍掉了 75%。但要到 800 元，还需要：
# 进一步优化
FURTHER_OPTIMIZATION = {
'CDN 流量包预付费': {
'说明': '购买 3TB/月流量包，折扣约 40%',
'原价': 307.96,
'优惠后': 307.96 * 0.6, # ≈ 185 元
'节省': 123,
},
'处理服务迁移到函数计算': {
'说明': '图片处理迁移到阿里云函数计算（按次计费）',
'原价': 400,
'优惠后': 50, # 实际处理次数不多
'节省': 350,
},
'存储进一步优化': {
'说明': '更激进的归档策略 + 清理冗余数据',
'原价': 97.5,
'优惠后': 70,
'节省': 27.5,
},
}
# 最终优化后成本：
# 存储: 70
# CDN: 185
# 回源: 60
# 审核: 50
# 处理: 50（函数计算）
# 上传服务: 300
# 队列: 80
# 监控: 30
# ──────────
# 总计: 825 元/月 ✅成本优化的核心心法
经过这一轮完整的成本分析，我总结了三条心法：
COST_OPTIMIZATION_PRINCIPLES = {
'心法 1：先算账，再动手': (
'不要凭直觉优化。先做完整的成本拆解，'
'找到最大的开支项，再集中火力优化。'
'我一开始以为是 CDN 最贵，结果发现服务器占 81%。'
),
'心法 2：减少数据量 > 优化存储单价': (
'格式转换（JPEG→AVIF）让流量减少 58%，'
'比优化 CDN 计价策略更有效。'
'源头减量永远比末端优化更高效。'
),
'心法 3：弹性 > 固定': (
'按需付费（Serverless、弹性伸缩）比固定部署便宜得多。'
'"光影"的访问有明显的峰谷（晚高峰），'
'弹性伸缩正好可以利用这个特征。'
),
}本节小结
✅ 我学到了什么：
- 完整的成本账本需要拆解到存储费、流量费、处理费、请求费、服务器等每一项
- 在 12000 用户规模下，服务器才是最大开支（81%），不是 CDN
- 三条降本路径：格式转换减体积、缓存优化减回源、存储分层减费用
- 弹性伸缩和 Serverless 是降本的关键武器
⚠️ 踩过的坑：
- 一开始只优化了存储分层，省了 200 元，但大头是服务器——方向搞错了
- CDN 流量包预付费有溢出风险（超出的部分按原价），需要精确预估
- Serverless 迁移需要改造代码，不是无脑切
🎯 下一步：成本优化做完了，整个系统的架构也稳定了。是时候回顾一下从第 0 章到现在的所有关键决策——每一个技术选型背后的权衡。
我的思考
思考 1
当”光影”的用户从 12000 增长到 10 万时，成本会如何变化？还是 825 元的 8.3 倍吗？
参考答案
不会线性增长。 不同成本项的增长率不同：
10 倍增长分析（12000 → 120000 用户）：
线性增长的项目：
- CDN 流量费：185 → 1850 元（用户越多，浏览越多）
- 回源流量费：60 → 600 元
- 审核费：50 → 500 元
亚线性增长的项目：
- 存储费：70 → 350 元（约 5 倍，因为冷数据归档摊薄）
- 处理费：50 → 200 元（函数计算有阶梯折扣）
需要阶梯式增长的项目：
- 服务器/上传服务：300 → 900 元（需要 6 台，不是 20 台）
10 倍用户后的预估月度成本：
≈ 1850 + 600 + 500 + 350 + 200 + 900 + 80 + 30
≈ 4510 元
增长倍数：4510 / 825 ≈ 5.5 倍（不是 10 倍）
关键洞察：
1. 弹性伸缩 + Serverless 让计算成本亚线性增长
2. 存储分层让存储成本远低于线性增长
3. CDN 是唯一接近线性增长的大项——优化 AVIF 转换率可以缓解思考 2
如果预算只有 500 元/月，能否支撑一个有 5000 用户的摄影社区？怎么做？
参考答案
可以，但需要取舍。5000 用户的极简方案：
5000 用户 / 500 元预算分配：
存储（80 元）：
- 全部标准存储 200 GB × 0.12 = 24 元
- 用 OSS 生命周期自动降级，不做复杂的自定义分层
- 省掉了自建分层引擎的开发成本
CDN（100 元）：
- 使用免费 CDN 额度（阿里云新用户通常有免费流量）
- 或用 Cloudflare 免费计划（无限流量！）
- 代价：国内速度不如阿里云 CDN
处理（0 元）：
- 用 OSS 自带的图片处理功能（免费额度内）
- 不自建处理服务
服务器（200 元）：
- 1 台 2C4G ECS（100 元）跑所有服务
- 用轻量应用服务器（更便宜）
- 或者用 Vercel + Cloudflare Workers（免费）
数据库 + 队列（100 元）：
- 云数据库基础版（50 元）
- 用 Redis 做轻量队列（50 元）或用数据库做简易队列
总计：24 + 0 + 0 + 200 + 100 = 324 元 ✅
核心取舍：
- 放弃高可用（单机部署）
- 放弃实时审核（改为举报 + 人工审核）
- 放弃 AVIF（只做 WebP，减少处理复杂度）
- 用免费/开源方案替代付费服务