《互联网产品的服务端架构·产品、流量与基础能力》附录 C 容量估算速查

500000 × 12 / 43200 × 3.2 = 444.444 QPS

40 GB/天 × 180 天 × 3 副本 = 21600 GB = 21.094 TB（按 1 TB = 1024 GB）

计算：200 × 730 × 0.10 = 14600.00 元
存储：20480 × 0.02 = 409.60 元
带宽：30720 × 0.05 = 1536.00 元
总计：14600.00 + 409.60 + 1536.00 = 16545.60 元

// file: internal/platform/capacity/sensitivity.go
// tier: L1
// verify: go test ./internal/platform/capacity/

package capacity

import "fmt"

// Range 是一个参数的可能取值区间。容量评估用区间而不是单点，是为了让
// 假设的误差显式传播到结果，而不是藏进一个看起来精确的数字里。
type Range struct {
	Low  float64
	High float64
}

// Inputs 是四个最常被拍脑袋的参数：DAU、每用户请求数、峰值系数和
// 有效活跃秒数。最后一个不是 86400，而是用户真正产生请求的时段长度。
type Inputs struct {
	DAU             Range
	RequestsPerUser Range
	PeakFactor      Range
	ActiveSeconds   Range
}

// BoundsResult 同时给出最保守与最激进的估算，NominalQPS 取各区间中值。
type BoundsResult struct {
	MinQPS     float64
	MaxQPS     float64
	NominalQPS float64
}

// Bounds 用区间上下界的组合给出 QPS 的最小值与最大值。
// 最小 QPS 取“流量最小、活跃时段最长”的组合，最大 QPS 取相反组合。
func Bounds(in Inputs) (BoundsResult, error) {
	switch {
	case in.DAU.Low <= 0 || in.DAU.High <= 0:
		return BoundsResult{}, fmt.Errorf("capacity: DAU must be positive")
	case in.DAU.Low > in.DAU.High:
		return BoundsResult{}, fmt.Errorf("capacity: DAU low %.3f > high %.3f", in.DAU.Low, in.DAU.High)
	case in.RequestsPerUser.Low < 0 || in.RequestsPerUser.High <= 0:
		return BoundsResult{}, fmt.Errorf("capacity: requests per user must be positive")
	case in.RequestsPerUser.Low > in.RequestsPerUser.High:
		return BoundsResult{}, fmt.Errorf("capacity: requests per user low %.3f > high %.3f", in.RequestsPerUser.Low, in.RequestsPerUser.High)
	case in.PeakFactor.Low < 1 || in.PeakFactor.High < 1:
		return BoundsResult{}, fmt.Errorf("capacity: peak factor must be >= 1")
	case in.PeakFactor.Low > in.PeakFactor.High:
		return BoundsResult{}, fmt.Errorf("capacity: peak factor low %.3f > high %.3f", in.PeakFactor.Low, in.PeakFactor.High)
	case in.ActiveSeconds.Low <= 0 || in.ActiveSeconds.High <= 0:
		return BoundsResult{}, fmt.Errorf("capacity: active seconds must be positive")
	case in.ActiveSeconds.Low > in.ActiveSeconds.High:
		return BoundsResult{}, fmt.Errorf("capacity: active seconds low %.3f > high %.3f", in.ActiveSeconds.Low, in.ActiveSeconds.High)
	}

	minQPS := in.DAU.Low * in.RequestsPerUser.Low / in.ActiveSeconds.High * in.PeakFactor.Low
	maxQPS := in.DAU.High * in.RequestsPerUser.High / in.ActiveSeconds.Low * in.PeakFactor.High

	dauMid := (in.DAU.Low + in.DAU.High) / 2
	rpuMid := (in.RequestsPerUser.Low + in.RequestsPerUser.High) / 2
	peakMid := (in.PeakFactor.Low + in.PeakFactor.High) / 2
	secMid := (in.ActiveSeconds.Low + in.ActiveSeconds.High) / 2
	nominal := dauMid * rpuMid / secMid * peakMid

	return BoundsResult{MinQPS: minQPS, MaxQPS: maxQPS, NominalQPS: nominal}, nil
}

// file: internal/platform/capacity/elastic.go
// tier: L1
// verify: go test ./internal/platform/capacity/

package capacity

import "fmt"

// Policy 是弹性策略的全部可调参数。阈值、步长和冷却时间必须一起调，
// 单独把阈值调低只会换来更频繁的抖动。
type Policy struct {
	Min             int
	Max             int
	TargetUtil      float64 // 目标利用率，0.6 表示按 60% 负载运行
	Step            int     // 每次扩缩容的实例数
	CooldownSeconds int
}

// Scaler 保存上一次真正发生扩缩容的时间，供冷却判断使用。
type Scaler struct {
	LastScaleAt int64
}

