《后端架构设计·演进与治理》1.1 微服务拆分不是默认答案：三个触发条件

// file: internal/platform/split/scorecard.go
// tier: L1
// verify: go test ./internal/platform/split/ -count=1
package split

import (
	"fmt"
	"math"
	"sort"
	"strings"
)

// Trigger is one observable reason that can justify a service split.
type Trigger string

const (
	ChangeFrequencyConflict  Trigger = "change_frequency_conflict"
	IndependentScaling       Trigger = "independent_scaling"
	FaultIsolationCompliance Trigger = "fault_isolation_compliance"
)

// Signal is measured from releases, runtime metrics and compliance scope.
// Team size and lines of code are absent: neither is a split trigger.
type Signal struct {
	ModuleReleasesPerMonth  float64
	CoupledReleasesPerMonth float64
	PeakCPUConsumption      float64
	PeakTrafficShare        float64
	CriticalityTier         int
	Regulated               bool
	BlastRadiusShare        float64
}

func (s Signal) validate() error {
	switch {
	case s.ModuleReleasesPerMonth < 0 || s.CoupledReleasesPerMonth < 0:
		return fmt.Errorf("split: releases must not be negative")
	case s.CoupledReleasesPerMonth > s.ModuleReleasesPerMonth:
		return fmt.Errorf("split: coupled releases %.0f exceed total %.0f", s.CoupledReleasesPerMonth, s.ModuleReleasesPerMonth)
	case s.PeakCPUConsumption < 0 || s.PeakCPUConsumption > 1:
		return fmt.Errorf("split: cpu share must be within [0,1], got %.2f", s.PeakCPUConsumption)
	case s.PeakTrafficShare < 0 || s.PeakTrafficShare > 1:
		return fmt.Errorf("split: traffic share must be within [0,1], got %.2f", s.PeakTrafficShare)
	case s.CriticalityTier < 1 || s.CriticalityTier > 3:
		return fmt.Errorf("split: criticality tier must be 1..3, got %d", s.CriticalityTier)
	case s.BlastRadiusShare < 0 || s.BlastRadiusShare > 1:
		return fmt.Errorf("split: blast radius must be within [0,1], got %.2f", s.BlastRadiusShare)
	}
	return nil
}

// TriggerScore is the points contributed by one trigger, 0..3.
type TriggerScore struct {
	Trigger Trigger
	Points  int
}

func (s Signal) scores() []TriggerScore {
	var out []TriggerScore
	// One coupled release in a quiet module is noise; require four releases.
	if s.ModuleReleasesPerMonth >= 4 {
		switch ratio := s.CoupledReleasesPerMonth / s.ModuleReleasesPerMonth; {
		case ratio >= 0.5:
			out = append(out, TriggerScore{ChangeFrequencyConflict, 3})
		case ratio >= 0.3:
			out = append(out, TriggerScore{ChangeFrequencyConflict, 2})
		case ratio >= 0.15:
			out = append(out, TriggerScore{ChangeFrequencyConflict, 1})
		}
	}
	switch share := math.Max(s.PeakCPUConsumption, s.PeakTrafficShare); {
	case share >= 0.8:
		out = append(out, TriggerScore{IndependentScaling, 3})
	case share >= 0.6:
		out = append(out, TriggerScore{IndependentScaling, 2})
	case share >= 0.4:
		out = append(out, TriggerScore{IndependentScaling, 1})
	}
	switch {
	case s.Regulated && s.CriticalityTier == 1:
		out = append(out, TriggerScore{FaultIsolationCompliance, 3})
	case s.CriticalityTier == 1 && s.BlastRadiusShare >= 0.5:
		out = append(out, TriggerScore{FaultIsolationCompliance, 2})
	case s.Regulated || s.BlastRadiusShare >= 0.8:
		out = append(out, TriggerScore{FaultIsolationCompliance, 1})
	}
	return out
}

// Readiness lists hard gates. A candidate without these gates is not ready.
type Readiness struct {
	DataOwnerNamed    bool
	ContractTests     bool
	IndependentDeploy bool
	RollbackPlan      bool
	Observability     bool
}

