《MMO 服务器开发》4.2 蓝绿、灰度与滚动发布

// file: internal/deploy/release.go
// tier: L1
// verify: go test ./internal/deploy/
// 4.2 的三种发布策略。蓝绿、灰度、滚动不是三种写法，而是三组取舍：切换多
// 快、多花多少容量、回滚多难、状态兼容要求多严。每种策略被编码成一个可回
// 放的「发布计划」，回放它就能算出取舍表里的数字——表是计划的结果，不是
// 拍脑袋的结论。
package deploy

// Strategy 是 4.2 对照的三种发布形态。
type Strategy string

const (
	// BlueGreen 把新版本整队拉起、验证后一步切流量，回滚就是一步切回去。
	BlueGreen Strategy = "blue-green"
	// Canary 让新版本按递增比例接流量，同时按比例退掉旧实例，把坏版本的影响面压小。
	Canary Strategy = "canary"
	// Rolling 逐台替换，额外容量最省，但最难回滚。
	Rolling Strategy = "rolling"
)

// StepKind 是发布计划里的一步动作。
type StepKind string

const (
	StepProvision StepKind = "provision"     // 拉起 N 个新版本副本
	StepShift     StepKind = "shift-traffic" // 把流量切给新版本
	StepVerify    StepKind = "verify"        // 健康检查 / 冒烟
	StepRetire    StepKind = "retire"        // 退掉 N 个旧版本副本
)

// Step 是一步动作。Percent 是这一步之后新版本累计持有的流量比例；Replicas
// 是这一步起停的副本数。
type Step struct {
	Kind     StepKind
	Percent  int
	Replicas int
}

// Plan 是某种策略的发布计划。
type Plan struct {
	Strategy Strategy
	Steps    []Step
}

// PlanFor 为服务 replicas 个副本的策略生成标准发布计划。
func PlanFor(s Strategy, replicas int) Plan {
	switch s {
	case BlueGreen:
		// 整队拉起 green、验证，然后一步切换。
		return Plan{s, []Step{
			{Kind: StepProvision, Replicas: replicas},
			{Kind: StepVerify},
			{Kind: StepShift, Percent: 100},
			{Kind: StepRetire, Replicas: replicas},
		}}
	case Canary:
		// 新版本随流量爬升，旧实例按比例退场，两队合计不超过 1.5 倍规模。
		half := (replicas + 1) / 2
		return Plan{s, []Step{
			{Kind: StepProvision, Replicas: 1},
			{Kind: StepShift, Percent: 10},
			{Kind: StepProvision, Replicas: half - 1},
			{Kind: StepShift, Percent: 50},
			{Kind: StepRetire, Replicas: replicas - half},
			{Kind: StepProvision, Replicas: replicas - half},
			{Kind: StepShift, Percent: 100},
			{Kind: StepRetire, Replicas: half},
		}}
	case Rolling:
		// 逐台替换：先多起一台、切它那份流量、再退掉一台旧实例，如此循环。
		steps := make([]Step, 0, replicas*3)
		for i := 1; i <= replicas; i++ {
			steps = append(steps,
				Step{Kind: StepProvision, Replicas: 1},
				Step{Kind: StepShift, Percent: i * 100 / replicas},
				Step{Kind: StepRetire, Replicas: 1},
			)
		}
		return Plan{s, steps}
	default:
		return Plan{}
	}
}

// Trace 是回放一份计划得到的代价，即 4.2 对照的四个维度。
type Trace struct {
	// PeakExtraReplicas 是整个过程里最多同时多跑了几个副本：用钱买的额外容量。
	PeakExtraReplicas int
	// SwitchSteps 是流量切换的次数，越少切换越原子、越快。
	SwitchSteps int
	// RollbackSteps 是要恢复旧版本需要倒回的流量步数，也就是策略留下的回滚点。
	RollbackSteps int
}

// Trace 把计划放到 replicas 个副本的稳态上回放。
func (p Plan) Trace(replicas int) Trace {
	old, fresh := replicas, 0
	peak, shifts := 0, 0
	for _, s := range p.Steps {
		switch s.Kind {
		case StepProvision:
			fresh += s.Replicas
		case StepRetire:
			old -= s.Replicas
		case StepShift:
			shifts++
		}
		if extra := old + fresh - replicas; extra > peak {
			peak = extra
		}
	}
	return Trace{PeakExtraReplicas: peak, SwitchSteps: shifts, RollbackSteps: shifts}
}

