|
|
关于MongoDB,我们能看到的资料,基本都是在指导大家如何使用MongoDB,但是,MongoDB内部是如何运作的,资料不是很多。
8 f# i* X+ X8 V1 g5 J
1 r: l# J. U) G, i 阅读使用手册,会有很多疑惑之处。例如,有人说,MongoDB 等同于分布式的 MySQL。它把一个Table ,按 row,分割成多个Shards,分别存放在不同的 Servers 上。这种说法是否正确?, |+ R: w" f% f& D7 u
3 M8 b9 }3 P& a) m, s 不深入了解 MongoDB 的内部结构,就无法透彻地回答类似问题。这个系列文章,就来和大家探讨MongoDB的内部的工作方式。
9 y& ^5 U! J4 ]; }! x. W7 v( u3 \
; V, e! C& a+ f/ U3 a, z) g
Z& p0 h# u1 Y6 f" M
图1-1 MongoDB架构图
" G2 k$ h0 I$ O. [7 h$ }/ g# q2 N7 R1 E& F) G
MongoDB 通常运行在一个服务器集群上,而不是一个单机。图1-1,描述了一个MongoDB集群的基本组成部分,包括若干shards,至少一个config server,至少一个routing servers(又称 mongos)。! \' x& R* U( T8 H% y2 b0 j; X
5 F: p0 q# P+ @" F" l" oShards
; b4 q3 L8 B3 E+ C2 e* }# {/ l, K+ Z) u' \0 f- F! t X! l
MongoDB的最基本的数据单元,叫document,类似于关系式数据库中的行 row。一系列documents,组成了一个collection,相当于关系式数据库中的table。当一个 collection 数据量太大时,可以把该collection按documents切分,分成多个数据块,每个数据块叫做一个chunk,多个chunks聚集在一起,组成了一个shard。
8 ~3 q) U# U9 }! I7 E9 f3 a! T" v! o @
- Y8 L; j/ r: R# l Sharding 的意义,不仅保障了数据库的扩容(scalability),同时也保障了系统的负载均衡(load balance)。
' {# l; S% P/ K% `; E d
7 H1 \6 U* V' F" c M8 | 每一个shard存储在一个物理服务器(server)上。Server上运行着mongod进程,通过这个进程,对shard中的数据进行操作,主要是增删改查。
* z W2 P, |* W+ X+ y5 K
: O1 B6 q- l2 l) ^; K 如果系统中的每个shard,只存储了一份数据,没有备份,那么当这个shard所在的server挂了,数据就丢失了。在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。
& o$ }. W* W& p6 O' Q! O" Q6 x) g: e7 F
Shard keys% c. ~; J% k: J. B. @. Q
: v* f5 l. g: R6 b2 f$ | 为了把collection切分成不同的chunks,从而存放到不同的shards中,我们需要制定一个切分的方式。
; Y# _' h3 E) E, {* l0 K/ K* ]4 X3 O- K- m# e! J R' m
如前所述,在 MongoDB 数据库中,一个表collection由多个行 documents 组成,而每个 document,有多个属性 fields。同一个 collection 中的不同的 documents,可能会有不同的 fields。例如,有个 collection 叫 Media,包含两条 documents,9 d5 S1 C; Y% b$ k) O+ a: l' k
6 ]4 y' i! z- [3 m/ n; K3 F! m
{' m: W5 K, j& F
"ISBN": "987-30-3652-5130-82",
6 f. Q0 q U }, {" C% ~! T "Type": "CD",6 K8 b. ?$ _, Y3 @; g' }, ^+ c9 `
"Author": "Nirvana",
6 P2 `4 Q/ ?/ l "Title": "Nevermind",
2 F' M7 G$ A. v) |; N/ y "Genre": "Grunge",
' Y, u9 [3 H3 @/ v+ a" D "Releasedate": "1991.09.24",1 W" G5 f# I# a
"Tracklist": [+ b* O7 M, M0 j$ t$ X8 |( [
{! S$ O L1 B& d* @4 L: _6 y
"Track" : "1",& L8 Z; S* c" o& _& c6 v
"Title" : "Smells like teen spirit",0 t& w, N; E" G
"Length" : "5:02"
1 P: h6 E( a7 d4 V2 r; l& e4 o, x },
. E) l! J, N6 N0 j7 [5 G( V {9 x# q+ m$ R+ K; z6 Y$ X" w: |
"Track" : "2",
8 D2 i& i9 A9 o: C' R2 x "Title" : "In Bloom",7 F8 g& ?3 X0 L/ }: f" F
"Length" : "4:15", Y( z3 [! L1 Y6 _
}8 }+ N9 F5 h1 P0 h$ P& y6 x
]
4 V5 v( Z# V- _' O3 F5 v}: |7 Z& w/ ~, o7 }2 o
* [0 q6 T+ t8 k, W0 y* o{
% ?4 j" k9 o% X! p5 S8 v& T "ISBN": "987-1-4302-3051-9",3 k/ H3 p+ f0 a. F: H7 ?7 g
"Type": "Book",4 e! y7 w7 i8 [2 U: D) M
"Title": "Definite Guide to MongoDB: The NoSQL Database",/ j# S) A4 }5 V: z
"Publisher": "Apress",
6 H! q$ Q5 c% v" `2 [ "Author": " Eelco Plugge",
3 q6 l6 B0 S5 ?# ]2 _6 l "Releasedate": "2011.06.09"
- B! x! `; P' e) ]! I# u i8 r/ B) V}3 O* |5 g& l4 n' G" M/ Z9 `
# s/ ]$ L! v' r7 B6 [2 C 假如,在同一个 collection 中的所有 document,都包含某个共同的 field,例如前例中的“ISBN”,那么我们就可以按照这个 field 的值,来分割 collection。这个 field 的值,又称为 shard key。! J3 N5 O2 G3 ~2 k8 I2 `7 x
, q6 `/ _$ J, j8 O 在选择shard key的时候,一定要确保这个key能够把collection均匀地切分成很多chunks。
k- o. U! i% t3 ~
: q1 o/ h. g% Y$ t 例如,如果我们选择“author”作为shard key,如果有大量的作者是重名的,那么就会有大量的数据聚集在同一个chunk中。当然,假设很少有作者同名同姓,那么“author”也可以作为一个shard key。换句话说,shard key 的选择,与使用场景密切相关。) H% R8 U3 u* J4 r5 J
0 A' ?( ]& K& u9 r# t6 n7 u- r) ` 很多情况下,无论选择哪一个单一的 field 作为shard key,都无法均匀分割 collection。在这种情况下,我们可以考虑,用多个 fields,构成一个复合的shard key。
$ k0 p8 s9 |1 m3 y& l1 q
4 ^; d; p5 Q$ v% \ 延续前例,假如有很多作者同名同姓,他们都叫“王二”。用 author 作为 shard key,显然无法均匀切割 collection。这时我们可以加上release-date,组成name-date的复合 shard key,例如“王二 2011”。' f0 U) ^' L3 T4 h4 ~) t D) `2 s
( r! F% M+ {" Y/ Y. xChunks
9 k% a! I5 }- E3 g) I; P: y/ E
1 [0 ^) V R9 k' U" p( }, a/ S+ f MongoDB按 shard key,把 collection切割成若干 chunks。每个 chunk 的数据结构,是一个三元组,{collection,minKey,maxKey},如图1-2 所示。; z" L3 W5 q% u% h. c1 [1 B
$ F7 M9 R' v0 a5 f
8 h* V, N. U5 f& [图1-2 chunk的三元组 % T$ L+ E( M9 o! L% Y7 J
9 J i6 m& G q. Q
其中,collection 是数据库中某一个表的名称,而 minKey 和 maxKey 是 shard key的范围。每一个 document 的shard key 的值,决定了这条document应该存放在哪个chunk中。
; T5 k( l& S+ ~: L8 |' T2 A) h0 C# H x H! Z& {0 y% C
如果两条 documents 的 shard keys 的值很接近,这两条 documents 很可能被存放在同一个 chunk 中。
3 z, |! ` p9 f& t V2 ~, Y, d7 T2 d9 o
Shard key 的值的顺序,决定了 document 存放的 chunk。在 MongoDB 的文献中,这种切割 collection 的方式,称为order-preserving。
Q' m) u& w1 M
+ Z& ~& L& u. I' s3 ^: r: \/ N 一个 chunk最多能够存储64MB的数据。 当某个chunk存储的 documents包含的数据量,接近这个阈值时,一个chunk会被切分成两个新的chunks。
3 X+ ]; `" p+ j" N6 O2 Y. n& l6 Q" d% x# Z/ Q1 L; P% k
当一个shard存储了过多的chunks,这个shard中的某些chunks会被迁移到其它 shard中。
3 X) `* T( o# [9 |4 i% p5 U5 f) U, p$ d
这里有个问题,假如某一条 document 包含的数据量很大,超过 64MB,一个 chunk 存放不下,怎么办?在后续章节介绍 GridFS 时,我们会详细讨论。
. O/ e4 A9 V1 _; N5 L! j& Q( R9 ^1 {! s6 s! A$ p( X
Replica set' G" q2 J$ Z$ {* a
' D' v" J. S$ P0 {( f/ T
在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。
1 C" M4 T3 p/ N
) p0 N. }4 _# T, z& g! Z0 h 这个replica set包括一个primary DB和多个secondary DBs。为了数据的一致性,所有的修改(insert / update / deletes) 请求都交给primary处理。处理结束之后,再异步地备份到其他secondary中。
2 M3 j7 h- r6 h+ \7 |$ X2 ~" H7 q- }- i! q+ }
Primary DB由replica set中的所有servers,共同选举产生。当这个primaryDB server出错的时候,可以从replica set中重新选举一个新的primaryDB,从而避免了单点故障。8 o3 I% e1 `. G) q8 ]6 s
( k8 U: K% [5 `0 K* ]! C6 b Replica set的选举策略和数据同步机制,确保了系统的数据的一致性。后文详述。0 {- d( K3 t1 _ ?1 b' p- `3 ^$ ]( \/ f
4 O( X* t0 [. w. t5 _4 _Config Server0 q: o; `6 j6 w8 ]
0 u( `* s- p' \" o2 ] Config servers用于存储MongoDB集群的元数据 metadata,这些元数据包括如下两个部分,每一个shard server包括哪些chunks,每个chunk存储了哪些 collections 的哪些 documents。
0 r* ^9 Z, b& q; J. l3 t
T, q5 J* ~ J( s( i: U 每一个config server都包括了MongoDB中所有chunk的信息。2 a4 N w, c6 i& P" y9 H% J8 g
. ~# X5 K8 k( c- F& N; r# z n
Config server也需要 replication。但是有趣的是,config server 采用了自己独特的replication模式,而没有沿用 replica set。
. q0 S" _$ {) c, F
% y' h; @% t; \% Q1 R; {# V' W6 @ 如果任何一台config server挂了,整个 config server 集群中,其它 config server变成只读状态。这样做的原因,是避免在系统不稳定的情况下,冒然对元数据做任何改动,导致在不同的 config servers 中,出现元数据不一致的情况。
- ?1 [/ ]5 ]* o9 k; k+ v, A) R
2 C1 l1 a. O: z4 Q MongoDB的官方文档建议,配置3个config servers比较合适,既提供了足够的安全性,又避免了更多的config servers实例之间的数据同步,引起的元数据不一致的麻烦。: R+ W% O' p5 } @
% _% M1 N9 ~0 p- O8 G, @
Mongos
: B* `' y$ r* H0 \+ S" Q5 p0 r+ G" [$ Y: a) o) c
用户使用MongoDB 时,用户的操作请求,全部由mongos来转发。& a p; q2 m8 H+ S( V
7 e9 P# s& g$ s& O
当 mongos 接收到用户请求时,它先查询 config server,找到存放相应数据的shard servers。然后把用户请求,转发到这些 shard servers。当这些 shard servers完成操作后,它们把结果分别返回给 mongos。而当 mongos 汇总了所有的结果后,它把结果返回给用户。, T, T; G# {9 S- R1 z
U1 e! u$ m5 M: l: s
Mongos每次启动的时候,都要到config servers中读取元数据,并缓存在本地。每当 config server中的元数据有改动,它都会通知所有的mongos。& V! Z- {7 E$ D! L. v* B. Y! D
" W# A9 Z; O/ [6 @' d G) P3 e+ x5 n Mongos之间,不存在彼此协同工作的问题。因此,MongoDB所需要配置的mongos server的数量,没有限制。" Q; z0 t* L: z; p6 X
; H% x* C$ ^# G* e
通过以上的介绍,我们对每个组成部分都有了基本的了解,但是涉及到工作的细节,我们尚有诸多疑问,例如,一个chunk的数据太大,如何切分?一个shard数据太多,如何迁移?在replica set中,如何选择primary?server挂了,怎么进行故障恢复?接下来的章节,我们逐个回答这些问题。
, n; U0 F- K) l# D) x. P) p9 O
* q2 A" O3 w) s6 j M* m7 m
' p6 W9 r! n: l2 v4 ~) b( AReference,
' }! |9 G; [0 V" U! N0 m% j" K6 I) i2 p5 ]( c3 f! @ y3 M4 z
[0] Architectural Overview
3 y; _/ R! M3 Q" xhttp://www.mongodb.org/display/DOCS/Sharding+Introduction
/ F5 W4 o5 | r% n& I |
评分
-
查看全部评分
|