江湖上流传的谷歌三宝是什么？GFS，MapReduce，还有一个很重要

江湖传说永流传&＃xff1a;谷歌技术有"三宝"&＃xff0c;GFS、MapReduce和大表&＃xff08;BigTable&＃xff09;&＃xff01;

谷歌在03到06年间连续发表了三篇很有影响力的文章&＃xff0c;分别是03年SOSP的GFS&＃xff0c;04年OSDI的MapReduce&＃xff0c;和06年OSDI的BigTable。SOSP和OSDI都是操作系统领域的顶级会议&＃xff0c;在计算机学会推荐会议里属于A类。SOSP在单数年举办&＃xff0c;而OSDI在双数年举办。

那么这篇博客就来介绍一下GFS&＃xff0c;MapReduce&＃xff0c;BigTable。

谷歌技术"三宝"之谷歌文件系统

题记&＃xff1a;初学分布式文件系统&＃xff0c;写篇博客加深点印象。GFS的特点是使用一堆廉价的商用计算机支撑大规模数据处理。

虽然"The Google File System " 是03年发表的老文章了&＃xff0c;但现在仍被广泛讨论&＃xff0c;其对后来的分布式文件系统设计具有指导意义。然而&＃xff0c;作者在设计GFS时&＃xff0c;是基于过去很多实验观察的&＃xff0c;并提出了很多假设作为前提&＃xff0c;这等于给出了一个GFS的应用场景。所以我们自己在设计分布式系统时&＃xff0c;一定要注意自己的应用场景是否和GFS相似&＃xff0c;不能盲从GFS。

GFS的主要假设如下&＃xff1a;

1. GFS的服务器都是普通的商用计算机&＃xff0c;并不那么可靠&＃xff0c;集群出现结点故障是常态。因此必须时刻监控系统的结点状态&＃xff0c;当结点失效时&＃xff0c;必须能检测到&＃xff0c;并恢复之。
2. 系统存储适当数量的大文件。理想的负载是几百万个文件&＃xff0c;文件一般都超过100MB&＃xff0c;GB级别以上的文件是很常见的&＃xff0c;必须进行有效管理。支持小文件&＃xff0c;但不对其进行优化。
3. 负载通常包含两种读&＃xff1a;大型的流式读&＃xff08;顺序读&＃xff09;&＃xff0c;和小型的随机读。前者通常一次读数百KB以上&＃xff0c;后者通常在随机位置读几个KB。
4. 负载还包括很多连续的写操作&＃xff0c;往文件追加数据&＃xff08;append&＃xff09;。文件很少会被修改&＃xff0c;支持随机写操作&＃xff0c;但不必进行优化。
5. 系统必须实现良好定义的语义&＃xff0c;用于多客户端并发写同一个文件。同步的开销必须保证最小。
6. 高带宽比低延迟更重要&＃xff0c;GFS的应用大多需要快速处理大量的数据&＃xff0c;很少会严格要求单一操作的响应时间。

从这些假设基本可以看出GFS期望的应用场景应该是大文件&＃xff0c;连续读&＃xff0c;不修改&＃xff0c;高并发。国内的淘宝文件系统&＃xff08;TFS&＃xff09;就不一样&＃xff0c;专门为处理小文件进行了优化。

1 体系结构

GFS包括一个master结点&＃xff08;元数据服务器&＃xff09;&＃xff0c;多个chunkserver&＃xff08;数据服务器&＃xff09;和多个client&＃xff08;运行各种应用的客户端&＃xff09;。在可靠性要求不高的场景&＃xff0c;client和chunkserver可以位于一个结点。图1是GFS的体系结构示意图&＃xff0c;每一结点都是普通的Linux服务器&＃xff0c;GFS的工作就是协调成百上千的服务器为各种应用提供服务。

• chunkserver提供存储。GFS会将文件划分为定长数据块&＃xff0c;每个数据块都有一个全局唯一不可变的id&＃xff08;chunk_handle&＃xff09;&＃xff0c;数据块以普通Linux文件的形式存储在chunkserver上&＃xff0c;出于可靠性考虑&＃xff0c;每个数据块会存储多个副本&＃xff0c;分布在不同chunkserver。
• GFS master就是GFS的元数据服务器&＃xff0c;负责维护文件系统的元数据&＃xff0c;包括命名空间、访问控制、文件-块映射、块地址等&＃xff0c;以及控制系统级活动&＃xff0c;如垃圾回收、负载均衡等。
• 应用需要链接client的代码&＃xff0c;然后client作为代理与master和chunkserver交互。master会定期与chunkserver交流&＃xff08;心跳&＃xff09;&＃xff0c;以获取chunkserver的状态并发送指令。

图1还描述了应用读取数据的流程。1.应用指定读取某个文件的某段数据&＃xff0c;因为数据块是定长的&＃xff0c;client可以计算出这段数据跨越了几个数据块&＃xff0c;client将文件名和需要的数据块索引发送给master&＃xff1b;2.master根据文件名查找命名空间和文件-块映射表&＃xff0c;得到需要的数据块副本所在的地址&＃xff0c;将数据块的id和其所有副本的地址反馈给client&＃xff1b;3.client选择一个副本&＃xff0c;联系chunkserver索取需要的数据&＃xff1b;4.chunkserver返回数据给client。

2 数据的布局

GFS将文件条带化&＃xff0c;按照类似RAID0的形式进行存储&＃xff0c;可以提高聚合带宽。事实上&＃xff0c;大多数分布式存储系统都会采取这种策略。GFS将文件按固定长度切分为数据块&＃xff0c;master在创建一个新数据块时&＃xff0c;会给每个数据块分配一个全局唯一且不可变的64位id。每个数据块以Linux文件的形式存储在chunkserver的本地文件系统里。

GFS为数据块设置了一个很大的长度&＃xff0c;64MB&＃xff0c;这比传统文件系统的块长要大多了。大块长会带来很多好处&＃xff1a;1.减少client和master的交互次数&＃xff0c;因为读写同一个块只需要一次交互&＃xff0c;在GFS假设的顺序读写负载的场景下特别有用&＃xff1b;2.同样也减少了client和chunkserver的交互次数&＃xff0c;降低TCP/IP连接等网络开销&＃xff1b;3.减少了元数据的规模&＃xff0c;因此master可以将元数据完全放在内存&＃xff0c;这对于集中式元数据模型的GFS尤为重要。

大数据块也有缺点。最大的缺点可能就是内部碎片了&＃xff0c;不过考虑到文件一般都相当大&＃xff0c;所以碎片也只存在于文件的最后一个数据块。还有一个缺点不是那么容易看出来&＃xff0c;由于小文件可能只有少量数据块&＃xff0c;极端情况只有一个&＃xff0c;那么当这个小文件是热点文件时&＃xff0c;存储该文件数据块的chunkserver可能会负载过重。不过正如前面所说&＃xff0c;小文件不在GFS的优化范围。

