|
|
关于MongoDB，我们能看到的资料，基本都是在指导大家如何使用MongoDB，但是，MongoDB内部是如何运作的，资料不是很多。
}9 D Q2 Q8 k! _$ C( d0 R: A" L: R% ?/ `8 Z7 |* E( I
阅读使用手册，会有很多疑惑之处。例如，有人说，MongoDB 等同于分布式的 MySQL。它把一个Table ，按 row，分割成多个Shards，分别存放在不同的 Servers 上。这种说法是否正确？
c* ]6 N, G9 X7 E1 v' R2 o: H' B# Y
不深入了解 MongoDB 的内部结构，就无法透彻地回答类似问题。这个系列文章，就来和大家探讨MongoDB的内部的工作方式。4 P' T, ?* F' S; r# V0 J. W% B
6 B6 E1 J# |& K( b6 B: p
. M6 _# V, N) i" r- ~/ L
6 y8 E" v% R$ O6 O图1-1 MongoDB架构图
' d& e/ Y) F. y- W4 }
3 O# _' @# e7 _ MongoDB 通常运行在一个服务器集群上，而不是一个单机。图1-1，描述了一个MongoDB集群的基本组成部分，包括若干shards，至少一个config server，至少一个routing servers（又称 mongos）。2 e/ j2 M6 d! e; p! R* ^, E: r( J
3 J3 w% C7 R a3 ?' D
Shards
! [- a+ G3 l! \' P
9 j2 B4 d0 J0 U! c MongoDB的最基本的数据单元，叫document，类似于关系式数据库中的行 row。一系列documents，组成了一个collection，相当于关系式数据库中的table。当一个 collection 数据量太大时，可以把该collection按documents切分，分成多个数据块，每个数据块叫做一个chunk，多个chunks聚集在一起，组成了一个shard。# @% |5 z+ y, l( q! k
. v" k, O4 ^+ L5 x+ B- I. ~7 X Sharding 的意义，不仅保障了数据库的扩容（scalability），同时也保障了系统的负载均衡（load balance）。! s/ {: Y$ q3 D: a) i
' y3 E! {4 {% T
每一个shard存储在一个物理服务器（server）上。Server上运行着mongod进程，通过这个进程，对shard中的数据进行操作，主要是增删改查。, R7 O* s6 A/ `8 J6 `4 m
5 S) D9 A! \! M* ^
如果系统中的每个shard，只存储了一份数据，没有备份，那么当这个shard所在的server挂了，数据就丢失了。在生产环境中，为了保证数据不丢失，为了提高系统的可用性（availability），每一个shard被存储多份，每个备份所在的servers，组成了一个replica set。
" q! o( u$ m: e/ B- O5 R
7 D+ \+ ^0 ]) S/ @1 DShard keys& T- y# E) {6 `% c& C: d8 A+ T
. J3 [+ O6 I2 T3 b
为了把collection切分成不同的chunks，从而存放到不同的shards中，我们需要制定一个切分的方式。
& ^6 O0 d4 l( b& F/ b* ?- }" E, p
如前所述，在 MongoDB 数据库中，一个表collection由多个行 documents 组成，而每个 document，有多个属性 fields。同一个 collection 中的不同的 documents，可能会有不同的 fields。例如，有个 collection 叫 Media，包含两条 documents，
! f, K, J8 g1 V8 _3 b R; v
( h6 T0 D1 V( l4 ~" u3 [7 d{
) u4 A, {. m" E# _/ K; T; o "ISBN": "987-30-3652-5130-82",* k9 f8 i1 V" K9 O; ]' S
"Type": "CD",, \3 P1 s8 ~* F5 V# U/ J
"Author": "Nirvana",
) c; q" a; v4 a "Title": "Nevermind",
8 m8 d- } w" u7 G5 T$ F3 v) x "Genre": "Grunge",2 L5 D& r0 D! W6 i* w
"Releasedate": "1991.09.24",3 Y; f ^6 _& X
"Tracklist": [, x' }9 l R/ J* \1 M, O F
{
3 r) }) h3 Y! c "Track" : "1",! B/ {( { r( ~! C5 T& z
"Title" : "Smells like teen spirit",7 `1 Q$ m. x" E
"Length" : "5:02"3 Y" |" u% ]# [) }, ~) T
},
+ T" F# R: f; t3 A/ } {
- h+ K) t. v0 ]( Q P# ?& V "Track" : "2",
$ T4 a8 n2 a& P4 ^9 n) M; W "Title" : "In Bloom",3 ^ U( t. c9 ]* I b
"Length" : "4:15"4 }1 @! }! _& _3 g3 s
}
: a7 [1 ~0 D6 h) n ]/ ~" t# e7 Q0 X& N2 d
}
' h2 ~9 n+ n p; Q. H+ c7 r! ~& P3 G \: ~* c+ h! K8 ~% z
{8 V" i$ v7 s/ E3 Y
"ISBN": "987-1-4302-3051-9",+ D& ]: m- i4 N
"Type": "Book",) `1 A/ m6 s, J1 D4 T4 l9 g" K
"Title": "Definite Guide to MongoDB: The NoSQL Database",
3 N& A" U2 S) v% v "Publisher": "Apress",
% c( s0 f, ]( f6 g4 c8 s "Author": " Eelco Plugge",
' X7 r1 h! t. k4 } {- J: V K( z "Releasedate": "2011.06.09"
4 [, Y8 ~! r* M) X}
5 j6 g0 n& d% F2 S1 n
4 L2 d* q: \ C" P/ l) w9 t0 } 假如，在同一个 collection 中的所有 document，都包含某个共同的 field，例如前例中的“ISBN”，那么我们就可以按照这个 field 的值，来分割 collection。这个 field 的值，又称为 shard key。
( _ k5 c p& }9 T% j; `. m z0 W& w2 m
在选择shard key的时候，一定要确保这个key能够把collection均匀地切分成很多chunks。
( S, A' Z1 ?' S: I0 j6 W8 e8 t5 v @. E" W0 b6 x
例如，如果我们选择“author”作为shard key，如果有大量的作者是重名的，那么就会有大量的数据聚集在同一个chunk中。当然，假设很少有作者同名同姓，那么“author”也可以作为一个shard key。换句话说，shard key 的选择，与使用场景密切相关。
4 h7 v/ e# J1 r& a8 K
& N4 [: S2 s' v0 D" h 很多情况下，无论选择哪一个单一的 field 作为shard key，都无法均匀分割 collection。在这种情况下，我们可以考虑，用多个 fields，构成一个复合的shard key。+ H! S, Y5 N4 L* v* @+ H `
6 r+ j, q$ o' Q4 F/ ^
延续前例，假如有很多作者同名同姓，他们都叫“王二”。用 author 作为 shard key，显然无法均匀切割 collection。这时我们可以加上release-date，组成name-date的复合 shard key，例如“王二 2011”。
7 d1 Z& _' |6 o
0 g% x" |4 ]; T K. DChunks
7 D' @6 d- M5 T+ J% j
0 M1 C7 K& ~, F. o( g# o9 i MongoDB按 shard key，把 collection切割成若干 chunks。每个 chunk 的数据结构，是一个三元组，{collection，minKey，maxKey}，如图1-2 所示。/ B6 G; O& O& v5 L' Z c: n; T
# `( A& t: m& ]8 Z9 p5 G( t; D
& q3 {2 m! l s6 [0 B, D/ E3 u9 x2 `
图1-2 chunk的三元组 # h9 }: c+ O) |8 a _) P, b1 y
- l' |: o: v- c( [0 ~
其中，collection 是数据库中某一个表的名称，而 minKey 和 maxKey 是 shard key的范围。每一个 document 的shard key 的值，决定了这条document应该存放在哪个chunk中。
& Y' g! ~2 L( f$ \' q5 _3 ]( T' i" ]/ j- Q2 T: x
如果两条 documents 的 shard keys 的值很接近，这两条 documents 很可能被存放在同一个 chunk 中。/ R3 K3 Z5 C/ L4 u8 j
& n- W* S% V( j# \! G Shard key 的值的顺序，决定了 document 存放的 chunk。在 MongoDB 的文献中，这种切割 collection 的方式，称为order-preserving。 t: j$ @. A5 `+ ^4 x* {
2 t7 \" D3 Z, t" L5 U5 e7 ^/ N
一个 chunk最多能够存储64MB的数据。 当某个chunk存储的 documents包含的数据量，接近这个阈值时，一个chunk会被切分成两个新的chunks。: _, ?% G8 e. V v0 [; |& A
7 G, Y" V" b8 o5 _4 I5 l
当一个shard存储了过多的chunks，这个shard中的某些chunks会被迁移到其它 shard中。+ Z+ n& Y% M* M: H# `3 f) `
0 X1 F5 a3 X: K l9 @( ^: D 这里有个问题，假如某一条 document 包含的数据量很大，超过 64MB，一个 chunk 存放不下，怎么办？在后续章节介绍 GridFS 时，我们会详细讨论。: |" t- o* J+ C9 c+ r
6 ]0 d) n) H; T q' m: U! j/ `
Replica set7 Q {; S7 e9 l9 m
9 O/ i* }( e" ?! }/ j
在生产环境中，为了保证数据不丢失，为了提高系统的可用性（availability），每一个shard被存储多份，每个备份所在的servers，组成了一个replica set。/ p! d$ X) ?4 |9 l$ X% K' h/ C' I
P+ j# V* R( r6 U. {
这个replica set包括一个primary DB和多个secondary DBs。为了数据的一致性，所有的修改(insert / update / deletes) 请求都交给primary处理。处理结束之后，再异步地备份到其他secondary中。
1 r5 M Q$ c5 F; f7 ^# I
F5 H- g3 o: ~# L Primary DB由replica set中的所有servers，共同选举产生。当这个primaryDB server出错的时候，可以从replica set中重新选举一个新的primaryDB，从而避免了单点故障。
% T; `# T0 U, R/ Q9 y
/ H' P$ W! ^2 G+ j9 v Replica set的选举策略和数据同步机制，确保了系统的数据的一致性。后文详述。& T. D* h7 w) w0 \2 y# c
. o/ p; Q5 d+ U
Config Server( I' k0 h& t) y9 m. S# c
I. }+ u$ x8 k8 E& a% k+ l: { Config servers用于存储MongoDB集群的元数据 metadata，这些元数据包括如下两个部分，每一个shard server包括哪些chunks，每个chunk存储了哪些 collections 的哪些 documents。: N* W( ^& [! S. ^& s$ R' g: Q
( u/ t! {. }4 ^' b, j/ d A 每一个config server都包括了MongoDB中所有chunk的信息。
3 c9 `, Y( p0 k% r4 k) n' y) Y# Y6 b# h, J! R1 Z
Config server也需要 replication。但是有趣的是，config server 采用了自己独特的replication模式，而没有沿用 replica set。
) n5 F( e: {( j z6 s3 V2 H4 S5 P8 l9 Y
如果任何一台config server挂了，整个 config server 集群中，其它 config server变成只读状态。这样做的原因，是避免在系统不稳定的情况下，冒然对元数据做任何改动，导致在不同的 config servers 中，出现元数据不一致的情况。. h" K# q" a8 f) q5 s$ n& W
% [2 x5 W _4 y/ P' r' R6 U MongoDB的官方文档建议，配置3个config servers比较合适，既提供了足够的安全性，又避免了更多的config servers实例之间的数据同步，引起的元数据不一致的麻烦。$ l: d5 w8 p k3 S! t( T- D
' X4 L( `6 W4 `. j% wMongos
# s7 t0 y- s" R# W, W$ V
+ ^0 h. Z i, b2 h$ }8 A' B. ^ 用户使用MongoDB 时，用户的操作请求，全部由mongos来转发。2 g4 V6 q; o, t% G4 s
7 T$ |$ g$ w# R& m 当 mongos 接收到用户请求时，它先查询 config server，找到存放相应数据的shard servers。然后把用户请求，转发到这些 shard servers。当这些 shard servers完成操作后，它们把结果分别返回给 mongos。而当 mongos 汇总了所有的结果后，它把结果返回给用户。
2 Q, g) j- l; N5 y. A& ~" L/ U2 Q" B8 @1 P
Mongos每次启动的时候，都要到config servers中读取元数据，并缓存在本地。每当 config server中的元数据有改动，它都会通知所有的mongos。) D7 X7 y1 i0 b9 s
0 Y; P; k. `) `) ~) n0 ^ Mongos之间，不存在彼此协同工作的问题。因此，MongoDB所需要配置的mongos server的数量，没有限制。
4 j3 K5 F3 U m* B6 ]. k. i6 Y# u/ y* w D" X' \; g1 |0 t( n' l$ O
通过以上的介绍，我们对每个组成部分都有了基本的了解，但是涉及到工作的细节，我们尚有诸多疑问，例如，一个chunk的数据太大，如何切分？一个shard数据太多，如何迁移？在replica set中，如何选择primary？server挂了，怎么进行故障恢复？接下来的章节，我们逐个回答这些问题。8 s* v+ a5 X+ V6 T+ k5 H* ]
0 q A2 Q# O; ^! R
$ c$ K6 L% U H# i# ` ]Reference，
3 ? Q0 ?' x7 p8 Z4 r0 u4 U4 U5 }6 b: P! v% T6 l x
[0] Architectural Overview0 Q) a; `% {, n, B" U G
http://www.mongodb.org/display/DOCS/Sharding+Introduction
, ^* j k# c8 { D( K& C8 d" ~ |
评分
-
查看全部评分
|
雷达卡
发表于 2012-9-18 12:31:10
收藏
分享
淘帖
支持
反对
提升卡
置顶卡
沉默卡
喧嚣卡
变色卡
抢沙发
千斤顶
显身卡
楼主
已经给你变成正式会员了。
+ t( { m7 W8 p9 k, k7 e