|
|
关于MongoDB,我们能看到的资料,基本都是在指导大家如何使用MongoDB,但是,MongoDB内部是如何运作的,资料不是很多。, U$ Q$ t* w+ f' `6 \9 B
* b- V9 Z/ j5 Q N. D. H/ h
阅读使用手册,会有很多疑惑之处。例如,有人说,MongoDB 等同于分布式的 MySQL。它把一个Table ,按 row,分割成多个Shards,分别存放在不同的 Servers 上。这种说法是否正确?* t' w5 P! T( r4 ?! x0 M: a
# r, h2 g4 K& C, c- G7 e, ] 不深入了解 MongoDB 的内部结构,就无法透彻地回答类似问题。这个系列文章,就来和大家探讨MongoDB的内部的工作方式。
- I3 Q+ {* `, g8 q0 g# `* W
" d, B! U L1 p$ S
) F( B/ ]% V9 J" b/ Z0 c
5 Y& h; W5 f6 G- S" }
图1-1 MongoDB架构图 % `# y) D1 V) N2 \3 E
0 }% x; f" ?1 Q! {
MongoDB 通常运行在一个服务器集群上,而不是一个单机。图1-1,描述了一个MongoDB集群的基本组成部分,包括若干shards,至少一个config server,至少一个routing servers(又称 mongos)。& Z( X- {( v& [- ~" {2 I
9 F2 g/ W6 U, \5 m( NShards' b7 o$ d( |7 w1 d
) t0 U w3 E: l! e- P; U1 g MongoDB的最基本的数据单元,叫document,类似于关系式数据库中的行 row。一系列documents,组成了一个collection,相当于关系式数据库中的table。当一个 collection 数据量太大时,可以把该collection按documents切分,分成多个数据块,每个数据块叫做一个chunk,多个chunks聚集在一起,组成了一个shard。/ C J+ s% |$ c+ A6 l& {2 v6 f7 d
, _, I8 u/ |. X8 F6 `% G" |
Sharding 的意义,不仅保障了数据库的扩容(scalability),同时也保障了系统的负载均衡(load balance)。! s2 o' U( v* f* r8 E/ w* W5 R a: e
+ q, j* x8 u$ J) p0 U- U( { 每一个shard存储在一个物理服务器(server)上。Server上运行着mongod进程,通过这个进程,对shard中的数据进行操作,主要是增删改查。
& P* `+ M$ j6 L, a1 n3 A& ~$ h; _) S" p* t, ?
如果系统中的每个shard,只存储了一份数据,没有备份,那么当这个shard所在的server挂了,数据就丢失了。在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。
8 T4 _7 {: R" m% W3 x% \ o5 u7 H; J+ E" ]+ r
Shard keys }- Z2 Y8 c! i( @! G" y( G* e
* u! {& [0 I. U/ n/ U+ j, } 为了把collection切分成不同的chunks,从而存放到不同的shards中,我们需要制定一个切分的方式。
8 m" h2 s! z" V- B1 K9 [
; v" m# t- s8 F: S7 N) P6 p 如前所述,在 MongoDB 数据库中,一个表collection由多个行 documents 组成,而每个 document,有多个属性 fields。同一个 collection 中的不同的 documents,可能会有不同的 fields。例如,有个 collection 叫 Media,包含两条 documents,
9 ^8 J& T6 P9 y# V: O
. Y" c( s! y+ K7 _; Z{9 c) ]" l7 K9 V5 V/ m* l; w
"ISBN": "987-30-3652-5130-82",
6 ^+ {: a0 F- @4 ? "Type": "CD",
$ V% I; X7 m2 o/ z+ a "Author": "Nirvana",
4 S+ `9 V4 v' u! @/ i, {' @2 c% A: @ "Title": "Nevermind",' K* Z. J' k1 b$ m
"Genre": "Grunge",0 N& P) x, U9 Y! Z$ E. P
"Releasedate": "1991.09.24",
( ]# `0 P* ?* s: R; j "Tracklist": [+ R& I. ~5 _' a0 y: o) v
{
; [3 V, A$ @3 b6 x "Track" : "1",9 M2 d9 J0 e# |5 t) d! [3 t3 x& V
"Title" : "Smells like teen spirit",
4 |" S8 r s1 q3 s% U" D7 X8 Y "Length" : "5:02"* H6 v7 _- G$ K5 ^; c
},
1 J# O, R6 ]$ G8 \% Q {
) v+ m7 C! c9 X) I% G "Track" : "2",
5 X& i4 t' B: e6 K& p "Title" : "In Bloom",
" M* Z/ [' d+ W; E# T( V$ ] "Length" : "4:15"
% q& t0 {$ e# K2 A+ c$ T }
! K& @! O/ }9 _4 l. |. R$ _ ]
' m$ _/ ]! P6 D: D' n, f: @}. i: c. Q A1 ^2 m9 M$ e
2 d" L& h: C, R9 I4 ^/ Z Y; s0 h{" \) w- C9 {# a7 B
"ISBN": "987-1-4302-3051-9",
9 h4 Z5 S& q# b; G# i6 n "Type": "Book",0 U! |$ ?# i5 u8 U4 K: q
"Title": "Definite Guide to MongoDB: The NoSQL Database",
6 g; D# Y. S$ ^3 H+ _ "Publisher": "Apress",& H. A H* e/ P5 s- k
"Author": " Eelco Plugge",
& U* C) o7 G7 S3 y "Releasedate": "2011.06.09"# v1 _" H1 w! L# Y+ z
}4 ]4 X5 ]5 v( U" d) i v w+ V
' |, H- U1 I' K 假如,在同一个 collection 中的所有 document,都包含某个共同的 field,例如前例中的“ISBN”,那么我们就可以按照这个 field 的值,来分割 collection。这个 field 的值,又称为 shard key。8 ?5 H7 m1 S& ~; d6 ^7 H: x
, T3 k' N% ? Q/ U" u/ _ 在选择shard key的时候,一定要确保这个key能够把collection均匀地切分成很多chunks。
1 s6 W$ Q# [( u: v( j3 K" ^4 ^) C. w8 [. V
例如,如果我们选择“author”作为shard key,如果有大量的作者是重名的,那么就会有大量的数据聚集在同一个chunk中。当然,假设很少有作者同名同姓,那么“author”也可以作为一个shard key。换句话说,shard key 的选择,与使用场景密切相关。
# W% L' w8 x$ n7 U, ^; ?
" u3 P3 {4 x2 E! e" | 很多情况下,无论选择哪一个单一的 field 作为shard key,都无法均匀分割 collection。在这种情况下,我们可以考虑,用多个 fields,构成一个复合的shard key。, L7 s& c0 ]; b) Y, d
: g8 L0 ?5 p8 x0 ]$ C! L
延续前例,假如有很多作者同名同姓,他们都叫“王二”。用 author 作为 shard key,显然无法均匀切割 collection。这时我们可以加上release-date,组成name-date的复合 shard key,例如“王二 2011”。/ w. P9 o8 m8 b! }
u5 ~& N2 @7 Q" L5 f1 W4 {
Chunks, h5 ]# I8 q8 b! l; O( e: q0 m6 b
6 r( ]; S/ i2 E7 A2 E MongoDB按 shard key,把 collection切割成若干 chunks。每个 chunk 的数据结构,是一个三元组,{collection,minKey,maxKey},如图1-2 所示。; c- B/ r p9 X! K6 y1 o
. f9 X* e' W0 [5 k) `3 Z0 H
' i5 c" c X! o' W. M" z3 x图1-2 chunk的三元组 & I+ U) _) T& s+ N r* J
* A/ ]$ O. d3 q5 \4 q) p. } 其中,collection 是数据库中某一个表的名称,而 minKey 和 maxKey 是 shard key的范围。每一个 document 的shard key 的值,决定了这条document应该存放在哪个chunk中。, o2 g. u! A1 W
5 _( H$ [8 K2 ` 如果两条 documents 的 shard keys 的值很接近,这两条 documents 很可能被存放在同一个 chunk 中。: G0 s% K% c2 M. C/ ~
2 z% M! d! W) I) [; ~9 q+ [
Shard key 的值的顺序,决定了 document 存放的 chunk。在 MongoDB 的文献中,这种切割 collection 的方式,称为order-preserving。( x! p: ]4 N7 Y, a& A
S6 y/ S9 g N4 n& }# } 一个 chunk最多能够存储64MB的数据。 当某个chunk存储的 documents包含的数据量,接近这个阈值时,一个chunk会被切分成两个新的chunks。9 [' b) \. ^. l4 t7 M1 |
+ ?4 y- f1 G5 } ]6 f
当一个shard存储了过多的chunks,这个shard中的某些chunks会被迁移到其它 shard中。
( b& |+ w; @% F, H0 E0 f# U% r& `2 ?: e0 C( e1 q6 F
这里有个问题,假如某一条 document 包含的数据量很大,超过 64MB,一个 chunk 存放不下,怎么办?在后续章节介绍 GridFS 时,我们会详细讨论。3 c) n' r8 ?5 [
2 e+ x# J( z! pReplica set" f0 Z# F! }+ Y
# d4 C- M/ S, |8 @7 S( T4 K2 h: o5 T( v
在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。 s! n+ u5 W) C3 o" V( |" m! y
; H, y- d8 Y8 W1 y3 l) k# M# W
这个replica set包括一个primary DB和多个secondary DBs。为了数据的一致性,所有的修改(insert / update / deletes) 请求都交给primary处理。处理结束之后,再异步地备份到其他secondary中。
4 o; j8 h& e" ~4 I1 E0 u2 Q7 V5 h- Q, X0 ]6 H7 @+ {3 m2 v# w3 U
Primary DB由replica set中的所有servers,共同选举产生。当这个primaryDB server出错的时候,可以从replica set中重新选举一个新的primaryDB,从而避免了单点故障。6 {* d% R: j3 t9 J. G
* E% A$ Q0 u2 V! _/ h
Replica set的选举策略和数据同步机制,确保了系统的数据的一致性。后文详述。
0 s& c7 j' f% _0 w" k0 P6 K' B4 z3 K& U+ d1 A% ^9 J. S* {8 E5 ?% Z0 B
Config Server6 ^2 i- e$ n1 y2 d
. [' |- L8 V: O. G$ H0 }- J
Config servers用于存储MongoDB集群的元数据 metadata,这些元数据包括如下两个部分,每一个shard server包括哪些chunks,每个chunk存储了哪些 collections 的哪些 documents。. M) g4 A* r: a9 h& M
! a$ x7 ]/ N1 s0 Z: V5 D
每一个config server都包括了MongoDB中所有chunk的信息。, J1 D9 d& V0 ?
5 F9 n; d9 F* y4 n; J% N Config server也需要 replication。但是有趣的是,config server 采用了自己独特的replication模式,而没有沿用 replica set。( g% ^* B. z4 S1 \
% T6 G- }; a2 v$ x8 t7 Z# i/ v3 B" v 如果任何一台config server挂了,整个 config server 集群中,其它 config server变成只读状态。这样做的原因,是避免在系统不稳定的情况下,冒然对元数据做任何改动,导致在不同的 config servers 中,出现元数据不一致的情况。
" c: K& u7 V& T6 _
1 V# m9 m% B: E, P( M MongoDB的官方文档建议,配置3个config servers比较合适,既提供了足够的安全性,又避免了更多的config servers实例之间的数据同步,引起的元数据不一致的麻烦。: c, C& b1 O4 ~8 `
: K3 J+ t# k+ XMongos
% g. M7 s8 G! ~& M9 X# h9 ~2 k. ?, B0 E
用户使用MongoDB 时,用户的操作请求,全部由mongos来转发。3 M6 |4 q3 o6 G# g) M" z% ]
- T6 x D9 W% a. V 当 mongos 接收到用户请求时,它先查询 config server,找到存放相应数据的shard servers。然后把用户请求,转发到这些 shard servers。当这些 shard servers完成操作后,它们把结果分别返回给 mongos。而当 mongos 汇总了所有的结果后,它把结果返回给用户。8 h+ C W- X* I) x {" c
- X' ?9 j8 J0 p" ~2 Q
Mongos每次启动的时候,都要到config servers中读取元数据,并缓存在本地。每当 config server中的元数据有改动,它都会通知所有的mongos。
1 I. m0 y2 B1 Z
6 Y: j* s+ \; ^3 u Mongos之间,不存在彼此协同工作的问题。因此,MongoDB所需要配置的mongos server的数量,没有限制。2 T: D3 o2 M6 {' o$ `; J+ `, L
( s# B' r( P: z9 M _ 通过以上的介绍,我们对每个组成部分都有了基本的了解,但是涉及到工作的细节,我们尚有诸多疑问,例如,一个chunk的数据太大,如何切分?一个shard数据太多,如何迁移?在replica set中,如何选择primary?server挂了,怎么进行故障恢复?接下来的章节,我们逐个回答这些问题。
$ ]' B$ j( t8 q# ^* W8 x5 Z6 \7 E/ f9 ]! Y, Y' @
4 p5 S% d' ?% E! ~+ o: M
Reference,- H$ c N* \9 ]' S) P
3 y* Z- T9 e0 e- [9 c3 h
[0] Architectural Overview
5 j4 r7 x9 j) g( p% d& G$ _7 Qhttp://www.mongodb.org/display/DOCS/Sharding+Introduction; O0 X; h- k9 l
|
评分
-
查看全部评分
|