|
|
关于MongoDB,我们能看到的资料,基本都是在指导大家如何使用MongoDB,但是,MongoDB内部是如何运作的,资料不是很多。2 e0 b& I6 M& y+ e' ~1 u9 {
$ H- ^. P# Y: f& ?
阅读使用手册,会有很多疑惑之处。例如,有人说,MongoDB 等同于分布式的 MySQL。它把一个Table ,按 row,分割成多个Shards,分别存放在不同的 Servers 上。这种说法是否正确?2 X9 S; F% R1 Y8 O& H2 b
8 e& M/ {" Y+ D( K 不深入了解 MongoDB 的内部结构,就无法透彻地回答类似问题。这个系列文章,就来和大家探讨MongoDB的内部的工作方式。% s9 p2 h# A* o" l: l1 U4 \! A
9 J6 b) B9 I0 ]" n6 l6 g
$ x" M. S3 |0 M/ D
8 l: y9 f" S W5 Q3 w( w0 W
图1-1 MongoDB架构图 ; h. e2 L' M1 T; |
' S$ s4 _% d" P2 M2 c$ T g
MongoDB 通常运行在一个服务器集群上,而不是一个单机。图1-1,描述了一个MongoDB集群的基本组成部分,包括若干shards,至少一个config server,至少一个routing servers(又称 mongos)。- k' W) Y, c1 O8 _* }
8 U, L5 n- u0 D- Z% X
Shards- |7 U1 u. t( W
: H7 M* T, f1 c' z0 [0 S MongoDB的最基本的数据单元,叫document,类似于关系式数据库中的行 row。一系列documents,组成了一个collection,相当于关系式数据库中的table。当一个 collection 数据量太大时,可以把该collection按documents切分,分成多个数据块,每个数据块叫做一个chunk,多个chunks聚集在一起,组成了一个shard。0 L. Q" y+ P O- i, ?: J2 Q& c
2 {) T. U$ N" X4 U& u' N
Sharding 的意义,不仅保障了数据库的扩容(scalability),同时也保障了系统的负载均衡(load balance)。2 {2 h: [ f; q/ U$ [& r) b
6 s! I0 y' C j0 W1 }7 S 每一个shard存储在一个物理服务器(server)上。Server上运行着mongod进程,通过这个进程,对shard中的数据进行操作,主要是增删改查。
- B3 c# Z( k' l2 b7 s Q: `; s c; } @4 d M
如果系统中的每个shard,只存储了一份数据,没有备份,那么当这个shard所在的server挂了,数据就丢失了。在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。0 N( Q8 z8 }7 y# l( A/ n
' y [/ M7 { r: u4 wShard keys1 I; x& ^" H3 u' J6 y
$ P8 R4 V4 o( {% _4 ?* q0 d { 为了把collection切分成不同的chunks,从而存放到不同的shards中,我们需要制定一个切分的方式。' {: f( J; X' O7 F1 o+ k
; l6 m/ l3 A4 L# ?4 j% S. `6 l 如前所述,在 MongoDB 数据库中,一个表collection由多个行 documents 组成,而每个 document,有多个属性 fields。同一个 collection 中的不同的 documents,可能会有不同的 fields。例如,有个 collection 叫 Media,包含两条 documents,
) J; J! V$ E- X! ~# X" ?( l _. I( O1 N( Q# r
{
: ?' D* u3 E9 @( v4 ~0 F8 ^- u" H3 {/ f "ISBN": "987-30-3652-5130-82",( g" R) }) X. v# G
"Type": "CD",: Z+ g& Y+ M1 S: [
"Author": "Nirvana",7 S% ]% Z2 } ~# e {7 l7 E6 u
"Title": "Nevermind",% a# C$ p' ?) z I
"Genre": "Grunge",4 |& ?1 O8 l1 s" q! Z6 S0 w
"Releasedate": "1991.09.24",
( Q) I! j0 x3 @4 O1 L/ p9 J "Tracklist": [% y8 k4 y9 ?$ h) I! L7 A1 _+ G
{& ^) t: ?4 I4 T8 N* E- \
"Track" : "1",
* S C1 G) J5 r( h% x& M: r "Title" : "Smells like teen spirit",
2 S0 L1 d2 v- U! E; `7 Q6 l6 \ "Length" : "5:02"
4 R% W' l2 z- A },+ r, T. K9 r) k
{
5 k7 q# S+ Y$ ^% l- n; k- g "Track" : "2",
1 ?& Y8 X/ K4 X8 _1 h" d1 c "Title" : "In Bloom",
& M" z; W* @2 y& e "Length" : "4:15"
1 C: W" t! p( K- O7 ~ }7 Q( w) [ j: \# h# B h6 I
]
! Y" E9 d F/ X7 r2 |}
' d& E: m! M5 D8 |/ Q3 k, W B) Q0 P5 p. s b( ]
{( U9 f3 B7 @4 ?: x
"ISBN": "987-1-4302-3051-9",
8 l5 r; a. U3 O9 {; O9 A: o: ] "Type": "Book",% j3 ~ e" G6 H% _
"Title": "Definite Guide to MongoDB: The NoSQL Database",
0 y3 _9 M! [* U% J& f "Publisher": "Apress",
! s9 x2 q1 F% l# n) G "Author": " Eelco Plugge",
G. t7 `. ^; { a; r0 D7 S "Releasedate": "2011.06.09"2 l8 P1 e+ @- k0 A* ^
}+ A1 o* d4 l- e+ e, b6 _, B( R
( S% v7 z) x; ^+ ^; i 假如,在同一个 collection 中的所有 document,都包含某个共同的 field,例如前例中的“ISBN”,那么我们就可以按照这个 field 的值,来分割 collection。这个 field 的值,又称为 shard key。/ Y# i1 M: |3 v& x- p4 U
( T, t' P" U$ `: N4 U# s
在选择shard key的时候,一定要确保这个key能够把collection均匀地切分成很多chunks。
0 z$ s7 v% V1 u. G' _7 Z! ]
: t. J) C f: D) z1 C, R- d( V+ U 例如,如果我们选择“author”作为shard key,如果有大量的作者是重名的,那么就会有大量的数据聚集在同一个chunk中。当然,假设很少有作者同名同姓,那么“author”也可以作为一个shard key。换句话说,shard key 的选择,与使用场景密切相关。; {8 x* w/ e3 v" u# D+ o
) a. B+ n) K S- a+ O* ^ 很多情况下,无论选择哪一个单一的 field 作为shard key,都无法均匀分割 collection。在这种情况下,我们可以考虑,用多个 fields,构成一个复合的shard key。
7 s) ~4 o, z; y: J7 G) D9 X7 P4 o" ?/ D2 z0 ]9 E
延续前例,假如有很多作者同名同姓,他们都叫“王二”。用 author 作为 shard key,显然无法均匀切割 collection。这时我们可以加上release-date,组成name-date的复合 shard key,例如“王二 2011”。) r" W- B; E2 X" }/ ~: U0 b) g. p
' I: R/ k. g+ C5 JChunks
! }7 |% o& T) \0 ]) x# N. L; I' }: a, @6 P
& W; M# s7 Z: @ MongoDB按 shard key,把 collection切割成若干 chunks。每个 chunk 的数据结构,是一个三元组,{collection,minKey,maxKey},如图1-2 所示。7 S! X% [6 `8 \: L5 R' }
/ |% R) e' l7 G' R, d
" }- [4 j4 y; x/ s; X) |3 R$ i Z& ~3 Z图1-2 chunk的三元组 , G U# R1 ]) T- n; |1 N
I/ X: v+ {, R$ H' K" W 其中,collection 是数据库中某一个表的名称,而 minKey 和 maxKey 是 shard key的范围。每一个 document 的shard key 的值,决定了这条document应该存放在哪个chunk中。5 i9 Z! z( G# ?2 @
) K1 L8 o7 Q' j# l2 D6 W+ |& W
如果两条 documents 的 shard keys 的值很接近,这两条 documents 很可能被存放在同一个 chunk 中。
) N7 u# S5 F! z5 C1 s
m0 }9 N, Q& _5 P# Y# w: X7 E$ s Shard key 的值的顺序,决定了 document 存放的 chunk。在 MongoDB 的文献中,这种切割 collection 的方式,称为order-preserving。
' l/ D1 ?' i: ]6 {
7 F! P) R E \! ]- l# w7 |3 W0 N 一个 chunk最多能够存储64MB的数据。 当某个chunk存储的 documents包含的数据量,接近这个阈值时,一个chunk会被切分成两个新的chunks。
/ t; \8 }' ~) T$ h# G' Q# L2 J7 |: D6 W9 K
当一个shard存储了过多的chunks,这个shard中的某些chunks会被迁移到其它 shard中。
+ g; @ k9 l, @% I$ |
* |/ o3 [8 N3 X W 这里有个问题,假如某一条 document 包含的数据量很大,超过 64MB,一个 chunk 存放不下,怎么办?在后续章节介绍 GridFS 时,我们会详细讨论。7 b5 J0 u- L w, t. z \$ X9 _9 l: O
" c: W6 c) g5 Q( a& `
Replica set
$ y1 K2 j- s! H; X! u$ Q
$ V8 C2 k& d. ?& l; E% m 在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。* q8 h' c# k3 l* z! A8 e
, H f! p9 ]; P+ A! s
这个replica set包括一个primary DB和多个secondary DBs。为了数据的一致性,所有的修改(insert / update / deletes) 请求都交给primary处理。处理结束之后,再异步地备份到其他secondary中。* N6 J2 Z0 f+ h
+ v7 U$ D0 S# A Primary DB由replica set中的所有servers,共同选举产生。当这个primaryDB server出错的时候,可以从replica set中重新选举一个新的primaryDB,从而避免了单点故障。
/ E( T* v! w/ _+ D8 O `! }% \7 d! f% ~1 _( Z0 K
Replica set的选举策略和数据同步机制,确保了系统的数据的一致性。后文详述。( U% z1 c/ a- [ k. t
; Y3 _* Z0 G; C6 Y; h: FConfig Server, Y; o4 ^+ I# a) y
) P0 H- |6 \* A' }, \* ]- B1 v
Config servers用于存储MongoDB集群的元数据 metadata,这些元数据包括如下两个部分,每一个shard server包括哪些chunks,每个chunk存储了哪些 collections 的哪些 documents。+ u: C W" `2 M
. L; o* ^4 e0 [7 ` 每一个config server都包括了MongoDB中所有chunk的信息。
# u3 h) N0 o& a; ^& X1 {# z {/ J9 Q" G
Config server也需要 replication。但是有趣的是,config server 采用了自己独特的replication模式,而没有沿用 replica set。
( M) n7 p: G5 |4 u2 {6 P' B/ m3 w9 t- m; p N" N9 l
如果任何一台config server挂了,整个 config server 集群中,其它 config server变成只读状态。这样做的原因,是避免在系统不稳定的情况下,冒然对元数据做任何改动,导致在不同的 config servers 中,出现元数据不一致的情况。) b& u$ E5 o! Q9 q- P$ N
' e$ [! v8 E$ n, p2 j g. V8 A3 Q! q- z MongoDB的官方文档建议,配置3个config servers比较合适,既提供了足够的安全性,又避免了更多的config servers实例之间的数据同步,引起的元数据不一致的麻烦。
% @+ v% u& N9 v
7 n' R2 n7 P, gMongos5 r$ M, N; q' K
o6 W3 d6 s$ k, Y' { 用户使用MongoDB 时,用户的操作请求,全部由mongos来转发。5 Q# w: J7 c9 U* `# q
' b# v" a: R6 B- `. j
当 mongos 接收到用户请求时,它先查询 config server,找到存放相应数据的shard servers。然后把用户请求,转发到这些 shard servers。当这些 shard servers完成操作后,它们把结果分别返回给 mongos。而当 mongos 汇总了所有的结果后,它把结果返回给用户。! \$ Q8 V! n8 h; v9 ]# s1 i
, ]) e6 |4 `3 z' p Mongos每次启动的时候,都要到config servers中读取元数据,并缓存在本地。每当 config server中的元数据有改动,它都会通知所有的mongos。
; v% n5 _) X4 K' \
0 p0 O5 x8 I: f) a. P" ?: A Mongos之间,不存在彼此协同工作的问题。因此,MongoDB所需要配置的mongos server的数量,没有限制。
$ G! d+ a7 l6 c! ^4 q/ B- c- G
8 h) e' Z$ ?9 W. j9 ] 通过以上的介绍,我们对每个组成部分都有了基本的了解,但是涉及到工作的细节,我们尚有诸多疑问,例如,一个chunk的数据太大,如何切分?一个shard数据太多,如何迁移?在replica set中,如何选择primary?server挂了,怎么进行故障恢复?接下来的章节,我们逐个回答这些问题。' f, \6 e, Z" F( C3 r( l0 D1 g
7 B' }) M- h; I& Q5 e3 ]+ s6 @7 n) t0 @6 \/ C, x! O4 q" m- \
Reference,
& s0 k# K/ Q+ z2 j
' L/ W: W: G) }& E. q B- E[0] Architectural Overview4 A" F: B a4 b; \8 u9 i
http://www.mongodb.org/display/DOCS/Sharding+Introduction
' S# O5 {3 s' j% K w- o5 j! Q |
评分
-
查看全部评分
|