|
关于MongoDB,我们能看到的资料,基本都是在指导大家如何使用MongoDB,但是,MongoDB内部是如何运作的,资料不是很多。: V! L- t# k: z. N
j. _8 s" j2 `7 Q/ x0 Y
阅读使用手册,会有很多疑惑之处。例如,有人说,MongoDB 等同于分布式的 MySQL。它把一个Table ,按 row,分割成多个Shards,分别存放在不同的 Servers 上。这种说法是否正确?% m5 U( v0 K5 `% g- W
# [! _" }( f9 F3 A1 a; N( D) C( x2 ]
不深入了解 MongoDB 的内部结构,就无法透彻地回答类似问题。这个系列文章,就来和大家探讨MongoDB的内部的工作方式。
$ F9 W5 K9 H, \/ k7 ~
& Q* Y* L( o' a1 I* u
3 a- X; a& ~# y1 m2 ], O* @
# J% x% c( [+ [0 o; B: Y3 t图1-1 MongoDB架构图 . ]5 ^: d, V4 z9 }& }
* N+ }$ G( S* B MongoDB 通常运行在一个服务器集群上,而不是一个单机。图1-1,描述了一个MongoDB集群的基本组成部分,包括若干shards,至少一个config server,至少一个routing servers(又称 mongos)。. d$ c3 c% J' K7 }+ b" [6 X
5 @' ~) a# H/ Y
Shards. n; l' j0 M4 y6 Z# J" D, l
/ F" s# W! q# o$ i
MongoDB的最基本的数据单元,叫document,类似于关系式数据库中的行 row。一系列documents,组成了一个collection,相当于关系式数据库中的table。当一个 collection 数据量太大时,可以把该collection按documents切分,分成多个数据块,每个数据块叫做一个chunk,多个chunks聚集在一起,组成了一个shard。
- r& P( `2 y8 r& y( x8 y0 h- T4 A; a/ `7 U) E( |2 t* H7 Y+ O
Sharding 的意义,不仅保障了数据库的扩容(scalability),同时也保障了系统的负载均衡(load balance)。
. H5 {( w, \8 j6 s5 n% l3 Y, H/ ?8 Z; {
每一个shard存储在一个物理服务器(server)上。Server上运行着mongod进程,通过这个进程,对shard中的数据进行操作,主要是增删改查。
4 A% c. r# U: k$ I! m* E# Y) p- M. y; P1 y; U7 L
如果系统中的每个shard,只存储了一份数据,没有备份,那么当这个shard所在的server挂了,数据就丢失了。在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。
7 b& G3 |' k+ {/ e8 \6 p! N+ D5 O' Z- `$ R0 L5 T# M
Shard keys
* m$ a6 F' ^. [8 O4 b$ f . _, M7 ^; q5 S* k7 ^
为了把collection切分成不同的chunks,从而存放到不同的shards中,我们需要制定一个切分的方式。* ^+ @4 W( O4 ^; l. U& n% L
/ F4 O4 r, ^4 y/ A/ a# @
如前所述,在 MongoDB 数据库中,一个表collection由多个行 documents 组成,而每个 document,有多个属性 fields。同一个 collection 中的不同的 documents,可能会有不同的 fields。例如,有个 collection 叫 Media,包含两条 documents,
9 l; v m) e; b2 |, F, p: d/ t' B, ~9 P! L. Z
{. ~; e2 n. i) \/ s0 z. o
"ISBN": "987-30-3652-5130-82",
# L: H$ Z# _2 A "Type": "CD",
; ^/ @8 I: c4 Z- N1 I$ Z "Author": "Nirvana",
" j I1 k! h2 V; T& y, q "Title": "Nevermind",
" a* |5 M. K. q6 D: I "Genre": "Grunge",# z9 s, ^" b" L: L: o8 @1 v. S
"Releasedate": "1991.09.24",0 [- d( N' @/ F3 T9 K) \) i' ~% A! Y
"Tracklist": [$ O& {! V$ W- b! P& R
{- A" j8 v) m" |
"Track" : "1",
) |( v4 @7 A' L2 Y E$ \' y' X "Title" : "Smells like teen spirit",
6 \. y( ?/ L# L; I$ u/ Y- l1 m, D5 i% _ "Length" : "5:02"! f# i% O4 b6 p7 A0 `. R) u
},1 H: }& f7 {# ~6 B* h2 p- y
{ |( J: j( m9 ?4 m. C7 F
"Track" : "2",
. D+ L" p% k, {4 t "Title" : "In Bloom",
5 Q) ]% f6 K- t8 t) x( t "Length" : "4:15", u, C/ D2 O' N5 _" n" ?
}- H+ x, F# g! s
]" T" a! N) J) F j- x# p/ r3 a
}4 o6 }- |7 d1 S" @' U+ u
' w2 {' x8 {, g; j+ \) A$ O! K& Q
{
! B S) Q' J, z6 g V "ISBN": "987-1-4302-3051-9",
) j. O) D. V( |3 U/ i* r "Type": "Book",
7 Y9 {* s. P, @/ T "Title": "Definite Guide to MongoDB: The NoSQL Database",# v T5 U: p6 e
"Publisher": "Apress",
1 }" V* z" q8 C "Author": " Eelco Plugge",: q& Y- k8 W; k7 u4 }4 j2 B
"Releasedate": "2011.06.09"/ }9 U: \# A% ]0 o- K, V
}
* A9 ]- y# q5 |$ U1 U& E( E* l, b# v+ K& d) Q0 X, k6 A% ?
假如,在同一个 collection 中的所有 document,都包含某个共同的 field,例如前例中的“ISBN”,那么我们就可以按照这个 field 的值,来分割 collection。这个 field 的值,又称为 shard key。
8 L, @* k' R$ R6 j
9 q- K7 J0 v+ ^ 在选择shard key的时候,一定要确保这个key能够把collection均匀地切分成很多chunks。
' l- i- x* \1 t& M, m6 o4 k' J! B4 M1 \; }
例如,如果我们选择“author”作为shard key,如果有大量的作者是重名的,那么就会有大量的数据聚集在同一个chunk中。当然,假设很少有作者同名同姓,那么“author”也可以作为一个shard key。换句话说,shard key 的选择,与使用场景密切相关。5 k; {: I# D3 k( x4 }
$ c5 i& q" Z7 G2 b 很多情况下,无论选择哪一个单一的 field 作为shard key,都无法均匀分割 collection。在这种情况下,我们可以考虑,用多个 fields,构成一个复合的shard key。1 X$ B ~+ @( n. l% X$ P/ q t
) z+ x+ l1 `8 \' I: h 延续前例,假如有很多作者同名同姓,他们都叫“王二”。用 author 作为 shard key,显然无法均匀切割 collection。这时我们可以加上release-date,组成name-date的复合 shard key,例如“王二 2011”。! l) I u3 _! x% X3 U# e
J0 W: z+ ?6 y0 h- Y
Chunks% X: L6 G0 W- l: p+ g5 ~' _
0 e3 c9 a- s# d5 s
MongoDB按 shard key,把 collection切割成若干 chunks。每个 chunk 的数据结构,是一个三元组,{collection,minKey,maxKey},如图1-2 所示。
, t3 [4 ~( ~) ?( d7 ?( r" y4 Z
& B# h/ b6 U3 j/ [3 }
! d e# a. |5 {, D; b% x+ A
图1-2 chunk的三元组 & `" A" c: C' ^" W
; J- \4 F- g# j, A* z# Q# J4 R 其中,collection 是数据库中某一个表的名称,而 minKey 和 maxKey 是 shard key的范围。每一个 document 的shard key 的值,决定了这条document应该存放在哪个chunk中。
7 C* v% L2 k$ N
& w1 P3 k S6 c S( y 如果两条 documents 的 shard keys 的值很接近,这两条 documents 很可能被存放在同一个 chunk 中。- F" ]0 m9 u+ N, P7 A; @& F
2 G1 Y7 k2 D9 @5 z6 Z% w
Shard key 的值的顺序,决定了 document 存放的 chunk。在 MongoDB 的文献中,这种切割 collection 的方式,称为order-preserving。: H( r2 c! M" q" F6 w! J$ X+ ~
5 P- z6 l0 {3 X1 X# q7 C# S
一个 chunk最多能够存储64MB的数据。 当某个chunk存储的 documents包含的数据量,接近这个阈值时,一个chunk会被切分成两个新的chunks。1 K5 u: N* @2 Y& I6 A9 u" W# `
4 N+ x- \2 |. m9 Y1 W% e
当一个shard存储了过多的chunks,这个shard中的某些chunks会被迁移到其它 shard中。
2 y7 r9 l0 O& ?( [8 X7 p3 R# Y
这里有个问题,假如某一条 document 包含的数据量很大,超过 64MB,一个 chunk 存放不下,怎么办?在后续章节介绍 GridFS 时,我们会详细讨论。$ }) i: v3 y, ]. M8 M
' ~6 \# S/ p/ t- }
Replica set
0 X8 I( t Y* C, `0 |1 H- e- M 7 v' W7 _1 K% O% r' h4 \" T
在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。
0 O) l; U% Z+ G7 _% A+ {; {
2 `7 w. {* V& ^$ y0 \ 这个replica set包括一个primary DB和多个secondary DBs。为了数据的一致性,所有的修改(insert / update / deletes) 请求都交给primary处理。处理结束之后,再异步地备份到其他secondary中。
2 f( W1 b/ Z6 z+ l" k) t' @0 t
Primary DB由replica set中的所有servers,共同选举产生。当这个primaryDB server出错的时候,可以从replica set中重新选举一个新的primaryDB,从而避免了单点故障。
) g. P& r3 w2 }6 ?0 W; x, e! ?* ^% \& ~. W6 M, L4 Q
Replica set的选举策略和数据同步机制,确保了系统的数据的一致性。后文详述。) ~7 w& \6 d: |+ o
$ G8 y# J9 J1 T3 W& r7 `
Config Server
* g2 w/ o( k. m1 T. v" e& |# _
# m8 w- p# W1 }9 v- ^ Config servers用于存储MongoDB集群的元数据 metadata,这些元数据包括如下两个部分,每一个shard server包括哪些chunks,每个chunk存储了哪些 collections 的哪些 documents。( f9 s) ]2 S' D
$ K1 o! C; J0 s 每一个config server都包括了MongoDB中所有chunk的信息。
) J6 ^! _# O6 A; E& M7 L* J3 [1 E* d& G q8 V: D
Config server也需要 replication。但是有趣的是,config server 采用了自己独特的replication模式,而没有沿用 replica set。
' F3 j8 t2 a0 B4 z$ @5 }! U( d# N1 Y8 C1 W
如果任何一台config server挂了,整个 config server 集群中,其它 config server变成只读状态。这样做的原因,是避免在系统不稳定的情况下,冒然对元数据做任何改动,导致在不同的 config servers 中,出现元数据不一致的情况。
$ L; x6 a! z4 b# |- K: d( C6 ^: l- y* U
MongoDB的官方文档建议,配置3个config servers比较合适,既提供了足够的安全性,又避免了更多的config servers实例之间的数据同步,引起的元数据不一致的麻烦。
% x% G: D& a& I! n1 U# c# d8 u& J% _. X0 V s! J
Mongos
! e. q; Q- \0 g' {/ j- s5 b
$ d2 g( Y/ m, H7 j 用户使用MongoDB 时,用户的操作请求,全部由mongos来转发。
3 m' z' N& w8 M+ I9 H
* S g) {! H0 r ] | 当 mongos 接收到用户请求时,它先查询 config server,找到存放相应数据的shard servers。然后把用户请求,转发到这些 shard servers。当这些 shard servers完成操作后,它们把结果分别返回给 mongos。而当 mongos 汇总了所有的结果后,它把结果返回给用户。' B( k, [/ j" _8 V; o* F
. F7 W0 L* h* S9 v) h2 ], U
Mongos每次启动的时候,都要到config servers中读取元数据,并缓存在本地。每当 config server中的元数据有改动,它都会通知所有的mongos。
. d' g8 ?) t& ~
) Y* E- C, U4 k- @. V( Y; t Mongos之间,不存在彼此协同工作的问题。因此,MongoDB所需要配置的mongos server的数量,没有限制。* z, a- [2 Y" t( e% C: ~
- Q$ e) S. o; I p" d6 m
通过以上的介绍,我们对每个组成部分都有了基本的了解,但是涉及到工作的细节,我们尚有诸多疑问,例如,一个chunk的数据太大,如何切分?一个shard数据太多,如何迁移?在replica set中,如何选择primary?server挂了,怎么进行故障恢复?接下来的章节,我们逐个回答这些问题。/ {0 c( M e @
% [8 F/ M9 ~3 c. t4 A2 a) Y
$ _% U$ ~. ~( V6 x0 ?' \Reference,3 H# H7 I! R1 p, G1 b/ u7 r
5 S# Q% S, |# [4 L1 G/ w( I
[0] Architectural Overview4 m; J7 |8 j6 g
http://www.mongodb.org/display/DOCS/Sharding+Introduction7 u ]+ a$ \# }; Z1 _% G' @. x& A
|
评分
-
查看全部评分
|