|
|
关于MongoDB,我们能看到的资料,基本都是在指导大家如何使用MongoDB,但是,MongoDB内部是如何运作的,资料不是很多。) x! b0 c2 i! E, u: b7 u
, U9 u9 w6 I) p' H6 a0 A7 z 阅读使用手册,会有很多疑惑之处。例如,有人说,MongoDB 等同于分布式的 MySQL。它把一个Table ,按 row,分割成多个Shards,分别存放在不同的 Servers 上。这种说法是否正确?
6 y/ o( O$ s0 N9 C# ^ x& J
0 \) n: Y* k# v 不深入了解 MongoDB 的内部结构,就无法透彻地回答类似问题。这个系列文章,就来和大家探讨MongoDB的内部的工作方式。9 R/ p7 M3 O0 l
+ t7 V6 [" a' m0 r* C( `* v
: H7 f, d. U( N5 g' W3 g$ P
6 H4 d& F& C. n# o图1-1 MongoDB架构图
" N! L% T: I7 M3 e
* e( Y0 ]2 ~2 }' S MongoDB 通常运行在一个服务器集群上,而不是一个单机。图1-1,描述了一个MongoDB集群的基本组成部分,包括若干shards,至少一个config server,至少一个routing servers(又称 mongos)。5 g* m$ g% z. A- A
/ O. Z& l# n/ o1 U4 |Shards7 G( V' F/ }) |! P
4 r; u F2 c: Q9 e) g' @% T5 x MongoDB的最基本的数据单元,叫document,类似于关系式数据库中的行 row。一系列documents,组成了一个collection,相当于关系式数据库中的table。当一个 collection 数据量太大时,可以把该collection按documents切分,分成多个数据块,每个数据块叫做一个chunk,多个chunks聚集在一起,组成了一个shard。: |2 r! o. e+ X% k% u+ k' i
# j* S; g9 O- ~' A5 b
Sharding 的意义,不仅保障了数据库的扩容(scalability),同时也保障了系统的负载均衡(load balance)。; B) r+ e$ u9 Y8 i0 K
+ H' D/ f7 K, O* d9 v1 \/ ]
每一个shard存储在一个物理服务器(server)上。Server上运行着mongod进程,通过这个进程,对shard中的数据进行操作,主要是增删改查。
! p' N1 H2 X9 z
0 X" i- }( a, |' x: W4 Q/ } 如果系统中的每个shard,只存储了一份数据,没有备份,那么当这个shard所在的server挂了,数据就丢失了。在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。5 \' ]& O$ ?# z a. x" s( O* D( y
8 H9 ]- w+ G4 I' b! \ E' b
Shard keys9 d% G! t/ O9 z7 R4 F8 W
/ E( t2 R V: h! f1 s 为了把collection切分成不同的chunks,从而存放到不同的shards中,我们需要制定一个切分的方式。
: w7 q' Z9 H( ]7 [% Z, W2 }/ u6 j9 G$ o/ T0 |9 I0 i/ U
如前所述,在 MongoDB 数据库中,一个表collection由多个行 documents 组成,而每个 document,有多个属性 fields。同一个 collection 中的不同的 documents,可能会有不同的 fields。例如,有个 collection 叫 Media,包含两条 documents," s3 H. I" K: _' c# G$ A
1 W7 q7 x! ~/ d4 s3 O0 X. ^
{
+ `" ~5 ^" G5 ?6 ?6 E "ISBN": "987-30-3652-5130-82",
( S& y- d4 ~& b, d "Type": "CD",
; p% D& X/ C$ [9 C "Author": "Nirvana",. m- V/ @: b* S# C; i Y4 {
"Title": "Nevermind",
* W0 V4 [# \) n9 U$ f" S "Genre": "Grunge",- W |9 m: T9 R a; m
"Releasedate": "1991.09.24",
1 u) L; l ^1 v6 a! v "Tracklist": [' d1 R& _2 A+ G6 B$ A j
{) v" Y, ^. k) h* H8 n1 K+ R8 n
"Track" : "1",
3 |3 g5 P- U$ D2 A$ ^# y2 l' { "Title" : "Smells like teen spirit",# P. L) g6 y% E1 X- k5 z% J
"Length" : "5:02"- R7 ]! Q8 j4 ?( @
},# S4 \" ?* m, M# i
{
- p6 Y' |6 }2 @6 y5 k: d' A "Track" : "2",( V4 I8 n, a3 v0 @
"Title" : "In Bloom",
9 E) q+ f5 m5 h" B5 }# Q$ u% K "Length" : "4:15"
7 w: M6 g0 `& \8 y# S. v }
1 D5 d" @8 Y* _3 I% l" X ]6 u+ e! G: G6 a7 C, \. c$ b6 q
}
4 C' U) f* g! f% `. V! H
# P7 A2 l6 y l7 F1 p( O8 }{7 {; t) G4 x' v& Q5 T
"ISBN": "987-1-4302-3051-9",
; t5 v) x7 D1 |; U$ G "Type": "Book",
, k* Z% H- u- ?# t+ O- V3 B "Title": "Definite Guide to MongoDB: The NoSQL Database",
7 a. j2 O T2 _& h0 E3 V "Publisher": "Apress",
$ u: ~/ ]. j1 O O. k" v1 p( | "Author": " Eelco Plugge",' w) z0 ]% T3 O* U
"Releasedate": "2011.06.09", u$ G1 @& v7 ~ P `
}+ z, k7 j7 S/ [* ~- A6 m' ]
' |7 H) m3 L9 c) |% l
假如,在同一个 collection 中的所有 document,都包含某个共同的 field,例如前例中的“ISBN”,那么我们就可以按照这个 field 的值,来分割 collection。这个 field 的值,又称为 shard key。# I! P0 B l5 W7 s8 i& u2 h
e Q% G4 p6 C9 `7 }
在选择shard key的时候,一定要确保这个key能够把collection均匀地切分成很多chunks。
/ g3 N% c- Y& c
/ W, t {# U: W9 M5 X% _; W4 o 例如,如果我们选择“author”作为shard key,如果有大量的作者是重名的,那么就会有大量的数据聚集在同一个chunk中。当然,假设很少有作者同名同姓,那么“author”也可以作为一个shard key。换句话说,shard key 的选择,与使用场景密切相关。
6 U! U2 q8 T# E( b6 h
$ T' {1 e+ Z1 \! n% B2 ?5 t- w 很多情况下,无论选择哪一个单一的 field 作为shard key,都无法均匀分割 collection。在这种情况下,我们可以考虑,用多个 fields,构成一个复合的shard key。( U8 K) Y. _( b5 O
8 o) X; b. b7 F# u" S) k 延续前例,假如有很多作者同名同姓,他们都叫“王二”。用 author 作为 shard key,显然无法均匀切割 collection。这时我们可以加上release-date,组成name-date的复合 shard key,例如“王二 2011”。
" D1 u/ V* h" j* @/ b$ A; e3 `2 I
8 C& T" |' f, L' i' R ?Chunks6 F$ N( ^( F+ @' e1 |& ]
$ }$ U, q( q5 C( k' H4 Y& _ MongoDB按 shard key,把 collection切割成若干 chunks。每个 chunk 的数据结构,是一个三元组,{collection,minKey,maxKey},如图1-2 所示。
3 B: t) X4 Y6 b t. w& q- O9 o- u' |' C: a$ d9 t' b2 f
9 P. N3 ^# b% o2 c8 J; Y5 W9 G
图1-2 chunk的三元组
+ Z: P/ i. a7 R: m8 n9 D2 k; G' i+ k6 {
; q1 e8 I- i: j6 p* D# w ~ 其中,collection 是数据库中某一个表的名称,而 minKey 和 maxKey 是 shard key的范围。每一个 document 的shard key 的值,决定了这条document应该存放在哪个chunk中。
) C' B* P% e+ s& P! U ]) Y. k1 ?: L) d8 o! G& \# R6 r
如果两条 documents 的 shard keys 的值很接近,这两条 documents 很可能被存放在同一个 chunk 中。) O2 g3 B6 m5 e, l( \
. r% ]0 s* s5 G3 {! {: U Shard key 的值的顺序,决定了 document 存放的 chunk。在 MongoDB 的文献中,这种切割 collection 的方式,称为order-preserving。
3 `) P4 X7 e9 L: c6 Y; B
" Q0 b+ U, ?8 K. _ 一个 chunk最多能够存储64MB的数据。 当某个chunk存储的 documents包含的数据量,接近这个阈值时,一个chunk会被切分成两个新的chunks。5 m8 l# X( ~1 J" C
% j0 ?7 r8 t2 d# \! I7 Q8 Y9 O
当一个shard存储了过多的chunks,这个shard中的某些chunks会被迁移到其它 shard中。
1 T# J. P7 y y. `0 }9 T% z7 u4 m' e- @9 @) _& `9 S
这里有个问题,假如某一条 document 包含的数据量很大,超过 64MB,一个 chunk 存放不下,怎么办?在后续章节介绍 GridFS 时,我们会详细讨论。
. Y% d2 r; g- Q+ ? H# g
( t. m* z$ C2 e3 Y' S+ ?Replica set
* ~' g1 \3 o) V- A" Z c9 Z
4 G2 m H3 j, y N 在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。5 I+ Q: h, G( l. l
9 ?. N- `- ?9 }$ H9 i9 K. L 这个replica set包括一个primary DB和多个secondary DBs。为了数据的一致性,所有的修改(insert / update / deletes) 请求都交给primary处理。处理结束之后,再异步地备份到其他secondary中。
; A6 H" f" ?; Y$ Z6 M, I3 w2 Q3 D" V8 n) ?* C( f
Primary DB由replica set中的所有servers,共同选举产生。当这个primaryDB server出错的时候,可以从replica set中重新选举一个新的primaryDB,从而避免了单点故障。
9 K9 b- X ^; M2 H8 d0 i, G6 L
! D8 A+ z' M& ~0 j- b! r Replica set的选举策略和数据同步机制,确保了系统的数据的一致性。后文详述。
( \, e3 e$ Q5 c- b! `* e! V' B9 ?3 {6 ~( A7 K5 e% g
Config Server8 V' {& X+ L0 }8 Y, a+ G
2 E) ?1 U! q5 q% r# q- G1 t* P$ C Config servers用于存储MongoDB集群的元数据 metadata,这些元数据包括如下两个部分,每一个shard server包括哪些chunks,每个chunk存储了哪些 collections 的哪些 documents。
: {% v6 x$ v! z, N9 t4 h- Z) b& j+ A, Z8 v- w2 [5 _0 f
每一个config server都包括了MongoDB中所有chunk的信息。) t, q# e4 `* u* r# u7 L
+ M- q' Z4 j7 ~7 C6 F Config server也需要 replication。但是有趣的是,config server 采用了自己独特的replication模式,而没有沿用 replica set。
$ h* Q0 H" [9 l6 s4 Q
9 H2 j- C6 n) {( i h! h 如果任何一台config server挂了,整个 config server 集群中,其它 config server变成只读状态。这样做的原因,是避免在系统不稳定的情况下,冒然对元数据做任何改动,导致在不同的 config servers 中,出现元数据不一致的情况。$ r/ }3 ?# q/ c' z8 Y
* J. L6 O3 Z8 i% D3 O
MongoDB的官方文档建议,配置3个config servers比较合适,既提供了足够的安全性,又避免了更多的config servers实例之间的数据同步,引起的元数据不一致的麻烦。8 e, x4 d$ } _' `4 E- ?# f% I1 G
# G; Y* }. ]' ~. G; rMongos
" m. F2 ], Y" B
% x' Z7 ~$ w: n( q0 }/ K" T 用户使用MongoDB 时,用户的操作请求,全部由mongos来转发。
2 a# T2 L2 c$ J4 e7 N( o' I4 v% i$ r3 f+ F
当 mongos 接收到用户请求时,它先查询 config server,找到存放相应数据的shard servers。然后把用户请求,转发到这些 shard servers。当这些 shard servers完成操作后,它们把结果分别返回给 mongos。而当 mongos 汇总了所有的结果后,它把结果返回给用户。
% R% ~# @- [2 x) q
0 {% B$ U0 G6 R, o6 n% F* W X Mongos每次启动的时候,都要到config servers中读取元数据,并缓存在本地。每当 config server中的元数据有改动,它都会通知所有的mongos。
; g0 s7 Z8 I) ]$ J1 a5 z4 a; C: G) z5 g
Mongos之间,不存在彼此协同工作的问题。因此,MongoDB所需要配置的mongos server的数量,没有限制。 ~4 y) k0 _( ~9 N$ w$ A
" C7 b) m4 `$ ~+ Z2 c. F, R; a( f 通过以上的介绍,我们对每个组成部分都有了基本的了解,但是涉及到工作的细节,我们尚有诸多疑问,例如,一个chunk的数据太大,如何切分?一个shard数据太多,如何迁移?在replica set中,如何选择primary?server挂了,怎么进行故障恢复?接下来的章节,我们逐个回答这些问题。
3 R4 E* l+ e# K( K3 Q$ Y' s; k" H2 F
& G$ J6 s2 R: h
Reference,! Q" `5 V( h W1 I `$ b6 W4 d1 `% h
+ s2 j. _4 ]$ z( a$ M0 j9 l/ o, s8 q[0] Architectural Overview
' ~, A: C2 o3 s+ z" i1 }http://www.mongodb.org/display/DOCS/Sharding+Introduction
! _" a4 ~5 ~3 } |
评分
-
查看全部评分
|