架构与系统设计 / 系统课时
接入自定义服务发现 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 只回答“当前有哪些后端”,不负责“这一请求发给谁”。

实现可运行的适配层
下面用内存注册中心模拟成员变化。ScaleToZero 表示注册中心明确确认服务当前没有实例;普通空切片表示一次不确定的空快照。第一次瞬时空快照出现后开始计算 maxStale,重复空快照不会续期,因此旧地址只会保留一个受控窗口。
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(®istryBuilder{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 := ®istryResolver{
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 版本应先升级,然后运行:
go run .预期输出:
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 的连接和负载均衡层,才能避免服务发现层永久粘住旧实例。