|
|
关于MongoDB,我们能看到的资料,基本都是在指导大家如何使用MongoDB,但是,MongoDB内部是如何运作的,资料不是很多。
: @& L' N' i3 o" U5 }# |% s) n# h3 d" H; {) a6 i( ^% I9 A* l3 H
阅读使用手册,会有很多疑惑之处。例如,有人说,MongoDB 等同于分布式的 MySQL。它把一个Table ,按 row,分割成多个Shards,分别存放在不同的 Servers 上。这种说法是否正确?
- O9 r( J1 ]) d3 T0 `) P
& w2 ~) a/ Y) I7 Q0 P; i 不深入了解 MongoDB 的内部结构,就无法透彻地回答类似问题。这个系列文章,就来和大家探讨MongoDB的内部的工作方式。
, z* x, E( b3 d& T' {$ ?$ Z
" D4 U( P4 r8 L4 b% P% \
. J- x- l4 l @2 E2 I1 V
1 @4 e# l+ ^' ^) ]0 i, `* F6 j
图1-1 MongoDB架构图
. \5 H1 Q# { o8 w( I3 {# |
1 ?$ c7 ?1 D8 f- `9 s3 v MongoDB 通常运行在一个服务器集群上,而不是一个单机。图1-1,描述了一个MongoDB集群的基本组成部分,包括若干shards,至少一个config server,至少一个routing servers(又称 mongos)。6 k& e4 l- Q% C8 ~. W B |; ?: \' l
/ a: G' z; D+ h* x. cShards
/ s5 j6 V; G/ i. }; x2 H7 F6 u
MongoDB的最基本的数据单元,叫document,类似于关系式数据库中的行 row。一系列documents,组成了一个collection,相当于关系式数据库中的table。当一个 collection 数据量太大时,可以把该collection按documents切分,分成多个数据块,每个数据块叫做一个chunk,多个chunks聚集在一起,组成了一个shard。
) l$ J' O( G0 `& _0 c6 Z! Z
/ P- |0 e) r$ ]8 Z Sharding 的意义,不仅保障了数据库的扩容(scalability),同时也保障了系统的负载均衡(load balance)。
% q m) w' O/ R; T* D: O1 _$ M3 i( ~4 d- V: x
每一个shard存储在一个物理服务器(server)上。Server上运行着mongod进程,通过这个进程,对shard中的数据进行操作,主要是增删改查。1 `5 n0 \" [0 U& U, @
* n2 \; m: W& @: j 如果系统中的每个shard,只存储了一份数据,没有备份,那么当这个shard所在的server挂了,数据就丢失了。在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。
4 k' n0 M7 V* x; T2 I! u6 L3 S9 t1 h; `- I
Shard keys
* M+ `( x. s) b 1 P! J5 T$ p. n3 o8 ^& n
为了把collection切分成不同的chunks,从而存放到不同的shards中,我们需要制定一个切分的方式。
. X% R# s, l7 J- C% l! K
$ D$ P& g( Z% T& l F! U 如前所述,在 MongoDB 数据库中,一个表collection由多个行 documents 组成,而每个 document,有多个属性 fields。同一个 collection 中的不同的 documents,可能会有不同的 fields。例如,有个 collection 叫 Media,包含两条 documents,+ x* l, R1 G) A- v5 ~6 y! O" K
5 f! W' a" U- m
{
# q9 h- N! J* z f6 R; ` "ISBN": "987-30-3652-5130-82",
5 q# f4 ~/ \, l" g/ E "Type": "CD",
$ A# F: {2 \1 _" p2 ` "Author": "Nirvana",/ N1 j, B2 m$ ~* E
"Title": "Nevermind",
( b6 p- |% O* j2 L8 [ V "Genre": "Grunge",
' S% K. @' @' w; e5 k "Releasedate": "1991.09.24",
% ^6 t9 v4 y( n1 j6 K "Tracklist": [9 n% l$ s- t% Y8 M
{/ ^( m/ e: K8 x0 n8 v
"Track" : "1",
0 f% A. B( I( q5 } O "Title" : "Smells like teen spirit",
. @. G/ W/ k+ s: s4 s "Length" : "5:02"# C7 b! I* y8 \7 C w; ~( p
},
! X0 F/ z( |9 |$ N- {# E0 j {& }6 b0 q$ S7 z+ w6 a- R& C! n
"Track" : "2",
, D( d; X; L, F) X1 c "Title" : "In Bloom",
$ q w; H: q3 q7 ~% T" j) u" E% [4 } "Length" : "4:15"
$ [0 h4 o1 k0 U) s+ \8 A) a1 L+ o }$ Q# w. J. b2 C1 E, F& o
]
- M; b# y' q# d' \9 l% P}3 U8 j& l) b- o+ ?; \7 B1 G
6 [) U% N& O k5 |7 ~4 a
{
/ `' a& M1 W) p "ISBN": "987-1-4302-3051-9",4 f* I! @5 M% p
"Type": "Book",
* R& J* e1 d K& L0 h. O5 V y# v "Title": "Definite Guide to MongoDB: The NoSQL Database",
6 O0 e2 L3 g* k+ e) f7 K# x. F# | "Publisher": "Apress",5 Z2 J" n7 C9 p L
"Author": " Eelco Plugge",
+ R! t6 h% m: a "Releasedate": "2011.06.09"
5 y1 M$ y; t( f2 |3 x}# k0 u$ P* G$ `: ]6 e* M& Y
1 F1 E9 O; c& P 假如,在同一个 collection 中的所有 document,都包含某个共同的 field,例如前例中的“ISBN”,那么我们就可以按照这个 field 的值,来分割 collection。这个 field 的值,又称为 shard key。6 s, Z) Q, Y7 \# @- }& \ ^
! P; k% y: j$ {& O+ i4 |
在选择shard key的时候,一定要确保这个key能够把collection均匀地切分成很多chunks。
; G/ W6 q7 E, t& O* Q! g! _; A( e2 f" }% ], U ^
例如,如果我们选择“author”作为shard key,如果有大量的作者是重名的,那么就会有大量的数据聚集在同一个chunk中。当然,假设很少有作者同名同姓,那么“author”也可以作为一个shard key。换句话说,shard key 的选择,与使用场景密切相关。
8 n' e- }. {& i8 K: [- {7 ]
6 Y7 B* j! D4 A& {$ } 很多情况下,无论选择哪一个单一的 field 作为shard key,都无法均匀分割 collection。在这种情况下,我们可以考虑,用多个 fields,构成一个复合的shard key。
1 l" P2 r4 l: q
7 w$ Y: b8 F: d* {( L" X E 延续前例,假如有很多作者同名同姓,他们都叫“王二”。用 author 作为 shard key,显然无法均匀切割 collection。这时我们可以加上release-date,组成name-date的复合 shard key,例如“王二 2011”。
7 p+ i2 q5 O' w- Y3 J; x$ K% y/ k4 @, i/ }
Chunks
4 S X$ T5 H0 C
9 f( b4 i3 n# N9 ~ MongoDB按 shard key,把 collection切割成若干 chunks。每个 chunk 的数据结构,是一个三元组,{collection,minKey,maxKey},如图1-2 所示。
( X, i* y! A" R5 m# ]! J4 ]6 _) v% J. _( c; g, z
: X: M- U r8 R, _& F% P
图1-2 chunk的三元组
+ l0 t, m: q5 U$ z* ~
. L" _* o# P1 Q' K7 F7 ] 其中,collection 是数据库中某一个表的名称,而 minKey 和 maxKey 是 shard key的范围。每一个 document 的shard key 的值,决定了这条document应该存放在哪个chunk中。
+ W$ \ Q" p' @$ F' ~
3 l8 W4 V8 c$ e3 T 如果两条 documents 的 shard keys 的值很接近,这两条 documents 很可能被存放在同一个 chunk 中。
6 j4 m( o8 T0 I$ g/ I) X; ]4 F! q+ y4 Z" V: `: O$ V f) B
Shard key 的值的顺序,决定了 document 存放的 chunk。在 MongoDB 的文献中,这种切割 collection 的方式,称为order-preserving。
; z+ Q; v8 t5 |3 g3 y: i
# ^/ L7 o7 h8 y& y; p4 M( K/ z 一个 chunk最多能够存储64MB的数据。 当某个chunk存储的 documents包含的数据量,接近这个阈值时,一个chunk会被切分成两个新的chunks。
; g' E' s [! a0 k$ Y0 u ~
4 \ W& @0 H1 l! T. H 当一个shard存储了过多的chunks,这个shard中的某些chunks会被迁移到其它 shard中。
' B9 y2 [5 s# U7 _ y0 a7 t
5 T2 X( f9 h, `8 o! W 这里有个问题,假如某一条 document 包含的数据量很大,超过 64MB,一个 chunk 存放不下,怎么办?在后续章节介绍 GridFS 时,我们会详细讨论。0 |: A8 ~* p/ g9 `; ?8 P
9 T, f1 G( T/ OReplica set$ }" G8 G8 D7 L% J
! g" w7 _, A" g8 O/ _) e
在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。
5 ]7 O( ^9 n( J7 a% E* `
# _3 f I3 K; K% a 这个replica set包括一个primary DB和多个secondary DBs。为了数据的一致性,所有的修改(insert / update / deletes) 请求都交给primary处理。处理结束之后,再异步地备份到其他secondary中。, R3 }5 f$ x$ r* Q) H4 K8 W q7 U
2 m \1 |8 H0 O* D) D( t; W Primary DB由replica set中的所有servers,共同选举产生。当这个primaryDB server出错的时候,可以从replica set中重新选举一个新的primaryDB,从而避免了单点故障。5 h" t" H# R5 A1 K7 `! j8 Z
: P1 q7 |, Y2 p. x5 I: B( _# F4 ~ Replica set的选举策略和数据同步机制,确保了系统的数据的一致性。后文详述。
* y5 @8 g2 m1 O5 e5 D* u1 U+ }2 ~
Config Server
e' K( G/ w9 o& ` p
3 q% f5 Y3 j, @% x/ z+ C( V; r Config servers用于存储MongoDB集群的元数据 metadata,这些元数据包括如下两个部分,每一个shard server包括哪些chunks,每个chunk存储了哪些 collections 的哪些 documents。
5 ~0 j9 W6 E7 C; o1 I; n/ n2 c3 ^ Q9 P0 c3 s/ f# q# a6 G
每一个config server都包括了MongoDB中所有chunk的信息。6 Z* h u" l1 @" m1 _/ B% [3 m
5 `: k7 x9 G( V3 Y
Config server也需要 replication。但是有趣的是,config server 采用了自己独特的replication模式,而没有沿用 replica set。+ D/ e+ E" }' s6 m$ {* G
9 D8 r& U% j: G 如果任何一台config server挂了,整个 config server 集群中,其它 config server变成只读状态。这样做的原因,是避免在系统不稳定的情况下,冒然对元数据做任何改动,导致在不同的 config servers 中,出现元数据不一致的情况。
% _/ B# L6 v/ I; w
3 }8 n0 W; O% D& q/ S MongoDB的官方文档建议,配置3个config servers比较合适,既提供了足够的安全性,又避免了更多的config servers实例之间的数据同步,引起的元数据不一致的麻烦。4 J8 T3 l- k' S2 Q% m2 _
8 G8 t* I& w& A- ~" i, w
Mongos$ ~3 K( ~! j$ c5 q7 r
6 `7 a# o& T$ o6 e
用户使用MongoDB 时,用户的操作请求,全部由mongos来转发。
k+ w, B* ?& n. a" ?8 N
1 N, o0 p$ v v0 v& d 当 mongos 接收到用户请求时,它先查询 config server,找到存放相应数据的shard servers。然后把用户请求,转发到这些 shard servers。当这些 shard servers完成操作后,它们把结果分别返回给 mongos。而当 mongos 汇总了所有的结果后,它把结果返回给用户。1 o4 x# ^7 p9 ]2 ]+ ^& O' q
( x) c4 t* H3 o7 X# C3 }2 d Mongos每次启动的时候,都要到config servers中读取元数据,并缓存在本地。每当 config server中的元数据有改动,它都会通知所有的mongos。8 v e! ]8 T; T3 _0 ?* {
$ b/ r4 Z8 n8 j3 h1 G1 i Mongos之间,不存在彼此协同工作的问题。因此,MongoDB所需要配置的mongos server的数量,没有限制。: ?0 W2 C5 d2 e% C# c4 K$ \8 X
0 {6 _# r/ F2 t5 z, z
通过以上的介绍,我们对每个组成部分都有了基本的了解,但是涉及到工作的细节,我们尚有诸多疑问,例如,一个chunk的数据太大,如何切分?一个shard数据太多,如何迁移?在replica set中,如何选择primary?server挂了,怎么进行故障恢复?接下来的章节,我们逐个回答这些问题。
3 M1 \# u& Y( L0 E
! {% Z* N" I# t- b$ d- X- H
2 S- A( o4 K G$ ]; F; E4 W- W, qReference,
3 G( N: q- W& d4 g9 N# v4 v. ~4 i: u) @5 q
[0] Architectural Overview
4 `. l) N% \0 P/ Lhttp://www.mongodb.org/display/DOCS/Sharding+Introduction
6 V8 Y7 L& Y3 p7 M |
评分
-
查看全部评分
|