|
|
关于MongoDB,我们能看到的资料,基本都是在指导大家如何使用MongoDB,但是,MongoDB内部是如何运作的,资料不是很多。. ~ n2 d' w, E. e* t2 B; x5 L
% x' X: O. \) ?0 W! C
阅读使用手册,会有很多疑惑之处。例如,有人说,MongoDB 等同于分布式的 MySQL。它把一个Table ,按 row,分割成多个Shards,分别存放在不同的 Servers 上。这种说法是否正确?
0 v+ Y5 _8 ?" O* u0 u
. l y7 h) ?5 V+ k/ g% ^# ?7 ] 不深入了解 MongoDB 的内部结构,就无法透彻地回答类似问题。这个系列文章,就来和大家探讨MongoDB的内部的工作方式。9 S1 T3 j6 t, J N
i+ x# N: u+ S' f6 X( x
. y# U5 e0 m1 J- x1 H, ]
" b: x3 l3 W8 {" N! @) r
图1-1 MongoDB架构图 8 g% E- `* |4 G- }
4 |; A" w" j2 H! }- A MongoDB 通常运行在一个服务器集群上,而不是一个单机。图1-1,描述了一个MongoDB集群的基本组成部分,包括若干shards,至少一个config server,至少一个routing servers(又称 mongos)。- e: E9 [; t3 b0 d9 z5 M
% A9 Z; K7 q# F7 g: u3 L
Shards
* g" Z4 ^' c! R- l, R8 I0 J8 R% F* A# q' ?: T8 {# W
MongoDB的最基本的数据单元,叫document,类似于关系式数据库中的行 row。一系列documents,组成了一个collection,相当于关系式数据库中的table。当一个 collection 数据量太大时,可以把该collection按documents切分,分成多个数据块,每个数据块叫做一个chunk,多个chunks聚集在一起,组成了一个shard。" C O: ^8 Q# k% |0 o, I
0 g) [' n7 L& y$ @" ?8 ^* n7 L% C Sharding 的意义,不仅保障了数据库的扩容(scalability),同时也保障了系统的负载均衡(load balance)。: S# J6 Y# K) k1 E: |5 [' [' p4 F
, D8 g" p4 d. |, H" ~" {& o8 A- \ 每一个shard存储在一个物理服务器(server)上。Server上运行着mongod进程,通过这个进程,对shard中的数据进行操作,主要是增删改查。! \# |6 v& |7 l K8 C
# h! y9 |) X1 N; J, {8 t; ]
如果系统中的每个shard,只存储了一份数据,没有备份,那么当这个shard所在的server挂了,数据就丢失了。在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。" h: |1 g0 _" z5 r
$ J# z; |- p& M6 Y1 y) BShard keys+ l9 N% ~( e! j9 p& @5 X
5 N: W0 d0 s! u# a$ ]. O1 F 为了把collection切分成不同的chunks,从而存放到不同的shards中,我们需要制定一个切分的方式。
" ^) K! o; x$ {8 G+ N+ P8 W
1 x6 \6 ^3 J$ h* \ 如前所述,在 MongoDB 数据库中,一个表collection由多个行 documents 组成,而每个 document,有多个属性 fields。同一个 collection 中的不同的 documents,可能会有不同的 fields。例如,有个 collection 叫 Media,包含两条 documents,
; [$ R t P4 V' u) V! ]2 C3 ]( T6 Z' x# ?
{
, R& x9 Z: |; y' y" Y "ISBN": "987-30-3652-5130-82"," t5 p' d8 t; P Y1 \/ W4 q4 J
"Type": "CD",% L$ ?" g( D s2 T& \ C7 E
"Author": "Nirvana",
/ y8 D3 L, f2 N Q r6 E! ~5 D "Title": "Nevermind",) M# ]/ ^; C2 J& V
"Genre": "Grunge",
0 r; Q' K" G1 `$ @- x2 x "Releasedate": "1991.09.24",
$ t3 L, c2 ~ n( \ "Tracklist": [' D, P8 L' a7 n7 a \. r
{7 g4 z6 ]- C& P4 C
"Track" : "1",
* E$ J9 H5 W# K "Title" : "Smells like teen spirit",2 t: |1 B4 \9 _3 G
"Length" : "5:02"
0 l. k* u% }9 i% y7 K; J },1 n+ _3 z) a1 n8 ~3 H4 n
{# `9 j6 |* P# q( P* ?
"Track" : "2",
' g2 c! T# L7 f) p$ d6 m( O# e "Title" : "In Bloom",
& M2 O' n, e+ {: V2 T7 ? "Length" : "4:15"
5 S1 m7 Z7 m4 A" C. g p }
2 H7 Q" W* V) k' N2 m2 Y ]
. ^( ]/ m y) d}3 x- N; m) k7 Q+ h- h( x
; w6 C, ~7 I/ A
{
1 J2 _) X. \7 F$ Z4 j) \ "ISBN": "987-1-4302-3051-9",( _' l. T/ ^2 H& P
"Type": "Book",
3 ~ k" l: e% y# {5 S& k "Title": "Definite Guide to MongoDB: The NoSQL Database",* p" v7 g+ i1 J
"Publisher": "Apress",
% X1 {% g, M. ^ ] "Author": " Eelco Plugge",
) I1 r# g. ]2 I1 M, c: R "Releasedate": "2011.06.09"
3 p# C0 x3 N9 _, T}! _7 Y9 i# e9 a$ f( T& l
- j( @/ U0 o1 M+ e4 ~! _' _
假如,在同一个 collection 中的所有 document,都包含某个共同的 field,例如前例中的“ISBN”,那么我们就可以按照这个 field 的值,来分割 collection。这个 field 的值,又称为 shard key。2 y* T4 P6 c2 _% ^
t: ~. W6 B5 w8 T
在选择shard key的时候,一定要确保这个key能够把collection均匀地切分成很多chunks。
1 [* V3 u! t, G) ]4 p9 L
7 _! @/ }! i( \" b( n+ a- H. g; L/ [ 例如,如果我们选择“author”作为shard key,如果有大量的作者是重名的,那么就会有大量的数据聚集在同一个chunk中。当然,假设很少有作者同名同姓,那么“author”也可以作为一个shard key。换句话说,shard key 的选择,与使用场景密切相关。/ C4 ~( C R- o9 N
; d1 L9 k: I% b, s 很多情况下,无论选择哪一个单一的 field 作为shard key,都无法均匀分割 collection。在这种情况下,我们可以考虑,用多个 fields,构成一个复合的shard key。
4 U M& b- t2 F3 b- j
]0 u5 [ C; p/ |3 l3 Z( S' T 延续前例,假如有很多作者同名同姓,他们都叫“王二”。用 author 作为 shard key,显然无法均匀切割 collection。这时我们可以加上release-date,组成name-date的复合 shard key,例如“王二 2011”。6 Z( L6 \3 E# i( p; ?8 O
( o7 u% M+ x& P+ A+ s5 {. B
Chunks
9 H; j8 ~/ G! W$ C " v7 |# ~+ `, h% X: u
MongoDB按 shard key,把 collection切割成若干 chunks。每个 chunk 的数据结构,是一个三元组,{collection,minKey,maxKey},如图1-2 所示。- w6 t( [! K" H+ D
3 Y3 {; ?" t( g3 t; C( h& m
: Z6 x& X9 Z4 ~* F8 v$ Q0 Y图1-2 chunk的三元组 5 M8 E- Y& _0 l; e3 T' ]/ z" l6 @
4 y1 e- h$ R5 D" \1 X+ p
其中,collection 是数据库中某一个表的名称,而 minKey 和 maxKey 是 shard key的范围。每一个 document 的shard key 的值,决定了这条document应该存放在哪个chunk中。
# z, \! @1 L, Q% ?: c5 R( w8 ?
2 C5 G# y1 p3 g 如果两条 documents 的 shard keys 的值很接近,这两条 documents 很可能被存放在同一个 chunk 中。
! F2 C" Y; `7 W7 `. w
/ t$ u! K/ c& B0 s Shard key 的值的顺序,决定了 document 存放的 chunk。在 MongoDB 的文献中,这种切割 collection 的方式,称为order-preserving。
; L& _5 m0 n: E8 C6 @, h. w' f$ i2 |0 @4 Q
一个 chunk最多能够存储64MB的数据。 当某个chunk存储的 documents包含的数据量,接近这个阈值时,一个chunk会被切分成两个新的chunks。
) L% b+ c1 I4 n4 `7 w/ v! s! J# F2 k. B5 ?7 F6 ]
当一个shard存储了过多的chunks,这个shard中的某些chunks会被迁移到其它 shard中。9 Z( L% U! @2 w5 _1 I2 P0 \( |6 E5 J
1 q# W1 e! U6 Y! I' Y" s" i 这里有个问题,假如某一条 document 包含的数据量很大,超过 64MB,一个 chunk 存放不下,怎么办?在后续章节介绍 GridFS 时,我们会详细讨论。
' x& P ?8 B ^3 c! u+ L1 M2 i( i7 O& _8 K0 I& u( a/ J1 e
Replica set+ Y" O: ^/ B( }# v T
, I, d7 B, V2 z2 k, y 在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。
: w' K8 c3 I5 l% Z1 b: h0 z2 q+ J0 [6 K& v- n! @
这个replica set包括一个primary DB和多个secondary DBs。为了数据的一致性,所有的修改(insert / update / deletes) 请求都交给primary处理。处理结束之后,再异步地备份到其他secondary中。
9 k6 p8 a2 H# K
k5 O1 f, }" [# A Primary DB由replica set中的所有servers,共同选举产生。当这个primaryDB server出错的时候,可以从replica set中重新选举一个新的primaryDB,从而避免了单点故障。
( u% v: Z3 W1 P/ c: V1 N/ t5 J1 G# |& i; x) Y, n p9 `. Y
Replica set的选举策略和数据同步机制,确保了系统的数据的一致性。后文详述。
7 Z: C' P6 Y6 s1 d& ~$ g$ F6 a6 O; I! |! Z, G" }4 F$ Q
Config Server
6 m- D e( N0 m1 {9 z U$ V* O2 s $ L" @) G* {+ X$ {* l1 [
Config servers用于存储MongoDB集群的元数据 metadata,这些元数据包括如下两个部分,每一个shard server包括哪些chunks,每个chunk存储了哪些 collections 的哪些 documents。
5 A! y. B" j B/ x M$ m/ Q$ U L6 ?" y7 Q
每一个config server都包括了MongoDB中所有chunk的信息。, i& q# d: B0 i/ L0 n/ D* w
! D) {: f L% i% l5 o# S, J Config server也需要 replication。但是有趣的是,config server 采用了自己独特的replication模式,而没有沿用 replica set。
/ ^% F+ ?8 M. W) ~
3 k3 q6 Z4 f; N$ z8 a# U) T! B- C 如果任何一台config server挂了,整个 config server 集群中,其它 config server变成只读状态。这样做的原因,是避免在系统不稳定的情况下,冒然对元数据做任何改动,导致在不同的 config servers 中,出现元数据不一致的情况。. G% T3 o5 N F+ P' o3 F* P1 b
j9 s9 @( n1 @8 J, v6 w
MongoDB的官方文档建议,配置3个config servers比较合适,既提供了足够的安全性,又避免了更多的config servers实例之间的数据同步,引起的元数据不一致的麻烦。
- k9 p5 M" J; g9 Z1 t- |& m' r- B. t& n9 ^$ D- z
Mongos
9 L. D, \" d9 t$ q% S1 Y- H* j' `' D, V5 d$ u! ^9 p
用户使用MongoDB 时,用户的操作请求,全部由mongos来转发。
% n# O }& @' g; G+ n8 |5 j2 ]; _9 s/ q1 I! ]% Y6 D6 s0 M
当 mongos 接收到用户请求时,它先查询 config server,找到存放相应数据的shard servers。然后把用户请求,转发到这些 shard servers。当这些 shard servers完成操作后,它们把结果分别返回给 mongos。而当 mongos 汇总了所有的结果后,它把结果返回给用户。1 B0 W3 I9 |! w+ Z4 A" x8 e* B
3 V' Q% w: e) M1 ~6 h+ s! r3 H' q Mongos每次启动的时候,都要到config servers中读取元数据,并缓存在本地。每当 config server中的元数据有改动,它都会通知所有的mongos。
" J5 D- J0 b. t; J. U" e+ s5 {5 l2 m6 H0 J! Z
Mongos之间,不存在彼此协同工作的问题。因此,MongoDB所需要配置的mongos server的数量,没有限制。
, ~+ r( E0 D" T
: b5 j+ Y! I" {% r' o. A. R 通过以上的介绍,我们对每个组成部分都有了基本的了解,但是涉及到工作的细节,我们尚有诸多疑问,例如,一个chunk的数据太大,如何切分?一个shard数据太多,如何迁移?在replica set中,如何选择primary?server挂了,怎么进行故障恢复?接下来的章节,我们逐个回答这些问题。
& J9 ? m$ d8 r. R5 \- C4 Y, d4 ]3 o$ P% ~2 d0 l
( k: }; s+ I& d
Reference,# l- a( Z2 W" c8 s0 P, v6 Y7 m
8 t7 F# o5 a' ~) b& W
[0] Architectural Overview
+ e0 x6 K. }9 M5 o6 bhttp://www.mongodb.org/display/DOCS/Sharding+Introduction# D- Y1 I' T3 `2 j# I
|
评分
-
查看全部评分
|