|
|
关于MongoDB,我们能看到的资料,基本都是在指导大家如何使用MongoDB,但是,MongoDB内部是如何运作的,资料不是很多。
+ j) ]$ m! u2 v+ X# i: i
2 P1 h* i7 y+ E# p 阅读使用手册,会有很多疑惑之处。例如,有人说,MongoDB 等同于分布式的 MySQL。它把一个Table ,按 row,分割成多个Shards,分别存放在不同的 Servers 上。这种说法是否正确?) v# T7 \/ W7 y
9 Q r$ a/ X6 p
不深入了解 MongoDB 的内部结构,就无法透彻地回答类似问题。这个系列文章,就来和大家探讨MongoDB的内部的工作方式。8 v, v1 P5 K' K" @ S
$ Y' G8 s" i$ K8 j/ z! ]3 }
2 d& k2 R9 Z+ H3 |, ]
7 M* S$ A' d: E& k, V图1-1 MongoDB架构图 3 Y& L3 |/ g$ |& o% C+ _- q
2 R0 x' B, R' t) ]1 _ MongoDB 通常运行在一个服务器集群上,而不是一个单机。图1-1,描述了一个MongoDB集群的基本组成部分,包括若干shards,至少一个config server,至少一个routing servers(又称 mongos)。& z, f6 @3 V8 x& W# E& o5 J
' ~3 x. r3 H w. K" n8 x% ?
Shards0 ?% v& x; I; w+ A: _' p1 n" f; y
4 g7 z6 l6 B$ i+ b0 M MongoDB的最基本的数据单元,叫document,类似于关系式数据库中的行 row。一系列documents,组成了一个collection,相当于关系式数据库中的table。当一个 collection 数据量太大时,可以把该collection按documents切分,分成多个数据块,每个数据块叫做一个chunk,多个chunks聚集在一起,组成了一个shard。; S! I8 S% @8 v# k% k6 b3 L
5 J3 k" |; E; H( {) O Sharding 的意义,不仅保障了数据库的扩容(scalability),同时也保障了系统的负载均衡(load balance)。
* D8 l' s: C& K7 _4 I" t* ?/ a* ?
每一个shard存储在一个物理服务器(server)上。Server上运行着mongod进程,通过这个进程,对shard中的数据进行操作,主要是增删改查。 E$ F- N2 K2 r ]) }# F
1 Z; V& O/ ]4 k$ B" S( k
如果系统中的每个shard,只存储了一份数据,没有备份,那么当这个shard所在的server挂了,数据就丢失了。在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。
! Y6 \ o* n- u
M9 n7 [, O- XShard keys
! {+ J0 j' v$ C1 [) ~ . I* i% a/ |- c. F$ ^* O
为了把collection切分成不同的chunks,从而存放到不同的shards中,我们需要制定一个切分的方式。
* h& ~ j- \, h( O3 s+ V0 J1 h& h% \* ]# l' \( o6 D1 W
如前所述,在 MongoDB 数据库中,一个表collection由多个行 documents 组成,而每个 document,有多个属性 fields。同一个 collection 中的不同的 documents,可能会有不同的 fields。例如,有个 collection 叫 Media,包含两条 documents,
3 r# n2 u( h& F: |* `' C% k6 L* E, R9 z1 E# Y" D
{% c! b& _: z+ q3 o: R2 g) g1 m
"ISBN": "987-30-3652-5130-82",
6 E/ m( C1 z$ {$ T& V% K# ~ "Type": "CD",
9 U" a9 z/ G8 I7 u: Y9 _( V* o "Author": "Nirvana",. A- t* H+ T8 w) A! h
"Title": "Nevermind",
`" }/ P2 P! R$ |6 N. v7 i "Genre": "Grunge",& E+ `- K- l5 W% E U6 t7 a
"Releasedate": "1991.09.24",+ J$ x/ p$ g/ C9 r' i- r
"Tracklist": [! A8 u3 _3 S z: [3 l4 [; s- \2 u9 `' ^
{
0 O/ R* f+ ^& @3 j "Track" : "1",
4 C3 m3 X; v3 _ "Title" : "Smells like teen spirit",
; j. Z0 r$ }$ b. ?5 r6 \ "Length" : "5:02"6 P1 q2 C. L$ c: d% J
},
( I# \! a+ u |- Q7 m1 U {
8 W& @4 X! N: ?( a2 D" b "Track" : "2",
" H: e3 `! Z1 _6 H "Title" : "In Bloom",
% y( d5 n d/ F8 L/ W4 q. _* Y "Length" : "4:15"2 L3 w& s8 u8 O3 F! O$ z, R
}9 [ v1 J I/ A" |" U
]
" _" d" Z2 F2 a, s}
8 ^/ G' ~8 G7 w! |2 T0 B: h# l8 X- T
{
( S6 v$ N3 _) e9 @+ z "ISBN": "987-1-4302-3051-9",8 K) }# d# }! B. W' ~) H
"Type": "Book",
) B' O$ s4 W* F0 t "Title": "Definite Guide to MongoDB: The NoSQL Database",
* t* ]0 f" s$ q) ?( t "Publisher": "Apress",
( [6 F; y3 [% ?+ E+ H' o "Author": " Eelco Plugge",
7 x2 w. r$ ^4 @) p' O3 h "Releasedate": "2011.06.09"
% P7 A( o E- w8 p) i" u# b' \}
- |7 V; \% a0 X U, w& F9 z* d4 ^
6 C0 H1 I; _" {1 _$ N9 x 假如,在同一个 collection 中的所有 document,都包含某个共同的 field,例如前例中的“ISBN”,那么我们就可以按照这个 field 的值,来分割 collection。这个 field 的值,又称为 shard key。4 y- Q0 f! F1 l& f- c
, ?* L* |& I5 S. y, h) t. { 在选择shard key的时候,一定要确保这个key能够把collection均匀地切分成很多chunks。
% j, R* s; N* K4 l$ d$ x$ p
4 {+ k5 G6 `% C 例如,如果我们选择“author”作为shard key,如果有大量的作者是重名的,那么就会有大量的数据聚集在同一个chunk中。当然,假设很少有作者同名同姓,那么“author”也可以作为一个shard key。换句话说,shard key 的选择,与使用场景密切相关。
) d- p v" @: Q1 K% B" Q2 |; C% u+ m, N
很多情况下,无论选择哪一个单一的 field 作为shard key,都无法均匀分割 collection。在这种情况下,我们可以考虑,用多个 fields,构成一个复合的shard key。$ ?2 |3 D/ d e
- ^% d. n8 X+ c 延续前例,假如有很多作者同名同姓,他们都叫“王二”。用 author 作为 shard key,显然无法均匀切割 collection。这时我们可以加上release-date,组成name-date的复合 shard key,例如“王二 2011”。, o8 [1 f* ?8 H7 R/ y$ U
. f6 j) q5 W/ e( o T. OChunks
- D) I8 M* g. ^) b
, H2 {$ F5 D9 U3 c8 [ MongoDB按 shard key,把 collection切割成若干 chunks。每个 chunk 的数据结构,是一个三元组,{collection,minKey,maxKey},如图1-2 所示。- [ a1 E- `: Q( j; G- r
' a; l8 B" J0 r j7 B4 q! r
. C6 Z0 x) d7 B7 N3 P+ I图1-2 chunk的三元组
9 @- w ~" `0 v
1 `3 C# ]" L q9 O 其中,collection 是数据库中某一个表的名称,而 minKey 和 maxKey 是 shard key的范围。每一个 document 的shard key 的值,决定了这条document应该存放在哪个chunk中。
9 v# T# J- o h5 G" R A3 Y( j
9 p8 h* a1 j7 @7 y u E; O 如果两条 documents 的 shard keys 的值很接近,这两条 documents 很可能被存放在同一个 chunk 中。
/ R: z: e$ l y
, g2 [4 t' A( ?. b; ~# y/ d Shard key 的值的顺序,决定了 document 存放的 chunk。在 MongoDB 的文献中,这种切割 collection 的方式,称为order-preserving。
# }( u/ C8 |# B& E5 p, U! c/ w
! M. Z" s G9 v" v J- ^6 o* V% ] 一个 chunk最多能够存储64MB的数据。 当某个chunk存储的 documents包含的数据量,接近这个阈值时,一个chunk会被切分成两个新的chunks。+ y6 ?/ Z! x. Y4 q
2 [) T* W: r6 s0 G0 U/ ^( {, V
当一个shard存储了过多的chunks,这个shard中的某些chunks会被迁移到其它 shard中。
4 [) e- U0 G! Y9 g& V+ B( @, h+ v3 }! ]4 w% v
这里有个问题,假如某一条 document 包含的数据量很大,超过 64MB,一个 chunk 存放不下,怎么办?在后续章节介绍 GridFS 时,我们会详细讨论。! D9 h6 m& v) H' T3 y/ X' r; l
8 E( [4 { ?4 ~Replica set
. @- u+ a) a# z9 Q9 R9 Q- t# P. M
6 K$ o5 b( N5 ^1 H+ y' x9 u) S 在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。
( |4 w. E9 X" t
0 D2 D# I# c$ o5 z( ^ 这个replica set包括一个primary DB和多个secondary DBs。为了数据的一致性,所有的修改(insert / update / deletes) 请求都交给primary处理。处理结束之后,再异步地备份到其他secondary中。7 @% P. }9 I' e) f7 p' `! h% n
' ?+ ^; @6 G! c Primary DB由replica set中的所有servers,共同选举产生。当这个primaryDB server出错的时候,可以从replica set中重新选举一个新的primaryDB,从而避免了单点故障。
7 r& c$ F* B ^9 u3 Q5 Z8 c, M% S$ |0 y' ]
Replica set的选举策略和数据同步机制,确保了系统的数据的一致性。后文详述。1 T0 ?6 J& n& S- C
; F. f+ Q5 B7 d
Config Server q# f9 o2 {4 X" f
# ^$ D a8 |3 E6 { Config servers用于存储MongoDB集群的元数据 metadata,这些元数据包括如下两个部分,每一个shard server包括哪些chunks,每个chunk存储了哪些 collections 的哪些 documents。
( z4 @- Y$ }# |5 o( ^
4 _" ?! Q6 f1 b* h* J 每一个config server都包括了MongoDB中所有chunk的信息。
3 U3 ]2 h$ O8 q1 _
& t; p) N) u) Q. L7 ~ Config server也需要 replication。但是有趣的是,config server 采用了自己独特的replication模式,而没有沿用 replica set。" O- u( O2 ~0 r1 z$ j4 ]! Q
; X: N2 I J- n( i# @ 如果任何一台config server挂了,整个 config server 集群中,其它 config server变成只读状态。这样做的原因,是避免在系统不稳定的情况下,冒然对元数据做任何改动,导致在不同的 config servers 中,出现元数据不一致的情况。. I6 {- \* u; J& \5 Z/ @. s% L8 ]. ?
: U4 Z; }9 D" h. T8 E MongoDB的官方文档建议,配置3个config servers比较合适,既提供了足够的安全性,又避免了更多的config servers实例之间的数据同步,引起的元数据不一致的麻烦。9 @2 Z: A7 b* L, t3 v; p5 Z
4 n8 R) E1 ^6 M, Y: I2 I# u
Mongos% K' g |! `, J& y6 ?2 C, M: M9 }, a
/ ^0 S5 b4 D6 k4 w6 A 用户使用MongoDB 时,用户的操作请求,全部由mongos来转发。
% G) i9 w! }+ c: n' e& F+ ^
. s' E7 t6 I h( d" e+ S: ` 当 mongos 接收到用户请求时,它先查询 config server,找到存放相应数据的shard servers。然后把用户请求,转发到这些 shard servers。当这些 shard servers完成操作后,它们把结果分别返回给 mongos。而当 mongos 汇总了所有的结果后,它把结果返回给用户。
5 o7 a5 u8 a, }0 A% {1 g' X' ?! @/ a: H* \6 S
Mongos每次启动的时候,都要到config servers中读取元数据,并缓存在本地。每当 config server中的元数据有改动,它都会通知所有的mongos。
$ o9 y9 G3 a, m2 V% i
# D* W2 k+ u& s. l3 Z Mongos之间,不存在彼此协同工作的问题。因此,MongoDB所需要配置的mongos server的数量,没有限制。
0 N/ \4 e) a6 L
! r! F. |3 {( j1 m, X3 M' Y8 P 通过以上的介绍,我们对每个组成部分都有了基本的了解,但是涉及到工作的细节,我们尚有诸多疑问,例如,一个chunk的数据太大,如何切分?一个shard数据太多,如何迁移?在replica set中,如何选择primary?server挂了,怎么进行故障恢复?接下来的章节,我们逐个回答这些问题。1 X3 n$ B, L& l- b7 x( d
) J7 C, Q2 W; y7 x
* V4 R6 L3 a: a6 s8 r# O/ w
Reference,
8 k' Z- `3 v6 }) _! L# D6 Q
, _2 j6 h/ W* \( ]& O, C7 l[0] Architectural Overview' l1 M% Q# |4 P
http://www.mongodb.org/display/DOCS/Sharding+Introduction
! j' o2 A! K8 h& | |
评分
-
查看全部评分
|