|
|
关于MongoDB,我们能看到的资料,基本都是在指导大家如何使用MongoDB,但是,MongoDB内部是如何运作的,资料不是很多。2 R1 S* K% m' L# Y* {/ ^
4 a' m% p( t5 c& c, C5 h' `0 i 阅读使用手册,会有很多疑惑之处。例如,有人说,MongoDB 等同于分布式的 MySQL。它把一个Table ,按 row,分割成多个Shards,分别存放在不同的 Servers 上。这种说法是否正确?
) ]# l: K0 z' h# J& y5 P" t0 S, U+ ~: x$ R3 Y5 d4 e. E: i7 v% O
不深入了解 MongoDB 的内部结构,就无法透彻地回答类似问题。这个系列文章,就来和大家探讨MongoDB的内部的工作方式。
# j) ~3 B7 k7 m! ^8 n( i) |
& R: L& V' X6 Q. a9 z
) s2 I: }9 U$ ]5 C
. Q( {. ]3 O& n: T& F- }图1-1 MongoDB架构图
2 H$ z1 L3 s9 V0 {4 q" P3 I8 r( H; u# j* O% \3 G
MongoDB 通常运行在一个服务器集群上,而不是一个单机。图1-1,描述了一个MongoDB集群的基本组成部分,包括若干shards,至少一个config server,至少一个routing servers(又称 mongos)。
7 P; l, ~; I1 A" s0 v5 D6 `7 P! ^4 c7 K, z G
Shards2 X o% L. o) S* r: \& K7 ?* `
* M% r) b; M" o5 \- o3 w b r
MongoDB的最基本的数据单元,叫document,类似于关系式数据库中的行 row。一系列documents,组成了一个collection,相当于关系式数据库中的table。当一个 collection 数据量太大时,可以把该collection按documents切分,分成多个数据块,每个数据块叫做一个chunk,多个chunks聚集在一起,组成了一个shard。1 B- }, N- C [+ b' R! i
0 p2 C2 Q( _8 o0 |! p) n3 T3 m
Sharding 的意义,不仅保障了数据库的扩容(scalability),同时也保障了系统的负载均衡(load balance)。
1 V9 `! e7 D% r5 u, M' q& R! j8 V8 \ q" H+ r. y8 u' F4 A O
每一个shard存储在一个物理服务器(server)上。Server上运行着mongod进程,通过这个进程,对shard中的数据进行操作,主要是增删改查。
) R* t. W4 D# |7 b% C; u- c
7 I( ?& i- m& M" P 如果系统中的每个shard,只存储了一份数据,没有备份,那么当这个shard所在的server挂了,数据就丢失了。在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。
0 v6 O' g3 y( B" k1 ~
, w' l3 S1 p+ Y8 ?. Z1 _) @+ g4 JShard keys
( W; y* o+ G( e8 D
- D2 q0 K1 j C, Z) D0 N 为了把collection切分成不同的chunks,从而存放到不同的shards中,我们需要制定一个切分的方式。
# t8 Z) A n$ y% g
2 |+ @3 q1 N- [# x! F* o 如前所述,在 MongoDB 数据库中,一个表collection由多个行 documents 组成,而每个 document,有多个属性 fields。同一个 collection 中的不同的 documents,可能会有不同的 fields。例如,有个 collection 叫 Media,包含两条 documents,
m4 z+ E5 q! t, }; ^6 } w; i: n/ v) h' p2 A
{
$ ~! s( ]3 K2 g T/ w. H "ISBN": "987-30-3652-5130-82",
' y4 n* ]3 K2 t" ` "Type": "CD",* _/ u" T/ t) B- u2 A. Z- @, P$ x
"Author": "Nirvana",9 Y# w) {# d* Y: P
"Title": "Nevermind",: E+ Y; D8 u4 Y
"Genre": "Grunge",
4 S) Y2 e9 J; N2 ` r, q "Releasedate": "1991.09.24",
D' _# B! @- W* ?5 d "Tracklist": [; ~. P0 u( B6 i& J+ B+ y( f
{
1 C0 _: M/ L# C+ \) b" u1 { "Track" : "1",3 \5 V! i7 U" S0 J$ P5 g
"Title" : "Smells like teen spirit",% {. G! z: p5 O$ V) `9 A' q
"Length" : "5:02"
" Y9 D0 g4 \9 n4 h. M },
$ B4 x: e4 a* b; m9 k$ J1 n, ?5 A7 q. j {
6 I. b1 K1 @- l "Track" : "2",
; _( e4 }" W. w. l# s# G% d% a "Title" : "In Bloom",
4 ]2 a9 ?) _% M) n8 G "Length" : "4:15"% d4 p1 p2 w/ }. k: x6 j- e7 |: r
}, \% i K- [; f3 _
]
3 I3 U0 V. G0 x! Q) U}# |2 o' w6 J) m1 c# n7 h3 Q# r
# w0 j6 L- ^& z& Z" l{9 O0 `- x+ t5 _7 r3 _( A
"ISBN": "987-1-4302-3051-9",$ w% ?% {6 M3 y; D( s
"Type": "Book",! l+ x4 f* @, d( R9 X; s% y
"Title": "Definite Guide to MongoDB: The NoSQL Database",- O; E) W2 k+ |2 l+ }0 |9 x0 m
"Publisher": "Apress",
" {9 h& @0 f h( d, X "Author": " Eelco Plugge",
1 Q P% a3 @! s+ o l "Releasedate": "2011.06.09"
Y$ V+ A- w2 v8 J0 O4 M8 m}2 \/ u2 p* v+ z7 o4 D
6 e/ |$ v( F# q1 u; s4 b 假如,在同一个 collection 中的所有 document,都包含某个共同的 field,例如前例中的“ISBN”,那么我们就可以按照这个 field 的值,来分割 collection。这个 field 的值,又称为 shard key。
3 ?( a" L: c9 C% `
2 Z) }& `( j; u! A: b) Z1 G 在选择shard key的时候,一定要确保这个key能够把collection均匀地切分成很多chunks。! _! ]7 q* t" b1 M8 u
4 h; b1 _" W1 \2 g4 Y
例如,如果我们选择“author”作为shard key,如果有大量的作者是重名的,那么就会有大量的数据聚集在同一个chunk中。当然,假设很少有作者同名同姓,那么“author”也可以作为一个shard key。换句话说,shard key 的选择,与使用场景密切相关。5 r5 R) o3 d* l0 p" n
. k- B# x* g) Z% {- D5 L 很多情况下,无论选择哪一个单一的 field 作为shard key,都无法均匀分割 collection。在这种情况下,我们可以考虑,用多个 fields,构成一个复合的shard key。
' U( a, j9 R1 p6 m
) C% J& ^, E$ t g: I 延续前例,假如有很多作者同名同姓,他们都叫“王二”。用 author 作为 shard key,显然无法均匀切割 collection。这时我们可以加上release-date,组成name-date的复合 shard key,例如“王二 2011”。. S# G$ p, }4 c) S" e
: J+ Z, Z& d1 N1 G: S+ d/ N
Chunks. w6 Z6 ?5 a( D7 s* @4 r2 C# `2 ]
- ]- ?1 Y9 V5 @# B MongoDB按 shard key,把 collection切割成若干 chunks。每个 chunk 的数据结构,是一个三元组,{collection,minKey,maxKey},如图1-2 所示。
Y2 y0 R9 X6 w3 K, v6 g+ ~0 ]
5 f: D4 g0 o/ _; F4 G
6 N% k; ~/ N3 }4 ^4 V% d图1-2 chunk的三元组 8 H* E, {: J$ b8 d0 c+ e
1 h% h. e4 Q+ k; a1 [ 其中,collection 是数据库中某一个表的名称,而 minKey 和 maxKey 是 shard key的范围。每一个 document 的shard key 的值,决定了这条document应该存放在哪个chunk中。
3 l9 A/ J; w7 O6 z) K. |1 A4 s% P7 O0 W3 D" I9 W
如果两条 documents 的 shard keys 的值很接近,这两条 documents 很可能被存放在同一个 chunk 中。2 T. ^) Z4 I" a* v7 i3 I1 b u
4 Y- Q6 y' M0 H* b2 e, t5 _- V Shard key 的值的顺序,决定了 document 存放的 chunk。在 MongoDB 的文献中,这种切割 collection 的方式,称为order-preserving。! Q$ V7 v* ^5 U- Z
1 w8 y2 l! X9 f9 R
一个 chunk最多能够存储64MB的数据。 当某个chunk存储的 documents包含的数据量,接近这个阈值时,一个chunk会被切分成两个新的chunks。
* z$ S8 }% F4 H% n( q U7 C- J( Y& O* L* @3 L
当一个shard存储了过多的chunks,这个shard中的某些chunks会被迁移到其它 shard中。9 _; B; Y* R# m n. z
0 h5 A3 R5 e" Z1 z 这里有个问题,假如某一条 document 包含的数据量很大,超过 64MB,一个 chunk 存放不下,怎么办?在后续章节介绍 GridFS 时,我们会详细讨论。) ~2 w, n! m0 d7 l2 a; y4 t- p" ]0 U
# V+ R' k, ^- nReplica set
; h0 G& ?/ ]7 ?1 ^: R % N+ ^9 U& i5 M2 ?/ W
在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。
+ g8 G% M2 ^; ]) l3 ~
+ Q% Y8 Q' z) h' f) `+ C) z 这个replica set包括一个primary DB和多个secondary DBs。为了数据的一致性,所有的修改(insert / update / deletes) 请求都交给primary处理。处理结束之后,再异步地备份到其他secondary中。
7 |1 f9 S8 C& E2 @0 ]. d0 a* I* |' f" e+ j- J3 v
Primary DB由replica set中的所有servers,共同选举产生。当这个primaryDB server出错的时候,可以从replica set中重新选举一个新的primaryDB,从而避免了单点故障。
; j' p- D; }" }/ [# C4 f
$ y8 j1 o# e8 g* u1 V% R Replica set的选举策略和数据同步机制,确保了系统的数据的一致性。后文详述。
5 u; B, V' i& ^" `
) G V3 N$ M1 a9 @/ K: `Config Server$ S4 B$ O: U) A8 J9 \
: Y' Z" N0 ?, E1 [; a- \ Config servers用于存储MongoDB集群的元数据 metadata,这些元数据包括如下两个部分,每一个shard server包括哪些chunks,每个chunk存储了哪些 collections 的哪些 documents。0 g4 ]0 C% a: m) j6 F9 C/ A3 x
' t" S# z+ ?! `! h0 { 每一个config server都包括了MongoDB中所有chunk的信息。
U0 ?2 B( W* x& _
4 E9 }( O3 Y N' ~! t5 a Config server也需要 replication。但是有趣的是,config server 采用了自己独特的replication模式,而没有沿用 replica set。
0 E0 @" R* N5 G6 q2 ^1 R- I# y0 y0 Q6 \5 a
如果任何一台config server挂了,整个 config server 集群中,其它 config server变成只读状态。这样做的原因,是避免在系统不稳定的情况下,冒然对元数据做任何改动,导致在不同的 config servers 中,出现元数据不一致的情况。
. e6 E& G7 ?1 G5 A/ _
% M( i) m4 d `, M+ j MongoDB的官方文档建议,配置3个config servers比较合适,既提供了足够的安全性,又避免了更多的config servers实例之间的数据同步,引起的元数据不一致的麻烦。- I7 ]3 Q& g% M0 L0 Z8 \6 n
$ [+ A9 @" M3 r9 }" | HMongos: {$ L: X( Z1 b5 D9 o
9 h% L% u$ b5 `: Y$ ~$ \) N& T 用户使用MongoDB 时,用户的操作请求,全部由mongos来转发。$ [4 H y `/ v, r$ n8 `9 I" A
9 `* C( u; s4 ?' h3 v( I) S6 J! r 当 mongos 接收到用户请求时,它先查询 config server,找到存放相应数据的shard servers。然后把用户请求,转发到这些 shard servers。当这些 shard servers完成操作后,它们把结果分别返回给 mongos。而当 mongos 汇总了所有的结果后,它把结果返回给用户。, o# a/ p$ `- a: Q" \6 Y7 p
! b. t( m5 A. ^, p# U
Mongos每次启动的时候,都要到config servers中读取元数据,并缓存在本地。每当 config server中的元数据有改动,它都会通知所有的mongos。5 ]" o# E6 s( M3 Y
5 n8 z! F6 i \7 N/ q
Mongos之间,不存在彼此协同工作的问题。因此,MongoDB所需要配置的mongos server的数量,没有限制。- e" B& M1 R' V8 W
% v+ j5 k) {+ g+ v7 }" r0 Y S8 B
通过以上的介绍,我们对每个组成部分都有了基本的了解,但是涉及到工作的细节,我们尚有诸多疑问,例如,一个chunk的数据太大,如何切分?一个shard数据太多,如何迁移?在replica set中,如何选择primary?server挂了,怎么进行故障恢复?接下来的章节,我们逐个回答这些问题。" t+ a' Z9 g- Q& M8 t8 ?. Y' o" D m
: x! E9 I. B- R
0 N( |3 Q p7 J: B, i- X
Reference,1 k R) i: }5 @7 W: B0 e! z. l y
4 f. |0 K7 b! t# \& p) H! Y& r[0] Architectural Overview- C4 @) ?+ W1 q$ N: R+ H
http://www.mongodb.org/display/DOCS/Sharding+Introduction
) t- l2 W; I# x% f/ I. G4 \ |
评分
-
查看全部评分
|