架构与系统设计 / 系统课时

接入自定义服务发现 Resolver

接入自定义服务发现 Resolver

自定义 Resolver 的职责是把注册中心状态转换成 gRPC 可消费的地址集合,而不是替负载均衡器选择某次 RPC 的目标。本课实现一个可运行的 grpc-go 适配层,并把瞬时空快照、最大陈旧时间与明确 scale-to-zero 三种情况分开处理。

学习目标

  • 实现 resolver.Builder 与 resolver.Resolver,让自定义 scheme 接入 grpc.ClientConn
  • 对注册中心快照做去重、排序和短窗口去抖,再通过 UpdateState 推送解析状态
  • 区分瞬时空快照与权威空集合,并用最大陈旧时间限制 last-known-good 的保留时间

Resolver 的职责边界

客户端访问 registry:///orders 时,registry 由 Builder 匹配,orders 是被监听的服务名。Resolver 持续订阅注册中心,把成员列表转换为 resolver.State;随后由 round_robin 等负载均衡策略维护 SubConn 并选择请求目标。Resolver 只回答“当前有哪些后端”,不负责“这一请求发给谁”。

自定义服务发现 Resolver 更新链路

实现可运行的适配层

下面用内存注册中心模拟成员变化。ScaleToZero 表示注册中心明确确认服务当前没有实例;普通空切片表示一次不确定的空快照。第一次瞬时空快照出现后开始计算 maxStale,重复空快照不会续期,因此旧地址只会保留一个受控窗口。

go
package main

import (
	"context"
	"fmt"
	"sort"
	"strings"
	"time"

	"google.golang.org/grpc"
	_ "google.golang.org/grpc/balancer/roundrobin"
	"google.golang.org/grpc/credentials/insecure"
	"google.golang.org/grpc/resolver"
)

const (
	debounceWindow = 80 * time.Millisecond
	maxStale       = 300 * time.Millisecond
)

type Snapshot struct {
	Addresses   []string
	ScaleToZero bool
}

type Registry interface {
	Watch(context.Context, string) <-chan Snapshot
}

type fakeRegistry struct {
	updates chan Snapshot
}

func newFakeRegistry() *fakeRegistry {
	return &fakeRegistry{updates: make(chan Snapshot, 8)}
}

func (f *fakeRegistry) Watch(context.Context, string) <-chan Snapshot {
	return f.updates
}

func (f *fakeRegistry) Push(addrs ...string) {
	f.updates <- Snapshot{Addresses: addrs}
}

func (f *fakeRegistry) PushScaleToZero() {
	f.updates <- Snapshot{ScaleToZero: true}
}

var reg = newFakeRegistry()

func init() {
	// scheme 必须与客户端 target 的前缀一致。
	resolver.Register(&registryBuilder{registry: reg})
}

type registryBuilder struct {
	registry Registry
}

func (b *registryBuilder) Scheme() string { return "registry" }

func (b *registryBuilder) Build(
	target resolver.Target,
	cc resolver.ClientConn,
	_ resolver.BuildOptions,
) (resolver.Resolver, error) {
	ctx, cancel := context.WithCancel(context.Background())
	r := &registryResolver{
		registry: b.registry,
		cc:       cc,
		cancel:   cancel,
	}
	go r.run(ctx, target.Endpoint())
	return r, nil
}

type registryResolver struct {
	registry Registry
	cc       resolver.ClientConn
	cancel   context.CancelFunc
	lastKey  string
	hasLast  bool
}

func (r *registryResolver) ResolveNow(resolver.ResolveNowOptions) {}

func (r *registryResolver) Close() {
	r.cancel()
}

func (r *registryResolver) run(ctx context.Context, service string) {
	updates := r.registry.Watch(ctx, service)

	var debounceTimer *time.Timer
	var debounceC <-chan time.Time
	var staleTimer *time.Timer
	var staleC <-chan time.Time
	var pending []string
	lastIsNonEmpty := false
	emptySince := time.Time{}

	stopTimer := func(t *time.Timer) {
		if t == nil {
			return
		}
		if !t.Stop() {
			select {
			case <-t.C:
			default:
			}
		}
	}
	resetTimer := func(t *time.Timer, d time.Duration) *time.Timer {
		if t == nil {
			return time.NewTimer(d)
		}
		stopTimer(t)
		t.Reset(d)
		return t
	}
	restartStaleTimer := func() {
		if emptySince.IsZero() {
			return
		}
		remaining := maxStale - time.Since(emptySince)
		if remaining <= 0 {
			remaining = time.Nanosecond
		}
		staleTimer = resetTimer(staleTimer, remaining)
		staleC = staleTimer.C
	}

	for {
		select {
		case <-ctx.Done():
			stopTimer(debounceTimer)
			stopTimer(staleTimer)
			return

		case raw, ok := <-updates:
			if !ok {
				r.cc.ReportError(fmt.Errorf("registry watch closed"))
				return
			}

			addrs := normalize(raw.Addresses)

			// 权威 scale-to-zero 必须立即撤掉旧地址。
			if raw.ScaleToZero && len(addrs) == 0 {
				stopTimer(debounceTimer)
				debounceC = nil
				stopTimer(staleTimer)
				staleC = nil
				emptySince = time.Time{}
				lastIsNonEmpty = false
				r.publish(nil)
				continue
			}

			if len(addrs) == 0 {
				stopTimer(debounceTimer)
				debounceC = nil
				r.cc.ReportError(fmt.Errorf("registry returned a temporary empty snapshot"))

				// 尚无 last-known-good 时只报告发现异常,不把“不确定的空”冒充权威空集合。
				if !lastIsNonEmpty {
					continue
				}

				if emptySince.IsZero() {
					emptySince = time.Now()
					restartStaleTimer()
					fmt.Printf(
						"resolver warning: temporary empty snapshot, keeping last good state for at most %s\n",
						maxStale,
					)
				}
				continue
			}

			// 新的非空快照先去抖;若发布成功,就取消之前的陈旧截止时间。
			stopTimer(staleTimer)
			staleC = nil
			pending = addrs
			debounceTimer = resetTimer(debounceTimer, debounceWindow)
			debounceC = debounceTimer.C

		case <-debounceC:
			debounceC = nil
			if r.publish(pending) {
				lastIsNonEmpty = true
				emptySince = time.Time{}
			} else {
				restartStaleTimer()
			}

		case <-staleC:
			staleC = nil
			emptySince = time.Time{}
			lastIsNonEmpty = false
			fmt.Println("resolver warning: last-known-good expired, publishing empty state")
			r.publish(nil)
		}
	}
}

