|
|
关于MongoDB,我们能看到的资料,基本都是在指导大家如何使用MongoDB,但是,MongoDB内部是如何运作的,资料不是很多。 q' a& P( ]$ q5 P1 e [' @
! K: ]) X$ i6 f+ C R 阅读使用手册,会有很多疑惑之处。例如,有人说,MongoDB 等同于分布式的 MySQL。它把一个Table ,按 row,分割成多个Shards,分别存放在不同的 Servers 上。这种说法是否正确?; y- v8 h/ P% p! M5 y9 F4 W/ r& ~
+ Z6 a. x, v$ D, L
不深入了解 MongoDB 的内部结构,就无法透彻地回答类似问题。这个系列文章,就来和大家探讨MongoDB的内部的工作方式。3 O- n; D2 i0 e! K
: o M3 K8 I& }
: a3 @' A. L3 S Z
% r d' t' R b- I' O图1-1 MongoDB架构图 9 c/ N3 C T+ O! Z, x
( E8 T! [1 _ u5 n1 E" T( m, J MongoDB 通常运行在一个服务器集群上,而不是一个单机。图1-1,描述了一个MongoDB集群的基本组成部分,包括若干shards,至少一个config server,至少一个routing servers(又称 mongos)。$ I2 N9 S0 G- T* n' X q7 ^5 I0 v
* `+ P( c: f7 Z fShards$ M. w6 n. y6 P! b
5 o% z5 Y" Z3 ^- d% {0 m. j MongoDB的最基本的数据单元,叫document,类似于关系式数据库中的行 row。一系列documents,组成了一个collection,相当于关系式数据库中的table。当一个 collection 数据量太大时,可以把该collection按documents切分,分成多个数据块,每个数据块叫做一个chunk,多个chunks聚集在一起,组成了一个shard。
4 b. O/ e6 y$ ~- Z) z h% j$ a7 {! l: W1 T5 O
Sharding 的意义,不仅保障了数据库的扩容(scalability),同时也保障了系统的负载均衡(load balance)。
; H7 m( A& ^+ ^8 D2 b1 b- Q& {
+ {+ R/ X: O g( z* g 每一个shard存储在一个物理服务器(server)上。Server上运行着mongod进程,通过这个进程,对shard中的数据进行操作,主要是增删改查。
* S' P* Y9 ~/ z5 @9 F# R- M6 j" m8 C3 G$ C" L
如果系统中的每个shard,只存储了一份数据,没有备份,那么当这个shard所在的server挂了,数据就丢失了。在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。
4 J' n% u, a' [* I+ ?; R, }/ R( j
0 \+ M4 X+ y8 v0 UShard keys. j* [. y1 ?2 l5 J4 g' [
& j& ~3 E' N0 Q$ X' i% W 为了把collection切分成不同的chunks,从而存放到不同的shards中,我们需要制定一个切分的方式。
3 q; U) H% }; m" T [
, s. {+ r6 j2 \) L- u 如前所述,在 MongoDB 数据库中,一个表collection由多个行 documents 组成,而每个 document,有多个属性 fields。同一个 collection 中的不同的 documents,可能会有不同的 fields。例如,有个 collection 叫 Media,包含两条 documents,
* R: ^3 @6 h* L2 P" {# p8 e
" ~$ Z$ W# N; J& g# t{9 t& a, P5 y( ?% r3 w
"ISBN": "987-30-3652-5130-82", H9 `9 O* Z+ O, r; W! o! l7 ~
"Type": "CD",+ j4 x" J% f2 g# c6 @, v. D
"Author": "Nirvana",
9 Y: |9 q Q7 s" N% n: } "Title": "Nevermind",$ }% J2 x( I8 Q% N' Q I
"Genre": "Grunge",0 d4 e2 M/ X& W9 g% v7 @
"Releasedate": "1991.09.24",7 u0 k0 F( w4 b) x- v
"Tracklist": [7 y L9 Z$ o) z4 J# [
{; \+ P& h# w% K2 @' X9 `0 ?
"Track" : "1",
* y8 z/ r& B" |1 D "Title" : "Smells like teen spirit",
8 A8 v3 }% t5 M3 K "Length" : "5:02" i; U6 I! z. Y2 ?6 A7 |
},
% l4 E. f5 m Z( C& a( ] {
* d4 m# G9 r7 P "Track" : "2",% v% r- {5 G/ Z- ^: j: c) F. {
"Title" : "In Bloom",
$ k; _8 n* q1 h7 X& [# L "Length" : "4:15". z# |& x$ v" ^3 @, l0 z J: J
}
7 H% O3 M3 B$ Z: O ]8 U5 E3 v$ T8 E
}! ^0 b) i, P2 y3 q' V3 h* ~9 [
5 o4 c8 Y3 c8 ^7 ?% Y8 d* n, o0 s; I{* p# o8 r- ^& d2 B
"ISBN": "987-1-4302-3051-9",; w* Z) w8 h2 \5 X. x6 J- [, T
"Type": "Book",; _( q2 @/ N4 ?1 H; H
"Title": "Definite Guide to MongoDB: The NoSQL Database",) s1 I: l( {4 T: ~* k+ I1 y, ]5 w
"Publisher": "Apress",
" G0 a0 q: r8 _2 n# U3 k5 ` "Author": " Eelco Plugge",4 ?( ]2 j1 m5 W/ N
"Releasedate": "2011.06.09"
" W, E7 u/ I J2 l( k9 h% F}
$ `: h7 X/ F- V4 \3 s5 ?4 I
1 Q" g1 W9 ?7 B, l 假如,在同一个 collection 中的所有 document,都包含某个共同的 field,例如前例中的“ISBN”,那么我们就可以按照这个 field 的值,来分割 collection。这个 field 的值,又称为 shard key。* n' Y" J" U g3 E5 T4 j
4 y/ H( c- r! y& q
在选择shard key的时候,一定要确保这个key能够把collection均匀地切分成很多chunks。
3 Z5 Z+ N3 s8 {# z H3 f2 y# ?2 K" `9 o; ~6 G) s
例如,如果我们选择“author”作为shard key,如果有大量的作者是重名的,那么就会有大量的数据聚集在同一个chunk中。当然,假设很少有作者同名同姓,那么“author”也可以作为一个shard key。换句话说,shard key 的选择,与使用场景密切相关。* S5 w( C! O3 ~5 h/ R# _
" U+ ~" O' c( u8 w. L2 x' j 很多情况下,无论选择哪一个单一的 field 作为shard key,都无法均匀分割 collection。在这种情况下,我们可以考虑,用多个 fields,构成一个复合的shard key。
6 }+ M: L; i( ~( I% T0 O0 O6 \7 X, R' t+ _; x0 f
延续前例,假如有很多作者同名同姓,他们都叫“王二”。用 author 作为 shard key,显然无法均匀切割 collection。这时我们可以加上release-date,组成name-date的复合 shard key,例如“王二 2011”。6 u4 v) P" Z: n+ |
0 F2 H1 w/ {: B- _$ d' p$ SChunks9 w/ M7 W# q/ m1 r" P! E2 j* Z
, c6 y, ^2 H T |6 {5 N MongoDB按 shard key,把 collection切割成若干 chunks。每个 chunk 的数据结构,是一个三元组,{collection,minKey,maxKey},如图1-2 所示。! O. _( w9 H, d" \7 q- e& K6 v
0 [7 c8 }! x) q! _6 r
. z* l4 x! z2 R5 m r2 D \9 X1 i图1-2 chunk的三元组 2 y; F$ G% o. ?! c5 w+ m8 \) t
& X9 A, _% r0 e6 m9 F: n+ c 其中,collection 是数据库中某一个表的名称,而 minKey 和 maxKey 是 shard key的范围。每一个 document 的shard key 的值,决定了这条document应该存放在哪个chunk中。
6 N6 [: w% w) _" @6 G# Z/ a
2 z& d+ U) w" {. d) y4 _ 如果两条 documents 的 shard keys 的值很接近,这两条 documents 很可能被存放在同一个 chunk 中。7 u# ^0 b0 j# S" K& j
G6 E4 y/ z+ k* i Shard key 的值的顺序,决定了 document 存放的 chunk。在 MongoDB 的文献中,这种切割 collection 的方式,称为order-preserving。
; E' [8 y, O& W! {- a$ Q4 d- C: W: k9 V) K0 r) i0 ^1 l* w
一个 chunk最多能够存储64MB的数据。 当某个chunk存储的 documents包含的数据量,接近这个阈值时,一个chunk会被切分成两个新的chunks。$ N% x8 \( c' m- v _
" A$ A- n1 V8 k# Q4 O: Q 当一个shard存储了过多的chunks,这个shard中的某些chunks会被迁移到其它 shard中。6 ~6 n$ y, P- f; x, k# N5 M6 n
* ^6 I2 h; ^1 o' ~; z
这里有个问题,假如某一条 document 包含的数据量很大,超过 64MB,一个 chunk 存放不下,怎么办?在后续章节介绍 GridFS 时,我们会详细讨论。; q8 ]5 A2 ^. H5 X
4 n- t5 f w. ?Replica set
8 {5 E5 j8 K9 U+ u U* K! l
) X* G) G3 j, e+ g! J 在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。$ ^4 ]6 W' q" O1 @+ V3 @/ T
i0 J3 x1 e0 p
这个replica set包括一个primary DB和多个secondary DBs。为了数据的一致性,所有的修改(insert / update / deletes) 请求都交给primary处理。处理结束之后,再异步地备份到其他secondary中。
6 B5 {/ C) C+ P2 M
; F. `0 c/ a% q9 f Primary DB由replica set中的所有servers,共同选举产生。当这个primaryDB server出错的时候,可以从replica set中重新选举一个新的primaryDB,从而避免了单点故障。/ v2 a) D# Y. G3 l5 @1 q$ [8 U% J: K
: O" K$ ~9 e! M, X1 G+ B( [2 r0 k: s Replica set的选举策略和数据同步机制,确保了系统的数据的一致性。后文详述。5 J: D5 `2 |0 P5 h% k/ D4 ]. D
- ~; w' U+ r8 Q% e: z/ ?6 A
Config Server
- I$ a) }) D) b0 w# A : |- m1 @# Y( U9 o- c4 [/ E
Config servers用于存储MongoDB集群的元数据 metadata,这些元数据包括如下两个部分,每一个shard server包括哪些chunks,每个chunk存储了哪些 collections 的哪些 documents。
! t4 S7 X7 r% s* |
/ z6 z- h) Y" t# P+ E 每一个config server都包括了MongoDB中所有chunk的信息。
8 y7 e/ X$ w; k( L7 S2 E. a
! @8 K) \; p: y \9 x2 R4 c Config server也需要 replication。但是有趣的是,config server 采用了自己独特的replication模式,而没有沿用 replica set。
# b# h* C, k& _- O, u3 x+ ?8 A7 c+ ?8 [+ @4 m& y
如果任何一台config server挂了,整个 config server 集群中,其它 config server变成只读状态。这样做的原因,是避免在系统不稳定的情况下,冒然对元数据做任何改动,导致在不同的 config servers 中,出现元数据不一致的情况。 c" _1 o0 u$ W
. t: b, c# z; `; G; g MongoDB的官方文档建议,配置3个config servers比较合适,既提供了足够的安全性,又避免了更多的config servers实例之间的数据同步,引起的元数据不一致的麻烦。
- x3 I, ]+ V( O/ X0 I
' F% o( |4 u: G. _2 h; rMongos* d' d! y" u' i4 {, E
# R( X* [* X: g1 t7 @
用户使用MongoDB 时,用户的操作请求,全部由mongos来转发。# w1 P3 l m% O- |/ w
3 P6 I0 Z1 s" F! J$ K
当 mongos 接收到用户请求时,它先查询 config server,找到存放相应数据的shard servers。然后把用户请求,转发到这些 shard servers。当这些 shard servers完成操作后,它们把结果分别返回给 mongos。而当 mongos 汇总了所有的结果后,它把结果返回给用户。$ k$ V* Y% j! [8 ^. X3 T9 B. T
) I* ?: H) ^1 D# Z( c
Mongos每次启动的时候,都要到config servers中读取元数据,并缓存在本地。每当 config server中的元数据有改动,它都会通知所有的mongos。
& B9 @) x- Z2 f( ]- y8 `* e
- U% f1 e7 c4 d Mongos之间,不存在彼此协同工作的问题。因此,MongoDB所需要配置的mongos server的数量,没有限制。
( v/ y/ b" A; {* ~1 I4 f3 x7 h* C* L3 l& _
通过以上的介绍,我们对每个组成部分都有了基本的了解,但是涉及到工作的细节,我们尚有诸多疑问,例如,一个chunk的数据太大,如何切分?一个shard数据太多,如何迁移?在replica set中,如何选择primary?server挂了,怎么进行故障恢复?接下来的章节,我们逐个回答这些问题。4 }: L; u- r# a, D" I7 h# X
5 u3 E$ y+ i7 ]6 t1 g7 b1 c( o4 k- x7 S: d1 w
Reference,
2 }0 u( C8 @, P2 P
5 N" B& w' q2 e9 R: E" k8 Y[0] Architectural Overview
5 x M% G1 w+ K* n" Z& B/ p, {http://www.mongodb.org/display/DOCS/Sharding+Introduction0 x$ j' x- }4 V3 m6 D+ W9 W
|
评分
-
查看全部评分
|