为了提高数据的可靠性和并发性&＃xff0c;每一个数据块都有多个副本。当客户端请求一个数据块时&＃xff0c;master会将所有副本的地址都通知客户端&＃xff0c;客户端再择优&＃xff08;距离最短等&＃xff09;选择一个副本。一个典型的GFS集群可能有数百台服务器&＃xff0c;跨越多个子网&＃xff0c;因此在考虑副本的放置时&＃xff0c;不仅要考虑机器级别的错误&＃xff0c;还要考虑整个子网瘫痪了该怎么办。将副本分布到多个子网去&＃xff0c;还可以提高系统的聚合带宽。因此创建一个数据块时&＃xff0c;主要考虑几个因素&＃xff1a;1.优先考虑存储利用率低于平均水平的结点&＃xff1b;2.限制单个节点同时创建副本的数量&＃xff1b;3.副本尽量跨子网。

3 元数据服务

GFS是典型的集中式元数据服务&＃xff0c;所有的元数据都存放在一个master结点内。元数据主要包括三种&＃xff1a;文件和数据块的命名空间&＃xff0c;文件-数据块映射表&＃xff0c;数据块的副本位置。所有的元数据都是放在内存里的。

前两种元数据会被持久化到本地磁盘中&＃xff0c;以操作日志的形式。操作日志会记录下这两种元数据的每一次关键变化&＃xff0c;因此当master宕机&＃xff0c;就可以根据日志恢复到某个时间点。日志的意义还在于&＃xff0c;它提供了一个时间线&＃xff0c;用于定义操作的先后顺序&＃xff0c;文件、数据块的版本都依赖于这个时间顺序。

数据块的副本位置则没有持久化&＃xff0c;因为动辄数以百计的chunkserver是很容易出错的&＃xff0c;因此只有chunkserver对自己存储的数据块有绝对的话语权&＃xff0c;而master上的位置信息很容易因为结点失效等原因而过时。取而代之的方法是&＃xff0c;master启动时询问每个chunkserver的数据块情况&＃xff0c;而且chunkserver在定期的心跳检查中也会汇报自己存储的部分数据块情况。

GFS物理上没有目录结构&＃xff0c;也不支持链接操作&＃xff0c;使用一张表来映射文件路径名和元数据。

4 缓存和预取

GFS的客户端和chunkserver都不会缓存任何数据&＃xff0c;这是因为GFS的典型应用是顺序访问大文件&＃xff0c;不存在时间局部性。空间局部性虽然存在&＃xff0c;但是数据集一般很大&＃xff0c;以致没有足够的空间缓存。

我们知道集中式元数据模型的元数据服务器容易成为瓶颈&＃xff0c;应该尽量减少客户端与元数据服务器的交互。因此GFS设计了元数据缓存。client需要访问数据时&＃xff0c;先询问master数据在哪儿&＃xff0c;然后将这个数据地址信息缓存起来&＃xff0c;之后client对该数据块的操作都只需直接与chunkserver联系了&＃xff0c;当然缓存的时间是有限的&＃xff0c;过期作废。

master还会元数据预取。因为空间局部性是存在&＃xff0c;master可以将逻辑上连续的几个数据块的地址信息一并发给客户端&＃xff0c;客户端缓存这些元数据&＃xff0c;以后需要时就可以不用找master的麻烦了。

5 出错了肿么办

引用&＃xff1a;“We treat component failures as the norm rather than the exception."

分布式系统整体的可靠性是至关重要的。GFS集群使用的都是普通的商用计算机&＃xff0c;而且机器的数量众多&＃xff0c;设备故障经常出现&＃xff0c;如何处理结点失效的问题是GFS最大的挑战。

5.1 完整性

GFS使用数以千计的磁盘&＃xff0c;磁盘出错导致数据被破坏时有发生&＃xff0c;我们可以用其它副本来恢复数据&＃xff0c;但首先必须能检测出错误。chunksever会使用校验和来检测错误数据。每一个块&＃xff08;chunk&＃xff09;都被划分为64KB的单元&＃xff08;block&＃xff09;&＃xff0c;每个block对应一个32位的校验和。校验和与数据分开存储&＃xff0c;内存有一份&＃xff0c;然后以日志的形式在此盘备一份。

chunkserver在发送数据之前会核对数据的校验和&＃xff0c;防止错误的数据传播出去。如果校验和与数据不匹配&＃xff0c;就返回错误&＃xff0c;并且向master反映情况。master会开始克隆副本的操作&＃xff0c;完成后就命令该chunkserver删除非法副本。

5.2 一致性

一致性指的是master的元数据和chunkserver的数据是否一致&＃xff0c;多个数据块副本之间是否一致&＃xff0c;多个客户端看到的数据是否一致。

先来看看元数据一致性。GFS的命名空间操作是原子性的&＃xff0c;并且用日志记录下操作顺序。虽然GFS没有目录结构&＃xff0c;但是仍然有一颗逻辑的目录树&＃xff0c;树的每个结点都有自己的读写锁&＃xff0c;每个元数据操作都需要获得一系列的锁&＃xff0c;应该是写锁会阻塞其它的锁&＃xff0c;而读锁只阻塞写锁而不阻塞读锁。比如/home/user "目录" 正在创建快照&＃xff0c;需要获得/home的读锁和/home/user的写锁&＃xff0c;这时如果想创建文件/home/user/foo会被阻塞&＃xff0c;因为需要获得/home、/home/user的读锁以及/home/user/foo的写锁&＃xff0c;快照会阻塞创建操作获取/home/user的读锁。如果是在一个有传统目录树结构的文件系统里&＃xff0c;创建一个文件需要修改父目录的数据&＃xff0c;因此需要获得父目录的写锁。这种锁机只允许在一个目录里并发修改数据&＃xff08;如并发创建文件等&＃xff09;&＃xff0c;这在传统文件系统里是不允许的。

再来看看GFS是如何并发写&＃xff08;write&＃xff09;的&＃xff0c;GFS必须将对数据块的修改同步到每一个副本。考虑一下多个应用同时修改同一数据块的情况&＃xff0c;我们必须为修改操作定义统一的时序&＃xff0c;不然多个副本会出现不一致的情况&＃xff0c;那么定义时序由谁做呢&＃xff1f;还记得前面提到的元数据缓存么&＃xff0c;为了减少master的负担&＃xff0c;client在获得副本位置后就不再和master交互&＃xff0c;所以必然需要选出一个master代理来完成这个任务。事实上GFS采用了租约&＃xff08;lease&＃xff09;的机制&＃xff0c;master会将租约授权给某个副本&＃xff0c;称为primary&＃xff0c;由这个primary来确定数据修改的顺序&＃xff0c;其它副本照做就是。

图2是写操作的控制流和数据流&＃xff1a;

