|
|
关于MongoDB,我们能看到的资料,基本都是在指导大家如何使用MongoDB,但是,MongoDB内部是如何运作的,资料不是很多。& q# U. g3 r; m
) D) h' K/ {$ d, J! \
阅读使用手册,会有很多疑惑之处。例如,有人说,MongoDB 等同于分布式的 MySQL。它把一个Table ,按 row,分割成多个Shards,分别存放在不同的 Servers 上。这种说法是否正确?" C- B0 P9 c+ |6 Y/ k1 p
" m( }, P, x& ?8 y 不深入了解 MongoDB 的内部结构,就无法透彻地回答类似问题。这个系列文章,就来和大家探讨MongoDB的内部的工作方式。
7 H3 o3 }6 e; u& O( a7 g6 c _" R4 l" L
! D1 f3 [) x4 `4 }: P- }3 e% M Z% @6 k) [7 ]
图1-1 MongoDB架构图 # H; d' {% k* f- w$ t
; `$ N w( ~) ^" ]3 O MongoDB 通常运行在一个服务器集群上,而不是一个单机。图1-1,描述了一个MongoDB集群的基本组成部分,包括若干shards,至少一个config server,至少一个routing servers(又称 mongos)。
$ D' B5 T5 W* O) m9 C& e5 m, U, V! u4 Y( t1 Q( k$ C
Shards
: J) P5 @3 _3 s# a. N9 k" R
4 t3 n9 u3 H; Y7 }; V0 d0 X, a MongoDB的最基本的数据单元,叫document,类似于关系式数据库中的行 row。一系列documents,组成了一个collection,相当于关系式数据库中的table。当一个 collection 数据量太大时,可以把该collection按documents切分,分成多个数据块,每个数据块叫做一个chunk,多个chunks聚集在一起,组成了一个shard。- b; E" ]; P& W T! o6 h
$ `" _ _) x: s2 O) l: G Sharding 的意义,不仅保障了数据库的扩容(scalability),同时也保障了系统的负载均衡(load balance)。, x4 z+ k! K- c8 y- K9 L" m
. i. ?$ R3 C5 H. e& r$ F: `
每一个shard存储在一个物理服务器(server)上。Server上运行着mongod进程,通过这个进程,对shard中的数据进行操作,主要是增删改查。% x* F) t- T) ?& }
h: e2 |0 u ]$ m
如果系统中的每个shard,只存储了一份数据,没有备份,那么当这个shard所在的server挂了,数据就丢失了。在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。$ ?0 |* a0 V0 n1 P* i$ D
4 \) C N0 A9 S9 y2 h7 J, M/ b8 fShard keys
* S1 x6 Z: W5 \" b* v+ N# t
1 j2 j) W( A8 E 为了把collection切分成不同的chunks,从而存放到不同的shards中,我们需要制定一个切分的方式。
7 Y; m% ^- S3 w [4 F* x! Z
4 [+ c. g8 l+ E; u" P2 I 如前所述,在 MongoDB 数据库中,一个表collection由多个行 documents 组成,而每个 document,有多个属性 fields。同一个 collection 中的不同的 documents,可能会有不同的 fields。例如,有个 collection 叫 Media,包含两条 documents,9 w2 }/ H0 n; h" U4 u
, n! k- n% G5 ?{, K. R( ]* {8 z& E" \( w
"ISBN": "987-30-3652-5130-82",
- E! @5 D- j! l4 M" c "Type": "CD",
: P9 r/ W0 N. u "Author": "Nirvana",
w8 _2 r$ U; o$ j6 E3 ~ "Title": "Nevermind",0 ?: V% F# K: K$ Z
"Genre": "Grunge",# x# D& V+ t$ e& g5 X: W6 K
"Releasedate": "1991.09.24",
8 [7 _& m2 c9 Y3 k' ^9 v% B! v "Tracklist": [
' J1 |# P4 C7 ~3 l {
3 F) Y" x/ T! q( S* [ "Track" : "1",. E$ r8 Z7 Y s' I
"Title" : "Smells like teen spirit",: D1 e; F% p) W9 v7 |% i* {
"Length" : "5:02"
" u. Y: {- t1 B, l0 c },1 s3 Z: J, |8 ]
{
8 o- ]! I# q8 y: | "Track" : "2",2 x1 d Q; p9 Q/ j, [1 S7 R
"Title" : "In Bloom",9 w3 I* D2 q- Z, W# I" y& _2 s: I
"Length" : "4:15": L# _) Q, `2 [2 z) [ ?
}
" x, `3 G" Q# I" D- q ]
: g8 } V5 h2 ^7 {' i}* G# b8 j) `. i) t
0 w- \- F* `. k' P
{# B9 h2 E1 [% u
"ISBN": "987-1-4302-3051-9",
0 n6 k4 {$ y* a4 w$ N7 E0 Y "Type": "Book",' t% L5 _2 `+ [! V# Q/ t
"Title": "Definite Guide to MongoDB: The NoSQL Database", a' b- Y5 `, o( C
"Publisher": "Apress",
/ ^6 L; `" U9 l; W9 f- F3 w2 b# z8 E "Author": " Eelco Plugge",
1 m' Q0 ?' w: L# B$ Q( ~. U6 [' _3 m "Releasedate": "2011.06.09"
}# V5 s- w. J7 E- D1 c( b v5 y}$ g+ G0 I2 e- }0 G: C
5 H F6 u4 m/ Z3 v2 U, K 假如,在同一个 collection 中的所有 document,都包含某个共同的 field,例如前例中的“ISBN”,那么我们就可以按照这个 field 的值,来分割 collection。这个 field 的值,又称为 shard key。5 P2 ]( B( g% u
" l& }/ _, T0 F, o, U* R$ ^
在选择shard key的时候,一定要确保这个key能够把collection均匀地切分成很多chunks。* L9 W5 A/ k/ B
5 G; @2 F$ Y4 V/ t+ G' _
例如,如果我们选择“author”作为shard key,如果有大量的作者是重名的,那么就会有大量的数据聚集在同一个chunk中。当然,假设很少有作者同名同姓,那么“author”也可以作为一个shard key。换句话说,shard key 的选择,与使用场景密切相关。# O$ Y: m3 m: S' {! _0 V5 b( m6 z$ W
! \- Q3 o6 O7 C4 a9 i. ~
很多情况下,无论选择哪一个单一的 field 作为shard key,都无法均匀分割 collection。在这种情况下,我们可以考虑,用多个 fields,构成一个复合的shard key。& f. R6 s) v9 q; I
: \# g) O2 p5 F' e4 Q; y+ F 延续前例,假如有很多作者同名同姓,他们都叫“王二”。用 author 作为 shard key,显然无法均匀切割 collection。这时我们可以加上release-date,组成name-date的复合 shard key,例如“王二 2011”。
7 _8 V+ Q+ j5 C. g+ w$ y+ p5 v6 Z+ ?7 J
: A% b, y" c: Q/ [! S( GChunks {& y \% t2 p- |5 [% L9 D9 e: N
/ I4 H$ c2 R6 G" O& O8 y2 Q2 G MongoDB按 shard key,把 collection切割成若干 chunks。每个 chunk 的数据结构,是一个三元组,{collection,minKey,maxKey},如图1-2 所示。
% u' o+ U6 m) }8 `- y# h/ m& t6 }' W/ l/ d7 ]
( j9 j8 c3 ^7 ^% @, H
图1-2 chunk的三元组 8 Z( ^# l, I; s% {- C* j7 g3 V0 ?
+ l+ e4 F( s& N! m2 b 其中,collection 是数据库中某一个表的名称,而 minKey 和 maxKey 是 shard key的范围。每一个 document 的shard key 的值,决定了这条document应该存放在哪个chunk中。
7 c/ Z/ o4 X! s+ W
: j T7 _, k) R1 i3 T 如果两条 documents 的 shard keys 的值很接近,这两条 documents 很可能被存放在同一个 chunk 中。
/ U/ l7 w5 V* \3 I8 Z7 T& g9 H
Shard key 的值的顺序,决定了 document 存放的 chunk。在 MongoDB 的文献中,这种切割 collection 的方式,称为order-preserving。* V" I! R7 E- _2 I9 P# n
. ~" {* b0 L+ T) L5 y
一个 chunk最多能够存储64MB的数据。 当某个chunk存储的 documents包含的数据量,接近这个阈值时,一个chunk会被切分成两个新的chunks。; d+ p$ U# T% x7 Z0 D
9 T* {. s% X7 O' z/ z
当一个shard存储了过多的chunks,这个shard中的某些chunks会被迁移到其它 shard中。+ [! i7 S- W ~; |, p; |- [! a
! i5 ^( F6 e4 e0 [5 `( y) [ 这里有个问题,假如某一条 document 包含的数据量很大,超过 64MB,一个 chunk 存放不下,怎么办?在后续章节介绍 GridFS 时,我们会详细讨论。
6 e( A, Q9 Y3 X
/ m# ]" V7 U- [6 E1 G; UReplica set
6 { c4 X- T% A5 Y: b/ f 2 t& ~( v# @$ H- _$ {8 d3 l
在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。& U! ~, H" H/ V$ I7 B- b
B! n, v9 a4 O+ |5 w 这个replica set包括一个primary DB和多个secondary DBs。为了数据的一致性,所有的修改(insert / update / deletes) 请求都交给primary处理。处理结束之后,再异步地备份到其他secondary中。
3 Z( q) C2 z8 a8 l; n
) }9 @% Y' |% T+ [6 V Primary DB由replica set中的所有servers,共同选举产生。当这个primaryDB server出错的时候,可以从replica set中重新选举一个新的primaryDB,从而避免了单点故障。
8 @: E7 k. f8 [' J' D% N; l2 T& }$ }% _9 f+ t9 B
Replica set的选举策略和数据同步机制,确保了系统的数据的一致性。后文详述。& B' S z9 z$ w6 U$ ? o
* Y- S% K! ]' y4 J/ PConfig Server0 L4 W ~0 O* Q9 n7 U8 z( h8 Z. X$ D
% J, s) g2 o8 F- q% n
Config servers用于存储MongoDB集群的元数据 metadata,这些元数据包括如下两个部分,每一个shard server包括哪些chunks,每个chunk存储了哪些 collections 的哪些 documents。$ p& P5 n& e$ m$ F
( g& x$ p& {! T8 q; Q
每一个config server都包括了MongoDB中所有chunk的信息。% W+ C( C* V) ~, r
# B% w7 X, ?" R. v
Config server也需要 replication。但是有趣的是,config server 采用了自己独特的replication模式,而没有沿用 replica set。
, Y8 r1 p5 k$ Y) s. I2 f# S3 \5 j
" I2 F8 t6 D# N3 e 如果任何一台config server挂了,整个 config server 集群中,其它 config server变成只读状态。这样做的原因,是避免在系统不稳定的情况下,冒然对元数据做任何改动,导致在不同的 config servers 中,出现元数据不一致的情况。
5 W; T$ P/ k7 S$ ~; P+ }+ ^" j$ b) x- U6 j: t
MongoDB的官方文档建议,配置3个config servers比较合适,既提供了足够的安全性,又避免了更多的config servers实例之间的数据同步,引起的元数据不一致的麻烦。: O: y6 q7 Y+ ^- t, O
6 P8 j5 n3 K' `/ R7 [9 d$ b
Mongos
% Y& t9 n( j) ?0 W, `
% {9 M" t' e2 H 用户使用MongoDB 时,用户的操作请求,全部由mongos来转发。
5 t8 d. b; r. B0 e. G- i' [4 g- G6 h* Y* F# o) n
当 mongos 接收到用户请求时,它先查询 config server,找到存放相应数据的shard servers。然后把用户请求,转发到这些 shard servers。当这些 shard servers完成操作后,它们把结果分别返回给 mongos。而当 mongos 汇总了所有的结果后,它把结果返回给用户。8 t T6 t( ^! O2 M0 e
1 D7 n9 f3 X" _) Q1 c B; w
Mongos每次启动的时候,都要到config servers中读取元数据,并缓存在本地。每当 config server中的元数据有改动,它都会通知所有的mongos。
- {* |! x' h" \# S+ [0 C' j% z( x7 R0 i( P! ~/ O( }, @; y
Mongos之间,不存在彼此协同工作的问题。因此,MongoDB所需要配置的mongos server的数量,没有限制。8 S. H$ y+ ~ u9 e% ~0 q
. Z5 m1 |8 K, T 通过以上的介绍,我们对每个组成部分都有了基本的了解,但是涉及到工作的细节,我们尚有诸多疑问,例如,一个chunk的数据太大,如何切分?一个shard数据太多,如何迁移?在replica set中,如何选择primary?server挂了,怎么进行故障恢复?接下来的章节,我们逐个回答这些问题。
V! l& z' Q5 ?
h! H: L/ k4 c1 r( ? {6 b+ `) C/ j( L
Reference,
4 V+ p. t9 [" \" y9 ^! f& ]+ u0 X/ T3 {
[0] Architectural Overview2 [3 F1 M3 ^# g3 G
http://www.mongodb.org/display/DOCS/Sharding+Introduction; i3 o8 J1 {5 y) t* j7 F: E& m
|
评分
-
查看全部评分
|