|
关于MongoDB,我们能看到的资料,基本都是在指导大家如何使用MongoDB,但是,MongoDB内部是如何运作的,资料不是很多。" b' y3 B) @8 t4 f
3 A# a& Q4 R, l' g0 N3 J 阅读使用手册,会有很多疑惑之处。例如,有人说,MongoDB 等同于分布式的 MySQL。它把一个Table ,按 row,分割成多个Shards,分别存放在不同的 Servers 上。这种说法是否正确?
2 I/ g& t, r7 ?2 j& E% K9 U6 X- B* C+ }1 J* l1 e# G0 i
不深入了解 MongoDB 的内部结构,就无法透彻地回答类似问题。这个系列文章,就来和大家探讨MongoDB的内部的工作方式。
+ J" g) t; D5 p9 l" w- { J) T& [
$ ]" d, O+ d+ q6 @: Y, d' t! r
+ B! X/ Q# k. ]6 d% f
) S! B2 Y( ~4 H% k5 F+ O k, x
图1-1 MongoDB架构图 : e4 I1 k$ c/ U/ W' v
2 x2 L9 Q8 ]$ T! y) I MongoDB 通常运行在一个服务器集群上,而不是一个单机。图1-1,描述了一个MongoDB集群的基本组成部分,包括若干shards,至少一个config server,至少一个routing servers(又称 mongos)。5 o& Z$ {% H2 s: k
$ a* p! v2 S1 `! `% I, |7 U cShards3 @/ u3 k+ m3 |% \" m7 |
) s( n$ M& v. C7 |9 M5 l+ |( w4 s( r; ]
MongoDB的最基本的数据单元,叫document,类似于关系式数据库中的行 row。一系列documents,组成了一个collection,相当于关系式数据库中的table。当一个 collection 数据量太大时,可以把该collection按documents切分,分成多个数据块,每个数据块叫做一个chunk,多个chunks聚集在一起,组成了一个shard。1 X5 ^- s; F H, m3 W' U b6 W
' ~: v2 B: I1 G" s0 q: d
Sharding 的意义,不仅保障了数据库的扩容(scalability),同时也保障了系统的负载均衡(load balance)。/ a' ^! o' n( |
; R% u$ ~5 m |5 `
每一个shard存储在一个物理服务器(server)上。Server上运行着mongod进程,通过这个进程,对shard中的数据进行操作,主要是增删改查。, P U# @$ P p' _0 d) D2 }$ V, i' r
( C& u7 f& x& r, a6 Y. H 如果系统中的每个shard,只存储了一份数据,没有备份,那么当这个shard所在的server挂了,数据就丢失了。在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。
' S" C- A' K. S* Q- ~" ]+ }" m
8 G* R# C# _# m- t: cShard keys
6 ?% P8 m2 ~* n" d) B& e+ L ' ~9 n# T7 o' E- N7 `) w9 k0 M
为了把collection切分成不同的chunks,从而存放到不同的shards中,我们需要制定一个切分的方式。
+ `1 c0 S& H5 G; t
# l( b, W8 p$ R, {) h" F 如前所述,在 MongoDB 数据库中,一个表collection由多个行 documents 组成,而每个 document,有多个属性 fields。同一个 collection 中的不同的 documents,可能会有不同的 fields。例如,有个 collection 叫 Media,包含两条 documents,
; s: O/ w' R6 ^0 ]7 l2 T2 q: T$ e, I7 r2 D1 H2 G% i+ a/ A
{4 X% d& x9 I2 A: Z
"ISBN": "987-30-3652-5130-82",5 a$ j; N) {! p/ M* J- Q! H7 O% r
"Type": "CD",! U8 P+ A+ N) Z8 E7 O; V
"Author": "Nirvana",+ F* w. Q5 e v& Y y* n, F) P
"Title": "Nevermind",, ^# N- E. [9 x) @+ Z1 \" j
"Genre": "Grunge"," N c: x6 S4 y& F
"Releasedate": "1991.09.24"," @6 x4 S( T1 J
"Tracklist": [8 x0 n8 S8 _' |3 \% X' b
{0 Z& ~3 A- ^/ R3 d
"Track" : "1"," z# L* a& Q: _2 `4 ]* C0 _* C
"Title" : "Smells like teen spirit",% f% W* y) g+ P* l1 r) \4 H
"Length" : "5:02"8 `. V% c1 L- d( d5 @5 U
},
2 g3 Y! i9 u* t7 {4 c: x {
- B) x0 R, ^! f) K+ k) n3 p. W "Track" : "2",
: `6 E4 |% ^" z( |" o "Title" : "In Bloom",' _& S+ q( q$ h4 g
"Length" : "4:15"+ W- {% K4 b+ S0 P3 m) O9 i! e
}
" ]( B, |) w3 a- m1 \) c: W' A ]
; Z) F0 X2 n' `# x}
% s. H# {! u# }/ L+ K9 v. _( r# ~" D" _/ U
{
. p7 f- G$ x9 V) t- o' z4 l9 H7 h "ISBN": "987-1-4302-3051-9",- {0 ^- f& q1 N# b6 n
"Type": "Book",3 j, Q: b) H" h p+ ~
"Title": "Definite Guide to MongoDB: The NoSQL Database",6 Z' Y9 \$ p; P2 f7 q
"Publisher": "Apress",' Y% y* ?) u# b: T, X0 `/ `: ?
"Author": " Eelco Plugge", M; r* _! E- f+ C$ u: i
"Releasedate": "2011.06.09"( ^* W: v$ f) D S5 V
}! K/ J; B( }/ l: b4 R2 Z% s0 B
- a" h( j% a6 L- L1 b1 b7 F 假如,在同一个 collection 中的所有 document,都包含某个共同的 field,例如前例中的“ISBN”,那么我们就可以按照这个 field 的值,来分割 collection。这个 field 的值,又称为 shard key。7 E9 h P. W: ` G+ H7 E
2 M3 c6 L" [+ B$ M3 ^8 h2 q
在选择shard key的时候,一定要确保这个key能够把collection均匀地切分成很多chunks。
" x6 k- J/ `( B. r% J8 Y
( ?6 k* p9 r3 U3 x( S 例如,如果我们选择“author”作为shard key,如果有大量的作者是重名的,那么就会有大量的数据聚集在同一个chunk中。当然,假设很少有作者同名同姓,那么“author”也可以作为一个shard key。换句话说,shard key 的选择,与使用场景密切相关。
+ G3 P2 d" w3 h) n8 v' ]$ v
2 D4 b4 q( l$ A 很多情况下,无论选择哪一个单一的 field 作为shard key,都无法均匀分割 collection。在这种情况下,我们可以考虑,用多个 fields,构成一个复合的shard key。
7 f8 ^4 J* _3 B1 b- y( I- ~5 U- ~0 ?1 A( e9 j9 N! Y0 o
延续前例,假如有很多作者同名同姓,他们都叫“王二”。用 author 作为 shard key,显然无法均匀切割 collection。这时我们可以加上release-date,组成name-date的复合 shard key,例如“王二 2011”。
7 j/ m) [% T9 ^$ b1 m- ]
+ x0 b1 v2 z2 U8 L$ |; Q uChunks
- \% p+ Z" |6 `4 r . j5 N# V4 o7 J. y- ]4 U
MongoDB按 shard key,把 collection切割成若干 chunks。每个 chunk 的数据结构,是一个三元组,{collection,minKey,maxKey},如图1-2 所示。% v# W) J: O. m
2 D) [8 N% i, b3 M9 Z2 ~/ \& g3 |& Z
* @/ k+ {/ [$ w5 P
图1-2 chunk的三元组 ) ^: m* _1 Q5 F, ^( ~) w
0 P5 S3 W, N/ v- ^! A# e; Q
其中,collection 是数据库中某一个表的名称,而 minKey 和 maxKey 是 shard key的范围。每一个 document 的shard key 的值,决定了这条document应该存放在哪个chunk中。
; Z6 w0 o& Q- m7 v* ?8 f ]/ P1 ~! p) |. A6 g7 L
如果两条 documents 的 shard keys 的值很接近,这两条 documents 很可能被存放在同一个 chunk 中。) ^% H8 m0 m, c j S! |% ]' h
! n! Z( U: B* A# J& v* N% q
Shard key 的值的顺序,决定了 document 存放的 chunk。在 MongoDB 的文献中,这种切割 collection 的方式,称为order-preserving。
0 E+ t9 w/ Q* m+ K
2 v0 q/ k4 a! a 一个 chunk最多能够存储64MB的数据。 当某个chunk存储的 documents包含的数据量,接近这个阈值时,一个chunk会被切分成两个新的chunks。
/ j9 [ \: i7 ~4 J; R5 M
3 c3 [3 U" ?# {- J% X7 u" m 当一个shard存储了过多的chunks,这个shard中的某些chunks会被迁移到其它 shard中。5 G- y3 d O2 h# L( S7 i; l
5 ?4 h" @; G' }5 K9 w: ?: ~& W 这里有个问题,假如某一条 document 包含的数据量很大,超过 64MB,一个 chunk 存放不下,怎么办?在后续章节介绍 GridFS 时,我们会详细讨论。, C. u* S% _3 y m4 H! M
: F/ L4 n, Y. w1 W$ @
Replica set | H( }/ c; V7 x% X- a# ^
6 p) w) }9 G* v( d: \2 m2 [
在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。6 _ r% C( b7 E1 g+ \' V+ T% O7 X
) i$ t j5 @/ [$ _& b9 v4 d$ y 这个replica set包括一个primary DB和多个secondary DBs。为了数据的一致性,所有的修改(insert / update / deletes) 请求都交给primary处理。处理结束之后,再异步地备份到其他secondary中。
) D9 Z2 j0 X* k2 |: `9 d" P8 [+ V% H2 U
Primary DB由replica set中的所有servers,共同选举产生。当这个primaryDB server出错的时候,可以从replica set中重新选举一个新的primaryDB,从而避免了单点故障。3 K- v3 j1 A+ W3 `
" Y# R7 ]; ^% [& b$ A/ o/ \# N
Replica set的选举策略和数据同步机制,确保了系统的数据的一致性。后文详述。. e. J6 c3 u3 Y+ t( k- k* z
, w% D8 v4 r9 [" W: l- HConfig Server
: a9 T6 d; e) K
& o' S, N6 s( W0 ] Config servers用于存储MongoDB集群的元数据 metadata,这些元数据包括如下两个部分,每一个shard server包括哪些chunks,每个chunk存储了哪些 collections 的哪些 documents。5 r n/ \, [4 F. U
( _0 S! U" d3 L2 c7 T) H8 a 每一个config server都包括了MongoDB中所有chunk的信息。
" I* B6 Z) r4 Y$ ~
, `* b! e; J' `- i% a Config server也需要 replication。但是有趣的是,config server 采用了自己独特的replication模式,而没有沿用 replica set。
% T9 s& i0 l$ f! E" X8 e
) ~$ S$ w0 n$ n2 `* S Q* j0 r 如果任何一台config server挂了,整个 config server 集群中,其它 config server变成只读状态。这样做的原因,是避免在系统不稳定的情况下,冒然对元数据做任何改动,导致在不同的 config servers 中,出现元数据不一致的情况。5 F% s/ D4 c8 Q3 H+ b
! c$ m5 v) P% u/ G* y MongoDB的官方文档建议,配置3个config servers比较合适,既提供了足够的安全性,又避免了更多的config servers实例之间的数据同步,引起的元数据不一致的麻烦。
7 E3 u$ j- V1 P) @$ O7 Z* w8 z" n y- P6 G/ a( k! ?8 D% @2 z! j
Mongos
! ?+ Y0 b5 s7 Z- b5 D8 k4 @1 V, n: U$ {
用户使用MongoDB 时,用户的操作请求,全部由mongos来转发。
( a2 a+ B. y" R5 {) b
K$ \# u0 g% f% v1 u! o 当 mongos 接收到用户请求时,它先查询 config server,找到存放相应数据的shard servers。然后把用户请求,转发到这些 shard servers。当这些 shard servers完成操作后,它们把结果分别返回给 mongos。而当 mongos 汇总了所有的结果后,它把结果返回给用户。
' J B, G7 L3 p3 S1 ^# C8 P$ p! u* i" i/ ^- P, ? O W
Mongos每次启动的时候,都要到config servers中读取元数据,并缓存在本地。每当 config server中的元数据有改动,它都会通知所有的mongos。6 W3 P/ t0 E6 Q8 y
) N& ^7 {/ T+ [$ F% J3 x
Mongos之间,不存在彼此协同工作的问题。因此,MongoDB所需要配置的mongos server的数量,没有限制。* ~9 t, ^' B- D
% n( t& k$ ?2 J
通过以上的介绍,我们对每个组成部分都有了基本的了解,但是涉及到工作的细节,我们尚有诸多疑问,例如,一个chunk的数据太大,如何切分?一个shard数据太多,如何迁移?在replica set中,如何选择primary?server挂了,怎么进行故障恢复?接下来的章节,我们逐个回答这些问题。2 @3 L. n" Z3 g+ }' x" q
# n) p: w1 h" @, W/ {6 g
/ T0 E3 ^8 B/ }0 O/ H+ nReference,
$ g. b5 J: t! t7 ]& B. M& M' t7 j+ g5 }) S
[0] Architectural Overview# n7 {4 A7 s1 c2 \+ `1 ^
http://www.mongodb.org/display/DOCS/Sharding+Introduction5 B5 s. m: Q) }
|
评分
-
查看全部评分
|