|
|
关于MongoDB,我们能看到的资料,基本都是在指导大家如何使用MongoDB,但是,MongoDB内部是如何运作的,资料不是很多。) v @, `$ e, L3 v) | Z
3 R5 k/ i( F/ T1 w& b 阅读使用手册,会有很多疑惑之处。例如,有人说,MongoDB 等同于分布式的 MySQL。它把一个Table ,按 row,分割成多个Shards,分别存放在不同的 Servers 上。这种说法是否正确?
4 ?- u$ b& l0 z# ~* Y; h$ p/ C8 V
% L6 B2 q. O2 U! V* `4 \/ ? 不深入了解 MongoDB 的内部结构,就无法透彻地回答类似问题。这个系列文章,就来和大家探讨MongoDB的内部的工作方式。
# A' ^! z* v: }- d" J" B; m+ s4 k
7 z: r2 Z6 i5 E6 j" D2 f
Y6 X" I8 ~5 W( P e1 {4 g' ^; m3 N4 j3 v5 r# r( J5 Q/ m: s+ t
图1-1 MongoDB架构图
6 E8 `* \) G" B% {7 Y6 k% B" I3 G7 e; `' d5 j ]0 i) W. g
MongoDB 通常运行在一个服务器集群上,而不是一个单机。图1-1,描述了一个MongoDB集群的基本组成部分,包括若干shards,至少一个config server,至少一个routing servers(又称 mongos)。
4 n0 ]3 R! M' [1 z2 Z: i- ]* Q
, U/ K1 W; p+ C1 W, @Shards, A# `7 Y$ K& _3 Z' D
; [% f9 r5 u4 x. w& O$ q- K MongoDB的最基本的数据单元,叫document,类似于关系式数据库中的行 row。一系列documents,组成了一个collection,相当于关系式数据库中的table。当一个 collection 数据量太大时,可以把该collection按documents切分,分成多个数据块,每个数据块叫做一个chunk,多个chunks聚集在一起,组成了一个shard。
8 W+ F4 |9 z" B- {
. T) B) F5 q5 ~, T6 F Sharding 的意义,不仅保障了数据库的扩容(scalability),同时也保障了系统的负载均衡(load balance)。* v! L6 z0 e) [
# z+ {1 u/ z- y( E 每一个shard存储在一个物理服务器(server)上。Server上运行着mongod进程,通过这个进程,对shard中的数据进行操作,主要是增删改查。 H7 c& z Y; [
+ l/ ]9 l- c$ \4 o 如果系统中的每个shard,只存储了一份数据,没有备份,那么当这个shard所在的server挂了,数据就丢失了。在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。 a$ }. U- z4 o
& \9 i# n9 u7 z$ [4 V3 S, ~
Shard keys2 b! o+ u5 q! r/ H Y
! y4 m; m3 x' [5 e9 P
为了把collection切分成不同的chunks,从而存放到不同的shards中,我们需要制定一个切分的方式。2 S: C: w- S8 k5 t9 U+ u
4 Q6 |9 j+ h) h7 N9 H" |: M$ u
如前所述,在 MongoDB 数据库中,一个表collection由多个行 documents 组成,而每个 document,有多个属性 fields。同一个 collection 中的不同的 documents,可能会有不同的 fields。例如,有个 collection 叫 Media,包含两条 documents,
, ~5 m3 _0 O9 a. ?0 p% @0 R6 b' @
3 m6 z- v% r/ s! R, V{
: `* l, ^: ^5 V) Q "ISBN": "987-30-3652-5130-82",
# f. @) }* I4 g' _, I4 Q "Type": "CD",( {" B% v+ [# m
"Author": "Nirvana",% P; g0 r" b. x8 l( L
"Title": "Nevermind",+ s7 K1 Z( ?& e: @- b: T
"Genre": "Grunge",+ `9 p& W# j. S
"Releasedate": "1991.09.24",2 n4 ]7 \& G% R x7 R
"Tracklist": [
2 F) t7 P% J- i9 O* m: [ {
% x# ^! M1 P5 ^ "Track" : "1",2 [: s" u. k/ n" t; \+ g) ?+ u9 [
"Title" : "Smells like teen spirit",# `9 }+ \3 d$ v+ A3 n$ N% z" y
"Length" : "5:02"
3 i4 h Z( j8 q6 t) ~2 X. E' W },
1 O y/ c2 N0 f% g' q9 j/ r t {! Y R% e, T" U
"Track" : "2",: e3 x! K. h I' U+ v% j0 m9 M
"Title" : "In Bloom",+ q6 G" D3 j, Q, W
"Length" : "4:15"* R' P1 O2 Y8 @( a2 Z8 r$ h1 M0 R
}
9 X; u) w! {3 f ]
7 }# H) O; k0 q* J$ r" Z}
# C# R" g5 a5 y( ^+ J' x2 H, x8 P: A. J* U# \* S
{
$ [& {: x4 q: l; w. R. b/ z "ISBN": "987-1-4302-3051-9",. l L, o6 [, n- r
"Type": "Book",
. r: g' A* W8 q- f "Title": "Definite Guide to MongoDB: The NoSQL Database",
- Y( v/ ^; X9 [2 ?0 P! J "Publisher": "Apress",/ X9 E. _. W; e; J/ F! c5 c
"Author": " Eelco Plugge",
8 }* ^) l' y# F, C3 i "Releasedate": "2011.06.09". H" q$ v/ Z, D2 T
}
$ t; W; A' I, l7 \) ~8 v8 U9 y1 C9 V) d9 r: \9 L8 u
假如,在同一个 collection 中的所有 document,都包含某个共同的 field,例如前例中的“ISBN”,那么我们就可以按照这个 field 的值,来分割 collection。这个 field 的值,又称为 shard key。
5 J f* b2 s8 A* }# x! J4 L6 m9 c2 n0 v+ n* d
在选择shard key的时候,一定要确保这个key能够把collection均匀地切分成很多chunks。
! o4 v: a; J: @. F
% y* l$ H8 @* ?& R) K6 c! {' T 例如,如果我们选择“author”作为shard key,如果有大量的作者是重名的,那么就会有大量的数据聚集在同一个chunk中。当然,假设很少有作者同名同姓,那么“author”也可以作为一个shard key。换句话说,shard key 的选择,与使用场景密切相关。9 A' O: I5 w3 W
& I: y! G4 U) n% ]0 x" P; n 很多情况下,无论选择哪一个单一的 field 作为shard key,都无法均匀分割 collection。在这种情况下,我们可以考虑,用多个 fields,构成一个复合的shard key。
4 x, r. T$ x+ r- w. u2 h' n& K# U9 s; S& ^6 S4 I1 ?
延续前例,假如有很多作者同名同姓,他们都叫“王二”。用 author 作为 shard key,显然无法均匀切割 collection。这时我们可以加上release-date,组成name-date的复合 shard key,例如“王二 2011”。3 H! Y# B( l( N
# k' B. H9 M1 _- }
Chunks9 c3 D% J+ G' `; T( m) X# a
7 A' r: V' K8 g3 V; t; H+ o MongoDB按 shard key,把 collection切割成若干 chunks。每个 chunk 的数据结构,是一个三元组,{collection,minKey,maxKey},如图1-2 所示。
& `+ [0 N0 V! [0 n
/ p2 ], X. y, j3 `3 h& s, Y* j
2 `9 \2 R7 q6 I8 ]* i: M' h图1-2 chunk的三元组
a& V( i, O7 x1 w% K2 e( M$ `( V$ E0 a, `: a
其中,collection 是数据库中某一个表的名称,而 minKey 和 maxKey 是 shard key的范围。每一个 document 的shard key 的值,决定了这条document应该存放在哪个chunk中。
( L1 I# z' w4 Y+ P( e+ g( w& _( m5 t D
如果两条 documents 的 shard keys 的值很接近,这两条 documents 很可能被存放在同一个 chunk 中。
8 y) c. V7 o' ~" y k8 N q; H) r4 f5 s; l: i4 c4 }
Shard key 的值的顺序,决定了 document 存放的 chunk。在 MongoDB 的文献中,这种切割 collection 的方式,称为order-preserving。3 n9 O% U2 P% I6 X# Z
; s& B) ?/ q$ [& N6 W
一个 chunk最多能够存储64MB的数据。 当某个chunk存储的 documents包含的数据量,接近这个阈值时,一个chunk会被切分成两个新的chunks。
4 v K" y @1 d% p3 V- O! t" a4 C5 _& K0 j% j5 e9 m& J/ S
当一个shard存储了过多的chunks,这个shard中的某些chunks会被迁移到其它 shard中。
5 K& w, |4 z+ M+ z' l- y0 ?/ u0 u9 F" ?6 X) w4 _
这里有个问题,假如某一条 document 包含的数据量很大,超过 64MB,一个 chunk 存放不下,怎么办?在后续章节介绍 GridFS 时,我们会详细讨论。
) @8 w% M/ I5 h+ o: q& K0 F7 |9 u8 }; I, r3 k+ d
Replica set
7 ?, o* P0 O5 N% U, c& A
5 s4 F, S; W3 D+ R5 ?& x6 W* D: x' ^ 在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。
" H6 B$ W* }6 a7 A5 W
8 b5 \3 T4 f% J8 k0 u9 L3 @- G6 V 这个replica set包括一个primary DB和多个secondary DBs。为了数据的一致性,所有的修改(insert / update / deletes) 请求都交给primary处理。处理结束之后,再异步地备份到其他secondary中。
5 A3 K$ Y7 [) S3 N0 T" ]
8 l. k( H% a5 |/ n Primary DB由replica set中的所有servers,共同选举产生。当这个primaryDB server出错的时候,可以从replica set中重新选举一个新的primaryDB,从而避免了单点故障。
' }9 O* r& B3 L; s7 x) \% y2 U: X% {% u! C# a; S9 [' c
Replica set的选举策略和数据同步机制,确保了系统的数据的一致性。后文详述。
1 [1 n0 C4 x1 a9 Y5 B& f0 i0 O& P9 Y0 G6 f9 q1 c
Config Server
( ]# T* G6 j) Z1 O9 }
3 `. |5 {1 [0 `* b7 m; ]0 l) `! j Config servers用于存储MongoDB集群的元数据 metadata,这些元数据包括如下两个部分,每一个shard server包括哪些chunks,每个chunk存储了哪些 collections 的哪些 documents。3 Y$ I6 ~' E) J$ G) l
. {0 P) T" q# L
每一个config server都包括了MongoDB中所有chunk的信息。
5 V" x( I# Y7 g/ K2 N
+ G8 ~+ K3 Q$ }+ |% m( l Config server也需要 replication。但是有趣的是,config server 采用了自己独特的replication模式,而没有沿用 replica set。
7 O4 ^+ z4 \+ `& L
, d3 y+ [/ K/ w2 X; l- r5 a 如果任何一台config server挂了,整个 config server 集群中,其它 config server变成只读状态。这样做的原因,是避免在系统不稳定的情况下,冒然对元数据做任何改动,导致在不同的 config servers 中,出现元数据不一致的情况。
6 l6 d2 M7 T: W
, H' Y: u) O, C& {: q* E7 Q MongoDB的官方文档建议,配置3个config servers比较合适,既提供了足够的安全性,又避免了更多的config servers实例之间的数据同步,引起的元数据不一致的麻烦。8 U0 s5 @$ R" [5 \* K) z' C
- q* F. ~( `' Z' Z! u
Mongos! a3 F9 A. a' j- ]" w
* g+ d7 X' l2 N! u& o) i
用户使用MongoDB 时,用户的操作请求,全部由mongos来转发。
$ V( d. u+ k% P D" I; W! W+ P5 J" }# ?3 J& N( V
当 mongos 接收到用户请求时,它先查询 config server,找到存放相应数据的shard servers。然后把用户请求,转发到这些 shard servers。当这些 shard servers完成操作后,它们把结果分别返回给 mongos。而当 mongos 汇总了所有的结果后,它把结果返回给用户。* M& D0 t- e) ~/ a% z
' A; W( L: @& ~! f6 b8 J Mongos每次启动的时候,都要到config servers中读取元数据,并缓存在本地。每当 config server中的元数据有改动,它都会通知所有的mongos。
: P) S9 V" m! e! [5 J: A
; a; m2 }2 i/ A Mongos之间,不存在彼此协同工作的问题。因此,MongoDB所需要配置的mongos server的数量,没有限制。- n& |9 g0 b W4 @; S8 }3 d2 r
5 c; x1 o3 Z Y3 q4 O& J
通过以上的介绍,我们对每个组成部分都有了基本的了解,但是涉及到工作的细节,我们尚有诸多疑问,例如,一个chunk的数据太大,如何切分?一个shard数据太多,如何迁移?在replica set中,如何选择primary?server挂了,怎么进行故障恢复?接下来的章节,我们逐个回答这些问题。
7 [ S y, P6 P, U& D8 N5 I9 n2 Z* e7 s4 M" M: N
0 ]2 e, U: C6 T9 e
Reference,
$ e1 U/ u1 ?& `! ^
( ^* \! n. n! C* L# ~[0] Architectural Overview
" n2 i& m. W7 U/ x2 qhttp://www.mongodb.org/display/DOCS/Sharding+Introduction8 Q) R g, S; X% w% N0 f# o
|
评分
-
查看全部评分
|