|
|
关于MongoDB,我们能看到的资料,基本都是在指导大家如何使用MongoDB,但是,MongoDB内部是如何运作的,资料不是很多。
% Y5 O3 o# Z# I: f1 }
8 q. E0 C4 t; ^" e( M7 O0 `8 L 阅读使用手册,会有很多疑惑之处。例如,有人说,MongoDB 等同于分布式的 MySQL。它把一个Table ,按 row,分割成多个Shards,分别存放在不同的 Servers 上。这种说法是否正确?2 o1 ^% s# G1 S5 M8 @0 I
6 b( {2 o, T5 c! u! M( \ 不深入了解 MongoDB 的内部结构,就无法透彻地回答类似问题。这个系列文章,就来和大家探讨MongoDB的内部的工作方式。- ?% V" G" g9 C5 P; I
]( S1 m8 e" q9 j' S, b+ k) }
$ E8 ]' g; A" q2 J
0 N: [6 D; a5 u; I图1-1 MongoDB架构图 & O8 T) P6 n; b' j
2 S' M* ^: M# ~' b) a
MongoDB 通常运行在一个服务器集群上,而不是一个单机。图1-1,描述了一个MongoDB集群的基本组成部分,包括若干shards,至少一个config server,至少一个routing servers(又称 mongos)。& y8 `) Z% _8 }; w
- c! p& h% L" r# x$ G' H9 Q6 f% zShards8 f7 g1 y' x6 i% i
9 N- ]3 B/ q9 U MongoDB的最基本的数据单元,叫document,类似于关系式数据库中的行 row。一系列documents,组成了一个collection,相当于关系式数据库中的table。当一个 collection 数据量太大时,可以把该collection按documents切分,分成多个数据块,每个数据块叫做一个chunk,多个chunks聚集在一起,组成了一个shard。
! [2 y5 B5 Y" x1 g. v0 q( C! g5 s$ r$ j+ D- Y( ^0 A/ d
Sharding 的意义,不仅保障了数据库的扩容(scalability),同时也保障了系统的负载均衡(load balance)。0 U( m9 R/ m7 U" g+ h1 Q7 r F
) d' E. x' Z" _9 H% [ 每一个shard存储在一个物理服务器(server)上。Server上运行着mongod进程,通过这个进程,对shard中的数据进行操作,主要是增删改查。: M) w% Y) a: C- i
6 _' M. C- }7 Q. P8 c" X8 r 如果系统中的每个shard,只存储了一份数据,没有备份,那么当这个shard所在的server挂了,数据就丢失了。在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。9 b5 O! R6 G2 `, |& D
5 R, w" Z# e5 r# P+ t i
Shard keys
5 Z' X6 R, N$ v; D) F $ s$ x; H4 c& I7 I2 a3 R
为了把collection切分成不同的chunks,从而存放到不同的shards中,我们需要制定一个切分的方式。
0 s1 N K( N0 r9 \
$ L7 {/ Z7 q* u$ W 如前所述,在 MongoDB 数据库中,一个表collection由多个行 documents 组成,而每个 document,有多个属性 fields。同一个 collection 中的不同的 documents,可能会有不同的 fields。例如,有个 collection 叫 Media,包含两条 documents,1 `, J5 h9 J v" b
& S( ?; \" W3 O0 o& m{
' d* \; q8 t1 R3 Y* ~! a "ISBN": "987-30-3652-5130-82",
5 a3 z3 w) x5 g% h# l "Type": "CD",
5 W% p' X. e$ B' x1 U1 [7 m0 o [ "Author": "Nirvana",2 f+ s6 M5 x% e, @; Q) j, A
"Title": "Nevermind",% Z) `9 C- I+ A. a( T' `
"Genre": "Grunge",
8 k) K1 C6 m! q# ? "Releasedate": "1991.09.24",' h0 K$ w: c4 D0 a
"Tracklist": [
+ b( D# w! ~# P+ d' N- R7 i {
$ \( ?( w4 q* K% R0 }2 d( @ "Track" : "1",( ?' I! Z* `) K" A( e! @
"Title" : "Smells like teen spirit",# M; s6 o; O, }6 l6 l
"Length" : "5:02"2 e3 i6 F- _) c; Z+ [
}, y' \8 o7 u9 r0 {8 I5 `& q1 W0 K4 `
{
( B0 k) k8 `6 F# U "Track" : "2",
8 B* a) c/ X7 R "Title" : "In Bloom",% a0 [0 W5 k1 o5 t
"Length" : "4:15"4 _7 X5 H2 M. p
}8 x/ M3 ?3 P' K; H
]) b+ L- i2 _7 u7 U% b8 b5 e
}, G- {7 @1 i% F
$ [: A" _' l9 c }3 J- @9 d{0 u8 Y( n( v) x# E/ _3 o
"ISBN": "987-1-4302-3051-9",
: B+ @" n+ x& K7 b1 A8 }/ Q6 x7 o "Type": "Book",
4 g2 P6 G! j+ e7 {* D9 d "Title": "Definite Guide to MongoDB: The NoSQL Database",+ ?- J6 a/ g/ v; R
"Publisher": "Apress",
/ {7 k/ B r4 s8 Q. x3 { "Author": " Eelco Plugge",3 B; |+ ^+ K6 n+ g0 J% \2 A
"Releasedate": "2011.06.09"" u$ Y1 z* X4 Y# y
}
1 J4 W$ }6 c& ?% H6 U5 K1 j- o
! U9 f0 E7 `. x& ~* { 假如,在同一个 collection 中的所有 document,都包含某个共同的 field,例如前例中的“ISBN”,那么我们就可以按照这个 field 的值,来分割 collection。这个 field 的值,又称为 shard key。& y2 [5 `8 o- } J1 N b
- K/ N. A8 ?1 c M9 R
在选择shard key的时候,一定要确保这个key能够把collection均匀地切分成很多chunks。
6 a, `' e7 k+ z2 C
5 ]0 c' t( s( s/ `4 `; e 例如,如果我们选择“author”作为shard key,如果有大量的作者是重名的,那么就会有大量的数据聚集在同一个chunk中。当然,假设很少有作者同名同姓,那么“author”也可以作为一个shard key。换句话说,shard key 的选择,与使用场景密切相关。
2 m( |2 q# d0 ]3 Y1 Q# L
7 c. ?; a/ {* t4 [& W5 U% F5 A 很多情况下,无论选择哪一个单一的 field 作为shard key,都无法均匀分割 collection。在这种情况下,我们可以考虑,用多个 fields,构成一个复合的shard key。2 i& e4 O9 [( K3 n
, V+ Y0 S- G5 G; b
延续前例,假如有很多作者同名同姓,他们都叫“王二”。用 author 作为 shard key,显然无法均匀切割 collection。这时我们可以加上release-date,组成name-date的复合 shard key,例如“王二 2011”。* l: r$ j. Y+ a. `/ M
- y2 Q) y7 f* w$ `1 V
Chunks" m. P* ]9 V+ L4 H
9 b2 c4 h: _4 r& q* t% v: N: c MongoDB按 shard key,把 collection切割成若干 chunks。每个 chunk 的数据结构,是一个三元组,{collection,minKey,maxKey},如图1-2 所示。+ n4 X2 F* n; f( j$ e
" ?4 j5 J+ c, I
- Y" r/ [6 s4 ^! G! U
图1-2 chunk的三元组
1 n9 e5 |; P" H& i: Q! Q) X! G5 p1 I) o' f
其中,collection 是数据库中某一个表的名称,而 minKey 和 maxKey 是 shard key的范围。每一个 document 的shard key 的值,决定了这条document应该存放在哪个chunk中。
; U+ y5 |% f. X: o0 Z a6 G9 M- t f
如果两条 documents 的 shard keys 的值很接近,这两条 documents 很可能被存放在同一个 chunk 中。
6 N6 v4 M* D8 J* b6 a2 [2 J! v5 ?3 E3 j* I/ U `2 Q' z( o
Shard key 的值的顺序,决定了 document 存放的 chunk。在 MongoDB 的文献中,这种切割 collection 的方式,称为order-preserving。1 B& T4 X# ?* G
4 k7 _* f$ ]4 Y. E4 A. T' H$ X 一个 chunk最多能够存储64MB的数据。 当某个chunk存储的 documents包含的数据量,接近这个阈值时,一个chunk会被切分成两个新的chunks。8 z6 y4 W+ s: B. c& g' Z' K
4 F1 A$ ]6 j% Q: ^1 \/ {2 K1 V
当一个shard存储了过多的chunks,这个shard中的某些chunks会被迁移到其它 shard中。
% A- A) ~5 K0 r% P6 R9 R
9 E2 l) n' l- n7 S 这里有个问题,假如某一条 document 包含的数据量很大,超过 64MB,一个 chunk 存放不下,怎么办?在后续章节介绍 GridFS 时,我们会详细讨论。
. ^- m- B* r! @6 ^$ m' D
1 C$ N" T( H4 w& L5 u; l5 \+ iReplica set9 `; V8 O% \5 Z+ r3 c5 l7 Q
; w( Y- l* L" [) O. B) t. ~ 在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。
9 @8 o- Z t9 H5 W1 [: F0 x+ d3 e$ a* P2 M
这个replica set包括一个primary DB和多个secondary DBs。为了数据的一致性,所有的修改(insert / update / deletes) 请求都交给primary处理。处理结束之后,再异步地备份到其他secondary中。+ ?9 K( N: l% g
2 G B) U/ K, R3 g7 G Primary DB由replica set中的所有servers,共同选举产生。当这个primaryDB server出错的时候,可以从replica set中重新选举一个新的primaryDB,从而避免了单点故障。5 q, \# ~* h5 ]' r. _: G
' m. p$ R0 A$ J3 T
Replica set的选举策略和数据同步机制,确保了系统的数据的一致性。后文详述。" H" j, {* u: N+ j! }& A( T5 N
4 G4 P5 |- ?3 ?4 PConfig Server
/ ?. i$ h' U1 {. }! q- R* n
8 w: y1 ]6 i# f7 V( W; z Config servers用于存储MongoDB集群的元数据 metadata,这些元数据包括如下两个部分,每一个shard server包括哪些chunks,每个chunk存储了哪些 collections 的哪些 documents。
, @; A2 A! v4 C* Y$ M4 t
' Q# G7 k9 j$ E1 J$ N4 z) M 每一个config server都包括了MongoDB中所有chunk的信息。$ ^( t) \, M4 y7 y' J1 D
# x1 G; b" Z3 D
Config server也需要 replication。但是有趣的是,config server 采用了自己独特的replication模式,而没有沿用 replica set。
" [: |' [$ C4 u* A; W: D& I2 ]8 B' C7 y
如果任何一台config server挂了,整个 config server 集群中,其它 config server变成只读状态。这样做的原因,是避免在系统不稳定的情况下,冒然对元数据做任何改动,导致在不同的 config servers 中,出现元数据不一致的情况。; F8 k; _2 n$ m% t
& A% j* c7 o6 J4 O MongoDB的官方文档建议,配置3个config servers比较合适,既提供了足够的安全性,又避免了更多的config servers实例之间的数据同步,引起的元数据不一致的麻烦。
1 C+ V1 c: G' V& H. ~% y. I* x& w/ @# R/ V) V+ ^( ?
Mongos$ K- ?) O& Z! c* d" }$ `) h
# ~/ A; R1 T* i" D$ P* p) \ 用户使用MongoDB 时,用户的操作请求,全部由mongos来转发。
; x% N' D! T9 U' o1 B, G7 S- Q9 K# @# I0 C* i9 d( e) F8 n
当 mongos 接收到用户请求时,它先查询 config server,找到存放相应数据的shard servers。然后把用户请求,转发到这些 shard servers。当这些 shard servers完成操作后,它们把结果分别返回给 mongos。而当 mongos 汇总了所有的结果后,它把结果返回给用户。
- O# P% a& H, P7 o( R" D( i# v, b' _2 x9 L, m4 j
Mongos每次启动的时候,都要到config servers中读取元数据,并缓存在本地。每当 config server中的元数据有改动,它都会通知所有的mongos。
0 |. A$ h" v8 Y, J2 W- s
+ C* k3 X/ T2 K" d* F. ^ Y1 ~ Mongos之间,不存在彼此协同工作的问题。因此,MongoDB所需要配置的mongos server的数量,没有限制。1 ]9 g7 _" \6 k( `/ X0 m# L
" v) \# _8 x" y
通过以上的介绍,我们对每个组成部分都有了基本的了解,但是涉及到工作的细节,我们尚有诸多疑问,例如,一个chunk的数据太大,如何切分?一个shard数据太多,如何迁移?在replica set中,如何选择primary?server挂了,怎么进行故障恢复?接下来的章节,我们逐个回答这些问题。( t# \5 c1 B5 k( J: J- ~2 L- l& ^
3 Q/ S1 Y: \* N: f7 ~
$ s. x: s/ f. K; f, Y+ V
Reference,
/ f* R% z9 u3 j5 D1 N2 v
# x* P7 P* |! k: s. K* @8 M( p[0] Architectural Overview! s# ?- _+ H3 }1 E. w" z% V/ }
http://www.mongodb.org/display/DOCS/Sharding+Introduction
4 h3 V# `4 a$ S4 u/ h |% ?' o z) s |
评分
-
查看全部评分
|