https://zerodha.tech/blog/high-performance-distributed-blob-storage/

Zerodha 的工程团队做了一件看起来有点反常识的事情:

他们没有选择 Redis、PostgreSQL、ScyllaDB 或者专业对象存储,而是用 SQLite 构建了一套高性能、分布式 Blob Storage 系统。

项目叫 Blobasaur,已经在生产环境替代了原来的 SSDB。

核心成绩

  • 生产环境 p99 延迟:2 ms
  • 16 分片 HSET ops/s:25,324
  • 平均压缩比例:11 倍
  • 当前生产集群:3 节点

以上数据来自 Zerodha 官方工程文章,性能测试和生产数据应当区分看待。

我觉得这篇文章最值得学习的不是 SQLite 有多快,而是它展示了一种很实用的架构思路:

把一个成熟的嵌入式数据库,通过分片、批量写入、压缩和集群路由,改造成专用的分布式存储服务。

下面拆开讲。

一、他们到底要解决什么问题?

Zerodha 是印度的证券交易平台,旗下 Kite 有约 2000 万用户。

用户可以自定义交易界面,例如:

  • 多个股票图表的布局。
  • 技术指标模板。
  • 图形绘制数据。
  • 用户工作区配置。
  • 各种 UI 偏好设置。

这些数据大部分是 JSON,大小从几 KB 到几 MB。

例如:

{
  "user_id": "12345",
  "workspace": {
    "charts": [
      {
        "symbol": "NIFTY",
        "interval": "5m",
        "indicators": ["EMA", "RSI"]
      }
    ],
    "layout": {
      "columns": 2,
      "rows": 2
    }
  }
}

这些数据有几个特点:

  1. 数据结构不固定,不需要复杂 SQL 查询。
  2. 主要通过 Key 读取和覆盖写入。
  3. 单个 Value 可能很大,达到几 MB。
  4. 用户频繁修改同一个 Key。
  5. 读写流量都很高,而且具有突发性。

他们最初使用 CouchDB,后来迁移到 SSDB。

SSDB 是一个使用 Redis 协议的磁盘型 Key-Value 数据库。

但是 SSDB 有两个问题:

  • 项目逐渐停止维护,继续使用存在维护风险。
  • 只能运行在单节点,扩展能力有限,大数据量时延迟也会恶化。

于是他们开始寻找替代品。

二、为什么不直接使用 Redis、PostgreSQL、S3?

这是文章中很有价值的一部分。

他们评估了不少方案:

方案遇到的问题
ScyllaDB大 Blob 性能不理想,资源开销较大
PostgreSQLBYTEA 存储大 Blob 的性能和空间效率不理想
YugabyteDB功能太复杂,不是专门针对 Blob 优化
RocksDB大 Blob 写入吞吐不符合需求
Ceph运维复杂,资源需求高
SeaweedFS覆盖写入导致空间膨胀,TTL 和元数据管理不够理想
S3 / MinIO小对象请求延迟和高频写入成本不理想
原始文件系统原子写入、批处理、TTL、inode 等问题都要自己解决

这里有个重要的认识:

通用数据库和对象存储,并不一定适合所有存储场景。

比如 S3 很适合存储图片、视频、备份文件。

但 Zerodha 的场景是:

  • 每秒成千上万次读写。
  • 大量小型 JSON。
  • 同一个 Key 反复覆盖。
  • 需要精确的 Key 级 TTL。
  • 希望毫秒级响应。

这就和传统对象存储的使用场景不太一样。

他们实际上需要的是一个专门的 KV Blob Store。

三、核心架构:SQLite + 多级分片

这是整篇文章最重要的技术部分。

首先要理解一个 SQLite 的限制:

WAL 模式下,允许多个读操作并发,但同一个数据库文件仍然只能有一个写事务同时执行。

假设只有一个 SQLite 数据库:

单 SQLite 文件

         多个客户端
       GET / SET / HSET
             |
             v
        SQLite WAL
   [并发 Reader] [单 Writer]
             |
             v
     写入需要竞争同一个写锁

读并发能力不错,但写入存在串行瓶颈。

Zerodha 的解决方法非常简单:一个 SQLite 文件不够,就拆成多个 SQLite 文件。

例如拆成 16 个:

单机 16 分片架构

           客户端请求
               |
               v
         一致性哈希路由
     根据 Key 决定落在哪个 Shard
               |
               v
  Shard 1   Shard 2   ...   Shard 16
  Writer    Writer    ...   Writer
  SQLite    SQLite    ...   SQLite

