用 Rust 从零搭一个对象存储:分块上传和校验和其实是同一件事
前面几个系统都在处理"会变的数据":
时序库: 每个数据点都在追加
IM: 每条消息、每个已读位置都在变
CRDT: 同一个文档被多人同时改
调度器: 期望状态和实际状态一直在互相追对象存储处理的东西,性质正好相反:
write(key, data) ✓
read(key) ✓
delete(key) ✓
update(key, data) ✗ —— 没有这个操作
append(key, data) ✗ —— 也没有"写进去之后永不修改"听起来像一个功能上的缺失。 但它实际上是这个系统里最值钱的设计决定——因为它把分布式系统里最难的一整类问题(并发更新、缓存失效、副本冲突)几乎全部消掉了。
这篇讲的是:消掉之后,剩下的工作是什么。
第一步:不可变是核心设计,不是限制
pub struct ObjectMeta {
pub bucket: String,
/// 对象键:可以是任意字符串,包括斜杠(模拟目录)
pub key: String,
/// 大小(字节)
pub size: u64,
/// 内容哈希 —— 也是"这个对象的身份"
pub etag: String,
/// 分块列表:对象由哪些块组成,顺序如何
pub parts: Vec<PartRef>,
/// 用户自定义元数据
pub user_meta: HashMap<String, String>,
/// 创建时间,不可变
pub created_at: i64,
}
pub struct PartRef {
/// 块的哈希 —— 块的地址
pub part_hash: [u8; 32],
pub offset: u64,
pub len: u64,
}注意 ObjectMeta 里没有 updated_at,也没有 version(除了用于并发控制的乐观版本号)。 因为一个对象一旦存在就不会变——想改内容只有一个办法:写一个同名的新对象,覆盖掉旧的那个。而那个动作在语义上是"删除 + 创建",不是"修改"。
这个不可变性给了五件事,每一件都是前面某个系统的痛点:
| 能力 | 为什么不可变之后就能免费获得 |
|---|---|
| 内容去重 | 块的内容哈希就是它的地址,相同块天然一份 |
| 缓存永不失效 | 一个对象的 key + etag 一旦确定,内容永远不会变 |
| 副本无冲突 | 副本之间不存在"哪个更新"的问题——它们必须完全相同 |
| 修复无歧义 | 校验失败时,任意健康副本都是正确答案,随便挑一个覆盖 |
| 快照无成本 | "某个时刻的数据视图"就是一组不可变对象的列表 |
第四项"修复无歧义"值得单独说,因为它是"自动修复"能成立的前提:
可变的复制系统(比如一个会变的 KV):
副本 A 说值是 X,副本 B 说值是 Y
→ 谁是"正确"的?需要版本号、需要冲突解决、可能需要人工介入
不可变的对象系统:
副本 A 的块校验和不对,副本 B 的块校验和正确
→ 正确答案唯一:B。把 B 的内容拷到 A 就行。
→ 没有任何歧义,可以完全自动化不可变的代价是"修改必须写成新对象",收益是"所有副本冲突问题消失"。 而这个交易在对象存储场景里极其划算——因为这个场景的数据本来就不需要被修改(图片、视频、备份、日志归档)。把限制施加在"本来就不需要的能力"上,是免费的。
第二步:写入路径——大文件必须分块
先看单次 PUT 的问题:
上传一个 5GB 的文件:
→ 传到 4.2GB 时网络断了
→ 整个 5GB 要重传
→ 而且服务端要先收完整 5GB 才能校验(因为它要先算哈希)两个问题:重传成本太高、服务端无法增量校验。所以必须分块(multipart upload):
① initiate:客户端说"我要传一个大对象,key 是 X"
→ 服务端返回一个 upload_id
② upload part:客户端把文件切成若干块,逐块上传
→ PUT /X?partNumber=1&uploadId=...
→ 每块返回自己的 etag
③ complete:客户端提交"块列表"
→ 服务端把块按顺序拼成一个对象pub struct MultipartUpload {
pub upload_id: String,
pub bucket: String,
pub key: String,
/// 已上传的块:part_number → (etag, size)
pub parts: BTreeMap<u32, UploadedPart>,
/// 创建时间(用于清理孤儿上传)
pub created_at: i64,
}
pub struct UploadedPart {
pub part_number: u32,
/// 这一块的哈希 —— 它同时是校验依据和地址
pub etag: [u8; 32],
pub size: u64,
}分块上传的接口设计里有三个必须明确的点:
点一:块编号必须从 1 开始、连续、有序。 BTreeMap<u32, _> 而不是 HashMap——因为完成时必须按编号排序拼装,而且不能有洞(那些空编号的块没有数据)。
点二:块的边界由客户端决定,但大小有约束。 服务端必须设一个下界和上界:
impl MultipartUpload {
pub fn validate_part(&self, size: u64, cfg: &Config) -> Result<()> {
// 下界:太小会产生过多块(块的元数据开销变成负担)
// 上界:太大则失去分块的意义(重传成本高)
if size < cfg.min_part_size {
return Err(Error::PartTooSmall { size, min: cfg.min_part_size });
}
if size > cfg.max_part_size {
return Err(Error::PartTooLarge { size, max: cfg.max_part_size });
}
Ok(())
}
}为什么要设下界? 因为允许 1 字节的块,就等于允许一个 5GB 文件产生 50 亿个块。 服务端要保存所有块的元数据,这会直接压垮元数据存储。 这是"接口上的自由度必须有边界"的一个典型例子。
点三:complete 的请求必须包含"客户端认为的块列表"。 因为它提供了一个校验机会:服务端收到的块,和客户端认为上传成功的块,是不是同一批。 如果客户端漏传了第 5 块,或者服务端的第 5 块损坏了,complete 是最后一道能发现问题的关卡。
impl ObjectStore {
pub fn complete_multipart(
&mut self,
upload_id: &str,
client_parts: Vec<(u32, [u8; 32])>, // 客户端认为的 (编号, etag)
) -> Result<String> {
let upload = self.uploads.get(upload_id)?;
// ① 校验:客户端列表必须和已上传的块一一对应
for (num, etag) in &client_parts {
match upload.parts.get(num) {
None => return Err(Error::MissingPart(*num)),
Some(p) if &p.etag != etag => {
// ★ 这是最重要的一条错误
// 客户端以为传上去的是 A,服务端存的是 B
// 说明传输过程中数据被改了(网络故障、或者中间人)
return Err(Error::PartChecksumMismatch {
part_number: *num,
client: *etag,
server: p.etag,
});
}
_ => {}
}
}
// ② 拼装:把块的引用按顺序写进对象的元数据
let etag = self.assemble_object(&upload, &client_parts)?;
self.uploads.remove(upload_id);
Ok(etag)
}
}注意 ② 这一步实际上什么都没"拼"——它只是写了一份元数据(哪些块、什么顺序)。 数据块本身还在原地,对象的"拼装"是元数据层面的操作,不做任何数据拷贝。
这一点非常重要:一个由 10000 个块组成的对象,complete 的开销是 O(块数) 的元数据写入,不是 O(数据量) 的拷贝。 这也是为什么对象存储在"组装大对象"上比文件系统便宜得多——文件系统的 cat a b > c 要真的拷贝一遍数据。
把"组装"变成元数据操作,是分层存储的共同手法。 只要底层的块是不可变的,上层就可以用"引用 + 顺序"来表达任意组合——而所有涉及数据的操作都退化成修改引用(O(1)),而不是搬运数据(O(n))。
第三步:核心洞察——分块上传和校验和是同一个设计
现在到这篇最重要的一段。
看看这两件事:
① 分块上传:把文件切成块,每块独立上传、独立校验,最后拼起来
② 校验和结构:要能验证完整数据,但不希望每次校验都读全量它们需要的是同一个结构:
对象
│
┌────┴────┬────────┬────────┐
块1 块2 块3 块4
│ │ │ │
hash1 hash2 hash3 hash4 ← 每块一个哈希
└────┬────┴────────┴───────┘
│
etag = hash(hash1 ‖ hash2 ‖ hash3 ‖ hash4) ← 所有块哈希再哈希这是一个"扁平两层"的 Merkle Tree。 而它同时满足两件事:
| 需求 | 由哪一层满足 |
|---|---|
| 局部校验(只查一个块有没有坏) | 第一层(块哈希) |
| 整体校验(这个对象是不是我上传的那个) | 第二层(块哈希的哈希) |
| 断点续传(知道哪些块已经有了) | 第一层(块哈希 → 地址) |
| 并行下载校验 | 两层都要(每块校验 + 最后比 etag) |
| 跨对象去重(相同的块只存一份) | 第一层(块哈希就是地址) |
"分块上传"和"校验和"不是两个功能,是同一个结构在两个场景下的名字。
而这个结构在整个计算机系统里反复出现:
| 系统 | 块(第一层) | 整体(第二层) |
|---|---|---|
| 对象存储 | part(5~64MB) | 对象的 etag |
| 版本控制系统 | blob(文件内容) | tree/commit 的哈希 |
| 数据库页存储 | 8KB 页 + 页校验和 | B 树节点的指针链 |
| 分布式文件系统 | chunk(通常 64MB) | 文件的校验和列表 |
| 消息队列 | segment(日志段) | 段的索引 |
为什么这个结构这么普遍? 因为它解决的是"大数据的完整性验证"这个共性问题:
直接对整个文件存一个哈希:
✓ 能验证完整性
✗ 验证时必须读完全部数据(一个 100GB 文件校验要读 100GB)
✗ 发现损坏时无法定位(只知道"这个文件坏了")
✗ 无法局部重传(只能整个重传)
分成块 + 每块一个哈希 + 汇总哈希:
✓ 验证一块只需要读那一块
✗ 但要验证"这份数据是不是完整的",必须读所有块的哈希(不用读数据)注意第二行那个 ✗ 其实是一个巨大的优点: "读所有块的哈希"通常只有几百字节,而"读所有数据"是几百 GB。所以"整体校验"的成本从 O(数据) 降到了 O(块数)。
这就是 Merkle Tree 在数据完整性领域的全部价值:把验证的成本从"数据量"降到"块的数量"。
一个必须配套的设计:complete 时的"块列表"就是根哈希的承诺
impl ObjectStore {
/// 块列表来自客户端 —— 这就意味着客户端"承诺"了块的顺序和内容
fn assemble_object(&mut self, upload: &MultipartUpload, client_parts: &[(u32, [u8; 32])])
-> Result<String>
{
let mut hasher = Sha256::new();
let mut parts = Vec::new();
let mut offset = 0u64;
for (num, etag) in client_parts {
let p = upload.parts.get(num).ok_or(Error::MissingPart(*num))?;
// ★ 根哈希的输入是"块哈希的串联",不是数据本身
hasher.update(etag);
parts.push(PartRef { part_hash: *etag, offset, len: p.size });
offset += p.size;
}
let etag = hex(hasher.finalize());
// ... 写入对象元数据
Ok(etag)
}
}这里有一个非常隐蔽但重要的性质: 根哈希的输入是"块哈希的串联",所以根哈希依赖于块的内容和块的分组方式,但不依赖于块存在哪里。
结论:对象可以被移动到任何节点、任何存储介质,
只要块内容不变、分组不变,etag 就不变。
这就是为什么对象存储可以把一个对象"迁移"到另一个集群而无需重算哈希 ——
只搬数据,元数据里的 etag 完全不用改。而这个性质也让"跨集群校验"变得便宜: 两个集群要对同一个对象,不需要比数据,比块列表就行。
Merkle 结构的价值不是"更快算哈希",而是"让更大范围内的比较和验证都只需要看哈希"。 从"比较两个文件"到"比较两个集群的数据",中间隔的就是这个结构的层数。 每加一层,能一次比较的范围就大一个数量级。
第四步:块级去重——以及那个必须显式做的隐私取舍
有了块哈希当地址,去重就自然发生了:
pub struct BlockStore {
/// 块哈希 → 块在磁盘上的位置 + 引用计数
index: HashMap<[u8; 32], BlockLocation>,
}
pub struct BlockLocation {
/// 物理位置(比如文件名)
path: PathBuf,
pub size: u64,
/// ★ 引用计数:有多少个对象的 part 指向这个块
refcount: AtomicU32,
}
impl BlockStore {
/// 写一个块:如果内容已经存在,直接增加引用计数
pub fn put(&mut self, data: &[u8]) -> Result<[u8; 32]> {
let hash = sha256(data);
if let Some(loc) = self.index.get_mut(&hash) {
// ★ 去重命中:不写数据,只加引用
loc.refcount.fetch_add(1, Ordering::Relaxed);
return Ok(hash);
}
// 新块:落盘 + 建索引
let path = self.path_for(&hash);
// 用临时文件 + rename,保证"要么没有,要么完整"
let tmp = path.with_extension("tmp");
fs::write(&tmp, data)?;
fs::rename(&tmp, &path)?;
self.index.insert(hash, BlockLocation {
path,
size: data.len() as u64,
refcount: AtomicU32::new(1),
});
Ok(hash)
}
}去重带来两个直接收益:
| 场景 | 收益 |
|---|---|
| 多人上传同一个安装包 | 只存一份 |
| 同一个文件的多个备份 | 块级去重后增量极小 |
| 虚拟机镜像(大量相同块) | 压缩比常常超过 10:1 |
但跨租户去重有一个必须显式处理的隐私问题:
场景:
租户 A 上传了一个机密文件 F
租户 B 想知道 A 是否拥有文件 F:
→ B 也上传 F 的一个副本
→ 如果服务端返回"秒传"(因为去重命中了)→ B 就知道了 A 有 F这被称为"去重侧信道"。 它不需要攻击者有什么特殊权限,只需要能观察到"上传耗时"或"是否秒传"这一个比特的信息。
而它在某些场景下是真实的信息泄露:
如果 F 是一个"已知的敏感文件"(比如某个泄露数据库、某份机密报告),
那么"B 能证明 A 拥有它"本身就是泄露。三种缓解方案,各有代价:
| 方案 | 做法 | 代价 |
|---|---|---|
| 租户隔离去重域 | 每个租户一个独立的块空间 | 失去跨租户去重的收益 |
| 加密后去重 | 每租户一个密钥,加密后的密文无法跨租户比较 | 同理失去收益 |
| 只在租户内去重 | 折中:单租户内去重,跨租户不去重 | 实现简单,收益有限但足够 |
实践中大多数系统选第三种——因为去重的主要收益来自"同一个租户的重复数据"(备份、镜像、多版本),跨租户的收益小得多,而隐私代价却不小。
"这个优化会不会泄露信息"这个问题,必须在设计去重的时候就问一遍。 因为去重的本质是"用相同性来判断",而"相同性"本身就是一个可能被观察的信息。 凡是"优化"建立在"跨信任边界比较数据"上的,都要停下来想一秒。
还有一个必须回答的问题:引用计数怎么在一次操作里同时完成"数据写入"和"计数增加"。
// ✗ 错误:两个动作分开做
fn put_bad(&mut self, data: &[u8]) -> Result<[u8; 32]> {
let hash = sha256(data);
self.write_block_if_absent(&hash, data)?; // 动作 1
self.increment_refcount(&hash)?; // 动作 2
Ok(hash)
}
// 崩在两步之间:块存在,但计数是 0
// → 后续的 GC 会认为这个块"没人引用",把它删掉
// → 而实际上有对象在引用它 → 数据损坏正确的做法是让"引用"成为唯一真相,而计数是推导出来的:
// ✓ 正确:引用在对象元数据里,计数由元数据推导(或者在同一个原子操作里)
fn put(&mut self, data: &[u8], owner_object: &ObjectId) -> Result<[u8; 32]> {
let hash = sha256(data);
// 一次原子操作:块落盘(如果不存在)+ 记录"这个对象引用了这个块"
self.index.apply(BlockChange {
hash,
data: Some(data),
add_reference: owner_object.clone(),
})?;
Ok(hash)
}"计数由元数据推导"比"维护一个独立的计数器"更可靠——因为计数器是一个冗余状态,而任何冗余状态都有"和真相不同步"的风险。 GC 的正确做法是"扫描所有对象,算出哪些块被引用",而不是"相信引用计数"。计数只是用来判断"要不要做全量扫描"的一个提示。
冗余状态可以提升性能,但不能成为正确性的依据。 引用计数在最坏情况下失效(崩溃、并发),所以 GC 必须能在"计数完全不可信"的情况下仍然正确——而这一切的兜底就是"扫描全部对象的块引用"。 这个模式的另一个例子是文件系统的链接计数:它会被
fsck从目录项重建。
第五步:放置——一致性哈希不够,还要机架感知
一个块该放在哪几个节点上? 这需要三个层次的决策。
第一层:用一致性哈希确定"主位置"
pub struct PlacementRing {
/// 一致性哈希环:节点 → 虚拟节点
ring: HashRing<NodeId>,
/// 副本因子
replicas: usize,
}
impl PlacementRing {
/// 一个块的副本节点列表
pub fn nodes_for(&self, block_hash: &[u8; 32]) -> Vec<NodeId> {
// 为什么用一致性哈希而不是取模:
// 取模:加一个节点 → 几乎所有块都要搬迁(O(数据量))
// 一致性哈希:加一个节点 → 只影响 1/N 的块
self.ring.replicas_for(block_hash, self.replicas)
}
}为什么用一致性哈希,前面已经写过,这里只补充对象存储特有的一个点: 块的哈希是均匀分布的,所以不需要额外的虚拟节点来做负载均衡(这是块存储相比"按 key 做缓存"的一个优势——key 本身就是随机哈希,天然均匀)。
第二层:机架感知——副本分布必须考虑故障域
pub struct Topology {
/// 节点 → 它所在的机架
node_rack: HashMap<NodeId, RackId>,
}
impl Topology {
/// 在"尽量落在不同机架"的前提下选出 N 个节点
pub fn spread(&self, candidates: &[NodeId], n: usize) -> Vec<NodeId> {
let mut by_rack: HashMap<RackId, Vec<NodeId>> = HashMap::new();
for node in candidates {
if let Some(rack) = self.node_rack.get(node) {
by_rack.entry(*rack).or_default().push(*node);
}
}
let mut chosen = Vec::new();
let mut racks: Vec<&RackId> = by_rack.keys().collect();
racks.sort(); // 确定性排序 —— 否则每次算出来的分布都不同
// ★ 第一轮:每个机架先出一个,保证副本分在不同故障域
for rack in &racks {
if chosen.len() >= n { break; }
if let Some(nodes) = by_rack.get(*rack) {
chosen.push(nodes[0]);
}
}
// 第二轮:还不够(机架数少于副本数)就在已有机架里补
if chosen.len() < n {
for rack in &racks {
let nodes = &by_rack[*rack];
for node in nodes.iter().skip(1) {
if chosen.len() >= n { return chosen; }
chosen.push(*node);
}
}
}
chosen
}
}为什么机架感知是必须的?因为故障的相关性是不均匀的:
不做机架感知(副本可能在同一机架):
机架 1 的交换机故障 → 3 个副本全挂 → 数据丢失
概率:交换机年故障率 2% × 机架相关故障
做机架感知(副本分散在 3 个机架):
丢数据需要 3 个机架同时出问题
概率:独立故障的乘积,低好几个数量级"副本数 3"这个数字本身不保证任何东西——保证持久性的是"副本落在多少个独立的故障域里"。
注意 racks.sort() 那一行:它看起来多余,但没有它,同一个块在不同时间算出来的副本分布可能不同——因为 HashMap 的迭代顺序是随机的。
这个 bug 的后果很隐蔽: 同一个块在两次查询里落到不同节点,那么"修复"逻辑会发现副本不一致,然后无休止地"修复"(复制到新节点 + 删旧节点),浪费大量带宽。
☞ "分布的确定性"是一个容易被忽略的要求。 只要一个计算涉及哈希表的迭代顺序,它的结果就是不可复现的——而在分布式摆放、一致性哈希、修复这些场景里,不可复现就意味着"系统会自己和自己打架"。
第三层:持久性是概率,必须靠持续修复维持
"3 副本"不意味着"不会丢数据",它意味着"同时坏 3 个的概率很低"。
单盘/单节点年故障率:约 2%(保守估计)
3 副本全部故障的概率 ≈ 0.02³ = 8e-6 / 年
听起来很小。但对于 10000 个块(一个中等规模的集群):
0.02³ × 10000 ≈ 0.08 / 年 → 大约每 12 年丢一个块但这个计算有一个致命前提:副本必须始终是 3 个。
如果某个节点挂了,它的副本数是 2
在"修复完成之前",故障概率变成了 0.02² = 4e-4
→ 而这期间如果又坏一个 → 只剩 1 份 → 再坏一个就丢了
→ 而"只剩 1 份"的窗口越长,风险越高所以"修复速度"直接决定持久性。 这就是为什么必须有一个持续运行的后台修复流程:
pub struct Scrubber {
store: Arc<BlockStore>,
placement: Arc<PlacementRing>,
/// 修复限速:每秒最多复制多少字节
bandwidth_limit: usize,
}
impl Scrubber {
/// 定期扫描:检查每个块的副本数,不足就补
pub async fn scan_once(&self) -> Result<ScrubReport> {
let mut report = ScrubReport::default();
for (hash, loc) in self.store.all_blocks() {
let expected: Vec<NodeId> = self.placement.nodes_for(&hash);
let present = loc.nodes();
// ① 缺副本 → 从任意一个健康副本拷过去
for node in expected.iter().filter(|n| !present.contains(n)) {
self.repair_to(&hash, *node).await?;
report.repaired += 1;
}
// ② 多副本(因为拓扑变化)→ 删掉不在期望列表里的
for node in present.iter().filter(|n| !expected.contains(n)) {
self.remove_from(&hash, *node).await?;
report.removed += 1;
}
}
Ok(report)
}
/// 修复一个副本 —— 注意这里没有"哪个副本是对的"这个问题
async fn repair_to(&self, hash: &[u8; 32], target: NodeId) -> Result<()> {
// ★ 因为块是不可变的,任意健康副本都是正确答案
// 不需要版本比较、不需要冲突解决、不需要人工介入
let source = self.pick_healthy_replica(hash)?;
let data = self.store.read_from(source, hash)?;
// 校验:确保读出来的和期望的哈希一致
if sha256(&data) != *hash {
return Err(Error::SourceCorrupted { node: source });
}
self.store.write_to(target, hash, &data).await?;
Ok(())
}
}repair_to 里那句注释是整篇文章最值钱的一句:
因为块不可变,"哪个副本是对的"这个问题不存在。 任意一个校验通过的副本都是正确答案。
对比一下会变的复制系统: 副本 A 和 B 不一致时,你需要版本号、需要冲突解决、可能需要业务层介入。而不可变系统里,唯一的判据是"校验和对不对",而答案唯一。
修复还有一个必须限速的原因:
一个 1PB 的集群,单节点故障 → 需要复制 1PB / 副本数 的数据
不限速的后果:
修复流量占满网络 → 前台的读写请求被挤掉 → 服务不可用
而且修复本身会失败(超时)→ 反复重试 → 情况更糟
所以修复必须限速,而且要能"慢到不影响前台"。
代价是:修复窗口变长 → 持久性风险窗口变长 → 需要更多副本"修复速度"和"副本数"是可以互换的两个参数:
| 组合 | 效果 |
|---|---|
| 3 副本 + 快速修复 | 持久性好,但修复时占用带宽多 |
| 4 副本 + 慢速修复 | 持久性相同,带宽占用平摊 |
选哪个取决于你的带宽是否比磁盘贵。 云上带宽贵,所以常常选"更多副本 + 慢修复";自建机房带宽便宜,就选"少副本 + 快修复"。
分布式存储的持久性不是一个静态属性,而是一个"修复速度 vs 故障到达速度"的赛跑。 副本数给你的是一个缓冲窗口,而修复速度决定了这个窗口能不能在故障再次发生前被填满。 所以"副本数"从来不是单独配置的——它必须和修复带宽一起定。
第六步:元数据和数据分离——强一致的边界画在哪
到这里必须说清楚一件事:这个系统里有两类数据,它们的规模和一致性要求完全不同。
元数据(小、需要事务、需要强一致):
bucket 是否存在
object 的 key → etag / 块列表 / 用户元数据
multipart upload 的进行状态
数据(大、只需最终一致):
块的内容本身所以它们的存储方式也必须不同:
pub struct ObjectStore {
/// 元数据:Raft 复制的 KV —— 强一致,可以走事务
meta: RaftKv,
/// 数据:每个节点本地的块存储
blocks: NodeLocalBlockStore,
/// 摆放:块哈希 → 应该在哪些节点(本身就是从元数据推导的,可以只存规则)
placement: PlacementRing,
}关键决策:把强一致的边界画在元数据上。
impl ObjectStore {
pub fn put_object(&mut self, bucket: &str, key: &str, data: &[u8]) -> Result<String> {
// ① 先写数据(块)—— 这一步不要求事务,因为块是内容寻址的、幂等的
let chunk_hashes = self.write_chunks(data)?;
// ② 再写元数据 —— 这一步是强一致的
// 一次原子提交:把"这个 key 指向这些块"变成事实
let etag = self.meta.compare_and_swap_object(bucket, key, ObjectMeta {
size: data.len() as u64,
etag: compute_etag(&chunk_hashes),
parts: chunk_hashes,
created_at: now(),
user_meta: Default::default(),
})?;
Ok(etag)
}
}这个顺序(先写数据,后写元数据)是必须的,而且它的正确性依赖于不可变性:
如果崩在 ① 和 ② 之间:
块已经存在,但没有对象引用它们
→ 它们是不可达的垃圾,等 GC 回收
→ 没有损坏,只浪费了空间 ✓
如果反过来(先写元数据,再写数据):
元数据说"这个对象有这些块",但块还没写完
→ 客户端来读 → 读不到数据 → 报错
→ 而且这个错误状态会一直持续到块写完
→ 如果写块失败了 → 元数据永远指向不存在的块 → 数据永久损坏 ✗"先写不可变的数据,再写指向它的引用"这个顺序,是所有"指针 + 数据"分离的系统的通用规则。 它和版本控制里"先写对象,再更新引用"是同一个顺序(而且理由完全一样)。
这个分离带来的最重要的能力是:
"读到一个对象的元数据,就一定能读到它的数据。"
为什么?因为数据是不可变的——不存在"我读到元数据的时候,数据正在被修改"。 一旦元数据说"这个对象由这些块组成",那些块就永远存在(至少在 GC 之前),而且内容永远不变。
所以读路径可以完全不加锁、不需要版本检查、不需要重试。 这是不可变性在这些"引用 + 数据"系统里最直接的收益。
第七步:读路径——Range 请求必须能 O(1) 定位
对象存储的一个核心能力是"只读一个对象的某一段"(HTTP 的 Range: bytes=1000-2000)。
impl ObjectStore {
pub fn read_range(&self, bucket: &str, key: &str, start: u64, end: u64) -> Result<Vec<u8>> {
let meta = self.meta.get_object(bucket, key)?;
// ① 定位涉及哪些块 —— 这是一次二分查找
// 因为 parts 是按 offset 有序的
let first = meta.parts.partition_point(|p| p.offset + p.len <= start);
let last = meta.parts.partition_point(|p| p.offset < end).saturating_sub(1);
let mut out = Vec::with_capacity((end - start) as usize);
// ② 只读涉及的那几块,而且只读块内的相关片段
for part in &meta.parts[first..=last] {
let nodes = self.placement.nodes_for(&part.part_hash);
// 从任意一个健康副本读
let data = self.blocks.read_from_any(&nodes, &part.part_hash)?;
// ★ 只取这个块里属于 [start, end) 的那一段
let local_start = start.saturating_sub(part.offset) as usize;
let local_end = ((end - part.offset).min(part.len)) as usize;
out.extend_from_slice(&data[local_start..local_end]);
}
Ok(out)
}
}这里有两个性能关键点:
点一:partition_point 让"哪个块覆盖这段字节"变成 O(log 块数)。 而不是"遍历所有块"。
点二:只有跨越边界的首尾两块需要"部分读取"。 中间那些块是全读的。
但更重要的是点三:完全不需要读的块,一个字节都不碰。
读一个 10GB 对象的 1KB range:
需要读的数据:最多 2 个块(首尾),实际传输约 1KB
不需要读:其余 9998 个块(约 10GB)
如果不做块级定位(比如只有一个 10GB 的块):
需要读:10GB(然后只返回 1KB)这就是第三层价值:分块不只是为了"校验"和"续传",它同时是"局部读取"的基础。 而这三种能力的实现,用的都是同一个"块列表 + 每块哈希"的结构。
零拷贝下发
impl ObjectStore {
/// 直接把块文件发给客户端 —— 不经过用户态缓冲区
pub async fn stream_block(&self, hash: &[u8; 32], range: Option<(u64, u64)>,
out: &mut TcpStream) -> Result<()> {
let path = self.blocks.path_for(hash);
let file = File::open(&path)?;
match range {
None => {
// 整个文件:用 sendfile
// 数据从页缓存直接到网卡,不经过用户态
sendfile(&mut out, &file)?;
}
Some((start, end)) => {
// 文件的一段:用 mmap + writev
let mmap = unsafe { Mmap::map(&file)? };
out.write_all(&mmap[start as usize..end as usize])?;
}
}
Ok(())
}
}注意"块"这个单位是零拷贝能高效工作的原因之一: 因为一个块是几千字节到几十兆的连续数据,所以一次 sendfile 就能搞定,不需要在用户态做任何拼接。
如果数据是"碎片的"(比如一个对象由几千个 4KB 的小片段组成),那么零拷贝就无从下手——每发一个片段都要一次系统调用,开销就回来了。 所以"分块"这个设计除了前面说的那些好处,还顺带让零拷贝变得可行。
很多优化不是独立的——它们互相成就。 分块让校验变便宜、让续传变便宜、让 range 读取变便宜,最后还让零拷贝变得可行。 而这一切都源于同一个决定:把大对象表示成"一串不可变块的引用"。
第八步:服务端怎么验证签名——以及预签名 URL 为什么危险
前面写过"客户端怎么对请求签名"。而从服务端看,同一个协议的验证侧有几个必须做对的地方。
impl SignatureVerifier {
pub fn verify(&self, req: &Request, secret: &[u8]) -> Result<Principal> {
// ① 从 Authorization 头里取出:access_key / 日期 / 签名 / 签名覆盖的头列表
let auth = parse_authorization(req.header("authorization")?)?;
// ② ★ 时间窗口检查 —— 防重放
let skew = (now() - auth.timestamp).abs();
if skew > self.max_clock_skew { // 通常 15 分钟
return Err(Error::RequestExpired { skew });
}
// ③ 重建 canonical request
let canonical = self.canonical_request(req, &auth.signed_headers)?;
// ④ 用同样的算法算出期望签名,然后比较
let expected = hmac_sha256(secret, &canonical);
// ★ 必须用"恒定时间比较",不能用 ==
// 普通的字符串比较会在第一个不同的字节处返回
// → 攻击者可以通过测量响应时间逐字节猜出签名
if !constant_time_eq(&expected, &auth.signature) {
return Err(Error::SignatureMismatch);
}
Ok(Principal { access_key: auth.access_key })
}
}四处细节,每一处都是"协议实现"里最容易漏的:
细节一:时间窗口。 签名里带了时间戳,服务端必须拒绝太旧和太"未来"的。没有这个检查,一个被截获的请求可以被永久重放。 而"太未来"的检查同样必要——否则攻击者可以签一个 10 年后过期的请求。
细节二:恒定时间比较。 这是一个真实的时序攻击面:== 在第一个不同的字节就返回,攻击者通过测量响应延迟可以逐字节地试出正确签名。 60 微秒和 65 微秒的差别,在本地网络里是完全可以测量的。
细节三:签名必须覆盖 Host 头。 否则同一个签名可以被用在不同的域名上——而这两个域名可能属于不同的租户(或者在同一个服务商的不同区域)。
细节四:签名必须覆盖 body 的哈希。 否则请求体可以在传输中被替换。而这正是"预签名 URL"风险的核心:
pub struct PresignedUrl {
/// 签名实际上是一个"授权凭证",被编码进了 URL
pub url: String,
/// 有效期
pub expires_in: Duration,
}预签名 URL 的本质是"把签名能力外包给一个 URL"。 它的风险点:
| 风险 | 原因 |
|---|---|
| URL 会被记录 | 浏览器历史、代理日志、CDN 日志、Referer 头 |
| URL 会共享 | "把这个链接发给同事"是最常见的用法 |
| 权限无法收回 | 签出去之后,在过期之前无法撤销 |
| 有效期只能靠时间 | 没有"用一次就失效"的原生语义 |
所以预签名 URL 的实践规则是:
✓ 有效期尽量短(几分钟,而不是几小时)
✓ 只签"必要的操作"(只读就不要签写权限)
✓ 尽量签具体的对象,而不是前缀(避免一个 URL 能访问整个目录)
✗ 不要把预签名 URL 写进日志(它等同于一个临时密码)"把权限编码成一个可传递的字符串"这个设计,天生就有一个矛盾:它的目的是被人传递,而被人传递就意味着可能被不该看到的人看到。 所以这类机制的正确用法永远是"缩短窗口 + 缩小范围",而不是"相信它不会被泄露"。
第九步:一致性模型——"不可变 + 强一致元数据"等于强一致的读
对象存储的一致性模型历史上经历过一次大的变化,而原因很值得拆开看。
早期(很多对象存储服务):
写新对象 → 强一致(读得到)
覆盖写 → 最终一致(可能读到旧版本)
列目录 → 最终一致(可能看不到刚写的对象)
2020 年之后(主流服务):
全部强一致为什么"覆盖写"和"列目录"曾经做不到强一致?因为它们本质上是在修改共享状态:
覆盖写:
A 上传 new.txt(内容 v2)
B 同时上传 new.txt(内容 v3)
→ 谁赢?两个请求都返回成功,但最终只有一个版本存在
→ 在"最终一致"的模型里,不同的副本可能在某个时刻持有不同版本
列目录:
需要一个"这个前缀下有哪些 key"的索引
而这个索引必须在所有键空间分片上保持一致
→ 分布式下的索引维护 + 一致性 = 昂贵而"不可变数据 + 强一致元数据"这个组合,恰好把这两个问题都解决了:
| 问题 | 为什么不再是问题 |
|---|---|
| 覆盖写的一致性 | 元数据是强一致的 → "当前这个 key 指向哪个 etag"是唯一确定的 |
| 读到旧版本 | 元数据强一致 → 读到的 etag 一定是最新的那个 |
| 块的内容不一致 | 块不可变 → 一旦元数据指向它,内容就确定 |
| 列目录不一致 | 目录本质上也是元数据(前缀索引)→ 走同一套强一致存储 |
关键洞察:
一个系统的一致性取决于"可变的那些部分",而不是"数据的总量"。 对象存储的数据量可能几百 PB,但可变的只有元数据里那几十亿条索引——只要把这一层做成强一致,整个系统对用户就是强一致的。
这就是"不可变 + 强一致元数据"这两个设计的组合威力: 它们把"强一致性的作用范围"从"全部数据"缩小到了"元数据"。而前者是几百 PB,后者是几 TB——差了五个数量级。
所以当有人问"你们这个存储是强一致的吗",正确的回答是继续问清楚:
✓ 写后读(read-after-write)一致吗?
✓ 覆盖写之后读到的是新版本吗?
✓ 列目录能立刻看到刚写的对象吗?
✓ 跨区域呢?而这四个问题的答案可以完全不同。 "强一致"作为一个不加限定的形容词,在分布式存储里几乎没有信息量。
结论
把这个系统拆开之后,它的形状是:
┌─ 不可变是核心:写出新对象 = 删除 + 创建
数据模型 ──────┴─ 拿到的五件事:去重、缓存不失效、副本无冲突、修复无歧义、快照免费
┌─ 先写数据(块,幂等),再写元数据(引用,强一致)
写入路径 ──────┼─ multipart:客户端定块边界,服务端验每块哈希
└─ complete 是"引用组装",不做数据拷贝(O(块数),不是 O(数据量))
┌─ 每块一个哈希 + 哈希的哈希 = 扁平两层 Merkle
校验与分块 ────┼─ 同一结构同时满足:局部校验、整体校验、断点续传、并行校验、去重
└─ 去重必须显式回答隐私问题(跨租户去重是侧信道)
┌─ 一致性哈希定位 + 机架感知分散故障域 + 确定性排序
放置 ──────────┼─ 持久性是概率,靠持续修复维持
└─ 修复速度是持久性的真实变量(不限速会打垮前台)
┌─ 强一致边界画在元数据上
元数据与数据 ───┴─ "读到元数据就一定能读到数据"(因为数据不可变)
┌─ 按 offset 二分定位块(O(log 块数))
读路径 ────────┴─ 分块让零拷贝可行(连续块 → sendfile)
┌─ 时间窗口防重放
签名验证 ──────┼─ 恒定时间比较防时序攻击
└─ 预签名 URL = 可传递的权限凭证,必须短窗口 + 小范围
└─ 强一致的范围是"元数据",不是"数据量"五条最值得记住的判断:
- 不可变消掉了并发更新、缓存失效、副本冲突这三个最难的问题。 把限制加在"本来就不需要的能力"上,是免费的。
- 分块上传和校验和是同一个结构。 "每块一个哈希 + 哈希的哈希"同时提供了校验、续传、局部读取、去重四种能力。
- "先写数据,后写引用"这个顺序不能反。 反了就会出现"引用指向不存在的数据",而那是永久损坏。
- 修复速度是持久性的真实变量。 "3 副本"不保证任何东西,保证的是"修复能在下一个故障到来前完成"。
- 强一致的范围由"可变部分"决定,不由"数据量"决定。 所以不可变数据 + 强一致元数据 = 强一致的读。
这五条的共同点是:它们都在利用"不可变"这一个性质,把一个原本很难的问题变简单。 而这也解释了为什么这个系统在互联网规模上如此普遍——它不是靠更强的工程能力解决问题,而是靠选择了一个让问题不存在的数据模型。
下一篇换到"缓存和回源"这个更传统的难题(CDN 边缘节点),那里没有不可变性可以依赖,一切都要靠失效策略和请求合并硬扛。