《Java 服务端通信工程》14.3 成本、扩缩容与预算

月度成本 = 实例数 × (vCPU × 单价_vcpu × 730 + 内存GiB × 单价_gib × 730)
         + 月度请求数 × 平均响应KB / 1,000,000 × 出口单价_GB × 出口占比

实例：4 vCPU / 8 GiB，2 个副本
请求：200 rps，平均响应 2.5 KB（gzip 后），80% 走公网
月度请求数 = 200 × 86400 × 30 = 518,400,000
月度流量   = 518,400,000 × 2.5 KB = 1,296,000,000 KB = 1,296 GB
计算成本   = 2 × (4 × 0.04 × 730 + 8 × 0.005 × 730)
           = 2 × (116.8 + 29.2) = 292.0
出口成本   = 1,296 × 0.09 × 0.8 ≈ 93.3
月度合计   ≈ 385.3（假设口径）

目标副本数 = max(
  按 CPU 需求,
  按在途请求需求,
  按 p99 需求,
  最小副本数
)
上限 = min(最大副本数, 预算允许的副本数)

package com.plume.linkd.v3.capacity;

public final class CostModel {

    public record Instance(int vcpu, int memoryGib) {
    }

    /** 单价均为假设值，用于演示算法，不代表实际云厂商报价。 */
    public record Prices(double vcpuHour, double gibHour, double egressGb) {
        public static Prices assumed() {
            return new Prices(0.04, 0.005, 0.09);
        }
    }

    public record Workload(long requestsPerMonth, double responseKb, double egressShare) {
    }

    public static double monthlyCompute(Instance instance, Prices prices, int replicas) {
        double hours = 730.0;
        return replicas * (instance.vcpu() * prices.vcpuHour() * hours
                + instance.memoryGib() * prices.gibHour() * hours);
    }

    public static double monthlyEgress(Workload workload, Prices prices) {
        double kb = workload.requestsPerMonth() * workload.responseKb();
        double gb = kb / 1_000_000.0; // 1 GB = 1e9 字节 = 1e6 KB，按云厂商十进制口径
        return gb * prices.egressGb() * workload.egressShare();
    }

    public static double total(Instance instance, Prices prices, int replicas, Workload workload) {
        return monthlyCompute(instance, prices, replicas) + monthlyEgress(workload, prices);
    }

    public static void main(String[] args) {
        Instance instance = new Instance(4, 8);
        Prices prices = Prices.assumed();
        Workload workload = new Workload(518_400_000L, 2.5, 0.8);
        System.out.printf("compute=%.2f egress=%.2f total=%.2f%n",
                monthlyCompute(instance, prices, 2),
                monthlyEgress(workload, prices),
                total(instance, prices, 2, workload));
        // 假设口径输出：compute=292.00 egress=93.31 total=385.31
    }
}

package com.plume.linkd.v3.capacity;

public final class ScalingPolicy {

    public record Signals(double cpuUtilization, int inflight, double p99Millis,
                          double queueWaitMillis, double errorRate) {
    }

    public static int desiredReplicas(Signals signals, int current,
                                      int minReplicas, int maxReplicas,
                                      int perInstanceInflight) {
        int byCpu = signals.cpuUtilization() > 0.60
                ? (int) Math.ceil(current * signals.cpuUtilization() / 0.60)
                : current;
        int byInflight = (int) Math.ceil(
                (double) signals.inflight() / Math.max(1, perInstanceInflight));
        int byP99 = signals.p99Millis() > 300 && current < maxReplicas
                ? current + 1
                : current;
        int byErrors = signals.errorRate() > 0.01 && current < maxReplicas
                ? current + 1
                : current;

        int desired = Math.max(Math.max(byCpu, byInflight), Math.max(byP99, byErrors));
        return Math.max(minReplicas, Math.min(maxReplicas, desired));
    }

    public static boolean shouldScaleIn(Signals signals, int lowLoadMinutes) {
        return lowLoadMinutes >= 10
                && signals.cpuUtilization() < 0.30
                && signals.inflight() == 0
                && signals.p99Millis() < 200
                && signals.errorRate() < 0.001;
    }
}