|
|
关于MongoDB,我们能看到的资料,基本都是在指导大家如何使用MongoDB,但是,MongoDB内部是如何运作的,资料不是很多。3 ?+ I; i$ C H5 D. b7 a" v4 m$ a
" u- l0 e" y7 d- O0 _ 阅读使用手册,会有很多疑惑之处。例如,有人说,MongoDB 等同于分布式的 MySQL。它把一个Table ,按 row,分割成多个Shards,分别存放在不同的 Servers 上。这种说法是否正确?
, m. c; l: O! G7 o* ~1 B! @* Q, U( U* Z6 v& \! O2 ?/ ?
不深入了解 MongoDB 的内部结构,就无法透彻地回答类似问题。这个系列文章,就来和大家探讨MongoDB的内部的工作方式。, e7 r/ ?$ D' u! |. @5 k
$ m. G6 W3 V2 ^9 i' \2 f! w/ S
3 m* Z) H8 Y& N0 ? X' w5 ]5 m6 \6 F' a- J3 E
图1-1 MongoDB架构图 8 K( P1 M( W% O# U& Y* J1 r
( h6 M& A4 f- z1 x% J
MongoDB 通常运行在一个服务器集群上,而不是一个单机。图1-1,描述了一个MongoDB集群的基本组成部分,包括若干shards,至少一个config server,至少一个routing servers(又称 mongos)。- r' D1 u' I1 H H1 Z
" @5 Y. o/ `: E! u! G
Shards
6 u5 F/ W4 |, X# K7 f2 A
( [ a5 e6 C9 R* x6 E/ y MongoDB的最基本的数据单元,叫document,类似于关系式数据库中的行 row。一系列documents,组成了一个collection,相当于关系式数据库中的table。当一个 collection 数据量太大时,可以把该collection按documents切分,分成多个数据块,每个数据块叫做一个chunk,多个chunks聚集在一起,组成了一个shard。
1 L, i; F# Q( X/ B. x+ f2 u- ]0 ~$ U! ^/ A& {0 |: R# R: `
Sharding 的意义,不仅保障了数据库的扩容(scalability),同时也保障了系统的负载均衡(load balance)。
1 N, D5 U1 S u: v/ m
' ]4 N! P1 @& I2 h c7 g 每一个shard存储在一个物理服务器(server)上。Server上运行着mongod进程,通过这个进程,对shard中的数据进行操作,主要是增删改查。 [8 T7 ^- T* q2 l& M3 m# }
9 g/ o0 C6 m* m 如果系统中的每个shard,只存储了一份数据,没有备份,那么当这个shard所在的server挂了,数据就丢失了。在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。
+ D- h. e T+ I* g: k3 o8 Z; P" \8 W, s! ?# o$ D7 }4 r6 t% \0 X
Shard keys. v: z/ D% w0 S [* j$ g O/ D
/ C/ |3 ~: Z" L' }/ k% w3 L
为了把collection切分成不同的chunks,从而存放到不同的shards中,我们需要制定一个切分的方式。0 n8 ?( L( i. {( T8 k* m
& h- q( \6 x7 r$ y# I$ ]; @+ y 如前所述,在 MongoDB 数据库中,一个表collection由多个行 documents 组成,而每个 document,有多个属性 fields。同一个 collection 中的不同的 documents,可能会有不同的 fields。例如,有个 collection 叫 Media,包含两条 documents,
) a) x7 b; Z: c7 @$ c; R1 T) v$ n* x1 J" A" i& h: M# I3 Y$ H
{ T3 E; X2 A2 v& {- [
"ISBN": "987-30-3652-5130-82",* g; `2 k- v* ]+ d7 }) S @& `
"Type": "CD",
( x/ e4 f' M- i, m1 u& d" k4 y0 J "Author": "Nirvana",; U% P& S1 F& i/ c& i5 V B
"Title": "Nevermind",
) }& X0 n1 H1 o2 b8 J2 h: G8 n! Y% l "Genre": "Grunge",9 E3 m4 _8 o H- ~( Z
"Releasedate": "1991.09.24",
/ f/ ?) n8 U0 e5 D/ N "Tracklist": [
9 o2 T$ q( w _ {
$ t7 u0 d' e5 W1 W$ [/ O6 n# o "Track" : "1", h2 j+ j% f: J8 }* q
"Title" : "Smells like teen spirit",1 I6 ~+ A8 L( Z" x
"Length" : "5:02"4 J- A* o3 ~+ u5 C2 }7 ?
},
4 G5 C9 q ]) I. i1 w) m7 l6 x {
4 k" \% a7 j9 A+ i) s( g "Track" : "2",
9 i( P- e4 @# c0 T "Title" : "In Bloom",5 \; R/ }2 Q9 R, c2 V3 o9 f9 J
"Length" : "4:15"4 k$ t0 B7 b# j
}) d2 m. c, R! i
]
5 ~" G$ R$ h- L* I}8 R* } g% r- K
" _" d( l# u% o
{
9 n9 e2 ?" l- s; R/ h# w "ISBN": "987-1-4302-3051-9",/ g+ K c( C' d$ y6 \
"Type": "Book",1 s, ?% T/ a4 [' l
"Title": "Definite Guide to MongoDB: The NoSQL Database",
9 U7 g5 g; ~% B5 Z4 c/ S "Publisher": "Apress",4 h# l7 X, q- p: T0 K" x0 n/ a$ O
"Author": " Eelco Plugge",4 B# o1 g; E( @: O* K0 U! ?$ j9 x
"Releasedate": "2011.06.09"
8 C6 m# b: e7 q6 p}
~/ k' r1 a4 q4 o% X0 G
8 n B: k5 L, d/ R. ? 假如,在同一个 collection 中的所有 document,都包含某个共同的 field,例如前例中的“ISBN”,那么我们就可以按照这个 field 的值,来分割 collection。这个 field 的值,又称为 shard key。
8 ^4 M; g# U! B& ~5 G, q" o5 d# J) v6 t! b
在选择shard key的时候,一定要确保这个key能够把collection均匀地切分成很多chunks。
5 V( \; b; I. s1 {# \
- S: j! X: }7 Y- ^# X 例如,如果我们选择“author”作为shard key,如果有大量的作者是重名的,那么就会有大量的数据聚集在同一个chunk中。当然,假设很少有作者同名同姓,那么“author”也可以作为一个shard key。换句话说,shard key 的选择,与使用场景密切相关。
% `+ V: l7 o, U; A- U: q' [5 C1 S+ _8 z& s6 e. A2 ?" B4 f
很多情况下,无论选择哪一个单一的 field 作为shard key,都无法均匀分割 collection。在这种情况下,我们可以考虑,用多个 fields,构成一个复合的shard key。
) @$ a N( g1 f/ L2 W0 R7 J- @2 S
$ D! i ^, n2 s, M" R( v0 a$ j" Q 延续前例,假如有很多作者同名同姓,他们都叫“王二”。用 author 作为 shard key,显然无法均匀切割 collection。这时我们可以加上release-date,组成name-date的复合 shard key,例如“王二 2011”。( {: w+ C, S4 U7 W8 ~
; s: E, g0 Z; {4 f+ V F
Chunks# z) q" c7 h5 Q2 c. |
) R- a" e- b. N5 a MongoDB按 shard key,把 collection切割成若干 chunks。每个 chunk 的数据结构,是一个三元组,{collection,minKey,maxKey},如图1-2 所示。% F# \0 s1 o& j; F) N7 T
$ ]- [! O" P: L) C( l4 g
' O0 Y; ^( r2 z, ?" X4 w, f7 e图1-2 chunk的三元组 - v8 Q" K2 Y. t U7 Q
% V: t) _: g: b& [+ w
其中,collection 是数据库中某一个表的名称,而 minKey 和 maxKey 是 shard key的范围。每一个 document 的shard key 的值,决定了这条document应该存放在哪个chunk中。
; e" q0 g; {3 T) p4 s$ Z; i; p! A5 V0 q! `: S: H
如果两条 documents 的 shard keys 的值很接近,这两条 documents 很可能被存放在同一个 chunk 中。
3 s2 l3 V/ r8 I9 l& K
1 q0 |2 R; B# C% ?; q( h Shard key 的值的顺序,决定了 document 存放的 chunk。在 MongoDB 的文献中,这种切割 collection 的方式,称为order-preserving。
! @, L8 {+ P6 x9 `
) _$ J" X3 O% s 一个 chunk最多能够存储64MB的数据。 当某个chunk存储的 documents包含的数据量,接近这个阈值时,一个chunk会被切分成两个新的chunks。2 \8 ^) c$ A3 s8 w; ~1 T
9 ~) A$ m9 r+ z 当一个shard存储了过多的chunks,这个shard中的某些chunks会被迁移到其它 shard中。
, ]% M6 L* F+ ]$ b
8 ^5 k4 J. X% P& y7 V 这里有个问题,假如某一条 document 包含的数据量很大,超过 64MB,一个 chunk 存放不下,怎么办?在后续章节介绍 GridFS 时,我们会详细讨论。
6 Z( m, u8 | N: l& t7 n( ~5 N( _" V7 q+ r
Replica set" e& N" x7 e( H7 t( _# @5 t. Z
/ g/ e! z' S. C- a0 X; \5 l4 U4 }2 e 在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。9 w' v W: a2 ?: T' [8 Q
- w* Z0 X# l1 w
这个replica set包括一个primary DB和多个secondary DBs。为了数据的一致性,所有的修改(insert / update / deletes) 请求都交给primary处理。处理结束之后,再异步地备份到其他secondary中。% @! c5 i; z" {0 Z c4 F# @
6 g; U4 x, R% _ Primary DB由replica set中的所有servers,共同选举产生。当这个primaryDB server出错的时候,可以从replica set中重新选举一个新的primaryDB,从而避免了单点故障。
. u5 {5 s4 V9 ?. d: E5 Q
+ M( B# L" ~$ v Replica set的选举策略和数据同步机制,确保了系统的数据的一致性。后文详述。
% ?+ A! z! k6 V$ j( l: i
" v3 w5 s4 ]: j( o- a$ @5 f4 HConfig Server
1 k$ E8 W8 D; P& z9 D$ n # \# n7 E E* d$ M
Config servers用于存储MongoDB集群的元数据 metadata,这些元数据包括如下两个部分,每一个shard server包括哪些chunks,每个chunk存储了哪些 collections 的哪些 documents。
% b6 \+ }' u/ C( P8 _8 x
+ F+ f5 K3 L% A, m, R 每一个config server都包括了MongoDB中所有chunk的信息。
3 x- z0 B3 z! |1 E* B
: C2 X. E2 a( a- q& h* B! |; y1 Y Config server也需要 replication。但是有趣的是,config server 采用了自己独特的replication模式,而没有沿用 replica set。( O1 V; a6 @+ R f) @
3 a& ^4 G( `' \ v
如果任何一台config server挂了,整个 config server 集群中,其它 config server变成只读状态。这样做的原因,是避免在系统不稳定的情况下,冒然对元数据做任何改动,导致在不同的 config servers 中,出现元数据不一致的情况。; q! _. B1 l% y: i
1 k x" O* V9 [3 A6 @/ W
MongoDB的官方文档建议,配置3个config servers比较合适,既提供了足够的安全性,又避免了更多的config servers实例之间的数据同步,引起的元数据不一致的麻烦。
! j# v1 R+ j& A4 e
& d7 Y& i% Y9 H& x6 z* eMongos: j6 r0 @9 e5 o' d2 O
2 @! ^/ ?& k! H* ?2 h, u, ? 用户使用MongoDB 时,用户的操作请求,全部由mongos来转发。# D% _/ O5 c3 j& Z
. k& I! [9 y2 q/ i' ?5 _ 当 mongos 接收到用户请求时,它先查询 config server,找到存放相应数据的shard servers。然后把用户请求,转发到这些 shard servers。当这些 shard servers完成操作后,它们把结果分别返回给 mongos。而当 mongos 汇总了所有的结果后,它把结果返回给用户。& q* k2 O% r' g4 h4 |3 ~
# P T* p$ r! `# {, o
Mongos每次启动的时候,都要到config servers中读取元数据,并缓存在本地。每当 config server中的元数据有改动,它都会通知所有的mongos。& \3 r9 C- c; x4 [8 X7 f
) L l1 U: d: V& X q) ~ Mongos之间,不存在彼此协同工作的问题。因此,MongoDB所需要配置的mongos server的数量,没有限制。; \* X: L) Q1 o" P$ A
3 p. d u8 A5 N 通过以上的介绍,我们对每个组成部分都有了基本的了解,但是涉及到工作的细节,我们尚有诸多疑问,例如,一个chunk的数据太大,如何切分?一个shard数据太多,如何迁移?在replica set中,如何选择primary?server挂了,怎么进行故障恢复?接下来的章节,我们逐个回答这些问题。
: _5 u. d: b$ h- C
' b5 D7 X' ?9 [5 {$ u' P9 m7 `( W0 C9 F
Reference,
8 M- r8 i) z- w: ~6 e
+ `+ K, E3 |& q: s7 l[0] Architectural Overview
0 [5 h* y# _& H' I: khttp://www.mongodb.org/display/DOCS/Sharding+Introduction8 y. x9 i5 X" z8 Q& `: S! E- D
|
评分
-
查看全部评分
|