1. client需要更新一个数据块&＃xff0c;询问master谁拥有该数据块的租约&＃xff08;谁是primary&＃xff09;&＃xff1b;
2. master将持有租约的primary和其它副本的位置告知client&＃xff0c;client缓存之&＃xff1b;
3. client向所有副本传输数据&＃xff0c;这里副本没有先后顺序&＃xff0c;根据网络拓扑情况找出最短路径&＃xff0c;数据从client出发沿着路径流向各个chunkserver&＃xff0c;这个过程采用流水线&＃xff08;网络和存储并行&＃xff09;。chunkserver将数据放到LRU缓存&＃xff1b;
4. 一旦所有的副本都确定接受数据&＃xff0c;client向primary发送写请求&＃xff0c;primary为这个前面接受到的数据分配序列号&＃xff08;primary为所有的写操作分配连续的序列号表示先后顺序&＃xff09;&＃xff0c;并且按照顺序执行数据更新&＃xff1b;
5. primary将写请求发送给其它副本&＃xff0c;每个副本都按照primary确定的顺序执行更新&＃xff1b;
6. 其它副本向primary汇报操作情况&＃xff1b;
7. primary回复client操作情况&＃xff0c;任何副本错误都导致此次请求失败&＃xff0c;并且此时副本处于不一致状态&＃xff08;写操作完成情况不一样&＃xff09;。client会尝试几次3到7的步骤&＃xff0c;实在不行就只能重头来过了。

如果一个写请求太大了或者跨越了chunk&＃xff0c;GFS的client会将其拆分为多个写请求&＃xff0c;每个写请求都遵循上述过程&＃xff0c;但是可能和其它应用的写操作交叉在一起。所以这些写操作共享的数据区域就可能包含几个写请求的碎片&＃xff08;就是下文提到的undefined状态&＃xff09;。

GFS还提供另一种写操作append record&＃xff0c;append只在文件的尾部以record为单位&＃xff08;为了避免内部碎片&＃xff0c;record一般不会很大&＃xff09;写入数据。append是原子性的&＃xff0c;GFS保证将数据顺序地写到文件尾部至少一次。append record的流程和图2类似&＃xff0c;只是在primary有点区别&＃xff0c;GFS必须保证一个record存储在一个chunk内&＃xff0c;所以当primary判断当前chunk有足够空间时&＃xff0c;就通知所有副本将chunk填充&＃xff0c;然后汇报失败&＃xff0c;client会申请创建新chunk并重新执行一次append record操作。如果该chunk大小合适&＃xff0c;primary会将数据写到数据块的尾部&＃xff0c;然后通知其它副本将数据写到一样的偏移。任何副本append失败&＃xff0c;各个副本会处于不一致状态&＃xff08;完成或未完成&＃xff09;&＃xff0c;这时primary必然是成功写入的&＃xff08;不然就没有4以后的操作了&＃xff09;。客户端重试append record操作时&＃xff0c;因为primary的chunk长度已经变化了&＃xff0c;primary就必须在新的偏移写入数据&＃xff0c;而其它副本也是照做。这就导致上一个失败的偏移位置&＃xff0c;各个副本处于不一致状态&＃xff0c;应用必须自己区分record正确与否&＃xff0c;我称这为无效数据区。

表1说明了GFS的一致性保证&＃xff0c;明白write和append操作后就容易理解了。consistent指的是多个副本之间是完全一致的&＃xff1b;defined指的是副本数据修改后不仅一致而且client能看到其修改的数据全貌。

• 成功的连续write是已定义的&＃xff0c;各个副本数据一致&＃xff1b;
• 成功的并发write能保证一致性性&＃xff0c;即各个副本是一样的&＃xff0c;但数据并不一定如用户所期望&＃xff0c;如前所述&＃xff0c;多个用户的修改可能交错在一起&＃xff1b;
• 失败的write操作&＃xff0c;使得副本之间不一致&＃xff0c;而且数据undefined&＃xff0c;不同client可能看到不同的数据&＃xff08;注意区别defined、undefined数据的方法&＃xff09;&＃xff1b;
• 成功的append操作&＃xff0c;不管是顺序还是并发都是defined&＃xff0c;因为GFS保证了append是原子性的&＃xff08;atomically at least once&＃xff09;。有效数据区确实是defined的&＃xff0c;但是失败append操作留下的无效数据区可能会有不一致的情况&＃xff0c;所以中间可能零散分布着不一致的数据。

如上所述&＃xff0c;在primary的协调下&＃xff0c;能保证并发write的一致性。但还有一些可能会导致数据不一致&＃xff0c;比如chunkserver宕机错过了数据更新&＃xff0c;这时就会出现新旧版本的数据&＃xff0c;GFS为每个数据块分配版本来解决这个问题。master每次授权数据块租约给primary之前&＃xff0c;都会增加数据块的版本号&＃xff0c;并且通知所有副本更新版本号。客户端需要读数据时当然会根据这个版本号来判断副本的数据是否最新。

5.3 可用性

为了保证数据的可用性&＃xff0c;GFS为每个数据块存储了多个副本&＃xff0c;在数据的布局里有介绍&＃xff0c;这里主要关注下元数据的可用性。

GFS是典型的集中式元数据模型&＃xff0c;一个元数据服务器承担了巨大的压力&＃xff0c;不仅有性能的问题&＃xff0c;还有单点故障问题。master为了能快速从故障中恢复过来&＃xff0c;采用了log和checkpoint技术&＃xff0c;log记录了元数据的每一次变化。用咱们备份的话来说&＃xff0c;checkpoint就相当于一次全量备份&＃xff0c;log相当于连续数据保护&＃xff0c;master宕机后&＃xff0c;就先恢复到checkpoint&＃xff0c;然后根据log恢复到最新状态。每次创建一个新的checkpoint&＃xff0c;log就可以清空&＃xff0c;这有效控制了log的大小。

这还不够&＃xff0c;如果master完全坏了肿么办&＃xff1f;GFS设置了“影子”服务器&＃xff0c;master将日志备份到影子上&＃xff0c;影子按照日志把元数据与master同步。如果master悲剧了&＃xff0c;我们还有影子。平时正常工作时&＃xff0c;影子可以分担一部分元数据访问工作&＃xff0c;当然不提供直接的写操作。

6 测试

6.1 模拟

实验的网络拓扑图大概就是这样。集群包括一个master和它的两个影子&＃xff0c;16个chunkserver&＃xff0c;16个client&＃xff0c;和两个HP交换机。两个交换机之间是1Gbps的链路&＃xff0c;结点与交换机的链路是100Mbps。聚合带宽的理论上限是125MB/s&＃xff0c;而单个client的理论带宽上限是12.5MB/s。

实验一&＃xff1a;N个client同时随机各自读取1GB数据。

图3(a)&＃xff0c;x轴是N&＃xff0c;y轴是聚合带宽&＃xff0c;上面一条线是理论值&＃xff0c;下面一条线是实际值。当N&＃61;1时&＃xff0c;吞吐率是10MB/s&＃xff0c;达到了理论值的80%。当N&＃61;16时&＃xff0c;吞吐率是94MB/s&＃xff0c;达到理论值的75%。此时瓶颈可能是在chunkserver&＃xff0c;因为client数量很多&＃xff0c;同时读一个chunkserver的概率很大。

