|
|
关于MongoDB,我们能看到的资料,基本都是在指导大家如何使用MongoDB,但是,MongoDB内部是如何运作的,资料不是很多。! {9 Q( V0 o8 z: _! [! @
& C7 d7 Q$ \" I3 T4 T; { 阅读使用手册,会有很多疑惑之处。例如,有人说,MongoDB 等同于分布式的 MySQL。它把一个Table ,按 row,分割成多个Shards,分别存放在不同的 Servers 上。这种说法是否正确?
}* F# K7 ]% X4 ?4 Z6 v& b5 c" V: n1 U; d% e, Y, r# f0 y
不深入了解 MongoDB 的内部结构,就无法透彻地回答类似问题。这个系列文章,就来和大家探讨MongoDB的内部的工作方式。& z% m4 \! N4 M C$ J; q n
- L0 t+ ?. B) ?9 p1 R
( S6 {0 m: B7 m; w" Y8 T! W1 z
$ U% m' y) ]: {. \0 V
图1-1 MongoDB架构图 # n$ e6 [1 s: |) w( o
5 S' n, E8 L u( @2 e/ S& N0 @. v9 I
MongoDB 通常运行在一个服务器集群上,而不是一个单机。图1-1,描述了一个MongoDB集群的基本组成部分,包括若干shards,至少一个config server,至少一个routing servers(又称 mongos)。; x; U* K3 m+ n* o1 w
% \9 U! e! K+ X2 s. O+ AShards
- X; j; b. k; j4 a: s8 }
8 }5 j4 D5 Q7 ] MongoDB的最基本的数据单元,叫document,类似于关系式数据库中的行 row。一系列documents,组成了一个collection,相当于关系式数据库中的table。当一个 collection 数据量太大时,可以把该collection按documents切分,分成多个数据块,每个数据块叫做一个chunk,多个chunks聚集在一起,组成了一个shard。
6 k3 n# B! K! @8 J% X; i& i) ^( ?- b5 e5 [; g4 l H/ ~5 _
Sharding 的意义,不仅保障了数据库的扩容(scalability),同时也保障了系统的负载均衡(load balance)。, Q( t; h" g3 l$ ~& u8 f. f A! h
. T. T' G) s' C- _8 L3 P% I
每一个shard存储在一个物理服务器(server)上。Server上运行着mongod进程,通过这个进程,对shard中的数据进行操作,主要是增删改查。
" {( `# D6 ` Y+ b. c& X2 b3 J K: S3 J
如果系统中的每个shard,只存储了一份数据,没有备份,那么当这个shard所在的server挂了,数据就丢失了。在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。
) |+ G: R) s7 B, `5 [' g2 w, U7 R5 z
Shard keys( L' N! l) m; f: X+ q8 Y6 z
}2 D% o7 t4 m
为了把collection切分成不同的chunks,从而存放到不同的shards中,我们需要制定一个切分的方式。
5 z* [) T1 v0 V# V9 g; ~* t
- D) e6 n$ p5 n; }4 y$ Z 如前所述,在 MongoDB 数据库中,一个表collection由多个行 documents 组成,而每个 document,有多个属性 fields。同一个 collection 中的不同的 documents,可能会有不同的 fields。例如,有个 collection 叫 Media,包含两条 documents,
0 y9 G, k0 y8 K
# H6 y$ q2 p4 L' f{
+ R0 K* E- p2 D* T+ J: o$ X "ISBN": "987-30-3652-5130-82",* _" }* |9 T9 ^. D
"Type": "CD",
+ A2 [, H, L1 J2 Y, } "Author": "Nirvana",
7 }3 n8 y* e' {* r "Title": "Nevermind",
/ m2 X2 ?6 g! T7 O: { "Genre": "Grunge",
; r7 K' o) E. H c1 h' ~3 R! x7 i "Releasedate": "1991.09.24",
4 V; K0 e+ ]9 ^. @4 B- j "Tracklist": [9 r$ v+ l. F- a( H$ G
{/ }0 z5 x3 Z6 q2 G
"Track" : "1",
! W1 h. C& Q; Y8 U- k+ s "Title" : "Smells like teen spirit",( b( f4 a- U; }- }* V; A
"Length" : "5:02"
: h0 B6 G6 I- T2 D( R% a },7 v% s# K& H9 U
{
& H* _3 [% l9 j0 D "Track" : "2",+ m! \: x9 K# f4 X+ i$ y& l) P" F
"Title" : "In Bloom",; @0 O+ Q; g6 Y4 g3 J0 Q5 O
"Length" : "4:15"
( Q3 ~" p4 F; Y }
$ S0 ?. Z: j2 O9 K# x! x- P% e* O ]& H% C" S [. r+ }9 q! m
}
; e) M+ L7 T0 Z/ q2 G1 w# @* H1 i
/ a3 C# ]6 n' C" x' q6 W{
& G% k: u: x6 e2 K "ISBN": "987-1-4302-3051-9",+ {6 Y% G. x0 _5 ?
"Type": "Book",
. K2 E# [( d( ^7 D3 f0 P "Title": "Definite Guide to MongoDB: The NoSQL Database",
3 n7 c3 d- m9 X5 O I0 z: | "Publisher": "Apress",
4 j- ~! ?# {1 `3 m "Author": " Eelco Plugge",$ X: e+ v- w# W$ l2 v' k/ X4 }
"Releasedate": "2011.06.09"
; S0 b# E+ U8 D$ D8 C}
5 l, E: }/ e. C a, M
1 n! c% q2 B$ e& n, l 假如,在同一个 collection 中的所有 document,都包含某个共同的 field,例如前例中的“ISBN”,那么我们就可以按照这个 field 的值,来分割 collection。这个 field 的值,又称为 shard key。
( |, P6 _/ a+ E5 H$ q$ I+ J- i8 |5 r' K$ n
在选择shard key的时候,一定要确保这个key能够把collection均匀地切分成很多chunks。
) A& m4 ~; b# w- Z; M1 q+ q5 h" Y; ` @' U2 S, U9 b) l* R- R
例如,如果我们选择“author”作为shard key,如果有大量的作者是重名的,那么就会有大量的数据聚集在同一个chunk中。当然,假设很少有作者同名同姓,那么“author”也可以作为一个shard key。换句话说,shard key 的选择,与使用场景密切相关。/ F8 c! s g E, E! v( {4 L
! v7 g3 i& e% g8 N$ x: V
很多情况下,无论选择哪一个单一的 field 作为shard key,都无法均匀分割 collection。在这种情况下,我们可以考虑,用多个 fields,构成一个复合的shard key。
8 J: G K# A' X: _
) n1 \# R: ?) x$ H6 S, W 延续前例,假如有很多作者同名同姓,他们都叫“王二”。用 author 作为 shard key,显然无法均匀切割 collection。这时我们可以加上release-date,组成name-date的复合 shard key,例如“王二 2011”。; j: e/ l. J- `0 O) }
: A3 }. d% A, Z( e1 \8 @6 u3 }0 I/ {
Chunks" c/ o. J# b0 [; \. Q# k0 c9 z; u
& k+ v/ N3 b8 y! ?' U r L- B' g MongoDB按 shard key,把 collection切割成若干 chunks。每个 chunk 的数据结构,是一个三元组,{collection,minKey,maxKey},如图1-2 所示。
4 q8 }; B7 N# c) J5 i7 h2 d4 I L! n% a+ T9 r# \" f7 N
# ~4 T6 ?' r0 D
图1-2 chunk的三元组
* g/ m1 r3 P2 X* H2 z1 V7 P( F* l6 p! F4 i6 {' @
其中,collection 是数据库中某一个表的名称,而 minKey 和 maxKey 是 shard key的范围。每一个 document 的shard key 的值,决定了这条document应该存放在哪个chunk中。# D; d7 s; V& k5 `3 C0 D
) e0 {6 W8 T2 O7 W2 X% r/ d* d
如果两条 documents 的 shard keys 的值很接近,这两条 documents 很可能被存放在同一个 chunk 中。
4 C4 s/ |5 I8 e' q# m+ y8 v; z1 W3 ~" `8 d3 l
Shard key 的值的顺序,决定了 document 存放的 chunk。在 MongoDB 的文献中,这种切割 collection 的方式,称为order-preserving。
- M6 }& b0 t. Q4 S0 Y- i. @4 [9 _
1 x9 O& r- `; X0 r e! B: U 一个 chunk最多能够存储64MB的数据。 当某个chunk存储的 documents包含的数据量,接近这个阈值时,一个chunk会被切分成两个新的chunks。- B. H* ~' d% J/ r% g) k& I4 k6 Y
# _$ w3 N% b8 A, u
当一个shard存储了过多的chunks,这个shard中的某些chunks会被迁移到其它 shard中。
1 W( I+ ]; E0 Q2 K+ _# P4 Q7 Z& i* Y) x' v5 _
这里有个问题,假如某一条 document 包含的数据量很大,超过 64MB,一个 chunk 存放不下,怎么办?在后续章节介绍 GridFS 时,我们会详细讨论。8 Z$ U# d9 r( d ]2 |
8 _6 u ?1 v& W7 E# `Replica set/ u+ s: }& [/ U* k' O, ^' P9 K
9 [, v5 ^8 z2 z& m' z
在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。
, q% m, G! b' z3 ?* T9 b, d# y2 V5 q% F, F1 g( q5 e0 t" J
这个replica set包括一个primary DB和多个secondary DBs。为了数据的一致性,所有的修改(insert / update / deletes) 请求都交给primary处理。处理结束之后,再异步地备份到其他secondary中。3 o+ Y! j$ m1 y/ f* g
+ [# f8 L7 T* i0 {7 k: M
Primary DB由replica set中的所有servers,共同选举产生。当这个primaryDB server出错的时候,可以从replica set中重新选举一个新的primaryDB,从而避免了单点故障。
0 c: q- r* }$ u# g5 M$ ?
6 X% g1 A2 n% \9 J4 K! Q Replica set的选举策略和数据同步机制,确保了系统的数据的一致性。后文详述。
7 ]2 A! b" _; s7 c" G
0 n! U8 b7 i8 I& u$ mConfig Server1 J: }- f& K y. \4 ]; ^
) ~2 @6 o0 G' _3 b7 O; ]
Config servers用于存储MongoDB集群的元数据 metadata,这些元数据包括如下两个部分,每一个shard server包括哪些chunks,每个chunk存储了哪些 collections 的哪些 documents。
1 a$ z5 e) I) U7 c# D' n2 _& j' e: ?7 D, p
每一个config server都包括了MongoDB中所有chunk的信息。% t+ s0 ^0 h- I7 M1 u+ _
" \/ ^ K* s6 j* i) j; n& W
Config server也需要 replication。但是有趣的是,config server 采用了自己独特的replication模式,而没有沿用 replica set。: z& R. s" M. F8 @4 i6 p9 X
5 [4 T' z$ t, t* P6 P- v
如果任何一台config server挂了,整个 config server 集群中,其它 config server变成只读状态。这样做的原因,是避免在系统不稳定的情况下,冒然对元数据做任何改动,导致在不同的 config servers 中,出现元数据不一致的情况。" R0 j# D% a. a G4 @3 v
! n( a1 y5 F( v, K MongoDB的官方文档建议,配置3个config servers比较合适,既提供了足够的安全性,又避免了更多的config servers实例之间的数据同步,引起的元数据不一致的麻烦。
6 M( u0 y7 B {) P/ d; D r
. p; x! J& n1 i) S8 cMongos
. }$ a- Q4 k! r1 h! n3 r {7 B' M. O
2 F, R/ s L. x2 l! a 用户使用MongoDB 时,用户的操作请求,全部由mongos来转发。
" O* W2 _3 m- t2 k9 P" L, x: Z
: i( i& j3 t/ g: z( ^3 ^: l 当 mongos 接收到用户请求时,它先查询 config server,找到存放相应数据的shard servers。然后把用户请求,转发到这些 shard servers。当这些 shard servers完成操作后,它们把结果分别返回给 mongos。而当 mongos 汇总了所有的结果后,它把结果返回给用户。
& \6 Z5 L- Q4 C t; B. [' M& X4 i, ?7 v
Mongos每次启动的时候,都要到config servers中读取元数据,并缓存在本地。每当 config server中的元数据有改动,它都会通知所有的mongos。0 g z+ W; I- D+ _" U# H/ U n4 |
3 \8 W S8 {" B
Mongos之间,不存在彼此协同工作的问题。因此,MongoDB所需要配置的mongos server的数量,没有限制。1 c' M5 {' a, n5 D, F9 N) R( o$ I
: z! k3 `4 v0 Q 通过以上的介绍,我们对每个组成部分都有了基本的了解,但是涉及到工作的细节,我们尚有诸多疑问,例如,一个chunk的数据太大,如何切分?一个shard数据太多,如何迁移?在replica set中,如何选择primary?server挂了,怎么进行故障恢复?接下来的章节,我们逐个回答这些问题。
4 K+ W! s+ J* |; ^) }3 x8 O! w4 Z7 o8 p# K4 Z6 k$ b
0 m& r( y8 p- q0 j9 t% q3 I
Reference,
/ O4 i/ R! h' Y2 W* C' c9 t; e9 t
[0] Architectural Overview
9 i' F4 k) ~1 m) e% qhttp://www.mongodb.org/display/DOCS/Sharding+Introduction! h# O8 X# N3 V' x" M& @9 ]
|
评分
-
查看全部评分
|