|
|
关于MongoDB,我们能看到的资料,基本都是在指导大家如何使用MongoDB,但是,MongoDB内部是如何运作的,资料不是很多。
3 m/ k' Z3 P4 v* j2 @4 b2 u( P9 i
8 B* C* G& j/ a. J7 S 阅读使用手册,会有很多疑惑之处。例如,有人说,MongoDB 等同于分布式的 MySQL。它把一个Table ,按 row,分割成多个Shards,分别存放在不同的 Servers 上。这种说法是否正确?
3 a- B& Q* T) M" E1 P4 s* `5 }; P8 p7 E. d+ Q0 ?
不深入了解 MongoDB 的内部结构,就无法透彻地回答类似问题。这个系列文章,就来和大家探讨MongoDB的内部的工作方式。3 R w& r5 n0 N) K/ f9 n& A+ ?* \, S' J- H
& w, P/ D9 K, Z d
. }* R8 o) A W7 n; b
. b2 t$ e( v2 R) R图1-1 MongoDB架构图 % ]7 o" j& o {0 h l% E1 A A
0 r$ r% d7 o& W MongoDB 通常运行在一个服务器集群上,而不是一个单机。图1-1,描述了一个MongoDB集群的基本组成部分,包括若干shards,至少一个config server,至少一个routing servers(又称 mongos)。
9 H# t2 P7 s' @1 e* d3 ]
; F" A; s: F- V. b% c/ B4 eShards U7 O4 s3 ]5 m4 z+ p% g2 n
( N+ E8 k) L' [! @
MongoDB的最基本的数据单元,叫document,类似于关系式数据库中的行 row。一系列documents,组成了一个collection,相当于关系式数据库中的table。当一个 collection 数据量太大时,可以把该collection按documents切分,分成多个数据块,每个数据块叫做一个chunk,多个chunks聚集在一起,组成了一个shard。
8 L0 {! h1 i$ U5 i7 k2 n
& ` B) S8 ~) I0 K Sharding 的意义,不仅保障了数据库的扩容(scalability),同时也保障了系统的负载均衡(load balance)。
& V3 _, B T$ y& p
3 R2 M* `0 s: o; L4 H8 v 每一个shard存储在一个物理服务器(server)上。Server上运行着mongod进程,通过这个进程,对shard中的数据进行操作,主要是增删改查。
) V4 G! D9 G; | j; S& S
5 o& z8 ]/ \6 n% t9 f1 v* P 如果系统中的每个shard,只存储了一份数据,没有备份,那么当这个shard所在的server挂了,数据就丢失了。在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。
7 J( c* i2 h6 v& b) x |9 Y' ^- i+ J+ ]: |+ A+ }" {* ^! Z5 j6 H
Shard keys
) n. T8 K1 U# G' C0 P: P
" {" k" M! }3 O& A$ K( b J+ e" `$ l 为了把collection切分成不同的chunks,从而存放到不同的shards中,我们需要制定一个切分的方式。
; F$ L u. [4 ^7 W* J
. Q; u" a& i6 k4 [; x" l( b8 d 如前所述,在 MongoDB 数据库中,一个表collection由多个行 documents 组成,而每个 document,有多个属性 fields。同一个 collection 中的不同的 documents,可能会有不同的 fields。例如,有个 collection 叫 Media,包含两条 documents,
. e! U3 E- \! U* u1 y9 O- q, Y2 Z! E$ g! Z$ V
{' s# v5 Z- I" d8 ?3 ?% j
"ISBN": "987-30-3652-5130-82",
6 C" ? s* \) R% V "Type": "CD",
0 |, s( R9 s) E2 U0 N5 J% j "Author": "Nirvana",
, M, a+ m8 Q% @0 P- D* W "Title": "Nevermind",
. {% i( u* c, A8 [1 `% T, ?8 H "Genre": "Grunge",
3 A2 z# \$ G* O# t4 I2 Y S) @ "Releasedate": "1991.09.24",
% j/ @& ?9 x! `( f: H "Tracklist": [
' b2 }$ P4 _5 Z( D {
* t1 G7 f% Q* ~ "Track" : "1",) g6 k# [) |% Q P& w
"Title" : "Smells like teen spirit",
% E5 S; o% L1 @1 w+ W7 H1 S0 v "Length" : "5:02"" a, M4 H. j. O9 V1 `! S
},( q3 S# k" ~ T8 `5 ~$ F# D" ^; C
{' d4 E1 r% \$ x1 S$ b
"Track" : "2",9 f; S: n: p# J: J
"Title" : "In Bloom",
1 W' z& {; F! S. d/ i# [ "Length" : "4:15"! ^% Z& w6 f# q$ H q+ `
}) c- ~" o% {; d8 J( ]- J
]* U' J0 N$ M( Z: e' i: v& j
}* ?% v" Y. q' u* ]
- Z* ?% D" R, M% A
{7 A( h! J4 W# I! o2 }# F: `% `
"ISBN": "987-1-4302-3051-9",8 @1 ]/ u" t% x: M
"Type": "Book",7 A) i% I* v" v) ^' A+ L
"Title": "Definite Guide to MongoDB: The NoSQL Database",; O& L3 [9 f- M" G
"Publisher": "Apress",+ I" \% u& `( g8 O8 x$ @: O
"Author": " Eelco Plugge",
Y) Z6 S- `. c$ { "Releasedate": "2011.06.09"
, A( j6 R7 d, g( n' N}+ C+ Y" R, ~0 Z) L/ _
6 t8 I4 Q2 B. T; F; P( l9 k5 ~
假如,在同一个 collection 中的所有 document,都包含某个共同的 field,例如前例中的“ISBN”,那么我们就可以按照这个 field 的值,来分割 collection。这个 field 的值,又称为 shard key。, L2 ^2 a9 u G* ]8 K( w6 ]$ e0 x
) b* h. \& Y; ~0 a0 Y' E 在选择shard key的时候,一定要确保这个key能够把collection均匀地切分成很多chunks。0 e: B. U* d0 n& i) ?# o
# _7 u0 }4 J& v. O7 x; e8 w8 \
例如,如果我们选择“author”作为shard key,如果有大量的作者是重名的,那么就会有大量的数据聚集在同一个chunk中。当然,假设很少有作者同名同姓,那么“author”也可以作为一个shard key。换句话说,shard key 的选择,与使用场景密切相关。; ?* y8 j n* n6 c$ O) H
* q7 W; {. I0 a% {9 o! h2 r
很多情况下,无论选择哪一个单一的 field 作为shard key,都无法均匀分割 collection。在这种情况下,我们可以考虑,用多个 fields,构成一个复合的shard key。
+ Z0 J: ] n" [% ^: i b: |! ]# R2 |' [" d' O
延续前例,假如有很多作者同名同姓,他们都叫“王二”。用 author 作为 shard key,显然无法均匀切割 collection。这时我们可以加上release-date,组成name-date的复合 shard key,例如“王二 2011”。
. G y: w3 a& \' k+ E3 k
- i6 F; B2 R7 h5 J, IChunks5 p7 \7 E( u- e' R: x, z
. I5 D, a( i! `$ }! Y, \
MongoDB按 shard key,把 collection切割成若干 chunks。每个 chunk 的数据结构,是一个三元组,{collection,minKey,maxKey},如图1-2 所示。
0 q o' h/ J6 Z3 f4 l9 A( |% |1 ^! D* g
" K: n1 @; @, h# f' C图1-2 chunk的三元组 ) E7 `' ]5 Y7 |; o
1 I! j/ r- {3 M+ ]7 d+ \ 其中,collection 是数据库中某一个表的名称,而 minKey 和 maxKey 是 shard key的范围。每一个 document 的shard key 的值,决定了这条document应该存放在哪个chunk中。
( T4 h7 k4 h, H4 e9 v
/ r& o6 h3 l. U; ?, N 如果两条 documents 的 shard keys 的值很接近,这两条 documents 很可能被存放在同一个 chunk 中。
% I8 U1 b( y+ G4 `1 C
, K# x, d& C3 S' m S# ^% C Shard key 的值的顺序,决定了 document 存放的 chunk。在 MongoDB 的文献中,这种切割 collection 的方式,称为order-preserving。- x- z- D- I4 Y4 a: }$ A
0 [, Q" q1 I. ~* l q# ~4 K
一个 chunk最多能够存储64MB的数据。 当某个chunk存储的 documents包含的数据量,接近这个阈值时,一个chunk会被切分成两个新的chunks。( ^! l4 g7 N2 e* @0 D
1 j# E" K- y0 O4 x. _ 当一个shard存储了过多的chunks,这个shard中的某些chunks会被迁移到其它 shard中。
8 o9 _& }) j8 R% L+ B' a
: w3 y5 m. ]) r 这里有个问题,假如某一条 document 包含的数据量很大,超过 64MB,一个 chunk 存放不下,怎么办?在后续章节介绍 GridFS 时,我们会详细讨论。
z" p2 J2 F" h5 ~0 U
0 r$ F2 n, {1 c/ ^Replica set
T' Q5 n+ w5 `! B& g9 v' ? : m! U/ ~+ l6 s
在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。
7 U& g3 K3 x/ J6 V A8 |9 y8 j3 G
' J* n. t/ P) f* D$ o 这个replica set包括一个primary DB和多个secondary DBs。为了数据的一致性,所有的修改(insert / update / deletes) 请求都交给primary处理。处理结束之后,再异步地备份到其他secondary中。 f' [" Q" ~* G
' V( g, [- j, I. w. b2 \ Primary DB由replica set中的所有servers,共同选举产生。当这个primaryDB server出错的时候,可以从replica set中重新选举一个新的primaryDB,从而避免了单点故障。
; n- m, Y* x. f7 e& Z6 }
% B4 J0 s5 N: P5 {0 p Replica set的选举策略和数据同步机制,确保了系统的数据的一致性。后文详述。
+ V6 H" F% ~1 ?: a8 _1 M, y" j0 N7 C$ p* ^' K
Config Server
9 w6 o% t& t% @# F% {2 x
5 h9 ]; r) R0 I* u5 {1 c Config servers用于存储MongoDB集群的元数据 metadata,这些元数据包括如下两个部分,每一个shard server包括哪些chunks,每个chunk存储了哪些 collections 的哪些 documents。
' m" h9 f& j# S8 I) J3 I
. a+ k0 Q! P! Y$ X+ s2 ~. C: L 每一个config server都包括了MongoDB中所有chunk的信息。
# u; n6 k3 b4 ]+ j/ Y
& o; ]& e$ Y# G3 G! v Config server也需要 replication。但是有趣的是,config server 采用了自己独特的replication模式,而没有沿用 replica set。
( d- B+ R" a2 b7 V0 Q3 `( j' y; E$ B
如果任何一台config server挂了,整个 config server 集群中,其它 config server变成只读状态。这样做的原因,是避免在系统不稳定的情况下,冒然对元数据做任何改动,导致在不同的 config servers 中,出现元数据不一致的情况。
: U8 A7 i) v# A6 c1 K$ h) P, C! w6 f, z
MongoDB的官方文档建议,配置3个config servers比较合适,既提供了足够的安全性,又避免了更多的config servers实例之间的数据同步,引起的元数据不一致的麻烦。
9 E- E9 S0 t- [. w, |; {, j, N' g$ Z# o& S4 M( ^: V
Mongos
7 N# I$ Q% N t# _" L9 A
/ ?( R* q! l: _1 b 用户使用MongoDB 时,用户的操作请求,全部由mongos来转发。
* k9 [+ G% j0 s! G2 Q* E9 Y
& d9 D. ]( F8 P1 N) X1 X 当 mongos 接收到用户请求时,它先查询 config server,找到存放相应数据的shard servers。然后把用户请求,转发到这些 shard servers。当这些 shard servers完成操作后,它们把结果分别返回给 mongos。而当 mongos 汇总了所有的结果后,它把结果返回给用户。# l# @7 z% P; P0 W+ {( o0 o4 j
* Y J- e7 ^$ s- \( [" e7 G H. ~ Mongos每次启动的时候,都要到config servers中读取元数据,并缓存在本地。每当 config server中的元数据有改动,它都会通知所有的mongos。. c! W3 m& N& A- n: r3 c3 }
; b% X' r8 W' T% N1 d# [9 m Mongos之间,不存在彼此协同工作的问题。因此,MongoDB所需要配置的mongos server的数量,没有限制。6 ~, G$ ~$ P+ U9 `5 o$ i! k& ]
U4 V6 d* ~3 q* u9 n% O" x 通过以上的介绍,我们对每个组成部分都有了基本的了解,但是涉及到工作的细节,我们尚有诸多疑问,例如,一个chunk的数据太大,如何切分?一个shard数据太多,如何迁移?在replica set中,如何选择primary?server挂了,怎么进行故障恢复?接下来的章节,我们逐个回答这些问题。" D. |( b, c7 A& S0 g8 \
# j6 E! t+ o4 a z# z% O" P, w, L/ i" k
Reference," B( v, n' g K+ }' b
8 q4 B0 H* \8 W
[0] Architectural Overview
( [5 Z" c9 y( G* X5 [* V+ [# ohttp://www.mongodb.org/display/DOCS/Sharding+Introduction U: F9 |# B6 O4 W4 C- K
|
评分
-
查看全部评分
|