|
|
关于MongoDB,我们能看到的资料,基本都是在指导大家如何使用MongoDB,但是,MongoDB内部是如何运作的,资料不是很多。$ R- F& g: S, T: E# f& U; p
+ Z" t0 c0 l1 p& d3 U+ O& B
阅读使用手册,会有很多疑惑之处。例如,有人说,MongoDB 等同于分布式的 MySQL。它把一个Table ,按 row,分割成多个Shards,分别存放在不同的 Servers 上。这种说法是否正确?% S6 W" a) F) w" Z" p k
, [7 O$ @/ q' Y: p' w. E. M
不深入了解 MongoDB 的内部结构,就无法透彻地回答类似问题。这个系列文章,就来和大家探讨MongoDB的内部的工作方式。" n: S8 i% J) I: G0 l2 s
0 W) X% \ u- R( R/ s
* t5 w+ ~3 z: l2 o2 T: N
6 E7 g1 v8 v! u E1 ~图1-1 MongoDB架构图 2 z( n4 d9 ~# }0 D/ `
3 M% k& z! B: P7 B% j6 x
MongoDB 通常运行在一个服务器集群上,而不是一个单机。图1-1,描述了一个MongoDB集群的基本组成部分,包括若干shards,至少一个config server,至少一个routing servers(又称 mongos)。2 {" S k, f) J
/ Y$ t: S3 H5 P5 ]Shards
" y, c1 ~. |0 V z7 ]$ v' F) ` X8 F' ]" H5 k$ N
MongoDB的最基本的数据单元,叫document,类似于关系式数据库中的行 row。一系列documents,组成了一个collection,相当于关系式数据库中的table。当一个 collection 数据量太大时,可以把该collection按documents切分,分成多个数据块,每个数据块叫做一个chunk,多个chunks聚集在一起,组成了一个shard。
: n% |# _! J6 O$ v
- K: ]% @- ~8 i Sharding 的意义,不仅保障了数据库的扩容(scalability),同时也保障了系统的负载均衡(load balance)。0 Q' M& K. F' x, h
8 `; o. m" [+ L; e 每一个shard存储在一个物理服务器(server)上。Server上运行着mongod进程,通过这个进程,对shard中的数据进行操作,主要是增删改查。
' B, [' O# c+ W( i' |* s8 p
' B* |3 c2 i" }4 E! v. X: b# V! t 如果系统中的每个shard,只存储了一份数据,没有备份,那么当这个shard所在的server挂了,数据就丢失了。在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。0 [9 I* M( j$ l4 [1 Q% _' t. Z/ I, R
* o/ u4 b4 j! s0 p4 Z7 E
Shard keys6 B @; d+ i# T3 o$ m3 h2 R
0 q: L' P# F9 Z3 |' `, E 为了把collection切分成不同的chunks,从而存放到不同的shards中,我们需要制定一个切分的方式。% N' x. p" x {* |2 G
* i2 K' I5 E' H. m, Z 如前所述,在 MongoDB 数据库中,一个表collection由多个行 documents 组成,而每个 document,有多个属性 fields。同一个 collection 中的不同的 documents,可能会有不同的 fields。例如,有个 collection 叫 Media,包含两条 documents,
) a' Q) B' L' \. H6 H
" B. z2 H0 \* a1 {{
/ B) y* ?, J9 I: \; V' P "ISBN": "987-30-3652-5130-82",' I p9 V3 Z$ a5 S
"Type": "CD",
: P5 b2 u5 `: C/ E% }# ^/ }' j "Author": "Nirvana",, P( a" Z6 I- u p- v. ]
"Title": "Nevermind",7 J' w" G3 U" |" s! h; ?5 J
"Genre": "Grunge",
$ _4 C0 i+ N; W+ Y9 p! h "Releasedate": "1991.09.24",$ Q( y% N1 q" r) k* E
"Tracklist": [
5 k" _; @- i Q. K* q: }: `2 {( p {
. | D; R: I; z$ N( G "Track" : "1",8 G. b5 r# A7 r# p8 b
"Title" : "Smells like teen spirit",5 q' W3 L( E' y! i
"Length" : "5:02"2 W( a, m" E. c: f! W7 Z9 X
},
/ v" H- Z2 b/ _% g {2 _4 D+ S" d# n$ E5 i' J8 }
"Track" : "2",
4 G, v$ L2 L# c6 d' ^# q% Z* t; Z "Title" : "In Bloom",$ J( P& V2 Y) z$ c
"Length" : "4:15" Q, J# z" Z0 T* j P* O! F' r N
}0 `2 d/ B0 T5 U }% W# E: z1 [
]
8 J& q+ a1 y; C1 E- o3 _7 e}0 o( B8 U, U# F1 |: B# Z. f
8 a& \$ O' x+ P0 i# y
{/ y1 x, X2 D7 H
"ISBN": "987-1-4302-3051-9",
2 z$ t8 O0 N1 }! Y "Type": "Book",- O4 x: `: C8 W7 v$ R! o) N3 |- ^* C6 `$ [
"Title": "Definite Guide to MongoDB: The NoSQL Database",/ C0 I X0 S! u( l2 w7 d [5 f
"Publisher": "Apress",
! b- y/ v2 Q8 ]/ D8 i "Author": " Eelco Plugge",
4 q) [5 t' D8 e/ j "Releasedate": "2011.06.09"
6 V% E# W- F i. _1 q}# R/ w, I. l6 ^
# p" L$ Q3 u+ F& B
假如,在同一个 collection 中的所有 document,都包含某个共同的 field,例如前例中的“ISBN”,那么我们就可以按照这个 field 的值,来分割 collection。这个 field 的值,又称为 shard key。' M3 g1 O0 @( j1 {2 c0 o$ y
2 [7 P. E9 x4 `) r- P$ R+ o7 m
在选择shard key的时候,一定要确保这个key能够把collection均匀地切分成很多chunks。
8 |: @' A) B8 R* l3 C% d+ {! y$ S$ N1 c' d! p0 |: N* V
例如,如果我们选择“author”作为shard key,如果有大量的作者是重名的,那么就会有大量的数据聚集在同一个chunk中。当然,假设很少有作者同名同姓,那么“author”也可以作为一个shard key。换句话说,shard key 的选择,与使用场景密切相关。4 }5 ~. ], q: u Z9 B( B" i
6 w$ F+ r8 I& i, T' F
很多情况下,无论选择哪一个单一的 field 作为shard key,都无法均匀分割 collection。在这种情况下,我们可以考虑,用多个 fields,构成一个复合的shard key。
0 x3 ]3 K/ A) b e5 L: i& P: J
\) A3 W2 j; L+ F& Z3 a 延续前例,假如有很多作者同名同姓,他们都叫“王二”。用 author 作为 shard key,显然无法均匀切割 collection。这时我们可以加上release-date,组成name-date的复合 shard key,例如“王二 2011”。9 X* p0 C# \2 o! V/ N" @- k
! Y2 ?" ~/ G3 l7 b8 q; fChunks( S! K b0 z& i% z3 ^6 N
% d$ H) j$ V1 Y1 m. M MongoDB按 shard key,把 collection切割成若干 chunks。每个 chunk 的数据结构,是一个三元组,{collection,minKey,maxKey},如图1-2 所示。+ X6 |$ L4 r; m+ A# k$ r( H4 p2 G
9 Z9 l. j: j P! H* m9 ?* \
5 D: d% |2 N( i图1-2 chunk的三元组 4 g9 T/ v' m; K4 `& E
0 L& u& m. N; p, Y
其中,collection 是数据库中某一个表的名称,而 minKey 和 maxKey 是 shard key的范围。每一个 document 的shard key 的值,决定了这条document应该存放在哪个chunk中。7 x, x. f- d1 F# D% f( y$ h
& U0 C3 w9 Z) e& ^/ Y" c
如果两条 documents 的 shard keys 的值很接近,这两条 documents 很可能被存放在同一个 chunk 中。
. s. P& _5 d. c8 N+ j; a* P
" K* M! U* V8 ]3 V. T. g- Z Shard key 的值的顺序,决定了 document 存放的 chunk。在 MongoDB 的文献中,这种切割 collection 的方式,称为order-preserving。9 ]1 U8 R8 V! y# ?. n
0 V" H$ `) [3 N
一个 chunk最多能够存储64MB的数据。 当某个chunk存储的 documents包含的数据量,接近这个阈值时,一个chunk会被切分成两个新的chunks。
( \$ z; t# G- D Z+ V5 c6 I$ F
& _1 Y; g; q! y 当一个shard存储了过多的chunks,这个shard中的某些chunks会被迁移到其它 shard中。8 @; N4 a- P* {+ h6 {* y
8 O9 w+ Q' N8 o c' ]
这里有个问题,假如某一条 document 包含的数据量很大,超过 64MB,一个 chunk 存放不下,怎么办?在后续章节介绍 GridFS 时,我们会详细讨论。
5 M) t0 C+ C! D8 \" } \" D% q, a! ]3 h$ U" u) i
Replica set$ y$ d& n7 Y1 s6 w4 W, C0 J
: X7 Y" y2 J" i' {6 M6 D, p
在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。" X" S$ ?: ^- d4 q
1 s. L8 V4 T1 I0 Z* O
这个replica set包括一个primary DB和多个secondary DBs。为了数据的一致性,所有的修改(insert / update / deletes) 请求都交给primary处理。处理结束之后,再异步地备份到其他secondary中。
2 p. W/ y! ?0 X; g* d( k; L! I j& n- s
Primary DB由replica set中的所有servers,共同选举产生。当这个primaryDB server出错的时候,可以从replica set中重新选举一个新的primaryDB,从而避免了单点故障。& a9 i9 {) ~5 f, i4 v+ q9 s
# J' c( Q0 c$ F+ J
Replica set的选举策略和数据同步机制,确保了系统的数据的一致性。后文详述。
_0 q/ C: H4 P/ c) j, F6 }. Z4 I S$ |1 Q7 T2 j+ u
Config Server, H5 \3 I' G# E3 `9 \& @% R
2 F5 i0 K6 d; E$ |& N% w" }& M
Config servers用于存储MongoDB集群的元数据 metadata,这些元数据包括如下两个部分,每一个shard server包括哪些chunks,每个chunk存储了哪些 collections 的哪些 documents。6 ]. V/ d! E8 D1 Y' w
2 t' n& l) u. a1 z 每一个config server都包括了MongoDB中所有chunk的信息。
* [0 [4 ]# i5 H3 [* _+ x! x4 _/ Y) \3 y
Config server也需要 replication。但是有趣的是,config server 采用了自己独特的replication模式,而没有沿用 replica set。! z+ x' K- N' w
: l# r7 ?0 A9 E$ N
如果任何一台config server挂了,整个 config server 集群中,其它 config server变成只读状态。这样做的原因,是避免在系统不稳定的情况下,冒然对元数据做任何改动,导致在不同的 config servers 中,出现元数据不一致的情况。
, N1 w; a3 q3 p: F+ \* p9 N6 e8 n' N, C+ ~7 g3 j4 c! H7 p& @3 o4 p
MongoDB的官方文档建议,配置3个config servers比较合适,既提供了足够的安全性,又避免了更多的config servers实例之间的数据同步,引起的元数据不一致的麻烦。( M b0 X- }0 X1 x7 G/ A
% y5 L8 R ]+ ?Mongos
8 |2 D" ], v! m( M
; i0 y% L8 K) n) _. A, W 用户使用MongoDB 时,用户的操作请求,全部由mongos来转发。3 v( L9 ~( l7 {* v3 ?! \' W4 m
$ q6 m0 u$ A' _8 `
当 mongos 接收到用户请求时,它先查询 config server,找到存放相应数据的shard servers。然后把用户请求,转发到这些 shard servers。当这些 shard servers完成操作后,它们把结果分别返回给 mongos。而当 mongos 汇总了所有的结果后,它把结果返回给用户。1 |0 N) ?8 A& W' R b, {& z* Z
& c' [- J z" L6 y9 F7 K Mongos每次启动的时候,都要到config servers中读取元数据,并缓存在本地。每当 config server中的元数据有改动,它都会通知所有的mongos。
+ P& s5 m+ [" n5 ^5 q! p2 \3 e$ U8 k7 O& h
Mongos之间,不存在彼此协同工作的问题。因此,MongoDB所需要配置的mongos server的数量,没有限制。
/ n1 M1 |( I7 i0 A' s8 H( M! U5 H* r) z; I4 \2 `$ o1 B
通过以上的介绍,我们对每个组成部分都有了基本的了解,但是涉及到工作的细节,我们尚有诸多疑问,例如,一个chunk的数据太大,如何切分?一个shard数据太多,如何迁移?在replica set中,如何选择primary?server挂了,怎么进行故障恢复?接下来的章节,我们逐个回答这些问题。) Y1 [& U: ~, W8 q* {
* t8 n# @# \; U: O, n d
% z8 x9 l/ u8 B$ hReference,( n9 `* q( G2 l- Z8 @4 |
4 Y% T ]% c$ u8 w* M2 F( b7 K) G
[0] Architectural Overview
. g2 j1 v$ o$ r8 b8 Yhttp://www.mongodb.org/display/DOCS/Sharding+Introduction* K0 U+ [0 Z7 u" M7 U/ q
|
评分
-
查看全部评分
|