|
关于MongoDB,我们能看到的资料,基本都是在指导大家如何使用MongoDB,但是,MongoDB内部是如何运作的,资料不是很多。
+ f' p. R1 j3 B
; _2 y7 F' ?. j: F( }9 `! Y 阅读使用手册,会有很多疑惑之处。例如,有人说,MongoDB 等同于分布式的 MySQL。它把一个Table ,按 row,分割成多个Shards,分别存放在不同的 Servers 上。这种说法是否正确?7 [& u* A- b+ \; g3 f6 ?
+ \$ h4 C4 L; b3 A2 k1 ^ 不深入了解 MongoDB 的内部结构,就无法透彻地回答类似问题。这个系列文章,就来和大家探讨MongoDB的内部的工作方式。
- R! L* o. g# H+ n+ n1 y# d
3 E4 j5 M9 Z" x" E
& O2 t. L6 P* d6 y; F$ c
" ?8 B: Y6 V9 I R4 ^6 v1 J图1-1 MongoDB架构图 & d. f% a2 r- K3 b1 L- d2 g& r
3 l4 Q6 I. `( T. K' z* _; \ MongoDB 通常运行在一个服务器集群上,而不是一个单机。图1-1,描述了一个MongoDB集群的基本组成部分,包括若干shards,至少一个config server,至少一个routing servers(又称 mongos)。: s6 D8 Z5 l! { [1 e' l
' e2 H; e6 C1 e2 |) K$ A# r- Y+ P
Shards. S+ w; ?# y5 ^2 b) X$ A
* E, _) {. a( S$ n
MongoDB的最基本的数据单元,叫document,类似于关系式数据库中的行 row。一系列documents,组成了一个collection,相当于关系式数据库中的table。当一个 collection 数据量太大时,可以把该collection按documents切分,分成多个数据块,每个数据块叫做一个chunk,多个chunks聚集在一起,组成了一个shard。1 F0 A2 ^, Q4 b2 s; \1 H0 F9 D
( m9 i' f8 Q2 u1 k
Sharding 的意义,不仅保障了数据库的扩容(scalability),同时也保障了系统的负载均衡(load balance)。- z, B! A- E# e
1 T7 m+ ]% P/ W% E0 s" i: b& p
每一个shard存储在一个物理服务器(server)上。Server上运行着mongod进程,通过这个进程,对shard中的数据进行操作,主要是增删改查。
8 I* c5 [7 F$ z+ p6 {" s
; a+ A; c8 {1 M4 ~% s; a, \' H- M* { 如果系统中的每个shard,只存储了一份数据,没有备份,那么当这个shard所在的server挂了,数据就丢失了。在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。- o; g) A0 Q3 w3 B! O
$ W5 S; t2 E; B" P+ k6 [% L' WShard keys, E' |& m+ G. ~0 w, ?
9 ^! s4 g/ j: F. s3 J5 E 为了把collection切分成不同的chunks,从而存放到不同的shards中,我们需要制定一个切分的方式。
$ r2 U- ?$ Z; \7 y) J, l: t+ h+ G
如前所述,在 MongoDB 数据库中,一个表collection由多个行 documents 组成,而每个 document,有多个属性 fields。同一个 collection 中的不同的 documents,可能会有不同的 fields。例如,有个 collection 叫 Media,包含两条 documents,3 ], g* W3 B# h! L) e
2 L8 Z- n) \6 a0 b' M/ k{3 j9 b! L3 _# r8 L1 k
"ISBN": "987-30-3652-5130-82",
8 \4 t' i2 P2 `' A% U "Type": "CD",
* I* M, d) Y4 z "Author": "Nirvana",% X0 J4 J, b# ~0 J1 ]( J% ]
"Title": "Nevermind",
8 }9 w) G: X$ U- U8 M8 E* H9 ~ "Genre": "Grunge",
, L' ]" l( c- h9 e) C. \ "Releasedate": "1991.09.24",. B I2 A8 X4 {" }- z
"Tracklist": [
2 v g( G) e# h4 h4 s {( F8 G* g1 N; b' f: L+ T" Z
"Track" : "1",
4 j5 s8 Q& E i2 A+ d9 H! ] "Title" : "Smells like teen spirit",8 E5 g9 P% z7 H/ s2 C
"Length" : "5:02"
" _' q9 |* K1 ?) I9 Y9 d$ }# _ },9 o" Q# N" z7 Y* o. S
{
f7 ?9 a8 j8 c. ^% \0 \/ O( ? H9 t* X "Track" : "2",5 i+ H( C; z1 v5 h( N0 [9 o
"Title" : "In Bloom",( j# v# p7 H5 h" [& G J
"Length" : "4:15"
Y( u5 I0 u6 B5 d* o1 T3 O }
* [/ s$ D y. P8 p+ ` ]
8 y' {! b4 r, C/ f6 g& k}4 T! `) U0 i/ O! z
2 u5 n6 T; o7 a9 J{
' |/ u. }& |0 i& P4 { "ISBN": "987-1-4302-3051-9",
1 e6 E* n: p: C0 H8 {! n A "Type": "Book",4 ?9 J3 W" @( t& q% P+ L
"Title": "Definite Guide to MongoDB: The NoSQL Database",
- p0 X- M1 S' r/ m "Publisher": "Apress",( R' Z" b# r+ P: e) P6 e9 V. ?
"Author": " Eelco Plugge",, t4 J1 E. W6 p
"Releasedate": "2011.06.09"
; G2 j! p# r, q5 C. }}' e( R1 } j; @& {0 P( y, j+ @
9 {% F/ A1 R0 T& w) _# d7 W
假如,在同一个 collection 中的所有 document,都包含某个共同的 field,例如前例中的“ISBN”,那么我们就可以按照这个 field 的值,来分割 collection。这个 field 的值,又称为 shard key。
, t7 P+ `. O& i3 v
5 ?) ~4 e% W) ]; |* C 在选择shard key的时候,一定要确保这个key能够把collection均匀地切分成很多chunks。1 w7 c) h/ n3 \$ h! ~3 s; K g& V. H# a
* h0 u* k s: P5 N; h
例如,如果我们选择“author”作为shard key,如果有大量的作者是重名的,那么就会有大量的数据聚集在同一个chunk中。当然,假设很少有作者同名同姓,那么“author”也可以作为一个shard key。换句话说,shard key 的选择,与使用场景密切相关。
/ [. C; _6 y* K5 g6 p+ T
5 O* k2 Q/ ~8 N2 U( h 很多情况下,无论选择哪一个单一的 field 作为shard key,都无法均匀分割 collection。在这种情况下,我们可以考虑,用多个 fields,构成一个复合的shard key。0 T$ n9 @, N. ?
% ]8 |8 o; h) T( {7 h2 L 延续前例,假如有很多作者同名同姓,他们都叫“王二”。用 author 作为 shard key,显然无法均匀切割 collection。这时我们可以加上release-date,组成name-date的复合 shard key,例如“王二 2011”。
# |- B ?; Z% r1 A' k
, F4 |6 x% l3 zChunks. N$ l8 X: w; Y. A0 O
- }" S% N' P A" r! V
MongoDB按 shard key,把 collection切割成若干 chunks。每个 chunk 的数据结构,是一个三元组,{collection,minKey,maxKey},如图1-2 所示。
: H! G) E( B; A7 r0 T- N& |6 D! z$ S0 k/ o
( ]+ s. q1 O: W7 U图1-2 chunk的三元组 9 }& M% X8 s, P& t& _$ w2 R: n
* o" g6 I6 r" I* Z) }& i 其中,collection 是数据库中某一个表的名称,而 minKey 和 maxKey 是 shard key的范围。每一个 document 的shard key 的值,决定了这条document应该存放在哪个chunk中。
2 L3 V9 d( K1 l0 s
; W/ o$ Q7 G9 V! L1 S8 K" [ 如果两条 documents 的 shard keys 的值很接近,这两条 documents 很可能被存放在同一个 chunk 中。* } g! w! I; S5 ]/ m! f6 b% O j2 Q
+ E. {8 I( y1 Y3 M; \! A$ u Shard key 的值的顺序,决定了 document 存放的 chunk。在 MongoDB 的文献中,这种切割 collection 的方式,称为order-preserving。 R9 N- R0 ?- D- @ a5 I
# f/ \+ o+ H- H9 F8 y. P$ M 一个 chunk最多能够存储64MB的数据。 当某个chunk存储的 documents包含的数据量,接近这个阈值时,一个chunk会被切分成两个新的chunks。
( O4 b/ g. S5 n7 l" P$ {' S# G0 P+ r+ a7 ?( Q7 E
当一个shard存储了过多的chunks,这个shard中的某些chunks会被迁移到其它 shard中。; i8 U7 K2 L3 ^5 T" X
* I: A' Q0 _4 V' H: w: v
这里有个问题,假如某一条 document 包含的数据量很大,超过 64MB,一个 chunk 存放不下,怎么办?在后续章节介绍 GridFS 时,我们会详细讨论。3 v3 z. Z; o2 l7 T: T
! e; Q8 R S0 t4 v9 c3 Z% ]/ PReplica set
9 s6 N F; Q1 a" f 1 e1 @ o& q% M4 V/ K. o% j
在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。# r' f% N8 H9 N7 l7 v
8 y+ i; e6 d' T
这个replica set包括一个primary DB和多个secondary DBs。为了数据的一致性,所有的修改(insert / update / deletes) 请求都交给primary处理。处理结束之后,再异步地备份到其他secondary中。
9 _3 C. `2 ~7 i/ {, D: X
' n6 U: U0 S" _8 w# M9 u' h4 [; D1 a Primary DB由replica set中的所有servers,共同选举产生。当这个primaryDB server出错的时候,可以从replica set中重新选举一个新的primaryDB,从而避免了单点故障。
+ l' ?# J o% t; T: T- `& W8 m, \2 v, `9 s5 m* Z
Replica set的选举策略和数据同步机制,确保了系统的数据的一致性。后文详述。* ]' G; T( ? V1 X+ l( K8 U
- |4 x& R) p7 P' k2 V( f) p
Config Server
' A0 W) [- Z8 K5 g6 d
8 T1 Z% d% y5 \8 X# P Config servers用于存储MongoDB集群的元数据 metadata,这些元数据包括如下两个部分,每一个shard server包括哪些chunks,每个chunk存储了哪些 collections 的哪些 documents。
8 o& N% i/ S( q" D/ z" A* p! |
+ ~5 P' K; U8 ]* u6 c+ q 每一个config server都包括了MongoDB中所有chunk的信息。* B8 r" x4 o) b
$ I9 \+ N& g% p& x& m8 w, X
Config server也需要 replication。但是有趣的是,config server 采用了自己独特的replication模式,而没有沿用 replica set。2 q' P s; R# v0 W* c0 d) i+ L
- v, L6 M8 q: t/ l& `/ M+ I 如果任何一台config server挂了,整个 config server 集群中,其它 config server变成只读状态。这样做的原因,是避免在系统不稳定的情况下,冒然对元数据做任何改动,导致在不同的 config servers 中,出现元数据不一致的情况。- o' t, G% f3 F; ^: v) I9 i
5 D m- ?+ P* \1 j F! g5 X
MongoDB的官方文档建议,配置3个config servers比较合适,既提供了足够的安全性,又避免了更多的config servers实例之间的数据同步,引起的元数据不一致的麻烦。; z3 M2 D9 S8 e% h2 ?: ]
. H8 I9 M# y0 _* c( F7 e7 @5 fMongos
- N, l, Q. }* `9 j+ W e: V3 J$ `% ^& U r" E" r/ g4 e- @
用户使用MongoDB 时,用户的操作请求,全部由mongos来转发。
. @. O$ p; F% ]/ g, H& y8 U* u6 H' C: |, J/ m" \. ]
当 mongos 接收到用户请求时,它先查询 config server,找到存放相应数据的shard servers。然后把用户请求,转发到这些 shard servers。当这些 shard servers完成操作后,它们把结果分别返回给 mongos。而当 mongos 汇总了所有的结果后,它把结果返回给用户。- _4 {0 k5 e7 M3 O7 j4 }+ x
+ g+ ~/ a) O% {7 H @/ M' Q8 a
Mongos每次启动的时候,都要到config servers中读取元数据,并缓存在本地。每当 config server中的元数据有改动,它都会通知所有的mongos。
, v r2 c: c) e
, B9 F7 b) U1 O+ N9 ?1 L Mongos之间,不存在彼此协同工作的问题。因此,MongoDB所需要配置的mongos server的数量,没有限制。
* I1 h9 @+ s) z$ b4 J& s
) ? R$ `' b3 ~ 通过以上的介绍,我们对每个组成部分都有了基本的了解,但是涉及到工作的细节,我们尚有诸多疑问,例如,一个chunk的数据太大,如何切分?一个shard数据太多,如何迁移?在replica set中,如何选择primary?server挂了,怎么进行故障恢复?接下来的章节,我们逐个回答这些问题。% W( K! z6 W* U, T. O e1 V$ ]$ w$ Q8 b
1 }, n7 \* Q& ^7 w' e& o5 i
, a0 C# m4 o( D" ^( O0 M; uReference,- h2 E+ X" R( ~: {+ F* o ]
; E3 E" E1 S% K4 s6 v[0] Architectural Overview
7 D/ g) r/ W, p! Qhttp://www.mongodb.org/display/DOCS/Sharding+Introduction
7 s1 q* k @5 {5 Z0 J) N- M* G |
评分
-
查看全部评分
|