|
|
关于MongoDB,我们能看到的资料,基本都是在指导大家如何使用MongoDB,但是,MongoDB内部是如何运作的,资料不是很多。9 }$ T7 w/ o5 C @( |5 d6 v# }
- T3 s$ |' {' Z6 C 阅读使用手册,会有很多疑惑之处。例如,有人说,MongoDB 等同于分布式的 MySQL。它把一个Table ,按 row,分割成多个Shards,分别存放在不同的 Servers 上。这种说法是否正确?
) }( j; n) d' |: _7 s! q5 l6 S! j
R! `6 l4 t/ @. g 不深入了解 MongoDB 的内部结构,就无法透彻地回答类似问题。这个系列文章,就来和大家探讨MongoDB的内部的工作方式。% Q' H% n4 S" }2 W) Z, w: M/ g
: b' S0 i$ F: s; c6 y0 m
# s/ W- C$ Y0 ]3 t5 G" ?; G
# f( v" w1 u7 d0 p1 h* X图1-1 MongoDB架构图 ( ]9 R# O& }. [' A- F, Y7 t0 D
9 o% c9 m6 \3 C2 D, B8 J7 y; \ MongoDB 通常运行在一个服务器集群上,而不是一个单机。图1-1,描述了一个MongoDB集群的基本组成部分,包括若干shards,至少一个config server,至少一个routing servers(又称 mongos)。2 Q+ _6 f; P' E$ ^' k
7 }- }, @: c3 \7 |) x9 v" N
Shards
% C! m4 X* H, n% F: H( [1 R1 q ]# E( A8 a& P. u7 {
MongoDB的最基本的数据单元,叫document,类似于关系式数据库中的行 row。一系列documents,组成了一个collection,相当于关系式数据库中的table。当一个 collection 数据量太大时,可以把该collection按documents切分,分成多个数据块,每个数据块叫做一个chunk,多个chunks聚集在一起,组成了一个shard。
! B5 J1 Y* M7 w/ Q" v. ~7 B0 Y Z) T
Sharding 的意义,不仅保障了数据库的扩容(scalability),同时也保障了系统的负载均衡(load balance)。: W1 l9 ?0 ^# `! E
6 C' ^3 K% y. U8 e8 Y% c8 P 每一个shard存储在一个物理服务器(server)上。Server上运行着mongod进程,通过这个进程,对shard中的数据进行操作,主要是增删改查。3 P* ?. l! {2 u6 G& ^7 t( B: u
7 O- T& z* l# Z0 T; T- C
如果系统中的每个shard,只存储了一份数据,没有备份,那么当这个shard所在的server挂了,数据就丢失了。在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。
o( k+ G, x6 C3 ]9 F
1 X* }0 d) ?6 ^Shard keys
$ ^8 _, T3 x$ R; P & a2 {4 e& M, t; I6 `, m& `
为了把collection切分成不同的chunks,从而存放到不同的shards中,我们需要制定一个切分的方式。
( Z8 z1 o9 l1 _5 W3 I( k. C- a, h; t' J( ~2 Z& B( I3 m# ]
如前所述,在 MongoDB 数据库中,一个表collection由多个行 documents 组成,而每个 document,有多个属性 fields。同一个 collection 中的不同的 documents,可能会有不同的 fields。例如,有个 collection 叫 Media,包含两条 documents,
2 F+ e9 ?5 W k0 S) k1 }
! m5 {( j0 Y* p/ l0 a W( P, a{6 @+ y" D& z5 z0 E$ l4 f0 U
"ISBN": "987-30-3652-5130-82",
0 z* L$ m' w- _3 B3 I4 G "Type": "CD",+ D/ N0 p f9 b
"Author": "Nirvana",
$ u! B+ f3 u4 V0 b* ^! G8 V "Title": "Nevermind",5 F8 {! i4 ]3 U* t, {
"Genre": "Grunge", H/ \- T0 k( c$ `, l) i6 H2 L
"Releasedate": "1991.09.24",* g) F: o. h3 ~, ?) g* y, x
"Tracklist": [! |8 `% e$ w1 Z; G9 k, s1 Y
{
) v _3 n0 G# W/ c# S- N7 L "Track" : "1",) w$ L9 H3 a1 U2 W$ S' ^0 b5 |: X
"Title" : "Smells like teen spirit",
+ M- L: p6 U; U8 e7 }- C2 s$ {9 e" D4 A "Length" : "5:02"
5 H2 P2 j4 B* Z9 v# V4 F },
+ z" a% h# c# W7 `1 @ {
. d6 H' h5 e+ b/ O8 m "Track" : "2",
* U2 H( `7 _) |% d "Title" : "In Bloom",, o, o8 o' [1 P5 p
"Length" : "4:15"
' ^- l; Y$ V9 R% K. o: T" g! ^! I }
2 h+ j- s: R' n3 O ]
' K- {8 Y+ k9 W% k; m} V- x- h+ v: ~# L: S
# a6 P9 c/ _- E+ K8 o0 _
{$ H/ G( a9 F0 r# |6 _3 J
"ISBN": "987-1-4302-3051-9",! i: f& Q% g; f
"Type": "Book",
, g+ K. x, o( d& z8 p) t- ?. u. Y "Title": "Definite Guide to MongoDB: The NoSQL Database",
2 G2 ?1 ^% G3 Y5 s! ] "Publisher": "Apress",
. s/ T6 n7 w$ Q1 N! M9 ~ "Author": " Eelco Plugge",8 x7 t7 F( S6 q/ g# p% p
"Releasedate": "2011.06.09"
1 j2 ]: v+ T4 L5 M7 `& b- y* l) n}
% M2 c! F3 d& K
3 m b) z7 C* D; L: n 假如,在同一个 collection 中的所有 document,都包含某个共同的 field,例如前例中的“ISBN”,那么我们就可以按照这个 field 的值,来分割 collection。这个 field 的值,又称为 shard key。
: J- H' D# \5 ^0 q
* i6 ~$ p2 W% n# i/ Y7 a 在选择shard key的时候,一定要确保这个key能够把collection均匀地切分成很多chunks。( ?, j5 K. d+ _, Z3 T( @: U' G* N
. ~0 m! e3 F9 P; L' n8 k0 f' `8 I
例如,如果我们选择“author”作为shard key,如果有大量的作者是重名的,那么就会有大量的数据聚集在同一个chunk中。当然,假设很少有作者同名同姓,那么“author”也可以作为一个shard key。换句话说,shard key 的选择,与使用场景密切相关。% m/ ?0 Y' p O0 I# d. T; ~6 i
* t2 o. \( h% j; F w1 p* p- C& E: p6 v
很多情况下,无论选择哪一个单一的 field 作为shard key,都无法均匀分割 collection。在这种情况下,我们可以考虑,用多个 fields,构成一个复合的shard key。/ L2 p" [9 q; t0 \4 n1 ?) @& X
# B* B8 [3 T8 J' U
延续前例,假如有很多作者同名同姓,他们都叫“王二”。用 author 作为 shard key,显然无法均匀切割 collection。这时我们可以加上release-date,组成name-date的复合 shard key,例如“王二 2011”。
! a* ~! o: k* W0 w& k5 \$ q8 u: _( b6 B% [
Chunks, ]% S# z: w# l; E0 l* v' g
5 I8 y" k5 O: v p9 s9 F3 ]
MongoDB按 shard key,把 collection切割成若干 chunks。每个 chunk 的数据结构,是一个三元组,{collection,minKey,maxKey},如图1-2 所示。
% b! L B; I: G; K
# d0 t4 x3 i, P) M5 Y3 p+ ~
& ~5 \" u# D( m" y3 c( b! P$ P
图1-2 chunk的三元组
, d) J% ?9 ^2 S/ N3 F6 E; M( U3 j8 K0 m: |$ c$ ]
其中,collection 是数据库中某一个表的名称,而 minKey 和 maxKey 是 shard key的范围。每一个 document 的shard key 的值,决定了这条document应该存放在哪个chunk中。! k# f1 l; E& P3 t0 |% y+ L6 C/ N1 Q
4 ^2 \ L1 L% k- R# C
如果两条 documents 的 shard keys 的值很接近,这两条 documents 很可能被存放在同一个 chunk 中。
2 ~# F. d T- ^6 k: ~1 I8 {0 t/ ?# ]2 B; O
Shard key 的值的顺序,决定了 document 存放的 chunk。在 MongoDB 的文献中,这种切割 collection 的方式,称为order-preserving。' u( ~% Y1 t! C" V) Z
4 n' g0 @1 Z. i0 E9 s* v 一个 chunk最多能够存储64MB的数据。 当某个chunk存储的 documents包含的数据量,接近这个阈值时,一个chunk会被切分成两个新的chunks。
, T) x8 H" u- o Q# F; i7 `* c: p. M a0 G n* E
当一个shard存储了过多的chunks,这个shard中的某些chunks会被迁移到其它 shard中。+ O2 I# c1 ?: {/ A" h y0 ^3 z3 R! |) a
9 D! S9 D, S( n
这里有个问题,假如某一条 document 包含的数据量很大,超过 64MB,一个 chunk 存放不下,怎么办?在后续章节介绍 GridFS 时,我们会详细讨论。. g# F" Y# i( L
' _/ d& y) a' `+ h
Replica set
5 ~7 |$ ?# v8 K# k1 b: |) H9 j & {0 C# }0 f. O8 w) w* }% r
在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。
- A# d* U* t6 I6 o
' |/ ^1 f" d2 f3 W 这个replica set包括一个primary DB和多个secondary DBs。为了数据的一致性,所有的修改(insert / update / deletes) 请求都交给primary处理。处理结束之后,再异步地备份到其他secondary中。
! E) r+ ?7 M9 L" D4 `# P( J
) C C( u7 M; h% H+ g' P- ]% U( B Primary DB由replica set中的所有servers,共同选举产生。当这个primaryDB server出错的时候,可以从replica set中重新选举一个新的primaryDB,从而避免了单点故障。( b) j0 x) c: I8 A8 N3 h
5 [8 b& e$ i: X! Y; A6 l4 l$ ?- {' \
Replica set的选举策略和数据同步机制,确保了系统的数据的一致性。后文详述。9 d; D/ Z7 r( Z, a* a' z) ^; F
/ O+ I# h! P* A6 ?" D' R0 QConfig Server
7 i7 w8 V' [/ a) l0 P2 p ' h7 ?$ H3 {' C$ j
Config servers用于存储MongoDB集群的元数据 metadata,这些元数据包括如下两个部分,每一个shard server包括哪些chunks,每个chunk存储了哪些 collections 的哪些 documents。; F3 Z c4 u. f g/ Z
4 n5 H" X" F$ e: M; P& ^3 u' L1 E 每一个config server都包括了MongoDB中所有chunk的信息。, I' k) | R( ^9 ?7 ?2 U. U: f- D( J
% |: ~7 k6 N( l9 k. y
Config server也需要 replication。但是有趣的是,config server 采用了自己独特的replication模式,而没有沿用 replica set。& P3 J3 X" y9 ?
% T% p2 s, ` J) d" E" H4 | 如果任何一台config server挂了,整个 config server 集群中,其它 config server变成只读状态。这样做的原因,是避免在系统不稳定的情况下,冒然对元数据做任何改动,导致在不同的 config servers 中,出现元数据不一致的情况。
6 G% K6 ?* ^( W& ]+ t
) ~" k9 [. X7 O1 A W& W MongoDB的官方文档建议,配置3个config servers比较合适,既提供了足够的安全性,又避免了更多的config servers实例之间的数据同步,引起的元数据不一致的麻烦。# D. m! F- P% F1 x. [, {% Q9 p
6 [9 J( C. U P
Mongos
4 p9 M0 j; J; M4 D! x/ b6 j9 R* G2 m% n q5 L) W
用户使用MongoDB 时,用户的操作请求,全部由mongos来转发。
# z9 f1 z6 |. S9 L
5 Z* m, b4 q k$ I9 [. S" ] 当 mongos 接收到用户请求时,它先查询 config server,找到存放相应数据的shard servers。然后把用户请求,转发到这些 shard servers。当这些 shard servers完成操作后,它们把结果分别返回给 mongos。而当 mongos 汇总了所有的结果后,它把结果返回给用户。/ Z( d z# ^, R+ q; w& C1 s$ {; C
A+ d: f) {8 V2 ^7 l
Mongos每次启动的时候,都要到config servers中读取元数据,并缓存在本地。每当 config server中的元数据有改动,它都会通知所有的mongos。* P5 u( H# L# M& A7 r1 C8 S& z
& P8 i% ~2 W( ^% I5 T Mongos之间,不存在彼此协同工作的问题。因此,MongoDB所需要配置的mongos server的数量,没有限制。! ?8 l! v' x3 v7 d3 _, d2 i& b# `7 f
' c5 y$ b9 E9 M6 p3 `- U& g1 A 通过以上的介绍,我们对每个组成部分都有了基本的了解,但是涉及到工作的细节,我们尚有诸多疑问,例如,一个chunk的数据太大,如何切分?一个shard数据太多,如何迁移?在replica set中,如何选择primary?server挂了,怎么进行故障恢复?接下来的章节,我们逐个回答这些问题。
. \) A4 v7 |2 P% b) q7 Q
! l$ x/ U, I! z) ~( @8 U% ~" }
Reference,
* B* O4 x2 H# b$ Y9 o" o
8 Y- I- K/ \3 @) \( v7 m3 s9 w# [& J[0] Architectural Overview7 O' Z- ]9 R- ?8 u, ?8 a, {
http://www.mongodb.org/display/DOCS/Sharding+Introduction
" W# \1 q) Z( v$ g4 C3 F" A |
评分
-
查看全部评分
|