返回文章列表

用 Rust 从零搭一个对象存储:分块上传和校验和其实是同一件事

1210 字·9 分钟阅读
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 = 可传递的权限凭证,必须短窗口 + 小范围
 
              └─ 强一致的范围是"元数据",不是"数据量"

五条最值得记住的判断:

  1. 不可变消掉了并发更新、缓存失效、副本冲突这三个最难的问题。 把限制加在"本来就不需要的能力"上,是免费的。
  2. 分块上传和校验和是同一个结构。 "每块一个哈希 + 哈希的哈希"同时提供了校验、续传、局部读取、去重四种能力。
  3. "先写数据,后写引用"这个顺序不能反。 反了就会出现"引用指向不存在的数据",而那是永久损坏。
  4. 修复速度是持久性的真实变量。 "3 副本"不保证任何东西,保证的是"修复能在下一个故障到来前完成"。
  5. 强一致的范围由"可变部分"决定,不由"数据量"决定。 所以不可变数据 + 强一致元数据 = 强一致的读。

这五条的共同点是:它们都在利用"不可变"这一个性质,把一个原本很难的问题变简单。 而这也解释了为什么这个系统在互联网规模上如此普遍——它不是靠更强的工程能力解决问题,而是靠选择了一个让问题不存在的数据模型。

下一篇换到"缓存和回源"这个更传统的难题(CDN 边缘节点),那里没有不可变性可以依赖,一切都要靠失效策略和请求合并硬扛。