《游戏服务端编程实践》21.2 AIOps 与自动化部署

// file: ch21/autoscale/autoscale.go
// tier: L1
// verify: go test ./ch21/autoscale/

package autoscale

import (
	"errors"
	"fmt"
	"math"
	"time"
)

var (
	ErrInvalidPolicy = errors.New("autoscale: invalid policy")
	ErrInvalidMetric = errors.New("autoscale: invalid metric")
)

// Policy 描述扩缩容的边界和节奏。TargetUtilization 用 0~1 表示，
// Hysteresis 是目标值两侧的死区比例，避免在阈值附近来回抖动。
type Policy struct {
	Min               int
	Max               int
	TargetUtilization float64
	Hysteresis        float64
	StepUp            int
	StepDown          int
	Cooldown          time.Duration
}

func (p Policy) Validate() error {
	if p.Min < 0 {
		return fmt.Errorf("%w: min must be >= 0", ErrInvalidPolicy)
	}
	if p.Max < 1 || p.Max < p.Min {
		return fmt.Errorf("%w: max must be >= 1 and >= min", ErrInvalidPolicy)
	}
	if p.TargetUtilization <= 0 || p.TargetUtilization > 1 {
		return fmt.Errorf("%w: target utilization must be in (0,1]", ErrInvalidPolicy)
	}
	if p.Hysteresis < 0 || p.Hysteresis >= 0.5 {
		return fmt.Errorf("%w: hysteresis must be in [0,0.5)", ErrInvalidPolicy)
	}
	if p.TargetUtilization*(1+p.Hysteresis) > 1 {
		return fmt.Errorf("%w: up threshold must not exceed 1", ErrInvalidPolicy)
	}
	if p.StepUp < 1 || p.StepDown < 1 {
		return fmt.Errorf("%w: step must be >= 1", ErrInvalidPolicy)
	}
	if p.Cooldown < 0 {
		return fmt.Errorf("%w: cooldown must be >= 0", ErrInvalidPolicy)
	}
	return nil
}

func (p Policy) upThreshold() float64 {
	return p.TargetUtilization * (1 + p.Hysteresis)
}

func (p Policy) downThreshold() float64 {
	return p.TargetUtilization * (1 - p.Hysteresis)
}

type Action string

const (
	ActionNone      Action = "none"
	ActionScaleUp   Action = "scale_up"
	ActionScaleDown Action = "scale_down"
)

// Result 同时给出当前值和决策后的副本数，调用方即使不动作也能记录原因。
type Result struct {
	From   int
	To     int
	Action Action
	Reason string
}

func (r Result) Changed() bool {
	return r.Action != ActionNone && r.To != r.From
}

// Decide 是纯函数：同样输入永远得到同样输出，便于回放和单元测试。
// 越界钳制优先于冷却，副本数已经不在合法区间时纠正是安全动作。
func Decide(p Policy, current int, utilization float64, now, lastAction time.Time) (Result, error) {
	if err := p.Validate(); err != nil {
		return Result{}, err
	}
	if current < 0 {
		return Result{}, fmt.Errorf("%w: replicas must be >= 0", ErrInvalidPolicy)
	}
	if math.IsNaN(utilization) || math.IsInf(utilization, 0) || utilization < 0 {
		return Result{}, fmt.Errorf("%w: utilization = %v", ErrInvalidMetric, utilization)
	}

	res := Result{From: current, To: current, Action: ActionNone}

	if current < p.Min {
		res.To = p.Min
		res.Action = ActionScaleUp
		res.Reason = "clamp to min"
		return res, nil
	}
	if current > p.Max {
		res.To = p.Max
		res.Action = ActionScaleDown
		res.Reason = "clamp to max"
		return res, nil
	}

	switch {
	case utilization >= p.upThreshold():
		res.To = min(current+p.StepUp, p.Max)
		if res.To > current {
			res.Action = ActionScaleUp
			res.Reason = fmt.Sprintf("utilization %.3f >= up threshold %.3f",
				utilization, p.upThreshold())
		} else {
			res.Reason = "already at max"
		}
	case utilization <= p.downThreshold():
		res.To = max(current-p.StepDown, p.Min)
		if res.To < current {
			res.Action = ActionScaleDown
			res.Reason = fmt.Sprintf("utilization %.3f <= down threshold %.3f",
				utilization, p.downThreshold())
		} else {
			res.Reason = "already at min"
		}
	default:
		res.Reason = "within hysteresis band"
	}

	if res.Action != ActionNone && !lastAction.IsZero() && now.Sub(lastAction) < p.Cooldown {
		res.To = current
		res.Action = ActionNone
		res.Reason = fmt.Sprintf("cooldown %s not elapsed", p.Cooldown)
	}
	return res, nil
}

// Controller 保存最近一次动作的时间，供控制循环反复调用 Observe。
// 它不是并发安全的：一个副本只应由一个控制循环驱动。
type Controller struct {
	policy     Policy
	current    int
	lastAction time.Time
}

func NewController(p Policy, initial int) (*Controller, error) {
	if err := p.Validate(); err != nil {
		return nil, err
	}
	if initial < p.Min {
		initial = p.Min
	}
	if initial > p.Max {
		initial = p.Max
	}
	return &Controller{policy: p, current: initial}, nil
}

func (c *Controller) Current() int {
	return c.current
}

func (c *Controller) Observe(utilization float64, now time.Time) (Result, error) {
	res, err := Decide(c.policy, c.current, utilization, now, c.lastAction)
	if err != nil {
		return Result{}, err
	}
	if res.Action != ActionNone && res.To != c.current {
		c.current = res.To
		c.lastAction = now
	}
	return res, nil
}

cd .local/checks/gs-practice-lab && gofmt -l ch21/autoscale && go vet ./ch21/autoscale/ && go test ./ch21/autoscale/ -count=1

ok  	gspractice/ch21/autoscale	0.387s