|
|
关于MongoDB,我们能看到的资料,基本都是在指导大家如何使用MongoDB,但是,MongoDB内部是如何运作的,资料不是很多。
- _) s3 }7 l& E) }
7 {* Z5 V% v0 p& \# ~0 P 阅读使用手册,会有很多疑惑之处。例如,有人说,MongoDB 等同于分布式的 MySQL。它把一个Table ,按 row,分割成多个Shards,分别存放在不同的 Servers 上。这种说法是否正确?8 w) S9 b3 V# N8 k7 S3 N
; Z6 V L& \/ t3 S; D7 R0 B, q 不深入了解 MongoDB 的内部结构,就无法透彻地回答类似问题。这个系列文章,就来和大家探讨MongoDB的内部的工作方式。: m. b# F/ a$ v6 t& K. R1 a
9 L- ^3 m; I4 r+ s. k" Z- \1 w
/ O9 ~' @+ A7 f& J- s6 B: H3 Q
+ C( Z* j9 I1 t* L. T/ ]* C* _( i图1-1 MongoDB架构图
. M, ]6 ?/ q2 v4 Q1 h
L+ f4 w% u# G! s MongoDB 通常运行在一个服务器集群上,而不是一个单机。图1-1,描述了一个MongoDB集群的基本组成部分,包括若干shards,至少一个config server,至少一个routing servers(又称 mongos)。
8 o4 W- O7 s x$ T% K0 ?& P( v/ V1 k5 s' \2 T6 {) e2 K
Shards
$ o( U, w9 @$ d! U) l5 ]- E/ J; m6 D" h8 {
MongoDB的最基本的数据单元,叫document,类似于关系式数据库中的行 row。一系列documents,组成了一个collection,相当于关系式数据库中的table。当一个 collection 数据量太大时,可以把该collection按documents切分,分成多个数据块,每个数据块叫做一个chunk,多个chunks聚集在一起,组成了一个shard。
, n Q) {$ a( C8 D( B7 [' X. l# p% i. w& C
Sharding 的意义,不仅保障了数据库的扩容(scalability),同时也保障了系统的负载均衡(load balance)。
; C" ~ _5 E7 D. e8 ]8 ~
; @4 O1 n- K7 I7 ] 每一个shard存储在一个物理服务器(server)上。Server上运行着mongod进程,通过这个进程,对shard中的数据进行操作,主要是增删改查。" U8 i4 ]4 ]+ g+ O$ G0 R8 ]; o
% L6 G5 z6 H5 ]6 f& k) z( { 如果系统中的每个shard,只存储了一份数据,没有备份,那么当这个shard所在的server挂了,数据就丢失了。在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。
" O C" H9 y. X4 e% G" L! G2 \' v( i" ~+ ]
Shard keys
$ y9 Z9 p- {- a" a- i! a
' @5 Y! G ~; E+ e) { 为了把collection切分成不同的chunks,从而存放到不同的shards中,我们需要制定一个切分的方式。4 e1 g1 H0 J2 g- U& q' z/ m
8 r) p* S$ e$ Q6 C& l; o- ^ 如前所述,在 MongoDB 数据库中,一个表collection由多个行 documents 组成,而每个 document,有多个属性 fields。同一个 collection 中的不同的 documents,可能会有不同的 fields。例如,有个 collection 叫 Media,包含两条 documents,
& d( m& H8 I5 K# O: `7 q
5 @- K' B5 ]8 K( M' u! s{% Z% _- ^$ o" S
"ISBN": "987-30-3652-5130-82",2 S! }. Q) l1 f" v2 x/ q
"Type": "CD",
/ Q/ t. c) F! T3 o7 [9 p& a9 w) } "Author": "Nirvana",
8 q& y! V2 I" l3 U4 c* Q "Title": "Nevermind",0 v& b! N* k1 x3 D# f8 U
"Genre": "Grunge"," l% \6 ^ l6 q
"Releasedate": "1991.09.24",
* R9 {# ?5 w+ N4 Z, \3 r "Tracklist": [; a6 Y3 z0 @' P( H9 I
{; J5 e( w) I" \" ?' i) ]
"Track" : "1",
/ \% V; v/ G! l "Title" : "Smells like teen spirit",
9 W4 I$ Q/ M- T: E "Length" : "5:02"
% [ ]6 Y! D/ i4 X },
' a% L/ S& W/ v4 l. a& U {
; @/ T) v" B. t% v6 C "Track" : "2",
% f& a" C: j7 u8 g3 @! t! g "Title" : "In Bloom",
0 i0 p1 i# l, `0 c "Length" : "4:15"
/ H0 K* h% n. T* p6 G2 j8 l }/ |+ a- w9 G* E7 X( [
]& d$ |( ]( {5 j Z1 j+ |9 ]( ^
}
5 o) o+ W7 |5 D. P6 ~5 M% c/ {/ J+ {8 d
{( o* D& x0 o& v1 T# a, K1 c
"ISBN": "987-1-4302-3051-9",
' H0 ]& c" R% T/ j; u/ P "Type": "Book",
* ?" b3 U4 I7 }& T/ X "Title": "Definite Guide to MongoDB: The NoSQL Database",7 }) } @) k4 W8 m' G3 G% L
"Publisher": "Apress",9 L E; q; j0 T* W3 y
"Author": " Eelco Plugge",+ \9 {3 f, g9 f. n8 o* j
"Releasedate": "2011.06.09"2 F, k( o) T. x( z$ b) P* a
}. Q: V" X* G$ |
2 T/ [% g" n7 g3 ~( q0 T$ \
假如,在同一个 collection 中的所有 document,都包含某个共同的 field,例如前例中的“ISBN”,那么我们就可以按照这个 field 的值,来分割 collection。这个 field 的值,又称为 shard key。
. e6 G2 j0 o% ^& s9 K# n$ D2 i- g' t4 { a4 I
在选择shard key的时候,一定要确保这个key能够把collection均匀地切分成很多chunks。
7 m4 J- J& X% D8 J" k' }# C h$ \/ B
/ {# u A- C i1 u! r 例如,如果我们选择“author”作为shard key,如果有大量的作者是重名的,那么就会有大量的数据聚集在同一个chunk中。当然,假设很少有作者同名同姓,那么“author”也可以作为一个shard key。换句话说,shard key 的选择,与使用场景密切相关。- V! Y' K8 @' x' J% k, K
8 n+ F( x2 q: Q8 _4 g& B% d$ Z. d
很多情况下,无论选择哪一个单一的 field 作为shard key,都无法均匀分割 collection。在这种情况下,我们可以考虑,用多个 fields,构成一个复合的shard key。2 m3 A+ e# |# U2 o
+ h4 G1 Z/ O+ B% K* @4 C$ \ 延续前例,假如有很多作者同名同姓,他们都叫“王二”。用 author 作为 shard key,显然无法均匀切割 collection。这时我们可以加上release-date,组成name-date的复合 shard key,例如“王二 2011”。
& h. g Y% ~& z: u; e# f: ?" i& r* n* E" a* R2 |- t; Q
Chunks& d8 m1 s" T5 b8 `7 ^+ @
: ^& `5 u- J2 U( E/ [
MongoDB按 shard key,把 collection切割成若干 chunks。每个 chunk 的数据结构,是一个三元组,{collection,minKey,maxKey},如图1-2 所示。 L3 w! ~4 \+ n0 a1 L) n/ t& l8 |
' ~% V% C! C9 e3 k [( v9 [
1 O% m* r2 y* K8 @! W5 c
图1-2 chunk的三元组 / E$ p5 Z; I) m7 X# `; e
# q( g4 {0 W* K
其中,collection 是数据库中某一个表的名称,而 minKey 和 maxKey 是 shard key的范围。每一个 document 的shard key 的值,决定了这条document应该存放在哪个chunk中。! @6 [9 a* H2 E J2 E
# S" J) ^7 s7 A" Z5 Q1 i* ?" n/ l- b
如果两条 documents 的 shard keys 的值很接近,这两条 documents 很可能被存放在同一个 chunk 中。8 l& ]4 M7 o- W. U w
( {$ a: x+ J- b" C
Shard key 的值的顺序,决定了 document 存放的 chunk。在 MongoDB 的文献中,这种切割 collection 的方式,称为order-preserving。
7 z# x! z7 S2 I6 S2 T! A0 t4 y3 A1 ~1 n" {
一个 chunk最多能够存储64MB的数据。 当某个chunk存储的 documents包含的数据量,接近这个阈值时,一个chunk会被切分成两个新的chunks。
0 @ b+ }% d& y; ?& r# C9 m5 I# k
% N" |! F8 m; U# B( G' e 当一个shard存储了过多的chunks,这个shard中的某些chunks会被迁移到其它 shard中。
/ M3 \( C; q- g2 K0 {" a" i8 y- G3 J! G! A- n6 r
这里有个问题,假如某一条 document 包含的数据量很大,超过 64MB,一个 chunk 存放不下,怎么办?在后续章节介绍 GridFS 时,我们会详细讨论。6 X- \, a1 H5 I8 ~0 c
2 K4 k+ _7 ^, d0 u" P+ |
Replica set4 J4 h% z! i$ _& o9 a. z" a# A
. n: H" z2 F8 `5 k1 v
在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。 y* z9 X0 }: u. M
% l- M) F/ p/ @8 s& @ 这个replica set包括一个primary DB和多个secondary DBs。为了数据的一致性,所有的修改(insert / update / deletes) 请求都交给primary处理。处理结束之后,再异步地备份到其他secondary中。
- a! ]4 k9 y5 y/ l9 b4 G9 e7 y
* ~- y7 y* n0 Z* e* J0 X/ G% U0 { Primary DB由replica set中的所有servers,共同选举产生。当这个primaryDB server出错的时候,可以从replica set中重新选举一个新的primaryDB,从而避免了单点故障。
" y& \ `' O( D" N' U0 J4 ]
6 \6 l1 ?$ Q( g O8 c$ k( @, a% m. t Replica set的选举策略和数据同步机制,确保了系统的数据的一致性。后文详述。# r# r0 P I( u& ~3 ?9 c
' U/ ]7 n7 v$ G. [1 l$ [8 ^Config Server
, q: p) `) |% E) U( i. Y
- A/ F4 X3 c: _0 e: R! K" n8 Q Config servers用于存储MongoDB集群的元数据 metadata,这些元数据包括如下两个部分,每一个shard server包括哪些chunks,每个chunk存储了哪些 collections 的哪些 documents。6 L; @: |- R' u# K' _
, r: z0 Y4 O5 k% y3 a5 E
每一个config server都包括了MongoDB中所有chunk的信息。
+ A3 H! c' l4 t" `# t! N+ [
7 E. M+ ^# z" ~" b+ \( X Config server也需要 replication。但是有趣的是,config server 采用了自己独特的replication模式,而没有沿用 replica set。 L8 y; Q% B: M# k. K
2 Q& ]) [7 R- a: B% e
如果任何一台config server挂了,整个 config server 集群中,其它 config server变成只读状态。这样做的原因,是避免在系统不稳定的情况下,冒然对元数据做任何改动,导致在不同的 config servers 中,出现元数据不一致的情况。
0 J3 h# u3 `/ Y% D# N3 R7 A1 T4 t0 N9 I0 [; n8 c0 g ]6 h7 n& `
MongoDB的官方文档建议,配置3个config servers比较合适,既提供了足够的安全性,又避免了更多的config servers实例之间的数据同步,引起的元数据不一致的麻烦。
9 T$ ?- N/ r$ q/ D- { k; O- f' {" m3 i
8 _7 d3 A5 W$ X! \. D lMongos
/ B, R o6 [5 f4 I( i3 u. r" H
, k8 C( d; C* K 用户使用MongoDB 时,用户的操作请求,全部由mongos来转发。
0 O. U! ^* e- ^0 I- f/ I5 u7 e9 @1 v( k2 g$ o% q
当 mongos 接收到用户请求时,它先查询 config server,找到存放相应数据的shard servers。然后把用户请求,转发到这些 shard servers。当这些 shard servers完成操作后,它们把结果分别返回给 mongos。而当 mongos 汇总了所有的结果后,它把结果返回给用户。& F0 L8 E# P7 p9 Y) W8 ]) T4 H
2 {2 w, M s: Y5 c* i# c Mongos每次启动的时候,都要到config servers中读取元数据,并缓存在本地。每当 config server中的元数据有改动,它都会通知所有的mongos。; n; M3 f \) {& k4 E8 N A6 o
% o: Y/ c/ Q9 S; W1 g4 ^' w; \% \) y
Mongos之间,不存在彼此协同工作的问题。因此,MongoDB所需要配置的mongos server的数量,没有限制。- i/ u* j+ T! ?
' L( R3 T4 y+ Y9 M
通过以上的介绍,我们对每个组成部分都有了基本的了解,但是涉及到工作的细节,我们尚有诸多疑问,例如,一个chunk的数据太大,如何切分?一个shard数据太多,如何迁移?在replica set中,如何选择primary?server挂了,怎么进行故障恢复?接下来的章节,我们逐个回答这些问题。3 u1 R0 x) Z1 ?8 [3 b: G9 c
$ l5 v$ L% V6 t9 ] m
0 S Y4 T ]# B8 U% }
Reference,8 |& A+ ?3 c l6 _3 {( P
C J. @ e8 }$ I5 U* B! J
[0] Architectural Overview% T! f! A" N5 \
http://www.mongodb.org/display/DOCS/Sharding+Introduction
/ N. _' r( m' v) O; o5 c |
评分
-
查看全部评分
|