|
|
关于MongoDB,我们能看到的资料,基本都是在指导大家如何使用MongoDB,但是,MongoDB内部是如何运作的,资料不是很多。9 y: { Y. S" Q# r
1 I% j+ X R T' _ 阅读使用手册,会有很多疑惑之处。例如,有人说,MongoDB 等同于分布式的 MySQL。它把一个Table ,按 row,分割成多个Shards,分别存放在不同的 Servers 上。这种说法是否正确?
0 T- F; V: f; E3 n9 s8 }) J) O/ p. `2 i, K' @/ I$ {" H
不深入了解 MongoDB 的内部结构,就无法透彻地回答类似问题。这个系列文章,就来和大家探讨MongoDB的内部的工作方式。
0 e, U$ F! g, c: I3 z% I Y0 ~) m" F
, a# Y2 O6 Y3 ^
2 ?! e$ h5 C4 K; s& c1 H图1-1 MongoDB架构图
; x) i' c8 H7 P; {# \+ ~
4 }! A! I$ o1 k( z4 E MongoDB 通常运行在一个服务器集群上,而不是一个单机。图1-1,描述了一个MongoDB集群的基本组成部分,包括若干shards,至少一个config server,至少一个routing servers(又称 mongos)。7 R. }% t$ a% V: d5 G: ` L( S
9 V! ^" e# |+ K' \& v, I4 V) SShards( F) \' x* G$ a
# S: Q4 J- |# E5 ?0 R
MongoDB的最基本的数据单元,叫document,类似于关系式数据库中的行 row。一系列documents,组成了一个collection,相当于关系式数据库中的table。当一个 collection 数据量太大时,可以把该collection按documents切分,分成多个数据块,每个数据块叫做一个chunk,多个chunks聚集在一起,组成了一个shard。
2 n- E# `, B9 |0 h/ g- W. t5 z* g
, J& n2 q) T4 Q9 C9 y0 e. f# Z0 K5 ^ Sharding 的意义,不仅保障了数据库的扩容(scalability),同时也保障了系统的负载均衡(load balance)。
8 l' W6 |5 @: ]) |! S9 Y# c3 f. K1 ] F* Z
每一个shard存储在一个物理服务器(server)上。Server上运行着mongod进程,通过这个进程,对shard中的数据进行操作,主要是增删改查。+ B* a* r I* w- C# Y9 `5 o- I6 D
, Q/ S _1 O$ r9 e; P8 m 如果系统中的每个shard,只存储了一份数据,没有备份,那么当这个shard所在的server挂了,数据就丢失了。在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。0 o3 v( y5 d% a, e5 q- k! p
4 V$ v; b' l% q/ b) k: R- y9 UShard keys
; [$ L) q: D% H7 p4 Q 2 n' n( e0 H3 v+ C6 \& I; Z$ O) g
为了把collection切分成不同的chunks,从而存放到不同的shards中,我们需要制定一个切分的方式。6 f+ R) G$ e4 X, |: P! k: S. s
: f3 X0 b0 R* F
如前所述,在 MongoDB 数据库中,一个表collection由多个行 documents 组成,而每个 document,有多个属性 fields。同一个 collection 中的不同的 documents,可能会有不同的 fields。例如,有个 collection 叫 Media,包含两条 documents,' s* Y r9 v9 G: f' j! J& F& l
& f8 X% [% u; O! @
{
, {7 l( |7 V. [ "ISBN": "987-30-3652-5130-82",
0 Q" w( d/ f6 I1 Z" D& D% Y1 R, ~$ @ "Type": "CD",( L+ k4 o" k( ?
"Author": "Nirvana",/ q/ y6 C1 \: s
"Title": "Nevermind",! J, c6 V+ }2 j* G$ A) z1 J' a
"Genre": "Grunge",
5 V# h: K, h1 P+ Q/ a5 h& R "Releasedate": "1991.09.24",
8 i3 g( G( M2 F1 a. R- B8 U7 Q "Tracklist": [; B, Z" v, J, G, c o. K, V1 n
{
- D S2 d$ A0 v5 h/ Y "Track" : "1",6 ]- I" e5 |( U8 k* C
"Title" : "Smells like teen spirit",
# ~/ o1 U+ Q. |+ p- o& Q3 S0 | "Length" : "5:02"
$ h7 Q& g- r/ ?, a1 A! P; b },
) U% i# C. O0 g6 p {( S" V. P9 F' k) s
"Track" : "2",
# J6 I# ~# y' o+ u "Title" : "In Bloom",6 U. Z9 h$ W1 Q( |. n# n
"Length" : "4:15"9 ?& F1 ]* m1 j# q. T2 r1 e( C$ j
}0 r0 U& v1 L0 @! n9 A
]2 y4 o& M" R: o8 q& q
}
. M% R' l( E! Y& K
5 F* F8 [; I0 e$ K5 s* Y/ o{7 }8 J+ M4 j M8 o( W, j1 K3 \5 h% Q, | j
"ISBN": "987-1-4302-3051-9",& S& O; ^, Z C @. @9 V
"Type": "Book", L: S! `+ c3 I2 i2 j$ j' {' x
"Title": "Definite Guide to MongoDB: The NoSQL Database",
8 L" J. U3 k- u h$ G! Y "Publisher": "Apress",
9 i5 [5 x R6 j' b "Author": " Eelco Plugge",
1 i; A3 J5 H& J5 W6 U0 O& H "Releasedate": "2011.06.09"
* m0 F0 e$ R* X8 D) ~& J6 @6 \! Z}, M" H7 O. U( k- n" q# {* U9 S
4 @1 e4 N3 |; n+ ] 假如,在同一个 collection 中的所有 document,都包含某个共同的 field,例如前例中的“ISBN”,那么我们就可以按照这个 field 的值,来分割 collection。这个 field 的值,又称为 shard key。
- R% j. n0 W8 e; m! s! |7 t( n0 L1 ]2 v7 m* t+ F# g6 P4 l* S
在选择shard key的时候,一定要确保这个key能够把collection均匀地切分成很多chunks。8 P& E& }3 ~( A7 I
+ r* c' n0 E# _7 K9 h- O7 n
例如,如果我们选择“author”作为shard key,如果有大量的作者是重名的,那么就会有大量的数据聚集在同一个chunk中。当然,假设很少有作者同名同姓,那么“author”也可以作为一个shard key。换句话说,shard key 的选择,与使用场景密切相关。
3 T* J% c8 b/ R( ~9 T' v- h* F! m7 H
很多情况下,无论选择哪一个单一的 field 作为shard key,都无法均匀分割 collection。在这种情况下,我们可以考虑,用多个 fields,构成一个复合的shard key。. m) E7 [( F$ s# L7 H/ Y, }6 r
5 f8 B5 O% q- g$ b 延续前例,假如有很多作者同名同姓,他们都叫“王二”。用 author 作为 shard key,显然无法均匀切割 collection。这时我们可以加上release-date,组成name-date的复合 shard key,例如“王二 2011”。
9 n* o; Q; }; C( o K
) o& [: [) Y6 KChunks
+ k8 p( M( {+ [, q; p% E 8 @* F1 P5 E M. r* ` ?- `
MongoDB按 shard key,把 collection切割成若干 chunks。每个 chunk 的数据结构,是一个三元组,{collection,minKey,maxKey},如图1-2 所示。! e- K& y* d$ Y! I
! @' [& [9 [1 l# [$ p: V* o) y- e
) _. o% @. f6 O) H: f8 X( H
图1-2 chunk的三元组 6 w3 A: p& Q8 `4 z; N: A
# Y& T6 ~% r% w# G* ]* ~9 I: g
其中,collection 是数据库中某一个表的名称,而 minKey 和 maxKey 是 shard key的范围。每一个 document 的shard key 的值,决定了这条document应该存放在哪个chunk中。
' B, S6 o+ C4 M5 _
+ T: E1 y4 Q1 R8 ]4 }8 w, W2 [ 如果两条 documents 的 shard keys 的值很接近,这两条 documents 很可能被存放在同一个 chunk 中。
. P' ]" M9 w5 y R8 m; K2 F1 x8 R9 ?) Q& p1 [# @, a
Shard key 的值的顺序,决定了 document 存放的 chunk。在 MongoDB 的文献中,这种切割 collection 的方式,称为order-preserving。
8 W" o5 v5 R5 i) k; N d* S8 K) ~) J4 S8 H, D$ p
一个 chunk最多能够存储64MB的数据。 当某个chunk存储的 documents包含的数据量,接近这个阈值时,一个chunk会被切分成两个新的chunks。
! ?& _, R8 g! Y6 W5 z# g2 B% I) l9 h" H$ u" O* {; F. B! R( t4 Q9 K
当一个shard存储了过多的chunks,这个shard中的某些chunks会被迁移到其它 shard中。% ^" q/ k. f; p. W' {: B
W; @ P, N% W8 Q7 E 这里有个问题,假如某一条 document 包含的数据量很大,超过 64MB,一个 chunk 存放不下,怎么办?在后续章节介绍 GridFS 时,我们会详细讨论。
. ? Z$ i8 i1 F0 K3 U6 ]/ f. O. k. c/ Y& X
Replica set
) w& ~3 m" f: v; D& H1 K6 n. i $ H, n% P0 y; { r) }# ]0 r! w
在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。
) X$ J: F+ E- T- G3 N
- n* n8 C% z3 c0 M. E, o# ^1 C 这个replica set包括一个primary DB和多个secondary DBs。为了数据的一致性,所有的修改(insert / update / deletes) 请求都交给primary处理。处理结束之后,再异步地备份到其他secondary中。& r8 t' S9 e; V* M6 F7 B
( g7 p6 p% b- `& {/ L
Primary DB由replica set中的所有servers,共同选举产生。当这个primaryDB server出错的时候,可以从replica set中重新选举一个新的primaryDB,从而避免了单点故障。; `/ T: E; w( Q4 g& L# n/ y* t( u
5 o" W; S! I% W
Replica set的选举策略和数据同步机制,确保了系统的数据的一致性。后文详述。6 G3 f5 n, I) y
; O% m5 d& v2 u0 x6 eConfig Server
+ F7 v* S: c6 W; F0 J7 l7 D - N8 K( Z* v. R+ q( P
Config servers用于存储MongoDB集群的元数据 metadata,这些元数据包括如下两个部分,每一个shard server包括哪些chunks,每个chunk存储了哪些 collections 的哪些 documents。3 O8 K& Y! X% [( r
V/ d; H* G9 x& v/ H) r& a
每一个config server都包括了MongoDB中所有chunk的信息。& {, n( u& X. N& {# ~- j/ R
# E) K7 p# u% J0 `, V
Config server也需要 replication。但是有趣的是,config server 采用了自己独特的replication模式,而没有沿用 replica set。
8 |/ j8 r) d; b* `% O* V
( _2 T+ ^' A7 H: A 如果任何一台config server挂了,整个 config server 集群中,其它 config server变成只读状态。这样做的原因,是避免在系统不稳定的情况下,冒然对元数据做任何改动,导致在不同的 config servers 中,出现元数据不一致的情况。# z5 \6 p9 S- x2 {
4 j; f8 E0 ^3 Q7 d; R0 k MongoDB的官方文档建议,配置3个config servers比较合适,既提供了足够的安全性,又避免了更多的config servers实例之间的数据同步,引起的元数据不一致的麻烦。$ G# E$ `. y# o. C$ K1 F. b
- ~: {, O. t& }6 Y; l, fMongos
/ D$ H; k4 l) d3 V6 `* G# b
. w9 Z. g# {( P w& t! C 用户使用MongoDB 时,用户的操作请求,全部由mongos来转发。; |- L" M* { N; K4 r/ q/ K
& l. z6 ?' K& \9 G7 P v7 I 当 mongos 接收到用户请求时,它先查询 config server,找到存放相应数据的shard servers。然后把用户请求,转发到这些 shard servers。当这些 shard servers完成操作后,它们把结果分别返回给 mongos。而当 mongos 汇总了所有的结果后,它把结果返回给用户。
, S. A1 V& z6 c$ E$ ?' T
9 f1 }7 l" U, |" P/ @8 U1 m Mongos每次启动的时候,都要到config servers中读取元数据,并缓存在本地。每当 config server中的元数据有改动,它都会通知所有的mongos。# Y# X. Q9 y+ k1 y* }
5 C2 K( E9 p4 T; o" G1 k7 x Mongos之间,不存在彼此协同工作的问题。因此,MongoDB所需要配置的mongos server的数量,没有限制。
2 [9 ]' t8 n, S" e) r
: f4 b, u1 m9 b$ C 通过以上的介绍,我们对每个组成部分都有了基本的了解,但是涉及到工作的细节,我们尚有诸多疑问,例如,一个chunk的数据太大,如何切分?一个shard数据太多,如何迁移?在replica set中,如何选择primary?server挂了,怎么进行故障恢复?接下来的章节,我们逐个回答这些问题。& T F% I' v% T( s8 k
/ A! t$ Y! i- W. `
8 ~; X) H! i& K$ t7 lReference,
3 G( H# ?# W0 S( K' Q% {$ K4 l* D: k* D0 n$ O
[0] Architectural Overview! d# n0 D% j. [: q1 [) a
http://www.mongodb.org/display/DOCS/Sharding+Introduction
( ~- {# z4 t/ Y2 Q" Q* ~" S1 R |
评分
-
查看全部评分
|