|
|
关于MongoDB,我们能看到的资料,基本都是在指导大家如何使用MongoDB,但是,MongoDB内部是如何运作的,资料不是很多。
5 h+ G/ l9 o; x8 }1 a0 k/ P J0 `. p* z) E, E# |3 r: |$ V
阅读使用手册,会有很多疑惑之处。例如,有人说,MongoDB 等同于分布式的 MySQL。它把一个Table ,按 row,分割成多个Shards,分别存放在不同的 Servers 上。这种说法是否正确?
9 R" l$ C6 N9 K
8 y% ^# s; J* R) }9 }2 l 不深入了解 MongoDB 的内部结构,就无法透彻地回答类似问题。这个系列文章,就来和大家探讨MongoDB的内部的工作方式。
, f$ ~ y3 _, u& N' W- T0 @9 U, H7 i7 S( O$ U* [
: X3 s/ X. i8 j2 H- i! h
: i' E+ P+ O" k; P3 F: y图1-1 MongoDB架构图
8 t' W3 K$ O- b/ _( L# {8 u, [8 k! |7 X5 n; p/ S- O
MongoDB 通常运行在一个服务器集群上,而不是一个单机。图1-1,描述了一个MongoDB集群的基本组成部分,包括若干shards,至少一个config server,至少一个routing servers(又称 mongos)。/ u7 a3 F: G# G3 Y$ t
! q+ O2 U j4 u8 ^# G; y$ ^( M/ t3 IShards( V) {- o. L0 J/ y3 e9 T
) L0 d+ T0 Z2 u9 m6 N
MongoDB的最基本的数据单元,叫document,类似于关系式数据库中的行 row。一系列documents,组成了一个collection,相当于关系式数据库中的table。当一个 collection 数据量太大时,可以把该collection按documents切分,分成多个数据块,每个数据块叫做一个chunk,多个chunks聚集在一起,组成了一个shard。
( K, x* H6 f6 r T6 B; R9 f! l# ^$ j& `; h/ W4 s& V
Sharding 的意义,不仅保障了数据库的扩容(scalability),同时也保障了系统的负载均衡(load balance)。
4 D; l' `4 [1 c7 h1 w# E0 O4 E0 }) c% r6 R1 A) W
每一个shard存储在一个物理服务器(server)上。Server上运行着mongod进程,通过这个进程,对shard中的数据进行操作,主要是增删改查。, F7 \" K' g; i) T1 N9 a2 t3 A
2 c: _/ q- _- ~7 ^* o) E 如果系统中的每个shard,只存储了一份数据,没有备份,那么当这个shard所在的server挂了,数据就丢失了。在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。5 x: w. L) j( M- N; q; o: ?
8 W+ G2 u/ R6 n: D U1 uShard keys
1 y. ?$ V! V& u ; x$ g5 P* |& u, ]# u* T9 X* Q
为了把collection切分成不同的chunks,从而存放到不同的shards中,我们需要制定一个切分的方式。1 L. N/ z8 N O0 V$ l8 k4 t- E
$ n$ e4 w) N# H/ `: n 如前所述,在 MongoDB 数据库中,一个表collection由多个行 documents 组成,而每个 document,有多个属性 fields。同一个 collection 中的不同的 documents,可能会有不同的 fields。例如,有个 collection 叫 Media,包含两条 documents,
: ]8 M. y% i' s9 V0 e8 j9 S- \9 X. D* n& v; Q6 V7 f
{
j% C8 E$ M ?5 ? "ISBN": "987-30-3652-5130-82",9 G+ k) Z* i% m9 @
"Type": "CD", c$ j% j. P2 H/ C5 {3 i9 p) _2 T% ~
"Author": "Nirvana",
$ o6 f" K* r" L- j2 ~! { "Title": "Nevermind",
, l7 R9 E4 v J; N0 m w, k) W. g "Genre": "Grunge",
3 Y/ ^3 t4 D/ n- ?7 O "Releasedate": "1991.09.24",
$ y9 ~/ D, [& k0 X, I) N "Tracklist": [ B* D8 G0 C0 r: Y' ~
{" D, V+ b7 G9 `
"Track" : "1",5 b" e. m; J. P. z
"Title" : "Smells like teen spirit",
7 n$ ?2 Y8 k2 T ? "Length" : "5:02"/ o% }7 K* \; J, g
},
6 h) t" l1 f' c. E% x5 k {/ l& J7 Y# N9 Y, ~* i; j& j, M
"Track" : "2",6 E3 i0 z2 G8 t, E$ f! R/ X! @5 J
"Title" : "In Bloom",
* B9 g" Q; V# r; c) w, w: z( C "Length" : "4:15"! L( _" l3 I) Q& q, d& ]* \ Y5 ]- T
}' b0 p$ V* }( ^) O, S
]
' G1 v4 z/ P( w}
+ O. P+ _( T- X% x8 E* n* `( N9 z# y% W, |2 r: \
{" U+ q9 r i0 ~/ t" f% u0 U3 o
"ISBN": "987-1-4302-3051-9",
3 n# I7 B; ?' ?5 ~2 O% Q7 r0 X j9 E "Type": "Book",
) n3 u+ O# V. X+ K4 L8 N2 C: r "Title": "Definite Guide to MongoDB: The NoSQL Database",
+ S7 A/ q T/ h! J) F7 S j" Z "Publisher": "Apress",& m) E4 v5 S5 c
"Author": " Eelco Plugge",/ e1 w' M, X, U- f1 ]0 {+ O
"Releasedate": "2011.06.09"7 [1 N, T, k* ~1 p6 A( e9 M( n
}2 `2 i. {& u/ p) y# i
2 B* Y& ^# C# @# V4 J5 d' ~
假如,在同一个 collection 中的所有 document,都包含某个共同的 field,例如前例中的“ISBN”,那么我们就可以按照这个 field 的值,来分割 collection。这个 field 的值,又称为 shard key。' S) l+ k5 @' R2 o! f- p( W' y
. w- J* E! K7 H* H 在选择shard key的时候,一定要确保这个key能够把collection均匀地切分成很多chunks。
8 F4 h4 u, J. ~0 K0 P
( D- G g& D; | 例如,如果我们选择“author”作为shard key,如果有大量的作者是重名的,那么就会有大量的数据聚集在同一个chunk中。当然,假设很少有作者同名同姓,那么“author”也可以作为一个shard key。换句话说,shard key 的选择,与使用场景密切相关。+ N' f5 d" g" z y# P
8 @+ [7 u0 B5 {" X L: f 很多情况下,无论选择哪一个单一的 field 作为shard key,都无法均匀分割 collection。在这种情况下,我们可以考虑,用多个 fields,构成一个复合的shard key。9 J3 f5 m! W: N' @4 J3 Z8 n
1 f3 |2 D! I1 f# y5 k3 [ 延续前例,假如有很多作者同名同姓,他们都叫“王二”。用 author 作为 shard key,显然无法均匀切割 collection。这时我们可以加上release-date,组成name-date的复合 shard key,例如“王二 2011”。
4 D2 H* |6 d8 j. c1 `& V
+ U8 t1 K3 d3 Z7 k3 I# n; k1 hChunks2 W1 x' ~' h! m, u/ H
$ {7 J3 x' i5 {9 ?( J- [# m# w# O7 d' [
MongoDB按 shard key,把 collection切割成若干 chunks。每个 chunk 的数据结构,是一个三元组,{collection,minKey,maxKey},如图1-2 所示。
( J; ?! n- o1 q* K+ Q
1 t9 w* A) i% X& p/ Y
7 o; c# T7 T+ K/ q) F
图1-2 chunk的三元组 $ e/ c7 _: T1 N( u' O" a$ U
$ x5 @8 b* G7 W+ B4 ~ 其中,collection 是数据库中某一个表的名称,而 minKey 和 maxKey 是 shard key的范围。每一个 document 的shard key 的值,决定了这条document应该存放在哪个chunk中。
]" ^* Q" a7 d5 x% l
# E. ^4 N% d- i" j/ W* D 如果两条 documents 的 shard keys 的值很接近,这两条 documents 很可能被存放在同一个 chunk 中。
3 J, t. m, `3 K' N" g6 ~- w9 N. b7 n/ G; H' b7 P7 m- H$ m* z/ r
Shard key 的值的顺序,决定了 document 存放的 chunk。在 MongoDB 的文献中,这种切割 collection 的方式,称为order-preserving。
, x7 |# j$ Y6 W5 _7 T1 D/ h" Q8 F
一个 chunk最多能够存储64MB的数据。 当某个chunk存储的 documents包含的数据量,接近这个阈值时,一个chunk会被切分成两个新的chunks。- g7 t- L4 ?. D$ t4 \
+ s: A5 {8 A' W8 e 当一个shard存储了过多的chunks,这个shard中的某些chunks会被迁移到其它 shard中。
) F) v" W5 Q9 |% d5 J" e9 r4 U. L% }$ e+ V0 A# s
这里有个问题,假如某一条 document 包含的数据量很大,超过 64MB,一个 chunk 存放不下,怎么办?在后续章节介绍 GridFS 时,我们会详细讨论。
8 _% V/ y. B7 A5 u+ u: H- F+ o' V( h0 P6 C
Replica set3 ]( J' e1 o% k
- I2 q; n$ N" V" n8 t
在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。
! M- Q7 K. ~( W. |, n- Y) R3 m5 E, _/ r
4 D5 Y! c# m' U. o7 ?! Q7 V 这个replica set包括一个primary DB和多个secondary DBs。为了数据的一致性,所有的修改(insert / update / deletes) 请求都交给primary处理。处理结束之后,再异步地备份到其他secondary中。4 }2 I) s1 a0 s) \) j" M
( w* ?! Q+ G( i6 a7 b$ a1 x Primary DB由replica set中的所有servers,共同选举产生。当这个primaryDB server出错的时候,可以从replica set中重新选举一个新的primaryDB,从而避免了单点故障。
U9 p5 @/ R) k' ]5 Z6 u$ C2 `6 z u8 h" U
Replica set的选举策略和数据同步机制,确保了系统的数据的一致性。后文详述。
% F3 L2 R+ S# r" V" f' x
( ]+ Y$ \1 _0 D) z2 qConfig Server
& s# L) W; r; V- r4 J8 P" ?) P3 X ; ]$ Z' u0 I; p* w" p8 W: ^
Config servers用于存储MongoDB集群的元数据 metadata,这些元数据包括如下两个部分,每一个shard server包括哪些chunks,每个chunk存储了哪些 collections 的哪些 documents。' R8 X" z4 K6 Q' d3 y3 N
0 O+ x: m% j) k- _! O. J: g 每一个config server都包括了MongoDB中所有chunk的信息。
- w$ r* d$ P# d8 Y: c7 R3 l* {* v( T/ v8 g; E
Config server也需要 replication。但是有趣的是,config server 采用了自己独特的replication模式,而没有沿用 replica set。
Y: Y) w$ E% t( W5 G9 D) m
3 Y+ V- E; v$ i$ U" J 如果任何一台config server挂了,整个 config server 集群中,其它 config server变成只读状态。这样做的原因,是避免在系统不稳定的情况下,冒然对元数据做任何改动,导致在不同的 config servers 中,出现元数据不一致的情况。% Q( c( q4 K9 C" O3 O5 N# g: s( E
: d( h+ X) \' v4 g9 A MongoDB的官方文档建议,配置3个config servers比较合适,既提供了足够的安全性,又避免了更多的config servers实例之间的数据同步,引起的元数据不一致的麻烦。" n8 Q; d+ _$ O( f; ~$ k6 r+ ^
7 W% y' g: L- @3 M5 X4 _, x; N) G% Z
Mongos
) t) a! a/ V8 S1 x3 ], B# v
C1 o3 j; p3 t4 E4 _5 R- f 用户使用MongoDB 时,用户的操作请求,全部由mongos来转发。; t% p4 _/ Q1 y3 ?5 z5 \ D
: _+ I3 M4 W2 Q& J( q9 V 当 mongos 接收到用户请求时,它先查询 config server,找到存放相应数据的shard servers。然后把用户请求,转发到这些 shard servers。当这些 shard servers完成操作后,它们把结果分别返回给 mongos。而当 mongos 汇总了所有的结果后,它把结果返回给用户。2 G2 h: O9 `8 U/ p
& p7 f) z( G- S/ T Mongos每次启动的时候,都要到config servers中读取元数据,并缓存在本地。每当 config server中的元数据有改动,它都会通知所有的mongos。- D. |* K: s2 j6 z; P% ?
; y' M, Q% Q+ ^ Mongos之间,不存在彼此协同工作的问题。因此,MongoDB所需要配置的mongos server的数量,没有限制。/ C# }7 ?- T4 }9 e
. A {8 h e" ]1 I( a5 I 通过以上的介绍,我们对每个组成部分都有了基本的了解,但是涉及到工作的细节,我们尚有诸多疑问,例如,一个chunk的数据太大,如何切分?一个shard数据太多,如何迁移?在replica set中,如何选择primary?server挂了,怎么进行故障恢复?接下来的章节,我们逐个回答这些问题。
( H. }* _% L2 x4 R; I8 o" ?9 ~$ W/ Y1 g4 o. P
* g% L5 \& B1 @+ T2 i
Reference,
1 |! R- c8 j0 g: \/ C+ i8 \
6 m% G! C; h( c+ W$ `4 i[0] Architectural Overview* U( F' M- r$ p+ Y3 H% w$ T
http://www.mongodb.org/display/DOCS/Sharding+Introduction7 j. O2 a2 j. R- L, i5 l
|
评分
-
查看全部评分
|