|
|
关于MongoDB,我们能看到的资料,基本都是在指导大家如何使用MongoDB,但是,MongoDB内部是如何运作的,资料不是很多。
1 U/ l# l% k% c) ^" J+ `4 C6 f
& U S9 h! x% s# a ~ 阅读使用手册,会有很多疑惑之处。例如,有人说,MongoDB 等同于分布式的 MySQL。它把一个Table ,按 row,分割成多个Shards,分别存放在不同的 Servers 上。这种说法是否正确?
8 `' N1 ]2 V' f, q
- q1 f( P' Q5 F/ m 不深入了解 MongoDB 的内部结构,就无法透彻地回答类似问题。这个系列文章,就来和大家探讨MongoDB的内部的工作方式。/ d$ a2 D( w" w6 X! ~4 ^$ V. m
$ J T! `6 W( L ]: T8 a* V; A
/ t' }- {0 U6 Z" N6 o7 I0 ~4 f+ t! ?
图1-1 MongoDB架构图 1 J3 n7 _' `/ l$ n2 G
' s5 @3 J4 D R- P: A+ } MongoDB 通常运行在一个服务器集群上,而不是一个单机。图1-1,描述了一个MongoDB集群的基本组成部分,包括若干shards,至少一个config server,至少一个routing servers(又称 mongos)。
9 `, ^1 K% y+ n% W" j/ S
* Y0 E! T/ N! ]Shards
" ?$ D3 ~& t2 V2 m/ L8 f# `+ ^4 @! L" m2 O7 y3 S3 O
MongoDB的最基本的数据单元,叫document,类似于关系式数据库中的行 row。一系列documents,组成了一个collection,相当于关系式数据库中的table。当一个 collection 数据量太大时,可以把该collection按documents切分,分成多个数据块,每个数据块叫做一个chunk,多个chunks聚集在一起,组成了一个shard。; F5 L2 ~' j; T) q1 k
7 t8 F" Q! b6 ^) e/ S4 F
Sharding 的意义,不仅保障了数据库的扩容(scalability),同时也保障了系统的负载均衡(load balance)。
+ H( Y1 a* }6 \1 u" H6 j7 f
$ w! z2 R) y( }! | 每一个shard存储在一个物理服务器(server)上。Server上运行着mongod进程,通过这个进程,对shard中的数据进行操作,主要是增删改查。/ i f# `0 y4 D+ T! v0 ]8 W* x
; [' k4 v; i6 A" s4 O/ Y: b
如果系统中的每个shard,只存储了一份数据,没有备份,那么当这个shard所在的server挂了,数据就丢失了。在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。+ I" C- q# {4 z6 _8 r
. h! w, a' O. ] |1 s+ ^7 l0 UShard keys
" Y8 k- R! T3 c; V) H- m J
! P7 a% W. q; K0 |; F* O) Z" C 为了把collection切分成不同的chunks,从而存放到不同的shards中,我们需要制定一个切分的方式。
4 U) H- i- ^# R# w; }
) M1 l. k% E* N& V& U0 a 如前所述,在 MongoDB 数据库中,一个表collection由多个行 documents 组成,而每个 document,有多个属性 fields。同一个 collection 中的不同的 documents,可能会有不同的 fields。例如,有个 collection 叫 Media,包含两条 documents,# h) d* a$ U) g E
, Z# b; a+ B( ]6 ^1 q8 X: S. J5 f{
. D! B( D' x- y9 w$ E5 `. h "ISBN": "987-30-3652-5130-82",
' t6 P9 y3 U6 A0 C "Type": "CD",
* a% t4 w9 ]8 N3 B "Author": "Nirvana",
- U9 N- g0 {; S* I! B( k "Title": "Nevermind",
$ h9 l8 m' W7 O W "Genre": "Grunge",7 I8 d4 I& p1 J
"Releasedate": "1991.09.24",2 |0 u+ t1 W- d4 C! y
"Tracklist": [
0 ^) m2 g9 B6 J, r3 ] {
7 W' u) j: s* U/ y "Track" : "1",, h- ?( A& Y, w& t( ?
"Title" : "Smells like teen spirit",
) r. |5 G% {/ g% S' \+ _ "Length" : "5:02"
. ]; r3 ~# k* F( S6 e },
) J6 a0 K7 T4 l( Q6 L! y9 K {! [% `! E5 [" J: O- V
"Track" : "2",
. g5 |% f3 Q( x7 h "Title" : "In Bloom",7 P4 W% C4 q1 l- k: p1 {7 Y
"Length" : "4:15"/ K5 M9 \3 J" R( E1 U, A3 k# n
}
( V5 f; t# F% c3 H9 u2 t: F6 e ]
! { K' S5 F6 d7 @4 h+ ~}
7 z3 A: `* F6 \: n! ^6 u, @
# y* H" |# I1 d8 t4 j{
% o% K6 Z: G* R0 U' E+ Q0 K- F "ISBN": "987-1-4302-3051-9",0 H5 l) ?0 o9 J6 E, i( E
"Type": "Book",7 n1 _* _" B. P% [/ V) o3 ]
"Title": "Definite Guide to MongoDB: The NoSQL Database",
+ M/ O" g" ]1 n' \9 p0 U* ^ "Publisher": "Apress",# ]9 T8 w7 [) l3 ^
"Author": " Eelco Plugge",
) r4 w$ A; @4 D5 j$ S6 m "Releasedate": "2011.06.09"
) ~+ U/ q- C# z; j" {' V}& [- T5 d3 }' Z& J' X, P
* B4 T# z9 |! Y$ W' X/ A
假如,在同一个 collection 中的所有 document,都包含某个共同的 field,例如前例中的“ISBN”,那么我们就可以按照这个 field 的值,来分割 collection。这个 field 的值,又称为 shard key。
& _9 z# P# ~9 x, {! |6 ~
) B! q$ \# }! D3 G5 _* c 在选择shard key的时候,一定要确保这个key能够把collection均匀地切分成很多chunks。) H+ Z) L/ ^' M# M" B2 ]
9 c7 r$ I1 g! v6 l% H" s$ G( p' ?
例如,如果我们选择“author”作为shard key,如果有大量的作者是重名的,那么就会有大量的数据聚集在同一个chunk中。当然,假设很少有作者同名同姓,那么“author”也可以作为一个shard key。换句话说,shard key 的选择,与使用场景密切相关。
) U* i+ G- ? g4 J3 f6 s- E% G: ?# ~+ }
很多情况下,无论选择哪一个单一的 field 作为shard key,都无法均匀分割 collection。在这种情况下,我们可以考虑,用多个 fields,构成一个复合的shard key。, r8 C4 O! K% ~6 U) }4 G5 d! `
0 Z5 J& M$ d2 S 延续前例,假如有很多作者同名同姓,他们都叫“王二”。用 author 作为 shard key,显然无法均匀切割 collection。这时我们可以加上release-date,组成name-date的复合 shard key,例如“王二 2011”。
& L1 P" T; i0 F! D$ l0 n2 h) {
Chunks
" [2 r: J9 t) F3 ]% c$ u$ P
! t' {% x0 O+ H) @ MongoDB按 shard key,把 collection切割成若干 chunks。每个 chunk 的数据结构,是一个三元组,{collection,minKey,maxKey},如图1-2 所示。
8 a- l# ^6 `9 Y$ F5 f& h- A- e! ~% O! f& D |' ?
7 i/ ^3 F1 E( U7 G3 V' p2 M i F
图1-2 chunk的三元组
. _" `5 U4 G5 r6 o. a1 a; Z
3 E, h% m, \# a. [ 其中,collection 是数据库中某一个表的名称,而 minKey 和 maxKey 是 shard key的范围。每一个 document 的shard key 的值,决定了这条document应该存放在哪个chunk中。
7 v5 b& Z" K# k( }3 l" R, E, F. `5 `0 @- y7 a. f5 B3 b
如果两条 documents 的 shard keys 的值很接近,这两条 documents 很可能被存放在同一个 chunk 中。2 {8 `% c* E) L, W: h
# ]. G8 A# N0 w2 n& Y, {, s' t: n
Shard key 的值的顺序,决定了 document 存放的 chunk。在 MongoDB 的文献中,这种切割 collection 的方式,称为order-preserving。8 V4 ?7 m+ V; W/ L2 e% a* D
" M- R3 k' H' b
一个 chunk最多能够存储64MB的数据。 当某个chunk存储的 documents包含的数据量,接近这个阈值时,一个chunk会被切分成两个新的chunks。
' A1 v8 P3 s' [+ B5 l7 t. U) M: e1 b- p+ j/ b0 z
当一个shard存储了过多的chunks,这个shard中的某些chunks会被迁移到其它 shard中。
( B, y* n1 V( ?! J4 ?, L
$ q8 a/ O6 ?+ _- z 这里有个问题,假如某一条 document 包含的数据量很大,超过 64MB,一个 chunk 存放不下,怎么办?在后续章节介绍 GridFS 时,我们会详细讨论。
0 |( v7 Q P" U' I
0 |. q" y7 E. p* Z( Q: n* G( v! ^Replica set2 B) ^& ~1 x! I3 N( q
6 ^& Q6 t/ T4 t4 \" u0 n! e* M
在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。
7 a9 O) [6 }3 I# G. B
3 y4 l) N* H4 Z6 p U 这个replica set包括一个primary DB和多个secondary DBs。为了数据的一致性,所有的修改(insert / update / deletes) 请求都交给primary处理。处理结束之后,再异步地备份到其他secondary中。
0 y6 k3 @# Q1 @ k1 v3 g; Z
7 W- T' V( N) F; r Primary DB由replica set中的所有servers,共同选举产生。当这个primaryDB server出错的时候,可以从replica set中重新选举一个新的primaryDB,从而避免了单点故障。2 x, H1 v0 i- i' Y; y
$ z% t' b8 ~6 a/ V3 l Replica set的选举策略和数据同步机制,确保了系统的数据的一致性。后文详述。
" m; m% D2 R3 f% Y1 T" S- i
3 b, Y h; N: K+ Z: E0 XConfig Server' H3 h& z/ {2 ^3 a l9 e
& m* j5 n k4 l; y7 ?. l6 S+ C' j
Config servers用于存储MongoDB集群的元数据 metadata,这些元数据包括如下两个部分,每一个shard server包括哪些chunks,每个chunk存储了哪些 collections 的哪些 documents。
* d7 D" J3 r" N: U# d! e" I" b4 K4 j9 j3 b% n5 T6 |
每一个config server都包括了MongoDB中所有chunk的信息。+ p7 B8 ^7 ~( U3 ^( f3 Q
& H4 s- @4 @3 P( l# N
Config server也需要 replication。但是有趣的是,config server 采用了自己独特的replication模式,而没有沿用 replica set。
/ D% T/ R( l( |
6 j4 s1 a! i) G8 l$ ~; p 如果任何一台config server挂了,整个 config server 集群中,其它 config server变成只读状态。这样做的原因,是避免在系统不稳定的情况下,冒然对元数据做任何改动,导致在不同的 config servers 中,出现元数据不一致的情况。% ]! e% d# W+ v
4 M: Q4 R3 B# ] MongoDB的官方文档建议,配置3个config servers比较合适,既提供了足够的安全性,又避免了更多的config servers实例之间的数据同步,引起的元数据不一致的麻烦。2 r$ R+ }2 r4 W" G' h* F) w
3 \! U' c D( \: N8 CMongos
8 b6 M0 N6 F) B0 T4 S
- K/ c0 O% A9 H$ j- s w7 p Z 用户使用MongoDB 时,用户的操作请求,全部由mongos来转发。3 m& Y0 k6 p/ s
2 Z$ V* k# I# c7 K& n! k& i4 Q1 b
当 mongos 接收到用户请求时,它先查询 config server,找到存放相应数据的shard servers。然后把用户请求,转发到这些 shard servers。当这些 shard servers完成操作后,它们把结果分别返回给 mongos。而当 mongos 汇总了所有的结果后,它把结果返回给用户。+ o5 O& Q- w; j& k/ E
. L7 i- g% F3 o
Mongos每次启动的时候,都要到config servers中读取元数据,并缓存在本地。每当 config server中的元数据有改动,它都会通知所有的mongos。( L% C6 M( J% Z: b G- k7 f
3 a( i; W$ R& x& { Mongos之间,不存在彼此协同工作的问题。因此,MongoDB所需要配置的mongos server的数量,没有限制。
3 X" `8 A& C! _/ R# D; g2 y5 J1 E: ?" r, s
通过以上的介绍,我们对每个组成部分都有了基本的了解,但是涉及到工作的细节,我们尚有诸多疑问,例如,一个chunk的数据太大,如何切分?一个shard数据太多,如何迁移?在replica set中,如何选择primary?server挂了,怎么进行故障恢复?接下来的章节,我们逐个回答这些问题。" ?8 m6 K# D) X/ R1 A" X
" y3 z) J+ X- v1 f, [+ O( y8 x
/ z0 P9 r. J# E8 l) H3 M* X6 r) Y5 h
Reference,7 q# E ~3 k W
& l" j5 X$ Q/ x4 Z/ L" Z
[0] Architectural Overview. d) h. x" g" _+ {. s" F; g" D3 f4 N
http://www.mongodb.org/display/DOCS/Sharding+Introduction
D% |/ q* P2 B0 x |
评分
-
查看全部评分
|