|
|
关于MongoDB,我们能看到的资料,基本都是在指导大家如何使用MongoDB,但是,MongoDB内部是如何运作的,资料不是很多。
3 ~- b0 `2 S3 A: A! Z* q/ v" u4 G4 |# n- ~$ x& `! D
阅读使用手册,会有很多疑惑之处。例如,有人说,MongoDB 等同于分布式的 MySQL。它把一个Table ,按 row,分割成多个Shards,分别存放在不同的 Servers 上。这种说法是否正确?5 b1 P8 W5 q4 c* _
2 k0 t1 I( }8 G+ P: W
不深入了解 MongoDB 的内部结构,就无法透彻地回答类似问题。这个系列文章,就来和大家探讨MongoDB的内部的工作方式。& i( V/ t, u# d7 s! F1 f/ k5 c
& }& X: q! v& A }
O/ h+ F7 O/ V8 p* u/ D. `7 f' I) M: M! ~/ I
图1-1 MongoDB架构图
4 F) X ^5 H) e3 y2 A! `& u$ _& ?: a! w* q/ M
MongoDB 通常运行在一个服务器集群上,而不是一个单机。图1-1,描述了一个MongoDB集群的基本组成部分,包括若干shards,至少一个config server,至少一个routing servers(又称 mongos)。
, `3 H# T7 e8 _/ B Z
- E3 n0 b8 N* N3 w7 v) E) W# @. fShards
2 w8 s* k8 D, E/ e4 ^- ?$ f) @7 U
+ |, L: n" T' O8 c. D/ e$ v MongoDB的最基本的数据单元,叫document,类似于关系式数据库中的行 row。一系列documents,组成了一个collection,相当于关系式数据库中的table。当一个 collection 数据量太大时,可以把该collection按documents切分,分成多个数据块,每个数据块叫做一个chunk,多个chunks聚集在一起,组成了一个shard。
. l T+ w1 r% [* y
( e& B3 K1 m9 n Sharding 的意义,不仅保障了数据库的扩容(scalability),同时也保障了系统的负载均衡(load balance)。
* h0 E3 B7 Y9 E e9 F# \$ m: K0 @9 H0 n. }, {
每一个shard存储在一个物理服务器(server)上。Server上运行着mongod进程,通过这个进程,对shard中的数据进行操作,主要是增删改查。8 n5 ]8 w5 h: x' o* G h
3 d' V9 O4 {- k 如果系统中的每个shard,只存储了一份数据,没有备份,那么当这个shard所在的server挂了,数据就丢失了。在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。' s1 _$ q% J2 z+ p: W" w+ w
/ a, y9 d; M2 ~) v
Shard keys
: y+ F% O& j# Z8 w& S. T' X
0 o- x5 e& _* `9 ]( v- O8 L, O! u 为了把collection切分成不同的chunks,从而存放到不同的shards中,我们需要制定一个切分的方式。; u/ h- R* O% w
( b& \( T! k5 Z0 M- K 如前所述,在 MongoDB 数据库中,一个表collection由多个行 documents 组成,而每个 document,有多个属性 fields。同一个 collection 中的不同的 documents,可能会有不同的 fields。例如,有个 collection 叫 Media,包含两条 documents,
2 M# |2 R# I. u! a1 G5 m! x: d1 V( D& r/ [4 w
{
# s" T1 y1 Z. s- F" v5 p4 N' n "ISBN": "987-30-3652-5130-82",9 t' l* D8 A! N! u
"Type": "CD",
( }/ u& i# B: [) h' C3 S8 q' M @ "Author": "Nirvana",
$ I+ v% v3 p0 C3 J5 p* W "Title": "Nevermind",3 z9 l9 i; b) n; ?) G
"Genre": "Grunge",5 S6 m* K$ ?% R. ]
"Releasedate": "1991.09.24",
% V' O# p" o" ^2 R$ ~4 M "Tracklist": [3 s% t& Y" t ?5 {5 Z, S
{
2 W8 u9 Z! a8 f' h' K "Track" : "1",9 v" ?- I4 }% y1 e# z8 t
"Title" : "Smells like teen spirit",- B, f0 ]2 T& }! x4 z
"Length" : "5:02"8 V' n" |/ R5 v% M/ b9 q
},
* d3 }/ v/ ]/ y4 P4 _/ d1 B {& A6 n' D7 G1 E" T+ W) u
"Track" : "2",
* v }& s( ~) W z1 T$ e "Title" : "In Bloom",2 C; B# v1 d( V8 c! X( b1 M
"Length" : "4:15"
3 J. `& x# d( x" j }# n7 G0 x) Q5 v+ i8 a/ |
]5 ?: G; F( ^# z7 @( ^4 ^
}
l# [" U2 n6 D
% |' `& ]. M# |: H ~. D{/ {* Z, Q2 a5 Z- i6 b
"ISBN": "987-1-4302-3051-9",
0 C0 a9 w: L& U. b" M5 m, M9 { "Type": "Book",2 D# z- f: j6 M& G$ ]# e
"Title": "Definite Guide to MongoDB: The NoSQL Database",# L% _3 ] X$ p% d% j6 q# B3 m
"Publisher": "Apress",
! @1 v8 p( U6 c4 o$ }- u "Author": " Eelco Plugge",/ v0 N R# ]# ?% k& ]# ^
"Releasedate": "2011.06.09"9 l6 f3 r; L9 K; k# B& n8 t9 P
}
+ M! x( F4 E7 T# M1 l( H5 g! m$ ^0 W! G0 E% E
假如,在同一个 collection 中的所有 document,都包含某个共同的 field,例如前例中的“ISBN”,那么我们就可以按照这个 field 的值,来分割 collection。这个 field 的值,又称为 shard key。
; `, f# Z$ c0 z+ N) o# F8 ^ j L5 |; j6 C% O* c. }3 G) h! V
在选择shard key的时候,一定要确保这个key能够把collection均匀地切分成很多chunks。
) T3 B/ x' y& U: P/ J( S9 H3 s. ?5 S# O( R, v8 b4 n
例如,如果我们选择“author”作为shard key,如果有大量的作者是重名的,那么就会有大量的数据聚集在同一个chunk中。当然,假设很少有作者同名同姓,那么“author”也可以作为一个shard key。换句话说,shard key 的选择,与使用场景密切相关。0 m, M0 a& j6 V) U( k8 l7 ^
+ j+ s* v. D% x* s* N 很多情况下,无论选择哪一个单一的 field 作为shard key,都无法均匀分割 collection。在这种情况下,我们可以考虑,用多个 fields,构成一个复合的shard key。
9 N. f/ }: @# R, m& N! `
, l1 ?4 S( D( r9 L) b 延续前例,假如有很多作者同名同姓,他们都叫“王二”。用 author 作为 shard key,显然无法均匀切割 collection。这时我们可以加上release-date,组成name-date的复合 shard key,例如“王二 2011”。% d g3 Z. n+ l9 V, [) l
8 I" T" ?( Q: ^+ m* BChunks
. a- f8 F" s, H: S+ ~
# \9 X) v8 s$ h" H8 p0 V MongoDB按 shard key,把 collection切割成若干 chunks。每个 chunk 的数据结构,是一个三元组,{collection,minKey,maxKey},如图1-2 所示。9 ^+ @4 U3 c% c, W: H9 i
! F g+ k" v! Z
) \( ]; E8 s) S u+ h' V" ]
图1-2 chunk的三元组
! w- _) R" J L% P+ v, z$ \
; _& D) |! l! V! N 其中,collection 是数据库中某一个表的名称,而 minKey 和 maxKey 是 shard key的范围。每一个 document 的shard key 的值,决定了这条document应该存放在哪个chunk中。
, R# [5 ] D! k1 i! M3 M0 D1 {$ i
% W; {& {, N/ q5 D" t 如果两条 documents 的 shard keys 的值很接近,这两条 documents 很可能被存放在同一个 chunk 中。# G8 O n$ W! @8 Y/ z3 n
( d( {5 t8 F' A" `) ~ Shard key 的值的顺序,决定了 document 存放的 chunk。在 MongoDB 的文献中,这种切割 collection 的方式,称为order-preserving。& @7 ~' y! t: ]7 D8 D* j
. x# B. ^# [% s; f( C0 c" I9 ~5 [ 一个 chunk最多能够存储64MB的数据。 当某个chunk存储的 documents包含的数据量,接近这个阈值时,一个chunk会被切分成两个新的chunks。* F% N1 r9 c; U" n
/ X+ m9 D! J, l* E# z) K& T: [ 当一个shard存储了过多的chunks,这个shard中的某些chunks会被迁移到其它 shard中。
! e2 B% g! f% j% P0 n4 \* @9 P
; G5 Z% ? Q: X, U 这里有个问题,假如某一条 document 包含的数据量很大,超过 64MB,一个 chunk 存放不下,怎么办?在后续章节介绍 GridFS 时,我们会详细讨论。5 z0 @6 @8 d( [
% b$ d0 W3 W0 V C/ m
Replica set: e$ B4 N* e' Q( }
2 @0 o: x3 F) G* X 在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。# ]' h$ @- ~0 T" v6 Z
* `; |, s% v( G2 R7 ?) n" b$ R c
这个replica set包括一个primary DB和多个secondary DBs。为了数据的一致性,所有的修改(insert / update / deletes) 请求都交给primary处理。处理结束之后,再异步地备份到其他secondary中。) q$ Z/ q$ p; {+ ]# T8 R
* d5 B) R; J2 e9 |- r Primary DB由replica set中的所有servers,共同选举产生。当这个primaryDB server出错的时候,可以从replica set中重新选举一个新的primaryDB,从而避免了单点故障。
* c# }3 G" `6 B/ |& F3 ?/ d: O; s4 l# s
Replica set的选举策略和数据同步机制,确保了系统的数据的一致性。后文详述。
% a: [. [: R, d" n3 m5 G
7 S& h0 p% W' |' mConfig Server' X" e8 E) U0 o! N/ [1 u5 a e
. G* K- X- B( g" ]9 l
Config servers用于存储MongoDB集群的元数据 metadata,这些元数据包括如下两个部分,每一个shard server包括哪些chunks,每个chunk存储了哪些 collections 的哪些 documents。! D/ o$ v. E" W; T: F/ o0 e3 ?
# w3 y/ V! s: {" R& [ 每一个config server都包括了MongoDB中所有chunk的信息。
3 D8 u; j3 C% H& {! X/ \5 Y- F, w6 ]) p' S. x' x4 a9 @* X
Config server也需要 replication。但是有趣的是,config server 采用了自己独特的replication模式,而没有沿用 replica set。
; H" n+ @( Q x6 _5 {9 @- l3 ?$ T+ y8 v, e6 }$ m, l
如果任何一台config server挂了,整个 config server 集群中,其它 config server变成只读状态。这样做的原因,是避免在系统不稳定的情况下,冒然对元数据做任何改动,导致在不同的 config servers 中,出现元数据不一致的情况。
* T2 m% u# W% ^/ M3 P
# s0 ?$ l, a, {$ E/ W MongoDB的官方文档建议,配置3个config servers比较合适,既提供了足够的安全性,又避免了更多的config servers实例之间的数据同步,引起的元数据不一致的麻烦。+ N9 }& _6 {1 c8 j4 L4 i, {7 H2 q
+ U2 b0 ^$ k- C0 q( {" gMongos
' h: g* @; [. ^/ G* y( {" E: }" |0 B$ S$ ]
用户使用MongoDB 时,用户的操作请求,全部由mongos来转发。6 H* Q9 x: V' L8 I$ ?; o
) X4 k1 Q$ P* E* `- q 当 mongos 接收到用户请求时,它先查询 config server,找到存放相应数据的shard servers。然后把用户请求,转发到这些 shard servers。当这些 shard servers完成操作后,它们把结果分别返回给 mongos。而当 mongos 汇总了所有的结果后,它把结果返回给用户。
8 K/ n" @' a% w6 b- t( T- N1 f8 k5 j2 e; K3 q
Mongos每次启动的时候,都要到config servers中读取元数据,并缓存在本地。每当 config server中的元数据有改动,它都会通知所有的mongos。
" y( a2 D$ u! Q2 c1 x2 L# {4 u# Y3 i7 ~' Y2 P1 {0 i- a2 \
Mongos之间,不存在彼此协同工作的问题。因此,MongoDB所需要配置的mongos server的数量,没有限制。
1 F: L1 [- r, L% P, y7 {& \* N, R! g, n* @! f
通过以上的介绍,我们对每个组成部分都有了基本的了解,但是涉及到工作的细节,我们尚有诸多疑问,例如,一个chunk的数据太大,如何切分?一个shard数据太多,如何迁移?在replica set中,如何选择primary?server挂了,怎么进行故障恢复?接下来的章节,我们逐个回答这些问题。% }9 p1 `) H, U- m
$ Z. H+ c! q9 h) O
6 K2 |% o7 H4 S6 bReference,
1 M! o2 v( q: a. |
" ^2 x& H, H. P5 \: I9 V[0] Architectural Overview
# E" {$ I" R( A" U! i: C. Ghttp://www.mongodb.org/display/DOCS/Sharding+Introduction- T9 s& N5 S2 E$ _
|
评分
-
查看全部评分
|