实验二&＃xff1a;N个client同时写N个不同文件&＃xff0c;各自连续写1GB。

图3(b)。理论值上限是67MB/s&＃xff08;The limit plateaus at 67 MB/s because we need to write each byte to 3 of the 16 chunkservers,

each with a 12.5 MB/s input connection&＃xff09;&＃xff0c;这个理论值我没有看明白是怎么算的。当N&＃61;1&＃xff0c;吞吐率是6.3MB/s&＃xff0c;达到极限的一半&＃xff0c;主要的瓶颈是数据在副本之间传递。N&＃61;16时&＃xff0c;聚合带宽为35MB/s&＃xff08;每个client有2.2MB/s&＃xff09;&＃xff0c;达到极限的一半&＃xff0c;这里chunkserver同时接受多个请求的情况比读更严重&＃xff0c;因为得写3个副本。写比期望的要慢。

实验三&＃xff1a;N个client同时向一个文件append record。

图3(c)。理论上限值是一台chunkserver的带宽&＃xff0c;即12.5MB/s。当N&＃61;1时&＃xff0c;吞吐率有6.0MB/s。当N&＃61;16时&＃xff0c;下降到4.8MB/s。这可能是因为拥塞。

6.2 现实

文章里还介绍了两个真实集群的使用情况&＃xff0c;cluster A and B。

表2是两个集群的情况。A和B都有数百个chunkserver&＃xff0c;存储利用率很高&＃xff0c;冗余度是3&＃xff0c;所以实际存储的数据是18TB和52TB。文件数相当&＃xff0c;dead file是需要删除的文件&＃xff0c;但还没被垃圾回收&＃xff08;GFS会为删除的文件保留三天才回收空间&＃xff09;。B的块数更多&＃xff0c;意味着文件更大&＃xff0c;不过A和B的文件平均都只有1到2个块。chunkserver的元数据主要是block&＃xff08;64KB&＃xff09;的校验和&＃xff08;4 Bytes&＃xff09;&＃xff0c;以及数据块的版本信息。master的元数据&＃xff08;文件和数据块的名字&＃xff0c;文件-数据块映射&＃xff0c;块位置等&＃xff09;相当小&＃xff0c;平均每个文件只有100B元数据&＃xff0c;大部分是用于存储文件名。平均下来&＃xff0c;每个服务器有50~100MB的元数据。

7 胡说八道

画了个全分布式元数据模型。

这估计是最简单的&＃xff0c;命名空间被划分为几个区域&＃xff0c;master各管各的。为了可靠性&＃xff0c;每个master做几个副本。映射方法可以是文件名计算哈希取模&＃xff0c;好的哈希函数可以使文件随机分布&＃xff0c;负载比较均衡。当然扩展性不是很好&＃xff0c;加入新的节点&＃xff0c;所有文件得重新映射。而且冗余度只能靠机器堆了&＃xff0c;不能软件控制。

又构思了个复杂点的。将文件映射到r(<&＃61;N)个master&＃xff0c;利用参数r控制冗余度&＃xff0c;当r&＃61;N时就变成全对等元数据集群。这个模型需要r个不同的哈希函数&＃xff0c;为了减少开销&＃xff0c;可以用两个函数模拟多个函数。比如有随机性很好的f(x)和g(x)函数&＃xff0c;我们用式子f(x)&＃43;i*g(x)来模拟&＃xff0c;其中i为非负整数。当我们处理文件x时&＃xff0c;就用前面式子求出r个不同的位置&＃xff08;有冲突的概率&＃xff0c;实际可能不止计算r次&＃xff09;。

胡说八道&＃xff0c;切勿当真&＃xff1b;如有雷同&＃xff0c;纯属巧合。

谷歌技术"三宝"之MapReduce

1. MapReduce是干啥的

因为没找到谷歌的示意图&＃xff0c;所以我想借用一张Hadoop项目的结构图来说明下MapReduce所处的位置&＃xff0c;如下图。

Hadoop实际上就是谷歌三宝的开源实现&＃xff0c;Hadoop MapReduce对应Google MapReduce&＃xff0c;HBase对应BigTable&＃xff0c;HDFS对应GFS。HDFS&＃xff08;或GFS&＃xff09;为上层提供高效的非结构化存储服务&＃xff0c;HBase&＃xff08;或BigTable&＃xff09;是提供结构化数据服务的分布式数据库&＃xff0c;Hadoop MapReduce&＃xff08;或Google MapReduce&＃xff09;是一种并行计算的编程模型&＃xff0c;用于作业调度。

GFS和BigTable已经为我们提供了高性能、高并发的服务&＃xff0c;但是并行编程可不是所有程序员都玩得转的活儿&＃xff0c;如果我们的应用本身不能并发&＃xff0c;那GFS、BigTable也都是没有意义的。MapReduce的伟大之处就在于让不熟悉并行编程的程序员也能充分发挥分布式系统的威力。

简单概括的说&＃xff0c;MapReduce是将一个大作业拆分为多个小作业的框架&＃xff08;大作业和小作业应该本质是一样的&＃xff0c;只是规模不同&＃xff09;&＃xff0c;用户需要做的就是决定拆成多少份&＃xff0c;以及定义作业本身。

下面用一个贯穿全文的例子来解释MapReduce是如何工作的。

2. 例子&＃xff1a;统计词频

如果我想统计下过去10年计算机论文出现最多的几个单词&＃xff0c;看看大家都在研究些什么&＃xff0c;那我收集好论文后&＃xff0c;该怎么办呢&＃xff1f;

方法一&＃xff1a;我可以写一个小程序&＃xff0c;把所有论文按顺序遍历一遍&＃xff0c;统计每一个遇到的单词的出现次数&＃xff0c;最后就可以知道哪几个单词最热门了。

这种方法在数据集比较小时&＃xff0c;是非常有效的&＃xff0c;而且实现最简单&＃xff0c;用来解决这个问题很合适。

方法二&＃xff1a;写一个多线程程序&＃xff0c;并发遍历论文。

这个问题理论上是可以高度并发的&＃xff0c;因为统计一个文件时不会影响统计另一个文件。当我们的机器是多核或者多处理器&＃xff0c;方法二肯定比方法一高效。但是写一个多线程程序要比方法一困难多了&＃xff0c;我们必须自己同步共享数据&＃xff0c;比如要防止两个线程重复统计文件。

方法三&＃xff1a;把作业交给多个计算机去完成。

我们可以使用方法一个程序&＃xff0c;部署到N台机器上去&＃xff0c;然后把论文集分成N份&＃xff0c;一台机器跑一个作业。这个方法跑得足够快&＃xff0c;但是部署起来很麻烦&＃xff0c;我们要人工把程序copy到别的机器&＃xff0c;要人工把论文集分开&＃xff0c;最痛苦的是还要把N个运行结果进行整合&＃xff08;当然我们也可以再写一个程序&＃xff09;。