func (r Readiness) Unmet() []string {
	var out []string
	for _, gate := range []struct {
		ok   bool
		name string
	}{
		{r.DataOwnerNamed, "data_owner_named"},
		{r.ContractTests, "contract_tests"},
		{r.IndependentDeploy, "independent_deploy"},
		{r.RollbackPlan, "rollback_plan"},
		{r.Observability, "observability"},
	} {
		if !gate.ok {
			out = append(out, gate.name)
		}
	}
	return out
}

func (r Readiness) Ready() bool { return len(r.Unmet()) == 0 }

// Decision is the only action the scorecard allows.
type Decision string

const (
	KeepModular    Decision = "keep_modular"
	ModularFirst   Decision = "modular_first"
	SplitCandidate Decision = "split_candidate"
	Prepare        Decision = "prepare"
)

// Assessment is the scorecard result.
type Assessment struct {
	Decision Decision
	Score    int
	Triggers []TriggerScore
	Unmet    []string
}

// Evaluate turns measured signals and readiness gates into one decision.
func Evaluate(s Signal, r Readiness) (Assessment, error) {
	if err := s.validate(); err != nil {
		return Assessment{}, err
	}
	scores := s.scores()
	total := 0
	strongIsolation := false
	for _, sc := range scores {
		total += sc.Points
		strongIsolation = strongIsolation || sc.Trigger == FaultIsolationCompliance && sc.Points >= 3
	}
	a := Assessment{Score: total, Triggers: scores, Unmet: r.Unmet()}
	switch {
	case total == 0:
		a.Decision = KeepModular
	case !r.Ready() && total >= 3:
		a.Decision = Prepare
	case strongIsolation:
		a.Decision = SplitCandidate
	case total >= 6:
		a.Decision = SplitCandidate
	default:
		a.Decision = ModularFirst
	}
	return a, nil
}

// Summary is one review-friendly line.
func (a Assessment) Summary() string {
	names := make([]string, 0, len(a.Triggers))
	for _, t := range a.Triggers {
		names = append(names, string(t.Trigger))
	}
	sort.Strings(names)
	return fmt.Sprintf("decision=%s score=%d triggers=%s unmet=%s",
		a.Decision, a.Score, strings.Join(names, ","), strings.Join(a.Unmet, ","))
}

// file: internal/platform/split/scorecard_test.go
// tier: L1
// verify: go test ./internal/platform/split/ -count=1
package split

import (
	"strings"
	"testing"
)

func ready() Readiness {
	return Readiness{DataOwnerNamed: true, ContractTests: true, IndependentDeploy: true, RollbackPlan: true, Observability: true}
}

func TestEvaluateScorecard(t *testing.T) {
	cases := []struct {
		name      string
		signal    Signal
		readiness Readiness
		decision  Decision
		score     int
	}{
		{"no_trigger", Signal{ModuleReleasesPerMonth: 2, CoupledReleasesPerMonth: 1, PeakCPUConsumption: 0.2, PeakTrafficShare: 0.2, CriticalityTier: 3, BlastRadiusShare: 0.1}, Readiness{}, KeepModular, 0},
		{"prepare", Signal{ModuleReleasesPerMonth: 8, CoupledReleasesPerMonth: 4, PeakCPUConsumption: 0.7, CriticalityTier: 2, BlastRadiusShare: 0.2}, Readiness{DataOwnerNamed: true}, Prepare, 5},
		{"split", Signal{ModuleReleasesPerMonth: 8, CoupledReleasesPerMonth: 4, PeakCPUConsumption: 0.85, CriticalityTier: 2, BlastRadiusShare: 0.2}, ready(), SplitCandidate, 6},
		{"compliance", Signal{ModuleReleasesPerMonth: 1, PeakCPUConsumption: 0.1, CriticalityTier: 1, Regulated: true, BlastRadiusShare: 0.2}, ready(), SplitCandidate, 3},
	}
	for _, tc := range cases {
		t.Run(tc.name, func(t *testing.T) {
			a, err := Evaluate(tc.signal, tc.readiness)
			if err != nil {
				t.Fatalf("Evaluate: %v", err)
			}
			t.Logf("summary: %s", a.Summary())
			if a.Decision != tc.decision || a.Score != tc.score {
				t.Fatalf("decision=%s score=%d, want %s/%d", a.Decision, a.Score, tc.decision, tc.score)
			}
		})
	}
}

