|
|
关于MongoDB,我们能看到的资料,基本都是在指导大家如何使用MongoDB,但是,MongoDB内部是如何运作的,资料不是很多。5 |% Q0 X" i3 ^4 Z) F- ]0 F
+ o% D* t% z) C8 P% _1 o 阅读使用手册,会有很多疑惑之处。例如,有人说,MongoDB 等同于分布式的 MySQL。它把一个Table ,按 row,分割成多个Shards,分别存放在不同的 Servers 上。这种说法是否正确?; [ J. R3 N0 D/ A4 t; c' R" i
; g$ z) M( N5 a" D9 _5 Y 不深入了解 MongoDB 的内部结构,就无法透彻地回答类似问题。这个系列文章,就来和大家探讨MongoDB的内部的工作方式。
9 B+ i) e* |: n6 ?7 Y7 E7 O5 b/ S) F% i' i% F; Z2 k! F" Q5 `+ K& F
c; ?8 N% i+ T. I5 ]% ^3 F
h" E5 s0 O8 f: p图1-1 MongoDB架构图 n$ S5 O) d+ J6 ?! m
2 I% b/ m0 Z, E1 U- Z0 q MongoDB 通常运行在一个服务器集群上,而不是一个单机。图1-1,描述了一个MongoDB集群的基本组成部分,包括若干shards,至少一个config server,至少一个routing servers(又称 mongos)。
( S( a; s4 z6 D& W
0 ]1 e) Y# k! U1 N& q- Z5 HShards& e) k9 o5 W. G4 X- a$ N7 b0 p
2 A/ N. X, |2 r$ `4 m1 f MongoDB的最基本的数据单元,叫document,类似于关系式数据库中的行 row。一系列documents,组成了一个collection,相当于关系式数据库中的table。当一个 collection 数据量太大时,可以把该collection按documents切分,分成多个数据块,每个数据块叫做一个chunk,多个chunks聚集在一起,组成了一个shard。; j$ L f& A' P% W
9 V# l& N" p8 _2 L/ h6 } Sharding 的意义,不仅保障了数据库的扩容(scalability),同时也保障了系统的负载均衡(load balance)。+ _8 p( D* Y8 ?5 s% E" A5 Q
3 H5 ^+ c! Q% t5 i: p8 c. b7 r 每一个shard存储在一个物理服务器(server)上。Server上运行着mongod进程,通过这个进程,对shard中的数据进行操作,主要是增删改查。! m/ p* J; N# R4 @. Q; r
# h2 T; [& y1 |/ M6 B6 L5 Z 如果系统中的每个shard,只存储了一份数据,没有备份,那么当这个shard所在的server挂了,数据就丢失了。在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。" H. O3 G9 A& t7 \' Q- h
1 j& p5 ]) A2 r3 bShard keys3 \ P) t9 o1 p% L8 `
0 ~" ^4 q# z6 P& ~
为了把collection切分成不同的chunks,从而存放到不同的shards中,我们需要制定一个切分的方式。
' ^( i+ t7 M. m* [# L$ ^4 I$ \9 v0 m8 A. J
如前所述,在 MongoDB 数据库中,一个表collection由多个行 documents 组成,而每个 document,有多个属性 fields。同一个 collection 中的不同的 documents,可能会有不同的 fields。例如,有个 collection 叫 Media,包含两条 documents,
6 P9 t' Y! j9 \, Q6 R" Y8 B, h0 u) f( t# o9 K) V( k' n
{
( D! W: R% v' Q0 k0 w "ISBN": "987-30-3652-5130-82",1 C% P1 }+ [5 B" }: C2 d3 B3 n* g
"Type": "CD",3 H, t% |9 D$ l5 }1 M- ~+ g
"Author": "Nirvana",
- Y2 A& q: F2 ~ ~7 {! h" ?% v "Title": "Nevermind",
J. ]1 O& U$ w. h P "Genre": "Grunge",
! _4 ?) `! Y$ I( o# @% U& y" J "Releasedate": "1991.09.24",
" i) C s3 v0 }! t "Tracklist": [, ?4 w4 a$ f8 o! |* v1 v, s
{
& t% N/ c# [; `9 ?/ C; r. ~ "Track" : "1",
- h, M) C2 _0 O* X; f4 I "Title" : "Smells like teen spirit",+ z3 ]( E! e0 A0 e% n
"Length" : "5:02"
/ o7 U" b0 E; ^5 b- { },
9 W" o! D3 e% m) H5 R- l {* U4 W2 Q1 V; m, R: W9 `4 O
"Track" : "2",
7 ]0 _! |2 j. }+ } j+ v "Title" : "In Bloom",$ N6 U x0 Q. C0 A# j) Y4 L' ^
"Length" : "4:15"& A; B2 F5 a$ \9 b$ D
}
: o" G1 o# L/ d" L8 A4 H' E! J ]
$ ?; G$ a) v* }}8 i2 y4 v/ u% _& d/ i Z" V
6 Q/ Z! V+ F4 b6 D1 L{) A2 X% ?! a9 S( _& _9 `# w
"ISBN": "987-1-4302-3051-9",
4 Q, h' e3 J! F3 F/ q8 l "Type": "Book",( ^7 ?: Q, U# ?: ?; S
"Title": "Definite Guide to MongoDB: The NoSQL Database",4 a* C$ m N3 n3 b( f' G
"Publisher": "Apress",
7 d3 M7 U4 o/ t9 H "Author": " Eelco Plugge",
7 o4 k! @( U ]5 k; \6 G& a9 r+ J; j "Releasedate": "2011.06.09"
- a1 w. }) W$ e7 i1 b3 i$ Z}3 f0 ` n4 k7 E. g' c& p
, d/ K, H* V2 y6 }6 q( f 假如,在同一个 collection 中的所有 document,都包含某个共同的 field,例如前例中的“ISBN”,那么我们就可以按照这个 field 的值,来分割 collection。这个 field 的值,又称为 shard key。/ U# Q$ o( E. z) `" p; X
" N2 H$ n j9 J8 m" W+ y7 t2 L# B% ?# A
在选择shard key的时候,一定要确保这个key能够把collection均匀地切分成很多chunks。7 r6 w& F# c# }# x5 D4 v% \6 H0 @7 c
- c0 ?2 Z# X1 b9 V5 Z5 I2 e
例如,如果我们选择“author”作为shard key,如果有大量的作者是重名的,那么就会有大量的数据聚集在同一个chunk中。当然,假设很少有作者同名同姓,那么“author”也可以作为一个shard key。换句话说,shard key 的选择,与使用场景密切相关。 N6 w, Q. _0 Z: E) k7 x
8 {$ g3 Z& G" A- h; H, J5 ? 很多情况下,无论选择哪一个单一的 field 作为shard key,都无法均匀分割 collection。在这种情况下,我们可以考虑,用多个 fields,构成一个复合的shard key。
$ X4 i. _% K+ F7 x8 l, \9 a) F" W; E7 @7 S" n0 \
延续前例,假如有很多作者同名同姓,他们都叫“王二”。用 author 作为 shard key,显然无法均匀切割 collection。这时我们可以加上release-date,组成name-date的复合 shard key,例如“王二 2011”。! f3 a; X/ D+ L, r5 q2 m: s
! h3 E- |6 J0 t2 N' A( bChunks( r$ F( ^2 q( o' b
" v- i: E: ^0 z
MongoDB按 shard key,把 collection切割成若干 chunks。每个 chunk 的数据结构,是一个三元组,{collection,minKey,maxKey},如图1-2 所示。
0 N4 P3 m4 [; M6 d& N% k/ H" O# \: O; d0 a5 [0 J4 P: W
[! c* L* K3 Z9 w! H' d
图1-2 chunk的三元组 ( B8 |* M9 G5 ^& E( y4 Q: x
5 I( V" _8 B" ]7 L4 Z. D 其中,collection 是数据库中某一个表的名称,而 minKey 和 maxKey 是 shard key的范围。每一个 document 的shard key 的值,决定了这条document应该存放在哪个chunk中。
6 A+ A0 @: E0 Q- ~3 Z* G. g! Y3 I$ h* O$ w9 W/ R
如果两条 documents 的 shard keys 的值很接近,这两条 documents 很可能被存放在同一个 chunk 中。' \) l. v6 O5 j% ]) r4 v( ]# s
9 _, v" D6 ?: N! C: \
Shard key 的值的顺序,决定了 document 存放的 chunk。在 MongoDB 的文献中,这种切割 collection 的方式,称为order-preserving。
" A: Z9 _" f0 y, j' o$ [7 M2 z0 l8 f: Z" t( f/ Q y- z2 p
一个 chunk最多能够存储64MB的数据。 当某个chunk存储的 documents包含的数据量,接近这个阈值时,一个chunk会被切分成两个新的chunks。0 Y3 H& \2 F7 ~ ^1 \
: H1 Z% t0 n0 h8 M 当一个shard存储了过多的chunks,这个shard中的某些chunks会被迁移到其它 shard中。
& K- h2 q# I* y/ A8 J4 a
) I7 |5 ?0 L+ b' {; D 这里有个问题,假如某一条 document 包含的数据量很大,超过 64MB,一个 chunk 存放不下,怎么办?在后续章节介绍 GridFS 时,我们会详细讨论。
7 R( E( O3 t" G! T' G) d
) O0 {5 \( B" ^+ t# i+ DReplica set! N5 D$ I' Y5 E* O, R. c
' N7 w* [+ U5 K# ]" ?
在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。. K: B, F1 q6 q7 m! ^! q
6 S, S3 w# [, z, C6 P
这个replica set包括一个primary DB和多个secondary DBs。为了数据的一致性,所有的修改(insert / update / deletes) 请求都交给primary处理。处理结束之后,再异步地备份到其他secondary中。
/ v- h6 T- `* \$ S G
/ b# ~/ I) R. h! C a6 { Primary DB由replica set中的所有servers,共同选举产生。当这个primaryDB server出错的时候,可以从replica set中重新选举一个新的primaryDB,从而避免了单点故障。
/ T" j* E, f* ]) f) H1 A: y# ~, d* `0 t) j- v8 j# d
Replica set的选举策略和数据同步机制,确保了系统的数据的一致性。后文详述。
) n- M4 P( \; K0 j0 a; p* `% l9 w4 ^3 S' L# D& Z0 y
Config Server
8 `* @6 M9 ~% O8 C3 P, w( y- U
7 _' K6 ]% f3 V! H: S Config servers用于存储MongoDB集群的元数据 metadata,这些元数据包括如下两个部分,每一个shard server包括哪些chunks,每个chunk存储了哪些 collections 的哪些 documents。
. B9 L# A! e# g- _8 P: P7 t, O0 w) x: k
3 y) L5 l! F$ b% Q3 l) V4 j& z. F 每一个config server都包括了MongoDB中所有chunk的信息。. g h: |. Y5 b6 F* c; p
( V: @. i9 }7 T7 p- H$ j1 f# J Config server也需要 replication。但是有趣的是,config server 采用了自己独特的replication模式,而没有沿用 replica set。
5 |- ~0 r: b F4 n$ `6 z+ R/ p( |# y0 ?3 [. ~6 T% B
如果任何一台config server挂了,整个 config server 集群中,其它 config server变成只读状态。这样做的原因,是避免在系统不稳定的情况下,冒然对元数据做任何改动,导致在不同的 config servers 中,出现元数据不一致的情况。% ` u1 g* z2 }
3 [! J$ }) n/ s5 e6 }+ C
MongoDB的官方文档建议,配置3个config servers比较合适,既提供了足够的安全性,又避免了更多的config servers实例之间的数据同步,引起的元数据不一致的麻烦。) h( z' X, |: w$ }' g9 }* q6 o
& f# S4 B% X7 u4 NMongos
( E5 N( ]/ y' T7 v$ m7 W2 g$ ^; S1 \5 K5 f2 a8 b. l
用户使用MongoDB 时,用户的操作请求,全部由mongos来转发。" y. V2 ]( }7 p) p7 `
* j; @8 b; o% L# L1 f ?* W
当 mongos 接收到用户请求时,它先查询 config server,找到存放相应数据的shard servers。然后把用户请求,转发到这些 shard servers。当这些 shard servers完成操作后,它们把结果分别返回给 mongos。而当 mongos 汇总了所有的结果后,它把结果返回给用户。4 O( e7 S7 r/ ?* j, r9 R# u$ w
" G) x2 W2 [3 B# H" v Mongos每次启动的时候,都要到config servers中读取元数据,并缓存在本地。每当 config server中的元数据有改动,它都会通知所有的mongos。
" l7 q5 j! T1 c$ z) q! P$ y. g; a0 a/ s0 o3 b" E/ y' M! A
Mongos之间,不存在彼此协同工作的问题。因此,MongoDB所需要配置的mongos server的数量,没有限制。
" J, K) R0 u2 U* y- f9 \4 s3 Z+ O8 U+ y5 [1 s
通过以上的介绍,我们对每个组成部分都有了基本的了解,但是涉及到工作的细节,我们尚有诸多疑问,例如,一个chunk的数据太大,如何切分?一个shard数据太多,如何迁移?在replica set中,如何选择primary?server挂了,怎么进行故障恢复?接下来的章节,我们逐个回答这些问题。
% @. s4 O* S! j3 _! s
0 |2 W, f, {, G- e. X- R" R8 }! o, o; t& }! m5 u8 j% ~# t U
Reference,
# K9 y8 A) [# \
' {- E9 W* j$ a$ M[0] Architectural Overview& y6 C" A3 }' {& Y/ k9 ?, i, S
http://www.mongodb.org/display/DOCS/Sharding+Introduction
+ w; i8 E2 F! j: z* d& u3 T |
评分
-
查看全部评分
|