方法四&＃xff1a;让MapReduce来帮帮我们吧&＃xff01;

MapReduce本质上就是方法三&＃xff0c;但是如何拆分文件集&＃xff0c;如何copy程序&＃xff0c;如何整合结果这些都是框架定义好的。我们只要定义好这个任务&＃xff08;用户程序&＃xff09;&＃xff0c;其它都交给MapReduce。

在介绍MapReduce如何工作之前&＃xff0c;先讲讲两个核心函数map和reduce以及MapReduce的伪代码。

3. map函数和reduce函数

map函数和reduce函数是交给用户实现的&＃xff0c;这两个函数定义了任务本身。

map函数&＃xff1a;接受一个键值对&＃xff08;key-value pair&＃xff09;&＃xff0c;产生一组中间键值对。MapReduce框架会将map函数产生的中间键值对里键相同的值传递给一个reduce函数。

reduce函数&＃xff1a;接受一个键&＃xff0c;以及相关的一组值&＃xff0c;将这组值进行合并产生一组规模更小的值&＃xff08;通常只有一个或零个值&＃xff09;。

统计词频的MapReduce函数的核心代码非常简短&＃xff0c;主要就是实现这两个函数。

在统计词频的例子里&＃xff0c;map函数接受的键是文件名&＃xff0c;值是文件的内容&＃xff0c;map逐个遍历单词&＃xff0c;每遇到一个单词w&＃xff0c;就产生一个中间键值对&＃xff0c;这表示单词w咱又找到了一个&＃xff1b;MapReduce将键相同&＃xff08;都是单词w&＃xff09;的键值对传给reduce函数&＃xff0c;这样reduce函数接受的键就是单词w&＃xff0c;值是一串"1"&＃xff08;最基本的实现是这样&＃xff0c;但可以优化&＃xff09;&＃xff0c;个数等于键为w的键值对的个数&＃xff0c;然后将这些“1”累加就得到单词w的出现次数。最后这些单词的出现次数会被写到用户定义的位置&＃xff0c;存储在底层的分布式存储系统&＃xff08;GFS或HDFS&＃xff09;。

4. MapReduce是如何工作的

上图是论文里给出的流程图。一切都是从最上方的user program开始的&＃xff0c;user program链接了MapReduce库&＃xff0c;实现了最基本的Map函数和Reduce函数。图中执行的顺序都用数字标记了。

1. MapReduce库先把user program的输入文件划分为M份&＃xff08;M为用户定义&＃xff09;&＃xff0c;每一份通常有16MB到64MB&＃xff0c;如图左方所示分成了split0~4&＃xff1b;然后使用fork将用户进程拷贝到集群内其它机器上。
2. user program的副本中有一个称为master&＃xff0c;其余称为worker&＃xff0c;master是负责调度的&＃xff0c;为空闲worker分配作业&＃xff08;Map作业或者Reduce作业&＃xff09;&＃xff0c;worker的数量也是可以由用户指定的。
3. 被分配了Map作业的worker&＃xff0c;开始读取对应分片的输入数据&＃xff0c;Map作业数量是由M决定的&＃xff0c;和split一一对应&＃xff1b;Map作业从输入数据中抽取出键值对&＃xff0c;每一个键值对都作为参数传递给map函数&＃xff0c;map函数产生的中间键值对被缓存在内存中。
4. 缓存的中间键值对会被定期写入本地磁盘&＃xff0c;而且被分为R个区&＃xff0c;R的大小是由用户定义的&＃xff0c;将来每个区会对应一个Reduce作业&＃xff1b;这些中间键值对的位置会被通报给master&＃xff0c;master负责将信息转发给Reduce worker。
5. master通知分配了Reduce作业的worker它负责的分区在什么位置&＃xff08;肯定不止一个地方&＃xff0c;每个Map作业产生的中间键值对都可能映射到所有R个不同分区&＃xff09;&＃xff0c;当Reduce worker把所有它负责的中间键值对都读过来后&＃xff0c;先对它们进行排序&＃xff0c;使得相同键的键值对聚集在一起。因为不同的键可能会映射到同一个分区也就是同一个Reduce作业&＃xff08;谁让分区少呢&＃xff09;&＃xff0c;所以排序是必须的。
6. reduce worker遍历排序后的中间键值对&＃xff0c;对于每个唯一的键&＃xff0c;都将键与关联的值传递给reduce函数&＃xff0c;reduce函数产生的输出会添加到这个分区的输出文件中。
7. 当所有的Map和Reduce作业都完成了&＃xff0c;master唤醒正版的user program&＃xff0c;MapReduce函数调用返回user program的代码。

所有执行完毕后&＃xff0c;MapReduce输出放在了R个分区的输出文件中&＃xff08;分别对应一个Reduce作业&＃xff09;。用户通常并不需要合并这R个文件&＃xff0c;而是将其作为输入交给另一个MapReduce程序处理。整个过程中&＃xff0c;输入数据是来自底层分布式文件系统&＃xff08;GFS&＃xff09;的&＃xff0c;中间数据是放在本地文件系统的&＃xff0c;最终输出数据是写入底层分布式文件系统&＃xff08;GFS&＃xff09;的。而且我们要注意Map/Reduce作业和map/reduce函数的区别&＃xff1a;Map作业处理一个输入数据的分片&＃xff0c;可能需要调用多次map函数来处理每个输入键值对&＃xff1b;Reduce作业处理一个分区的中间键值对&＃xff0c;期间要对每个不同的键调用一次reduce函数&＃xff0c;Reduce作业最终也对应一个输出文件。

我更喜欢把流程分为三个阶段。第一阶段是准备阶段&＃xff0c;包括1、2&＃xff0c;主角是MapReduce库&＃xff0c;完成拆分作业和拷贝用户程序等任务&＃xff1b;第二阶段是运行阶段&＃xff0c;包括3、4、5、6&＃xff0c;主角是用户定义的map和reduce函数&＃xff0c;每个小作业都独立运行着&＃xff1b;第三阶段是扫尾阶段&＃xff0c;这时作业已经完成&＃xff0c;作业结果被放在输出文件里&＃xff0c;就看用户想怎么处理这些输出了。

5. 词频是怎么统计出来的

结合第四节&＃xff0c;我们就可以知道第三节的代码是如何工作的了。假设咱们定义M&＃61;5&＃xff0c;R&＃61;3&＃xff0c;并且有6台机器&＃xff0c;一台master。

这幅图描述了MapReduce如何处理词频统计。由于map worker数量不够&＃xff0c;首先处理了分片1、3、4&＃xff0c;并产生中间键值对&＃xff1b;当所有中间值都准备好了&＃xff0c;Reduce作业就开始读取对应分区&＃xff0c;并输出统计结果。

6. 用户的权利

用户最主要的任务是实现map和reduce接口&＃xff0c;但还有一些有用的接口是向用户开放的。