func (r *registryResolver) publish(addrs []string) bool {
	key := strings.Join(addrs, ";")
	if r.hasLast && key == r.lastKey {
		return true
	}

	addresses := make([]resolver.Address, 0, len(addrs))
	for _, addr := range addrs {
		addresses = append(addresses, resolver.Address{Addr: addr})
	}

	err := r.cc.UpdateState(resolver.State{Addresses: addresses})
	if err != nil && len(addrs) > 0 {
		fmt.Printf("resolver update rejected: %v\n", err)
		return false
	}

	r.lastKey = key
	r.hasLast = true
	fmt.Printf("resolver update: %v\n", addrs)
	return true
}

func normalize(raw []string) []string {
	seen := make(map[string]struct{}, len(raw))
	out := make([]string, 0, len(raw))
	for _, addr := range raw {
		addr = strings.TrimSpace(addr)
		if addr == "" {
			continue
		}
		if _, ok := seen[addr]; ok {
			continue
		}
		seen[addr] = struct{}{}
		out = append(out, addr)
	}
	sort.Strings(out)
	return out
}

func main() {
	conn, err := grpc.NewClient(
		"registry:///orders",
		grpc.WithTransportCredentials(insecure.NewCredentials()),
		grpc.WithDefaultServiceConfig(`{"loadBalancingConfig":[{"round_robin":{}}]}`),
	)
	if err != nil {
		panic(err)
	}
	defer conn.Close()

	conn.Connect()
	time.Sleep(100 * time.Millisecond)

	reg.Push("127.0.0.1:50052", "127.0.0.1:50051", "127.0.0.1:50051")
	time.Sleep(200 * time.Millisecond)

	// 仅顺序变化,规范化后不会触发重复 UpdateState。
	reg.Push("127.0.0.1:50051", "127.0.0.1:50052")
	time.Sleep(200 * time.Millisecond)

	// 瞬时空快照保留旧状态;恢复后取消陈旧计时。
	reg.Push()
	time.Sleep(150 * time.Millisecond)
	reg.Push("127.0.0.1:50051", "127.0.0.1:50052", "127.0.0.1:50053")
	time.Sleep(200 * time.Millisecond)

	// 连续空状态超过 maxStale 后,撤掉 last-known-good。
	reg.Push()
	time.Sleep(500 * time.Millisecond)

	reg.Push("127.0.0.1:50051")
	time.Sleep(200 * time.Millisecond)

	// 权威 scale-to-zero 不等待 maxStale,直接传播空集合。
	reg.PushScaleToZero()
	time.Sleep(100 * time.Millisecond)
}

在已经初始化 Go module 并引入 google.golang.org/grpc 的目录中保存为 main.go。示例使用 grpc.NewClient,较旧的 grpc-go 版本应先升级,然后运行:

bash
go run .

预期输出:

text
resolver update: [127.0.0.1:50051 127.0.0.1:50052]
resolver warning: temporary empty snapshot, keeping last good state for at most 300ms
resolver update: [127.0.0.1:50051 127.0.0.1:50052 127.0.0.1:50053]
resolver warning: temporary empty snapshot, keeping last good state for at most 300ms
resolver warning: last-known-good expired, publishing empty state
resolver update: []
resolver update: [127.0.0.1:50051]
resolver update: []

示例没有真正发起 RPC,因此这些本地端口不需要监听;它验证的是注册中心事件能否按既定语义转换成 gRPC 解析状态。

正确处理空快照

去重和排序必须发生在状态比较之前,否则同一批实例只改变顺序也会触发无意义更新。去抖只用于合并短时间内连续的成员变化,窗口不宜过大,否则会延迟真实摘除。

瞬时空快照与“服务确实没有实例”必须由注册中心协议明确区分。前者可以暂存 last-known-good,但最大陈旧时间要从第一次空快照开始计算,重复空事件不能续期;权威 scale-to-zero 则直接调用 UpdateState 提交空地址集合。陈旧时间到期后同样提交空集合,避免长期把流量送往已经下线的实例。

生产实现的边界

ReportError 表示解析过程出错,UpdateState 表示解析结果发生变化,两者不能互相替代。watch 型 Resolver 可以把 ResolveNow 保持为空实现,因为注册中心事件已经主动驱动更新;如果底层发现机制需要显式刷新,则应在 ResolveNow 中触发一次重新查询。

本例把窗口压到毫秒级只是为了快速观察结果。生产环境应根据注册中心传播延迟、实例摘除 SLA 和请求超时来配置去抖与最大陈旧时间,并为 watch 断开、空快照持续时间和地址数量建立指标。成员发现留在 Resolver,连接健康与请求选择继续交给 gRPC 的连接和负载均衡层,才能避免服务发现层永久粘住旧实例。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

接入自定义服务发现 Resolver

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通