|
|
关于MongoDB，我们能看到的资料，基本都是在指导大家如何使用MongoDB，但是，MongoDB内部是如何运作的，资料不是很多。
. q; Z! b1 ]! U1 _! X+ e
$ ~* {8 @( A* p9 ~9 C2 c! }/ Z 阅读使用手册，会有很多疑惑之处。例如，有人说，MongoDB 等同于分布式的 MySQL。它把一个Table ，按 row，分割成多个Shards，分别存放在不同的 Servers 上。这种说法是否正确？
+ Q* T! ]9 q; e# {! f& d* N3 l# ]2 p' s
不深入了解 MongoDB 的内部结构，就无法透彻地回答类似问题。这个系列文章，就来和大家探讨MongoDB的内部的工作方式。7 ^' T9 A$ u/ U7 {) m) Z% r
" X/ V- n& B# u
9 ~1 {8 a; ^$ t, s7 F
6 m: ?, Y! M) T' {+ B
图1-1 MongoDB架构图 * O) y1 P) x; i9 `9 W. C
1 u; ~5 ]4 n4 u& n5 `! q- s% J MongoDB 通常运行在一个服务器集群上，而不是一个单机。图1-1，描述了一个MongoDB集群的基本组成部分，包括若干shards，至少一个config server，至少一个routing servers（又称 mongos）。
# o1 r2 g* b: `" y/ V$ f3 p8 B( D# ~- l3 M' s& V7 K+ P3 m
Shards6 l* z8 |, v* T0 g" j3 {
' Q% b. J2 C9 S7 d7 L
MongoDB的最基本的数据单元，叫document，类似于关系式数据库中的行 row。一系列documents，组成了一个collection，相当于关系式数据库中的table。当一个 collection 数据量太大时，可以把该collection按documents切分，分成多个数据块，每个数据块叫做一个chunk，多个chunks聚集在一起，组成了一个shard。
% | n2 @) l0 p: v" L5 k: f" W. v$ ]# u( J. E! c
Sharding 的意义，不仅保障了数据库的扩容（scalability），同时也保障了系统的负载均衡（load balance）。
8 u' t x. B/ f+ t$ g* ~
% I8 ]# P" h+ Y; H" m' b& S8 e 每一个shard存储在一个物理服务器（server）上。Server上运行着mongod进程，通过这个进程，对shard中的数据进行操作，主要是增删改查。6 Z+ p) K9 P( a/ P% k/ @6 m8 c) c3 k2 A
2 h+ B5 _* j$ Z" {+ m 如果系统中的每个shard，只存储了一份数据，没有备份，那么当这个shard所在的server挂了，数据就丢失了。在生产环境中，为了保证数据不丢失，为了提高系统的可用性（availability），每一个shard被存储多份，每个备份所在的servers，组成了一个replica set。
9 }; Q) d4 K# P; h' {/ o
% f1 w2 M2 t+ P [" oShard keys
( C! d* b9 f, P+ L' l
+ f( S* U# J M% z 为了把collection切分成不同的chunks，从而存放到不同的shards中，我们需要制定一个切分的方式。
9 B+ W* x G, y5 L7 |- F; m
- L9 L) f n; o" N 如前所述，在 MongoDB 数据库中，一个表collection由多个行 documents 组成，而每个 document，有多个属性 fields。同一个 collection 中的不同的 documents，可能会有不同的 fields。例如，有个 collection 叫 Media，包含两条 documents，
/ K* o6 f' r5 \% s P( s& n
6 J& ^+ d7 Q+ M{" e8 E3 w7 r* _/ Y, S
"ISBN": "987-30-3652-5130-82",1 n5 o) X5 F" \9 t# ~
"Type": "CD",
/ F5 [% g& _" M, ] "Author": "Nirvana",
7 H6 w$ r( W4 {7 U3 ` _ m( V "Title": "Nevermind",
1 h6 M* G. [. j. g+ k4 n4 ]9 _" } "Genre": "Grunge",8 c' @# J- x+ \, ^6 z; l
"Releasedate": "1991.09.24",5 g; \7 `/ V. R* L, Q* u0 q
"Tracklist": [ d/ R. I5 z) f3 k
{
C( A! ^! S1 x1 Q' Y7 p' @) {! N "Track" : "1",$ n) @( c# {! H6 I
"Title" : "Smells like teen spirit",- v2 s3 g9 N6 J, L
"Length" : "5:02"; ^: ~" x8 P) }7 ?& R+ {
},
2 {- x6 P3 t) B1 W {& V% }4 d# n/ Y5 U# ^' Y( h# v7 R
"Track" : "2",
% F) ]% V" U- U1 `( @. ]6 x "Title" : "In Bloom",+ v2 d' ?" ]- o' [6 [/ |0 I) ^: _
"Length" : "4:15"- B ^5 o! |+ R5 _3 L4 g0 h3 u
}
8 o- C! T4 H4 a0 i9 p0 L P ]6 Q% P* ]$ T6 @
}- K6 H) T, e& r1 f) T
; o5 v; U, X7 D! H{* ` B: X: G! E7 O6 E. I L$ b
"ISBN": "987-1-4302-3051-9",
8 J. Y9 E$ w) H7 Q/ T0 ^& } "Type": "Book",
; M; ~' [ y# T9 `/ o4 l) l( w& q "Title": "Definite Guide to MongoDB: The NoSQL Database",
$ d+ O c3 o6 S' ? "Publisher": "Apress",
: @( C) v$ S" E% X' s; A. }" J4 j "Author": " Eelco Plugge",
; A; n6 p( ?) l- M, j! R( l "Releasedate": "2011.06.09"
, D) k" E, X0 L: h}5 p. j4 i7 i- {. B, \7 E x
/ ~7 @6 O# ~4 ]5 I
假如，在同一个 collection 中的所有 document，都包含某个共同的 field，例如前例中的“ISBN”，那么我们就可以按照这个 field 的值，来分割 collection。这个 field 的值，又称为 shard key。
; m! p' U! @; q! K4 X
4 g, E9 C5 \+ M: B& |9 \& E6 g 在选择shard key的时候，一定要确保这个key能够把collection均匀地切分成很多chunks。5 x7 a# u% y! N9 x& s/ V# h9 [
# w4 ]- l7 U J9 ^' O/ R( N# b: u% Y
例如，如果我们选择“author”作为shard key，如果有大量的作者是重名的，那么就会有大量的数据聚集在同一个chunk中。当然，假设很少有作者同名同姓，那么“author”也可以作为一个shard key。换句话说，shard key 的选择，与使用场景密切相关。
9 M3 }+ p' m; T. S/ G
! s' O0 t g+ O y7 Y I- M$ M 很多情况下，无论选择哪一个单一的 field 作为shard key，都无法均匀分割 collection。在这种情况下，我们可以考虑，用多个 fields，构成一个复合的shard key。+ M+ Z6 r* `/ @. _: Z+ b4 x; u
' ^" m6 M5 h$ V4 b- u
延续前例，假如有很多作者同名同姓，他们都叫“王二”。用 author 作为 shard key，显然无法均匀切割 collection。这时我们可以加上release-date，组成name-date的复合 shard key，例如“王二 2011”。
! b: y# f: j" L
/ J8 {0 v3 ]7 w! R& J* C+ S! ~# P; bChunks) l4 P* b7 I" T( s; r" |8 m
( Z" R" H$ X' |- R5 }, D MongoDB按 shard key，把 collection切割成若干 chunks。每个 chunk 的数据结构，是一个三元组，{collection，minKey，maxKey}，如图1-2 所示。
% Q( W/ u2 q5 S0 K6 h0 I/ I# K8 @! L- g6 Y
" q4 h$ P) F( o$ S5 P) S
图1-2 chunk的三元组 [5 B; t' Q1 V
/ w, {+ j& \) _; l' @: z1 Q. D
其中，collection 是数据库中某一个表的名称，而 minKey 和 maxKey 是 shard key的范围。每一个 document 的shard key 的值，决定了这条document应该存放在哪个chunk中。0 p; _ i- ^9 r$ |) Z
# e8 v$ u+ W Z: } k. G/ @, @
如果两条 documents 的 shard keys 的值很接近，这两条 documents 很可能被存放在同一个 chunk 中。
- \" K5 w. Q% @, }: ]5 m- j: W
" p/ I( v0 e& s: Y' a Shard key 的值的顺序，决定了 document 存放的 chunk。在 MongoDB 的文献中，这种切割 collection 的方式，称为order-preserving。
^& ^( R9 W9 L
/ V( Z" I% z" J1 t 一个 chunk最多能够存储64MB的数据。 当某个chunk存储的 documents包含的数据量，接近这个阈值时，一个chunk会被切分成两个新的chunks。
) c, J' C- o7 a( a
9 K1 N6 k' `- {, F 当一个shard存储了过多的chunks，这个shard中的某些chunks会被迁移到其它 shard中。
* I5 f4 Y9 V. r! J1 V8 D" v& ?9 w- c
这里有个问题，假如某一条 document 包含的数据量很大，超过 64MB，一个 chunk 存放不下，怎么办？在后续章节介绍 GridFS 时，我们会详细讨论。3 J7 q# Z; o6 Y# O# ^4 M. U R
, |/ @( h [- ~Replica set
) ~' B+ l; J0 l' M) m
/ N8 A# \- P5 t, ^ 在生产环境中，为了保证数据不丢失，为了提高系统的可用性（availability），每一个shard被存储多份，每个备份所在的servers，组成了一个replica set。& B* R, t" S* k/ A3 I1 o! O9 l
% o; T& A: h V- G
这个replica set包括一个primary DB和多个secondary DBs。为了数据的一致性，所有的修改(insert / update / deletes) 请求都交给primary处理。处理结束之后，再异步地备份到其他secondary中。/ d+ D: P6 Z9 ~
& @1 T% w9 u8 y; [ Primary DB由replica set中的所有servers，共同选举产生。当这个primaryDB server出错的时候，可以从replica set中重新选举一个新的primaryDB，从而避免了单点故障。
/ ]# i# y) {) P7 p
2 W! u6 ^: ? [& z" j Replica set的选举策略和数据同步机制，确保了系统的数据的一致性。后文详述。
: Q; H- x3 |7 R" r- d+ @# V# X& ^+ T% [, D5 {7 p
Config Server
) H' r: `; ]4 j- f4 _, s; @
t6 V0 F- j. L3 G$ h1 M2 j+ g( E Config servers用于存储MongoDB集群的元数据 metadata，这些元数据包括如下两个部分，每一个shard server包括哪些chunks，每个chunk存储了哪些 collections 的哪些 documents。4 h! Z/ F8 z$ P
% b/ K7 s, z$ g: p% H# J, |' v1 S 每一个config server都包括了MongoDB中所有chunk的信息。
3 a: d% R! R2 y) y% C f# R* x0 X$ c+ @. q# p
Config server也需要 replication。但是有趣的是，config server 采用了自己独特的replication模式，而没有沿用 replica set。: F( H0 f0 Q2 q1 E# l' q: e$ E
; y4 W6 S2 y/ ^7 U" y
如果任何一台config server挂了，整个 config server 集群中，其它 config server变成只读状态。这样做的原因，是避免在系统不稳定的情况下，冒然对元数据做任何改动，导致在不同的 config servers 中，出现元数据不一致的情况。
) v" K+ b' L0 M1 D |. D; b
% W C. P# Q! p* L3 F: { r MongoDB的官方文档建议，配置3个config servers比较合适，既提供了足够的安全性，又避免了更多的config servers实例之间的数据同步，引起的元数据不一致的麻烦。
" Q8 ~+ `7 m h4 F# J+ ~7 s9 n, ?" m
Mongos
/ G! q$ E! X8 B" y; h
2 T1 q! I2 o* [* K: R) G5 f 用户使用MongoDB 时，用户的操作请求，全部由mongos来转发。0 r U1 g' [/ x9 I9 Z( d
7 u6 j* c# @8 }9 v/ N
当 mongos 接收到用户请求时，它先查询 config server，找到存放相应数据的shard servers。然后把用户请求，转发到这些 shard servers。当这些 shard servers完成操作后，它们把结果分别返回给 mongos。而当 mongos 汇总了所有的结果后，它把结果返回给用户。
8 ? h6 j& d. k3 V0 t r
- D/ u, ~, z) B0 @% v, c9 P8 D- a Mongos每次启动的时候，都要到config servers中读取元数据，并缓存在本地。每当 config server中的元数据有改动，它都会通知所有的mongos。
0 y1 l* c+ l* X N/ M( L4 @& [# `3 q/ K. j
Mongos之间，不存在彼此协同工作的问题。因此，MongoDB所需要配置的mongos server的数量，没有限制。, U' T2 ]& r$ K( w) [
, y. [, ^1 k/ _0 V2 o 通过以上的介绍，我们对每个组成部分都有了基本的了解，但是涉及到工作的细节，我们尚有诸多疑问，例如，一个chunk的数据太大，如何切分？一个shard数据太多，如何迁移？在replica set中，如何选择primary？server挂了，怎么进行故障恢复？接下来的章节，我们逐个回答这些问题。
6 J6 U$ P# f, t8 M3 c6 Y8 L! s- Z5 a& W
! y5 @1 J2 B+ J3 ?; C
Reference，/ m; @5 ^$ p8 N" ?
$ D- v2 x- \6 \. R3 Y3 @# r[0] Architectural Overview
8 _5 g$ R/ }1 E2 |2 U8 {http://www.mongodb.org/display/DOCS/Sharding+Introduction9 N; U# V" m1 j% C8 H
|
评分
-
查看全部评分
|
雷达卡
发表于 2012-9-18 12:31:10
收藏
分享
淘帖
支持
反对
提升卡
置顶卡
沉默卡
喧嚣卡
变色卡
抢沙发
千斤顶
显身卡
楼主
已经给你变成正式会员了。
* H. H# @1 f- Y