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

处理 DNS 与动态地址更新

处理 DNS 与动态地址更新

DNS 记录发生变化,不等于运行中的 gRPC Channel 会立即看到新 Endpoint。本课以 gRPC-Go 1.83.2 和本地 CoreDNS 为例,把 DNS 查询、Resolver State、负载均衡与连接状态拆开验证,说明扩容为何可能滞后,以及连接失败如何促使重新解析。

学习目标

  • 解释 DNS 地址如何进入 Resolver State 并成为可选 Endpoint
  • 区分 DNS 数据更新、Resolver 重新解析和连接进入 READY 三个时刻
  • 用可控实验观察扩容与实例替换的可见性

从 DNS 到可选 Endpoint

对 dns:///grpc-demo.test:50051 这类目标,DNS 解析只是第一层。Resolver 把地址集合发布给 gRPC,负载均衡器再为这些地址维护子连接;只有满足负载均衡策略并达到可用状态的连接,才会真正参与 RPC 选取。

DNS 变化到 gRPC Endpoint 可见的链路

这里最容易误判的是 TTL。以 gRPC-Go 1.83.2 的 DNS Resolver 为例,成功解析后并不会仅因为 DNS TTL 到期就主动按 TTL 轮询;后续重新解析依赖 ResolveNow 等触发,并受最小解析间隔限制,默认最小间隔为 30 秒。因此,DNS TTL 到期不等于 Channel 立即刷新地址。不同语言和版本的 Resolver 策略可能不同,排障时应以实际客户端实现为准。

用本地 DNS 建立实验

实验使用 Go 1.25、gRPC-Go 1.83.2 和 CoreDNS 1.14.6。A、B、C 三个后端都运行标准 gRPC Health 服务;客户端启用 round_robin 并打印每次 RPC 的真实 peer 地址。以下命令假定在支持 Bash、Docker 和 127.0.0.0/8 本地回环地址的环境中执行。

创建 go.mod:

text
module dns-lab

go 1.25

require google.golang.org/grpc v1.83.2

这是模块配置,执行 go mod tidy 时会解析依赖并生成 go.sum。

创建 server.go:

go
package main

import (
    "flag"
    "log"
    "net"

    "google.golang.org/grpc"
    "google.golang.org/grpc/health"
    healthpb "google.golang.org/grpc/health/grpc_health_v1"
)

func main() {
    listen := flag.String("listen", "127.0.0.2:50051", "listen address")
    flag.Parse()

    lis, err := net.Listen("tcp", *listen)
    if err != nil {
        log.Fatal(err)
    }

    server := grpc.NewServer()
    hs := health.NewServer()
    hs.SetServingStatus("", healthpb.HealthCheckResponse_SERVING)
    healthpb.RegisterHealthServer(server, hs)

    log.Printf("health server listening on %s", *listen)
    log.Fatal(server.Serve(lis))
}

预期结果:

text
<NO_OUTPUT>

后续执行 go build -o health-server server.go 成功时通常没有标准输出,并生成 ./health-server。

创建 client.go:

go
package main

import (
    "context"
    "fmt"
    "log"
    "time"

    "google.golang.org/grpc"
    _ "google.golang.org/grpc/balancer/roundrobin"
    "google.golang.org/grpc/credentials/insecure"
    healthpb "google.golang.org/grpc/health/grpc_health_v1"
    "google.golang.org/grpc/peer"
    grpcdns "google.golang.org/grpc/resolver/dns"
)

func main() {
    // 仅为实验缩短 ResolveNow 触发后的最小重解析间隔,不应作为生产调优手段。
    grpcdns.SetMinResolutionInterval(time.Second)

    cc, err := grpc.NewClient(
        "dns://127.0.0.1:1053/grpc-demo.test:50051",
        grpc.WithTransportCredentials(insecure.NewCredentials()),
        grpc.WithDefaultServiceConfig(
            `{"loadBalancingConfig":[{"round_robin":{}}]}`,
        ),
    )
    if err != nil {
        log.Fatal(err)
    }
    defer cc.Close()

    client := healthpb.NewHealthClient(cc)
    for i := 1; i <= 80; i++ {
        ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
        var p peer.Peer
        _, err := client.Check(
            ctx,
            &healthpb.HealthCheckRequest{},
            grpc.Peer(&p),
            grpc.WaitForReady(true),
        )
        cancel()

        if err != nil {
            fmt.Printf("%02d -> error: %v\n", i, err)
        } else if p.Addr != nil {
            fmt.Printf("%02d -> %s\n", i, p.Addr.String())
        }
        time.Sleep(500 * time.Millisecond)
    }
}