每个分片有自己的 SQLite 文件、独立写入任务和读取连接池。

这样就相当于在一台机器上创建了 16 个独立的写入通道。

每个 SQLite 文件仍然只能有一个 Writer,但 16 个文件可以同时写入。

1. 一致性哈希分片

每个 Key 通过哈希算法决定存储位置。

概念上:

fn get_shard(key: &str, shard_count: usize) -> usize {
    hash(key) % shard_count
}

这是普通取模的简化示意,Blobasaur 实际采用的是 multi-probe consistent hashing(一致性哈希)。

为什么不直接取模?

假设:

  • 4 个分片,100 万条数据。
  • 扩展到 5 个分片。

普通取模:

shard = hash(key) % 4

变成:

shard = hash(key) % 5

几乎所有 Key 都可能重新分布,理论上约 80% 的 Key 需要迁移。

一致性哈希则只需要移动约 20% 的数据,也就是新分片应该承担的那部分。

这对大型存储系统非常重要。

2. Group Commit:批量写入

这是第二个关键优化。

假设有 100 个客户端同时写入:

普通方式:

BEGIN
INSERT
COMMIT

BEGIN
INSERT
COMMIT

BEGIN
INSERT
COMMIT
...

每条数据都单独提交事务,事务开销很大。

Blobasaur 的方式:

多个客户端
    |
    v
有界写入队列
    |
    v
Writer Task
    |
    v
收集一批写操作
    |
    v
BEGIN IMMEDIATE
    |
    +-- INSERT 1
    +-- INSERT 2
    +-- INSERT 3
    +-- ...
    +-- INSERT 50
    |
    v
COMMIT

原本 50 次事务提交,现在只需要一次。

这叫 Group Commit(组提交)。

有两个好处:

  • 减少事务提交的固定开销。
  • 减少 WAL 写入及同步操作的频率。

同时,队列有容量限制,避免流量突然增加时无限占用内存。

3. 读写分离

SQLite WAL 模式本身就支持 Reader 和 Writer 并发。

因此 Blobasaur 对读写采用不同的处理方式:

  • 写入:进入专门的 Writer 队列。
  • 读取:直接从只读连接池读取。
  • 每个 Shard 独立管理读写。

读操作不需要等待正常的写入事务完成(仍需遵守 SQLite 的锁和快照规则)。

4. 性能到底提升了多少?

文章做了一组比较:

测试环境:16 核笔记本、64 个并发连接、64 KiB JSON、100,000 个 Key、batch_size=50,数据目录使用 tmpfs。

测试场景1 Shard16 Shards
纯 HSET7,74025,324
HSET + HGET14,22729,538
纯 HGET67,12870,884

单位:ops/s。

结果:

  • 写入吞吐提升 3.3 倍。
  • 混合读写吞吐提升约 2.1 倍。
  • 纯读取吞吐变化不大。

为什么读取提升不明显?

因为 WAL 本身已经允许多个 Reader 并发,读取不是原来最主要的瓶颈。

这个实验很好地证明了:SQLite 的性能瓶颈不一定是 SQLite 本身,而可能是单数据库文件的写锁竞争。

不过要注意,这组实验使用 tmpfs,主要测试数据库锁竞争、CPU 和事务开销,不等于真实 SSD 上的端到端性能,也不是 16 台机器的集群性能。

四、第二个杀手锏:Zstd 压缩

他们发现自己的数据几乎都是 JSON。

而 JSON 有一个特点:重复文本非常多。

例如:

{
  "user_id": "123",
  "chart_type": "candlestick",
  "symbol": "NIFTY",
  "chart_type": "candlestick",
  "symbol": "BANKNIFTY"
}

字段名、结构、重复字符串都非常适合压缩。

Blobasaur 支持:

  • Zstd
  • LZ4
  • Gzip
  • Brotli

生产环境选择 Zstd。

真实生产数据压缩效果

  • 平均数据(约 11 倍压缩):原始 63.6 KiB,压缩后 5.5 KiB
  • P99 数据(约 16 倍压缩):原始 935 KiB,压缩后 59.3 KiB

这个优化不只是节省磁盘空间。

还会带来连锁收益:

  1. SQLite 数据页减少。
  2. Page Cache 可以容纳更多实际数据。
  3. WAL 写入量减少。
  4. 磁盘 I/O 减少。
  5. 读取时需要传输的数据量减少。

