|
|
关于MongoDB,我们能看到的资料,基本都是在指导大家如何使用MongoDB,但是,MongoDB内部是如何运作的,资料不是很多。7 a4 h6 R/ n* m% A# ^7 r
) {* A2 m7 m/ U- u
阅读使用手册,会有很多疑惑之处。例如,有人说,MongoDB 等同于分布式的 MySQL。它把一个Table ,按 row,分割成多个Shards,分别存放在不同的 Servers 上。这种说法是否正确?
; ^/ h. F8 V* p. |- f' v
4 q6 E2 P* X9 i3 K; b" g' E 不深入了解 MongoDB 的内部结构,就无法透彻地回答类似问题。这个系列文章,就来和大家探讨MongoDB的内部的工作方式。
+ ~: H% S8 I) \' N9 C8 ~
# d2 ?& O, `) O3 \) F5 m6 v3 |
( f; w- L6 B0 o& d& B
& X+ ~; ?" m& @/ E* D/ J
图1-1 MongoDB架构图 Q2 e% a2 \. w8 I1 g! U; T
3 z& v- [9 U' |4 O0 N
MongoDB 通常运行在一个服务器集群上,而不是一个单机。图1-1,描述了一个MongoDB集群的基本组成部分,包括若干shards,至少一个config server,至少一个routing servers(又称 mongos)。0 g( z8 G: M8 P3 i
1 a3 r% T4 n; o' i7 b" B+ M% I# _
Shards
; B/ J2 L" p( a% U) X$ Y4 T+ p# q+ |" P r; e( N* ^; w
MongoDB的最基本的数据单元,叫document,类似于关系式数据库中的行 row。一系列documents,组成了一个collection,相当于关系式数据库中的table。当一个 collection 数据量太大时,可以把该collection按documents切分,分成多个数据块,每个数据块叫做一个chunk,多个chunks聚集在一起,组成了一个shard。
C2 C, a7 e9 r5 C. ^+ h1 j
" s8 G; q: ]4 L) R* r! ^5 ^$ @* H Sharding 的意义,不仅保障了数据库的扩容(scalability),同时也保障了系统的负载均衡(load balance)。
* W4 Y5 R: p% ~3 n7 I7 |# R
1 _7 n8 P6 ]5 i* n: M 每一个shard存储在一个物理服务器(server)上。Server上运行着mongod进程,通过这个进程,对shard中的数据进行操作,主要是增删改查。. x: \$ u7 t+ z, K4 L
$ W$ e- m' ~. g7 g5 P! H: Z! }8 u; [, ~ 如果系统中的每个shard,只存储了一份数据,没有备份,那么当这个shard所在的server挂了,数据就丢失了。在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。' M2 X- i& S! O* j" u8 D v
: C* w$ Q- d1 ^
Shard keys
) P ~" \6 m6 \& |$ S, O& k7 D2 ?
+ t$ [4 I F1 f' U" j 为了把collection切分成不同的chunks,从而存放到不同的shards中,我们需要制定一个切分的方式。; \% B, h- |( E) F- @) E
! M* ^3 A( `: o& l4 ~4 l+ ? 如前所述,在 MongoDB 数据库中,一个表collection由多个行 documents 组成,而每个 document,有多个属性 fields。同一个 collection 中的不同的 documents,可能会有不同的 fields。例如,有个 collection 叫 Media,包含两条 documents,4 s! V+ w9 q" u! C0 J( ] c0 B$ ~
8 F* h" J/ P' L8 }% L
{
% n* e2 v- Q: i- n/ E( { "ISBN": "987-30-3652-5130-82",0 ], J8 K2 F+ p3 E5 e; h5 m
"Type": "CD",
B$ G; s% ?+ `& E* k* e "Author": "Nirvana",
* {% m+ u f% e# ]9 p- S5 L! T9 E "Title": "Nevermind",; e( f, h# q5 [+ `. f
"Genre": "Grunge",
! w3 ^3 n# w W& z "Releasedate": "1991.09.24",, ?8 u* P `0 t
"Tracklist": [( e( @) s8 \" f6 i6 H
{8 D4 S. O! U( L4 d4 M7 q' ^! A
"Track" : "1",
& O1 [0 {1 ?3 J+ |! w# \: _; i6 r* ^ "Title" : "Smells like teen spirit",
7 Q4 u. |3 a( ]+ _& ~- R "Length" : "5:02"
. N Z$ I+ J5 y/ f/ U },3 Q2 U& I: J( g7 z9 Q. x/ z, t
{
2 H: a- P$ A* O4 \: p- k) Q "Track" : "2",
9 j. S/ ~" D; j7 _7 j/ [. t$ n "Title" : "In Bloom",5 k, w I9 D4 v& O; U# v/ X
"Length" : "4:15"6 q+ Z( ?( {! E( w& r
}, K; ?8 S. n" f
]
% Q; {9 d! g( K5 f+ g; K}: }1 `7 ]" d7 ?% c4 q
; o M' e5 B, v0 D& }
{4 \4 k; H+ o0 t6 L
"ISBN": "987-1-4302-3051-9",1 L, P8 E9 b$ h1 }$ `) Q
"Type": "Book",
+ I+ _; {0 L k- f; n. c6 Y( u' d "Title": "Definite Guide to MongoDB: The NoSQL Database",
2 Z5 _; k5 `5 Z% z "Publisher": "Apress",4 L7 ]5 b1 y' c; n
"Author": " Eelco Plugge",
0 I* |- f* V1 q3 s. c T; z "Releasedate": "2011.06.09"
( s3 K+ I8 R2 ]2 z- B: r; p+ g+ o}
. O* e/ D7 S" D. o. Z8 E0 r# o" [8 p6 h2 V
假如,在同一个 collection 中的所有 document,都包含某个共同的 field,例如前例中的“ISBN”,那么我们就可以按照这个 field 的值,来分割 collection。这个 field 的值,又称为 shard key。; Z* D1 O+ |0 V/ ]5 [. @1 q0 j1 w9 F
6 E! j* i# O% e2 y. k+ ? 在选择shard key的时候,一定要确保这个key能够把collection均匀地切分成很多chunks。6 B4 t( k9 f0 C f- X& K
6 k9 \3 h7 D/ y# d# _0 X
例如,如果我们选择“author”作为shard key,如果有大量的作者是重名的,那么就会有大量的数据聚集在同一个chunk中。当然,假设很少有作者同名同姓,那么“author”也可以作为一个shard key。换句话说,shard key 的选择,与使用场景密切相关。
/ E) l% P' @1 `+ w1 ~! h" L
4 ?! v) ]( I1 s. Y/ L 很多情况下,无论选择哪一个单一的 field 作为shard key,都无法均匀分割 collection。在这种情况下,我们可以考虑,用多个 fields,构成一个复合的shard key。1 d0 K% t( B3 W4 d) a
2 C; x: M1 l% Y. \6 S& d, l# A6 Y2 r
延续前例,假如有很多作者同名同姓,他们都叫“王二”。用 author 作为 shard key,显然无法均匀切割 collection。这时我们可以加上release-date,组成name-date的复合 shard key,例如“王二 2011”。
' \/ u: D- D& S4 o/ q( a" G- s( q/ \! A `) b7 O# Y1 }8 G
Chunks
) c+ l% ]8 Y- s" f& ?, M" X4 d
+ x2 J# i& e+ q6 m& q6 `4 r MongoDB按 shard key,把 collection切割成若干 chunks。每个 chunk 的数据结构,是一个三元组,{collection,minKey,maxKey},如图1-2 所示。5 Q3 |$ u5 `' o
* m3 `! O( q7 H
! A! j& G' M7 S/ m2 L( o( ?图1-2 chunk的三元组 & c) e V$ F5 }! @/ L
4 F1 ]: l# J( h W/ I 其中,collection 是数据库中某一个表的名称,而 minKey 和 maxKey 是 shard key的范围。每一个 document 的shard key 的值,决定了这条document应该存放在哪个chunk中。
; N$ S3 D6 j" a) h: k9 f
+ F7 f% R- G8 Q" Q- u4 E0 M$ b1 U% \ 如果两条 documents 的 shard keys 的值很接近,这两条 documents 很可能被存放在同一个 chunk 中。& C* ^0 P8 \6 o) T* x
# d: ?( X* G9 |( F5 V+ c% K6 w Shard key 的值的顺序,决定了 document 存放的 chunk。在 MongoDB 的文献中,这种切割 collection 的方式,称为order-preserving。
& K- `6 x3 `- R R& w( d, W) @! U: e3 o
一个 chunk最多能够存储64MB的数据。 当某个chunk存储的 documents包含的数据量,接近这个阈值时,一个chunk会被切分成两个新的chunks。7 D; C- t0 u! k0 v. G5 r
' Q+ b" h/ f5 V# y2 \. u 当一个shard存储了过多的chunks,这个shard中的某些chunks会被迁移到其它 shard中。
: m* u: k t, G; @0 l, ] t
! {* |+ h. t F 这里有个问题,假如某一条 document 包含的数据量很大,超过 64MB,一个 chunk 存放不下,怎么办?在后续章节介绍 GridFS 时,我们会详细讨论。
7 X& F0 {5 R3 V- ^. w3 A+ y8 q( }/ o& h! z/ p
Replica set
0 h6 a q# x0 m' C$ {3 d0 R8 {
$ s; n' z) q! ^" e 在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。1 P$ x+ k6 H, Y: B# T
$ @8 R1 K" z! J6 R6 t# ~' e
这个replica set包括一个primary DB和多个secondary DBs。为了数据的一致性,所有的修改(insert / update / deletes) 请求都交给primary处理。处理结束之后,再异步地备份到其他secondary中。- L4 d. o n! Q/ @9 U
! V) W& P& x5 a9 w9 q
Primary DB由replica set中的所有servers,共同选举产生。当这个primaryDB server出错的时候,可以从replica set中重新选举一个新的primaryDB,从而避免了单点故障。
* D) {- t: |) p6 o" {- T
5 b5 z# M6 V* Z4 ~5 ` Replica set的选举策略和数据同步机制,确保了系统的数据的一致性。后文详述。
2 [/ J" M( t% d9 G; `
! z# I0 t( `& o' eConfig Server& T3 _. J/ |/ w9 }# c1 Y3 x. E
% x$ Q, T" P! ?) K3 J H Config servers用于存储MongoDB集群的元数据 metadata,这些元数据包括如下两个部分,每一个shard server包括哪些chunks,每个chunk存储了哪些 collections 的哪些 documents。
9 A6 H; }7 m$ }% o2 H
# l4 H# j+ W& \3 s; @7 C 每一个config server都包括了MongoDB中所有chunk的信息。
0 x2 x9 |! Q& _4 R3 z1 R
! S9 ~. Z8 N; x+ \# t8 H0 B+ g, e Config server也需要 replication。但是有趣的是,config server 采用了自己独特的replication模式,而没有沿用 replica set。, g/ C5 [2 u/ B, {2 |9 N1 m2 }0 a
. `- @* U% {# x& H- { 如果任何一台config server挂了,整个 config server 集群中,其它 config server变成只读状态。这样做的原因,是避免在系统不稳定的情况下,冒然对元数据做任何改动,导致在不同的 config servers 中,出现元数据不一致的情况。
$ d% v9 N/ P B2 U7 I; ? y: U9 T' ~' N! \% J( p7 t
MongoDB的官方文档建议,配置3个config servers比较合适,既提供了足够的安全性,又避免了更多的config servers实例之间的数据同步,引起的元数据不一致的麻烦。
: D' q& P9 J5 e
4 F, k: t! c+ @- h* p- \Mongos
2 O8 v3 |8 b' @' N0 b
- c- U" a1 e' W( ~0 c 用户使用MongoDB 时,用户的操作请求,全部由mongos来转发。
7 ^) I+ |3 m& j# u1 V$ T7 c; L# Z) k0 E/ C+ J2 i7 r" v
当 mongos 接收到用户请求时,它先查询 config server,找到存放相应数据的shard servers。然后把用户请求,转发到这些 shard servers。当这些 shard servers完成操作后,它们把结果分别返回给 mongos。而当 mongos 汇总了所有的结果后,它把结果返回给用户。# C( e6 K4 C* B8 p
6 w" H1 P: X; c" z) U; P* V2 o
Mongos每次启动的时候,都要到config servers中读取元数据,并缓存在本地。每当 config server中的元数据有改动,它都会通知所有的mongos。
* q- a, @# x% v' V# _7 t' Z1 A/ l" E
Mongos之间,不存在彼此协同工作的问题。因此,MongoDB所需要配置的mongos server的数量,没有限制。7 ? L# R1 R3 |4 s3 ]/ E% T
2 }, g) x( q) M; T! t" J
通过以上的介绍,我们对每个组成部分都有了基本的了解,但是涉及到工作的细节,我们尚有诸多疑问,例如,一个chunk的数据太大,如何切分?一个shard数据太多,如何迁移?在replica set中,如何选择primary?server挂了,怎么进行故障恢复?接下来的章节,我们逐个回答这些问题。
: s- {1 i7 `# B7 Z3 U9 H5 O. H K
- n6 u' ?6 A' oReference,6 H/ W/ u, h! l
' \) P& H z# f% A6 N[0] Architectural Overview
; K+ h+ G/ x# f/ C! o! U/ z5 Mhttp://www.mongodb.org/display/DOCS/Sharding+Introduction
; V/ f' a; q9 W* L* l8 L |
评分
-
查看全部评分
|