|
关于MongoDB,我们能看到的资料,基本都是在指导大家如何使用MongoDB,但是,MongoDB内部是如何运作的,资料不是很多。
* J7 a' {# h7 G* P& j* G
" z7 M5 A# h& F8 o! t K% j 阅读使用手册,会有很多疑惑之处。例如,有人说,MongoDB 等同于分布式的 MySQL。它把一个Table ,按 row,分割成多个Shards,分别存放在不同的 Servers 上。这种说法是否正确?
: Q' T0 E- c/ H2 X: P5 e& ] d) e9 A( f7 N u5 _2 @! W: }5 q
不深入了解 MongoDB 的内部结构,就无法透彻地回答类似问题。这个系列文章,就来和大家探讨MongoDB的内部的工作方式。1 ]3 l" V' C, f1 B
y Y& ~6 l0 A4 l5 w
" \+ R+ m+ J3 D o/ }6 r( p
. _! i0 n( Z* n% Z) s图1-1 MongoDB架构图 * \; X, g6 S" `% g' @" k& _0 g
0 e K0 r: R+ S( m% Y) e. t
MongoDB 通常运行在一个服务器集群上,而不是一个单机。图1-1,描述了一个MongoDB集群的基本组成部分,包括若干shards,至少一个config server,至少一个routing servers(又称 mongos)。
8 q+ r: k, e: ^6 X1 N# g+ U
$ A j6 z* Z8 H. O5 R* T z) m: q% JShards
' a6 n( d ~6 F
3 o' _# E) X$ @& z& j8 r J MongoDB的最基本的数据单元,叫document,类似于关系式数据库中的行 row。一系列documents,组成了一个collection,相当于关系式数据库中的table。当一个 collection 数据量太大时,可以把该collection按documents切分,分成多个数据块,每个数据块叫做一个chunk,多个chunks聚集在一起,组成了一个shard。
7 o3 M4 `+ t5 v- C& o0 S$ E9 X$ i6 {; J& R! s! D$ y. Z' L
Sharding 的意义,不仅保障了数据库的扩容(scalability),同时也保障了系统的负载均衡(load balance)。
# a S7 B* \! N, ~. O; e" B- R' I% @' I4 t5 e0 M ~
每一个shard存储在一个物理服务器(server)上。Server上运行着mongod进程,通过这个进程,对shard中的数据进行操作,主要是增删改查。2 }6 j* p+ p4 Y, m8 t
, m. `% p! \- A7 m8 A5 X
如果系统中的每个shard,只存储了一份数据,没有备份,那么当这个shard所在的server挂了,数据就丢失了。在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。! c& M" q. K, z# |
; D4 w& j) F" z: B1 C1 F# @Shard keys( Q0 t+ T' e7 c: f% V, Q
' y' @/ K, W1 W" V0 P
为了把collection切分成不同的chunks,从而存放到不同的shards中,我们需要制定一个切分的方式。
6 y& Q8 b0 p0 H* z% _3 X; m% l6 N, Z7 m! J) N
如前所述,在 MongoDB 数据库中,一个表collection由多个行 documents 组成,而每个 document,有多个属性 fields。同一个 collection 中的不同的 documents,可能会有不同的 fields。例如,有个 collection 叫 Media,包含两条 documents,
7 h0 O4 G' O- N* }) H; Q
: b6 L2 v# E# @7 P{4 ~# U, P+ d8 w. H
"ISBN": "987-30-3652-5130-82",6 O$ J; |/ ^5 }9 d
"Type": "CD",
4 F9 c# f: Q5 r9 M! @# u i "Author": "Nirvana",
8 [! O/ `. C) v! p+ R "Title": "Nevermind",
5 k( t2 V3 R7 p4 O+ e "Genre": "Grunge",; i' j" ^7 X; M ~' k; r
"Releasedate": "1991.09.24",
: ?6 T* Z2 w" [" w2 [/ H- b% c "Tracklist": [
`- y+ {5 |( B9 G& K {% G, h8 N' A7 v' J
"Track" : "1",$ |" T1 o) H+ t J ^( R- c+ W l
"Title" : "Smells like teen spirit",7 w5 o6 ~) [ z0 N# H6 w4 {( v; `
"Length" : "5:02"3 t2 `1 K6 c. M) v
},) f; g3 \# P3 f0 B" c) T
{
z( ^8 f: e* X* ~% d& M "Track" : "2",; J3 L, J- p+ p f8 ?/ L% P
"Title" : "In Bloom",
9 A! B! z: H" @: M) r9 J+ u "Length" : "4:15"# I0 w x; J. N9 f6 u0 h; [: u
}& g& N# H! C3 D$ k, l3 ~; b
]7 ~. h, M Q* u) T
} `' m$ f% f8 u; b; @
6 ^6 E0 C' s& ]2 o- T$ B9 E( N% H# G
{! ~0 R! v' ^( u8 p; h
"ISBN": "987-1-4302-3051-9",! S' r( K2 J/ j$ }
"Type": "Book",
& t- s* }1 W( h9 ?: G% W "Title": "Definite Guide to MongoDB: The NoSQL Database",' g; z g5 ?. _1 s0 k5 S
"Publisher": "Apress",
% X% h }' D0 @( q$ S: |% \ y "Author": " Eelco Plugge",
5 F5 Q2 A( D, z! C8 x$ T6 P7 d1 v "Releasedate": "2011.06.09"3 ^& O O5 m9 V! T) ~9 u
}, l# H7 p1 z7 Z! U) y! V, u
$ Q0 k# U5 V. Z& p6 D1 J# |/ C 假如,在同一个 collection 中的所有 document,都包含某个共同的 field,例如前例中的“ISBN”,那么我们就可以按照这个 field 的值,来分割 collection。这个 field 的值,又称为 shard key。" V: z! b; R' n
% i) s" q8 ]% b# L) i# S3 } 在选择shard key的时候,一定要确保这个key能够把collection均匀地切分成很多chunks。
W( D+ X' D9 D! e* o
2 f6 i1 S0 Z. o; B 例如,如果我们选择“author”作为shard key,如果有大量的作者是重名的,那么就会有大量的数据聚集在同一个chunk中。当然,假设很少有作者同名同姓,那么“author”也可以作为一个shard key。换句话说,shard key 的选择,与使用场景密切相关。, h' h; G7 p5 h: `7 r
6 h+ m2 ?9 i" U1 K' N
很多情况下,无论选择哪一个单一的 field 作为shard key,都无法均匀分割 collection。在这种情况下,我们可以考虑,用多个 fields,构成一个复合的shard key。, M5 b) f `/ I0 F/ W& \
. {8 d2 ?& T; u' E
延续前例,假如有很多作者同名同姓,他们都叫“王二”。用 author 作为 shard key,显然无法均匀切割 collection。这时我们可以加上release-date,组成name-date的复合 shard key,例如“王二 2011”。" q7 q' E: @) I; L" Q, t
8 ]0 d3 {0 f& r/ a3 E1 T P& d
Chunks7 @) i6 e! u* z5 i7 P# H
4 K0 d* Z) ?8 @; ^ [
MongoDB按 shard key,把 collection切割成若干 chunks。每个 chunk 的数据结构,是一个三元组,{collection,minKey,maxKey},如图1-2 所示。
0 ~ J ~' ^+ Y; Y5 U2 O6 I* A, _6 L6 Y+ U
- W0 W, D! N3 n, b5 m# R4 F: n图1-2 chunk的三元组 - k$ C8 ]2 o2 p c1 {3 T/ L* b
; O; f9 s4 z1 Z4 s5 ? 其中,collection 是数据库中某一个表的名称,而 minKey 和 maxKey 是 shard key的范围。每一个 document 的shard key 的值,决定了这条document应该存放在哪个chunk中。6 ?/ f; r2 y3 n6 W1 B/ v, }% d
; X5 @6 @2 H' M3 M8 z* x0 l6 O 如果两条 documents 的 shard keys 的值很接近,这两条 documents 很可能被存放在同一个 chunk 中。
0 H3 y9 _* X1 I8 t
1 |1 T. `: D5 ?) F, ]0 | Shard key 的值的顺序,决定了 document 存放的 chunk。在 MongoDB 的文献中,这种切割 collection 的方式,称为order-preserving。* L m7 a# h; C: M( V; X
, E% K, G8 j' f. ]( b1 y/ N 一个 chunk最多能够存储64MB的数据。 当某个chunk存储的 documents包含的数据量,接近这个阈值时,一个chunk会被切分成两个新的chunks。
x8 i9 D( G$ e( g( Y
* i$ T# _% ^6 c2 S7 [% ^- c; T 当一个shard存储了过多的chunks,这个shard中的某些chunks会被迁移到其它 shard中。& _/ l0 ]/ r6 r
! u% q- u4 k- p3 R 这里有个问题,假如某一条 document 包含的数据量很大,超过 64MB,一个 chunk 存放不下,怎么办?在后续章节介绍 GridFS 时,我们会详细讨论。; [" S |6 D/ w) f! [+ ?$ ]8 v; N' C
/ S/ w: F, B* e9 u0 IReplica set
; L* n. L2 M/ L' m 6 l, B: c& }1 F7 r' j; M
在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。, Q0 b& _0 {" Z5 ^- E: K+ ^' S
+ {$ h9 ^- I3 H E* m M; n4 M1 F" |$ M 这个replica set包括一个primary DB和多个secondary DBs。为了数据的一致性,所有的修改(insert / update / deletes) 请求都交给primary处理。处理结束之后,再异步地备份到其他secondary中。
$ ]- y2 o- m$ d% f) l) m: H( Q8 g* x
Primary DB由replica set中的所有servers,共同选举产生。当这个primaryDB server出错的时候,可以从replica set中重新选举一个新的primaryDB,从而避免了单点故障。
' F8 k+ h3 B: J6 X- P2 X* ?9 k* Q# \
Replica set的选举策略和数据同步机制,确保了系统的数据的一致性。后文详述。
9 m8 t' G8 n, [5 ^; |3 a; }9 a# J2 `+ h( n! d
Config Server
5 Z9 h9 @ W6 u$ y8 s 5 z% Q0 D. L3 b1 R3 Y- O9 ~0 d
Config servers用于存储MongoDB集群的元数据 metadata,这些元数据包括如下两个部分,每一个shard server包括哪些chunks,每个chunk存储了哪些 collections 的哪些 documents。
0 E5 b3 z S: Q# ~" j
' H2 d8 p( n4 a* w 每一个config server都包括了MongoDB中所有chunk的信息。
0 R! {- S1 }/ D( z. |+ V" |
6 m# j9 E7 ]0 \0 S% S Config server也需要 replication。但是有趣的是,config server 采用了自己独特的replication模式,而没有沿用 replica set。4 B' P% W3 [$ H1 s/ u$ \
* ~ G8 R( T5 d. ~. r* \ 如果任何一台config server挂了,整个 config server 集群中,其它 config server变成只读状态。这样做的原因,是避免在系统不稳定的情况下,冒然对元数据做任何改动,导致在不同的 config servers 中,出现元数据不一致的情况。; z* u! H, e/ M$ {; }0 a/ k- z
3 h$ m: c; `- M# s- R MongoDB的官方文档建议,配置3个config servers比较合适,既提供了足够的安全性,又避免了更多的config servers实例之间的数据同步,引起的元数据不一致的麻烦。; U% p5 O. O" b( E
P& O" S% B1 _Mongos/ W+ t6 m/ a- e1 ~2 y9 Q$ z# {
4 i$ H: b/ B7 T 用户使用MongoDB 时,用户的操作请求,全部由mongos来转发。
7 t; l% J @0 ]5 j+ x+ m7 L$ ~
. g8 `. d6 V" n) W+ c( O' M 当 mongos 接收到用户请求时,它先查询 config server,找到存放相应数据的shard servers。然后把用户请求,转发到这些 shard servers。当这些 shard servers完成操作后,它们把结果分别返回给 mongos。而当 mongos 汇总了所有的结果后,它把结果返回给用户。
$ R# [6 V' M6 u3 L! ^: k2 K
4 E4 ^- n; @: N& m) Y5 j Mongos每次启动的时候,都要到config servers中读取元数据,并缓存在本地。每当 config server中的元数据有改动,它都会通知所有的mongos。& J6 M; V0 [# s; H. S
2 B1 u& J! V3 N8 @1 ?, x+ P
Mongos之间,不存在彼此协同工作的问题。因此,MongoDB所需要配置的mongos server的数量,没有限制。& M8 H" f% Q' w3 }- {
e. t' P$ Z( d- {5 z 通过以上的介绍,我们对每个组成部分都有了基本的了解,但是涉及到工作的细节,我们尚有诸多疑问,例如,一个chunk的数据太大,如何切分?一个shard数据太多,如何迁移?在replica set中,如何选择primary?server挂了,怎么进行故障恢复?接下来的章节,我们逐个回答这些问题。' l& Q2 f6 j1 R( C" e/ T
& u- o" Z8 a2 F8 p: O
) R2 X3 ?/ N/ A; y8 u+ P) k( J' D$ DReference,% m5 h7 E1 q. E1 m* u5 z
& V% F2 z) A' s8 d8 I) C4 w* n1 ~[0] Architectural Overview
c& ]1 V( T9 w( `" p7 v! H" ~; Zhttp://www.mongodb.org/display/DOCS/Sharding+Introduction
7 ?6 t2 F4 C( j' i% N7 P1 ` |
评分
-
查看全部评分
|