有个细节值得注意:

SQLite 的默认 Page Size 是 4 KiB。

63.6 KiB 的数据原本大约占 16 个页面,压缩到 5.5 KiB 后,大约只需要 2 个页面。

这对缓存命中率有直接帮助。

五、TTL 和 SQLite 空间回收

这一部分我觉得尤其值得做数据库开发的人学习。

Blobasaur 的表结构很简单:

CREATE TABLE blobs (
    key TEXT PRIMARY KEY,
    data BLOB,
    created_at INTEGER NOT NULL,
    updated_at INTEGER NOT NULL,
    expires_at INTEGER,
    version INTEGER NOT NULL DEFAULT 0
);

CREATE INDEX idx_expires_at
ON blobs(expires_at)
WHERE expires_at IS NOT NULL;

有两个值得关注的设计。

1. TTL 不需要单独的存储系统

每条记录直接记录过期时间:

key         = user:123
data        = {...}
expires_at  = 1790000000

读取的时候:

SELECT data
FROM blobs
WHERE key = ?
AND (
    expires_at IS NULL
    OR expires_at > ?
);

后台任务再负责清理已经过期的数据。

这样做有个好处:

逻辑过期和物理删除分离。

即使后台清理还没有执行,用户也无法读取已经过期的数据。

另外,TTL 索引使用了部分索引:

WHERE expires_at IS NOT NULL

没有设置 TTL 的记录不需要进入这个索引,节省索引空间。

2. SQLite 删除数据,文件为什么不变小?

这是 SQLite 很经典的一个问题。

假设数据库原来有:

database.db = 10 GB

删除了 8 GB 数据。

你可能以为文件会变成 2 GB。

实际上很可能仍然是:

database.db = 10 GB

为什么?

SQLite 删除记录后,释放的页面通常会进入 FreeList(空闲页列表),留待后续写入复用,而不是立即归还给操作系统。

Blobasaur 通过以下方式处理:

PRAGMA auto_vacuum = INCREMENTAL;

然后定期执行增量 Vacuum。

文章还提到:

PRAGMA wal_checkpoint(TRUNCATE);

因为在 WAL 模式下,要真正处理数据库文件的空间回收,还需要考虑 WAL Checkpoint。

这告诉我们一个重要事实:

SQLite 适合高频覆盖写入,但必须把数据库空间回收纳入日常运维。

不能只关注 INSERT、UPDATE、DELETE 的性能。

六、异步写入:性能与一致性的权衡

Blobasaur 还有一个可选功能:

async_write = true

普通同步写入:

客户端 SET
    |
    v
SQLite 提交事务
    |
    v
返回 OK

异步写入:

客户端 SET
    |
    v
进入内存队列
    |
    v
立即返回 OK
    |
    v
后台批量写入 SQLite

显然,第二种方式响应更快。

但是有一个非常容易忽略的问题。

假设:

SET user:123 "new"
GET user:123

SET 已经返回 OK,但后台 SQLite 事务还没提交。

此时 GET 如果直接查询 SQLite,就可能读到旧数据。

这就是 Read-your-writes consistency(读己之写一致性)问题。

他们的解决方案是增加一个内存 Pending Map:

              写入队列
                  |
                  v
              Pending Map
                  |
                  v
               SQLite

GET / HGET / EXISTS / TTL
                  |
                  v
          先检查 Pending Map
                  |
             有则返回
             没有则查 SQLite

还有一个更隐蔽的问题:

DEL user:123
GET user:123

如果 DEL 还没有提交,GET 可能读到 SQLite 里的旧值。

因此 Pending Map 还需要记录 Tombstone(删除标记)。

这也是分布式存储、缓存和异步写入系统中经常遇到的问题。

异步并不只是把写操作丢到队列里,还必须考虑:

  • 写后读。
  • 删除后读。
  • EXISTS。
  • TTL 查询。
  • 队列满时的行为。
  • 进程异常退出。

这部分实现非常值得研究。

七、如何扩展到多台服务器?

前面讲的是单机 16 个 SQLite 分片。

但是如果一台机器的 CPU、内存、磁盘已经到极限怎么办?

Blobasaur 实现了 Redis Cluster 协议。

它采用两级路由:

