|
|
关于MongoDB,我们能看到的资料,基本都是在指导大家如何使用MongoDB,但是,MongoDB内部是如何运作的,资料不是很多。+ v" T; u9 I5 a, }( k
1 k% _+ i6 g6 ] v8 p2 P a 阅读使用手册,会有很多疑惑之处。例如,有人说,MongoDB 等同于分布式的 MySQL。它把一个Table ,按 row,分割成多个Shards,分别存放在不同的 Servers 上。这种说法是否正确?
' ?& \4 N* A, E. \ s/ d* C- T# J: a# T; f
不深入了解 MongoDB 的内部结构,就无法透彻地回答类似问题。这个系列文章,就来和大家探讨MongoDB的内部的工作方式。* S/ ?) m- L# {: z5 [3 i+ w
- t+ _( A0 G4 y0 v! c4 w8 a! x
n. i! L* r/ h- c2 a( E) t! @2 K
! q7 M2 g! X5 m
图1-1 MongoDB架构图 : ]2 @/ ]) W8 V
$ q7 ]* n2 L% ^4 l9 i
MongoDB 通常运行在一个服务器集群上,而不是一个单机。图1-1,描述了一个MongoDB集群的基本组成部分,包括若干shards,至少一个config server,至少一个routing servers(又称 mongos)。
7 _% T% h9 t/ u1 v/ H3 F
4 @% t7 C; X. Z& \Shards
* _) T( E# A& ~' D( [
) j8 p0 _6 s- I5 A0 K# {0 E MongoDB的最基本的数据单元,叫document,类似于关系式数据库中的行 row。一系列documents,组成了一个collection,相当于关系式数据库中的table。当一个 collection 数据量太大时,可以把该collection按documents切分,分成多个数据块,每个数据块叫做一个chunk,多个chunks聚集在一起,组成了一个shard。
: A! f" F& E$ L3 w) n1 q- v
5 f0 N: x) v$ u }! S1 R Sharding 的意义,不仅保障了数据库的扩容(scalability),同时也保障了系统的负载均衡(load balance)。
4 V% m4 _7 T* Z" G/ m/ z0 ^
& @4 v8 X, X ~1 c 每一个shard存储在一个物理服务器(server)上。Server上运行着mongod进程,通过这个进程,对shard中的数据进行操作,主要是增删改查。& L ?. e3 P. l; f3 P) V
: T$ @& I7 w, L/ H
如果系统中的每个shard,只存储了一份数据,没有备份,那么当这个shard所在的server挂了,数据就丢失了。在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。
% {( m( P9 L# P* S; b' A% [
! p0 ~( B- l8 J* S/ L, O+ XShard keys
- c8 c; C# f# q! |2 y. T7 M
6 g2 g+ P$ l7 G$ k. m# K! [7 _ 为了把collection切分成不同的chunks,从而存放到不同的shards中,我们需要制定一个切分的方式。
( I8 R8 @ Z( y# o# a+ D* @0 r) k- H& X4 u# U. @& w# ?8 [0 T
如前所述,在 MongoDB 数据库中,一个表collection由多个行 documents 组成,而每个 document,有多个属性 fields。同一个 collection 中的不同的 documents,可能会有不同的 fields。例如,有个 collection 叫 Media,包含两条 documents,
# m% q* T5 R' U& o7 x& f5 r$ z( ^$ x" k6 L. g# Q
{
1 {* U7 P/ }5 z "ISBN": "987-30-3652-5130-82",7 Q5 e9 Z+ x6 [3 q
"Type": "CD",
2 o, c( j% ?" ]6 c; v "Author": "Nirvana",: v; u" V; o) _
"Title": "Nevermind",
1 b7 V1 ~) n3 {2 I) E "Genre": "Grunge",
: H: X/ Y: x0 z( z6 b# Q) V8 M3 C "Releasedate": "1991.09.24",6 M- I/ W" |% Y+ G0 G9 a
"Tracklist": [& r! E4 z! P, i& b
{
7 S% \9 O/ {' v0 U- O "Track" : "1",- Y% o& ?+ R {& c4 L+ U/ o1 _
"Title" : "Smells like teen spirit",
3 H: p) A$ Q7 T" k9 m "Length" : "5:02"
) J0 V# Y; r5 B; Y },0 q4 }# i' W: }- M
{
1 H3 Q2 A7 ^* M9 r4 V "Track" : "2",
' H5 ~! K0 |" X4 C# D "Title" : "In Bloom",
" |7 N" q8 U# r* r+ O, p" \ "Length" : "4:15"; e' e5 l1 X: M! i" C
}+ z9 k0 w# `# t3 M9 {
]
$ f$ Z) Y R1 K G8 M}
$ l$ u, B. F& Q, c! a/ x
! o4 \3 o6 o1 w$ K{3 [" @0 f1 J3 f9 L# j9 k1 D
"ISBN": "987-1-4302-3051-9",
8 _4 @2 V5 W- u& F1 U: M "Type": "Book",/ e* s: D6 O" f: q4 h+ y+ X0 d
"Title": "Definite Guide to MongoDB: The NoSQL Database",
( r: N9 \0 b" L( O "Publisher": "Apress",
# j$ i" O8 C3 t6 e" S5 u8 n "Author": " Eelco Plugge",
9 |9 _ o- P4 Q "Releasedate": "2011.06.09"( F1 y2 o: e" g- e% t
}. t9 S, n5 t6 F% N9 ~, r
& A9 i2 i! v3 F7 P0 d: M0 \ 假如,在同一个 collection 中的所有 document,都包含某个共同的 field,例如前例中的“ISBN”,那么我们就可以按照这个 field 的值,来分割 collection。这个 field 的值,又称为 shard key。/ H* z7 Z! E5 e7 B. Q- O, Q" h. N
& Z; C$ ^ m Q! ]: n. R" Z 在选择shard key的时候,一定要确保这个key能够把collection均匀地切分成很多chunks。2 b1 d* X* I$ {( e/ y, s& ]) {. x$ h
0 r! F0 B, l2 U& s; D% O }/ n 例如,如果我们选择“author”作为shard key,如果有大量的作者是重名的,那么就会有大量的数据聚集在同一个chunk中。当然,假设很少有作者同名同姓,那么“author”也可以作为一个shard key。换句话说,shard key 的选择,与使用场景密切相关。
7 Q3 ]6 B' t' p5 t0 h3 J( ` W. k; z, @6 i/ t) Q: |: Q: o& {5 y8 {
很多情况下,无论选择哪一个单一的 field 作为shard key,都无法均匀分割 collection。在这种情况下,我们可以考虑,用多个 fields,构成一个复合的shard key。
/ w3 w" m$ J: p; @# N" ?) S% K; [4 x: a
延续前例,假如有很多作者同名同姓,他们都叫“王二”。用 author 作为 shard key,显然无法均匀切割 collection。这时我们可以加上release-date,组成name-date的复合 shard key,例如“王二 2011”。
T8 o. _+ N: Z5 i+ I
: | [, Y) k; q$ p7 ]$ xChunks
) i4 t; a" E0 V' g & g* M% X4 p* V
MongoDB按 shard key,把 collection切割成若干 chunks。每个 chunk 的数据结构,是一个三元组,{collection,minKey,maxKey},如图1-2 所示。3 I$ ~. {' O @, j+ Z
$ s/ {6 e8 ]3 ~, T
& G) A" Z6 t! ?
图1-2 chunk的三元组 / g5 Y- k; d% y8 K+ P1 o1 l! ]
" M3 g$ O' Y2 t: x' J8 Y4 m
其中,collection 是数据库中某一个表的名称,而 minKey 和 maxKey 是 shard key的范围。每一个 document 的shard key 的值,决定了这条document应该存放在哪个chunk中。
7 s$ K" J0 I2 T% O; [' b Q. R, q: d& f/ `! r1 y+ ^' C5 |
如果两条 documents 的 shard keys 的值很接近,这两条 documents 很可能被存放在同一个 chunk 中。
% d) q/ d0 x$ A5 H
- y1 ]2 G, h) T# j- U( ]6 a Shard key 的值的顺序,决定了 document 存放的 chunk。在 MongoDB 的文献中,这种切割 collection 的方式,称为order-preserving。
, t- F, J# ^8 ^1 H. d! r! A9 n0 _' L9 I7 p0 u8 V# G: e
一个 chunk最多能够存储64MB的数据。 当某个chunk存储的 documents包含的数据量,接近这个阈值时,一个chunk会被切分成两个新的chunks。
) g/ C |0 o% }7 S ~' @1 s/ r' |5 [5 @
当一个shard存储了过多的chunks,这个shard中的某些chunks会被迁移到其它 shard中。/ E) _7 o! ]8 O! x8 j8 z) P
2 f: T" o% K( I3 P1 V- U" Y
这里有个问题,假如某一条 document 包含的数据量很大,超过 64MB,一个 chunk 存放不下,怎么办?在后续章节介绍 GridFS 时,我们会详细讨论。% m6 e$ F6 Y% A6 ?, z
) W8 j4 U4 @/ N' }, M) i% AReplica set
6 Y. [* ^4 w9 ~' i
8 n; `. K8 H V! L; W 在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。, E' Z0 B; V7 l3 p* F
# _8 L1 p8 k, d/ Z/ P, J, D 这个replica set包括一个primary DB和多个secondary DBs。为了数据的一致性,所有的修改(insert / update / deletes) 请求都交给primary处理。处理结束之后,再异步地备份到其他secondary中。' N0 C3 s- i" O1 M5 S
: |- q# V* X- Y5 E5 `4 w8 I9 a b Primary DB由replica set中的所有servers,共同选举产生。当这个primaryDB server出错的时候,可以从replica set中重新选举一个新的primaryDB,从而避免了单点故障。
A T6 g: l) s, P3 h% ^, M4 c% U& J
Replica set的选举策略和数据同步机制,确保了系统的数据的一致性。后文详述。, w" r' P! l( ?0 E- K3 J3 Z
6 L$ i! @, _9 J8 L/ ~" @Config Server6 i" i" S' N+ |2 P$ E' r
" F7 }3 I- Z7 Z+ L
Config servers用于存储MongoDB集群的元数据 metadata,这些元数据包括如下两个部分,每一个shard server包括哪些chunks,每个chunk存储了哪些 collections 的哪些 documents。 e0 d. F- |) `& \+ G
3 P8 B+ l {7 }4 d 每一个config server都包括了MongoDB中所有chunk的信息。
7 b* r3 ~ c2 Q% M( ?' x( F4 a- {" h( e
Config server也需要 replication。但是有趣的是,config server 采用了自己独特的replication模式,而没有沿用 replica set。4 c/ |: F2 j. ?2 \- j
% }; J! g0 {4 @3 j- q5 g
如果任何一台config server挂了,整个 config server 集群中,其它 config server变成只读状态。这样做的原因,是避免在系统不稳定的情况下,冒然对元数据做任何改动,导致在不同的 config servers 中,出现元数据不一致的情况。) S; m T7 l$ L" D, u0 a1 h
* a0 U9 p. L/ Q- C* K MongoDB的官方文档建议,配置3个config servers比较合适,既提供了足够的安全性,又避免了更多的config servers实例之间的数据同步,引起的元数据不一致的麻烦。! |( U/ Q/ ?' K' p
# r5 `, B2 q! V2 T$ S( c# r; CMongos
- c, {* S: S% \6 }0 Z8 b
& x" ^+ W/ `( e, _. ~& a, x 用户使用MongoDB 时,用户的操作请求,全部由mongos来转发。
/ W7 ?& B5 l' t' F9 |: F* l, q& z3 e4 F* G8 T
当 mongos 接收到用户请求时,它先查询 config server,找到存放相应数据的shard servers。然后把用户请求,转发到这些 shard servers。当这些 shard servers完成操作后,它们把结果分别返回给 mongos。而当 mongos 汇总了所有的结果后,它把结果返回给用户。 f* R9 Y7 N. T
K% G( S9 p: z3 L# g
Mongos每次启动的时候,都要到config servers中读取元数据,并缓存在本地。每当 config server中的元数据有改动,它都会通知所有的mongos。! M3 d% k% W- ]. {# E
+ Y, a2 A- _& v( R
Mongos之间,不存在彼此协同工作的问题。因此,MongoDB所需要配置的mongos server的数量,没有限制。
/ [; N, f2 D+ B8 r: H7 L! b( _+ n# Z
通过以上的介绍,我们对每个组成部分都有了基本的了解,但是涉及到工作的细节,我们尚有诸多疑问,例如,一个chunk的数据太大,如何切分?一个shard数据太多,如何迁移?在replica set中,如何选择primary?server挂了,怎么进行故障恢复?接下来的章节,我们逐个回答这些问题。8 j% d, N9 |% I; |
- k/ P5 m2 \: ^: q: D
- u) e( ~6 o1 t
Reference,
2 K4 ~" H! q/ E$ q `9 E+ d- y0 y7 q
7 o* k6 h4 U0 e5 d6 E( ][0] Architectural Overview/ W6 Q& G9 t8 W5 y5 N
http://www.mongodb.org/display/DOCS/Sharding+Introduction. l5 e' {; x, ]4 L
|
评分
-
查看全部评分
|