|
关于MongoDB,我们能看到的资料,基本都是在指导大家如何使用MongoDB,但是,MongoDB内部是如何运作的,资料不是很多。
! D [& H! z+ x& `% F+ Z- ^# W# }; T3 k" G; q+ T
阅读使用手册,会有很多疑惑之处。例如,有人说,MongoDB 等同于分布式的 MySQL。它把一个Table ,按 row,分割成多个Shards,分别存放在不同的 Servers 上。这种说法是否正确?. I* ^3 G2 J# J% B( M/ s
, f$ r' O! i8 U- h
不深入了解 MongoDB 的内部结构,就无法透彻地回答类似问题。这个系列文章,就来和大家探讨MongoDB的内部的工作方式。+ M+ N) \% H T9 u( c- I. x
6 B* b8 o8 ]0 g& s
+ {" C" `1 Q, J& Z
- T1 N! V/ E2 A( @" v
图1-1 MongoDB架构图
: ]; r6 q3 E/ v Q. o7 `" Z, p
) V" a# F* C- C1 w8 k( D MongoDB 通常运行在一个服务器集群上,而不是一个单机。图1-1,描述了一个MongoDB集群的基本组成部分,包括若干shards,至少一个config server,至少一个routing servers(又称 mongos)。$ W# J/ N, W, e0 \! S1 Y6 Q
8 ~! W; O9 u* [3 n
Shards/ }; ^: E& f6 l
6 j$ e$ t2 r8 w! E+ f7 S. P
MongoDB的最基本的数据单元,叫document,类似于关系式数据库中的行 row。一系列documents,组成了一个collection,相当于关系式数据库中的table。当一个 collection 数据量太大时,可以把该collection按documents切分,分成多个数据块,每个数据块叫做一个chunk,多个chunks聚集在一起,组成了一个shard。
6 w! {. N: m( K) ]+ \$ V8 ^; d4 @/ L5 ~9 _
Sharding 的意义,不仅保障了数据库的扩容(scalability),同时也保障了系统的负载均衡(load balance)。
0 R0 q% H3 c9 Q7 X$ m+ b# _! Q5 E6 N
每一个shard存储在一个物理服务器(server)上。Server上运行着mongod进程,通过这个进程,对shard中的数据进行操作,主要是增删改查。
- n' U/ ~' n" d1 x6 K' Q. E, d4 d4 Z" A0 W& J' S
如果系统中的每个shard,只存储了一份数据,没有备份,那么当这个shard所在的server挂了,数据就丢失了。在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。+ a& ?' Y$ u5 M2 {2 O. H: t
3 k4 h3 ^9 [6 B8 S: U4 j
Shard keys
. ^% ] @; s1 ]3 ^! s: w' v# ^' ~
+ l1 W$ \6 e$ z. H 为了把collection切分成不同的chunks,从而存放到不同的shards中,我们需要制定一个切分的方式。' w4 E( |# L* ]: l# P5 X
+ o/ P2 K9 E. I' U K8 K$ J# b% Z) ] 如前所述,在 MongoDB 数据库中,一个表collection由多个行 documents 组成,而每个 document,有多个属性 fields。同一个 collection 中的不同的 documents,可能会有不同的 fields。例如,有个 collection 叫 Media,包含两条 documents,
- u, c" ]% l8 g+ R {( N2 A: G! F+ O' h' j
{
4 P: [! ^1 v1 l2 ^: d9 V7 u "ISBN": "987-30-3652-5130-82",
+ C: l9 a, C. S, ?6 {6 X "Type": "CD",, ]! V; D; G# ~ T0 ~
"Author": "Nirvana",
0 P* b' B+ [- E4 Y: S "Title": "Nevermind",/ ~2 ?1 |* i( B- z' p+ H' i& d
"Genre": "Grunge",2 ?0 r0 J$ E4 T9 {" v
"Releasedate": "1991.09.24",# q! |$ {- y# y$ U
"Tracklist": [
( _4 m$ F$ W$ h/ B) F4 }( s$ }, n {( X% s/ E- q; f! |
"Track" : "1",
7 F4 ^ y7 N2 b9 e! y- I "Title" : "Smells like teen spirit",/ b, y% N% a- r |! ~! q
"Length" : "5:02"
2 c+ v O- @/ M7 W" g3 M/ @/ ~ },
9 m1 ~# y) T' M& t" }4 y {
7 P5 V( a, ]6 m: @# ^* ] "Track" : "2",
. F$ K5 Q- L8 Y4 `' W* s, [! E "Title" : "In Bloom",
! C( w9 ^$ W. q* B0 U2 i, E$ K7 t "Length" : "4:15"4 o# z. F& m1 j- c0 n7 ~% h
}5 R. H4 {) w, N% ?
]; s: }7 H4 w$ H# D( y
}" n5 y: _; p8 j9 }* Q
% }3 U. J1 m" h0 Z0 m* h
{
! l: U" i" u% x4 {9 n- j "ISBN": "987-1-4302-3051-9",; U* A3 y9 i: P. u1 `: E
"Type": "Book",
! H1 y: s- h. @. U; T& P* y% v "Title": "Definite Guide to MongoDB: The NoSQL Database",
! H) u6 H# W \ X$ x! I, e "Publisher": "Apress",
7 I. G+ b* u- R3 R/ w8 ^- Q "Author": " Eelco Plugge",
?) M" T8 ^: p0 i "Releasedate": "2011.06.09"% V3 L% i- i( `! ?
}/ J1 W, ]& N& y
0 \5 j1 w7 z$ G$ U& l8 ?5 k
假如,在同一个 collection 中的所有 document,都包含某个共同的 field,例如前例中的“ISBN”,那么我们就可以按照这个 field 的值,来分割 collection。这个 field 的值,又称为 shard key。
N% q( w" n1 E! ~/ S: x6 f( u) g, O
在选择shard key的时候,一定要确保这个key能够把collection均匀地切分成很多chunks。) t- w" o2 S$ U& L3 |, \, S
! s3 p4 F- u" S9 \
例如,如果我们选择“author”作为shard key,如果有大量的作者是重名的,那么就会有大量的数据聚集在同一个chunk中。当然,假设很少有作者同名同姓,那么“author”也可以作为一个shard key。换句话说,shard key 的选择,与使用场景密切相关。
; s) j8 x1 O) ^, B& B! C
' a" k) e9 [% M/ g* b, w2 e1 H/ I" `/ h! t 很多情况下,无论选择哪一个单一的 field 作为shard key,都无法均匀分割 collection。在这种情况下,我们可以考虑,用多个 fields,构成一个复合的shard key。
" T3 b- p% p6 L) z% W" j
& e# d4 [! F) v/ m* W$ c" V' w 延续前例,假如有很多作者同名同姓,他们都叫“王二”。用 author 作为 shard key,显然无法均匀切割 collection。这时我们可以加上release-date,组成name-date的复合 shard key,例如“王二 2011”。
+ t" n& r* R4 j7 e3 k* F: A* E
Chunks
/ U+ S. M- v& Q4 H4 r2 ]
! N9 y) T2 ?4 \9 a8 @9 y MongoDB按 shard key,把 collection切割成若干 chunks。每个 chunk 的数据结构,是一个三元组,{collection,minKey,maxKey},如图1-2 所示。
! F1 W# n+ v e& C# F! p! M: D5 D1 Q/ c; X- t
, k+ {8 w' K- U/ j: L6 ~9 T图1-2 chunk的三元组 7 T5 H% b; S$ Z% X# D
: o/ J0 }2 V w, G
其中,collection 是数据库中某一个表的名称,而 minKey 和 maxKey 是 shard key的范围。每一个 document 的shard key 的值,决定了这条document应该存放在哪个chunk中。! D) K* f/ y2 @, I/ D3 d1 R1 S
3 _$ F2 d n* w
如果两条 documents 的 shard keys 的值很接近,这两条 documents 很可能被存放在同一个 chunk 中。7 Y3 _0 W9 p$ R; d* l3 A, |& L" u) Z
5 [4 ?( {5 e8 m" F) A& h$ ~
Shard key 的值的顺序,决定了 document 存放的 chunk。在 MongoDB 的文献中,这种切割 collection 的方式,称为order-preserving。
6 ~ \# P8 k4 y* h$ l9 G" |& [( G9 ~; y w! [* B0 f! Q
一个 chunk最多能够存储64MB的数据。 当某个chunk存储的 documents包含的数据量,接近这个阈值时,一个chunk会被切分成两个新的chunks。
+ z& Q5 S" K' L. }7 t& e' b& k
. k1 U7 D1 }3 Z, z3 X* u: U# I- Z2 O& ? 当一个shard存储了过多的chunks,这个shard中的某些chunks会被迁移到其它 shard中。
9 m7 P- X' U% X: }3 E7 p
7 i/ @0 J- a. z0 i, x 这里有个问题,假如某一条 document 包含的数据量很大,超过 64MB,一个 chunk 存放不下,怎么办?在后续章节介绍 GridFS 时,我们会详细讨论。
& A9 H" m2 e( R& ~8 ^0 W- I) w; J; B% O/ z8 _6 H0 r
Replica set* g. e0 R& Y$ i+ b
' v' g0 A' O5 u1 \
在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。1 _% `# d5 r* |" v
+ ~% x0 X/ l' H0 y 这个replica set包括一个primary DB和多个secondary DBs。为了数据的一致性,所有的修改(insert / update / deletes) 请求都交给primary处理。处理结束之后,再异步地备份到其他secondary中。
& _2 ^- c/ _- [, J. f# P# m( H2 P
5 P3 y) q6 K+ F7 z5 q Primary DB由replica set中的所有servers,共同选举产生。当这个primaryDB server出错的时候,可以从replica set中重新选举一个新的primaryDB,从而避免了单点故障。3 Z( F5 K, h. N' W1 i/ V) `/ ~+ n9 ]; E
6 ?2 T9 J* N% B/ r' a/ o Replica set的选举策略和数据同步机制,确保了系统的数据的一致性。后文详述。
% U# T( a% z+ i
# ?/ I& n- B9 v4 q$ w; gConfig Server, g& w1 S2 s! a3 P, r: t$ B
* k9 d# M% w q1 A& e' ?9 i) a" i! j
Config servers用于存储MongoDB集群的元数据 metadata,这些元数据包括如下两个部分,每一个shard server包括哪些chunks,每个chunk存储了哪些 collections 的哪些 documents。5 Z# Y- C$ N0 Z( J8 @; L" d- m
) u* V. e& ?( K- G: G, N+ t/ s, o9 M 每一个config server都包括了MongoDB中所有chunk的信息。
* K. X$ O8 n p" S- o H% c* e( B# R
^6 T( v' n3 d/ y$ R9 r Config server也需要 replication。但是有趣的是,config server 采用了自己独特的replication模式,而没有沿用 replica set。9 r' i! {1 L/ e( N5 }: X
7 Y9 d% ]1 J1 O `" h o
如果任何一台config server挂了,整个 config server 集群中,其它 config server变成只读状态。这样做的原因,是避免在系统不稳定的情况下,冒然对元数据做任何改动,导致在不同的 config servers 中,出现元数据不一致的情况。
2 U8 m+ o. m4 o3 z' `# t) Z# r
) e' `2 g Q1 h2 k. m A MongoDB的官方文档建议,配置3个config servers比较合适,既提供了足够的安全性,又避免了更多的config servers实例之间的数据同步,引起的元数据不一致的麻烦。. F8 n. G3 @ \% f: w
3 @$ e9 a( J0 o. f+ e7 ~, t
Mongos
. o8 Y8 r) S+ x) w& v
/ G4 K, y4 ?7 N+ R- X8 \ 用户使用MongoDB 时,用户的操作请求,全部由mongos来转发。* E# R8 h" o* Y% m9 L
! _& V1 w% |; D+ d% X 当 mongos 接收到用户请求时,它先查询 config server,找到存放相应数据的shard servers。然后把用户请求,转发到这些 shard servers。当这些 shard servers完成操作后,它们把结果分别返回给 mongos。而当 mongos 汇总了所有的结果后,它把结果返回给用户。
3 n# {3 l' K) ^* B- U# H) G0 X( \2 j2 }% F% b
Mongos每次启动的时候,都要到config servers中读取元数据,并缓存在本地。每当 config server中的元数据有改动,它都会通知所有的mongos。
. T2 X. r7 c; I$ A W6 I. ~! t; p( Z9 u9 Q% @6 x" ?
Mongos之间,不存在彼此协同工作的问题。因此,MongoDB所需要配置的mongos server的数量,没有限制。
0 ^& q Z1 z( L- M& Y
6 S3 b4 \3 U0 f' U; I2 p! \# P V, Z 通过以上的介绍,我们对每个组成部分都有了基本的了解,但是涉及到工作的细节,我们尚有诸多疑问,例如,一个chunk的数据太大,如何切分?一个shard数据太多,如何迁移?在replica set中,如何选择primary?server挂了,怎么进行故障恢复?接下来的章节,我们逐个回答这些问题。
* }% _% ^/ x* U/ e: m& G) s; U3 G% T/ v# R3 q/ |( ^
! F5 Q( _- R" u9 V2 q; v: r% F
Reference,
: i$ ^: F0 _7 A. Q' \9 O; {1 ~1 {5 g' }+ O+ ?; v
[0] Architectural Overview! ]9 O( \9 i+ Q3 @2 ]
http://www.mongodb.org/display/DOCS/Sharding+Introduction0 e- k0 ?7 E4 T% I
|
评分
-
查看全部评分
|