|
|
关于MongoDB,我们能看到的资料,基本都是在指导大家如何使用MongoDB,但是,MongoDB内部是如何运作的,资料不是很多。6 h% h- y6 L, J
1 C& `" |9 V9 o A% L# d$ C, a% l( ] 阅读使用手册,会有很多疑惑之处。例如,有人说,MongoDB 等同于分布式的 MySQL。它把一个Table ,按 row,分割成多个Shards,分别存放在不同的 Servers 上。这种说法是否正确?
% h/ w1 E- v2 }" v8 y/ P; k- ?, z9 m. b( H: ^/ l
不深入了解 MongoDB 的内部结构,就无法透彻地回答类似问题。这个系列文章,就来和大家探讨MongoDB的内部的工作方式。+ \. v# q% q* m) s7 v
# @. \. H8 l3 O4 }! G' A% Y L
9 h0 C* N, E% A* } \4 N
, g1 p6 Z/ ~. F7 i" a" m9 f. M' p图1-1 MongoDB架构图 ~: K9 R0 A6 `' k
" N+ @$ a: l* d0 ^' B% c& ]
MongoDB 通常运行在一个服务器集群上,而不是一个单机。图1-1,描述了一个MongoDB集群的基本组成部分,包括若干shards,至少一个config server,至少一个routing servers(又称 mongos)。# z* f; K4 P/ O- w) v+ ~ j! [9 a( e
G+ I x( L9 P, s. _
Shards1 k/ u, [& S, x/ {- {' G
8 y4 l5 A$ G) W6 g- A MongoDB的最基本的数据单元,叫document,类似于关系式数据库中的行 row。一系列documents,组成了一个collection,相当于关系式数据库中的table。当一个 collection 数据量太大时,可以把该collection按documents切分,分成多个数据块,每个数据块叫做一个chunk,多个chunks聚集在一起,组成了一个shard。+ D \; K# _! n
1 t$ k# ]8 W/ j C8 d) d Sharding 的意义,不仅保障了数据库的扩容(scalability),同时也保障了系统的负载均衡(load balance)。. F2 k8 g2 X4 o1 d9 H/ x! @
7 E5 E7 O$ O" G v' p6 m 每一个shard存储在一个物理服务器(server)上。Server上运行着mongod进程,通过这个进程,对shard中的数据进行操作,主要是增删改查。
8 j2 ~9 e1 ^/ m% t( t
3 Q" ~" J1 |8 t; j3 t1 y6 {# U) T 如果系统中的每个shard,只存储了一份数据,没有备份,那么当这个shard所在的server挂了,数据就丢失了。在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。
( @# a; f( B5 z! j. i/ ^5 ^" Y# z' d+ {! z
Shard keys* f2 x( J; ^4 s" F
1 o; V' Q- ^+ Q* L' ~" Q; n 为了把collection切分成不同的chunks,从而存放到不同的shards中,我们需要制定一个切分的方式。
& D( O5 V& Z4 t" z8 R- u/ }( G3 ~& [3 G" _9 f; ^2 M
如前所述,在 MongoDB 数据库中,一个表collection由多个行 documents 组成,而每个 document,有多个属性 fields。同一个 collection 中的不同的 documents,可能会有不同的 fields。例如,有个 collection 叫 Media,包含两条 documents,/ L2 M0 v, K6 v+ f3 h5 S, s
' Q5 `. @9 U" r0 l* l
{+ g: F# u4 g5 n& M) g) ]) U
"ISBN": "987-30-3652-5130-82",
3 [( o% X# n1 t: Y& K- U3 l "Type": "CD",
1 Z9 r f# V( Z/ J# ^+ d) L "Author": "Nirvana",; }- ?7 m9 G$ @! E
"Title": "Nevermind",
5 q* }2 c: U" q+ k) q "Genre": "Grunge",
* r% J+ B0 S* s4 x6 r( P6 v "Releasedate": "1991.09.24",4 [. e- K- t* G6 X& H
"Tracklist": [) O' Q# m# D8 l E0 s$ Y
{8 F7 Y6 w' ?7 [
"Track" : "1",
+ j, c0 Q, ]+ n" w2 R* b "Title" : "Smells like teen spirit",
' ^: O) c3 J5 `8 [% H8 z Q' p! y "Length" : "5:02"& Q. z2 n" V( Y8 g
},
6 y: O* W2 i& h* P- N4 C( [ {
$ ^% M" Y. P7 S; } "Track" : "2",+ n/ t4 p7 v# ?3 l4 X7 w
"Title" : "In Bloom",
5 s& R* n' N* m# ?5 p "Length" : "4:15"
+ u/ h5 I3 |. H* F }+ K( E5 [6 v# K, Q8 H8 p
]
2 H" u+ [# ~% n0 T}
# P" l: M {/ i" h% p/ H3 p
8 f3 k: w6 g7 M5 o( j# [{
) O% C6 e+ X/ Q4 `% ~, k1 a "ISBN": "987-1-4302-3051-9",0 N. h* ^/ C3 D; C* E. u8 ~3 L+ S
"Type": "Book",
8 ?: z' ` U3 c "Title": "Definite Guide to MongoDB: The NoSQL Database",
, f4 g& U$ X L0 `- z1 o "Publisher": "Apress",3 { n- I! \( u z& |; E% S N7 N
"Author": " Eelco Plugge",& {: Z! O2 q! @$ F- S3 g: P
"Releasedate": "2011.06.09"7 y, F: z) c4 l. r& N
}; N9 C7 \# |8 N# J( V/ f
3 S; F( g4 G6 c0 {/ Z l% m8 V; k
假如,在同一个 collection 中的所有 document,都包含某个共同的 field,例如前例中的“ISBN”,那么我们就可以按照这个 field 的值,来分割 collection。这个 field 的值,又称为 shard key。
( w) P2 {5 |4 a7 _$ [ I* T& q' I/ D
V( N* M- h# ~5 d 在选择shard key的时候,一定要确保这个key能够把collection均匀地切分成很多chunks。
0 y1 Z3 e, R, W& r
( T) @8 x6 D) U# d) a2 L 例如,如果我们选择“author”作为shard key,如果有大量的作者是重名的,那么就会有大量的数据聚集在同一个chunk中。当然,假设很少有作者同名同姓,那么“author”也可以作为一个shard key。换句话说,shard key 的选择,与使用场景密切相关。$ ^( R5 ]6 `$ S4 h
9 i6 u# T% m- W 很多情况下,无论选择哪一个单一的 field 作为shard key,都无法均匀分割 collection。在这种情况下,我们可以考虑,用多个 fields,构成一个复合的shard key。# n' e/ q8 x/ g3 o
, T8 O e' c) M- O- Q. V+ r 延续前例,假如有很多作者同名同姓,他们都叫“王二”。用 author 作为 shard key,显然无法均匀切割 collection。这时我们可以加上release-date,组成name-date的复合 shard key,例如“王二 2011”。
+ M! @/ f* v: h# N5 u4 k! r* y
; p1 k- h8 d, ^+ pChunks
5 T8 p7 m- J5 @9 r0 B# {; X
6 f3 V3 L: \; v2 z9 i MongoDB按 shard key,把 collection切割成若干 chunks。每个 chunk 的数据结构,是一个三元组,{collection,minKey,maxKey},如图1-2 所示。
) Q2 B7 T$ m- X2 ?4 L
4 t: }7 |( t. X/ g9 n
# H- A' {' i. E图1-2 chunk的三元组
& L* I" l' j7 e/ C2 c, O1 v0 T' `! I: y( ]$ @9 Z7 O2 {% s+ Q
其中,collection 是数据库中某一个表的名称,而 minKey 和 maxKey 是 shard key的范围。每一个 document 的shard key 的值,决定了这条document应该存放在哪个chunk中。( y3 Q, [6 T8 g4 x: h ~
+ E. P3 d/ c6 _- I: w% V# y 如果两条 documents 的 shard keys 的值很接近,这两条 documents 很可能被存放在同一个 chunk 中。
0 w$ o, `6 C; u
* H: F* W4 P4 R' r Shard key 的值的顺序,决定了 document 存放的 chunk。在 MongoDB 的文献中,这种切割 collection 的方式,称为order-preserving。
( r; ?) {% j" E" t! o" k% H' h( D( U5 n
一个 chunk最多能够存储64MB的数据。 当某个chunk存储的 documents包含的数据量,接近这个阈值时,一个chunk会被切分成两个新的chunks。4 \8 y9 n1 |/ P' w ?' ]: S' ^' k
z6 x6 @2 i8 J 当一个shard存储了过多的chunks,这个shard中的某些chunks会被迁移到其它 shard中。2 T0 R3 F7 ?* ?7 ?6 H
. [2 I/ U$ Q0 Y$ s7 I; |8 V. w$ g 这里有个问题,假如某一条 document 包含的数据量很大,超过 64MB,一个 chunk 存放不下,怎么办?在后续章节介绍 GridFS 时,我们会详细讨论。# Z. x$ ?5 K9 ^) j, y0 v5 Y
7 f: g4 d8 x8 w) E. M
Replica set
: O8 K& x. Z. i0 f2 G
& M2 T& n x! }4 ]# {3 C 在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。9 g1 j4 F& s% }- @& i
1 r1 W1 r8 E- j) P 这个replica set包括一个primary DB和多个secondary DBs。为了数据的一致性,所有的修改(insert / update / deletes) 请求都交给primary处理。处理结束之后,再异步地备份到其他secondary中。
}4 Z) d: _) C( C3 O0 {, ?" k7 S2 l0 q' v( j$ l' ]2 F
Primary DB由replica set中的所有servers,共同选举产生。当这个primaryDB server出错的时候,可以从replica set中重新选举一个新的primaryDB,从而避免了单点故障。1 O! _ ] y, z* ]9 R
% \# a+ B3 x2 u% R- [9 x0 z6 J4 T
Replica set的选举策略和数据同步机制,确保了系统的数据的一致性。后文详述。
1 L+ Q$ @7 I+ l/ X
( ^" f/ u5 s! @, sConfig Server1 @6 l4 {; f j4 o5 e
/ Z) }9 B; B6 y) C6 n( k* o8 A* S/ i Config servers用于存储MongoDB集群的元数据 metadata,这些元数据包括如下两个部分,每一个shard server包括哪些chunks,每个chunk存储了哪些 collections 的哪些 documents。
6 {, r! g0 o2 h! E! }6 o- P9 |4 Y6 X9 C. `/ t
每一个config server都包括了MongoDB中所有chunk的信息。
1 [% p& t$ d! d$ u( r8 Z) o; P; f h
Config server也需要 replication。但是有趣的是,config server 采用了自己独特的replication模式,而没有沿用 replica set。
9 q7 A6 L: I% C q
" a7 }' A+ u' S 如果任何一台config server挂了,整个 config server 集群中,其它 config server变成只读状态。这样做的原因,是避免在系统不稳定的情况下,冒然对元数据做任何改动,导致在不同的 config servers 中,出现元数据不一致的情况。. I: _" Z# E8 P w5 r/ X2 i
$ V4 ^3 }- k2 ~# }4 X MongoDB的官方文档建议,配置3个config servers比较合适,既提供了足够的安全性,又避免了更多的config servers实例之间的数据同步,引起的元数据不一致的麻烦。
: J( u8 a# w ?: `+ B. G; U- b) L. J* l2 [
Mongos9 S" w( s }( d, \2 c
7 t6 n9 ^ M* ~" }" D/ u, T, o
用户使用MongoDB 时,用户的操作请求,全部由mongos来转发。( Y2 Y6 c/ H/ r' O8 E9 e: K; F; z
" R- ~# i( s8 O/ k# q! n, W" G 当 mongos 接收到用户请求时,它先查询 config server,找到存放相应数据的shard servers。然后把用户请求,转发到这些 shard servers。当这些 shard servers完成操作后,它们把结果分别返回给 mongos。而当 mongos 汇总了所有的结果后,它把结果返回给用户。5 l5 N @" H# q/ l, ?% m# p8 P
2 M5 ]6 C c. F( S" d. d, Z# Y Mongos每次启动的时候,都要到config servers中读取元数据,并缓存在本地。每当 config server中的元数据有改动,它都会通知所有的mongos。5 Z* S8 G1 L3 L) W6 d
, w5 r- v3 f; ^; i& R. Z Mongos之间,不存在彼此协同工作的问题。因此,MongoDB所需要配置的mongos server的数量,没有限制。. C( W" y/ Y/ I
2 i+ ~( w% o7 @- N 通过以上的介绍,我们对每个组成部分都有了基本的了解,但是涉及到工作的细节,我们尚有诸多疑问,例如,一个chunk的数据太大,如何切分?一个shard数据太多,如何迁移?在replica set中,如何选择primary?server挂了,怎么进行故障恢复?接下来的章节,我们逐个回答这些问题。
~7 I' h* ^; k. E. M4 h/ h5 J" w5 ?; \; T% A
6 D1 l5 P/ t: Z6 [9 v1 _( {
Reference,6 f: L0 ?* u! i; y
; {! f9 F8 g/ B0 W" c[0] Architectural Overview
3 J6 ~5 M0 j( fhttp://www.mongodb.org/display/DOCS/Sharding+Introduction
( v/ u6 g0 _6 V K! ^/ b |
评分
-
查看全部评分
|