// Rollback 返回把流量倒回旧版本的动作序列，按顺序排列。
func (p Plan) Rollback(replicas int) []Step {
	var pcts []int
	for _, s := range p.Steps {
		if s.Kind == StepShift {
			pcts = append(pcts, s.Percent)
		}
	}
	out := make([]Step, 0, len(pcts))
	for i := len(pcts) - 1; i >= 0; i-- {
		prev := 0
		if i > 0 {
			prev = pcts[i-1]
		}
		out = append(out, Step{Kind: StepShift, Percent: prev})
	}
	return out
}

// file: internal/deploy/release_test.go
// tier: L1
// verify: go test ./internal/deploy/
package deploy

import "testing"

const fleet = 6

func TestBlueGreenSwitchesInOneStep(t *testing.T) {
	tr := PlanFor(BlueGreen, fleet).Trace(fleet)
	if tr.SwitchSteps != 1 {
		t.Errorf("blue-green switch steps = %d, want 1 (atomic switch)", tr.SwitchSteps)
	}
	if tr.PeakExtraReplicas != fleet {
		t.Errorf("blue-green peak extra = %d, want %d (a full duplicate fleet)",
			tr.PeakExtraReplicas, fleet)
	}
	if tr.RollbackSteps != 1 {
		t.Errorf("blue-green rollback steps = %d, want 1 (flip back)", tr.RollbackSteps)
	}
}

func TestCanaryRampsInSteps(t *testing.T) {
	tr := PlanFor(Canary, fleet).Trace(fleet)
	if tr.SwitchSteps < 3 {
		t.Errorf("canary switch steps = %d, want >= 3 (gradual ramp)", tr.SwitchSteps)
	}
	if tr.PeakExtraReplicas >= fleet {
		t.Errorf("canary peak extra = %d, must stay below a full duplicate (%d)",
			tr.PeakExtraReplicas, fleet)
	}
	if tr.RollbackSteps != tr.SwitchSteps {
		t.Errorf("canary rollback steps = %d, want %d (one rollback point per shift)",
			tr.RollbackSteps, tr.SwitchSteps)
	}
}

func TestRollingUsesLeastCapacity(t *testing.T) {
	tr := PlanFor(Rolling, fleet).Trace(fleet)
	if tr.PeakExtraReplicas != 1 {
		t.Errorf("rolling peak extra = %d, want 1 (surge by one)", tr.PeakExtraReplicas)
	}
	if tr.SwitchSteps != fleet {
		t.Errorf("rolling switch steps = %d, want %d (one per replica)", tr.SwitchSteps, fleet)
	}
}

func TestTradeoffOrdering(t *testing.T) {
	bg := PlanFor(BlueGreen, fleet).Trace(fleet)
	ca := PlanFor(Canary, fleet).Trace(fleet)
	ro := PlanFor(Rolling, fleet).Trace(fleet)

	// 容量：滚动 < 灰度 < 蓝绿。
	if !(ro.PeakExtraReplicas < ca.PeakExtraReplicas && ca.PeakExtraReplicas < bg.PeakExtraReplicas) {
		t.Errorf("capacity order broken: rolling=%d canary=%d blue-green=%d",
			ro.PeakExtraReplicas, ca.PeakExtraReplicas, bg.PeakExtraReplicas)
	}
	// 切换速度：蓝绿最原子，滚动最不原子。
	if !(bg.SwitchSteps < ca.SwitchSteps && ca.SwitchSteps < ro.SwitchSteps) {
		t.Errorf("switch-speed order broken: blue-green=%d canary=%d rolling=%d",
			bg.SwitchSteps, ca.SwitchSteps, ro.SwitchSteps)
	}
	// 回滚：蓝绿最容易，滚动最难。
	if !(bg.RollbackSteps < ro.RollbackSteps) {
		t.Errorf("rollback order broken: blue-green=%d rolling=%d",
			bg.RollbackSteps, ro.RollbackSteps)
	}
}

func TestRollbackPathEndsAtZero(t *testing.T) {
	for _, s := range []Strategy{BlueGreen, Canary, Rolling} {
		p := PlanFor(s, fleet)
		path := p.Rollback(fleet)
		if len(path) != p.Trace(fleet).RollbackSteps {
			t.Errorf("%s: rollback path length %d != rollback steps %d",
				s, len(path), p.Trace(fleet).RollbackSteps)
		}
		if len(path) == 0 || path[len(path)-1].Percent != 0 {
			t.Errorf("%s: rollback path must end with traffic back at 0", s)
		}
	}
}

--- PASS: TestBlueGreenSwitchesInOneStep (0.00s)
--- PASS: TestCanaryRampsInSteps (0.00s)
--- PASS: TestRollingUsesLeastCapacity (0.00s)
--- PASS: TestTradeoffOrdering (0.00s)
--- PASS: TestRollbackPathEndsAtZero (0.00s)
ok  	aegis/internal/deploy	0.248s