• an input reader。这个函数会将输入分为M个部分&＃xff0c;并且定义了如何从数据中抽取最初的键值对&＃xff0c;比如词频的例子中定义文件名和文件内容是键值对。
• a partition function。这个函数用于将map函数产生的中间键值对映射到一个分区里去&＃xff0c;最简单的实现就是将键求哈希再对R取模。
• a compare function。这个函数用于Reduce作业排序&＃xff0c;这个函数定义了键的大小关系。
• an output writer。负责将结果写入底层分布式文件系统。
• a combiner function。实际就是reduce函数&＃xff0c;这是用于前面提到的优化的&＃xff0c;比如统计词频时&＃xff0c;如果每个要读一次&＃xff0c;因为reduce和map通常不在一台机器&＃xff0c;非常浪费时间&＃xff0c;所以可以在map执行的地方先运行一次combiner&＃xff0c;这样reduce只需要读一次了。
• map和reduce函数就不多说了。

7. MapReduce的实现

目前MapReduce已经有多种实现&＃xff0c;除了谷歌自己的实现外&＃xff0c;还有著名的hadoop&＃xff0c;区别是谷歌是c&＃43;&＃43;&＃xff0c;而hadoop是用java。另外斯坦福大学实现了一个在多核/多处理器、共享内存环境内运行的MapReduce&＃xff0c;称为Phoenix&＃xff08;介绍&＃xff09;&＃xff0c;相关的论文发表在07年的HPCA&＃xff0c;是当年的最佳论文哦&＃xff01;

谷歌技术"三宝"之BigTable

2006年的OSDI有两篇google的论文&＃xff0c;分别是BigTable和Chubby。Chubby是一个分布式锁服务&＃xff0c;基于Paxos算法&＃xff1b;BigTable是一个用于管理结构化数据的分布式存储系统&＃xff0c;构建在GFS、Chubby、SSTable等google技术之上。相当多的google应用使用了BigTable&＃xff0c;比如Google Earth和Google Analytics&＃xff0c;因此它和GFS、MapReduce并称为谷歌技术"三宝"。

与GFS和MapReduce的论文相比&＃xff0c;我觉得BigTable的论文难懂一些。一方面是因为自己对数据库不太了解&＃xff0c;另一方面又是因为对数据库的理解局限于关系型数据库。尝试用关系型数据模型去理解BigTable就容易"走火入魔"。在这里推荐一篇文章&＃xff08;需要翻墙&＃xff09;&＃xff1a;Understanding HBase and BigTable&＃xff0c;相信这篇文章对理解BigTable/HBase的数据模型有很大帮助。

1 什么是BigTable

Bigtable是一个为管理大规模结构化数据而设计的分布式存储系统&＃xff0c;可以扩展到PB级数据和上千台服务器。很多google的项目使用Bigtable存储数据&＃xff0c;这些应用对Bigtable提出了不同的挑战&＃xff0c;比如数据规模的要求、延迟的要求。Bigtable能满足这些多变的要求&＃xff0c;为这些产品成功地提供了灵活、高性能的存储解决方案。

Bigtable看起来像一个数据库&＃xff0c;采用了很多数据库的实现策略。但是Bigtable并不支持完整的关系型数据模型&＃xff1b;而是为客户端提供了一种简单的数据模型&＃xff0c;客户端可以动态地控制数据的布局和格式&＃xff0c;并且利用底层数据存储的局部性特征。Bigtable将数据统统看成无意义的字节串&＃xff0c;客户端需要将结构化和非结构化数据串行化再存入Bigtable。

下文对BigTable的数据模型和基本工作原理进行介绍&＃xff0c;而各种优化技术&＃xff08;如压缩、Bloom Filter等&＃xff09;不在讨论范围。

2 BigTable的数据模型

Bigtable不是关系型数据库&＃xff0c;但是却沿用了很多关系型数据库的术语&＃xff0c;像table&＃xff08;表&＃xff09;、row&＃xff08;行&＃xff09;、column&＃xff08;列&＃xff09;等。这容易让读者误入歧途&＃xff0c;将其与关系型数据库的概念对应起来&＃xff0c;从而难以理解论文。Understanding HBase and BigTable是篇很优秀的文章&＃xff0c;可以帮助读者从关系型数据模型的思维定势中走出来。

本质上说&＃xff0c;Bigtable是一个键值&＃xff08;key-value&＃xff09;映射。按作者的说法&＃xff0c;Bigtable是一个稀疏的&＃xff0c;分布式的&＃xff0c;持久化的&＃xff0c;多维的排序映射。

先来看看多维、排序、映射。Bigtable的键有三维&＃xff0c;分别是行键&＃xff08;row key&＃xff09;、列键&＃xff08;column key&＃xff09;和时间戳&＃xff08;timestamp&＃xff09;&＃xff0c;行键和列键都是字节串&＃xff0c;时间戳是64位整型&＃xff1b;而值是一个字节串。可以用 (row:string, column:string, time:int64)→string 来表示一条键值对记录。

行键可以是任意字节串&＃xff0c;通常有10-100字节。行的读写都是原子性的。Bigtable按照行键的字典序存储数据。Bigtable的表会根据行键自动划分为片&＃xff08;tablet&＃xff09;&＃xff0c;片是负载均衡的单元。最初表都只有一个片&＃xff0c;但随着表不断增大&＃xff0c;片会自动分裂&＃xff0c;片的大小控制在100-200MB。行是表的第一级索引&＃xff0c;我们可以把该行的列、时间和值看成一个整体&＃xff0c;简化为一维键值映射&＃xff0c;类似于&＃xff1a;

table{"1" : {sth.},//一行"aaaaa" : {sth.},"aaaab" : {sth.},"xyz" : {sth.},"zzzzz" : {sth.}
}

列是第二级索引&＃xff0c;每行拥有的列是不受限制的&＃xff0c;可以随时增加减少。为了方便管理&＃xff0c;列被分为多个列族&＃xff08;column family&＃xff0c;是访问控制的单元&＃xff09;&＃xff0c;一个列族里的列一般存储相同类型的数据。一行的列族很少变化&＃xff0c;但是列族里的列可以随意添加删除。列键按照family:qualifier格式命名的。这次我们将列拿出来&＃xff0c;将时间和值看成一个整体&＃xff0c;简化为二维键值映射&＃xff0c;类似于&＃xff1a;

table{// ..."aaaaa" : { //一行"A:foo" : {sth.},//一列"A:bar" : {sth.},//一列"B:" : {sth.} //一列&＃xff0c;列族名为B&＃xff0c;但是列名是空字串},"aaaab" : { //一行"A:foo" : {sth.},"B:" : {sth.}},// ...
}

或者可以将列族当作一层新的索引&＃xff0c;类似于&＃xff1a;

