|
关于MongoDB,我们能看到的资料,基本都是在指导大家如何使用MongoDB,但是,MongoDB内部是如何运作的,资料不是很多。) m( M) V9 T* o$ r K$ n0 B
* ~8 z5 ^/ M( Y4 I
阅读使用手册,会有很多疑惑之处。例如,有人说,MongoDB 等同于分布式的 MySQL。它把一个Table ,按 row,分割成多个Shards,分别存放在不同的 Servers 上。这种说法是否正确?
0 ]' ?, J' i# }& p9 D u, v$ G r2 X. U8 y$ s9 ~3 o/ n! t9 h
不深入了解 MongoDB 的内部结构,就无法透彻地回答类似问题。这个系列文章,就来和大家探讨MongoDB的内部的工作方式。8 I9 V! j9 Y5 o0 P; r2 D
" b' D/ `8 k3 @' G9 \: {
6 J$ u# L+ E0 H3 G' w ^
' z, I' t) c3 S8 A. t# t& D图1-1 MongoDB架构图
0 D/ E3 Q$ F) I1 k: {( e7 V
4 e- [1 \9 P) ]* Y; q4 }( m' t MongoDB 通常运行在一个服务器集群上,而不是一个单机。图1-1,描述了一个MongoDB集群的基本组成部分,包括若干shards,至少一个config server,至少一个routing servers(又称 mongos)。
! k0 [5 `" S$ j, f/ Y" w) c/ B! @ H+ p2 l- } b# M6 z5 _ U
Shards
% w+ X. Q* ^( j7 ] ^. a) o# V7 {* r# M9 z# m n' d3 P( ]
MongoDB的最基本的数据单元,叫document,类似于关系式数据库中的行 row。一系列documents,组成了一个collection,相当于关系式数据库中的table。当一个 collection 数据量太大时,可以把该collection按documents切分,分成多个数据块,每个数据块叫做一个chunk,多个chunks聚集在一起,组成了一个shard。
5 y, p, n4 H( w- b( b' b
: t! ]! ~, o$ S+ V" T8 T' A8 \3 Q Sharding 的意义,不仅保障了数据库的扩容(scalability),同时也保障了系统的负载均衡(load balance)。
% h2 j) {+ Y+ }* j, f3 V: \9 I# a k1 r3 A, I8 a1 ?" h
每一个shard存储在一个物理服务器(server)上。Server上运行着mongod进程,通过这个进程,对shard中的数据进行操作,主要是增删改查。
" J$ x1 K. l. I* V% M% G
! |, l% N- q" g 如果系统中的每个shard,只存储了一份数据,没有备份,那么当这个shard所在的server挂了,数据就丢失了。在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。
# Q2 s1 h. F9 K1 m O' Q& v1 \ p0 G- x! @3 c/ O6 a
Shard keys
6 P- P# Z! m4 O* \0 j1 R. [, ~0 ?
" v, m4 r+ X6 P$ L6 G 为了把collection切分成不同的chunks,从而存放到不同的shards中,我们需要制定一个切分的方式。: O* `1 z5 h$ X9 B
3 |1 |* ~& G: l& @/ T 如前所述,在 MongoDB 数据库中,一个表collection由多个行 documents 组成,而每个 document,有多个属性 fields。同一个 collection 中的不同的 documents,可能会有不同的 fields。例如,有个 collection 叫 Media,包含两条 documents,; }( t& s( ]2 z# f# {- b7 U
) V2 {4 N" K- K" D4 e, Q6 A; h{% C7 @+ L$ Z+ C6 S N
"ISBN": "987-30-3652-5130-82",' y3 V K0 ]! l
"Type": "CD",% ~( @' ?) [( y: c3 r/ E
"Author": "Nirvana"," p" S4 }6 X- u' A2 `9 @& ^, z
"Title": "Nevermind",3 [3 V2 m T1 ^9 m9 P
"Genre": "Grunge",
4 o: D# g: Q/ [+ M* ]' B/ q+ H" _ "Releasedate": "1991.09.24",8 y6 J3 G: { a0 L7 ?/ D1 q
"Tracklist": [3 s; U2 M, ~ c4 N7 M
{
6 t$ q* E7 k& f7 K9 Y5 V$ b "Track" : "1",
) q; ?7 W3 A5 f4 V "Title" : "Smells like teen spirit",
; Z v# r- n' h9 \: _4 o4 k" g "Length" : "5:02"; C# ?7 O" ~+ P$ _
},
3 P# Z/ m8 M$ ?! j I {# _+ \; C! e. W8 o4 j! g- O5 J
"Track" : "2",
9 z$ g _4 }1 y' {4 f "Title" : "In Bloom",5 F, k* | A1 y: o: v
"Length" : "4:15"
1 g% |1 k4 `# G X: ~1 m; } }# X5 g/ [, G! Q! ^8 i
]9 B: m* U6 T7 x& {
}1 n' d( r9 L5 `6 \* q; [
8 U! }4 ] Q2 Z9 P! g{& s# R5 @+ y+ K7 X; m
"ISBN": "987-1-4302-3051-9",
4 j1 e+ U( g- x2 s "Type": "Book",
, W) ^; B. L( G! l' W& o "Title": "Definite Guide to MongoDB: The NoSQL Database",
; ]* `1 ~! c# z0 l1 h; N "Publisher": "Apress",
7 d- h( G& U* m0 A3 c0 Z "Author": " Eelco Plugge",
) O- W: ~9 |. |/ y \2 V "Releasedate": "2011.06.09"
j' z% w; z. `: [2 M}
3 b- F* Q t- J% R8 I5 ^" `6 p. `% N" S
5 P2 }' l+ j+ i" D; p" E 假如,在同一个 collection 中的所有 document,都包含某个共同的 field,例如前例中的“ISBN”,那么我们就可以按照这个 field 的值,来分割 collection。这个 field 的值,又称为 shard key。9 `8 W3 U, |- v! t: s9 Z
: k7 B2 O/ W% R' S% j M 在选择shard key的时候,一定要确保这个key能够把collection均匀地切分成很多chunks。( `. J4 g* y c' m
* j/ u8 V2 Y8 ]* i, z
例如,如果我们选择“author”作为shard key,如果有大量的作者是重名的,那么就会有大量的数据聚集在同一个chunk中。当然,假设很少有作者同名同姓,那么“author”也可以作为一个shard key。换句话说,shard key 的选择,与使用场景密切相关。
4 T" J' u! e- F0 l; j
3 [2 \( V3 r# g4 U2 | 很多情况下,无论选择哪一个单一的 field 作为shard key,都无法均匀分割 collection。在这种情况下,我们可以考虑,用多个 fields,构成一个复合的shard key。/ V% h2 k1 q, i2 {& m) w* i
% K; a" h+ x2 v
延续前例,假如有很多作者同名同姓,他们都叫“王二”。用 author 作为 shard key,显然无法均匀切割 collection。这时我们可以加上release-date,组成name-date的复合 shard key,例如“王二 2011”。8 K( t! w9 M1 l' n! x4 ^
5 Y4 e- X E- y2 t5 k. d% `; f
Chunks: B9 w; y0 `. K$ Q6 B( f, k/ [
4 }" [0 C; B7 M6 z' H: w
MongoDB按 shard key,把 collection切割成若干 chunks。每个 chunk 的数据结构,是一个三元组,{collection,minKey,maxKey},如图1-2 所示。
7 P$ y) {3 w# ~. i2 o
! j2 V+ |' y# f" `
/ }9 \7 ?+ ~" Y
图1-2 chunk的三元组
9 \. `0 A& T! a6 B$ k0 h) Z0 W1 b( \4 A: y
其中,collection 是数据库中某一个表的名称,而 minKey 和 maxKey 是 shard key的范围。每一个 document 的shard key 的值,决定了这条document应该存放在哪个chunk中。
& U% V. T1 G( c* W' O; a4 p
% `3 T, |- E& M# m8 ] 如果两条 documents 的 shard keys 的值很接近,这两条 documents 很可能被存放在同一个 chunk 中。
) I+ S! ^ H5 g6 w
+ I4 k9 p' c) L+ { Shard key 的值的顺序,决定了 document 存放的 chunk。在 MongoDB 的文献中,这种切割 collection 的方式,称为order-preserving。9 A$ C3 \% X$ y3 @8 ?7 V( V
3 a( p+ H. m) r& H 一个 chunk最多能够存储64MB的数据。 当某个chunk存储的 documents包含的数据量,接近这个阈值时,一个chunk会被切分成两个新的chunks。7 O0 ]$ d2 v8 O7 w ? v* H
5 q& {% u P& \2 j a; X9 B% u
当一个shard存储了过多的chunks,这个shard中的某些chunks会被迁移到其它 shard中。
3 C: [& K6 o0 r5 Y r
f' I8 I9 Z/ G6 A' z/ g/ ]+ G% Q" r 这里有个问题,假如某一条 document 包含的数据量很大,超过 64MB,一个 chunk 存放不下,怎么办?在后续章节介绍 GridFS 时,我们会详细讨论。
& I/ @$ e) g3 b; m
8 h6 k- S3 L2 T& h) x, h9 @( ^! `) MReplica set
2 T. ]* W& ], h6 g: t; G$ v 0 h" N1 W5 T# `) @" Z
在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。# K3 H+ q3 X) E$ C T
7 H; Z. d) M! t
这个replica set包括一个primary DB和多个secondary DBs。为了数据的一致性,所有的修改(insert / update / deletes) 请求都交给primary处理。处理结束之后,再异步地备份到其他secondary中。 M( w# v: w# l) C
; }6 \) H; Y, l! v" }7 g) U$ s
Primary DB由replica set中的所有servers,共同选举产生。当这个primaryDB server出错的时候,可以从replica set中重新选举一个新的primaryDB,从而避免了单点故障。
. x# A$ X: y7 [1 g* f
/ V" a8 f7 q+ X2 A: e; P Replica set的选举策略和数据同步机制,确保了系统的数据的一致性。后文详述。9 O+ L. K4 v2 d M/ ~
0 g3 m/ p4 R2 E& M {8 j& |7 _' C" X
Config Server
( A5 z9 Q$ s( k& g
/ b( L! z! R: i' W6 J Config servers用于存储MongoDB集群的元数据 metadata,这些元数据包括如下两个部分,每一个shard server包括哪些chunks,每个chunk存储了哪些 collections 的哪些 documents。) d' E" D- p9 B, X
2 X0 ^" b' I( H8 R- a( M( H 每一个config server都包括了MongoDB中所有chunk的信息。+ [3 k8 Q, v$ j* t5 _5 ^
: D" t8 q( P8 Y+ g$ ~& p, `# h1 `& R Config server也需要 replication。但是有趣的是,config server 采用了自己独特的replication模式,而没有沿用 replica set。
# a& z1 T1 ~+ p# l3 r: Z- S% w8 T. q+ r
如果任何一台config server挂了,整个 config server 集群中,其它 config server变成只读状态。这样做的原因,是避免在系统不稳定的情况下,冒然对元数据做任何改动,导致在不同的 config servers 中,出现元数据不一致的情况。; R( H; v8 N: g, \! M' I' \- u, j
1 b7 j' v- a9 O& B0 G5 g MongoDB的官方文档建议,配置3个config servers比较合适,既提供了足够的安全性,又避免了更多的config servers实例之间的数据同步,引起的元数据不一致的麻烦。% p ~- e) K0 l+ n( k
9 G n. g6 K4 ~( ], G
Mongos
% R0 { D% P( W }' N2 R( @% X4 I5 w1 Q' `. `
用户使用MongoDB 时,用户的操作请求,全部由mongos来转发。! ~; Q8 y" a& H) y7 f
* D4 |9 d% u. G
当 mongos 接收到用户请求时,它先查询 config server,找到存放相应数据的shard servers。然后把用户请求,转发到这些 shard servers。当这些 shard servers完成操作后,它们把结果分别返回给 mongos。而当 mongos 汇总了所有的结果后,它把结果返回给用户。; m: A0 {# X% a0 n. ]
. D; y: v& U9 f/ E/ U: _ Mongos每次启动的时候,都要到config servers中读取元数据,并缓存在本地。每当 config server中的元数据有改动,它都会通知所有的mongos。
6 v( O1 t, H+ |* F6 D/ b+ D1 |7 \. s2 O; ]9 j3 ~" Q+ e }: [4 e4 ^
Mongos之间,不存在彼此协同工作的问题。因此,MongoDB所需要配置的mongos server的数量,没有限制。. h3 C h. X: d2 L ^/ e$ U
. S& w! ?7 Y0 Y c# G, \ 通过以上的介绍,我们对每个组成部分都有了基本的了解,但是涉及到工作的细节,我们尚有诸多疑问,例如,一个chunk的数据太大,如何切分?一个shard数据太多,如何迁移?在replica set中,如何选择primary?server挂了,怎么进行故障恢复?接下来的章节,我们逐个回答这些问题。
- E0 @, _1 ^% @. f8 P9 U: s2 {0 { g- \
- i0 f$ Y. x4 z4 ~$ \
( c9 B8 B" P* _7 K4 J2 w4 l, }$ Z8 G% C5 fReference,
: J( }+ e: e" H3 M! d1 Z7 E. `
& q* P/ N) n( m6 R0 c6 @" W8 w[0] Architectural Overview
. x- z3 |. F9 f/ jhttp://www.mongodb.org/display/DOCS/Sharding+Introduction/ u' s' E" P" a, v7 v2 @
|
评分
-
查看全部评分
|