|
关于MongoDB,我们能看到的资料,基本都是在指导大家如何使用MongoDB,但是,MongoDB内部是如何运作的,资料不是很多。1 ?+ V# n7 K7 \' X
. L" }9 ]7 q& M7 b6 Y+ R
阅读使用手册,会有很多疑惑之处。例如,有人说,MongoDB 等同于分布式的 MySQL。它把一个Table ,按 row,分割成多个Shards,分别存放在不同的 Servers 上。这种说法是否正确?
0 s/ s2 U# Y0 V7 ^7 v( O- t, W; ~4 ?7 M: l$ C
不深入了解 MongoDB 的内部结构,就无法透彻地回答类似问题。这个系列文章,就来和大家探讨MongoDB的内部的工作方式。
. V" Z& L. Z' b5 S3 j# d- |7 v
0 [" z2 `2 X4 o0 o
& W0 S6 e+ R/ _: ~6 _! B, w" ~ i6 T$ F) Q( Q7 M3 F( k* @; G
图1-1 MongoDB架构图
, ]3 d& m+ T" u( J$ A
" o* i" p% L" |6 O0 p6 [# Y1 @" G MongoDB 通常运行在一个服务器集群上,而不是一个单机。图1-1,描述了一个MongoDB集群的基本组成部分,包括若干shards,至少一个config server,至少一个routing servers(又称 mongos)。. |1 i, i. S5 t+ |3 G
0 w7 T1 D- v" b# JShards) I7 b, f% [) J$ m7 H
9 n* |$ w3 A1 o9 ` MongoDB的最基本的数据单元,叫document,类似于关系式数据库中的行 row。一系列documents,组成了一个collection,相当于关系式数据库中的table。当一个 collection 数据量太大时,可以把该collection按documents切分,分成多个数据块,每个数据块叫做一个chunk,多个chunks聚集在一起,组成了一个shard。
. V/ |2 T7 ?# U3 A
; l3 ]. o; j3 g9 t6 d" V* { Sharding 的意义,不仅保障了数据库的扩容(scalability),同时也保障了系统的负载均衡(load balance)。
L3 o: t* N# \# n9 F4 i" M2 g' J3 Z, e
每一个shard存储在一个物理服务器(server)上。Server上运行着mongod进程,通过这个进程,对shard中的数据进行操作,主要是增删改查。
8 ]" j4 v' |8 f7 @0 b
+ M% c* e7 }3 l# S, ? 如果系统中的每个shard,只存储了一份数据,没有备份,那么当这个shard所在的server挂了,数据就丢失了。在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。1 b' s' c0 e5 M. k' I8 d2 V
# t) U. t- z) _Shard keys
; b& \$ J; O$ u, _- k
( `* c9 o4 I* E$ U 为了把collection切分成不同的chunks,从而存放到不同的shards中,我们需要制定一个切分的方式。4 \ Y2 {- Q. \& I
/ X& C* F( x) f$ D6 s 如前所述,在 MongoDB 数据库中,一个表collection由多个行 documents 组成,而每个 document,有多个属性 fields。同一个 collection 中的不同的 documents,可能会有不同的 fields。例如,有个 collection 叫 Media,包含两条 documents,! _, z- s9 z' @
. Y+ A' D5 P4 {- x{/ Q# E1 \+ p0 O- m
"ISBN": "987-30-3652-5130-82",
# u6 _& f5 Z5 i "Type": "CD",' J. n4 ^7 B y5 p' n2 e- t
"Author": "Nirvana",
6 ]& Q' v9 b& z0 Q$ `$ x "Title": "Nevermind",! s8 h6 ?9 s$ d. m& n6 A
"Genre": "Grunge",3 ?% v4 a5 s0 t! X0 r5 T
"Releasedate": "1991.09.24", b! v, o* l/ m, p& e
"Tracklist": [& i! P- x* t( C7 W+ K- b
{
+ V6 X) _/ D0 Q1 F4 o "Track" : "1",
( Q2 t4 r, @$ P* A "Title" : "Smells like teen spirit",; q- U& ?( X" H, K9 O1 T) j' u
"Length" : "5:02"
+ v2 e' x7 e. @6 V% L8 K6 E* Z },
# Y, y0 Q3 N+ }0 ^ {
- A5 E' Z/ i. `9 j, x "Track" : "2",
. Q& c& C; E3 Y$ Z" ?, Y! e "Title" : "In Bloom",. f) W6 S: r8 V6 o) T* H
"Length" : "4:15"
0 E) u. D" o2 Z: ~& S- r }
# w; i' q) @/ x6 B; p- }/ ` ]% v/ L5 J3 X$ O) E
}+ _& q: ~( q$ h
2 B' n' _* l8 i: k- [ L
{3 f" z3 x2 Y4 {- B
"ISBN": "987-1-4302-3051-9",0 z7 \$ g; Z2 `% G0 b3 z
"Type": "Book",
: ~2 X2 |! s+ a" h5 W2 T "Title": "Definite Guide to MongoDB: The NoSQL Database",
* j( [: V; h6 Q "Publisher": "Apress",3 M4 h' J3 X* R1 P3 v
"Author": " Eelco Plugge",
' _' N3 l$ b" T/ m "Releasedate": "2011.06.09"( l* G$ s2 {* y) O0 u
}
. I5 Q6 H* V1 x3 D* X n# T9 M, ~2 O: I N. F9 E# P
假如,在同一个 collection 中的所有 document,都包含某个共同的 field,例如前例中的“ISBN”,那么我们就可以按照这个 field 的值,来分割 collection。这个 field 的值,又称为 shard key。
* x# i, ]# F5 X) I* r6 S/ g P7 p7 f% C$ ]- ^, T. Q
在选择shard key的时候,一定要确保这个key能够把collection均匀地切分成很多chunks。
& `* p2 ^7 Q+ k, f$ w! h, F# e7 E6 U* R; F- O' U
例如,如果我们选择“author”作为shard key,如果有大量的作者是重名的,那么就会有大量的数据聚集在同一个chunk中。当然,假设很少有作者同名同姓,那么“author”也可以作为一个shard key。换句话说,shard key 的选择,与使用场景密切相关。2 W) R% \) U: U! t2 l3 S4 i
+ N$ k; b, |0 P$ l$ l
很多情况下,无论选择哪一个单一的 field 作为shard key,都无法均匀分割 collection。在这种情况下,我们可以考虑,用多个 fields,构成一个复合的shard key。
, z3 k4 u, E9 N9 Z2 ]8 Z# K$ @9 f* M: t6 I# B
延续前例,假如有很多作者同名同姓,他们都叫“王二”。用 author 作为 shard key,显然无法均匀切割 collection。这时我们可以加上release-date,组成name-date的复合 shard key,例如“王二 2011”。0 u) Y% [* q& G- N. b! F/ g4 o$ B
7 ^+ E+ S$ d! I+ w! L
Chunks$ y" ]6 g# ^" Q
3 H) [( I. d1 O, y0 X) A MongoDB按 shard key,把 collection切割成若干 chunks。每个 chunk 的数据结构,是一个三元组,{collection,minKey,maxKey},如图1-2 所示。" c( j" O. w- o
' K5 b6 r* R5 P2 ]! n3 ~
# H: T. A8 @. v$ \7 p- ~2 a/ Y图1-2 chunk的三元组
6 [5 D/ `6 [) q" i/ w" d
, m2 d; Y4 }* O: l Q/ S 其中,collection 是数据库中某一个表的名称,而 minKey 和 maxKey 是 shard key的范围。每一个 document 的shard key 的值,决定了这条document应该存放在哪个chunk中。
9 `3 U8 k# W5 Y* X T3 b; s5 w& q
6 x% {- d$ o7 U 如果两条 documents 的 shard keys 的值很接近,这两条 documents 很可能被存放在同一个 chunk 中。9 }( B, ? [, ]! R& k+ N" O0 Y
5 j' i# b: p9 Q6 X/ z0 C7 c
Shard key 的值的顺序,决定了 document 存放的 chunk。在 MongoDB 的文献中,这种切割 collection 的方式,称为order-preserving。" j$ d+ W" O! T& U* O; B; C
: A0 N3 c& J% i0 A 一个 chunk最多能够存储64MB的数据。 当某个chunk存储的 documents包含的数据量,接近这个阈值时,一个chunk会被切分成两个新的chunks。( w3 F& N `) W8 B/ J! x( Q
/ |9 h: O' O9 z% H9 X
当一个shard存储了过多的chunks,这个shard中的某些chunks会被迁移到其它 shard中。
5 e' B X8 Q# }9 X* |2 {: ^$ e+ i- g/ s2 Z
这里有个问题,假如某一条 document 包含的数据量很大,超过 64MB,一个 chunk 存放不下,怎么办?在后续章节介绍 GridFS 时,我们会详细讨论。8 ~3 x: N1 Z; ]
! x/ U" P1 G$ U3 w; dReplica set
Y" e) ?9 G7 L) e
" K( f1 H7 Z' b! T1 L! z; t) T* R 在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。( t- ?/ s! Z! O+ F4 R5 j
, |! R/ X) ?! q) S2 ^$ L, H 这个replica set包括一个primary DB和多个secondary DBs。为了数据的一致性,所有的修改(insert / update / deletes) 请求都交给primary处理。处理结束之后,再异步地备份到其他secondary中。
2 z! C: n' R) H% H$ X9 Q
7 q `6 {" K% X- P C Primary DB由replica set中的所有servers,共同选举产生。当这个primaryDB server出错的时候,可以从replica set中重新选举一个新的primaryDB,从而避免了单点故障。0 v- R- s2 O$ S8 r! W- k5 Y) {* X
3 Z- U4 k( y) ^$ e- }" Q
Replica set的选举策略和数据同步机制,确保了系统的数据的一致性。后文详述。
8 g- F8 E- C2 z" D1 ]. s5 ^7 s
* b# S/ F2 e4 v4 J5 p# iConfig Server" J" V0 f2 B- n7 n
$ }! s2 \6 S8 b* d2 `' K Config servers用于存储MongoDB集群的元数据 metadata,这些元数据包括如下两个部分,每一个shard server包括哪些chunks,每个chunk存储了哪些 collections 的哪些 documents。+ f5 u0 \- `- Q
: A; S( r1 |8 |
每一个config server都包括了MongoDB中所有chunk的信息。5 H+ T& Q! w7 {
& b' l2 r n0 s Config server也需要 replication。但是有趣的是,config server 采用了自己独特的replication模式,而没有沿用 replica set。
: `- ]* ^, _. G& y' ]* h; |, l' N3 A& B* b$ `& o" o9 _' }
如果任何一台config server挂了,整个 config server 集群中,其它 config server变成只读状态。这样做的原因,是避免在系统不稳定的情况下,冒然对元数据做任何改动,导致在不同的 config servers 中,出现元数据不一致的情况。
: M3 w& B0 y3 ^ W+ B, C7 c( h0 R* w$ R* B
MongoDB的官方文档建议,配置3个config servers比较合适,既提供了足够的安全性,又避免了更多的config servers实例之间的数据同步,引起的元数据不一致的麻烦。
- ^ k; d' C' C3 [- |- b( G$ {
Mongos8 _' Q& ~2 I6 p" O# e7 a
) E5 {6 \3 c8 s& g 用户使用MongoDB 时,用户的操作请求,全部由mongos来转发。% |7 Q6 V: D/ Q x$ W9 f
: M3 b! |. G' x+ E Y0 ~
当 mongos 接收到用户请求时,它先查询 config server,找到存放相应数据的shard servers。然后把用户请求,转发到这些 shard servers。当这些 shard servers完成操作后,它们把结果分别返回给 mongos。而当 mongos 汇总了所有的结果后,它把结果返回给用户。4 s& \! |' _+ y% d7 |( p
+ N/ {- _8 R& Q: o) a1 b, ?5 }
Mongos每次启动的时候,都要到config servers中读取元数据,并缓存在本地。每当 config server中的元数据有改动,它都会通知所有的mongos。. B( A, ]1 X2 a5 y: P3 m
5 Z* P$ Z y# n( f Mongos之间,不存在彼此协同工作的问题。因此,MongoDB所需要配置的mongos server的数量,没有限制。
v. U+ r6 J; Y6 Z2 X% V0 U. r& Z% G. n
通过以上的介绍,我们对每个组成部分都有了基本的了解,但是涉及到工作的细节,我们尚有诸多疑问,例如,一个chunk的数据太大,如何切分?一个shard数据太多,如何迁移?在replica set中,如何选择primary?server挂了,怎么进行故障恢复?接下来的章节,我们逐个回答这些问题。
' \) ~4 N5 z% T8 ^. c* N. p# s6 G8 h5 b0 g6 ^! K
1 a, S5 S# ^. CReference,
* v/ H0 Y J3 d$ p' ?. X- ?, ~* v' m0 G4 x% @" L9 a0 r2 f7 y; p
[0] Architectural Overview
) ?3 b* d3 q7 F. | ~http://www.mongodb.org/display/DOCS/Sharding+Introduction
% d$ ^# }- A6 l) R M |
评分
-
查看全部评分
|