|
|
关于MongoDB,我们能看到的资料,基本都是在指导大家如何使用MongoDB,但是,MongoDB内部是如何运作的,资料不是很多。% V O# B3 x/ B/ \; a
5 ^+ L- L5 R9 m; }; Q4 i8 x 阅读使用手册,会有很多疑惑之处。例如,有人说,MongoDB 等同于分布式的 MySQL。它把一个Table ,按 row,分割成多个Shards,分别存放在不同的 Servers 上。这种说法是否正确?
: X& n$ R( Q/ Q+ m
; h) x) @1 c' \ H 不深入了解 MongoDB 的内部结构,就无法透彻地回答类似问题。这个系列文章,就来和大家探讨MongoDB的内部的工作方式。 |. Q7 a: e" J4 X
( p6 y. @- v/ \# @! t# h
: z5 s$ x. t% ]0 i" ~! R9 C$ d
2 U0 t t$ n% q7 }' t图1-1 MongoDB架构图
% D- m" O! E3 M u( a: @3 ], r$ P2 h) R1 t2 {/ M8 \) ?. @6 B' J! Y
MongoDB 通常运行在一个服务器集群上,而不是一个单机。图1-1,描述了一个MongoDB集群的基本组成部分,包括若干shards,至少一个config server,至少一个routing servers(又称 mongos)。
. K; t/ q" Z' h2 y- I f
7 G8 s2 c6 m6 `& q& R/ [Shards* U) b0 L6 V" G, S
6 ?+ `- Y1 U: ?9 e \+ Y! E0 Y! } MongoDB的最基本的数据单元,叫document,类似于关系式数据库中的行 row。一系列documents,组成了一个collection,相当于关系式数据库中的table。当一个 collection 数据量太大时,可以把该collection按documents切分,分成多个数据块,每个数据块叫做一个chunk,多个chunks聚集在一起,组成了一个shard。6 M1 C9 z# D: B! |0 [3 k
* C1 M4 P& y" ?1 w1 D4 m1 U Sharding 的意义,不仅保障了数据库的扩容(scalability),同时也保障了系统的负载均衡(load balance)。1 f! r, \# C, w5 P
! j; V* ^6 L9 p
每一个shard存储在一个物理服务器(server)上。Server上运行着mongod进程,通过这个进程,对shard中的数据进行操作,主要是增删改查。
2 i) Y, a1 V9 j5 {- T
) Y# Z. N$ a% g1 N 如果系统中的每个shard,只存储了一份数据,没有备份,那么当这个shard所在的server挂了,数据就丢失了。在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。! e3 Y1 B+ X9 k
1 S, w8 r3 Y. i8 o" j
Shard keys
. ?. W2 p* U: p4 E
8 ]+ `& C: y6 v2 }" F5 s 为了把collection切分成不同的chunks,从而存放到不同的shards中,我们需要制定一个切分的方式。
3 w7 B7 o. c2 |- W3 E3 j
% s$ W7 P& G2 j! S- { 如前所述,在 MongoDB 数据库中,一个表collection由多个行 documents 组成,而每个 document,有多个属性 fields。同一个 collection 中的不同的 documents,可能会有不同的 fields。例如,有个 collection 叫 Media,包含两条 documents,
3 @ z! S3 N |6 W. p6 a5 \3 J& [0 ~; |" C2 m; O
{- h: t3 [# t' B$ f
"ISBN": "987-30-3652-5130-82",
4 R- H- b& @4 M, c( S "Type": "CD",, H- t0 }9 r7 [
"Author": "Nirvana",
$ F1 _: I5 w2 T& ?* J8 a- d" k "Title": "Nevermind",
+ `9 C* K: l$ w2 q C "Genre": "Grunge",
% H! S& x* a( z) Z) w3 c "Releasedate": "1991.09.24",
9 F* B: X, e: a7 K "Tracklist": [) _4 K& x5 Z. p
{2 Q) K( `( o/ ^# A( G4 {
"Track" : "1",! m$ e2 u6 o- R, p I2 O' R5 ^
"Title" : "Smells like teen spirit",
! S- O0 |' L2 b& e5 S "Length" : "5:02"
7 j: y8 w% C3 u7 Y D# n4 ]3 B },2 S; k$ F& s& e# d9 G
{. v2 ^5 J2 n r3 e" T
"Track" : "2",
+ \, }8 `& |: L0 v7 }' p6 ~ "Title" : "In Bloom",& i3 [$ g: L2 v( e) N4 K
"Length" : "4:15"
# M) C; j$ j% _/ t& K }
" z8 z. i1 F9 j: J; P. U ]' q% b1 A8 _5 p" u
}5 p2 v Z, |- W, `; u, Q$ y& o
$ `: ?& _+ q* ^4 T }' p$ w{5 o; T% I! g; l8 I4 i4 N+ `" b
"ISBN": "987-1-4302-3051-9",, U2 I) \2 w4 E* y5 D
"Type": "Book",
6 t; |9 B( Y5 w "Title": "Definite Guide to MongoDB: The NoSQL Database",
0 A0 `( Q9 |' Z$ A "Publisher": "Apress",
' X" k* I; v$ ^- Y: i' F( e4 F. n "Author": " Eelco Plugge",
) x7 F9 O% X' T2 a "Releasedate": "2011.06.09"2 p% D- l7 L5 c, @% E- C
}
" J% O6 ~8 ^/ R0 A/ V( I
4 v6 n% }& J4 b" E2 J2 U 假如,在同一个 collection 中的所有 document,都包含某个共同的 field,例如前例中的“ISBN”,那么我们就可以按照这个 field 的值,来分割 collection。这个 field 的值,又称为 shard key。
, U1 k, R" X* H7 r7 W
) u2 p1 Y8 a. ^/ ?( A7 N 在选择shard key的时候,一定要确保这个key能够把collection均匀地切分成很多chunks。* P( ~' m* a6 z9 p
8 _+ b, b: g3 C' W3 `: E
例如,如果我们选择“author”作为shard key,如果有大量的作者是重名的,那么就会有大量的数据聚集在同一个chunk中。当然,假设很少有作者同名同姓,那么“author”也可以作为一个shard key。换句话说,shard key 的选择,与使用场景密切相关。( H3 a l$ X- ?
9 \2 r! t' H D4 ]
很多情况下,无论选择哪一个单一的 field 作为shard key,都无法均匀分割 collection。在这种情况下,我们可以考虑,用多个 fields,构成一个复合的shard key。- _; M+ s" x2 ~ _/ R
; Z1 @2 i% c) t" g1 @ 延续前例,假如有很多作者同名同姓,他们都叫“王二”。用 author 作为 shard key,显然无法均匀切割 collection。这时我们可以加上release-date,组成name-date的复合 shard key,例如“王二 2011”。
+ U2 j8 T2 Z, D- F7 t& t- O7 e, F2 b$ j; N/ H# m1 R2 E
Chunks, g( \/ L9 G9 G1 c7 X+ N/ q
! {8 f- l* X; W MongoDB按 shard key,把 collection切割成若干 chunks。每个 chunk 的数据结构,是一个三元组,{collection,minKey,maxKey},如图1-2 所示。
+ W' e+ c# X, J9 ]$ w, z" c' ]. A5 a
$ u$ _! F6 U2 N图1-2 chunk的三元组
5 @" t# m6 J$ U' t; b3 ~5 a/ [* C+ K- D
其中,collection 是数据库中某一个表的名称,而 minKey 和 maxKey 是 shard key的范围。每一个 document 的shard key 的值,决定了这条document应该存放在哪个chunk中。8 m! e4 P( F0 j/ Q% [) i
' G) R3 I( \" Z w; }. L/ U 如果两条 documents 的 shard keys 的值很接近,这两条 documents 很可能被存放在同一个 chunk 中。* t1 v; |% W' K! g
: N L% r+ ]1 }( p: T
Shard key 的值的顺序,决定了 document 存放的 chunk。在 MongoDB 的文献中,这种切割 collection 的方式,称为order-preserving。 V+ T- `0 d# k, G5 x
- P0 U/ Z' t; v/ x
一个 chunk最多能够存储64MB的数据。 当某个chunk存储的 documents包含的数据量,接近这个阈值时,一个chunk会被切分成两个新的chunks。
$ |& O3 z2 x' l8 v
; `# F) B7 t# f. s3 m* x5 H- A 当一个shard存储了过多的chunks,这个shard中的某些chunks会被迁移到其它 shard中。% w9 {1 u' t1 d# R# G9 u& t
, m0 O4 W n* g( ~/ b9 v! B 这里有个问题,假如某一条 document 包含的数据量很大,超过 64MB,一个 chunk 存放不下,怎么办?在后续章节介绍 GridFS 时,我们会详细讨论。9 D9 v! Z% L+ r- v" y
/ n! h4 s9 v9 q5 [5 O
Replica set
% h6 r s$ W K \& B
; {& K7 h3 a. n0 C% _% M 在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。1 [5 f2 p! r( n9 \; O
, L3 Y+ y1 i" O4 i 这个replica set包括一个primary DB和多个secondary DBs。为了数据的一致性,所有的修改(insert / update / deletes) 请求都交给primary处理。处理结束之后,再异步地备份到其他secondary中。
[2 N; |0 b% L& b, C5 \
+ E5 B8 {" d& M: H* U4 @0 B9 l3 a5 R Primary DB由replica set中的所有servers,共同选举产生。当这个primaryDB server出错的时候,可以从replica set中重新选举一个新的primaryDB,从而避免了单点故障。
5 ^2 e" }2 U, y& [- q( o4 c' n _1 o& U y- T8 h2 P/ E* `
Replica set的选举策略和数据同步机制,确保了系统的数据的一致性。后文详述。
v+ t& Y: Z4 i) b/ h3 N) V3 A+ O
Config Server/ ]% A$ n2 c3 G# F! K
' L* G2 A1 V; _: J Config servers用于存储MongoDB集群的元数据 metadata,这些元数据包括如下两个部分,每一个shard server包括哪些chunks,每个chunk存储了哪些 collections 的哪些 documents。
2 C0 j. T2 s) A8 p, }7 l
& X' L5 z6 p+ W 每一个config server都包括了MongoDB中所有chunk的信息。
5 B; O; Y b2 W4 i* Y4 w. E2 j& o; L% \$ T5 T
Config server也需要 replication。但是有趣的是,config server 采用了自己独特的replication模式,而没有沿用 replica set。
* Y% Z( q0 C# f1 F2 F# k
+ F: ]. t) w/ C4 u K$ N/ u 如果任何一台config server挂了,整个 config server 集群中,其它 config server变成只读状态。这样做的原因,是避免在系统不稳定的情况下,冒然对元数据做任何改动,导致在不同的 config servers 中,出现元数据不一致的情况。
- @' S* T9 D( u% h. @7 H5 {: q& K2 @$ `9 ]' v
MongoDB的官方文档建议,配置3个config servers比较合适,既提供了足够的安全性,又避免了更多的config servers实例之间的数据同步,引起的元数据不一致的麻烦。, o8 l t$ C3 U. q8 M5 e3 R% B- e
( B7 r8 O5 P( R F$ Y1 xMongos
' |- X; b: c& `6 Z% _/ V8 F2 G( u+ U3 ~% l j1 }0 D) }
用户使用MongoDB 时,用户的操作请求,全部由mongos来转发。0 z x! e3 v7 i. \9 z: z7 ]
2 R, {+ Q/ @) d0 i7 N3 d
当 mongos 接收到用户请求时,它先查询 config server,找到存放相应数据的shard servers。然后把用户请求,转发到这些 shard servers。当这些 shard servers完成操作后,它们把结果分别返回给 mongos。而当 mongos 汇总了所有的结果后,它把结果返回给用户。* P+ I6 Q, A5 m7 N
9 C7 n) Y$ W; o M) d
Mongos每次启动的时候,都要到config servers中读取元数据,并缓存在本地。每当 config server中的元数据有改动,它都会通知所有的mongos。
; Z' p9 {5 |5 ~& i. ^, M" v. w: ?6 {" W
Mongos之间,不存在彼此协同工作的问题。因此,MongoDB所需要配置的mongos server的数量,没有限制。3 M! t* ^( r5 f2 M/ ^/ O/ v, K
! h9 y6 k) k g4 J9 k) z3 ` B0 i 通过以上的介绍,我们对每个组成部分都有了基本的了解,但是涉及到工作的细节,我们尚有诸多疑问,例如,一个chunk的数据太大,如何切分?一个shard数据太多,如何迁移?在replica set中,如何选择primary?server挂了,怎么进行故障恢复?接下来的章节,我们逐个回答这些问题。. ]4 z5 F. \2 B% ?* w& S9 \
( p3 p, o( Q6 {- Q5 X, D$ v
" x2 s4 e* T! E1 i$ XReference,$ g% n6 X3 b3 P _3 N# v
2 c& l; o/ M x: u+ h
[0] Architectural Overview
2 ~8 X$ M) g( \7 Q" dhttp://www.mongodb.org/display/DOCS/Sharding+Introduction7 ^! S4 g. X9 \: P) ?
|
评分
-
查看全部评分
|