|
|
关于MongoDB,我们能看到的资料,基本都是在指导大家如何使用MongoDB,但是,MongoDB内部是如何运作的,资料不是很多。
" V1 f, x0 \8 h4 | i, @
J! q2 K! U( ]) V% w7 m 阅读使用手册,会有很多疑惑之处。例如,有人说,MongoDB 等同于分布式的 MySQL。它把一个Table ,按 row,分割成多个Shards,分别存放在不同的 Servers 上。这种说法是否正确?% B, J; y; ^6 v# P7 ?
@8 l# `8 J, m- d: b; I% n 不深入了解 MongoDB 的内部结构,就无法透彻地回答类似问题。这个系列文章,就来和大家探讨MongoDB的内部的工作方式。
, M# Q* D- R6 r5 W; U
- d' h, ^7 Y. [/ H3 }
1 T9 M6 a4 R+ v9 _$ i2 m- m
2 m/ a; }! P2 X/ T3 H
图1-1 MongoDB架构图
6 C6 P4 I m) S. n) u1 V0 y% b6 l" c! ?1 w( B; s
MongoDB 通常运行在一个服务器集群上,而不是一个单机。图1-1,描述了一个MongoDB集群的基本组成部分,包括若干shards,至少一个config server,至少一个routing servers(又称 mongos)。+ [* i3 M5 s) t, J7 g- G: D
( h0 I* D4 R1 N) }" ZShards
; c v6 m& C9 D. ]8 k
- x2 S, l% B# O) j$ H MongoDB的最基本的数据单元,叫document,类似于关系式数据库中的行 row。一系列documents,组成了一个collection,相当于关系式数据库中的table。当一个 collection 数据量太大时,可以把该collection按documents切分,分成多个数据块,每个数据块叫做一个chunk,多个chunks聚集在一起,组成了一个shard。
8 Y5 D* g* X6 o6 C$ u; k0 a- S8 d' f8 g! |
Sharding 的意义,不仅保障了数据库的扩容(scalability),同时也保障了系统的负载均衡(load balance)。
5 Q* I6 \4 L3 ]' D; x. O, Z+ {% E4 T" v8 k: R3 `2 E0 ?, C+ z
每一个shard存储在一个物理服务器(server)上。Server上运行着mongod进程,通过这个进程,对shard中的数据进行操作,主要是增删改查。+ a3 l! F$ M5 @$ U3 p2 u" \2 Z
$ E1 [# ^) ` `4 _ F8 ^ 如果系统中的每个shard,只存储了一份数据,没有备份,那么当这个shard所在的server挂了,数据就丢失了。在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。
/ [4 u; s. S6 L) `3 t0 y
' L; _# y5 Z- j/ R3 W1 {Shard keys2 T0 d7 e9 c0 }
' A8 A+ w& e( U$ ~, R& H
为了把collection切分成不同的chunks,从而存放到不同的shards中,我们需要制定一个切分的方式。: c' L8 _- C0 ^" G( }
7 r- t. C6 z7 k5 Z8 T. P) R7 b* a
如前所述,在 MongoDB 数据库中,一个表collection由多个行 documents 组成,而每个 document,有多个属性 fields。同一个 collection 中的不同的 documents,可能会有不同的 fields。例如,有个 collection 叫 Media,包含两条 documents,
. a/ r; i+ n3 ^
9 U# x& r4 b6 j, y{
1 k" I0 ?" y$ D6 D "ISBN": "987-30-3652-5130-82",- a( _6 S) L- N, L
"Type": "CD",/ Y/ C) X' E6 i; [+ s! K
"Author": "Nirvana",7 b2 p1 C6 e; a( o, j* T
"Title": "Nevermind",
$ ?3 f: w- N3 ^0 i: V "Genre": "Grunge",
+ e5 F6 Q$ G$ Q& Y& O, R "Releasedate": "1991.09.24",3 t# [1 y! x/ T" z0 P
"Tracklist": [/ V& i% M1 j7 o
{8 B W) a1 e! m( H6 v \7 v
"Track" : "1",0 H |3 K$ G$ ?9 i5 ~
"Title" : "Smells like teen spirit",8 {' g/ G4 H4 W h( d9 |) x) S9 [ O- c* Z
"Length" : "5:02"
0 y' {+ v2 h" v1 [" M3 Z! X },
6 f' @; Y/ j* M6 ]% Y' \* ^ {9 V/ B6 C5 Z# J# v0 R5 s7 [2 r. W
"Track" : "2",
, I/ i, t2 k/ N$ M "Title" : "In Bloom",
) u# |! h* m* t( c8 z9 C5 K "Length" : "4:15"
; t, _* e! @, m+ N }9 K/ d" q" I) [8 g) p- L
]6 h0 U' ~( }2 O1 g' x! F
}
( B2 S7 @- f& z5 v2 {; W! ]4 g$ b- E' D0 X) {0 U/ @4 D
{6 A* v% g. b% s$ z& N' g
"ISBN": "987-1-4302-3051-9",
2 V* ^% B' G ]1 w "Type": "Book"," ~0 O# [1 J9 |2 X
"Title": "Definite Guide to MongoDB: The NoSQL Database",+ N& n" W4 I3 L" H# k
"Publisher": "Apress",
: N2 v- a r9 x0 `4 w, Y% P "Author": " Eelco Plugge",* a2 j4 s2 W. {* p. j1 p. }
"Releasedate": "2011.06.09") o7 o. X* p8 g% M8 \$ d
}
9 d+ K! b4 J* a. g$ a# U. h1 y5 z0 b R- G- |: s
假如,在同一个 collection 中的所有 document,都包含某个共同的 field,例如前例中的“ISBN”,那么我们就可以按照这个 field 的值,来分割 collection。这个 field 的值,又称为 shard key。! k4 A7 t8 v9 `- n, X' w
2 x( S4 i. r$ N5 I7 Y 在选择shard key的时候,一定要确保这个key能够把collection均匀地切分成很多chunks。
: i$ G. ~: [' f+ a. @9 h- {& i, Y1 r+ y7 Y9 u$ Y7 h
例如,如果我们选择“author”作为shard key,如果有大量的作者是重名的,那么就会有大量的数据聚集在同一个chunk中。当然,假设很少有作者同名同姓,那么“author”也可以作为一个shard key。换句话说,shard key 的选择,与使用场景密切相关。& \# Y H5 J7 B* ]6 w8 @/ D7 U
2 ]( U4 C9 i+ f: r5 |# i+ V 很多情况下,无论选择哪一个单一的 field 作为shard key,都无法均匀分割 collection。在这种情况下,我们可以考虑,用多个 fields,构成一个复合的shard key。. u, h% r s4 N0 n* d; |* a
( G/ ^. z0 X% R8 B/ B6 d7 a
延续前例,假如有很多作者同名同姓,他们都叫“王二”。用 author 作为 shard key,显然无法均匀切割 collection。这时我们可以加上release-date,组成name-date的复合 shard key,例如“王二 2011”。/ N; ]. X; T* `. \3 [6 e* E2 b
" W% R+ n2 l0 P0 b- aChunks
2 i6 o" I- I$ I1 c0 z
0 ]" i, m5 A$ g6 x* ? MongoDB按 shard key,把 collection切割成若干 chunks。每个 chunk 的数据结构,是一个三元组,{collection,minKey,maxKey},如图1-2 所示。* R( D& v5 n: n6 _4 b
) Q6 E, C! @6 l0 I3 p |& ~5 j
( L0 [5 p8 Q3 l) c/ e# R图1-2 chunk的三元组
/ P( C A8 ^' J! I# v
0 v; K/ b. b+ t1 }8 i9 W5 } 其中,collection 是数据库中某一个表的名称,而 minKey 和 maxKey 是 shard key的范围。每一个 document 的shard key 的值,决定了这条document应该存放在哪个chunk中。0 Q4 \2 A0 C! T9 ~
' N: w- d* F+ j8 `1 G% G$ w: \ 如果两条 documents 的 shard keys 的值很接近,这两条 documents 很可能被存放在同一个 chunk 中。) O# {& `: e/ B4 L$ B7 ^+ Z4 I4 A6 ?
: ], B7 J4 Y1 q: @6 k% p9 Z Shard key 的值的顺序,决定了 document 存放的 chunk。在 MongoDB 的文献中,这种切割 collection 的方式,称为order-preserving。
9 M3 @" p* y! E8 Z- |. E( t: g
, M) o9 S* ^. \' H 一个 chunk最多能够存储64MB的数据。 当某个chunk存储的 documents包含的数据量,接近这个阈值时,一个chunk会被切分成两个新的chunks。+ T9 v9 |- P {
3 Z3 `3 b7 u0 n4 i" h 当一个shard存储了过多的chunks,这个shard中的某些chunks会被迁移到其它 shard中。
, B6 m+ A9 d$ P5 l% k6 v
) `7 s4 q! k$ L 这里有个问题,假如某一条 document 包含的数据量很大,超过 64MB,一个 chunk 存放不下,怎么办?在后续章节介绍 GridFS 时,我们会详细讨论。
! T; b6 X" A! G! t+ H" O1 Q$ {
2 f- k$ H1 v2 |6 c; H% q8 k ^( s( lReplica set- E$ b4 ~! U. Y# [0 N) C. d
, Y% y, Q+ r2 f( L/ x 在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。- w- C; I: O _9 s. s
+ K7 W% {. |/ |, D9 p) z
这个replica set包括一个primary DB和多个secondary DBs。为了数据的一致性,所有的修改(insert / update / deletes) 请求都交给primary处理。处理结束之后,再异步地备份到其他secondary中。
8 y- {* R; t& q% J, G# s) A( k% t8 X) X7 H8 h* }, P
Primary DB由replica set中的所有servers,共同选举产生。当这个primaryDB server出错的时候,可以从replica set中重新选举一个新的primaryDB,从而避免了单点故障。
! {" B7 U; i* D* U) q
3 ^ | }7 I1 e$ D2 x# i7 | Replica set的选举策略和数据同步机制,确保了系统的数据的一致性。后文详述。) h7 A" e. ?7 T
5 {% q1 T( {0 X5 ^6 _6 iConfig Server+ l; y8 A# o" b$ c
6 x9 h9 I/ o8 D5 L* l U
Config servers用于存储MongoDB集群的元数据 metadata,这些元数据包括如下两个部分,每一个shard server包括哪些chunks,每个chunk存储了哪些 collections 的哪些 documents。$ `0 ^- D6 k# |: f9 s9 ^ F0 c9 G
2 s9 n* l" c' a. X% @- C
每一个config server都包括了MongoDB中所有chunk的信息。, d. T% a" G" d" P9 j0 @% H: Q) C
- l7 Z `/ r" |9 M
Config server也需要 replication。但是有趣的是,config server 采用了自己独特的replication模式,而没有沿用 replica set。1 Q6 R9 s, X8 D+ n2 ]9 M
! ~1 ?: F8 @- K$ L7 t 如果任何一台config server挂了,整个 config server 集群中,其它 config server变成只读状态。这样做的原因,是避免在系统不稳定的情况下,冒然对元数据做任何改动,导致在不同的 config servers 中,出现元数据不一致的情况。
. a9 S- o$ m; D: ^! b: t
+ A, q1 L2 R; \3 L' n MongoDB的官方文档建议,配置3个config servers比较合适,既提供了足够的安全性,又避免了更多的config servers实例之间的数据同步,引起的元数据不一致的麻烦。
) m! ~( t* j% ?: |" u8 N$ Y! I7 X$ c$ V- X. `
Mongos
' \; q# R* v5 E# j: k
1 \3 V4 E k' Q0 q 用户使用MongoDB 时,用户的操作请求,全部由mongos来转发。
n$ b4 V: H0 u4 |2 q" |( ?
0 V: u/ c) ]8 b- [# R 当 mongos 接收到用户请求时,它先查询 config server,找到存放相应数据的shard servers。然后把用户请求,转发到这些 shard servers。当这些 shard servers完成操作后,它们把结果分别返回给 mongos。而当 mongos 汇总了所有的结果后,它把结果返回给用户。
) O0 j4 r) ^; y6 p1 s9 a' V3 @7 M4 N. ] u" v l
Mongos每次启动的时候,都要到config servers中读取元数据,并缓存在本地。每当 config server中的元数据有改动,它都会通知所有的mongos。- r1 h+ ]* F( t# A4 o6 \' w% S
: v, v% B2 D9 k4 {6 Z1 w
Mongos之间,不存在彼此协同工作的问题。因此,MongoDB所需要配置的mongos server的数量,没有限制。
9 J# ?# C r0 I& v
9 t% _4 {; q2 y 通过以上的介绍,我们对每个组成部分都有了基本的了解,但是涉及到工作的细节,我们尚有诸多疑问,例如,一个chunk的数据太大,如何切分?一个shard数据太多,如何迁移?在replica set中,如何选择primary?server挂了,怎么进行故障恢复?接下来的章节,我们逐个回答这些问题。 a" S9 |. |% N4 {- k% J3 |5 g1 B
+ F) k4 N7 m3 w! T
8 W7 U" q, Q# X j( LReference,8 A! O: M0 x d3 W4 g
( e# K* M* X- X0 L
[0] Architectural Overview
# J! a: l3 h" f$ J! b; xhttp://www.mongodb.org/display/DOCS/Sharding+Introduction2 v5 v' R" h# z R0 |
|
评分
-
查看全部评分
|