|
|
关于MongoDB，我们能看到的资料，基本都是在指导大家如何使用MongoDB，但是，MongoDB内部是如何运作的，资料不是很多。: G9 ?7 ]) O6 C# h
. O: d+ l# H( ^% g/ l
阅读使用手册，会有很多疑惑之处。例如，有人说，MongoDB 等同于分布式的 MySQL。它把一个Table ，按 row，分割成多个Shards，分别存放在不同的 Servers 上。这种说法是否正确？
2 V2 v+ X# @' X8 i( `' {
4 Z5 n# ?1 t& R0 T0 n1 Q9 V5 @$ n 不深入了解 MongoDB 的内部结构，就无法透彻地回答类似问题。这个系列文章，就来和大家探讨MongoDB的内部的工作方式。
3 e0 e- y, N7 ^- B W. ~! P1 u! v! `5 f! S# f% N+ T. q2 u- R
7 ]3 f( X# a% H( ` _" K4 D
2 R, H5 p. U8 }6 G图1-1 MongoDB架构图 % F" D% @; ~2 V9 v. m
8 ]2 [# P* z6 _# Y- k% F3 T
MongoDB 通常运行在一个服务器集群上，而不是一个单机。图1-1，描述了一个MongoDB集群的基本组成部分，包括若干shards，至少一个config server，至少一个routing servers（又称 mongos）。3 z. }. }0 e0 m
) x7 }5 A7 w3 ^: V+ }; ]" ~
Shards
+ r( E7 Y; ^) B. ^, H! x! i) {0 l0 G5 m1 O
MongoDB的最基本的数据单元，叫document，类似于关系式数据库中的行 row。一系列documents，组成了一个collection，相当于关系式数据库中的table。当一个 collection 数据量太大时，可以把该collection按documents切分，分成多个数据块，每个数据块叫做一个chunk，多个chunks聚集在一起，组成了一个shard。
/ b9 t4 X6 v4 U F! x2 M- B. T* L# {+ u
Sharding 的意义，不仅保障了数据库的扩容（scalability），同时也保障了系统的负载均衡（load balance）。3 A/ j! s3 ^# ?0 U) A# Y3 g/ B' {) A+ P
5 N7 w% Y/ ]# {7 ?+ g! P1 j& i 每一个shard存储在一个物理服务器（server）上。Server上运行着mongod进程，通过这个进程，对shard中的数据进行操作，主要是增删改查。
) u# h, N# H1 y6 X1 Z6 _8 g& i- y* q. V9 A& R# T
如果系统中的每个shard，只存储了一份数据，没有备份，那么当这个shard所在的server挂了，数据就丢失了。在生产环境中，为了保证数据不丢失，为了提高系统的可用性（availability），每一个shard被存储多份，每个备份所在的servers，组成了一个replica set。
0 g$ s; H1 |9 v! F& Y
! U* E$ e1 H/ L: v. k" ZShard keys$ u) z0 P9 N: C3 Y
6 V, u, m4 j! [ o6 L4 @$ R; E
为了把collection切分成不同的chunks，从而存放到不同的shards中，我们需要制定一个切分的方式。; i3 M0 }% `* C- p
1 L& B- @. N7 n6 [9 A1 |5 d+ l7 M
如前所述，在 MongoDB 数据库中，一个表collection由多个行 documents 组成，而每个 document，有多个属性 fields。同一个 collection 中的不同的 documents，可能会有不同的 fields。例如，有个 collection 叫 Media，包含两条 documents，
) R, r6 e% f3 G2 N" q( d& Y. j+ }9 i9 F- L# ^" z
{
1 V4 }6 q4 ~- v6 L4 _ "ISBN": "987-30-3652-5130-82",6 d9 Z" K2 E) S2 F
"Type": "CD",
! w! E8 x0 W8 u( { "Author": "Nirvana",, y- j! K, I" \' R2 E7 b; m0 K
"Title": "Nevermind",6 V( T' O2 e/ M8 B4 d; j# F1 ~
"Genre": "Grunge",1 R8 i/ x; A: [3 e! L7 P8 n
"Releasedate": "1991.09.24"," k! A( F, u3 c0 a0 @6 K
"Tracklist": [0 _. ?. A9 n) G, w; `
{: v H7 h2 ~* O1 v. W
"Track" : "1",
) U6 M, @% O8 v% l+ W4 h "Title" : "Smells like teen spirit", r. S. m! n6 ?
"Length" : "5:02"
! R) R: I4 g5 X7 w- s' ^3 `9 r },
* U) `' R' q) Z2 N- F G% ] {8 O! ^ s% |/ _+ N4 w
"Track" : "2",
2 V, [' [! Q# L, u "Title" : "In Bloom",
6 m+ ?+ F; A- j "Length" : "4:15"8 @4 E. S! T; h. [
}
. t8 d2 f- R( d1 w, T ]
, X+ t% k; N+ a& R. D7 T}
" a) M8 x$ p( [6 |+ h+ c4 P
9 n0 r; Y; m9 U{1 n) w0 y" P: S9 X8 v9 D9 P# j4 O
"ISBN": "987-1-4302-3051-9",7 M) `* R, Q! q# S1 e
"Type": "Book",
8 p f! f1 e- D$ r0 X$ ~3 z "Title": "Definite Guide to MongoDB: The NoSQL Database",
b2 u- j( @- d' x% G6 g J "Publisher": "Apress",
1 L( Z4 v1 c" _& C) H0 }+ F "Author": " Eelco Plugge",. g g& x: u$ n' e5 ?8 R
"Releasedate": "2011.06.09"8 f$ M" Q' L0 B# T o8 {: B
}" z f% [, V. v+ D+ q. H1 p3 h9 l: T
% s' A5 f2 ~( @. B
假如，在同一个 collection 中的所有 document，都包含某个共同的 field，例如前例中的“ISBN”，那么我们就可以按照这个 field 的值，来分割 collection。这个 field 的值，又称为 shard key。
4 \: V0 }* {' W- D/ ^) {+ D) \2 A. D# m% [8 P; s2 I' l! j* `* `, V
在选择shard key的时候，一定要确保这个key能够把collection均匀地切分成很多chunks。; e @! d5 g( V7 _' T& p: M4 m* K
% h2 B& p3 l& X9 Q1 }- K3 e 例如，如果我们选择“author”作为shard key，如果有大量的作者是重名的，那么就会有大量的数据聚集在同一个chunk中。当然，假设很少有作者同名同姓，那么“author”也可以作为一个shard key。换句话说，shard key 的选择，与使用场景密切相关。
' g) S3 @2 n5 S$ l z' @2 a/ R% t# D* ?3 e( \
很多情况下，无论选择哪一个单一的 field 作为shard key，都无法均匀分割 collection。在这种情况下，我们可以考虑，用多个 fields，构成一个复合的shard key。4 V2 t9 W* {5 i
3 z- g Y+ R# ~5 P
延续前例，假如有很多作者同名同姓，他们都叫“王二”。用 author 作为 shard key，显然无法均匀切割 collection。这时我们可以加上release-date，组成name-date的复合 shard key，例如“王二 2011”。6 h2 p) }6 L: h- V8 A: c/ g" ]
2 L7 m: S8 f7 C4 H5 w3 ^( wChunks. |6 E3 Z, h( P9 f T# _
# Y8 Q( u- Z2 J- G, i' O6 V8 F MongoDB按 shard key，把 collection切割成若干 chunks。每个 chunk 的数据结构，是一个三元组，{collection，minKey，maxKey}，如图1-2 所示。
$ r1 Y U* F. p3 a
7 D! v% P7 d& T& X2 K2 i! ~$ J
3 i, K; l' `4 x" m图1-2 chunk的三元组
* i* B1 ~: \% a1 P7 b5 n9 z% k' K, O2 ?4 ` S
其中，collection 是数据库中某一个表的名称，而 minKey 和 maxKey 是 shard key的范围。每一个 document 的shard key 的值，决定了这条document应该存放在哪个chunk中。
' h4 s* ~! H9 [) z B
# B) ?# p' y( g8 B0 m1 q3 L7 c Y 如果两条 documents 的 shard keys 的值很接近，这两条 documents 很可能被存放在同一个 chunk 中。1 m8 u' }4 A- h2 B6 v2 u6 J$ }+ l
- S0 h4 p1 L3 N Shard key 的值的顺序，决定了 document 存放的 chunk。在 MongoDB 的文献中，这种切割 collection 的方式，称为order-preserving。
1 M2 O0 z7 ?& f& u4 T0 h3 e& [
# b; l4 W7 I g( U6 p% j: _$ D, V- `' O 一个 chunk最多能够存储64MB的数据。 当某个chunk存储的 documents包含的数据量，接近这个阈值时，一个chunk会被切分成两个新的chunks。8 R, b- n% @& {; C4 T+ b
9 d, j }, V) F5 `, `/ u- n
当一个shard存储了过多的chunks，这个shard中的某些chunks会被迁移到其它 shard中。
0 F+ g+ y/ n: N9 m s8 [5 c; X7 \/ \9 ?& ~ m
这里有个问题，假如某一条 document 包含的数据量很大，超过 64MB，一个 chunk 存放不下，怎么办？在后续章节介绍 GridFS 时，我们会详细讨论。9 x( V* l5 j6 ?% v" b- I
3 b( z4 \; T( Q$ V7 }4 g; ~+ l/ eReplica set
( g- x! r2 h: R3 n3 n5 R % L' z- | ?5 {8 U
在生产环境中，为了保证数据不丢失，为了提高系统的可用性（availability），每一个shard被存储多份，每个备份所在的servers，组成了一个replica set。
( I" y4 h1 V, S- x4 K+ B# @/ @ x7 B! ]
这个replica set包括一个primary DB和多个secondary DBs。为了数据的一致性，所有的修改(insert / update / deletes) 请求都交给primary处理。处理结束之后，再异步地备份到其他secondary中。
& }& v' [- S: w
: t( Q7 W( w) a# h8 R6 v! ?5 V7 N Primary DB由replica set中的所有servers，共同选举产生。当这个primaryDB server出错的时候，可以从replica set中重新选举一个新的primaryDB，从而避免了单点故障。
f8 ~! @' t$ T0 A2 d) v- M3 t$ [5 }3 I$ t$ S$ D2 b6 x: E
Replica set的选举策略和数据同步机制，确保了系统的数据的一致性。后文详述。
5 Y# d W0 c0 }- o+ }" k) D7 ?6 g d2 {; `+ H
Config Server
6 D" u4 s% i( {9 Y5 U9 W 5 o( F- y. ~& E9 o C
Config servers用于存储MongoDB集群的元数据 metadata，这些元数据包括如下两个部分，每一个shard server包括哪些chunks，每个chunk存储了哪些 collections 的哪些 documents。
4 g# o* L- w* p% x- b1 c! b
) R% E; l% E/ C- P: g 每一个config server都包括了MongoDB中所有chunk的信息。
, ?' i& O Q: f! c. \6 o: c: Q$ `7 G; N8 r3 q+ }
Config server也需要 replication。但是有趣的是，config server 采用了自己独特的replication模式，而没有沿用 replica set。
6 d) D9 t3 r( K$ @& T
% E- X. x& D q( z$ r; w7 U 如果任何一台config server挂了，整个 config server 集群中，其它 config server变成只读状态。这样做的原因，是避免在系统不稳定的情况下，冒然对元数据做任何改动，导致在不同的 config servers 中，出现元数据不一致的情况。
; p4 t' `7 n0 R8 D& c
6 x- }( }$ {& Z" h0 I, t. n: f MongoDB的官方文档建议，配置3个config servers比较合适，既提供了足够的安全性，又避免了更多的config servers实例之间的数据同步，引起的元数据不一致的麻烦。: }% J6 C( p3 d8 y
' F, V# {. c+ g+ I
Mongos, j& e( x e8 x0 L5 {
0 r3 s/ |& p# m5 Y& G/ _2 f: u 用户使用MongoDB 时，用户的操作请求，全部由mongos来转发。' a; ~) V s9 ?! ^" F: N
- ^2 s+ y: T; O! S' r/ E: v1 |1 ~
当 mongos 接收到用户请求时，它先查询 config server，找到存放相应数据的shard servers。然后把用户请求，转发到这些 shard servers。当这些 shard servers完成操作后，它们把结果分别返回给 mongos。而当 mongos 汇总了所有的结果后，它把结果返回给用户。
. @ v% O- y/ `) R. [$ M/ ]* I h7 A3 L2 L; A2 v' T
Mongos每次启动的时候，都要到config servers中读取元数据，并缓存在本地。每当 config server中的元数据有改动，它都会通知所有的mongos。' U+ I( [) T; i$ U+ `1 h$ [
9 g' E( b, i3 f9 G+ k* j7 n
Mongos之间，不存在彼此协同工作的问题。因此，MongoDB所需要配置的mongos server的数量，没有限制。
. N: m& P( z5 n" T- C% Q M' g! W' ~) ^" Y( I$ A7 T
通过以上的介绍，我们对每个组成部分都有了基本的了解，但是涉及到工作的细节，我们尚有诸多疑问，例如，一个chunk的数据太大，如何切分？一个shard数据太多，如何迁移？在replica set中，如何选择primary？server挂了，怎么进行故障恢复？接下来的章节，我们逐个回答这些问题。. j) t" ]- v# j. g
4 y ^6 J- s1 S/ I$ J$ Z9 N
2 H+ Y2 V" @& B* N& d
Reference，) x2 Y' Y8 r* M0 K
- A& h( H) `. E3 J; \[0] Architectural Overview
6 }, I) D$ R5 o" x+ D' P2 phttp://www.mongodb.org/display/DOCS/Sharding+Introduction
% j0 u* O" ?$ J7 m; L |
评分
-
查看全部评分
|
雷达卡
发表于 2012-9-18 12:31:10
收藏
分享
淘帖
支持
反对
提升卡
置顶卡
沉默卡
喧嚣卡
变色卡
抢沙发
千斤顶
显身卡
楼主
已经给你变成正式会员了。
( ?+ C" o8 C% d" h1 z+ d M