|
|
关于MongoDB,我们能看到的资料,基本都是在指导大家如何使用MongoDB,但是,MongoDB内部是如何运作的,资料不是很多。
3 H, `/ Z, i" r. I, W8 f7 U$ Q1 o6 U W3 h3 \
阅读使用手册,会有很多疑惑之处。例如,有人说,MongoDB 等同于分布式的 MySQL。它把一个Table ,按 row,分割成多个Shards,分别存放在不同的 Servers 上。这种说法是否正确?
! S c9 Z# n5 [
; f' V8 t# a, D& F 不深入了解 MongoDB 的内部结构,就无法透彻地回答类似问题。这个系列文章,就来和大家探讨MongoDB的内部的工作方式。+ ~( r9 m& V, w0 o! e+ @8 M: D' }
! N: F. T1 @% l4 {8 r# P5 X
. X1 a9 C- O( t6 p5 H; e
4 [8 G% Q% n# |' w8 r图1-1 MongoDB架构图 5 n! n3 k7 T4 L6 Z5 E K
" z. Q% x- I( U9 R# i8 y9 z1 q MongoDB 通常运行在一个服务器集群上,而不是一个单机。图1-1,描述了一个MongoDB集群的基本组成部分,包括若干shards,至少一个config server,至少一个routing servers(又称 mongos)。/ Q l( }/ |2 `. M- P& f7 p
$ l" ^. U% A, n/ SShards( C+ N+ q# r4 V, A. H( t& S5 n7 i, \
! r# v0 x: y4 \3 `; J# J
MongoDB的最基本的数据单元,叫document,类似于关系式数据库中的行 row。一系列documents,组成了一个collection,相当于关系式数据库中的table。当一个 collection 数据量太大时,可以把该collection按documents切分,分成多个数据块,每个数据块叫做一个chunk,多个chunks聚集在一起,组成了一个shard。0 K; P g9 j( I3 v! g
6 I; w& K: q9 E Sharding 的意义,不仅保障了数据库的扩容(scalability),同时也保障了系统的负载均衡(load balance)。
0 S. J& ^# _4 a, v) n1 o b3 q, ~" r# E2 R
每一个shard存储在一个物理服务器(server)上。Server上运行着mongod进程,通过这个进程,对shard中的数据进行操作,主要是增删改查。
! d) b) D- K+ k; u* X& z/ K2 \$ B6 s" r
4 T6 ]& a1 {7 i6 l 如果系统中的每个shard,只存储了一份数据,没有备份,那么当这个shard所在的server挂了,数据就丢失了。在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。
+ c ^+ y9 t* ?' f; K) P% b) n+ k4 y6 d) F, D
Shard keys
: w: I& _: h4 f, h, ^( T1 b& y( l* q
V& j% {) l1 T/ E 为了把collection切分成不同的chunks,从而存放到不同的shards中,我们需要制定一个切分的方式。* W0 x6 E9 m: p9 Y0 E
! d9 b8 S! @7 I8 H, F$ Y* L
如前所述,在 MongoDB 数据库中,一个表collection由多个行 documents 组成,而每个 document,有多个属性 fields。同一个 collection 中的不同的 documents,可能会有不同的 fields。例如,有个 collection 叫 Media,包含两条 documents,
+ e: M# v( Y- P7 a- }/ ?# n* M0 g: z! R
& T1 [$ R6 `& M1 B1 d1 E3 _{
" h) Y; O. E, }0 n5 C "ISBN": "987-30-3652-5130-82",
) V' }6 u1 [/ u0 j" J "Type": "CD",% |5 y6 D) f9 U! K
"Author": "Nirvana",
( N- Y! Z* s; m "Title": "Nevermind",$ X1 ~, d6 z# h! N8 E
"Genre": "Grunge",
- S( s+ W. a. F3 I% ?* v6 p. }7 O "Releasedate": "1991.09.24",2 L3 B' r/ h! A
"Tracklist": [
' c0 ]3 {- [3 P: b; j {/ P9 t( D3 S' h# g6 o
"Track" : "1",2 o: Z: I! _( T
"Title" : "Smells like teen spirit",; `3 R: \; ?- ~- I
"Length" : "5:02"
, i" s$ Z3 _! s( b' O1 x },
/ R3 q! S& k$ t4 l0 Q2 G {
5 c& J! B1 b# |5 }9 Y" J "Track" : "2",
L1 y: e- w+ G% d "Title" : "In Bloom",
2 s. y! l) W2 A* t3 a! u4 ?3 j "Length" : "4:15"
, C. G, Q' q) u% P }
6 P' F+ _. a! \3 z0 d4 q ]: p3 m" W1 P3 M2 t% O
}% D# ~% K! v3 D! t+ A
' S6 @3 b# v8 ?/ `) s
{
1 z W4 F+ B) P! j5 D "ISBN": "987-1-4302-3051-9",- G. T$ o3 ~, t5 w6 n* [- N- G/ |
"Type": "Book",: _5 ^" C5 a' o5 ^/ g
"Title": "Definite Guide to MongoDB: The NoSQL Database",
( e/ E8 f1 v3 l. _2 o, e3 V. q- ~ "Publisher": "Apress",1 ~/ X. o" [! n9 k4 k3 m4 \7 J
"Author": " Eelco Plugge",, [+ G+ q- W- Z! f9 \3 {
"Releasedate": "2011.06.09"
$ g( W3 M' G6 P' L X# y. v}) k, x$ ]* c+ _" g
5 m& E) y* d5 w6 v- u+ a
假如,在同一个 collection 中的所有 document,都包含某个共同的 field,例如前例中的“ISBN”,那么我们就可以按照这个 field 的值,来分割 collection。这个 field 的值,又称为 shard key。
& u' Q5 z) I3 D1 ]6 T, i x% b s3 r! [2 H3 c
在选择shard key的时候,一定要确保这个key能够把collection均匀地切分成很多chunks。& y# G3 z4 P" B4 e4 |
+ u* ?4 u; O# h 例如,如果我们选择“author”作为shard key,如果有大量的作者是重名的,那么就会有大量的数据聚集在同一个chunk中。当然,假设很少有作者同名同姓,那么“author”也可以作为一个shard key。换句话说,shard key 的选择,与使用场景密切相关。
8 }( T* F8 z7 G. _ ?) Q$ ? o) X5 d& e6 U
很多情况下,无论选择哪一个单一的 field 作为shard key,都无法均匀分割 collection。在这种情况下,我们可以考虑,用多个 fields,构成一个复合的shard key。
. U8 a7 E* |( K/ T- J" i3 [/ G' H0 z( ]& Z, J& l' D# c
延续前例,假如有很多作者同名同姓,他们都叫“王二”。用 author 作为 shard key,显然无法均匀切割 collection。这时我们可以加上release-date,组成name-date的复合 shard key,例如“王二 2011”。
l" c7 R# [$ k- g4 a$ Y! R
2 Z/ D6 q6 L+ Y; {- R, h" B" aChunks
/ H5 [+ G8 C- M; G6 l9 N
! K3 u w( e' O$ Z" W Q* W0 ?+ U MongoDB按 shard key,把 collection切割成若干 chunks。每个 chunk 的数据结构,是一个三元组,{collection,minKey,maxKey},如图1-2 所示。3 k- W; r$ S8 H
) [# V$ s4 A# p- M/ Q2 }
: p0 @! ?1 J; n/ `' [2 w- J7 d+ w
图1-2 chunk的三元组 : o0 r) a' j9 Q9 L: f
7 y# b- @2 v% z" D7 j
其中,collection 是数据库中某一个表的名称,而 minKey 和 maxKey 是 shard key的范围。每一个 document 的shard key 的值,决定了这条document应该存放在哪个chunk中。
2 {8 Y+ n# } N+ _0 ^
& ~& v4 S. s! ?: V1 t 如果两条 documents 的 shard keys 的值很接近,这两条 documents 很可能被存放在同一个 chunk 中。' W+ K: \7 d8 g2 ^
/ e: H/ Z. c3 e) w% s4 E, s5 `; o Shard key 的值的顺序,决定了 document 存放的 chunk。在 MongoDB 的文献中,这种切割 collection 的方式,称为order-preserving。
; y% v6 ^* N! G( c: k5 U! v& q; t! K4 M5 o8 c
一个 chunk最多能够存储64MB的数据。 当某个chunk存储的 documents包含的数据量,接近这个阈值时,一个chunk会被切分成两个新的chunks。% S7 y- b( t6 B- [. z( V
* L- }- k5 B, w2 z
当一个shard存储了过多的chunks,这个shard中的某些chunks会被迁移到其它 shard中。) p( k; l) r1 a ]1 b( p) ^
# x# g8 H7 l9 {! f0 R
这里有个问题,假如某一条 document 包含的数据量很大,超过 64MB,一个 chunk 存放不下,怎么办?在后续章节介绍 GridFS 时,我们会详细讨论。
A2 M1 P2 ?8 [' z/ A8 ^# _/ m4 ^8 z0 S; L. x
Replica set) b; l2 b. O6 S; u' x
' e- k5 n2 C$ ^5 y [( P! C% l+ U 在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。
9 Y ^9 Y6 `$ C2 F4 x% z% v( D& ]3 U; Y8 b, t) m
这个replica set包括一个primary DB和多个secondary DBs。为了数据的一致性,所有的修改(insert / update / deletes) 请求都交给primary处理。处理结束之后,再异步地备份到其他secondary中。+ u0 O7 }2 q; t
$ M7 H' V9 E1 } Primary DB由replica set中的所有servers,共同选举产生。当这个primaryDB server出错的时候,可以从replica set中重新选举一个新的primaryDB,从而避免了单点故障。 G8 Q: r0 w- R8 R" \
9 Y, ^9 s! X1 T7 j3 T
Replica set的选举策略和数据同步机制,确保了系统的数据的一致性。后文详述。
' r: H3 P8 X3 i3 [3 L6 F' H" E& c' q: j7 S
Config Server- W7 r0 K6 N* d, e
1 F+ ~" Z3 s6 u- z( m" d( W Config servers用于存储MongoDB集群的元数据 metadata,这些元数据包括如下两个部分,每一个shard server包括哪些chunks,每个chunk存储了哪些 collections 的哪些 documents。
, ^7 n) @ g/ }$ `2 B9 Q0 K+ g+ M
( U6 n. t. O6 P* s1 x7 D7 r 每一个config server都包括了MongoDB中所有chunk的信息。2 A! s! q! W/ p8 a
# j6 v3 l" p) _ Config server也需要 replication。但是有趣的是,config server 采用了自己独特的replication模式,而没有沿用 replica set。
4 D3 F1 F" m9 Z; n- ?1 l
/ A- p. B6 Z) t+ T 如果任何一台config server挂了,整个 config server 集群中,其它 config server变成只读状态。这样做的原因,是避免在系统不稳定的情况下,冒然对元数据做任何改动,导致在不同的 config servers 中,出现元数据不一致的情况。
, b; C/ }/ x: c4 [" [3 x# b2 w P6 S1 g
MongoDB的官方文档建议,配置3个config servers比较合适,既提供了足够的安全性,又避免了更多的config servers实例之间的数据同步,引起的元数据不一致的麻烦。
& O& q% b$ C1 z/ ]+ t+ x* t/ m
; O$ @: \% j8 D. \9 N5 z" o/ TMongos5 [5 z+ e8 ?: Q8 j3 A
, Z/ K7 Z- h+ H% z 用户使用MongoDB 时,用户的操作请求,全部由mongos来转发。
8 I: E4 f" ^% P j' C5 F5 e- u
. d9 i. B$ g* R- z/ O9 j+ T6 _ 当 mongos 接收到用户请求时,它先查询 config server,找到存放相应数据的shard servers。然后把用户请求,转发到这些 shard servers。当这些 shard servers完成操作后,它们把结果分别返回给 mongos。而当 mongos 汇总了所有的结果后,它把结果返回给用户。
: F9 K b% W$ |; Q8 E4 N- A1 F) Q) _. V" |
Mongos每次启动的时候,都要到config servers中读取元数据,并缓存在本地。每当 config server中的元数据有改动,它都会通知所有的mongos。
' o# q$ N: X* s+ f0 m+ }/ x- X1 y0 J" h/ t7 l6 A; k) j
Mongos之间,不存在彼此协同工作的问题。因此,MongoDB所需要配置的mongos server的数量,没有限制。
+ o3 H! @! a) R; O
9 f G3 E/ o' ~ 通过以上的介绍,我们对每个组成部分都有了基本的了解,但是涉及到工作的细节,我们尚有诸多疑问,例如,一个chunk的数据太大,如何切分?一个shard数据太多,如何迁移?在replica set中,如何选择primary?server挂了,怎么进行故障恢复?接下来的章节,我们逐个回答这些问题。
: K. e. O5 H4 D+ w2 m7 c4 Y S/ X3 N+ p
' a8 y1 V9 b$ s8 R, N; x2 _
Reference,
2 S7 S2 S* @6 N. U. z7 z
8 _# Y: E& L/ r9 i4 t[0] Architectural Overview6 H/ @" w4 q2 f& x( `6 n+ c$ }
http://www.mongodb.org/display/DOCS/Sharding+Introduction
& ]) ~# J' b/ j3 S7 v5 } |
评分
-
查看全部评分
|