|
关于MongoDB,我们能看到的资料,基本都是在指导大家如何使用MongoDB,但是,MongoDB内部是如何运作的,资料不是很多。5 l0 X, S4 Q& a5 r, ~6 \" o
7 h' Y8 q: s' U6 _1 t
阅读使用手册,会有很多疑惑之处。例如,有人说,MongoDB 等同于分布式的 MySQL。它把一个Table ,按 row,分割成多个Shards,分别存放在不同的 Servers 上。这种说法是否正确?
& \" K5 F) V- d* D1 i( ?/ b
( Y0 ~# G1 W4 n/ ]4 b2 B& y$ ` 不深入了解 MongoDB 的内部结构,就无法透彻地回答类似问题。这个系列文章,就来和大家探讨MongoDB的内部的工作方式。
: e8 p" i3 K5 Z2 f% N* X$ D
5 r# t) L0 _# q" z g/ T* ~
) R7 R2 ]' X: Y8 ]) J7 w7 P3 |5 Q" v* Y. b) ?' X3 x
图1-1 MongoDB架构图 $ @; m) r' k. t7 a3 o4 ?! L
) ?7 d* P2 i/ e% S, f MongoDB 通常运行在一个服务器集群上,而不是一个单机。图1-1,描述了一个MongoDB集群的基本组成部分,包括若干shards,至少一个config server,至少一个routing servers(又称 mongos)。9 n& q4 q" m7 v/ K) ]
4 F% `9 K. f$ e# @6 U% NShards& X. |: N" W4 M1 t; |0 T. U7 x3 v
. S$ i9 y# K, Y" _" U9 K
MongoDB的最基本的数据单元,叫document,类似于关系式数据库中的行 row。一系列documents,组成了一个collection,相当于关系式数据库中的table。当一个 collection 数据量太大时,可以把该collection按documents切分,分成多个数据块,每个数据块叫做一个chunk,多个chunks聚集在一起,组成了一个shard。
/ b6 q3 D! M# ~: u f- q4 x6 k. X8 W; J/ c3 D
Sharding 的意义,不仅保障了数据库的扩容(scalability),同时也保障了系统的负载均衡(load balance)。
7 V6 W) x' R; g* m# x2 h& P1 p* Z" V1 H: `, g8 d, l+ y, U
每一个shard存储在一个物理服务器(server)上。Server上运行着mongod进程,通过这个进程,对shard中的数据进行操作,主要是增删改查。
0 f* a3 Y- C8 }; ?' O# [! ^& c- E/ b j
如果系统中的每个shard,只存储了一份数据,没有备份,那么当这个shard所在的server挂了,数据就丢失了。在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。
! s4 n' H% G; C0 \7 M3 x1 J4 |
# @& k2 O- k. |8 x& L( \Shard keys
0 g3 @- V! J9 \5 K0 g
4 }9 b$ P# E0 A5 d* y+ q7 j 为了把collection切分成不同的chunks,从而存放到不同的shards中,我们需要制定一个切分的方式。9 B8 S6 @) O$ V& M1 N- d2 o/ l
3 ]' A3 o. m- x8 K+ M1 E
如前所述,在 MongoDB 数据库中,一个表collection由多个行 documents 组成,而每个 document,有多个属性 fields。同一个 collection 中的不同的 documents,可能会有不同的 fields。例如,有个 collection 叫 Media,包含两条 documents,# D, ]7 [0 O9 \- B
% D. P/ Y$ \5 q- b& k
{3 ?/ b+ j7 G6 l# q5 L
"ISBN": "987-30-3652-5130-82",
% W0 O4 p8 U- D" r% G) {7 G' s "Type": "CD",3 \- \9 ^8 U! E! O0 A6 q4 `) v
"Author": "Nirvana",
# W$ M) T) R+ b' P$ c4 n$ Q "Title": "Nevermind",: Q. l U1 Y" ^) d7 t- W
"Genre": "Grunge",
" E% m$ {( i: Q& M3 u "Releasedate": "1991.09.24",
$ D6 n ?* n7 U T1 L; [! H3 Z "Tracklist": [
9 e: i+ {# y: b; ?* J% d W {
# a" O1 I! D8 O2 A* P6 N; n "Track" : "1",+ C% x4 L: J) O) J4 R. F: @4 l
"Title" : "Smells like teen spirit",, S% S1 Z+ l/ G8 |% T; w
"Length" : "5:02"
9 d$ l$ z; n+ ]! k5 G1 ? },
7 Y1 Q1 f8 X5 {: U6 J: I" ?6 I3 E# s {/ D1 q( w0 a8 x6 r; K" t
"Track" : "2",
4 Q/ `8 Y9 ~, F "Title" : "In Bloom",
6 \/ E. }* L" a "Length" : "4:15": M* S) a' G" [9 V5 `
}& c( C* |3 Y+ `; X# _% i. w) G- O
]
& w4 X& X6 c" @% `% I$ b}
6 C- {8 v; I* R2 Y# ^: R6 d7 t4 @# U8 P9 o2 p2 x
{
1 b# c; q c# |- y: a "ISBN": "987-1-4302-3051-9"," A# m. e# m$ R
"Type": "Book",
2 t3 M' U4 S2 X. `! ^& ^0 Z) w "Title": "Definite Guide to MongoDB: The NoSQL Database",
6 w( Y7 j2 c9 ? w; j "Publisher": "Apress",
# O6 h9 c ~$ w9 M- d+ f "Author": " Eelco Plugge",# v. U3 R/ r# C' b9 y; H: K" a& R) p
"Releasedate": "2011.06.09"
, i2 _$ M- n0 w2 \1 o}
) p* e& Z# q& m0 i8 a% X
8 P2 n5 V) l* d; b, ], Z6 C, ? 假如,在同一个 collection 中的所有 document,都包含某个共同的 field,例如前例中的“ISBN”,那么我们就可以按照这个 field 的值,来分割 collection。这个 field 的值,又称为 shard key。
& `( `4 P6 w9 [; j1 j- ?$ |% C% w! {7 N `. ?" T; U
在选择shard key的时候,一定要确保这个key能够把collection均匀地切分成很多chunks。
' H9 J2 J% K3 M2 }/ i' c
+ e# S6 }7 ]$ n' r 例如,如果我们选择“author”作为shard key,如果有大量的作者是重名的,那么就会有大量的数据聚集在同一个chunk中。当然,假设很少有作者同名同姓,那么“author”也可以作为一个shard key。换句话说,shard key 的选择,与使用场景密切相关。5 c+ g2 P1 {: K p2 W
2 y4 M% p2 n) ?/ m( c. C
很多情况下,无论选择哪一个单一的 field 作为shard key,都无法均匀分割 collection。在这种情况下,我们可以考虑,用多个 fields,构成一个复合的shard key。$ _: i. S: }0 V
: G u. S+ G/ S) N, B) @1 ^' A
延续前例,假如有很多作者同名同姓,他们都叫“王二”。用 author 作为 shard key,显然无法均匀切割 collection。这时我们可以加上release-date,组成name-date的复合 shard key,例如“王二 2011”。" T! D7 \( F2 S4 j% _6 Y- T
. W: q3 U {1 z: UChunks
- J# ^* r* _ [: G/ g8 U T" V: C
9 E9 O& e2 F5 V MongoDB按 shard key,把 collection切割成若干 chunks。每个 chunk 的数据结构,是一个三元组,{collection,minKey,maxKey},如图1-2 所示。
, g$ w5 W" n$ B
& _' R1 z0 X7 G6 Q. B4 [
; g! U5 l, h8 w s图1-2 chunk的三元组 z( ?3 ~# Q7 a6 M
7 ]: I; E5 X; V( K) D2 a
其中,collection 是数据库中某一个表的名称,而 minKey 和 maxKey 是 shard key的范围。每一个 document 的shard key 的值,决定了这条document应该存放在哪个chunk中。
; w/ m( L7 z% x* z4 p$ _5 t) x1 n2 M
如果两条 documents 的 shard keys 的值很接近,这两条 documents 很可能被存放在同一个 chunk 中。
2 Y, U+ l/ z- W4 @# S
+ a3 L+ h& I; D; N' t Shard key 的值的顺序,决定了 document 存放的 chunk。在 MongoDB 的文献中,这种切割 collection 的方式,称为order-preserving。
! O# F& U# F# m* S$ B" ^
& P, G. B' L" s, i; N 一个 chunk最多能够存储64MB的数据。 当某个chunk存储的 documents包含的数据量,接近这个阈值时,一个chunk会被切分成两个新的chunks。
! H( k# G$ G# R) J
: @+ t+ {# Q2 L) W: U! G9 R1 e: q 当一个shard存储了过多的chunks,这个shard中的某些chunks会被迁移到其它 shard中。
$ w9 C7 ?1 a; J% X
2 B, D; c/ q- q. w( w 这里有个问题,假如某一条 document 包含的数据量很大,超过 64MB,一个 chunk 存放不下,怎么办?在后续章节介绍 GridFS 时,我们会详细讨论。3 {0 H Q0 _9 o) N! h
. K. r1 U% k0 y6 c
Replica set
! _9 s: g. s$ y4 m. O
7 k, V1 j$ t. D& g/ g; C8 T6 ] 在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。
, A& C6 V( M$ \! |7 ]0 K
% V/ ]5 n, c9 Q8 T( W* S# F 这个replica set包括一个primary DB和多个secondary DBs。为了数据的一致性,所有的修改(insert / update / deletes) 请求都交给primary处理。处理结束之后,再异步地备份到其他secondary中。
2 X: L( t: {# } X) g5 {# B4 E% n" n0 }: y" p* ~
Primary DB由replica set中的所有servers,共同选举产生。当这个primaryDB server出错的时候,可以从replica set中重新选举一个新的primaryDB,从而避免了单点故障。
! J( `6 w& v/ J9 x
0 @# h* Q- _$ G4 F i Replica set的选举策略和数据同步机制,确保了系统的数据的一致性。后文详述。( A: G6 p$ ~+ K
7 C3 q8 {' O: D, ?! H
Config Server
V& Y$ R8 h1 o5 Z: S 7 t" A% r' U+ s7 B1 d! f* O/ x) m
Config servers用于存储MongoDB集群的元数据 metadata,这些元数据包括如下两个部分,每一个shard server包括哪些chunks,每个chunk存储了哪些 collections 的哪些 documents。6 \0 E+ J* q- B; c- Y3 q
/ W% L2 P% X0 v7 d% }) j9 u
每一个config server都包括了MongoDB中所有chunk的信息。
' x7 n5 x7 G7 j+ ?! A! _% m2 V5 @0 `
Config server也需要 replication。但是有趣的是,config server 采用了自己独特的replication模式,而没有沿用 replica set。' ~: h' y. m# d+ I
6 w! w1 g y' U, D3 ` 如果任何一台config server挂了,整个 config server 集群中,其它 config server变成只读状态。这样做的原因,是避免在系统不稳定的情况下,冒然对元数据做任何改动,导致在不同的 config servers 中,出现元数据不一致的情况。. m9 N9 |4 n+ v
" p0 }9 y1 q, V1 q0 o& ~0 X MongoDB的官方文档建议,配置3个config servers比较合适,既提供了足够的安全性,又避免了更多的config servers实例之间的数据同步,引起的元数据不一致的麻烦。
* _( U7 _& d& w" g' ~- c2 m% i5 E
+ H$ r8 p% R" W: \' X: rMongos2 g, ?, ?8 I7 L: C' g$ j
, \1 W; Y! ?4 F8 z2 c 用户使用MongoDB 时,用户的操作请求,全部由mongos来转发。
f% d/ E3 j! K* H8 f$ r
0 K3 U: |3 ?/ N# r 当 mongos 接收到用户请求时,它先查询 config server,找到存放相应数据的shard servers。然后把用户请求,转发到这些 shard servers。当这些 shard servers完成操作后,它们把结果分别返回给 mongos。而当 mongos 汇总了所有的结果后,它把结果返回给用户。
# \1 z/ e7 y0 a# T' K0 Q$ d* H# m2 y; s! L9 s* H2 y v
Mongos每次启动的时候,都要到config servers中读取元数据,并缓存在本地。每当 config server中的元数据有改动,它都会通知所有的mongos。8 O/ W ~$ @! F
, G# I, I2 O6 e- H Mongos之间,不存在彼此协同工作的问题。因此,MongoDB所需要配置的mongos server的数量,没有限制。' s0 g+ V, a# p! m) F7 g' _2 @
/ r7 Y$ G5 J5 I, X, {( A9 |: m6 s 通过以上的介绍,我们对每个组成部分都有了基本的了解,但是涉及到工作的细节,我们尚有诸多疑问,例如,一个chunk的数据太大,如何切分?一个shard数据太多,如何迁移?在replica set中,如何选择primary?server挂了,怎么进行故障恢复?接下来的章节,我们逐个回答这些问题。
0 _4 Q/ @/ D/ |+ b8 S! _/ y. n* M( M9 a. ]* v( a( W
; ]+ p; X( E% K6 I, g* W+ gReference,! J( X6 r# H9 G; ]
- Z m w/ G P- z[0] Architectural Overview' \0 l1 I5 X7 n9 Z" {3 h3 H+ d
http://www.mongodb.org/display/DOCS/Sharding+Introduction4 U$ G5 r1 `! w/ B* ^) j
|
评分
-
查看全部评分
|