// Decide 返回下一次应运行的实例数。它不执行扩缩容，只做纯决策，
// 便于在测试里把时间当参数注入，而不是靠 sleep。
func Decide(s *Scaler, now int64, current int, util float64, p Policy) (int, error) {
	switch {
	case s == nil:
		return 0, fmt.Errorf("capacity: scaler must not be nil")
	case now < 0:
		return 0, fmt.Errorf("capacity: now must not be negative")
	case p.Min < 1:
		return 0, fmt.Errorf("capacity: min must be at least 1")
	case p.Max < p.Min:
		return 0, fmt.Errorf("capacity: max must be >= min")
	case p.TargetUtil <= 0 || p.TargetUtil > 1:
		return 0, fmt.Errorf("capacity: target utilization must be in (0,1]")
	case p.Step < 1:
		return 0, fmt.Errorf("capacity: step must be at least 1")
	case p.CooldownSeconds < 0:
		return 0, fmt.Errorf("capacity: cooldown must not be negative")
	case current < 0:
		return 0, fmt.Errorf("capacity: current must not be negative")
	case util < 0:
		return 0, fmt.Errorf("capacity: utilization must not be negative")
	}

	// 从未扩缩容时 LastScaleAt 为 0，不应被误判为刚动作过。
	if s.LastScaleAt > 0 && now-s.LastScaleAt < int64(p.CooldownSeconds) {
		return current, nil
	}

	next := current
	switch {
	case util > p.TargetUtil:
		next = current + p.Step
	case util < p.TargetUtil/2:
		next = current - p.Step
	}

	if next < p.Min {
		next = p.Min
	}
	if next > p.Max {
		next = p.Max
	}
	if next != current {
		s.LastScaleAt = now
	}
	return next, nil
}

cd /Users/bingrong.yan/projects/birdor/plumephp/.local/checks/webapp-lab
go test ./internal/platform/capacity/

ok  	webapp/internal/platform/capacity	0.649s

cd /Users/bingrong.yan/projects/birdor/plumephp/.local/tmp
python3 - <<'PY'
# 区间算例：Bounds 的最小/标称/最大（上下界组合，不是 min 与 max 的中点）
lo = 450_000 * 10 / 50_400 * 2.8
hi = 550_000 * 14 / 36_000 * 3.6
nom = 500_000 * 12 / 43_200 * 3.2
print(f"bounds_min={lo:.3f} bounds_nominal={nom:.3f} bounds_max={hi:.3f} midpoint={((lo + hi) / 2):.3f}")

# 算例一：回声的峰值 QPS（单点输入等价于 Bounds 的上下界重合）
dau, rpu, peak, sec = 500_000, 12, 3.2, 12 * 3600
qps = dau * rpu / sec * peak
print(f"active_seconds={sec} daily_requests={dau * rpu}")
print(f"peak_qps={qps:.3f}")
print(f"avg_qps_86400={dau * rpu / 86400:.3f} peak_qps_86400={dau * rpu / 86400 * peak:.3f}")
print(f"ratio_vs_86400={qps / (dau * rpu / 86400 * peak):.3f}")

# 算例二：图片存储稳态（SteadyState，CurrentGB=0）
daily, days, rep, current = 40, 180, 3, 0
total = current + daily * days * rep
print(f"retained_gb={daily * days * rep} steady_gb={total} steady_tb={total / 1024:.3f}")
print(f"if_90_days={daily * 90 * rep} if_one_replica={daily * days}")

# 算例三：200 核一个月的账单（Monthly）
cores, hours, storage_tb, transfer_tb = 200, 730, 20, 30
core_hour, gb_month, gb_transfer = 0.10, 0.02, 0.05
storage_gb, transfer_gb = storage_tb * 1024, transfer_tb * 1024
compute = cores * hours * core_hour
storage = storage_gb * gb_month
transfer = transfer_gb * gb_transfer
print(f"storage_gb={storage_gb} transfer_gb={transfer_gb}")
print(f"compute={compute:.2f} storage={storage:.2f} transfer={transfer:.2f} total={compute + storage + transfer:.2f}")
print(f"compute_share={compute / (compute + storage + transfer) * 100:.2f}%")
print(f"if_30_days={cores * 30 * 24 * core_hour:.2f}")
PY

bounds_min=250.000 bounds_nominal=444.444 bounds_max=770.000 midpoint=510.000
active_seconds=43200 daily_requests=6000000
peak_qps=444.444
avg_qps_86400=69.444 peak_qps_86400=222.222
ratio_vs_86400=2.000
retained_gb=21600 steady_gb=21600 steady_tb=21.094
if_90_days=10800 if_one_replica=7200
storage_gb=20480 transfer_gb=30720
compute=14600.00 storage=409.60 transfer=1536.00 total=16545.60
compute_share=88.24%
if_30_days=14400.00