|
关于MongoDB,我们能看到的资料,基本都是在指导大家如何使用MongoDB,但是,MongoDB内部是如何运作的,资料不是很多。
0 N/ W' m% m* M9 r& W$ U( ^ `4 W6 ?% h" K: l( {" Y; S% N' D
阅读使用手册,会有很多疑惑之处。例如,有人说,MongoDB 等同于分布式的 MySQL。它把一个Table ,按 row,分割成多个Shards,分别存放在不同的 Servers 上。这种说法是否正确?
$ |) j" G' y6 o8 A4 R5 Q r4 {0 y2 o, u: t1 `
不深入了解 MongoDB 的内部结构,就无法透彻地回答类似问题。这个系列文章,就来和大家探讨MongoDB的内部的工作方式。" e: W, w2 F0 F2 }9 }- G; a
y5 C" J# G4 F. q
" l' C* b: G+ Z, T$ ^& s- v1 ]) c9 H
图1-1 MongoDB架构图 ! s: ?4 U8 @7 X" ^. g* \
: M9 N7 R4 b3 c" ^$ t8 H3 M MongoDB 通常运行在一个服务器集群上,而不是一个单机。图1-1,描述了一个MongoDB集群的基本组成部分,包括若干shards,至少一个config server,至少一个routing servers(又称 mongos)。
2 L2 Z' I1 y* _" V9 l4 o6 v
/ V; p( }9 Y' f# t* @4 ?Shards2 A6 ~2 W+ f* y: `
9 w3 v1 r" A, u MongoDB的最基本的数据单元,叫document,类似于关系式数据库中的行 row。一系列documents,组成了一个collection,相当于关系式数据库中的table。当一个 collection 数据量太大时,可以把该collection按documents切分,分成多个数据块,每个数据块叫做一个chunk,多个chunks聚集在一起,组成了一个shard。
$ z3 }; s- y% R$ k9 j+ \; ^$ n' e2 ^
Sharding 的意义,不仅保障了数据库的扩容(scalability),同时也保障了系统的负载均衡(load balance)。 U* S0 C! J, Z$ Z2 S. i
+ y/ I9 a# \; P% {5 a
每一个shard存储在一个物理服务器(server)上。Server上运行着mongod进程,通过这个进程,对shard中的数据进行操作,主要是增删改查。
1 i5 m4 }, P) L1 ]1 n2 W* l) W
4 k, | o( d% p% ^7 w. o/ H' y 如果系统中的每个shard,只存储了一份数据,没有备份,那么当这个shard所在的server挂了,数据就丢失了。在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。3 d$ p0 @& x9 ?# C w0 ~3 D5 k
- V4 n# L( d- o& w& h8 |+ O, ^
Shard keys! T8 T* P8 \/ E' g7 k9 e* v ~: E
1 b3 z2 v' g3 J 为了把collection切分成不同的chunks,从而存放到不同的shards中,我们需要制定一个切分的方式。
* G& @3 \! w p8 [" {" \, Q7 _: ~/ t' O3 U3 N+ t* `0 M
如前所述,在 MongoDB 数据库中,一个表collection由多个行 documents 组成,而每个 document,有多个属性 fields。同一个 collection 中的不同的 documents,可能会有不同的 fields。例如,有个 collection 叫 Media,包含两条 documents,7 c/ F) S3 X* C7 B
4 M6 ~3 B* N; q9 M W3 `
{# U& N& ~1 O: G! [5 f
"ISBN": "987-30-3652-5130-82",6 D) N$ O( X0 W: } V/ a1 N
"Type": "CD",
/ w1 r) ?) Y8 h" Q1 b( V' [5 Z "Author": "Nirvana",
" e6 j' B7 a- d( v "Title": "Nevermind",! M2 k/ L- }2 F6 M7 T* ?# X( \. r
"Genre": "Grunge",5 m/ X& _5 M0 h. A) T
"Releasedate": "1991.09.24",) x' F) w, k+ h5 K- x( L6 C; l
"Tracklist": [
; k8 F; P. ]% }% S3 G0 O- ~6 Q {/ A4 T- ]" I1 b: L
"Track" : "1",* _6 j2 W( D6 a1 Q1 q& j$ U: [6 H
"Title" : "Smells like teen spirit",1 S% e2 A/ F1 ^, l
"Length" : "5:02"
$ A6 H1 u0 T8 Z },/ [ l( V+ r. ^8 u
{
0 d; U9 E% {+ o' i/ v" n "Track" : "2",$ M( X# ^" ~* d+ |8 \
"Title" : "In Bloom",5 k: h7 Q6 i) D" s {
"Length" : "4:15", z' i) l l. }$ Z: g
}; @" r# H9 |- P9 j
]
* d f* I* B7 R8 x1 S: j( T, Q}" |4 q+ \0 W- p: ~7 x0 v
/ _2 A9 G$ b* C8 P6 O4 w6 b# E
{# c- o' q, ?/ e7 ]
"ISBN": "987-1-4302-3051-9"," Z) J; C! q9 R: g, Y# u6 a
"Type": "Book", j/ i L$ d. f% A! E) h: B) W
"Title": "Definite Guide to MongoDB: The NoSQL Database",! Y5 j2 i1 p* l+ e+ l" e
"Publisher": "Apress",' {8 b* N4 V/ x
"Author": " Eelco Plugge",! W$ u P2 _7 M. a/ C! u3 v, \
"Releasedate": "2011.06.09"5 _ I0 I7 P- Q" g, e% l- l6 L: K
}3 {5 N8 ~6 m" l# W
+ u7 k+ f1 z" J0 S n 假如,在同一个 collection 中的所有 document,都包含某个共同的 field,例如前例中的“ISBN”,那么我们就可以按照这个 field 的值,来分割 collection。这个 field 的值,又称为 shard key。. o% o( [3 |6 I( O2 j8 A
3 f X0 t. {5 u- c' m$ x4 T
在选择shard key的时候,一定要确保这个key能够把collection均匀地切分成很多chunks。- U3 [: [* I. E
* G6 M9 i( ~* y8 |( s/ P
例如,如果我们选择“author”作为shard key,如果有大量的作者是重名的,那么就会有大量的数据聚集在同一个chunk中。当然,假设很少有作者同名同姓,那么“author”也可以作为一个shard key。换句话说,shard key 的选择,与使用场景密切相关。7 }5 b7 K$ j* r( j" d5 `5 ?
& W, k/ u* Z! W$ b6 d, }5 ^# ~( ^
很多情况下,无论选择哪一个单一的 field 作为shard key,都无法均匀分割 collection。在这种情况下,我们可以考虑,用多个 fields,构成一个复合的shard key。3 z, a8 Q( e8 ~) ^- K) W; F
) D4 }" K% F% k0 t, o+ i. O$ {
延续前例,假如有很多作者同名同姓,他们都叫“王二”。用 author 作为 shard key,显然无法均匀切割 collection。这时我们可以加上release-date,组成name-date的复合 shard key,例如“王二 2011”。
: _! K) Y" p- l+ r: F& Q' e- {; m, j. c6 H0 }. `4 S1 ~& t
Chunks
& [/ u! X6 q2 W/ k$ j V
2 n% k7 i7 h b& G* F* { MongoDB按 shard key,把 collection切割成若干 chunks。每个 chunk 的数据结构,是一个三元组,{collection,minKey,maxKey},如图1-2 所示。
7 H# g+ v; A8 C$ w0 \6 j* ^# E
5 k k- G' D% C% }
图1-2 chunk的三元组 $ l9 t' r' y5 e
# d1 ?" G7 @8 s1 B 其中,collection 是数据库中某一个表的名称,而 minKey 和 maxKey 是 shard key的范围。每一个 document 的shard key 的值,决定了这条document应该存放在哪个chunk中。
( I+ v! ^( w, s; r3 @6 h
1 A; ]2 F8 t- j3 b Q 如果两条 documents 的 shard keys 的值很接近,这两条 documents 很可能被存放在同一个 chunk 中。5 D8 p- `( C5 e' ^1 A/ P
. R9 B$ q/ p8 [" \# s
Shard key 的值的顺序,决定了 document 存放的 chunk。在 MongoDB 的文献中,这种切割 collection 的方式,称为order-preserving。& m# L w# |: `, s% ~ y
2 u# x! s/ n5 ^! R9 q, X1 s 一个 chunk最多能够存储64MB的数据。 当某个chunk存储的 documents包含的数据量,接近这个阈值时,一个chunk会被切分成两个新的chunks。
* f( Q+ g( y3 B( n
& v/ J4 r' @+ ~1 C: { 当一个shard存储了过多的chunks,这个shard中的某些chunks会被迁移到其它 shard中。. ?' V0 k$ j) F6 M" K& ?
+ [4 p# f: j' j1 F
这里有个问题,假如某一条 document 包含的数据量很大,超过 64MB,一个 chunk 存放不下,怎么办?在后续章节介绍 GridFS 时,我们会详细讨论。( c1 W' Q% N5 }- X
4 {( A" T0 H# O# o# A6 t
Replica set7 D O5 l* ]( t. X5 Y; E; a: j% J
* i+ ?3 e" M& y2 [8 \ 在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。
+ _. O) S! N8 l Y" H6 J
% [4 l4 G) \2 z 这个replica set包括一个primary DB和多个secondary DBs。为了数据的一致性,所有的修改(insert / update / deletes) 请求都交给primary处理。处理结束之后,再异步地备份到其他secondary中。4 q0 L( m# N8 c( O3 F4 I
0 K A! G$ U2 x3 O2 x( p Primary DB由replica set中的所有servers,共同选举产生。当这个primaryDB server出错的时候,可以从replica set中重新选举一个新的primaryDB,从而避免了单点故障。* m W; j5 Z. {; P5 p3 D2 N% I4 q
) l/ d8 F, q1 h Replica set的选举策略和数据同步机制,确保了系统的数据的一致性。后文详述。
% V& ^: C( }, s4 v! s+ S9 O; l5 a2 w# I
Config Server2 C0 J9 A0 M ^2 q; v3 ]6 `
0 ~; T: V1 @7 M. T& @; E Config servers用于存储MongoDB集群的元数据 metadata,这些元数据包括如下两个部分,每一个shard server包括哪些chunks,每个chunk存储了哪些 collections 的哪些 documents。
2 n/ W! K0 Q) U
' ^/ p1 F$ k3 H2 o 每一个config server都包括了MongoDB中所有chunk的信息。0 p# O- `6 j ?0 c
" `7 Q3 h8 }; l7 [ Config server也需要 replication。但是有趣的是,config server 采用了自己独特的replication模式,而没有沿用 replica set。6 f* ^) q2 ~$ s7 I
2 T1 P: a/ r+ g, Z7 K D! P 如果任何一台config server挂了,整个 config server 集群中,其它 config server变成只读状态。这样做的原因,是避免在系统不稳定的情况下,冒然对元数据做任何改动,导致在不同的 config servers 中,出现元数据不一致的情况。
( T. B1 O0 A' M6 c: R4 G' ~7 c5 L9 p0 ?
MongoDB的官方文档建议,配置3个config servers比较合适,既提供了足够的安全性,又避免了更多的config servers实例之间的数据同步,引起的元数据不一致的麻烦。
& }2 l' u* C% V. Y) V4 w
8 _; \8 d' i5 a" U* ~- M& ^Mongos' e+ j: c4 C$ V; Y* e6 \5 J
9 ` h$ v2 h2 r& y0 B- X) Z" v 用户使用MongoDB 时,用户的操作请求,全部由mongos来转发。
3 J' X# y$ q$ M. } i9 j
/ @% W2 h: n5 z4 A 当 mongos 接收到用户请求时,它先查询 config server,找到存放相应数据的shard servers。然后把用户请求,转发到这些 shard servers。当这些 shard servers完成操作后,它们把结果分别返回给 mongos。而当 mongos 汇总了所有的结果后,它把结果返回给用户。' F0 A4 p: Z- y4 i/ V6 y9 q$ L1 z
2 A) l% l; D; U- B/ D Mongos每次启动的时候,都要到config servers中读取元数据,并缓存在本地。每当 config server中的元数据有改动,它都会通知所有的mongos。
: f* J7 V D+ ^' A9 ?$ B: b0 l; g; Z7 J5 H' P8 ^
Mongos之间,不存在彼此协同工作的问题。因此,MongoDB所需要配置的mongos server的数量,没有限制。
% r7 N( p5 ~( w2 Z V- H3 |$ p! o2 e. p8 s
通过以上的介绍,我们对每个组成部分都有了基本的了解,但是涉及到工作的细节,我们尚有诸多疑问,例如,一个chunk的数据太大,如何切分?一个shard数据太多,如何迁移?在replica set中,如何选择primary?server挂了,怎么进行故障恢复?接下来的章节,我们逐个回答这些问题。" `1 v/ j- v9 p; g# d* [
. b q; n7 i' }; B
# [/ c4 V' J6 s o! d% FReference,& L2 l+ a/ ?$ v; r5 c7 n
3 c% `% ?0 p0 L[0] Architectural Overview
H5 ]9 a2 t0 \/ Whttp://www.mongodb.org/display/DOCS/Sharding+Introduction! `& F" B, c! v) ]
|
评分
-
查看全部评分
|