|
|
关于MongoDB，我们能看到的资料，基本都是在指导大家如何使用MongoDB，但是，MongoDB内部是如何运作的，资料不是很多。
$ I, m# Y' C# \: t$ Z) p2 _ M
阅读使用手册，会有很多疑惑之处。例如，有人说，MongoDB 等同于分布式的 MySQL。它把一个Table ，按 row，分割成多个Shards，分别存放在不同的 Servers 上。这种说法是否正确？- G; S7 y8 Z( W, L8 c8 m( x1 y
% i7 P1 C0 k" {5 E$ O2 d 不深入了解 MongoDB 的内部结构，就无法透彻地回答类似问题。这个系列文章，就来和大家探讨MongoDB的内部的工作方式。
8 W. X: p' O: W# C8 G
5 r/ E u( @. m! j, D
% C, m* `8 p/ w% C/ e) O% ?- |
4 i! ?' s# H0 h, t; n5 p" Y0 s% N图1-1 MongoDB架构图 / k! P+ Z9 }& S0 f# J. Z
) }+ f6 B% |0 F9 o6 j: y8 J( P# `6 A% O MongoDB 通常运行在一个服务器集群上，而不是一个单机。图1-1，描述了一个MongoDB集群的基本组成部分，包括若干shards，至少一个config server，至少一个routing servers（又称 mongos）。) R0 R1 j% `* { z9 Z! h
* H# `4 D J1 G0 | t& {
Shards
( V! U4 `0 j# g g5 U; k; b
. d: v( e# ^. ^; h' Z+ t. e MongoDB的最基本的数据单元，叫document，类似于关系式数据库中的行 row。一系列documents，组成了一个collection，相当于关系式数据库中的table。当一个 collection 数据量太大时，可以把该collection按documents切分，分成多个数据块，每个数据块叫做一个chunk，多个chunks聚集在一起，组成了一个shard。6 \& e' b4 `7 f
2 @4 g0 f& r9 w, D- j8 U' i Sharding 的意义，不仅保障了数据库的扩容（scalability），同时也保障了系统的负载均衡（load balance）。
( z7 {% i3 O6 X- [. L
2 Y @5 ] K5 d# t8 d2 k+ d 每一个shard存储在一个物理服务器（server）上。Server上运行着mongod进程，通过这个进程，对shard中的数据进行操作，主要是增删改查。
+ X+ u4 W* \1 h t1 Q1 T0 r! x; u/ O* M- T2 b) z$ b8 W" V* ]
如果系统中的每个shard，只存储了一份数据，没有备份，那么当这个shard所在的server挂了，数据就丢失了。在生产环境中，为了保证数据不丢失，为了提高系统的可用性（availability），每一个shard被存储多份，每个备份所在的servers，组成了一个replica set。
2 `" w3 K6 U5 P% w4 O1 W- b' f/ N6 [5 T8 j2 a1 j! }
Shard keys9 s8 O* _! P( w" E5 e1 D
/ r* ^. b i' t# H: i
为了把collection切分成不同的chunks，从而存放到不同的shards中，我们需要制定一个切分的方式。
% w7 q1 i. J4 ^- F' Y. U' M9 f" q3 O. L. m# D3 J ^& Q& X
如前所述，在 MongoDB 数据库中，一个表collection由多个行 documents 组成，而每个 document，有多个属性 fields。同一个 collection 中的不同的 documents，可能会有不同的 fields。例如，有个 collection 叫 Media，包含两条 documents，
! V4 W* _( H0 b# B. H* A6 ?
% m$ I! b2 ~7 [1 _; r{
5 P& U+ Q$ ~" R "ISBN": "987-30-3652-5130-82",+ D. R/ k! w% Q6 v. `* A" U# N8 n
"Type": "CD",
# F' _* ]; Y- ?$ {" \4 F' H0 y8 C "Author": "Nirvana",
# `) W' b& p/ I. o& t* X1 j "Title": "Nevermind",% ?9 D, z0 V* C( M) V% X
"Genre": "Grunge",
. P) x R( s, \ "Releasedate": "1991.09.24",
6 l3 u' V; k" M% y2 D5 r! i "Tracklist": [: m6 L7 D4 |" ~8 z! S( P
{7 u. x# r' n$ V* q* Z
"Track" : "1",
# I( M: A6 W N, G& t9 _4 T3 Q "Title" : "Smells like teen spirit",
7 n. m, r' Y R/ r0 s "Length" : "5:02"( P# _: X7 S" a4 o4 N& A
},2 N- r% r: y8 y+ Y" O3 o
{
6 s/ C) w s* }3 J2 H# i& T "Track" : "2",# w! A: j. k+ J1 U. p. D( ]
"Title" : "In Bloom",1 c! A% n3 W3 @) F% y
"Length" : "4:15"8 d( @" W8 L+ N8 Y% y' G0 T. U
}
& S+ K F! I8 h$ K ]
0 Q* L0 x: K2 c, P$ g}
, c* Q/ ^0 T+ j) w3 P) U+ A( S! I9 d* p! [, q, U w& ^
{
* l4 g1 F V& t: T# O9 ]+ B/ q) y "ISBN": "987-1-4302-3051-9",- G6 W6 _+ J' L
"Type": "Book",& W2 K, e2 t6 A& C
"Title": "Definite Guide to MongoDB: The NoSQL Database",
; w! D {7 _9 f) y6 e "Publisher": "Apress",
% v* P! O" Y9 h- B4 k& ? "Author": " Eelco Plugge",8 X! ]# v" ]. H2 z/ E: K/ R! j
"Releasedate": "2011.06.09"
G* C2 J& Z+ Q% r9 w}! _9 _5 R* @! c' S- v' p
7 U5 L" t8 s' m9 n/ D 假如，在同一个 collection 中的所有 document，都包含某个共同的 field，例如前例中的“ISBN”，那么我们就可以按照这个 field 的值，来分割 collection。这个 field 的值，又称为 shard key。
6 k2 A; H! e: _0 l
$ z/ O; O$ {( ~$ @8 H0 H 在选择shard key的时候，一定要确保这个key能够把collection均匀地切分成很多chunks。 w9 @0 ]$ Q# J$ I/ I/ D; d
4 C2 S. n/ _" h8 {% O: i 例如，如果我们选择“author”作为shard key，如果有大量的作者是重名的，那么就会有大量的数据聚集在同一个chunk中。当然，假设很少有作者同名同姓，那么“author”也可以作为一个shard key。换句话说，shard key 的选择，与使用场景密切相关。; }3 J1 ~* h. n3 y0 m8 X
' S. T) `: x. M5 \5 E% n. n
很多情况下，无论选择哪一个单一的 field 作为shard key，都无法均匀分割 collection。在这种情况下，我们可以考虑，用多个 fields，构成一个复合的shard key。' l$ S0 @3 `% R, L% q- y, K
" \7 @* E* O0 k9 b' I; R6 h, H
延续前例，假如有很多作者同名同姓，他们都叫“王二”。用 author 作为 shard key，显然无法均匀切割 collection。这时我们可以加上release-date，组成name-date的复合 shard key，例如“王二 2011”。
; q4 R8 x2 A2 V4 a8 ~+ }2 E
9 p" J) P4 k* s1 T0 { s- r8 ^+ NChunks' Y4 U+ f& s; U. n, U
) r( O1 E, |$ a& V- H8 c7 ` MongoDB按 shard key，把 collection切割成若干 chunks。每个 chunk 的数据结构，是一个三元组，{collection，minKey，maxKey}，如图1-2 所示。( k& {9 U( s& j. A' U* k
7 N/ X; `" N" A/ c% G6 f- U. Z
3 f+ ^% ?% H0 e+ N: h# i! H* S* _! p
图1-2 chunk的三元组
8 `/ t7 P* Z4 J6 y# }6 T
3 G. v5 J/ i9 X7 x7 z 其中，collection 是数据库中某一个表的名称，而 minKey 和 maxKey 是 shard key的范围。每一个 document 的shard key 的值，决定了这条document应该存放在哪个chunk中。3 x$ C7 }* O3 c7 L* t
' p3 O) n% K6 o1 n
如果两条 documents 的 shard keys 的值很接近，这两条 documents 很可能被存放在同一个 chunk 中。
) k Q: U0 `: l0 K9 g! k0 u/ f% R( U0 j/ m) r% i6 n: H8 a1 `
Shard key 的值的顺序，决定了 document 存放的 chunk。在 MongoDB 的文献中，这种切割 collection 的方式，称为order-preserving。
% R" `: q% i0 S. N6 `+ b
& J8 D/ c4 i" U/ ?, r' L 一个 chunk最多能够存储64MB的数据。 当某个chunk存储的 documents包含的数据量，接近这个阈值时，一个chunk会被切分成两个新的chunks。
# c- B: V0 g9 f( @# z8 j: u4 J% x
: W# L0 w L2 y 当一个shard存储了过多的chunks，这个shard中的某些chunks会被迁移到其它 shard中。4 h, {2 f1 i$ t! O* E M" u9 f
( `4 C4 t# c: q6 V( l4 r1 T
这里有个问题，假如某一条 document 包含的数据量很大，超过 64MB，一个 chunk 存放不下，怎么办？在后续章节介绍 GridFS 时，我们会详细讨论。% t+ }7 u6 a6 t$ T
' Y$ }9 y, }' n+ n1 jReplica set
. ^% b0 X! p3 \4 W" W0 ^/ I
. O8 S8 P( a$ B' N4 C 在生产环境中，为了保证数据不丢失，为了提高系统的可用性（availability），每一个shard被存储多份，每个备份所在的servers，组成了一个replica set。( ^$ g( A) E$ `! `- y5 A
2 |) \1 ~ Z& o7 D r 这个replica set包括一个primary DB和多个secondary DBs。为了数据的一致性，所有的修改(insert / update / deletes) 请求都交给primary处理。处理结束之后，再异步地备份到其他secondary中。. D2 v/ {+ e2 w! V2 t, v0 {1 w
4 O+ B# \4 o t0 M: m7 m0 G8 \ Primary DB由replica set中的所有servers，共同选举产生。当这个primaryDB server出错的时候，可以从replica set中重新选举一个新的primaryDB，从而避免了单点故障。$ x% S- J0 b" a/ S7 E) z: N
; v7 f+ K, ^' l* l5 e( q( m
Replica set的选举策略和数据同步机制，确保了系统的数据的一致性。后文详述。, ?* Z% N) M+ h2 Z$ y$ R8 @" l1 N7 |
4 `( [6 L. y+ u7 S" h. |4 Q6 lConfig Server- u8 D6 _1 `, ~) o- G* S& a
. v& F# a, H1 I0 H- O S# W
Config servers用于存储MongoDB集群的元数据 metadata，这些元数据包括如下两个部分，每一个shard server包括哪些chunks，每个chunk存储了哪些 collections 的哪些 documents。
2 r$ {0 ^: O6 [. p9 P8 g7 E0 Y4 L" m7 {8 D' @) |3 a
每一个config server都包括了MongoDB中所有chunk的信息。
) t8 s$ q# t, g' q
) v5 @, N$ k+ A. H' H* P1 P" {* H Config server也需要 replication。但是有趣的是，config server 采用了自己独特的replication模式，而没有沿用 replica set。; X' {: s- ^* x* z# U
' t0 T6 t" ?/ |: ?* m
如果任何一台config server挂了，整个 config server 集群中，其它 config server变成只读状态。这样做的原因，是避免在系统不稳定的情况下，冒然对元数据做任何改动，导致在不同的 config servers 中，出现元数据不一致的情况。
1 }3 I# {4 }4 D+ u" J/ N2 B$ h- \' g9 F5 S5 T; @
MongoDB的官方文档建议，配置3个config servers比较合适，既提供了足够的安全性，又避免了更多的config servers实例之间的数据同步，引起的元数据不一致的麻烦。
# V. K8 H2 Y2 x# t w. G& z
; {4 H; l! b( q; t/ \Mongos
0 N6 ^ f" ~# G' f6 v7 H: h) U- d8 |
用户使用MongoDB 时，用户的操作请求，全部由mongos来转发。
+ W. X* e7 E& s; W2 Q4 M
. J7 N0 a+ `4 h9 v0 |/ J! V 当 mongos 接收到用户请求时，它先查询 config server，找到存放相应数据的shard servers。然后把用户请求，转发到这些 shard servers。当这些 shard servers完成操作后，它们把结果分别返回给 mongos。而当 mongos 汇总了所有的结果后，它把结果返回给用户。, [1 d: L- ]0 P: O1 Z' E) j
/ e& K) D; T P Mongos每次启动的时候，都要到config servers中读取元数据，并缓存在本地。每当 config server中的元数据有改动，它都会通知所有的mongos。6 Z% \& ]; v" j! X' G) I
+ B+ A, z; c$ a Mongos之间，不存在彼此协同工作的问题。因此，MongoDB所需要配置的mongos server的数量，没有限制。
4 G7 @$ v6 K' ^3 O! c9 g
$ q9 d+ f4 R3 s, [# l 通过以上的介绍，我们对每个组成部分都有了基本的了解，但是涉及到工作的细节，我们尚有诸多疑问，例如，一个chunk的数据太大，如何切分？一个shard数据太多，如何迁移？在replica set中，如何选择primary？server挂了，怎么进行故障恢复？接下来的章节，我们逐个回答这些问题。
, D ^* ?% k3 @' i% z+ @
8 q' R9 w- x$ C3 m2 f
4 i2 Y! P+ P3 T8 M6 O& z" KReference，
4 _3 w8 H3 B- `4 |7 W; e) p- V5 o/ l6 P; t
[0] Architectural Overview
6 N( g3 n1 s7 K# j% Qhttp://www.mongodb.org/display/DOCS/Sharding+Introduction
; U2 y1 Q' I" P. F- O% c' h! ^2 j: | |
评分
-
查看全部评分
|
雷达卡
发表于 2012-9-18 12:31:10
收藏
分享
淘帖
支持
反对
提升卡
置顶卡
沉默卡
喧嚣卡
变色卡
抢沙发
千斤顶
显身卡
楼主
已经给你变成正式会员了。
: f. Q. _. b1 x4 i