|
关于MongoDB,我们能看到的资料,基本都是在指导大家如何使用MongoDB,但是,MongoDB内部是如何运作的,资料不是很多。0 k+ A" R7 y u( B& n
" j: K: o0 |% C# Z 阅读使用手册,会有很多疑惑之处。例如,有人说,MongoDB 等同于分布式的 MySQL。它把一个Table ,按 row,分割成多个Shards,分别存放在不同的 Servers 上。这种说法是否正确?
) @* V& J: } [; z/ E+ W' e1 |& T4 q S" n
不深入了解 MongoDB 的内部结构,就无法透彻地回答类似问题。这个系列文章,就来和大家探讨MongoDB的内部的工作方式。
, ^. r* @$ ]4 ?1 i
/ Y$ E0 u2 z' {. Z+ g; d0 V
4 L3 e9 l, u! n3 R( D
/ d0 q& h0 [0 M* Y! b! N图1-1 MongoDB架构图
; s7 i) w6 Z# a6 e8 @: {$ G3 f' w* u
# N+ ?7 S( v9 Y+ Z- H* F2 a MongoDB 通常运行在一个服务器集群上,而不是一个单机。图1-1,描述了一个MongoDB集群的基本组成部分,包括若干shards,至少一个config server,至少一个routing servers(又称 mongos)。0 t# s3 A$ _# c7 {- k" m2 r
0 F7 k8 p& O$ H% h9 b
Shards p( W a* H+ i( @
5 z$ n" ~- A* c. s) W MongoDB的最基本的数据单元,叫document,类似于关系式数据库中的行 row。一系列documents,组成了一个collection,相当于关系式数据库中的table。当一个 collection 数据量太大时,可以把该collection按documents切分,分成多个数据块,每个数据块叫做一个chunk,多个chunks聚集在一起,组成了一个shard。
8 X; \/ r0 B. v5 J S
4 U# C+ H6 _( K9 J) C6 o) g" k; i Sharding 的意义,不仅保障了数据库的扩容(scalability),同时也保障了系统的负载均衡(load balance)。5 X N* K, R/ q5 ^4 T; `
# O! a0 g5 x4 \" G$ \; w8 F5 ] 每一个shard存储在一个物理服务器(server)上。Server上运行着mongod进程,通过这个进程,对shard中的数据进行操作,主要是增删改查。8 O- A( J' O( H6 l9 U( r/ a
+ W' n) h' Y6 I: h2 e3 H9 p9 Z 如果系统中的每个shard,只存储了一份数据,没有备份,那么当这个shard所在的server挂了,数据就丢失了。在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。
9 A+ R( _/ ?0 s/ y R
. S9 ?$ f) [) f7 F2 bShard keys
& E/ S. v$ k8 {. L T " g: ]! W% f3 Z
为了把collection切分成不同的chunks,从而存放到不同的shards中,我们需要制定一个切分的方式。/ L9 S A+ E \7 i
# i& r" H! K4 O: O+ p
如前所述,在 MongoDB 数据库中,一个表collection由多个行 documents 组成,而每个 document,有多个属性 fields。同一个 collection 中的不同的 documents,可能会有不同的 fields。例如,有个 collection 叫 Media,包含两条 documents,1 O: I, G1 N2 W! B9 X
" S2 a9 d- j. r( y$ N4 G) J{
+ u2 B1 Q: X1 b7 _* d3 R "ISBN": "987-30-3652-5130-82",
4 } L, H6 T' e7 h$ ^ "Type": "CD",+ Q$ ^7 o8 S+ E% n
"Author": "Nirvana",. @2 g( }. Y% E, `* F2 r
"Title": "Nevermind",7 X9 s5 w# t4 ?% Y) |
"Genre": "Grunge",5 u8 y- S$ B+ a5 S
"Releasedate": "1991.09.24",
* k% i2 x |# g7 y" ^- n "Tracklist": [
) Q. X+ ^+ O% y. N. S( V {$ z, q% k. Y! F, \7 |' w- G
"Track" : "1",1 N- A8 r" t. L. h+ Z+ p
"Title" : "Smells like teen spirit", g* @ C# a1 n1 J% ^; J
"Length" : "5:02"' G4 P# d5 ]! s: b# `
},
; F1 p" X3 V$ `/ _ {* [% R% v* ] x3 J
"Track" : "2",
. `) |; m" M2 ^6 w( e "Title" : "In Bloom",
3 F2 x/ x2 l. E: H0 o, e% F "Length" : "4:15"
4 c) `& F4 P5 Y; m% \ }
' h3 d; d* V2 ?" K: `5 Q- L% N) Z ]- a. I& M: M. A4 Q- H7 s: ~
}7 r- N. _1 y- ^: E! R+ b
9 [2 s6 S0 P8 T- w6 D% w+ L{
+ u% U7 b' T( m/ }, l6 j "ISBN": "987-1-4302-3051-9",9 m, u( e* I8 u; D3 r
"Type": "Book",- D! p9 f T' e- }4 e
"Title": "Definite Guide to MongoDB: The NoSQL Database",/ T2 l8 T, l. G' q% Y
"Publisher": "Apress",/ A: j2 c- L/ C- e
"Author": " Eelco Plugge",1 O, ^: v2 W5 r& x6 j
"Releasedate": "2011.06.09"
. b) F8 ]% Q* |5 b}9 F7 C, d( G7 c6 {
, [) t" [% ~* J+ r. B
假如,在同一个 collection 中的所有 document,都包含某个共同的 field,例如前例中的“ISBN”,那么我们就可以按照这个 field 的值,来分割 collection。这个 field 的值,又称为 shard key。
% r1 ^+ d L: i1 f6 H/ @+ m* m% |# l; v0 u* `6 s
在选择shard key的时候,一定要确保这个key能够把collection均匀地切分成很多chunks。
" j9 i" \( W, X9 {: X u
$ r5 h2 V5 l4 q 例如,如果我们选择“author”作为shard key,如果有大量的作者是重名的,那么就会有大量的数据聚集在同一个chunk中。当然,假设很少有作者同名同姓,那么“author”也可以作为一个shard key。换句话说,shard key 的选择,与使用场景密切相关。6 K, i7 x9 u% y/ I
# h3 H/ B, e5 D3 q, L
很多情况下,无论选择哪一个单一的 field 作为shard key,都无法均匀分割 collection。在这种情况下,我们可以考虑,用多个 fields,构成一个复合的shard key。
+ X- H! t7 L7 x' g/ b, K' i q
# n+ y# P9 U2 j5 ] 延续前例,假如有很多作者同名同姓,他们都叫“王二”。用 author 作为 shard key,显然无法均匀切割 collection。这时我们可以加上release-date,组成name-date的复合 shard key,例如“王二 2011”。2 I, T% I' w# G2 \0 }7 t
& S& M* M! q. M4 Y2 R! `, r. mChunks$ X$ Z# r9 T* L8 v8 M8 Z
9 {0 u! ?/ P* U# ]3 `
MongoDB按 shard key,把 collection切割成若干 chunks。每个 chunk 的数据结构,是一个三元组,{collection,minKey,maxKey},如图1-2 所示。
' P$ g) M# t1 P9 Z y9 d* H# j
2 o4 y0 A+ p& c \2 q/ u# K3 s6 |8 c3 [
" _ X* }8 `: ]( Y) b* ^
图1-2 chunk的三元组 9 a) C# J( \ L7 d M/ b
+ p+ }/ g3 w# {1 l6 h2 s 其中,collection 是数据库中某一个表的名称,而 minKey 和 maxKey 是 shard key的范围。每一个 document 的shard key 的值,决定了这条document应该存放在哪个chunk中。5 t7 o7 E! C. t* v' ^0 g
1 n" ]8 }) T/ Z
如果两条 documents 的 shard keys 的值很接近,这两条 documents 很可能被存放在同一个 chunk 中。
% m3 e0 u. H7 H
2 q5 Q' u1 l7 t5 J/ b4 K1 f Shard key 的值的顺序,决定了 document 存放的 chunk。在 MongoDB 的文献中,这种切割 collection 的方式,称为order-preserving。
; `0 s- `' Z- r, o" }$ L4 H( r8 |6 f, W$ H: F( ]
一个 chunk最多能够存储64MB的数据。 当某个chunk存储的 documents包含的数据量,接近这个阈值时,一个chunk会被切分成两个新的chunks。
, j6 L! w* A# D( w4 T5 x! ?/ {- v! r) _
当一个shard存储了过多的chunks,这个shard中的某些chunks会被迁移到其它 shard中。
& _/ x: V) B+ v, R- P7 w4 s/ D
* g. e9 [! y; \0 C4 t' G 这里有个问题,假如某一条 document 包含的数据量很大,超过 64MB,一个 chunk 存放不下,怎么办?在后续章节介绍 GridFS 时,我们会详细讨论。
0 z) q) {& ^' x9 h( g- y+ U7 g
+ q* T- o; f# B( `0 m. k) u$ `; [Replica set
, _) ^- r' q: D2 X9 [' c% J/ M, R 9 y! l! D( V B
在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。, W3 C4 l( Z& l% R r5 I5 q. Z8 F
% N3 r! w# M! ]) W
这个replica set包括一个primary DB和多个secondary DBs。为了数据的一致性,所有的修改(insert / update / deletes) 请求都交给primary处理。处理结束之后,再异步地备份到其他secondary中。/ R% A% [) k5 @0 E
+ S$ ]& c; E5 H! y8 P8 b
Primary DB由replica set中的所有servers,共同选举产生。当这个primaryDB server出错的时候,可以从replica set中重新选举一个新的primaryDB,从而避免了单点故障。
, D4 o3 y G# m6 L4 t: Z
+ R1 y3 ^' _) e6 q& M& O2 ] Replica set的选举策略和数据同步机制,确保了系统的数据的一致性。后文详述。
+ p0 Q: u! }# M* V
) A {4 Q; z k: u; L9 H( cConfig Server j) N3 v9 g, k0 D" D0 l
# T) f h! c! N2 h4 o( Q- F
Config servers用于存储MongoDB集群的元数据 metadata,这些元数据包括如下两个部分,每一个shard server包括哪些chunks,每个chunk存储了哪些 collections 的哪些 documents。' q: R% [" J9 W5 |+ ]1 W/ N/ V
5 ]+ d) O3 {; x! L 每一个config server都包括了MongoDB中所有chunk的信息。2 K: c6 l( h% S; L% p- V9 T% L
) _ z; \2 }/ _
Config server也需要 replication。但是有趣的是,config server 采用了自己独特的replication模式,而没有沿用 replica set。) F; f6 v1 F H3 _+ g& {
- j! G( G; n$ w0 [. d0 m& I
如果任何一台config server挂了,整个 config server 集群中,其它 config server变成只读状态。这样做的原因,是避免在系统不稳定的情况下,冒然对元数据做任何改动,导致在不同的 config servers 中,出现元数据不一致的情况。( K4 X+ Z/ ]4 e
/ W" `; i, N/ \( [ MongoDB的官方文档建议,配置3个config servers比较合适,既提供了足够的安全性,又避免了更多的config servers实例之间的数据同步,引起的元数据不一致的麻烦。$ m7 E; v* V7 [: J7 @4 q; i
7 l# c2 s8 Q8 ^, u& X) ~% Y! r" q
Mongos9 J7 h8 d0 |/ L" x* u0 P0 E
b0 A+ a4 e! F. h
用户使用MongoDB 时,用户的操作请求,全部由mongos来转发。" ?' T+ I( e) e1 G8 m
0 U5 s* g4 R2 K$ q% K 当 mongos 接收到用户请求时,它先查询 config server,找到存放相应数据的shard servers。然后把用户请求,转发到这些 shard servers。当这些 shard servers完成操作后,它们把结果分别返回给 mongos。而当 mongos 汇总了所有的结果后,它把结果返回给用户。
0 a0 T+ q2 V* O$ p
. W1 t3 v; x& |$ u0 W Mongos每次启动的时候,都要到config servers中读取元数据,并缓存在本地。每当 config server中的元数据有改动,它都会通知所有的mongos。
" {$ C/ |. p( H& U$ I3 O3 ]# L3 h/ d+ l5 `
Mongos之间,不存在彼此协同工作的问题。因此,MongoDB所需要配置的mongos server的数量,没有限制。
" @5 g+ M' \, X5 W4 U4 v' k$ n
" M5 v8 d% o8 i3 |- F 通过以上的介绍,我们对每个组成部分都有了基本的了解,但是涉及到工作的细节,我们尚有诸多疑问,例如,一个chunk的数据太大,如何切分?一个shard数据太多,如何迁移?在replica set中,如何选择primary?server挂了,怎么进行故障恢复?接下来的章节,我们逐个回答这些问题。
7 i* k+ @0 D* P8 a3 D& [' S3 T- }! l8 L) K: v# G
+ d t2 \. z; Y: F
Reference,
9 Q0 S! p( Y: ^, T! ^" `; x9 U3 I! i6 m
4 _+ c6 r6 D" a5 @+ p[0] Architectural Overview
3 L6 ^& H8 A- P7 M1 f/ Mhttp://www.mongodb.org/display/DOCS/Sharding+Introduction
8 b$ @5 g- n/ `0 | L+ N# H |
评分
-
查看全部评分
|