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
}
}
}
这些数据有几个特点:
- 数据结构不固定,不需要复杂 SQL 查询。
- 主要通过 Key 读取和覆盖写入。
- 单个 Value 可能很大,达到几 MB。
- 用户频繁修改同一个 Key。
- 读写流量都很高,而且具有突发性。
他们最初使用 CouchDB,后来迁移到 SSDB。
SSDB 是一个使用 Redis 协议的磁盘型 Key-Value 数据库。
但是 SSDB 有两个问题:
- 项目逐渐停止维护,继续使用存在维护风险。
- 只能运行在单节点,扩展能力有限,大数据量时延迟也会恶化。
于是他们开始寻找替代品。
二、为什么不直接使用 Redis、PostgreSQL、S3?
这是文章中很有价值的一部分。
他们评估了不少方案:
| 方案 | 遇到的问题 |
|---|---|
| ScyllaDB | 大 Blob 性能不理想,资源开销较大 |
| PostgreSQL | BYTEA 存储大 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 Shard | 16 Shards |
|---|---|---|
| 纯 HSET | 7,740 | 25,324 |
| HSET + HGET | 14,227 | 29,538 |
| 纯 HGET | 67,128 | 70,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
这个优化不只是节省磁盘空间。
还会带来连锁收益:
- SQLite 数据页减少。
- Page Cache 可以容纳更多实际数据。
- WAL 写入量减少。
- 磁盘 I/O 减少。
- 读取时需要传输的数据量减少。
有个细节值得注意:
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 |
| 每节点 CPU | 4 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 迁移过来的?
这部分也值得学习。
他们没有直接停掉旧系统、切换新系统,而是分三个阶段:
- 新业务先接入
Kite Terminal 新功能直接使用 Blobasaur,不影响旧业务。
- 双写 + 历史数据迁移
旧业务同时写入 SSDB 和 Blobasaur。
后台迁移历史数据,读取优先 Blobasaur,失败或未命中时回退 SSDB。
- 正式切换
双写运行一个月,没有发现数据差异,最终关闭 SSDB。
客户端主要改动是从单节点 Redis Client 换成 Redis Cluster Client。
这是一个很标准的渐进式迁移策略。
对于生产数据库替换,我也更倾向于这种方式,而不是一次性切换。
十一、我建议重点研究的几个技术细节
如果你打算深入这个项目,我建议按照下面的顺序:
| 优先级 | 技术点 | 学习价值 |
|---|---|---|
| 1 | SQLite WAL + 多文件分片 | 理解 SQLite 并发瓶颈 |
| 2 | Group Commit | 高吞吐写入优化 |
| 3 | Multi-probe Consistent Hashing | 分布式数据分片 |
| 4 | Zstd 压缩 | 存储空间与 I/O 优化 |
| 5 | Pending Map + Tombstone | 异步写入一致性 |
| 6 | Incremental Vacuum | SQLite 空间管理 |
| 7 | Redis Cluster Protocol | 分布式客户端路由 |
项目源码:
Blobasaur
Rust + SQLite + Redis Protocol
开源
注意:项目采用 AGPL-3.0 许可证,如果考虑集成到商业产品或修改后提供网络服务,需要认真评估许可证义务。
十二、我的最终评价
我认为这篇文章最值得记住的是三个观点:
1. 不要因为 SQLite 是单文件数据库,就认为它无法水平扩展。
单个 SQLite 文件确实存在写入限制,但多个独立 SQLite 文件可以构成一个并行写入系统。
2. 性能优化应该针对实际瓶颈,而不是盲目更换数据库。
Zerodha 没有因为吞吐量不够就上更复杂的分布式数据库,而是通过分片和批量提交解决了最核心的问题。
3. 专用存储系统往往比通用数据库更高效。
他们不需要 SQL 查询、复杂事务、丰富的数据结构,只需要 KV、TTL、压缩和高吞吐。
因此,他们选择 SQLite 作为存储引擎,自己实现上层分布式能力。
我还有一个特别想强调的地方:
Blobasaur 不是证明 SQLite 可以替代所有数据库,而是证明当你明确知道自己需要什么时,可以用一个非常简单、成熟的组件,组合出一个性能很强的专用系统。
这也是我认为这篇文章最值得软件架构师学习的地方。