func TestEvaluateValidation(t *testing.T) {
	cases := []struct {
		name   string
		signal Signal
		want   string
	}{
		{"coupled_exceeds_total", Signal{ModuleReleasesPerMonth: 2, CoupledReleasesPerMonth: 3, CriticalityTier: 2, PeakCPUConsumption: 0.1}, "coupled releases"},
		{"bad_cpu_share", Signal{ModuleReleasesPerMonth: 0, CriticalityTier: 2, PeakCPUConsumption: 1.2}, "cpu share"},
		{"bad_tier", Signal{ModuleReleasesPerMonth: 0, CriticalityTier: 0, PeakCPUConsumption: 0.1}, "criticality tier"},
	}
	for _, tc := range cases {
		t.Run(tc.name, func(t *testing.T) {
			if _, err := Evaluate(tc.signal, ready()); err == nil || !strings.Contains(err.Error(), tc.want) {
				t.Fatalf("err=%v, want substring %q", err, tc.want)
			}
		})
	}
}

func TestAssessmentSummary(t *testing.T) {
	signal := Signal{ModuleReleasesPerMonth: 8, CoupledReleasesPerMonth: 4, PeakCPUConsumption: 0.85, CriticalityTier: 2, BlastRadiusShare: 0.2}
	a, err := Evaluate(signal, ready())
	if err != nil {
		t.Fatalf("Evaluate: %v", err)
	}
	want := "decision=split_candidate score=6 triggers=change_frequency_conflict,independent_scaling unmet="
	if got := a.Summary(); got != want {
		t.Fatalf("Summary()=%q, want %q", got, want)
	}
}

$ cd .local/checks/be-arch-gov-ch01
$ gofmt -l .
$ go vet ./...
$ go test ./internal/platform/split/ -run '^(TestEvaluateScorecard|TestEvaluateValidation|TestAssessmentSummary)$' -count=1 -v
=== RUN   TestEvaluateScorecard
=== RUN   TestEvaluateScorecard/no_trigger
    scorecard_test.go:34: summary: decision=keep_modular score=0 triggers= unmet=data_owner_named,contract_tests,independent_deploy,rollback_plan,observability
=== RUN   TestEvaluateScorecard/prepare
    scorecard_test.go:34: summary: decision=prepare score=5 triggers=change_frequency_conflict,independent_scaling unmet=contract_tests,independent_deploy,rollback_plan,observability
=== RUN   TestEvaluateScorecard/split
    scorecard_test.go:34: summary: decision=split_candidate score=6 triggers=change_frequency_conflict,independent_scaling unmet=
=== RUN   TestEvaluateScorecard/compliance
    scorecard_test.go:34: summary: decision=split_candidate score=3 triggers=fault_isolation_compliance unmet=
--- PASS: TestEvaluateScorecard (0.00s)
    --- PASS: TestEvaluateScorecard/no_trigger (0.00s)
    --- PASS: TestEvaluateScorecard/prepare (0.00s)
    --- PASS: TestEvaluateScorecard/split (0.00s)
    --- PASS: TestEvaluateScorecard/compliance (0.00s)
=== RUN   TestEvaluateValidation
=== RUN   TestEvaluateValidation/coupled_exceeds_total
=== RUN   TestEvaluateValidation/bad_cpu_share
=== RUN   TestEvaluateValidation/bad_tier
--- PASS: TestEvaluateValidation (0.00s)
    --- PASS: TestEvaluateValidation/coupled_exceeds_total (0.00s)
    --- PASS: TestEvaluateValidation/bad_cpu_share (0.00s)
    --- PASS: TestEvaluateValidation/bad_tier (0.00s)
=== RUN   TestAssessmentSummary
--- PASS: TestAssessmentSummary (0.00s)
PASS
ok  	archlab/internal/platform/split	0.283s