|
|
关于MongoDB,我们能看到的资料,基本都是在指导大家如何使用MongoDB,但是,MongoDB内部是如何运作的,资料不是很多。* A( {/ F7 H) k; D
5 x* `' H* V) x3 Z
阅读使用手册,会有很多疑惑之处。例如,有人说,MongoDB 等同于分布式的 MySQL。它把一个Table ,按 row,分割成多个Shards,分别存放在不同的 Servers 上。这种说法是否正确?$ O& S) h R3 o, j7 t& K* n
, O7 w1 ?3 q# f4 W
不深入了解 MongoDB 的内部结构,就无法透彻地回答类似问题。这个系列文章,就来和大家探讨MongoDB的内部的工作方式。4 G6 m! I3 B: {. g0 R
# o! R: h z0 u& t2 v
' U) q) C z& o$ j# V4 ~! V* B
* y+ @; G h0 i6 ^& A- i
图1-1 MongoDB架构图
$ o# M' {' y* A' R) X3 N/ S
9 |; R z' C! b p MongoDB 通常运行在一个服务器集群上,而不是一个单机。图1-1,描述了一个MongoDB集群的基本组成部分,包括若干shards,至少一个config server,至少一个routing servers(又称 mongos)。
2 s7 E, G& |- l$ ?6 D0 ^' F
: m2 f$ h9 h$ ]6 g2 a5 C( zShards1 O3 H3 M: f: J8 S
! b0 u# M' {: V
MongoDB的最基本的数据单元,叫document,类似于关系式数据库中的行 row。一系列documents,组成了一个collection,相当于关系式数据库中的table。当一个 collection 数据量太大时,可以把该collection按documents切分,分成多个数据块,每个数据块叫做一个chunk,多个chunks聚集在一起,组成了一个shard。
& H+ I/ t' C+ g( _* |6 N
0 ], X* g; q: B! U% }: B Sharding 的意义,不仅保障了数据库的扩容(scalability),同时也保障了系统的负载均衡(load balance)。
( n- n; I( b6 d+ b0 T$ x2 {5 h+ O$ G: L! ^. H/ X" f! Q
每一个shard存储在一个物理服务器(server)上。Server上运行着mongod进程,通过这个进程,对shard中的数据进行操作,主要是增删改查。- W2 q& m' t3 h& g0 x* S
& r- p9 w$ R/ E* \ 如果系统中的每个shard,只存储了一份数据,没有备份,那么当这个shard所在的server挂了,数据就丢失了。在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。- U3 d- [; {5 W2 G% G% |4 _) r" D
8 n; H1 Y" a3 U( Z% e, C
Shard keys
% ~3 U7 M! r$ J! ]8 O. r$ L @* M8 Y1 p; M2 P
为了把collection切分成不同的chunks,从而存放到不同的shards中,我们需要制定一个切分的方式。5 s0 W' c3 ~. |; o
8 W( C( \. W) g* i2 s" @3 B( C3 f 如前所述,在 MongoDB 数据库中,一个表collection由多个行 documents 组成,而每个 document,有多个属性 fields。同一个 collection 中的不同的 documents,可能会有不同的 fields。例如,有个 collection 叫 Media,包含两条 documents,2 Y0 R" ]$ \# T+ O7 T
1 S v& G. D3 @6 i0 q4 ]2 |2 m{( M# t4 E: u; l! ~& C
"ISBN": "987-30-3652-5130-82",/ q& f2 W* M$ t1 V# h
"Type": "CD",$ J- M( e. z: G0 _" b7 a+ v
"Author": "Nirvana"," o9 `: m( \; P2 h
"Title": "Nevermind",! S3 X8 @% ?% H
"Genre": "Grunge",
% s% u" _2 C8 B+ U "Releasedate": "1991.09.24",
! E7 j- m( G( n "Tracklist": [7 |) t& p0 t" O- g- \
{* z: x# g5 r, ^" V& f0 K
"Track" : "1",
9 N) s- |. M$ u# y* } "Title" : "Smells like teen spirit",
& C f9 S* ]4 g, X7 R; i "Length" : "5:02"
; ~0 X( w7 u* \' ? },
) Y& P& g2 ]- U* m# _) N {
6 Z9 i; T; {! U' z" \6 P+ s "Track" : "2",9 N ?( @3 I: s; U$ |2 @
"Title" : "In Bloom",% Q5 T x+ R! Z% x% [' s, @
"Length" : "4:15"
1 [1 I$ r% h, k. g }; k/ t. K' _1 Z/ W# m
]
8 a2 |7 r. N: h% @& z9 b}
' C* w3 |8 l) H* K( @/ j1 |( F& D
{
) h) n* ?! p! n9 U "ISBN": "987-1-4302-3051-9",
1 J, O9 b5 J4 {5 H "Type": "Book",9 W) c! T7 G- ?
"Title": "Definite Guide to MongoDB: The NoSQL Database",) {5 M& }6 x% w3 \' b2 P& O( Y
"Publisher": "Apress",. X$ V8 O5 w2 M5 S& g, x# l
"Author": " Eelco Plugge",
( q ]/ h' Y9 v3 K "Releasedate": "2011.06.09"/ _# o+ y. W; o
}( G* \8 J, e+ T2 Y$ U2 x. x
]* o R. `+ H9 J* I 假如,在同一个 collection 中的所有 document,都包含某个共同的 field,例如前例中的“ISBN”,那么我们就可以按照这个 field 的值,来分割 collection。这个 field 的值,又称为 shard key。
: w! Y+ I `9 z, S2 v
' o9 h. ]6 }5 n! ]# t& x 在选择shard key的时候,一定要确保这个key能够把collection均匀地切分成很多chunks。; U& U) n6 I3 U0 ^# `
1 C. n8 ^9 o7 i8 }1 ~" n2 b0 t 例如,如果我们选择“author”作为shard key,如果有大量的作者是重名的,那么就会有大量的数据聚集在同一个chunk中。当然,假设很少有作者同名同姓,那么“author”也可以作为一个shard key。换句话说,shard key 的选择,与使用场景密切相关。0 k4 L" R; M, B O% |8 L- o
/ l' y( T I9 ?* U. z% E
很多情况下,无论选择哪一个单一的 field 作为shard key,都无法均匀分割 collection。在这种情况下,我们可以考虑,用多个 fields,构成一个复合的shard key。9 |+ p2 U5 e: Y6 E2 d
0 r/ W1 l! z5 @) ` 延续前例,假如有很多作者同名同姓,他们都叫“王二”。用 author 作为 shard key,显然无法均匀切割 collection。这时我们可以加上release-date,组成name-date的复合 shard key,例如“王二 2011”。
6 T: s0 [5 v3 [; t* D+ C: A$ {4 ?$ L, C0 a% m' ^; E
Chunks
" C8 L. O4 p; {4 y% L, N
( Y, z; d( \; M$ [* v MongoDB按 shard key,把 collection切割成若干 chunks。每个 chunk 的数据结构,是一个三元组,{collection,minKey,maxKey},如图1-2 所示。5 P/ [! H! Z8 p. C, E
5 _( Q& B- x! u
2 `, T* c( n4 v7 C
图1-2 chunk的三元组
( _4 j1 P7 `$ s4 m1 M
* ?) B$ d8 r* _1 E 其中,collection 是数据库中某一个表的名称,而 minKey 和 maxKey 是 shard key的范围。每一个 document 的shard key 的值,决定了这条document应该存放在哪个chunk中。( k: d0 R7 _4 y0 A$ y
4 ]( T( D* U% z% j0 ` 如果两条 documents 的 shard keys 的值很接近,这两条 documents 很可能被存放在同一个 chunk 中。 B6 M! F2 ~) f
- G: A& n4 [" @* \1 q1 B+ W# V& g4 P
Shard key 的值的顺序,决定了 document 存放的 chunk。在 MongoDB 的文献中,这种切割 collection 的方式,称为order-preserving。) A' v2 o2 `6 f: r0 [
2 A4 t* x6 Y q3 a% w
一个 chunk最多能够存储64MB的数据。 当某个chunk存储的 documents包含的数据量,接近这个阈值时,一个chunk会被切分成两个新的chunks。; ?1 B3 A; h8 ` r1 l( ~
. ?* n5 r% t3 G( h) C$ W) G7 O; a
当一个shard存储了过多的chunks,这个shard中的某些chunks会被迁移到其它 shard中。
5 q/ ~" C6 }4 s2 R/ g, @ h0 I/ t* o: Q" ?& m
这里有个问题,假如某一条 document 包含的数据量很大,超过 64MB,一个 chunk 存放不下,怎么办?在后续章节介绍 GridFS 时,我们会详细讨论。
* |' V) f" R5 ]: {( g! L$ d7 H% d# D1 Y3 P+ b1 e
Replica set4 } z( A2 J/ G% K5 a/ i, R
& L7 t; i$ R! Q$ B- I5 w' d3 ~! F 在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。/ Y; @+ b1 A; F& n; o( s# ^
0 L1 G# j8 {! @& p! ~ 这个replica set包括一个primary DB和多个secondary DBs。为了数据的一致性,所有的修改(insert / update / deletes) 请求都交给primary处理。处理结束之后,再异步地备份到其他secondary中。
+ R2 X' [2 J4 k, _" [( k/ M+ B& i$ O5 B8 o9 z6 v
Primary DB由replica set中的所有servers,共同选举产生。当这个primaryDB server出错的时候,可以从replica set中重新选举一个新的primaryDB,从而避免了单点故障。
; E" M" V# D+ c: i# |/ n0 K. M% v
, {9 m+ J7 f* `% }" s* I) M Replica set的选举策略和数据同步机制,确保了系统的数据的一致性。后文详述。: n0 S7 y, o! {6 u2 |1 h, l$ _
' V# g& q; ~8 ?1 m' r6 }Config Server+ E# Q- b" r: ~
9 Z& g1 |/ O5 A Config servers用于存储MongoDB集群的元数据 metadata,这些元数据包括如下两个部分,每一个shard server包括哪些chunks,每个chunk存储了哪些 collections 的哪些 documents。1 ~. [) o. j3 b" N" v: p" M
& j. J& @, w- |# ]
每一个config server都包括了MongoDB中所有chunk的信息。4 X) ]5 v9 I! }# q( h; V5 O8 _
# P3 ~* \; U/ a+ {9 r3 i' H+ Y
Config server也需要 replication。但是有趣的是,config server 采用了自己独特的replication模式,而没有沿用 replica set。
/ |6 V [6 H: B. N# T8 u
8 P6 b! b' R \7 K 如果任何一台config server挂了,整个 config server 集群中,其它 config server变成只读状态。这样做的原因,是避免在系统不稳定的情况下,冒然对元数据做任何改动,导致在不同的 config servers 中,出现元数据不一致的情况。
" k* d) e1 ~- v( E+ T6 _! T, w# i' R( ~$ X; N
MongoDB的官方文档建议,配置3个config servers比较合适,既提供了足够的安全性,又避免了更多的config servers实例之间的数据同步,引起的元数据不一致的麻烦。
$ g: |1 f) k x9 o* U
# f/ X' y2 U4 _8 j5 \Mongos
5 G2 k! h* I& u( P
- N. H3 }3 } b 用户使用MongoDB 时,用户的操作请求,全部由mongos来转发。
: ~6 f1 O) }0 R9 N8 u* A4 h2 O6 j8 E6 N/ j+ w
当 mongos 接收到用户请求时,它先查询 config server,找到存放相应数据的shard servers。然后把用户请求,转发到这些 shard servers。当这些 shard servers完成操作后,它们把结果分别返回给 mongos。而当 mongos 汇总了所有的结果后,它把结果返回给用户。, l4 S' A- J' C5 @6 G# i
: C: r7 }. _, |9 c7 O
Mongos每次启动的时候,都要到config servers中读取元数据,并缓存在本地。每当 config server中的元数据有改动,它都会通知所有的mongos。
2 L- H! @# C( y0 Q: ^4 N" }6 O! K% [8 P. _5 G
Mongos之间,不存在彼此协同工作的问题。因此,MongoDB所需要配置的mongos server的数量,没有限制。& D7 n% K) d2 r8 w1 v
+ V8 c' | t; A7 X2 ]# s
通过以上的介绍,我们对每个组成部分都有了基本的了解,但是涉及到工作的细节,我们尚有诸多疑问,例如,一个chunk的数据太大,如何切分?一个shard数据太多,如何迁移?在replica set中,如何选择primary?server挂了,怎么进行故障恢复?接下来的章节,我们逐个回答这些问题。8 O2 |1 ~% o; H' c6 R2 ^
# R: _4 P9 t% |4 e# ]3 s; G+ W( G/ u, j) q7 m- P$ U" Z+ e2 d
Reference,4 V- C, h; B4 ~; I4 j8 [+ l x
; M1 X8 R$ K. S) e$ Z1 C- m
[0] Architectural Overview
0 m# J, P5 E9 k) o, U- {http://www.mongodb.org/display/DOCS/Sharding+Introduction
! ^% x; E) z& e% T |
评分
-
查看全部评分
|