|
|
关于MongoDB,我们能看到的资料,基本都是在指导大家如何使用MongoDB,但是,MongoDB内部是如何运作的,资料不是很多。
/ M6 v% U) [5 k' i% u1 O' s( P' X* @8 d; h
阅读使用手册,会有很多疑惑之处。例如,有人说,MongoDB 等同于分布式的 MySQL。它把一个Table ,按 row,分割成多个Shards,分别存放在不同的 Servers 上。这种说法是否正确?
M) k& u8 J( ?1 s O0 R. M4 W* E. e1 q
不深入了解 MongoDB 的内部结构,就无法透彻地回答类似问题。这个系列文章,就来和大家探讨MongoDB的内部的工作方式。
/ q) u7 }$ U0 h: b
7 p! k8 l6 ?) z+ r! _# I3 N
. s8 `1 H* e, D5 m% L; C+ q5 F7 U* r
( p7 e: G7 i* P. h1 f+ m图1-1 MongoDB架构图
. x( J0 I' A3 y2 n4 ~) u7 n9 j7 Z1 U; L) P& E/ F2 n$ Q- `5 g& P
MongoDB 通常运行在一个服务器集群上,而不是一个单机。图1-1,描述了一个MongoDB集群的基本组成部分,包括若干shards,至少一个config server,至少一个routing servers(又称 mongos)。
. H' E1 c* h" F) k) ~5 E& V6 X# q( l- q; V5 D& H$ `5 C" B' C, t3 f
Shards
; ]: n) h9 N$ t9 I% h( p
. s7 i8 s1 R* p7 W* R- A) H3 B MongoDB的最基本的数据单元,叫document,类似于关系式数据库中的行 row。一系列documents,组成了一个collection,相当于关系式数据库中的table。当一个 collection 数据量太大时,可以把该collection按documents切分,分成多个数据块,每个数据块叫做一个chunk,多个chunks聚集在一起,组成了一个shard。
' ]" _* v0 ^/ d Q) k
# T: a) T3 R* q( d7 d Sharding 的意义,不仅保障了数据库的扩容(scalability),同时也保障了系统的负载均衡(load balance)。# k e6 f4 r3 W1 X2 d8 e1 b( s! S
3 O" U; }) O6 \3 I# O5 U# q r1 w7 m 每一个shard存储在一个物理服务器(server)上。Server上运行着mongod进程,通过这个进程,对shard中的数据进行操作,主要是增删改查。
g! D% a& b9 u$ I B1 F* X1 A7 C2 Z' i, g6 Q' Q$ J+ `- U
如果系统中的每个shard,只存储了一份数据,没有备份,那么当这个shard所在的server挂了,数据就丢失了。在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。
2 ?, L: W7 T0 [/ {8 k7 d+ M2 c: l6 j' d/ \; @: ~" I
Shard keys
6 b8 S, i# d- N% t: b9 W# k
$ a3 k+ i( e; m+ I' i+ }/ T 为了把collection切分成不同的chunks,从而存放到不同的shards中,我们需要制定一个切分的方式。% y g1 M- U/ j
9 o& |; B% Y8 k5 c% I- m' } 如前所述,在 MongoDB 数据库中,一个表collection由多个行 documents 组成,而每个 document,有多个属性 fields。同一个 collection 中的不同的 documents,可能会有不同的 fields。例如,有个 collection 叫 Media,包含两条 documents,5 b: O* V) N0 Q0 M" |* i3 X0 L7 @
) A0 {- D$ R' ]2 v6 i& }3 C{
' R, O2 Y# B' A# |: } "ISBN": "987-30-3652-5130-82",
5 T5 c0 N( R& M4 }7 t3 b: I "Type": "CD",
2 d- j R4 T. e+ r: N "Author": "Nirvana",
$ V0 M* l# V I7 j, y, J: q: I" Y "Title": "Nevermind",
" H' O% u; W% h8 u7 R "Genre": "Grunge",* u$ }4 c' J% ~ @) g! n
"Releasedate": "1991.09.24",
% _/ Y, {: i5 j0 \0 w: w# K "Tracklist": [
8 L) Q. A) s9 k x# f3 z {$ }9 J' s1 ?3 x7 Z. m8 |. J
"Track" : "1",
! N8 ~* c' y, T3 U "Title" : "Smells like teen spirit",* Y! ^, |9 t0 }# x5 [! E0 t0 Y
"Length" : "5:02"
1 j. y; r; d5 p9 u0 T& ] },
3 K; O, h' H# o p: Y* `% E4 U: ?& [ {8 t2 d' P1 e2 w ^7 [$ ?# E) O: M
"Track" : "2",, y" w9 f( s" Z+ R9 U( t7 K
"Title" : "In Bloom",+ q; u% ], O4 h+ g' w4 \
"Length" : "4:15"
6 P$ [6 v: {5 a& J$ u8 @* m3 c: g }
( s3 i2 d& s9 d; ^& h ]
9 G! ]( `7 O5 f+ |}
0 c* N! f9 }8 g* N! ?' }3 M# [" g# b: [2 r4 ?
{
& {+ w9 L' F( a "ISBN": "987-1-4302-3051-9",, z3 w' V) u7 u$ w0 z# Q) N$ ~* Z4 b
"Type": "Book",
2 s3 f2 r, `0 o% J9 j: S. x "Title": "Definite Guide to MongoDB: The NoSQL Database",2 ]4 O6 I( u9 q; f- D7 {+ X
"Publisher": "Apress",
5 }( T8 d' P% \/ P0 c4 [( @4 t "Author": " Eelco Plugge",
% f( y" z" o7 |+ @ "Releasedate": "2011.06.09"8 g8 n+ _0 Y" u) h( O0 f
}' M8 f4 ^1 ^4 O0 V! H: O
$ l9 x$ {6 \$ ~' D. J; J 假如,在同一个 collection 中的所有 document,都包含某个共同的 field,例如前例中的“ISBN”,那么我们就可以按照这个 field 的值,来分割 collection。这个 field 的值,又称为 shard key。
: V& u' ?* ~6 u5 J( ]$ I, {9 J. t5 p9 e7 E2 x* f5 N) \
在选择shard key的时候,一定要确保这个key能够把collection均匀地切分成很多chunks。
0 M% l, v& ~( E9 M- x( t* X$ P6 z. F3 B6 B0 U1 ?9 Y, M
例如,如果我们选择“author”作为shard key,如果有大量的作者是重名的,那么就会有大量的数据聚集在同一个chunk中。当然,假设很少有作者同名同姓,那么“author”也可以作为一个shard key。换句话说,shard key 的选择,与使用场景密切相关。
/ G8 j6 J9 G) ^0 [
2 X+ f2 o5 E! S) I* I 很多情况下,无论选择哪一个单一的 field 作为shard key,都无法均匀分割 collection。在这种情况下,我们可以考虑,用多个 fields,构成一个复合的shard key。* O2 c. M- D4 G2 U" H2 M# e% B4 D
6 w* o! _: [; e; m5 K 延续前例,假如有很多作者同名同姓,他们都叫“王二”。用 author 作为 shard key,显然无法均匀切割 collection。这时我们可以加上release-date,组成name-date的复合 shard key,例如“王二 2011”。
) W! ]( u# x! Y" n e! R+ R
$ P+ r+ m* h( [# u* OChunks5 x W+ F2 ~: a: D# H
7 h0 |8 z) F1 P5 W+ j4 H
MongoDB按 shard key,把 collection切割成若干 chunks。每个 chunk 的数据结构,是一个三元组,{collection,minKey,maxKey},如图1-2 所示。) j- P$ e% W3 U2 d
8 Y! E [" T/ ~( Z t, S6 O
, V" D# t" M. e5 t, }/ [' v
图1-2 chunk的三元组 ) v) T% H7 d; W) S
( k/ B* W* z9 W
其中,collection 是数据库中某一个表的名称,而 minKey 和 maxKey 是 shard key的范围。每一个 document 的shard key 的值,决定了这条document应该存放在哪个chunk中。
% C% {( S# ]4 s0 F/ Z! g* Y' v) n+ b( [: g9 ~0 M: V* ]
如果两条 documents 的 shard keys 的值很接近,这两条 documents 很可能被存放在同一个 chunk 中。( b; z; o$ U( V& l/ N
$ f6 ?6 `5 m1 N. @1 Q Shard key 的值的顺序,决定了 document 存放的 chunk。在 MongoDB 的文献中,这种切割 collection 的方式,称为order-preserving。2 P5 M3 O% Z# n
* z/ s3 t& p1 {% P 一个 chunk最多能够存储64MB的数据。 当某个chunk存储的 documents包含的数据量,接近这个阈值时,一个chunk会被切分成两个新的chunks。
* X2 s/ B5 r, C: p7 b( Q2 G# @3 h' {' H& V
当一个shard存储了过多的chunks,这个shard中的某些chunks会被迁移到其它 shard中。. C2 W6 u2 p. D) R W3 {0 `) i3 H
6 S: x8 a5 \& v/ A1 Z4 f7 V
这里有个问题,假如某一条 document 包含的数据量很大,超过 64MB,一个 chunk 存放不下,怎么办?在后续章节介绍 GridFS 时,我们会详细讨论。
6 b' b1 u& \$ {) G# u* [4 u2 g h* A. I2 J+ H
Replica set
; K7 q$ F! P- c' U9 \
- g0 B! | m: |+ V1 H 在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。
& o# E! |6 _1 f- G# G0 t1 U3 T( m5 v4 c1 x! t) M" e5 ?' X; x
这个replica set包括一个primary DB和多个secondary DBs。为了数据的一致性,所有的修改(insert / update / deletes) 请求都交给primary处理。处理结束之后,再异步地备份到其他secondary中。
% i: n8 f( h" Q @1 s2 ?( h4 S% B+ w/ h- h5 ]8 i; q6 l
Primary DB由replica set中的所有servers,共同选举产生。当这个primaryDB server出错的时候,可以从replica set中重新选举一个新的primaryDB,从而避免了单点故障。7 i. j* {( Q) d3 O4 O7 z
2 Q6 Y% B, l2 F8 u Replica set的选举策略和数据同步机制,确保了系统的数据的一致性。后文详述。
- _6 Q# a: D7 T' [$ t* R& {, Q+ \
Config Server
- c/ w! S; T8 N. h: S/ [
9 [$ j \7 w: S5 Y, @ Config servers用于存储MongoDB集群的元数据 metadata,这些元数据包括如下两个部分,每一个shard server包括哪些chunks,每个chunk存储了哪些 collections 的哪些 documents。6 u% H" V H: h+ ]8 r, Y: w4 I
. a$ ]9 S& N( h* g 每一个config server都包括了MongoDB中所有chunk的信息。' P$ j) b4 V4 t- r/ Q- p
8 p9 C% [' e8 a$ |* h
Config server也需要 replication。但是有趣的是,config server 采用了自己独特的replication模式,而没有沿用 replica set。
8 _) F3 ~: A* T3 d( U \1 B4 S/ K, x# v9 S
如果任何一台config server挂了,整个 config server 集群中,其它 config server变成只读状态。这样做的原因,是避免在系统不稳定的情况下,冒然对元数据做任何改动,导致在不同的 config servers 中,出现元数据不一致的情况。
$ W9 t5 B# `/ F9 i: _7 @# }1 y2 F; ]- B# I5 m" _) o( x! n* ?
MongoDB的官方文档建议,配置3个config servers比较合适,既提供了足够的安全性,又避免了更多的config servers实例之间的数据同步,引起的元数据不一致的麻烦。
, i; X2 \; t) o; ^- \3 S2 m
: m% A( y" J" WMongos
3 M& o8 |7 e, |9 p$ m/ j( ?: g! r$ Z
用户使用MongoDB 时,用户的操作请求,全部由mongos来转发。
" ]- y9 N- `# f8 u: Q+ ]( \ _/ p$ S* H3 U4 P3 ], d
当 mongos 接收到用户请求时,它先查询 config server,找到存放相应数据的shard servers。然后把用户请求,转发到这些 shard servers。当这些 shard servers完成操作后,它们把结果分别返回给 mongos。而当 mongos 汇总了所有的结果后,它把结果返回给用户。
$ p5 k1 f- q( ?2 X9 l
+ d# j1 U& u/ Q( G1 w% Z5 H Mongos每次启动的时候,都要到config servers中读取元数据,并缓存在本地。每当 config server中的元数据有改动,它都会通知所有的mongos。
) _; K0 B. m/ _, Y( _, f* r% _$ G) d5 i; P: \% L
Mongos之间,不存在彼此协同工作的问题。因此,MongoDB所需要配置的mongos server的数量,没有限制。
; b) B8 ^3 Y" i' N: e: u2 h. U5 K" p
通过以上的介绍,我们对每个组成部分都有了基本的了解,但是涉及到工作的细节,我们尚有诸多疑问,例如,一个chunk的数据太大,如何切分?一个shard数据太多,如何迁移?在replica set中,如何选择primary?server挂了,怎么进行故障恢复?接下来的章节,我们逐个回答这些问题。
5 M( b9 J3 a" p. n) o$ B6 K$ J) x% u" I+ p
. F- j; F* ?& o0 W& m- c& LReference,
7 d# m9 A3 ?4 S+ A2 |! |
$ u* q3 @1 W' S+ N: _4 B% |4 n+ w[0] Architectural Overview3 Q! j8 ?% J- O3 r- @) T. I
http://www.mongodb.org/display/DOCS/Sharding+Introduction2 G0 i l+ I9 `; w! |* Q
|
评分
-
查看全部评分
|