|
|
关于MongoDB,我们能看到的资料,基本都是在指导大家如何使用MongoDB,但是,MongoDB内部是如何运作的,资料不是很多。. _. }1 f* x- R" ?
: b$ @& ~4 ~6 `2 f, c 阅读使用手册,会有很多疑惑之处。例如,有人说,MongoDB 等同于分布式的 MySQL。它把一个Table ,按 row,分割成多个Shards,分别存放在不同的 Servers 上。这种说法是否正确?. t X3 O" \" W0 f, v% _& n. u
3 V9 z( a0 Q% r% \- ]2 |4 w+ j 不深入了解 MongoDB 的内部结构,就无法透彻地回答类似问题。这个系列文章,就来和大家探讨MongoDB的内部的工作方式。1 x- b: K5 ]& V, E6 M O
0 @- [& \9 [" d# q# i2 `+ d. n
- ~' Z5 W; d! B
8 J' k" j* M4 S- x4 M3 _图1-1 MongoDB架构图
% P! y# K, f% E5 i3 u1 a% ^& Z
+ I5 `) m o c, `) @& ?; w MongoDB 通常运行在一个服务器集群上,而不是一个单机。图1-1,描述了一个MongoDB集群的基本组成部分,包括若干shards,至少一个config server,至少一个routing servers(又称 mongos)。
/ u4 T4 n0 x5 _ y8 ? L: F" A9 D B) j; X* I- {, b; b* x
Shards
% @0 o: j |$ o: d& b) v
3 _' t9 G) z- p% l# l; w! j MongoDB的最基本的数据单元,叫document,类似于关系式数据库中的行 row。一系列documents,组成了一个collection,相当于关系式数据库中的table。当一个 collection 数据量太大时,可以把该collection按documents切分,分成多个数据块,每个数据块叫做一个chunk,多个chunks聚集在一起,组成了一个shard。$ G4 p$ ^0 A: I
; s' k/ V/ \1 I/ W# D5 t Sharding 的意义,不仅保障了数据库的扩容(scalability),同时也保障了系统的负载均衡(load balance)。( N, n" r; d1 g) o* U: D; t( N4 v; e
* l, Q8 X) P, z6 ^0 i 每一个shard存储在一个物理服务器(server)上。Server上运行着mongod进程,通过这个进程,对shard中的数据进行操作,主要是增删改查。
1 i/ G+ u, y8 ? A) ], z* r4 ? ?9 F$ W" `' G/ D1 {
如果系统中的每个shard,只存储了一份数据,没有备份,那么当这个shard所在的server挂了,数据就丢失了。在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。' h* t1 I' c- b
N) j, V, \" M9 N9 T9 O( a3 O J
Shard keys: K( H; v7 J* x% [' [
H+ j! ?$ E7 |: l
为了把collection切分成不同的chunks,从而存放到不同的shards中,我们需要制定一个切分的方式。- k& r# M! V; @, L# J f6 U# Y
% K0 b N) T$ Q0 I& p8 J* u, l 如前所述,在 MongoDB 数据库中,一个表collection由多个行 documents 组成,而每个 document,有多个属性 fields。同一个 collection 中的不同的 documents,可能会有不同的 fields。例如,有个 collection 叫 Media,包含两条 documents,
. p0 I+ s6 Q! J5 Q6 }5 o/ |3 B4 f( d0 i
{' K: M2 j7 w% A; Z4 Z# F7 i
"ISBN": "987-30-3652-5130-82",
, O) j; I8 H% p9 y "Type": "CD",
" H& W+ v% P" N# u5 S8 ~; v& `& l# i+ g "Author": "Nirvana",' Y0 @) s w2 t) r% \9 ?) U# u. j
"Title": "Nevermind",3 e! x. f0 h) m* G/ X
"Genre": "Grunge",
, E# i8 b0 T6 s1 d8 e& C! q5 Y "Releasedate": "1991.09.24",9 Q" {1 i+ V! S$ h
"Tracklist": [2 @& U* B; L- w e
{
1 |, L0 [( }8 ^- j3 Y "Track" : "1",
; Z3 C2 O9 C4 c7 _ "Title" : "Smells like teen spirit",
; H5 x9 b4 t3 O# A' h# N "Length" : "5:02"
) [) \ k- Q; D0 T1 o5 G },7 S0 y+ X I4 H2 b, A& L- g
{
9 n0 W6 ]' h- d. q "Track" : "2",
* h* q! K% d3 Q. a1 X3 Q "Title" : "In Bloom",5 c! C0 A1 I+ [3 X3 s8 b6 k
"Length" : "4:15"/ x6 u, r# A+ k1 a1 C1 ^" L
}9 V- _( m+ }: ]1 {0 l$ i
]7 m0 q& K5 b, q; [8 V
}! I7 g/ [; ~8 L {1 ~
' Y+ G) c7 h; y2 K/ c8 h3 {+ _
{
8 A9 P& e8 ^ o' v "ISBN": "987-1-4302-3051-9",
) k/ @3 j: V. A: X5 } q, }# d "Type": "Book",6 r5 \3 V% G. P: b& f
"Title": "Definite Guide to MongoDB: The NoSQL Database",
* U! ~. f7 z7 H: i9 x" z6 G "Publisher": "Apress",
2 [9 b" |4 _+ k% }& B "Author": " Eelco Plugge",7 H" S* Y0 K+ g/ U N/ i
"Releasedate": "2011.06.09"! Y4 V7 D0 e; S' E/ M
}$ E6 S0 W$ `9 @* v6 t8 t
) m) u- R' L. n2 {( D: p' U! e
假如,在同一个 collection 中的所有 document,都包含某个共同的 field,例如前例中的“ISBN”,那么我们就可以按照这个 field 的值,来分割 collection。这个 field 的值,又称为 shard key。
0 f) r# _1 Q, k/ c4 m0 C# X
9 _+ f s# e! w) H 在选择shard key的时候,一定要确保这个key能够把collection均匀地切分成很多chunks。# M/ ~0 g8 |' ~
. ^7 u) h& x$ K 例如,如果我们选择“author”作为shard key,如果有大量的作者是重名的,那么就会有大量的数据聚集在同一个chunk中。当然,假设很少有作者同名同姓,那么“author”也可以作为一个shard key。换句话说,shard key 的选择,与使用场景密切相关。
3 J' c1 _+ _$ V0 Z0 P4 o' q1 a& \2 I
- b; X% L+ A- F% B- k 很多情况下,无论选择哪一个单一的 field 作为shard key,都无法均匀分割 collection。在这种情况下,我们可以考虑,用多个 fields,构成一个复合的shard key。# p3 Z) r/ S0 W: I
! h$ i* @& K, W4 [! h I) \! _1 D( l7 b' h
延续前例,假如有很多作者同名同姓,他们都叫“王二”。用 author 作为 shard key,显然无法均匀切割 collection。这时我们可以加上release-date,组成name-date的复合 shard key,例如“王二 2011”。
+ i7 a- D) x( s# P! N9 G4 _/ [: \
Chunks
/ [+ \( Q+ G2 F, Y# [ 8 j: _; u- P( G* f% ^4 q) e
MongoDB按 shard key,把 collection切割成若干 chunks。每个 chunk 的数据结构,是一个三元组,{collection,minKey,maxKey},如图1-2 所示。7 N K7 L9 w$ Z2 ?$ z
1 @( D, P5 h( f2 P# j% q/ R
9 _1 C# x8 \- w2 G0 ]( o图1-2 chunk的三元组
! S! O" [9 ]3 n4 L4 o% K* _# _% f* u# i' r. R4 K( w3 A: m4 @
其中,collection 是数据库中某一个表的名称,而 minKey 和 maxKey 是 shard key的范围。每一个 document 的shard key 的值,决定了这条document应该存放在哪个chunk中。( w/ y3 w7 }# o' Y+ b
3 O5 l) C t) e, u$ ]7 g 如果两条 documents 的 shard keys 的值很接近,这两条 documents 很可能被存放在同一个 chunk 中。. V0 e4 v, z$ W
1 H9 \% o" v& B' G/ U& ?% ?
Shard key 的值的顺序,决定了 document 存放的 chunk。在 MongoDB 的文献中,这种切割 collection 的方式,称为order-preserving。" H! S2 }% h7 j
0 V. m6 U- t6 Y V+ m
一个 chunk最多能够存储64MB的数据。 当某个chunk存储的 documents包含的数据量,接近这个阈值时,一个chunk会被切分成两个新的chunks。' `$ p' G# M- U! h8 e' B r% O# t" a
8 _+ v9 t K" U) i, J 当一个shard存储了过多的chunks,这个shard中的某些chunks会被迁移到其它 shard中。
, w% v2 J% P/ A. e6 i/ L
+ p; P0 t" x6 R 这里有个问题,假如某一条 document 包含的数据量很大,超过 64MB,一个 chunk 存放不下,怎么办?在后续章节介绍 GridFS 时,我们会详细讨论。5 [: [1 g2 ?% C9 {; x7 p) x- a
2 K7 H$ p: q, q( j0 X- F
Replica set
: ?9 ]* p: N W
$ ?7 H) t3 M( ~/ P3 }* p3 A! B 在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。/ ^, z4 M, B1 D! D3 ~& P2 K1 j! N7 ]
! m5 X1 N1 s8 I5 O1 x/ Z# f
这个replica set包括一个primary DB和多个secondary DBs。为了数据的一致性,所有的修改(insert / update / deletes) 请求都交给primary处理。处理结束之后,再异步地备份到其他secondary中。
4 u% V( v* e% h1 \
$ l; H# R8 k9 _4 }; n0 o, H( F) v k Primary DB由replica set中的所有servers,共同选举产生。当这个primaryDB server出错的时候,可以从replica set中重新选举一个新的primaryDB,从而避免了单点故障。5 `5 g" M0 L3 T0 d$ h m3 \: u1 R$ }
6 f) d# U. _7 r9 a) y; o" ]
Replica set的选举策略和数据同步机制,确保了系统的数据的一致性。后文详述。
+ q2 ]6 B6 |) s5 M0 I% q; z Z& o4 U' K* W( ?# `( s
Config Server3 E' O/ L2 j$ B0 h
8 p e1 D3 O8 v) `6 U Config servers用于存储MongoDB集群的元数据 metadata,这些元数据包括如下两个部分,每一个shard server包括哪些chunks,每个chunk存储了哪些 collections 的哪些 documents。
1 s/ n' B6 I! E8 t* P7 {5 q: R. d" U0 o7 ?6 y5 j. I& _
每一个config server都包括了MongoDB中所有chunk的信息。" l J' M- G; K X% N
" Z1 p# e0 x7 j! g
Config server也需要 replication。但是有趣的是,config server 采用了自己独特的replication模式,而没有沿用 replica set。0 U5 Z/ X: ]2 W6 _' J! p% n
- j% ~8 s# E" j s
如果任何一台config server挂了,整个 config server 集群中,其它 config server变成只读状态。这样做的原因,是避免在系统不稳定的情况下,冒然对元数据做任何改动,导致在不同的 config servers 中,出现元数据不一致的情况。* h4 @4 S: h! Z# {9 i1 z
6 ?5 E' N0 C6 T MongoDB的官方文档建议,配置3个config servers比较合适,既提供了足够的安全性,又避免了更多的config servers实例之间的数据同步,引起的元数据不一致的麻烦。* D* A- e% ?" J7 }2 O0 i
2 l& a# J/ ^8 t9 n2 o" @Mongos: f) A K6 I* M
* J/ {% q3 i( a" w/ Z! A 用户使用MongoDB 时,用户的操作请求,全部由mongos来转发。
- ^7 y: U- L+ K4 z' x3 _& R U
- z0 W: q! P9 B- S 当 mongos 接收到用户请求时,它先查询 config server,找到存放相应数据的shard servers。然后把用户请求,转发到这些 shard servers。当这些 shard servers完成操作后,它们把结果分别返回给 mongos。而当 mongos 汇总了所有的结果后,它把结果返回给用户。
" G: S3 V+ K w7 {: Y' Q" Y) h# p* ?* v9 d
Mongos每次启动的时候,都要到config servers中读取元数据,并缓存在本地。每当 config server中的元数据有改动,它都会通知所有的mongos。
$ D; M9 Z Q& h% g N, @9 e# I7 u8 U/ @# e7 R
Mongos之间,不存在彼此协同工作的问题。因此,MongoDB所需要配置的mongos server的数量,没有限制。
. Q* F7 O( H: T7 _1 L( G: V' D3 r9 U! a9 c
通过以上的介绍,我们对每个组成部分都有了基本的了解,但是涉及到工作的细节,我们尚有诸多疑问,例如,一个chunk的数据太大,如何切分?一个shard数据太多,如何迁移?在replica set中,如何选择primary?server挂了,怎么进行故障恢复?接下来的章节,我们逐个回答这些问题。
7 ^8 n+ k9 F, E# C! ~# i6 n+ Z8 j/ H2 u
. d2 W! [+ C" I/ a9 u
Reference,4 ?; U9 |; k G* m T3 T! c% g
2 R" B! i1 s' N/ x[0] Architectural Overview+ p9 v: A# s" G3 B0 J
http://www.mongodb.org/display/DOCS/Sharding+Introduction
0 P1 M+ V0 f; g# I3 Z: ` |
评分
-
查看全部评分
|