|
|
关于MongoDB,我们能看到的资料,基本都是在指导大家如何使用MongoDB,但是,MongoDB内部是如何运作的,资料不是很多。
7 q( ], l' O$ m+ |- l+ E2 q! c, a
阅读使用手册,会有很多疑惑之处。例如,有人说,MongoDB 等同于分布式的 MySQL。它把一个Table ,按 row,分割成多个Shards,分别存放在不同的 Servers 上。这种说法是否正确? [' e( A& e; d0 V- {( l: q3 _% V
2 d) N2 ~! f& s8 j! m0 h# a0 {
不深入了解 MongoDB 的内部结构,就无法透彻地回答类似问题。这个系列文章,就来和大家探讨MongoDB的内部的工作方式。5 H$ M+ L# w6 [) C9 N" y! v6 B" q+ v
, j7 M# L" x( \" h4 n# z* v
c# m' S- m% s+ W- w7 E
! w5 Q. m/ ~8 T: r+ }6 K' z/ F6 }0 k# W% A
图1-1 MongoDB架构图 2 C. t3 a& H4 p2 ?& b Y0 U* T) ?
8 N" o8 q# G2 G0 n2 g4 f
MongoDB 通常运行在一个服务器集群上,而不是一个单机。图1-1,描述了一个MongoDB集群的基本组成部分,包括若干shards,至少一个config server,至少一个routing servers(又称 mongos)。
x8 T7 V; A2 }$ [7 ]+ L3 Z1 ~9 i, T; x: t9 y3 V: B
Shards
3 R- I- }! _8 \4 L0 ^2 U4 E7 P- u$ C5 q* V: |3 k
MongoDB的最基本的数据单元,叫document,类似于关系式数据库中的行 row。一系列documents,组成了一个collection,相当于关系式数据库中的table。当一个 collection 数据量太大时,可以把该collection按documents切分,分成多个数据块,每个数据块叫做一个chunk,多个chunks聚集在一起,组成了一个shard。+ S6 F# f# x( n& S$ b
7 Z# g" B5 n3 V. w( o U3 @' \. H Sharding 的意义,不仅保障了数据库的扩容(scalability),同时也保障了系统的负载均衡(load balance)。
) y! _; f# j) a8 I- V) Z' s1 T# [$ S6 |
) y' d# }7 s f. V' U 每一个shard存储在一个物理服务器(server)上。Server上运行着mongod进程,通过这个进程,对shard中的数据进行操作,主要是增删改查。2 Z( W0 _' p0 n) r1 c u
6 Y6 ^$ N( x' d Z6 Y 如果系统中的每个shard,只存储了一份数据,没有备份,那么当这个shard所在的server挂了,数据就丢失了。在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。
+ w: n, }/ t. E5 r9 a: r1 k4 P/ H
2 P1 q2 ~* Y8 Z. aShard keys
6 ?- A; g: A) F. C, u, e
6 I. e9 z, b0 X5 E. t 为了把collection切分成不同的chunks,从而存放到不同的shards中,我们需要制定一个切分的方式。
! ^" X' K' x K8 k6 h W# S" A |) ~- M
如前所述,在 MongoDB 数据库中,一个表collection由多个行 documents 组成,而每个 document,有多个属性 fields。同一个 collection 中的不同的 documents,可能会有不同的 fields。例如,有个 collection 叫 Media,包含两条 documents,
- A7 O z: q+ c- I" ~1 a
5 ]# @2 D) B- Z" q- e, X* k{7 [0 t# E- h! }0 A
"ISBN": "987-30-3652-5130-82",% T; w; T# ~0 k+ _3 _ I
"Type": "CD",
+ N6 v: _) [/ N3 v( H5 o x' t( [ "Author": "Nirvana",
9 t2 W' q# C; Q8 f2 ]/ E& m; f; X "Title": "Nevermind",! h: n/ f0 R3 Q( V: V2 w
"Genre": "Grunge",9 a/ b1 E1 N& M0 g F
"Releasedate": "1991.09.24",
1 H7 K% N, [+ C "Tracklist": [ D4 n! N" a! R
{, `& I* `/ P- ^
"Track" : "1",; \# U! H8 v/ C0 [' e
"Title" : "Smells like teen spirit",( \& t+ \+ I' K& ?8 X
"Length" : "5:02"
5 h) v( c) W5 T; F4 g6 Z! L },2 x9 Q# ~* G! j+ |# m
{( ~$ J( _! N9 I3 }9 A8 }$ i
"Track" : "2",9 o) d; F$ C& ?' y
"Title" : "In Bloom",
+ o* Y; a6 `+ a; t( n4 C "Length" : "4:15"$ H. P8 s( J/ r( s; W) N0 {
}
: Y/ _5 H* F# T/ h. D/ X+ y ]$ Z( T7 } B& ?7 s- Q, Y
}
6 `+ x0 \9 H e2 S' [, j, g4 y0 ~( q F9 t
{3 _& `+ M) _) G4 R& B
"ISBN": "987-1-4302-3051-9",
) w. L- Q7 g9 z/ G/ k0 \8 C2 l "Type": "Book",
' ^6 E% J' s# I& M+ X "Title": "Definite Guide to MongoDB: The NoSQL Database",. p/ u' W( ?* h9 ~9 N6 Z# D3 Z
"Publisher": "Apress",
& f5 L8 v. y* y) j$ s& |0 r "Author": " Eelco Plugge",
$ a' f# _5 Y( l2 K! [! ?% e6 p i" R "Releasedate": "2011.06.09"
7 `) S6 D* Z1 L, Z7 S; w) t}' Y4 G7 g% N& G4 Q
3 n6 C% Y+ F( K3 Q! Z
假如,在同一个 collection 中的所有 document,都包含某个共同的 field,例如前例中的“ISBN”,那么我们就可以按照这个 field 的值,来分割 collection。这个 field 的值,又称为 shard key。6 ]% y- _7 Z- p( u- `4 C. S8 V5 ]
2 ~8 P- Z6 B! H! E 在选择shard key的时候,一定要确保这个key能够把collection均匀地切分成很多chunks。" Q5 o/ R3 i! T7 a3 S9 P
4 V j1 l |( Z% l/ C- k! m
例如,如果我们选择“author”作为shard key,如果有大量的作者是重名的,那么就会有大量的数据聚集在同一个chunk中。当然,假设很少有作者同名同姓,那么“author”也可以作为一个shard key。换句话说,shard key 的选择,与使用场景密切相关。
1 q$ s b0 Y- l/ o* \; Q+ H( b) V7 k+ I# B& K
很多情况下,无论选择哪一个单一的 field 作为shard key,都无法均匀分割 collection。在这种情况下,我们可以考虑,用多个 fields,构成一个复合的shard key。6 ~# z0 I% ^; O! u2 B
: E: o# l4 @8 R- s' G
延续前例,假如有很多作者同名同姓,他们都叫“王二”。用 author 作为 shard key,显然无法均匀切割 collection。这时我们可以加上release-date,组成name-date的复合 shard key,例如“王二 2011”。/ Q6 A! M9 p1 |. i& l
4 s& b" V* a& u
Chunks
l+ e- v2 M3 \* @- ^$ x$ f( N : Y1 `. ~3 {7 t) i% ~. L
MongoDB按 shard key,把 collection切割成若干 chunks。每个 chunk 的数据结构,是一个三元组,{collection,minKey,maxKey},如图1-2 所示。& ~& Y/ @6 t. E: s# Z: `
7 p7 v6 R$ x( q& j0 V( L$ D; B
7 _3 a1 l# Z5 I; X
图1-2 chunk的三元组
$ ]9 w# s7 T2 N8 x) ]1 ]9 ^# E6 ^8 r# g8 Y# a7 S) ]/ G6 s
其中,collection 是数据库中某一个表的名称,而 minKey 和 maxKey 是 shard key的范围。每一个 document 的shard key 的值,决定了这条document应该存放在哪个chunk中。
( k9 T& }, j6 n) J% |7 e4 f) a+ V: _7 F& M" i$ N* a
如果两条 documents 的 shard keys 的值很接近,这两条 documents 很可能被存放在同一个 chunk 中。+ W. r ?( c" P& l5 Y. C) h; ~$ S! f
5 Y4 K' d2 c j7 J Shard key 的值的顺序,决定了 document 存放的 chunk。在 MongoDB 的文献中,这种切割 collection 的方式,称为order-preserving。
7 H: u9 ^, s' p, h, c& \" o, r9 }, ]1 S% t% d
一个 chunk最多能够存储64MB的数据。 当某个chunk存储的 documents包含的数据量,接近这个阈值时,一个chunk会被切分成两个新的chunks。
9 K& |9 k3 c4 v( ^6 ~2 P6 x
2 ]5 B; _6 |1 t8 M* R# W# T 当一个shard存储了过多的chunks,这个shard中的某些chunks会被迁移到其它 shard中。
: U5 d% ~9 J2 w+ J1 h2 a; l V2 b0 j/ L* v' M
这里有个问题,假如某一条 document 包含的数据量很大,超过 64MB,一个 chunk 存放不下,怎么办?在后续章节介绍 GridFS 时,我们会详细讨论。* }9 {3 i1 T, z. ]& Z* e
; m2 I) e. |0 N: n
Replica set
% k. s" P4 e/ W3 L& V2 O 8 L7 M# |3 D$ m5 Q
在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。& R9 T# s" a' S8 M& X3 V' T
l: }3 c: e$ {- `! A1 p
这个replica set包括一个primary DB和多个secondary DBs。为了数据的一致性,所有的修改(insert / update / deletes) 请求都交给primary处理。处理结束之后,再异步地备份到其他secondary中。! j; M* a( i' g0 t" x: o. ~6 V
/ @# Z+ V% z2 q5 c5 S6 g; B" T$ r
Primary DB由replica set中的所有servers,共同选举产生。当这个primaryDB server出错的时候,可以从replica set中重新选举一个新的primaryDB,从而避免了单点故障。6 F! T4 P" _6 q- `. k
& l% ^! E* \! W; @5 J Replica set的选举策略和数据同步机制,确保了系统的数据的一致性。后文详述。
3 y# F, M# u- I( M* ^( f
# f2 x/ j) j3 P" h0 RConfig Server
: E; `6 i0 O9 y2 @. @7 ?3 n$ B- I
4 w8 U3 [0 X2 l1 ? Config servers用于存储MongoDB集群的元数据 metadata,这些元数据包括如下两个部分,每一个shard server包括哪些chunks,每个chunk存储了哪些 collections 的哪些 documents。$ C# @+ k' X5 ^% k
+ ]5 @$ W( [1 g/ e3 B+ }7 z 每一个config server都包括了MongoDB中所有chunk的信息。7 ]' ]7 a5 `2 [& n |% ~" F
; c$ Z4 n: Y+ ^; `" D Config server也需要 replication。但是有趣的是,config server 采用了自己独特的replication模式,而没有沿用 replica set。
* x8 G3 J- H6 l' M3 p7 X9 Q
( w$ w$ @' a) ` 如果任何一台config server挂了,整个 config server 集群中,其它 config server变成只读状态。这样做的原因,是避免在系统不稳定的情况下,冒然对元数据做任何改动,导致在不同的 config servers 中,出现元数据不一致的情况。
5 ^: c8 a4 Y: H& G7 Q" c
4 K. W$ ?* e& B, X$ {- W* h! r MongoDB的官方文档建议,配置3个config servers比较合适,既提供了足够的安全性,又避免了更多的config servers实例之间的数据同步,引起的元数据不一致的麻烦。; y$ P+ f7 Y2 Z& z
7 o7 ?/ q* m* B- Q% EMongos
. c; Q" ?! Z5 q6 e$ v2 ^2 o/ s1 z8 S! K9 G' k6 x5 a' l
用户使用MongoDB 时,用户的操作请求,全部由mongos来转发。6 \9 e( A1 [7 ]) ^
2 o/ Y& \& y+ r% N
当 mongos 接收到用户请求时,它先查询 config server,找到存放相应数据的shard servers。然后把用户请求,转发到这些 shard servers。当这些 shard servers完成操作后,它们把结果分别返回给 mongos。而当 mongos 汇总了所有的结果后,它把结果返回给用户。" M ]5 C! C+ r6 `
, D* C) U0 d9 h( C' ] ]# f
Mongos每次启动的时候,都要到config servers中读取元数据,并缓存在本地。每当 config server中的元数据有改动,它都会通知所有的mongos。
8 K* g! [( b/ L& F4 E
9 K. @4 h( z3 D5 U Mongos之间,不存在彼此协同工作的问题。因此,MongoDB所需要配置的mongos server的数量,没有限制。
0 C3 @; S2 [% D4 L2 I
- Z7 U- V0 t/ g1 A 通过以上的介绍,我们对每个组成部分都有了基本的了解,但是涉及到工作的细节,我们尚有诸多疑问,例如,一个chunk的数据太大,如何切分?一个shard数据太多,如何迁移?在replica set中,如何选择primary?server挂了,怎么进行故障恢复?接下来的章节,我们逐个回答这些问题。
$ b8 T! ]9 d1 L
! C j; M- S2 X L) i3 B F' ?7 p6 ^- p5 m
Reference,0 V! _/ C& w+ ~$ m2 Z
( _+ o$ W3 E n% P
[0] Architectural Overview
9 `* u) `, f! e0 T& B# Fhttp://www.mongodb.org/display/DOCS/Sharding+Introduction, c E, r: Z( b( n
|
评分
-
查看全部评分
|