Rust 所有权模型与 服务发现 的思考
起因
前几天在改一个内部服务发现的客户端,原先是用 Go 写的,注册和注销靠 defer,简单粗暴但能用。后来因为要和主服务放在同一个 Rust 进程里,就顺手用 Rust 重写了一遍。第一反应当然是照抄:注册完返回一个 guard,Drop 的时候自动注销,多优雅。
结果写出来才发现,事情没那么直接。Rust 的所有权模型确实在逼你想清楚一些东西,但服务发现这玩意儿是分布式的,编译器管不到网络那头。下面是我踩完一圈之后的一些零碎想法,不是什么架构方法论,更多是“原来这里也得考虑所有权”。
注册中心拿到的不是所有权
Rust 里一个值只有一个所有者,别人想用只能借。服务发现其实很像:服务实例的所有权在进程自己手里,注册中心拿到的只是一条记录,一条“弱引用”。进程活着,心跳还在,这条记录就有效;进程挂了,心跳停了,记录就该被回收。
问题在于,Rust 的借用检查器是编译期的,服务发现的“借用检查”只能靠 TTL 和心跳在运行期做。你没法让 etcd 在编译期保证“这个 key 一定会在实例退出前删掉”。所以 Drop 里注销只能算尽力而为,真正兜底的是租约。
我一开始写了个特别理想化的 Lease:
pub struct Lease {
key: String,
registry: Arc<Registry>,
shutdown: CancellationToken,
}
impl Drop for Lease {
fn drop(&mut self) {
let registry = self.registry.clone();
let key = self.key.clone();
self.shutdown.cancel();
if let Ok(handle) = tokio::runtime::Handle::try_current() {
handle.spawn(async move {
if let Err(err) = registry.deregister(&key).await {
tracing::warn!(%key, %err, "deregister failed");
}
});
}
}
}
这里有个坑:Drop 是同步的,不能 await。我一开始直接在里面调 tokio::spawn,本地测试没问题,后来有个测试在 runtime 外面构造了 Lease,一 drop 就直接 panic。换成 Handle::try_current() 之后好歹不炸了,但也就是“不炸”而已,runtime 关闭的时候该丢的注销请求还是会丢。
所以别把 Drop 当成事务。它更像是一个提醒:你确实想过要释放,但释放成没成功,得看日志。
生命周期标注管不到服务清单
客户端这边要缓存服务端返回的 endpoint 列表,不然每次调用都去查注册中心,延迟受不了。我一开始写了个特别朴素的缓存:
struct EndpointCache {
inner: RwLock<HashMap<String, Cached>>,
}
#[derive(Clone)]
struct Cached {
endpoints: Arc<Vec<Endpoint>>,
fetched_at: Instant,
}
看起来没问题,Arc 共享,RwLock 保护,克隆出去就能用。但用着用着发现,调用方拿到 Arc<Vec<Endpoint>> 之后可能会一直攥着不放,比如放在某个长连接对象里。等缓存过期、注册中心里的实例已经换了一轮,它手里还是旧列表。
这其实和 Rust 里的引用有点像:&'a T 不能活得比 T 长,服务清单的“引用”也不该活得比 TTL 长。但 Rust 里编译器会拦你,服务发现里只能靠约定。后来我干脆不在对外接口里返回 Arc<Vec<Endpoint>>,改成返回一个带过期时间的快照,调用方每次用之前自己判断一下:
pub struct Snapshot {
endpoints: Arc<Vec<Endpoint>>,
expires_at: Instant,
}
impl Snapshot {
pub fn get(&self) -> Option<&[Endpoint]> {
if Instant::now() < self.expires_at {
Some(&self.endpoints)
} else {
None
}
}
}
这玩意儿不优雅,但至少把“什么时候该重新解析”这件事从调用方的良心变成了类型的一部分。
Arc 和锁解决不了共享生命周期
多个 resolver 共享一个 registry client,肯定得 Arc。我一开始图省事,直接 Arc<RwLock<HashMap<String, Vec<Endpoint>>>>,读的时候拿读锁,发现过期了就在锁里 await 去刷新。编译器不拦,因为 RwLockReadGuard 在 await 期间确实还活着,但运行起来就是灾难:一个 resolver 在等网络,其他 resolver 全卡在锁上。
后来改成先拿快照,释放锁,再去 await:
async fn resolve(&self, service: &str) -> Result<Arc<Vec<Endpoint>>> {
let cached = {
let cache = self.cache.read().await;
cache.get(service).cloned()
};
if let Some(cached) = cached {
if cached.fetched_at.elapsed() < self.ttl {
return Ok(cached.endpoints);
}
}
let fresh = self.registry.lookup(service).await?;
let value = Cached {
endpoints: Arc::new(fresh),
fetched_at: Instant::now(),
};
self.cache.write().await.insert(service.to_owned(), value.clone());
Ok(value.endpoints)
}
Arc 解决的是“谁都能读”,不是“读的时候别人不能改”。服务发现里真正难的是后者:你希望刷新的时候别把正在用的旧列表干掉,又希望旧列表别永远不释放。这事儿 Rust 的类型系统帮不上太多,还是得靠 TTL 和快照。
滚动更新像一次所有权转移
服务升级的时候,新实例先注册,健康检查通过,流量切过去,旧实例再注销。顺序反了就会出现一段空窗。这个流程在 Rust 里没有直接对应,但很像 mem::replace:先把新值放进去,再把旧值拿出来,中间不能有“两个都没有”的时刻。
注册中心没有借用检查器,所以只能靠 grace period。K8s 的 preStop 里 sleep 几秒,本质上就是在给这个“所有权转移”留缓冲。我在客户端里也加了一个小逻辑:从注册中心拿到实例列表后,不立刻把旧连接全关掉,而是等新连接建立成功、发过一轮请求之后,再慢慢淘汰旧的。代码不复杂,但如果没有这个,滚动更新期间总会有几个请求打到已经 SIGTERM 的实例上。
最后
Rust 的所有权模型没有直接教你怎么做服务发现,但它给了一个挺好的隐喻:每个注册项都得有明确的 owner,得有确定的回收路径。如果代码里说不清“谁负责注销”“什么时候算过期”,线上就一定会留下僵尸实例。
我现在写服务发现相关的代码,会先问自己三个问题:这个 Lease 归谁持有?它 drop 的时候注销请求发不出去怎么办?调用方拿到 endpoint 列表之后能活多久?这三个问题在 Rust 里是类型和生命周期,在分布式系统里就是租约和 TTL。说起来是一回事,做起来嘛,还是得靠日志和告警兜底。
评论
还没有评论。
发表评论
提交后评论将经过自动审核,审核通过后公开展示。