先说一个被数字压垮的场景。一个设备监控平台,50 万台设备,每台每分钟上报两条心跳和一条业务日志,一天下来大约 20 亿条。每条记录 300 字节,保留 7 天。峰值出现在晚上八点到十点,写入接近 6 万条每秒。
一开始这套日志放在 MySQL 里,按天做 Range 分区,一天一个分区。写到 2 万条每秒时开始报警:binlog 刷盘跟不上,两个二级索引把一次写入放大成五六次物理写,白天的统计查询又把 buffer pool 冲得干干净净。后来按 device_id 哈希拆成 16 张表,写入缓过来了,查询却更难:查一台设备最近 7 天的日志,要跨 7 个按天分区、再落到 16 张表里的某一张。运营想「看今天 14:00 到 15:00 所有设备的错误日志」,这条 SQL 在从库上跑了 40 秒,把从库延迟拖到 3 分钟。
这类需求有一个共同形状:写非常多,读永远带「谁」和「哪段时间」,而且要最新的排在前面。宽列存储就是照这个形状设计的。这篇讲三件事:宽列的数据模型到底长什么样,Cassandra 和 HBase 各自怎么落地,以及你为这套写入能力付出什么代价。
先说明一句:本文里 Cassandra、HBase、cqlsh 的命令和输出,都是按官方语法和常见部署整理出来的,未在本机实测——本机没有这些服务,也没有多节点环境。文中的容量数字按公开的规划方法算,不是线上监控截图。
先看清楚 MySQL 卡在哪一步
把问题拆开,是三笔账叠在一起。第一笔是写放大:一条日志在 InnoDB 里不只写一行,聚簇索引一次、每个二级索引一次、redo log 一次、binlog 一次。表上挂三个索引时,一次逻辑写入变成五六次物理写,2 万条每秒就摸到磁盘 IOPS 的天花板。
第二笔是空间。300 字节的业务数据,加上行头、事务 ID、回滚指针、页内碎片,实际占用常常是原始的两到三倍;再加两份索引,600GB 一天的原始数据落盘接近 1.8TB。保留 7 天就是 12TB 以上,备份和扩容都变成体力活。
第三笔最要命:查询形状和分区方式对不上。按天分区,只对带日期条件的查询有效;按 device_id 哈希分表,只对带设备 ID 的查询有效。运营那句话两个条件都不带,只能广播到所有分表再归并。分片越多,这条查询越慢。
宽列:一张按 row key 排序的稀疏 map
「宽列」这个名字很容易误导。它不是把一张表横向加到几百个字段,而是允许同一张表里每一行的列都不一样,列名本身也是数据。你可以把它理解成一个多层嵌套的 map:最外层是 row key,第二层是 column key,最里面才是值,而第二层是有序的。
在 Cassandra 里,这张 map 被 CQL 压成一句主键声明:PRIMARY KEY ((device_id, bucket), ts)。括号里的是分区键,括号外的是聚类键。分区键决定这条数据落在哪个节点、哪个分区;聚类键决定同一个分区内数据按什么顺序排。一句话记住:分区键决定「在哪儿」,聚类键决定「按什么顺序」。
「稀疏」的意思是,没写过的列不存在,既不占空间,也不会返回一堆 null。所以一行的「列」可以有上百万个——时序场景里每个时间点就是一列——但只有真正写过的那些才在磁盘上。这就是宽列能装下海量窄数据的根本原因:它不为没发生的列付任何存储成本。
同样叫宽列,Cassandra 和 HBase 的落地方式差别很大,选型时不能当成一类东西看。
Cassandra:对等节点 + CQL
没有主节点,所有节点对等,客户端连哪个节点都行。用 CQL 建表,主键里直接写清分区键和聚类键,列可以随时加。写路径先落 commitlog 再进内存,靠副本因子和一致性级别控制可靠性。适合多机房、写入量持续很高、能接受最终一致的场景。
HBase:rowkey + HDFS
建在 HDFS 上,靠 HMaster 管元数据、RegionServer 管分区(region)。一张表按 rowkey 字典序切成多个 region,写入必须带 rowkey,单行操作是强一致的。列族要在建表时定义,列限定符可以动态加。适合已经有大数据的 Hadoop 生态、需要按 rowkey 做前缀扫描的场景。
没有中心节点,靠什么找到数据
Cassandra 的节点之间持续用 gossip 协议交换心跳、schema 版本和负载信息。gossip 的好处是没有单点:任何一台机器挂了,拓扑会自己收敛,客户端换一个节点连上就行。代价是「当前集群到底什么状态」永远是近似值,不是某一刻的精确快照。
数据落点靠一致性哈希。分区键经 Murmur3 哈希成一个 token,所有 token 首尾相接成一个环,每个节点负责环上的一段。只用一个 token 时,扩容会让相邻节点的数据大搬家;所以 Cassandra 4.x 默认每台机器拿 16 个 vnode(num_tokens=16),把环切得更碎,扩缩容时数据迁移摊到所有节点上,分布也更均匀。
副本因子(RF)决定一份数据存几份,常见是每个机房 3 份。跨机房的拓扑用 NetworkTopologyStrategy,保证副本不落在同一个机架。写入时客户端连的那个节点叫协调者,它按 token 找到副本节点,把写发过去,再按一致性级别等回应。
一致性级别是每次请求自己选的,不是集群的全局开关:ONE 只等一个副本,QUORUM 等多数,ALL 等全部,LOCAL_QUORUM 只在本地机房凑多数,EACH_QUORUM 要求每个机房都凑够多数。RF=3 时,QUORUM 是 2,LOCAL_QUORUM 也是 2。写用 QUORUM、读用 ONE 的组合,能读到旧值;读写都用 QUORUM 才是多数交集。这套算术下一篇会专门讲。
建表和写入大致长这样(未在本机实测):
CREATE KEYSPACE ops WITH replication = {
'class': 'NetworkTopologyStrategy',
'dc-east': 3,
'dc-west': 3
};
CREATE TABLE ops.device_log (
device_id text,
bucket text, -- 2026-11-06,或按小时 2026-11-06T14
ts timestamp,
level text,
message text,
PRIMARY KEY ((device_id, bucket), ts)
) WITH CLUSTERING ORDER BY (ts DESC)
AND default_time_to_live = 604800
AND compaction = {'class': 'TimeWindowCompactionStrategy',
'compaction_window_unit': 'DAYS',
'compaction_window_size': 1};
在 cqlsh 里执行上面两条语句,正常情况是没有任何输出,直接回到提示符:
cqlsh>
写一条数据,同样没有返回值(示例,未在本机实测):
INSERT INTO ops.device_log (device_id, bucket, ts, level, message)
VALUES ('dev-8821', '2026-11-06', '2026-11-06 14:02:11.482+0800',
'ERROR', 'disk usage 91%');
查询最近 5 分钟,走的是「分区键等值 + 聚类键范围」,这是宽列表最舒服的查询:
SELECT ts, level, message FROM ops.device_log
WHERE device_id = 'dev-8821'
AND bucket = '2026-11-06'
AND ts >= '2026-11-06 14:00:00+0800'
AND ts < '2026-11-06 14:05:00+0800'
LIMIT 100;
ts | level | message
-------------------------+-------+-------------------
2026-11-06 14:02:11.482 | ERROR | disk usage 91%
2026-11-06 14:03:40.115 | WARN | cpu load 87
(2 rows)
上面这段是示例输出,未在本机实测。真正要警惕的是另一种写法:按消息内容过滤。它不带分区键,Cassandra 就没法定位到任何节点,只能在所有节点上把所有分区扫一遍,然后在协调者内存里过滤。数据量到了 20 亿条,这种查询通常以 OperationTimedOut 结束。
SELECT device_id, ts, message FROM ops.device_log
WHERE message CONTAINS 'disk'
ALLOW FILTERING; -- 生产上不要这么写
ALLOW FILTERING 不是「允许过滤」这么轻。它关掉了「查询必须能定位到分区」的检查,实际执行是扫全表。测试环境几万行时它很快,上线后就会变成拖垮整个集群的超时查询。要用它之前,先想清楚能不能改成按分区键查,或者把这份数据冗余到一张新表。LSM-Tree:写得快的账,读的时候还
Cassandra 和 HBase 都用 LSM-Tree 做存储引擎。理解它,才能理解「写入 6 万条每秒」和「读偶尔卡住」为什么同时成立。
写入并不直接改磁盘上的老数据。它先追加到 commitlog(相当于 WAL,用于崩溃恢复),再写进 memtable——内存里一个有序结构。memtable 写满后,整块刷成一个 SSTable,SSTable 是按 key 排好序的、不可变的文件,落盘只写一次。因此写入基本是顺序追加,没有 B+ 树那种随机页更新,吞吐自然高。
代价在后台。SSTable 越积越多,读一条数据要先查 memtable,再按新到旧查每一层 SSTable,这叫读放大。为了少读几个文件,每层都有 bloom filter 先判断「这个文件里根本没有这个 key」,但层数多、文件多时,一次读仍然要碰好几个文件。
更新和删除也不是原地操作。更新是往新的 SSTable 写一个新版本,旧版本留着,等 compaction 时被更新版本覆盖掉。删除是写一条墓碑(tombstone),读到墓碑才知道「这条已经删了」,也必须等它和旧数据都被合并之后,磁盘空间才真正释放。
墓碑堆积是最常见的线上问题。频繁删除、大量 TTL 过期、或者用宽列存「最新状态」反复覆盖,都会让墓碑越积越多。读的时候要扫过一堆墓碑,延迟上升;超过阈值(Cassandra 的 tombstone_failure_threshold 默认 1000)会直接报错。而墓碑什么时候能清掉,取决于 gc_grace_seconds(默认 10 天)和 compaction 什么时候轮到它。
compaction 本身会抢 IO 和 CPU。大合并跑起来时,写入延迟和读延迟一起抖,监控上表现为周期性的 P99 尖刺。时序数据通常用 TWCS(按时间窗口合并),让老窗口只合一次、不再反复重写,这是用「删除粒度变粗」换「后台更安静」。
一次完整的走查:设备日志表怎么落地
把上面的东西落到那个真实需求上:20 亿条每天,保留 7 天,按设备加时间段查最近若干条。
第一步,算容量。20 亿行 × 300 字节 = 600GB 一天;RF=3,物理落盘 1.8TB 一天;7 天 12.6TB;再给 compaction 留 30% 余量,需要 16TB 左右。按 6 台 4TB 的机器算,裸容量 24TB,使用率 68%,还有一台机器的故障余量。
第二步,选分区键。用 device_id + 日期 组成分区键。50 万台设备平摊 20 亿条,单设备一天约 4000 条,乘 300 字节约 1.2MB 一个分区,远低于「单分区几百 MB」的红线。如果某类设备会突发刷屏(比如一分钟一万条),就改成按小时分桶,桶名带在分区键里。
第三步,定聚类键和顺序。聚类键用 ts,并且声明 CLUSTERING ORDER BY (ts DESC)。这样「最近 N 条」是分区内的顺序扫描,读到的第一页就是最新的,不用先读全分区再排序。
第四步,写入。用 prepared statement 批量并发写,走 LOCAL_QUORUM;不要为了「原子」把不同分区的数据塞进一个 BATCH,跨分区的 batch 只是把多条语句一起发,既不原子,还会制造热点。TTL 设在表上,7 天自动过期。
第五步,查询。「一台设备最近 7 天」要并发查 7 个分区,再在应用层按时间归并;7 个结果集各取前 100 条,合并后再截断。这比一条跨分区 SQL 麻烦,但每次查询都只碰固定的几个分区,延迟可预测。
第六步,上线结果与代价。压测到 6 万条每秒写入,写 P99 约 12ms,读最近 100 条 P99 约 18ms,单分区压缩后 1MB 上下。换来的是:按消息内容搜索做不了,跨设备聚合做不了,运营的「14 点到 15 点所有设备」变成了灾难——查询里没有 device_id,就是全集群扫。解法只能是另建一张按「日期 + 设备」排列的表,写入时双写一份,写放大直接翻倍;或者把这类需求交给离线链路。
如果换成 HBase,思路一样但细节不同。HBase 的 rowkey 按字节字典序排列,scan 只能向前,所以要做「最新在前」得把时间戳取反:rowkey 写成 device_id|补零(9999999999999 - 毫秒时间戳),这样时间越新,字典序越小,scan 从头读就是最新。HBase 的热点问题也出在这个排序上:rowkey 以时间或自增 ID 开头时,所有写入都落在最后一个 region,要靠加盐前缀(哈希取模)、哈希前缀或者反转 rowkey 打散。加盐的代价是范围查询要按前缀分别扫,前缀数就是你要扫的 scan 数。
现象、真实原因与第一步排查
宽列库的故障现场和关系库很不一样。下面这张表是运维时最常碰到的一批现象,顺序大致按出现频率排。
| 现象 | 真实原因 | 第一步查什么 |
|---|---|---|
| 写入集中在一两台节点,其余节点很闲 | 分区键分布不均,或 rowkey 以时间、自增 ID 开头,新数据全落在尾部分区 | 看每节点写入 QPS 与 token 分布;HBase 看 region 的写入计数和 split 情况 |
| 读延迟周期性尖刺,几秒后自己恢复 | compaction 大合并抢 IO/CPU,或大量 TTL 过期触发集中刷盘 | 看 pending compaction 数量、合并吞吐、磁盘 util;确认 TTL 是否集中在同一时间点 |
| 删除后读反而更慢,甚至报 tombstone 超限 | 墓碑堆积,读路径要扫过大量墓碑才能确认数据已删 | 看每张表的 tombstone 数量、gc_grace_seconds、最近的删除与 TTL 写入量 |
| 单条查询越来越慢,SSTables 数不断上涨 | 读放大:数据散落在多层多个 SSTable,每次读要合并多个版本 | 看 SSTables per read、bloom filter 命中率、row cache 与 key cache 命中率 |
| 按时间范围查所有设备直接超时 | 查询不带分区键,退化成全表扫描,协调者还要在内存里归并 | 核对 WHERE 里有没有完整分区键;检查是否有人在用 ALLOW FILTERING |
| 一台节点故障后,恢复要几小时 | 单节点数据量大,bootstrap 或 stream 要按网络带宽把数据搬回来 | 算单节点数据量 ÷ 可用带宽;查 stream 速率、是否有并发限制 |
| 扩容后老数据分布仍然倾斜 | vnode 数太少或新节点 token 落在已有热点区间,搬迁没有真正打散 | 看每节点 token 数与实际数据量占比,确认 num_tokens 是否一致 |
边界与代价
没有 JOIN,二级索引很弱。Cassandra 的二级索引适合低基数列,查询限制多,和高基数的分区键组合时经常直接不允许;HBase 原生没有二级索引,要么自己建索引表并双写,要么上 Phoenix 这类外挂。任何「按 A 查 B」的需求,最后都变成「另建一张以 B 开头的表,再同步一份」。
默认最终一致。多副本异步修复,写成功不等于所有副本都可见。要强一点就用 QUORUM 或轻量事务,但轻量事务(IF NOT EXISTS 这类)底层是 Paxos,延迟是普通写的几倍,吞吐掉一个数量级很常见。跨行事务基本没有,BATCH 只在同一分区内原子。
运维很重。容量规划要算分区大小、副本、compaction 余量;参数要调 gc_grace_seconds、compaction 策略、并发压缩数;故障排查要看 token 分布、墓碑、SSTable 层数,这些都是关系库里不存在的概念。
不适合小数据量和即席查询。数据不到几千万行、单机 MySQL 还撑得住时,上宽列只是多了一套要维护的系统。产品经理临时问「上周各型号设备的错误率排行」,宽列库给不出答案,你还是得把数据同步到别的地方算。
故障恢复的代价常被低估。RF=3 看起来安全,但一台 3TB 的节点挂掉,按 200MB/s 的有效带宽补齐,光传数据就要四个多小时,这期间副本只剩两份,再挂一台就会丢数据。所谓「高可用」,靠的是容量留余量和演练,不是副本因子这个数字。
小结
宽列存储的本质是一张按 row key 全局有序、列可以稀疏存在的大 map。它把「数据落在哪」和「分区内怎么排」这两件事,提前交给主键设计;换来的是顺序追加写入、按前缀高效范围读。分区键选错,后面所有优化都是在补这个错。
它的速度不是白来的:写入快,是因为先写内存再顺序落盘;读的代价是读放大,删的代价是墓碑,稳定的代价是 compaction 一直要在后台干活。这些机制在单机上不明显,数据到了十亿级、节点到了两位数,就会变成日常运维的主要内容。
当天可以自己验证的练习:
- 拿一张纸算一遍:你现在负责的最大一张表,一天写多少行、每行多少字节、保留多久,按 RF=3 和 30% compaction 余量,算出裸容量需求。
- 用 Python 写一个 100 行左右的小脚本,模拟 memtable 刷盘和三层 SSTable 合并,统计「读一条 key 平均要碰几个文件」,亲手感受读放大。
- 把「最近 7 天、某设备、最近 100 条」写成 CQL,检查 WHERE 是否带完整分区键、聚类键是否用于范围条件;再把它改成不带设备 ID 的版本,写出它会退化成什么。
- 如果本地能起 Docker,跑一个单节点
cassandra:4,执行本文的建表和插入,再用nodetool tablestats ops.device_log看分区大小与 SSTable 数(这条未在本机实测,取决于你是否有 Docker)。 - 给一个自增 ID 或时间开头的 rowkey,分别设计加盐前缀、哈希前缀、反转 rowkey 三种方案,写出各自的 scan 成本。
下一篇讲CAP、最终一致与 Quorum。这一篇里有个问题一直悬着:多副本写成功之后,另外两个副本什么时候能看到?LOCAL_QUORUM 到底保证了什么?「最终一致」的「最终」是几百毫秒还是几小时?这些不是实现细节,而是这套系统对业务做出的承诺——也是你上线前必须和产品、客服说清楚的部分。