table{// ..."aaaaa" : { //一行"A" : { //列族A"foo" : {sth.}, //一列"bar" : {sth.}},"B" : { //列族B"" : {sth.}}},"aaaab" : { //一行"A" : {"foo" : {sth.},},"B" : {"" : "ocean"}},// ...
}

时间戳是第三级索引。Bigtable允许保存数据的多个版本&＃xff0c;版本区分的依据就是时间戳。时间戳可以由Bigtable赋值&＃xff0c;代表数据进入Bigtable的准确时间&＃xff0c;也可以由客户端赋值。数据的不同版本按照时间戳降序存储&＃xff0c;因此先读到的是最新版本的数据。我们加入时间戳后&＃xff0c;就得到了Bigtable的完整数据模型&＃xff0c;类似于&＃xff1a;

table{// ..."aaaaa" : { //一行"A:foo" : { //一列15 : "y", //一个版本4 : "m"},"A:bar" : { //一列15 : "d",},"B:" : { //一列6 : "w"3 : "o"1 : "w"}},// ...
}

查询时&＃xff0c;如果只给出行列&＃xff0c;那么返回的是最新版本的数据&＃xff1b;如果给出了行列时间戳&＃xff0c;那么返回的是时间小于或等于时间戳的数据。比如&＃xff0c;我们查询"aaaaa"/"A:foo"&＃xff0c;返回的值是"y"&＃xff1b;查询"aaaaa"/"A:foo"/10&＃xff0c;返回的结果就是"m"&＃xff1b;查询"aaaaa"/"A:foo"/2&＃xff0c;返回的结果是空。

图1是Bigtable论文里给出的例子&＃xff0c;Webtable表存储了大量的网页和相关信息。在Webtable&＃xff0c;每一行存储一个网页&＃xff0c;其反转的url作为行键&＃xff0c;比如
maps.google.com/index.html的数据存储在键为
com.google.maps/index.html的行里&＃xff0c;反转的原因是为了让同一个域名下的子域名网页能聚集在一起。图1中的列族"anchor"保存了该网页的引用站点&＃xff08;比如引用了CNN主页的站点&＃xff09;&＃xff0c;qualifier是引用站点的名称&＃xff0c;而数据是链接文本&＃xff1b;列族"contents"保存的是网页的内容&＃xff0c;这个列族只有一个空列"contents:"。图1中"contents:"列下保存了网页的三个版本&＃xff0c;我们可以用("com.cnn.www", "contents:", t5)来找到CNN主页在t5时刻的内容。

再来看看作者说的其它特征&＃xff1a;稀疏&＃xff0c;分布式&＃xff0c;持久化。持久化的意思很简单&＃xff0c;Bigtable的数据最终会以文件的形式放到GFS去。Bigtable建立在GFS之上本身就意味着分布式&＃xff0c;当然分布式的意义还不仅限于此。稀疏的意思是&＃xff0c;一个表里不同的行&＃xff0c;列可能完完全全不一样。

3 支撑技术

Bigtable依赖于google的几项技术。用GFS来存储日志和数据文件&＃xff1b;按SSTable文件格式存储数据&＃xff1b;用Chubby管理元数据。

GFS参见谷歌技术"三宝"之谷歌文件系统。BigTable的数据和日志都是写入GFS的。

SSTable的全称是Sorted Strings Table&＃xff0c;是一种不可修改的有序的键值映射&＃xff0c;提供了查询、遍历等功能。每个SSTable由一系列的块&＃xff08;block&＃xff09;组成&＃xff0c;Bigtable将块默认设为64KB。在SSTable的尾部存储着块索引&＃xff0c;在访问SSTable时&＃xff0c;整个索引会被读入内存。BigTable论文没有提到SSTable的具体结构&＃xff0c;LevelDb日知录之四&＃xff1a; SSTable文件这篇文章对LevelDb的SSTable格式进行了介绍&＃xff0c;因为LevelDB的作者JeffreyDean正是BigTable的设计师&＃xff0c;所以极具参考价值。每一个片&＃xff08;tablet&＃xff09;在GFS里都是按照SSTable的格式存储的&＃xff0c;每个片可能对应多个SSTable。

Chubby是一种高可用的分布式锁服务&＃xff0c;Chubby有五个活跃副本&＃xff0c;同时只有一个主副本提供服务&＃xff0c;副本之间用Paxos算法维持一致性&＃xff0c;Chubby提供了一个命名空间&＃xff08;包括一些目录和文件&＃xff09;&＃xff0c;每个目录和文件就是一个锁&＃xff0c;Chubby的客户端必须和Chubby保持会话&＃xff0c;客户端的会话若过期则会丢失所有的锁。关于Chubby的详细信息可以看google的另一篇论文&＃xff1a;The Chubby lock service for loosely-coupled distributed systems。Chubby用于片定位&＃xff0c;片服务器的状态监控&＃xff0c;访问控制列表存储等任务。

4 Bigtable集群

Bigtable集群包括三个主要部分&＃xff1a;一个供客户端使用的库&＃xff0c;一个主服务器&＃xff08;master server&＃xff09;&＃xff0c;许多片服务器&＃xff08;tablet server&＃xff09;。

正如数据模型小节所说&＃xff0c;Bigtable会将表&＃xff08;table&＃xff09;进行分片&＃xff0c;片&＃xff08;tablet&＃xff09;的大小维持在100-200MB范围&＃xff0c;一旦超出范围就将分裂成更小的片&＃xff0c;或者合并成更大的片。每个片服务器负责一定量的片&＃xff0c;处理对其片的读写请求&＃xff0c;以及片的分裂或合并。片服务器可以根据负载随时添加和删除。这里片服务器并不真实存储数据&＃xff0c;而相当于一个连接Bigtable和GFS的代理&＃xff0c;客户端的一些数据操作都通过片服务器代理间接访问GFS。

主服务器负责将片分配给片服务器&＃xff0c;监控片服务器的添加和删除&＃xff0c;平衡片服务器的负载&＃xff0c;处理表和列族的创建等。注意&＃xff0c;主服务器不存储任何片&＃xff0c;不提供任何数据服务&＃xff0c;也不提供片的定位信息。

客户端需要读写数据时&＃xff0c;直接与片服务器联系。因为客户端并不需要从主服务器获取片的位置信息&＃xff0c;所以大多数客户端从来不需要访问主服务器&＃xff0c;主服务器的负载一般很轻。

5 片的定位

前面提到主服务器不提供片的位置信息&＃xff0c;那么客户端是如何访问片的呢&＃xff1f;来看看论文给的示意图&＃xff0c;Bigtable使用一个类似B&＃43;树的数据结构存储片的位置信息。

首先是第一层&＃xff0c;Chubby file。这一层是一个Chubby文件&＃xff0c;它保存着root tablet的位置。这个Chubby文件属于Chubby服务的一部分&＃xff0c;一旦Chubby不可用&＃xff0c;就意味着丢失了root tablet的位置&＃xff0c;整个Bigtable也就不可用了。

