|
|
关于MongoDB,我们能看到的资料,基本都是在指导大家如何使用MongoDB,但是,MongoDB内部是如何运作的,资料不是很多。% |* F$ F' t5 P. l+ g f
" [ P, v% I7 ?- U+ G7 d2 Z 阅读使用手册,会有很多疑惑之处。例如,有人说,MongoDB 等同于分布式的 MySQL。它把一个Table ,按 row,分割成多个Shards,分别存放在不同的 Servers 上。这种说法是否正确?
* J5 g" ]. {- f- X+ F: `' A/ \0 @9 W% x" T f7 Z
不深入了解 MongoDB 的内部结构,就无法透彻地回答类似问题。这个系列文章,就来和大家探讨MongoDB的内部的工作方式。
; O& ~- E2 x) S! G; q
+ x$ y2 n) ` t6 g9 R9 {8 M9 p
8 j" }/ m) L( s; I" M6 v- D. ?4 I2 j
! a2 R; v8 h% @1 ~9 h! e* R* t( q
图1-1 MongoDB架构图 # N% J& R- v# ~3 _9 V
2 l: h5 d m/ Y MongoDB 通常运行在一个服务器集群上,而不是一个单机。图1-1,描述了一个MongoDB集群的基本组成部分,包括若干shards,至少一个config server,至少一个routing servers(又称 mongos)。! S: N C" @. W7 D5 y
( k4 D# Z; r' ^* Y/ k6 a
Shards( a5 V5 h u" H' e. U* p
9 a* x, _0 }6 X1 u MongoDB的最基本的数据单元,叫document,类似于关系式数据库中的行 row。一系列documents,组成了一个collection,相当于关系式数据库中的table。当一个 collection 数据量太大时,可以把该collection按documents切分,分成多个数据块,每个数据块叫做一个chunk,多个chunks聚集在一起,组成了一个shard。
8 u# n! J0 e5 m3 C# c k2 A) E$ k+ M3 e3 F) m2 J
Sharding 的意义,不仅保障了数据库的扩容(scalability),同时也保障了系统的负载均衡(load balance)。
2 D! {/ n* z' X2 X5 V
$ W2 p4 a6 m( L, m3 r* _ D 每一个shard存储在一个物理服务器(server)上。Server上运行着mongod进程,通过这个进程,对shard中的数据进行操作,主要是增删改查。
* I- Z5 w' d6 n5 v) v9 V. c/ R% l$ {- \
如果系统中的每个shard,只存储了一份数据,没有备份,那么当这个shard所在的server挂了,数据就丢失了。在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。
% E; g+ q3 q4 {, R) w* q+ F0 q/ ]% o: X' i3 s2 o: O# p
Shard keys' N& \% U, ~9 I! k( O
$ P" O+ l4 c/ h1 F% }) T
为了把collection切分成不同的chunks,从而存放到不同的shards中,我们需要制定一个切分的方式。
8 t- M- R3 x: O1 s1 ? t+ h' E" k* X- |% n- T M) j) \
如前所述,在 MongoDB 数据库中,一个表collection由多个行 documents 组成,而每个 document,有多个属性 fields。同一个 collection 中的不同的 documents,可能会有不同的 fields。例如,有个 collection 叫 Media,包含两条 documents,; w; e# ~( o. y" F+ Y7 g& d+ `' K
) t6 ~2 x$ p7 |' a* l8 Y{3 e6 Y- A: E# b7 I- l" H |
"ISBN": "987-30-3652-5130-82",1 K1 A( ~) p: r7 D8 r( {
"Type": "CD",5 F* k# H& t! X
"Author": "Nirvana",
) ^: D/ `- U2 M# [; ?3 t/ i "Title": "Nevermind",1 o+ a( a& L. m% @/ X9 m
"Genre": "Grunge",, n2 J$ i! G& s; l
"Releasedate": "1991.09.24",
7 T9 o+ E5 S/ w5 V) b "Tracklist": [% O5 O9 Z& |) ?+ y! F0 Z
{+ w. A1 h. i2 d6 g
"Track" : "1",
* c3 O1 I6 V* U8 i) S$ @$ V "Title" : "Smells like teen spirit",! s0 G! g) p+ Q
"Length" : "5:02"
4 h& `0 O$ \6 f K: x4 E( | },
* I6 u9 z0 g# X/ ]! ] {
9 _9 D% [& K8 `0 U$ S! B& ^ "Track" : "2",% i, u$ W* X6 v
"Title" : "In Bloom",
9 U# b4 `$ y& S7 j8 ?- t, q: m' c- K "Length" : "4:15"
5 q; Z+ q y- `8 F }
' w; H# c& [: g7 v ]3 T( _: S4 } Z* Z) |" s, a
}
7 ^2 R8 d a# I* A6 s3 h0 c7 Z
* m+ b' G9 ^9 I) c: l{! c+ s0 x% ^9 n/ {& N
"ISBN": "987-1-4302-3051-9",9 M0 e3 Z* h+ X5 J0 n2 P& h; |
"Type": "Book",& ?( s" m/ d* N9 v2 ]8 U0 Q" O
"Title": "Definite Guide to MongoDB: The NoSQL Database",
6 G; O/ e' x3 |5 M- ]7 j* ? "Publisher": "Apress",8 B( W u2 z- L8 S8 m" J7 E
"Author": " Eelco Plugge",9 [4 T( _$ d; W
"Releasedate": "2011.06.09") x6 D$ ^! \1 k2 [! P3 x; b; R
}
: c3 E1 R/ f" v6 l: `
4 a6 f% q' f. I) | 假如,在同一个 collection 中的所有 document,都包含某个共同的 field,例如前例中的“ISBN”,那么我们就可以按照这个 field 的值,来分割 collection。这个 field 的值,又称为 shard key。 @- ]" k5 m+ i- M5 u; \9 y
, a$ c, [8 |' y8 ?3 C! L 在选择shard key的时候,一定要确保这个key能够把collection均匀地切分成很多chunks。
; Z5 V0 ~' }' \% w2 E7 L% q7 \6 x& j. H: f9 P
例如,如果我们选择“author”作为shard key,如果有大量的作者是重名的,那么就会有大量的数据聚集在同一个chunk中。当然,假设很少有作者同名同姓,那么“author”也可以作为一个shard key。换句话说,shard key 的选择,与使用场景密切相关。) a' E B# _: ?1 n- B/ Y
; Z" H( S, [# d 很多情况下,无论选择哪一个单一的 field 作为shard key,都无法均匀分割 collection。在这种情况下,我们可以考虑,用多个 fields,构成一个复合的shard key。
1 I- x" n; f% U; t
) `# z Z6 N; I1 Y/ E# ?: W5 q% T i 延续前例,假如有很多作者同名同姓,他们都叫“王二”。用 author 作为 shard key,显然无法均匀切割 collection。这时我们可以加上release-date,组成name-date的复合 shard key,例如“王二 2011”。
/ D ?7 F' e6 Z V5 X3 [0 C B/ e5 d; a9 ~: }, Q
Chunks
! d( R$ l. ~5 Y8 E. j B/ [
! k; m* C# }* L9 q- d MongoDB按 shard key,把 collection切割成若干 chunks。每个 chunk 的数据结构,是一个三元组,{collection,minKey,maxKey},如图1-2 所示。
1 m) Z% y1 a) Q& b$ `2 H
- F8 O) h& e; Z* U
# Z4 v9 v( r# D, f图1-2 chunk的三元组
" g: D3 @9 g; x6 o! k+ Y. p- Q! y# D% M, a9 ~; n9 I2 D" p, N
其中,collection 是数据库中某一个表的名称,而 minKey 和 maxKey 是 shard key的范围。每一个 document 的shard key 的值,决定了这条document应该存放在哪个chunk中。. X" ]# X1 p8 }' g0 @& a6 {
% @: u( p4 } [6 A5 A$ E' w 如果两条 documents 的 shard keys 的值很接近,这两条 documents 很可能被存放在同一个 chunk 中。* y5 ?- C( ?; C6 C+ }0 y
* }! J" m% a7 b8 K- L# `
Shard key 的值的顺序,决定了 document 存放的 chunk。在 MongoDB 的文献中,这种切割 collection 的方式,称为order-preserving。
/ l$ j8 `7 Z1 }/ C, g( F2 A( O; O+ p2 r+ G2 t
一个 chunk最多能够存储64MB的数据。 当某个chunk存储的 documents包含的数据量,接近这个阈值时,一个chunk会被切分成两个新的chunks。" j, B: I7 @4 u0 O
2 {( e3 j1 ^, M2 e' P0 \' V 当一个shard存储了过多的chunks,这个shard中的某些chunks会被迁移到其它 shard中。( f7 |! x# h( T) m7 @# Z
0 j. g J7 e0 C- L+ ], R; f 这里有个问题,假如某一条 document 包含的数据量很大,超过 64MB,一个 chunk 存放不下,怎么办?在后续章节介绍 GridFS 时,我们会详细讨论。1 F' i2 Y- A3 m7 a, Q
4 D7 z5 f' w/ A" A: t4 ^
Replica set
$ N0 ~- @9 ^# t9 k% w
. e6 B5 p4 t3 n9 f+ L 在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。
9 e/ ]: {: ?6 ^. ]+ U0 V! ^
( ~5 `4 H4 ^0 \5 R3 q 这个replica set包括一个primary DB和多个secondary DBs。为了数据的一致性,所有的修改(insert / update / deletes) 请求都交给primary处理。处理结束之后,再异步地备份到其他secondary中。
m. D, l W. f* e/ _: A( D
; L' @$ F! `) d. Y& K; S: S Primary DB由replica set中的所有servers,共同选举产生。当这个primaryDB server出错的时候,可以从replica set中重新选举一个新的primaryDB,从而避免了单点故障。
# }* }3 e5 h$ N$ O/ [( h
[6 \+ F; `( n7 \ Replica set的选举策略和数据同步机制,确保了系统的数据的一致性。后文详述。
. q: }6 f+ d4 L% E1 |8 t
9 q" w& m$ V) o0 s2 m" @Config Server
$ p9 n$ a, d+ @; x 9 h. _, C3 G n9 a
Config servers用于存储MongoDB集群的元数据 metadata,这些元数据包括如下两个部分,每一个shard server包括哪些chunks,每个chunk存储了哪些 collections 的哪些 documents。
) E$ L$ G7 P: _# f# i F
E' H0 X/ F6 O 每一个config server都包括了MongoDB中所有chunk的信息。
& H+ z" j5 c( I
6 K1 t& {2 T' _8 ^) N" X! { Config server也需要 replication。但是有趣的是,config server 采用了自己独特的replication模式,而没有沿用 replica set。2 q: w6 Z- G( ? c" @2 [
+ b1 t1 L. p- z 如果任何一台config server挂了,整个 config server 集群中,其它 config server变成只读状态。这样做的原因,是避免在系统不稳定的情况下,冒然对元数据做任何改动,导致在不同的 config servers 中,出现元数据不一致的情况。
) g& u3 T9 x; a. n/ d: ?8 }4 ` X7 I* y4 s1 @
MongoDB的官方文档建议,配置3个config servers比较合适,既提供了足够的安全性,又避免了更多的config servers实例之间的数据同步,引起的元数据不一致的麻烦。7 Y; I I# N* N I
8 o2 o, M4 G# O* @5 ]2 c* ^Mongos
( x* e# T7 [+ b1 k- z- Y' h- @& s+ }5 O* u0 X8 [5 z+ K# I8 w
用户使用MongoDB 时,用户的操作请求,全部由mongos来转发。5 A! _8 A3 z' D1 J' X1 h* u
& a- i- v n, D* t 当 mongos 接收到用户请求时,它先查询 config server,找到存放相应数据的shard servers。然后把用户请求,转发到这些 shard servers。当这些 shard servers完成操作后,它们把结果分别返回给 mongos。而当 mongos 汇总了所有的结果后,它把结果返回给用户。) ?1 B1 w% m0 S+ f( d8 p
; B$ A5 J% y# o
Mongos每次启动的时候,都要到config servers中读取元数据,并缓存在本地。每当 config server中的元数据有改动,它都会通知所有的mongos。, G0 @- _6 t$ @
" B% a$ H L% B
Mongos之间,不存在彼此协同工作的问题。因此,MongoDB所需要配置的mongos server的数量,没有限制。
2 d3 f% y: G" F1 K/ m3 d
& I6 v5 ?6 S$ c ~2 y* u 通过以上的介绍,我们对每个组成部分都有了基本的了解,但是涉及到工作的细节,我们尚有诸多疑问,例如,一个chunk的数据太大,如何切分?一个shard数据太多,如何迁移?在replica set中,如何选择primary?server挂了,怎么进行故障恢复?接下来的章节,我们逐个回答这些问题。) F* G2 l. \* a' x8 r
( B- e' K: m$ O# D- c+ r
- [: q; D- y: t7 w6 D" b" M
Reference,
+ s* I) i3 z" V
3 A' p" A+ S# c, G' N[0] Architectural Overview; R, U& x% H7 R7 K$ f) L+ \% N. a4 ^+ h& Q
http://www.mongodb.org/display/DOCS/Sharding+Introduction4 F, U7 q; k# y$ B2 J
|
评分
-
查看全部评分
|