|
关于MongoDB,我们能看到的资料,基本都是在指导大家如何使用MongoDB,但是,MongoDB内部是如何运作的,资料不是很多。 h2 k& c$ j; C% O1 a
# i7 k& v: Z; I
阅读使用手册,会有很多疑惑之处。例如,有人说,MongoDB 等同于分布式的 MySQL。它把一个Table ,按 row,分割成多个Shards,分别存放在不同的 Servers 上。这种说法是否正确?
& n9 I* X. Z; u0 N
5 ?( \, x# R7 t: U4 N5 H 不深入了解 MongoDB 的内部结构,就无法透彻地回答类似问题。这个系列文章,就来和大家探讨MongoDB的内部的工作方式。, I3 I. f8 Q3 k ?: D4 ^
$ `6 t4 W) ~- r0 d2 y
9 c4 l/ L* W; W" r0 L# O# }2 u2 V& l& e7 _7 k
图1-1 MongoDB架构图 ! q; g3 Z# K" _) v; r0 C! y( v
7 P: f) F- T1 ]2 F MongoDB 通常运行在一个服务器集群上,而不是一个单机。图1-1,描述了一个MongoDB集群的基本组成部分,包括若干shards,至少一个config server,至少一个routing servers(又称 mongos)。, n+ u) ]! Y, N2 H7 w- A" Q! A# }
5 D( X# l! ^' d \. ^; qShards
& `: A! n+ X$ m ^& M
3 b! \/ `3 b$ Q8 A9 C MongoDB的最基本的数据单元,叫document,类似于关系式数据库中的行 row。一系列documents,组成了一个collection,相当于关系式数据库中的table。当一个 collection 数据量太大时,可以把该collection按documents切分,分成多个数据块,每个数据块叫做一个chunk,多个chunks聚集在一起,组成了一个shard。
4 R- r( J- x+ |# r" ~% U# m$ c* |$ ~7 {" a' r, M
Sharding 的意义,不仅保障了数据库的扩容(scalability),同时也保障了系统的负载均衡(load balance)。/ D9 g7 p* f5 q2 }' g# y* w5 U2 I4 b
. I0 S# d) c8 ^& g
每一个shard存储在一个物理服务器(server)上。Server上运行着mongod进程,通过这个进程,对shard中的数据进行操作,主要是增删改查。7 n/ h) [+ ?# X9 t4 b
6 S& |$ @, r# q7 G
如果系统中的每个shard,只存储了一份数据,没有备份,那么当这个shard所在的server挂了,数据就丢失了。在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。* a; e4 l4 Q. R( p( j/ ?1 K
% N7 J0 q' h' E0 C
Shard keys
; \/ H& j( g) q% ~6 Y# j. B4 P * M1 K6 w7 G- k; ~' [3 ?4 r
为了把collection切分成不同的chunks,从而存放到不同的shards中,我们需要制定一个切分的方式。
& u, d9 {8 {: C; C' b( Q. J8 b! }7 P! R$ \9 b+ V2 l
如前所述,在 MongoDB 数据库中,一个表collection由多个行 documents 组成,而每个 document,有多个属性 fields。同一个 collection 中的不同的 documents,可能会有不同的 fields。例如,有个 collection 叫 Media,包含两条 documents,# L: B# n0 C# C' k& w% Q5 U
$ q# D; b0 O, F: i{+ F) w+ w9 i( ?
"ISBN": "987-30-3652-5130-82",
- ]+ Q- j* T" c3 t "Type": "CD",0 R& U% J* e% C
"Author": "Nirvana",
3 F% P/ F6 l* \( ]. ~* r } "Title": "Nevermind",
1 |3 W& I: A( i4 L "Genre": "Grunge",6 _* F2 G, e0 G! W+ N/ t
"Releasedate": "1991.09.24",
9 }; {' A4 ?) }0 t3 U- Y "Tracklist": [ A; U) e& Q" E( Z/ }4 V
{5 K9 N( e) |$ N5 y
"Track" : "1",
, A3 ?. U9 J: x+ ]! X R "Title" : "Smells like teen spirit",
9 z8 F3 f J0 Q6 X* Y- N "Length" : "5:02"9 \ b4 G1 |6 z
},
& P4 t; s. h! t! N% r1 S2 @ {: f4 c# [$ c2 a& E9 S" r$ e
"Track" : "2",
& J& `4 D6 x: k# | "Title" : "In Bloom",
_4 v- \0 |$ i q0 S$ x5 ` "Length" : "4:15"
9 U7 Y$ c/ B6 r }( A/ i: U% z0 W
]& _; c' A0 }' \( r
}
3 C4 x1 \; A7 n, h G; ^2 L9 `+ g
{
- }3 ^; G1 A; n- J "ISBN": "987-1-4302-3051-9",
/ L6 }" l0 c; h4 f0 y9 O/ u "Type": "Book",
2 V1 m# Q! O* O3 {7 F2 w5 x3 [ "Title": "Definite Guide to MongoDB: The NoSQL Database",
$ \. \$ x4 n. b# g: b# n2 G "Publisher": "Apress",
4 K n- d5 E: q3 D "Author": " Eelco Plugge",( V4 s% K8 B1 \1 i
"Releasedate": "2011.06.09"
7 Z* T" e. }4 c; T9 J$ ]$ J5 W}$ _0 H2 K" {& x; H" w: V) C
: R7 x- C7 |# g4 B 假如,在同一个 collection 中的所有 document,都包含某个共同的 field,例如前例中的“ISBN”,那么我们就可以按照这个 field 的值,来分割 collection。这个 field 的值,又称为 shard key。! B7 l- K+ t' w! z% j
( ]9 l' V. s- N# m# Q* q8 e; ? 在选择shard key的时候,一定要确保这个key能够把collection均匀地切分成很多chunks。
* x2 |7 u# h' `* g) @( L9 W: ]& O/ s9 d! T
例如,如果我们选择“author”作为shard key,如果有大量的作者是重名的,那么就会有大量的数据聚集在同一个chunk中。当然,假设很少有作者同名同姓,那么“author”也可以作为一个shard key。换句话说,shard key 的选择,与使用场景密切相关。
1 D; v- `$ ~& [: h d% |$ m @: [% l5 g! g# W# \6 K
很多情况下,无论选择哪一个单一的 field 作为shard key,都无法均匀分割 collection。在这种情况下,我们可以考虑,用多个 fields,构成一个复合的shard key。, P; p% V0 m# o Z! x3 C# C
% b9 E1 [8 V1 f$ P7 F$ K+ {8 d 延续前例,假如有很多作者同名同姓,他们都叫“王二”。用 author 作为 shard key,显然无法均匀切割 collection。这时我们可以加上release-date,组成name-date的复合 shard key,例如“王二 2011”。
! W k; m8 L, n% U" _! M0 p1 Y( v0 H0 O: \. Q
Chunks+ G/ g+ w% _% d2 p0 l. e
0 F4 R8 U9 e; l$ j4 C9 i MongoDB按 shard key,把 collection切割成若干 chunks。每个 chunk 的数据结构,是一个三元组,{collection,minKey,maxKey},如图1-2 所示。
! r0 x: o1 s, N# C5 X& X% Z/ F) E0 u: P8 K9 v, ?7 x/ s$ N
/ v8 a" N: A: p3 X% C* b" R
图1-2 chunk的三元组
; i1 {& Y; y" i5 Y
7 \) c6 H9 C3 ^- F5 y( {! G5 V8 u 其中,collection 是数据库中某一个表的名称,而 minKey 和 maxKey 是 shard key的范围。每一个 document 的shard key 的值,决定了这条document应该存放在哪个chunk中。2 d, u. m) W7 s$ ^% D4 {; P2 w/ `
4 N# u2 y& ]$ o0 U# m+ j/ X( L9 ^1 y
如果两条 documents 的 shard keys 的值很接近,这两条 documents 很可能被存放在同一个 chunk 中。
. b* u0 N' f+ }' a. w+ g9 O( f- m/ Q
Shard key 的值的顺序,决定了 document 存放的 chunk。在 MongoDB 的文献中,这种切割 collection 的方式,称为order-preserving。+ c0 ?: j6 v* w6 e: O- \
: V6 K$ P2 h2 i; J3 L% W
一个 chunk最多能够存储64MB的数据。 当某个chunk存储的 documents包含的数据量,接近这个阈值时,一个chunk会被切分成两个新的chunks。$ j* {- Z" x- @/ }- q& E: S
4 p: j J, ]. z7 F, h4 y \ Q
当一个shard存储了过多的chunks,这个shard中的某些chunks会被迁移到其它 shard中。( T, M% Q2 W! y4 X, L4 o
; S/ U5 A O/ X
这里有个问题,假如某一条 document 包含的数据量很大,超过 64MB,一个 chunk 存放不下,怎么办?在后续章节介绍 GridFS 时,我们会详细讨论。
+ P6 ]9 x4 D: \0 w0 h& W% G" ^' ?4 S: @. B/ i
Replica set
0 g1 v! w+ w1 o+ i+ A 1 u/ @8 J4 Y: w: U- x* Q
在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。* E9 o: H2 N* i
3 h, o7 ~- D, B/ e& ?' R% J% `0 D
这个replica set包括一个primary DB和多个secondary DBs。为了数据的一致性,所有的修改(insert / update / deletes) 请求都交给primary处理。处理结束之后,再异步地备份到其他secondary中。
3 \4 H; y8 o, P5 k9 L: T" p" H
# I: Q. _6 q7 j4 e) v Primary DB由replica set中的所有servers,共同选举产生。当这个primaryDB server出错的时候,可以从replica set中重新选举一个新的primaryDB,从而避免了单点故障。& j8 V' m0 ~5 Z1 n2 y
/ t# L; ~9 c: H# K Replica set的选举策略和数据同步机制,确保了系统的数据的一致性。后文详述。2 E( k9 \( f, |' p
+ `4 n5 t3 `! z" M5 j9 Z1 M' P$ [4 yConfig Server4 v j, e4 E# M7 _" |9 Y
) }% s4 y; @6 l v& Y# N( c! ~9 V- ~
Config servers用于存储MongoDB集群的元数据 metadata,这些元数据包括如下两个部分,每一个shard server包括哪些chunks,每个chunk存储了哪些 collections 的哪些 documents。
6 s9 @! D, r, }+ b& e w; u8 k( S: E, o1 j: d! H
每一个config server都包括了MongoDB中所有chunk的信息。
0 K1 x$ j6 @: V: l1 e7 W
; g1 J! W0 L, @$ a Config server也需要 replication。但是有趣的是,config server 采用了自己独特的replication模式,而没有沿用 replica set。
) |3 y) I# Q; z6 r3 Y: c4 C
. H) {! D* q5 B; T9 b 如果任何一台config server挂了,整个 config server 集群中,其它 config server变成只读状态。这样做的原因,是避免在系统不稳定的情况下,冒然对元数据做任何改动,导致在不同的 config servers 中,出现元数据不一致的情况。( R+ d( m6 Z' P, z$ o
0 G" H+ K9 Q$ P2 P3 w; ?, Y( [# f MongoDB的官方文档建议,配置3个config servers比较合适,既提供了足够的安全性,又避免了更多的config servers实例之间的数据同步,引起的元数据不一致的麻烦。) Y9 M. I- r; r+ D( f9 [
& n, V& e. F' }0 w' x
Mongos
' y* i1 N% @0 j& G. \) E. ]8 n1 H8 j5 M$ k
用户使用MongoDB 时,用户的操作请求,全部由mongos来转发。
. X* U1 U0 t' S8 N6 H# w( v5 \ T' h& F X% N& a- e8 f
当 mongos 接收到用户请求时,它先查询 config server,找到存放相应数据的shard servers。然后把用户请求,转发到这些 shard servers。当这些 shard servers完成操作后,它们把结果分别返回给 mongos。而当 mongos 汇总了所有的结果后,它把结果返回给用户。
J2 y0 D; E1 U J9 K( H2 M/ o# `5 Q3 C& A
Mongos每次启动的时候,都要到config servers中读取元数据,并缓存在本地。每当 config server中的元数据有改动,它都会通知所有的mongos。
0 G' \& }! R+ v0 B' y, @; M, X% F' N: [/ R$ X' @- X8 L2 c+ D
Mongos之间,不存在彼此协同工作的问题。因此,MongoDB所需要配置的mongos server的数量,没有限制。
' o# A4 Q! M1 [' ^. p5 Y
: y. Z+ e p% I 通过以上的介绍,我们对每个组成部分都有了基本的了解,但是涉及到工作的细节,我们尚有诸多疑问,例如,一个chunk的数据太大,如何切分?一个shard数据太多,如何迁移?在replica set中,如何选择primary?server挂了,怎么进行故障恢复?接下来的章节,我们逐个回答这些问题。
6 D5 K- r h( _* c
& T* i1 I$ j/ W) K
" X' l& E+ @; m7 k" x( ~5 K/ WReference,0 L& f2 f8 c2 e0 b
0 L. X+ T0 i1 D/ h: r' A; |, \' u1 K
[0] Architectural Overview
% y0 n( r/ H; X. e& qhttp://www.mongodb.org/display/DOCS/Sharding+Introduction$ C9 r! J* D3 Y% i9 U% X
|
评分
-
查看全部评分
|