第二层是root tablet。root tablet其实是元数据表&＃xff08;METADATA table&＃xff09;的第一个分片&＃xff0c;它保存着元数据表其它片的位置。root tablet很特别&＃xff0c;为了保证树的深度不变&＃xff0c;root tablet从不分裂。

第三层是其它的元数据片&＃xff0c;它们和root tablet一起组成完整的元数据表。每个元数据片都包含了许多用户片的位置信息。

可以看出整个定位系统其实只是两部分&＃xff0c;一个Chubby文件&＃xff0c;一个元数据表。注意元数据表虽然特殊&＃xff0c;但也仍然服从前文的数据模型&＃xff0c;每个分片也都是由专门的片服务器负责&＃xff0c;这就是不需要主服务器提供位置信息的原因。客户端会缓存片的位置信息&＃xff0c;如果在缓存里找不到一个片的位置信息&＃xff0c;就需要查找这个三层结构了&＃xff0c;包括访问一次Chubby服务&＃xff0c;访问两次片服务器。

6 片的存储和访问

片的数据最终还是写到GFS里的&＃xff0c;片在GFS里的物理形态就是若干个SSTable文件。图5展示了读写操作基本情况。

当片服务器收到一个写请求&＃xff0c;片服务器首先检查请求是否合法。如果合法&＃xff0c;先将写请求提交到日志去&＃xff0c;然后将数据写入内存中的memtable。memtable相当于SSTable的缓存&＃xff0c;当memtable成长到一定规模会被冻结&＃xff0c;Bigtable随之创建一个新的memtable&＃xff0c;并且将冻结的memtable转换为SSTable格式写入GFS&＃xff0c;这个操作称为minor compaction。

当片服务器收到一个读请求&＃xff0c;同样要检查请求是否合法。如果合法&＃xff0c;这个读操作会查看所有SSTable文件和memtable的合并视图&＃xff0c;因为SSTable和memtable本身都是已排序的&＃xff0c;所以合并相当快。

每一次minor compaction都会产生一个新的SSTable文件&＃xff0c;SSTable文件太多读操作的效率就降低了&＃xff0c;所以Bigtable定期执行merging compaction操作&＃xff0c;将几个SSTable和memtable合并为一个新的SSTable。BigTable还有个更厉害的叫major compaction&＃xff0c;它将所有SSTable合并为一个新的SSTable。

遗憾的是&＃xff0c;BigTable作者没有介绍memtable和SSTable的详细数据结构。

7 BigTable和GFS的关系

集群包括主服务器和片服务器&＃xff0c;主服务器负责将片分配给片服务器&＃xff0c;而具体的数据服务则全权由片服务器负责。但是不要误以为片服务器真的存储了数据&＃xff08;除了内存中memtable的数据&＃xff09;&＃xff0c;数据的真实位置只有GFS才知道&＃xff0c;主服务器将片分配给片服务器的意思应该是&＃xff0c;片服务器获取了片的所有SSTable文件名&＃xff0c;片服务器通过一些索引机制可以知道所需要的数据在哪个SSTable文件&＃xff0c;然后从GFS中读取SSTable文件的数据&＃xff0c;这个SSTable文件可能分布在好几台chunkserver上。

8 元数据表的结构

元数据表&＃xff08;METADATA table&＃xff09;是一张特殊的表&＃xff0c;它被用于数据的定位以及一些元数据服务&＃xff0c;不可谓不重要。但是Bigtable论文里只给出了少量线索&＃xff0c;而对表的具体结构没有说明。这里我试图根据论文的一些线索&＃xff0c;猜测一下表的结构。首先列出论文中的线索&＃xff1a;

1. The METADATA table stores the location of a tablet under a row key that is an encoding of the tablet&＃39;s table identifier and its end row.
2. Each METADATA row stores approximately 1KB of data in memory&＃xff08;因为访问量比较大&＃xff0c;元数据表是放在内存里的&＃xff0c;这个优化在论文的locality groups中提到&＃xff09;.This feature&＃xff08;将locality group放到内存中的特性&＃xff09; is useful for small pieces of data that are accessed frequently: we use it internally for the location column family in the METADATA table.
3. We also store secondary information in the METADATA table, including a log of all events pertaining to each tablet(such as when a server begins
   serving it).

第一条线索&＃xff0c;元数据表的行键是由片所属表名的id和片最后一行编码而成&＃xff0c;所以每个片在元数据表中占据一条记录&＃xff08;一行&＃xff09;&＃xff0c;而且行键既包含了其所属表的信息也包含了其所拥有的行的范围。譬如采取最简单的编码方式&＃xff0c;元数据表的行键等于strcat(表名&＃xff0c;片最后一行的行键)。

第二点线索&＃xff0c;除了知道元数据表的地址部分是常驻内存以外&＃xff0c;还可以发现元数据表有一个列族称为location&＃xff0c;我们已经知道元数据表每一行代表一个片&＃xff0c;那么为什么需要一个列族来存储地址呢&＃xff1f;因为每个片都可能由多个SSTable文件组成&＃xff0c;列族可以用来存储任意多个SSTable文件的位置。一个合理的假设就是每个SSTable文件的位置信息占据一列&＃xff0c;别名为location:filename。当然不一定非得用列键存储完整文件名&＃xff0c;更大的可能性是把SSTable文件名存在值里。获取了文件名就可以向GFS索要数据了。

第三个线索告诉我们元数据表不止存储位置信息&＃xff0c;也就是说列族不止location&＃xff0c;这些数据暂时不是咱们关心的。

通过以上信息&＃xff0c;我画了一个简化的Bigtable结构图&＃xff1a;

结构图以Webtable表为例&＃xff0c;表中存储了网易、百度和豆瓣的几个网页。当我们想查找百度贴吧昨天的网页内容&＃xff0c;可以向Bigtable发出查询Webtable表的(com.baidu.tieba, contents:, yesterday)。

假设客户端没有该缓存&＃xff0c;那么Bigtable访问root tablet的片服务器&＃xff0c;希望得到该网页所属的片的位置信息在哪个元数据片中。使用
METADATA.Webtable.com.baidu.tieba为行键在root tablet中查找&＃xff0c;定位到最后一个比它大的是
METADATA.Webtable.com.baidu.www&＃xff0c;于是确定需要的就是元数据表的片A。访问片A的片服务器&＃xff0c;继续查找Webtable.com.baidu.tieba&＃xff0c;定位到Webtable.com.baidu.www是比它大的&＃xff0c;确定需要的是Webtable表的片B。访问片B的片服务器&＃xff0c;获得数据。

这里需要注意的是&＃xff0c;每个片实际都由若干SSTable文件和memtable组成&＃xff0c;而且这些SSTable和memtable都是已排序的。这就导致查找片B时&＃xff0c;可能需要将所有SSTable和memtable都查找一遍&＃xff1b;另外客户端应该不会直接从元数据表获得SSTable的文件名&＃xff0c;而只是获得片属于片服务器的信息&＃xff0c;通过片服务器为代理访问SSTable。