两级分片架构

       Client(Redis Cluster Client)
                  |
                  v
       第一层:集群级分片
       CRC16(key) % 16384
        Node 1   Node 2   Node 3
                  |
                  v
       第二层:节点内部 Sharding
        Node 1   Node 2   Node 3
       (每个节点多个 SQLite)

第一层:

CRC16(key) % 16384

Redis Cluster 把整个 Key 空间划分成 16384 个 Hash Slots。

每台服务器负责其中一部分。

第二层:

每台服务器内部再通过一致性哈希,把数据分配到多个 SQLite 文件。

如果客户端把请求发送到了错误的节点,服务器会返回:

MOVED <slot> <host>:<port>

客户端根据提示重新请求正确的节点。

节点之间通过 Gossip 机制发现彼此。

不过有个重要限制:

目前集群还没有实现在线 Slot Rebalancing 和自动故障转移。

也就是说:

  • Slot 分配通过配置静态管理。
  • 节点故障后没有自动 Failover。
  • 节点扩缩容还需要人工参与。

所以它虽然实现了 Redis Cluster 协议,但不能简单理解成已经拥有 Redis Cluster 全部成熟的高可用运维能力。

八、生产环境表现

文章给出了实际生产环境的数据:

Zerodha 当前生产部署

指标数值
服务器节点3
每节点 CPU4 vCPU
每节点内存8 GB
交易时段整体 P99~2 ms

各命令 P99 延迟

命令延迟
HSET约 2 ms
HGET约 1.4 ms
HDEL通常低于 1 ms

生产环境 P50 为 250~550 μs。统计范围为交易时段 09:00~15:30。

这组数据很有说服力。

3 台普通配置的服务器,就可以支撑他们的高频用户偏好存储业务。

但也要注意,这是特定负载、特定数据分布和特定硬件条件下的结果,不代表随便部署三台 4 核服务器就能达到同样性能。

九、他们是如何从 SSDB 迁移过来的?

这部分也值得学习。

他们没有直接停掉旧系统、切换新系统,而是分三个阶段:

  1. 新业务先接入

Kite Terminal 新功能直接使用 Blobasaur,不影响旧业务。

  1. 双写 + 历史数据迁移

旧业务同时写入 SSDB 和 Blobasaur。

后台迁移历史数据,读取优先 Blobasaur,失败或未命中时回退 SSDB。

  1. 正式切换

双写运行一个月,没有发现数据差异,最终关闭 SSDB。

客户端主要改动是从单节点 Redis Client 换成 Redis Cluster Client。

这是一个很标准的渐进式迁移策略。

对于生产数据库替换,我也更倾向于这种方式,而不是一次性切换。

十一、我建议重点研究的几个技术细节

如果你打算深入这个项目,我建议按照下面的顺序:

优先级技术点学习价值
1SQLite WAL + 多文件分片理解 SQLite 并发瓶颈
2Group Commit高吞吐写入优化
3Multi-probe Consistent Hashing分布式数据分片
4Zstd 压缩存储空间与 I/O 优化
5Pending Map + Tombstone异步写入一致性
6Incremental VacuumSQLite 空间管理
7Redis Cluster Protocol分布式客户端路由

项目源码:

Blobasaur

Rust + SQLite + Redis Protocol

开源

注意:项目采用 AGPL-3.0 许可证,如果考虑集成到商业产品或修改后提供网络服务,需要认真评估许可证义务。

十二、我的最终评价

我认为这篇文章最值得记住的是三个观点:

1. 不要因为 SQLite 是单文件数据库,就认为它无法水平扩展。

单个 SQLite 文件确实存在写入限制,但多个独立 SQLite 文件可以构成一个并行写入系统。

2. 性能优化应该针对实际瓶颈,而不是盲目更换数据库。

Zerodha 没有因为吞吐量不够就上更复杂的分布式数据库,而是通过分片和批量提交解决了最核心的问题。

3. 专用存储系统往往比通用数据库更高效。

他们不需要 SQL 查询、复杂事务、丰富的数据结构,只需要 KV、TTL、压缩和高吞吐。

因此,他们选择 SQLite 作为存储引擎,自己实现上层分布式能力。

我还有一个特别想强调的地方:

Blobasaur 不是证明 SQLite 可以替代所有数据库,而是证明当你明确知道自己需要什么时,可以用一个非常简单、成熟的组件,组合出一个性能很强的专用系统。

这也是我认为这篇文章最值得软件架构师学习的地方。