|
|
关于MongoDB,我们能看到的资料,基本都是在指导大家如何使用MongoDB,但是,MongoDB内部是如何运作的,资料不是很多。
: x% N7 e, d9 n; r7 z Q, g& X0 z& h2 j/ s# K1 F
阅读使用手册,会有很多疑惑之处。例如,有人说,MongoDB 等同于分布式的 MySQL。它把一个Table ,按 row,分割成多个Shards,分别存放在不同的 Servers 上。这种说法是否正确?
1 x% a. L, ]% K# }3 W* Q2 v6 ]# n% }0 N
不深入了解 MongoDB 的内部结构,就无法透彻地回答类似问题。这个系列文章,就来和大家探讨MongoDB的内部的工作方式。: T5 Z9 F1 c3 @0 [- d
' Z( b: U. g* G1 o6 D
0 r3 a, R& w# B# ~3 B8 f. S6 y. ?; X
图1-1 MongoDB架构图 ' U. m ?% n9 J1 z
' C* h7 c# w m$ f- R6 @
MongoDB 通常运行在一个服务器集群上,而不是一个单机。图1-1,描述了一个MongoDB集群的基本组成部分,包括若干shards,至少一个config server,至少一个routing servers(又称 mongos)。- A0 L; |1 v! f ?& a
- Z" E: \+ A5 S, f& |
Shards/ _1 z) l* |0 t, T+ `/ Y! K
( D$ s) v$ d2 L5 ~3 |/ R9 j MongoDB的最基本的数据单元,叫document,类似于关系式数据库中的行 row。一系列documents,组成了一个collection,相当于关系式数据库中的table。当一个 collection 数据量太大时,可以把该collection按documents切分,分成多个数据块,每个数据块叫做一个chunk,多个chunks聚集在一起,组成了一个shard。
" q. i+ ?- J! |% u
' h7 i! D. T9 @ | Sharding 的意义,不仅保障了数据库的扩容(scalability),同时也保障了系统的负载均衡(load balance)。8 Y2 [) s& K8 r/ @8 t$ y6 {
4 {0 G$ I! t9 O
每一个shard存储在一个物理服务器(server)上。Server上运行着mongod进程,通过这个进程,对shard中的数据进行操作,主要是增删改查。
% A- H5 U* x( E. @% u) f
* c9 ~% {$ `6 b/ C) m& B 如果系统中的每个shard,只存储了一份数据,没有备份,那么当这个shard所在的server挂了,数据就丢失了。在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。1 j1 T* r. B+ R( f {/ O5 S, @
2 h* D( h( o$ \0 g; F7 h1 X4 iShard keys5 N* R7 q2 ^" J1 Q0 R/ ^: K
( q# C: ~. _' r! V9 H
为了把collection切分成不同的chunks,从而存放到不同的shards中,我们需要制定一个切分的方式。' [1 y) F! U5 R l- z
0 h4 w! O M; M5 L 如前所述,在 MongoDB 数据库中,一个表collection由多个行 documents 组成,而每个 document,有多个属性 fields。同一个 collection 中的不同的 documents,可能会有不同的 fields。例如,有个 collection 叫 Media,包含两条 documents,% ]% N& n. ^5 M
$ W4 V9 k4 y) m" }# V9 \
{; P9 v9 T4 _8 V7 L0 ?' x1 p
"ISBN": "987-30-3652-5130-82",! U' x& f' h$ [7 e! o$ ^
"Type": "CD",7 Z, D. O+ p, t- Y0 X+ F# l6 R0 e
"Author": "Nirvana"," F* q% G! @5 H I n1 `2 S, d
"Title": "Nevermind",
$ g# Y+ D' N! a7 f "Genre": "Grunge",; @' d0 |( C$ T; h, X6 @0 V s
"Releasedate": "1991.09.24",
" v/ X/ N, j# w& i2 |# j% V "Tracklist": [" N( m' d# p4 n6 k; Q1 G
{& D( l- a: q0 L/ f6 G2 L
"Track" : "1",
, f* w& t! N0 @5 J* m3 \+ X "Title" : "Smells like teen spirit",, [9 l! M2 m* [; G
"Length" : "5:02"
1 ]6 c8 D& e( X },
8 K* m. c1 ]' A$ U2 @5 k5 h2 p8 H {
% D6 n6 }% @& j8 g$ e, s' \- B "Track" : "2",
( B% I# ^5 U6 S& |; X0 \( X( d% k "Title" : "In Bloom",
2 v, \% Y0 I2 C8 C: u( v S- C "Length" : "4:15"
! {1 x6 n& o' ?7 |7 Z5 i k }6 _0 F% j4 K! P& R! t
]& v; d0 N; V; [5 [6 @$ `+ m, M
}5 d8 t5 A# v5 v' j
4 C* L/ k9 Z1 V. A
{
- m$ u/ f) i: R0 K* { "ISBN": "987-1-4302-3051-9",
8 q8 E( C: ?* U. _ "Type": "Book",
E* m* s) D) W: i, z" u "Title": "Definite Guide to MongoDB: The NoSQL Database",
# L& l% B, l; @2 m% {% F% S1 H "Publisher": "Apress",
% `* P8 N2 O7 K- n' [ "Author": " Eelco Plugge",7 d$ h7 |3 I( i3 m$ h. Z5 ?
"Releasedate": "2011.06.09"# i& U X S: c1 V& E
}
5 [1 b* s* p6 E5 U1 Q) V
, h7 n, `2 k& E 假如,在同一个 collection 中的所有 document,都包含某个共同的 field,例如前例中的“ISBN”,那么我们就可以按照这个 field 的值,来分割 collection。这个 field 的值,又称为 shard key。
4 V& r9 B8 H3 S8 U, M5 S
# Q7 v3 c) O! Q 在选择shard key的时候,一定要确保这个key能够把collection均匀地切分成很多chunks。( S- E$ A$ Z- X
- L7 U5 m6 [8 \% G/ |8 t 例如,如果我们选择“author”作为shard key,如果有大量的作者是重名的,那么就会有大量的数据聚集在同一个chunk中。当然,假设很少有作者同名同姓,那么“author”也可以作为一个shard key。换句话说,shard key 的选择,与使用场景密切相关。) `% G( i* {5 u$ ^
3 }/ \1 \; t9 r1 V* ` 很多情况下,无论选择哪一个单一的 field 作为shard key,都无法均匀分割 collection。在这种情况下,我们可以考虑,用多个 fields,构成一个复合的shard key。9 r" V$ e/ \7 V+ S `3 V
. k0 ?4 R; A7 z9 O9 b" S 延续前例,假如有很多作者同名同姓,他们都叫“王二”。用 author 作为 shard key,显然无法均匀切割 collection。这时我们可以加上release-date,组成name-date的复合 shard key,例如“王二 2011”。
) f# {3 x. ^. l p$ J, R$ x, T
4 r$ f4 ~' I' ?5 V$ nChunks* g1 v/ K7 q/ i) J$ h8 \
" M- Y4 E( f) Y" A MongoDB按 shard key,把 collection切割成若干 chunks。每个 chunk 的数据结构,是一个三元组,{collection,minKey,maxKey},如图1-2 所示。 W4 o6 q% ~+ k& e; x+ w
5 l4 ^# I. j& W4 O
% N- Y0 D9 d$ I: P" D图1-2 chunk的三元组 " F4 S# \: F: F* K3 @$ k
) e/ r, Q9 W% r6 N6 {6 g8 k+ z$ k; ?
其中,collection 是数据库中某一个表的名称,而 minKey 和 maxKey 是 shard key的范围。每一个 document 的shard key 的值,决定了这条document应该存放在哪个chunk中。. u9 F9 f& I/ H) W
$ w. b5 E* k9 T$ k! h4 q) S" ? 如果两条 documents 的 shard keys 的值很接近,这两条 documents 很可能被存放在同一个 chunk 中。
; X5 |, c- ]1 v- ^& y3 u- i' j) O% R! p: |5 p' l" B- q/ F1 I
Shard key 的值的顺序,决定了 document 存放的 chunk。在 MongoDB 的文献中,这种切割 collection 的方式,称为order-preserving。
. q* y' Q( D7 J) u* [( B/ O
; A! N+ _8 [& S: _ 一个 chunk最多能够存储64MB的数据。 当某个chunk存储的 documents包含的数据量,接近这个阈值时,一个chunk会被切分成两个新的chunks。# a2 x" t3 @1 q6 r% ^$ [0 A" s
9 Q6 P( V6 p) W9 b) y 当一个shard存储了过多的chunks,这个shard中的某些chunks会被迁移到其它 shard中。
! ~" m' c0 E7 H1 @% I4 N+ A8 c& q- o- C
这里有个问题,假如某一条 document 包含的数据量很大,超过 64MB,一个 chunk 存放不下,怎么办?在后续章节介绍 GridFS 时,我们会详细讨论。) [6 x9 g% O4 q: O' B. v
$ U8 ?- [1 v/ B3 E; A, a
Replica set) ^1 B/ {, h) Q& ^4 Y
; m! z/ x6 O, g6 E
在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。4 O; j* l5 p! r
/ y6 d- W% e) _, p; m! Z& F 这个replica set包括一个primary DB和多个secondary DBs。为了数据的一致性,所有的修改(insert / update / deletes) 请求都交给primary处理。处理结束之后,再异步地备份到其他secondary中。
: E/ u. `6 p. y( U: {; T' B- E& j+ ]
5 K! R# b7 C) @. [: f8 J Primary DB由replica set中的所有servers,共同选举产生。当这个primaryDB server出错的时候,可以从replica set中重新选举一个新的primaryDB,从而避免了单点故障。* [7 @# p6 [" B8 E; ~! g4 U) {. B
% `- u& N, k" v. S: O Replica set的选举策略和数据同步机制,确保了系统的数据的一致性。后文详述。8 y/ F5 R# m6 v1 R: h9 r
F/ D; K. p7 t$ H6 ~) q' l
Config Server
! @: z5 U6 z/ x
$ J# k& J# ~5 U: u7 G Config servers用于存储MongoDB集群的元数据 metadata,这些元数据包括如下两个部分,每一个shard server包括哪些chunks,每个chunk存储了哪些 collections 的哪些 documents。) C' u9 [8 c9 L/ U9 e, X/ D
3 P6 V2 x! v8 I6 g; H8 G! a6 M# l
每一个config server都包括了MongoDB中所有chunk的信息。
$ J; o$ j- g8 e* R3 B8 [
! j& P) M9 @* m6 q; g2 T Config server也需要 replication。但是有趣的是,config server 采用了自己独特的replication模式,而没有沿用 replica set。+ r$ Z9 b! l2 e0 o/ z" V- j; ?
7 T" w( X, b$ P$ L0 p1 g, F 如果任何一台config server挂了,整个 config server 集群中,其它 config server变成只读状态。这样做的原因,是避免在系统不稳定的情况下,冒然对元数据做任何改动,导致在不同的 config servers 中,出现元数据不一致的情况。6 t* f5 w" S& I5 s) P
. f/ F$ O' a3 B/ y MongoDB的官方文档建议,配置3个config servers比较合适,既提供了足够的安全性,又避免了更多的config servers实例之间的数据同步,引起的元数据不一致的麻烦。, ^' E e% @! y! i
`$ G- s( ~# I8 z: t% i
Mongos4 w/ \/ M Y7 S' C) `, Q
5 ~! Z4 `9 [1 o% G$ z% E$ d& x- m& i
用户使用MongoDB 时,用户的操作请求,全部由mongos来转发。
) H1 I( q/ L! R ^1 Q1 |9 X2 e) z4 L* l6 I5 e8 a- M" V
当 mongos 接收到用户请求时,它先查询 config server,找到存放相应数据的shard servers。然后把用户请求,转发到这些 shard servers。当这些 shard servers完成操作后,它们把结果分别返回给 mongos。而当 mongos 汇总了所有的结果后,它把结果返回给用户。# l: K x; G3 D) N2 t1 s
$ @" }1 p! i/ f; ^( c" Y
Mongos每次启动的时候,都要到config servers中读取元数据,并缓存在本地。每当 config server中的元数据有改动,它都会通知所有的mongos。! J$ G! ]* e# ~8 ~: f# d7 l1 I- d
' X8 V% ?8 n8 c+ C Mongos之间,不存在彼此协同工作的问题。因此,MongoDB所需要配置的mongos server的数量,没有限制。! {+ x; V7 P; `
* |8 ^7 }7 p5 C1 K/ \/ n n3 G# V 通过以上的介绍,我们对每个组成部分都有了基本的了解,但是涉及到工作的细节,我们尚有诸多疑问,例如,一个chunk的数据太大,如何切分?一个shard数据太多,如何迁移?在replica set中,如何选择primary?server挂了,怎么进行故障恢复?接下来的章节,我们逐个回答这些问题。
L& M4 i( ]- n
6 s. v# V+ {$ F& e" a4 N" W3 j) R7 S$ w* m! b9 R
Reference,, F4 N# N1 O* T+ U* O) F- o9 Y+ q3 m
4 K: {6 b$ d5 r% c; c
[0] Architectural Overview d3 r8 R$ P$ e- G
http://www.mongodb.org/display/DOCS/Sharding+Introduction# _0 `" N c2 @/ V) J8 I
|
评分
-
查看全部评分
|