预期结果:

text
客户端持续执行 80 次健康检查;成功 RPC 会打印实际命中的后端地址。

创建 CoreDNS 配置 Corefile:

text
.:53 {
    hosts /data/hosts {
        ttl 1
        reload 1s
    }
    errors
}

创建初始 hosts:

text
127.0.0.2 grpc-demo.test
127.0.0.3 grpc-demo.test

启动三个后端和 DNS:

bash
go mod tidy
go build -o health-server server.go

./health-server -listen 127.0.0.2:50051 >a.log 2>&1 &
A_PID=$!
./health-server -listen 127.0.0.3:50051 >b.log 2>&1 &
B_PID=$!
./health-server -listen 127.0.0.4:50051 >c.log 2>&1 &
C_PID=$!

docker run -d --rm --name grpc-dns \
  -p 127.0.0.1:1053:53/udp \
  -v "$PWD/Corefile:/Corefile:ro" \
  -v "$PWD/hosts:/data/hosts:ro" \
  coredns/coredns:1.14.6 -conf /Corefile

预期输出:

text
<CONTAINER_ID>

前面的构建和后台启动通常没有标准输出;最后一条命令返回实际容器 ID。

另开终端执行:

bash
go run client.go

预期开始阶段只会看到 A、B 交替出现,起始顺序可能不同:

text
01 -> 127.0.0.2:50051
02 -> 127.0.0.3:50051
03 -> 127.0.0.2:50051
04 -> 127.0.0.3:50051
...

观察扩容为何可能滞后

客户端运行期间,把 C 加入 DNS:

bash
cat > hosts <<'EOF'
127.0.0.2 grpc-demo.test
127.0.0.3 grpc-demo.test
127.0.0.4 grpc-demo.test
EOF
sleep 2

预期结果:

text
<NO_OUTPUT>

命令成功时没有标准输出。此时 CoreDNS 已能返回 C,但运行中的 Channel 仍可能只命中 A、B,因为 ttl 1 只影响 DNS 响应的 TTL,不能主动唤醒 gRPC Resolver。grpcdns.SetMinResolutionInterval(time.Second) 也只是缩短已经触发重新解析后的限流间隔,并不会把 Resolver 变成每秒轮询 DNS 的定时器。

用连接失败触发重新解析

为了让现象更明确,先把 DNS 切换为只保留 C,再停止当前 Channel 已知的 A、B。现有子连接失效后,gRPC 会产生重新解析请求;本实验把最小解析间隔设为 1 秒,因此 Resolver 可以较快得到只包含 C 的新地址集合,随后 round_robin 为 C 建立可用连接。

bash
cat > hosts <<'EOF'
127.0.0.4 grpc-demo.test
EOF
sleep 2
kill "$A_PID" "$B_PID"

预期结果:

text
<COUNT> -> 127.0.0.4:50051
<COUNT> -> 127.0.0.4:50051
...

<COUNT> 取决于执行切换的时机;从 DNS 更新到 RPC 再次成功之间也可能短暂出现等待或错误。

清理实验环境:

bash
kill "$C_PID" 2>/dev/null || true
docker rm -f grpc-dns >/dev/null 2>&1 || true

预期结果:

text
<NO_OUTPUT>

生产环境避免地址滞后

滚动发布时应一起设计旧实例从 DNS 移除的时点、优雅下线窗口、现有连接生命周期、Resolver 重解析行为和 RPC Deadline。只改 DNS 后立刻杀掉旧实例,可能把解析延迟直接暴露为 UNAVAILABLE 或等待。

如果实例列表变化很频繁,或扩容必须快速被客户端看到,应优先评估能主动推送地址更新的服务发现机制,例如自定义 Resolver 或 xDS。继续使用 DNS 时,则把“DNS 已变更”“Resolver 已更新”“新连接已 READY”作为三个独立检查点。

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

目录与阅读设置

阅读设置

17

记录一个想法

处理 DNS 与动态地址更新

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

登录哪都通