|
|
关于MongoDB,我们能看到的资料,基本都是在指导大家如何使用MongoDB,但是,MongoDB内部是如何运作的,资料不是很多。
' T4 h$ G6 ~, v2 w" W
1 s$ }# a' K, A0 a1 ~( Z m. y 阅读使用手册,会有很多疑惑之处。例如,有人说,MongoDB 等同于分布式的 MySQL。它把一个Table ,按 row,分割成多个Shards,分别存放在不同的 Servers 上。这种说法是否正确?
# j6 n z; ~, W d3 J' s8 D
' B5 T; o4 s& i! T3 w$ p. X" y 不深入了解 MongoDB 的内部结构,就无法透彻地回答类似问题。这个系列文章,就来和大家探讨MongoDB的内部的工作方式。% u0 p0 `# Q- m5 X) F1 y- x
! T3 |- o& h0 I$ x3 W: E0 \
7 m& b- s# U* d q+ U( v5 q
* Y& G) u c: h; j$ F1 T图1-1 MongoDB架构图 # d4 r7 }4 m2 s' N$ h, m3 @* `
1 @3 H) Y! a3 \ MongoDB 通常运行在一个服务器集群上,而不是一个单机。图1-1,描述了一个MongoDB集群的基本组成部分,包括若干shards,至少一个config server,至少一个routing servers(又称 mongos)。
" {( g9 W. x+ ` n! R% X3 `& j# F8 W* _3 Q
Shards! ?1 ~+ K+ f" _4 F! O
; ?8 B. X7 E L9 W# R6 L; g
MongoDB的最基本的数据单元,叫document,类似于关系式数据库中的行 row。一系列documents,组成了一个collection,相当于关系式数据库中的table。当一个 collection 数据量太大时,可以把该collection按documents切分,分成多个数据块,每个数据块叫做一个chunk,多个chunks聚集在一起,组成了一个shard。) l0 l. N2 l2 f$ k1 m& B! d6 k: C
% X0 g! W' K7 G
Sharding 的意义,不仅保障了数据库的扩容(scalability),同时也保障了系统的负载均衡(load balance)。
, Y8 U, W% p7 j8 O
, P7 z: ^8 J+ y8 c* E 每一个shard存储在一个物理服务器(server)上。Server上运行着mongod进程,通过这个进程,对shard中的数据进行操作,主要是增删改查。
' b0 m: F+ r+ k) t" s' H/ q$ D* B$ Q A% o& K$ a! O
如果系统中的每个shard,只存储了一份数据,没有备份,那么当这个shard所在的server挂了,数据就丢失了。在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。( @- i, \' n s0 r$ _, T
" Y2 F/ [/ L& E+ o7 J
Shard keys4 @4 e. |6 e- x( ]; U/ J& Z# n8 i, J
, J* U! J! D% i5 O0 ?; M
为了把collection切分成不同的chunks,从而存放到不同的shards中,我们需要制定一个切分的方式。$ X$ Q) Q) o+ t/ {6 P
$ O6 b7 T( }! {1 K
如前所述,在 MongoDB 数据库中,一个表collection由多个行 documents 组成,而每个 document,有多个属性 fields。同一个 collection 中的不同的 documents,可能会有不同的 fields。例如,有个 collection 叫 Media,包含两条 documents,
! K0 ^$ W3 n- ^) U# M) u2 g+ o c8 \4 S% N! `* U
{, L7 e+ v: [% L$ A6 l
"ISBN": "987-30-3652-5130-82",
& R3 K) R' B& R: B0 |4 X/ C "Type": "CD",! g2 u9 N0 m% X# N/ x
"Author": "Nirvana",# ~+ V) ?1 Y2 f# k
"Title": "Nevermind",
6 a6 h: L1 ?; C2 F3 q. H& R" ^ "Genre": "Grunge",
" }; \ Q. i5 b- B2 K. B$ `; I "Releasedate": "1991.09.24",0 ~2 A' o: m7 \( B
"Tracklist": [5 h7 Q" j0 f7 i% l; u
{4 t2 B$ E8 x6 o3 h6 }
"Track" : "1",, a! O6 U$ u- Q% U/ f
"Title" : "Smells like teen spirit",# E v% r. Q% \% B* r# {# F
"Length" : "5:02"+ J$ y9 b) [" `, m* W: o" C6 q
},
0 _& v# m6 A7 k! b+ A {
0 F L; f3 e* Q5 ?" C1 U# s "Track" : "2",' [4 C) N" R- z" U
"Title" : "In Bloom",
* `, @& K5 q7 ?. }$ _! z "Length" : "4:15"
5 o5 {2 j& E' ^ }
# I2 x7 E# ^& k9 Y+ I ] P% a5 ~ W) P" ~' i* D, ]
}
1 ~+ R7 R. p- H# U; Q& }( D1 m0 s* h& T6 j
{
. b8 B" b' C% _8 c6 O' a7 u, W7 w "ISBN": "987-1-4302-3051-9",
- Q* m7 @. ]' ~6 M2 N "Type": "Book",$ y& a3 F' n2 w9 j- a
"Title": "Definite Guide to MongoDB: The NoSQL Database",
" b' B# ^& v5 Y3 U( B$ j "Publisher": "Apress",1 o& s7 t! l' g" I1 R
"Author": " Eelco Plugge",; ]; f6 ]7 A ?7 f) ?* c
"Releasedate": "2011.06.09"
8 [! e& X& B. l+ u: V' |}* b1 S( \4 x. J2 z/ h
2 P2 N( n# Q- X5 H
假如,在同一个 collection 中的所有 document,都包含某个共同的 field,例如前例中的“ISBN”,那么我们就可以按照这个 field 的值,来分割 collection。这个 field 的值,又称为 shard key。
5 o q$ g7 I/ Q, `, e4 W0 R1 m' L. W- ?& j+ |$ O
在选择shard key的时候,一定要确保这个key能够把collection均匀地切分成很多chunks。
; ^* U$ S9 p) _. J% }4 x+ i
7 Z. _+ }& `2 [( N8 [, j 例如,如果我们选择“author”作为shard key,如果有大量的作者是重名的,那么就会有大量的数据聚集在同一个chunk中。当然,假设很少有作者同名同姓,那么“author”也可以作为一个shard key。换句话说,shard key 的选择,与使用场景密切相关。" i; @7 R# i7 S; x. [2 h
& A2 E: {/ {: B. B! H
很多情况下,无论选择哪一个单一的 field 作为shard key,都无法均匀分割 collection。在这种情况下,我们可以考虑,用多个 fields,构成一个复合的shard key。
! k) _8 g8 x2 D2 Q4 F7 }
& C6 A6 Q+ L. y: I& \& K5 D 延续前例,假如有很多作者同名同姓,他们都叫“王二”。用 author 作为 shard key,显然无法均匀切割 collection。这时我们可以加上release-date,组成name-date的复合 shard key,例如“王二 2011”。
U* A$ v, |: f! Y
% }. g& p$ |: k" L0 Q; W( z- s6 A" F6 C% pChunks
" {. c- {! T8 ~" C# r( |
8 x) u6 j V/ Q" Q, g MongoDB按 shard key,把 collection切割成若干 chunks。每个 chunk 的数据结构,是一个三元组,{collection,minKey,maxKey},如图1-2 所示。4 [8 B, H G o4 ^+ I, o" D2 o
' V7 {5 z2 M& C5 M8 S1 j- U# j% U
) Q- D) ^+ Z8 k图1-2 chunk的三元组
3 v9 {; d' o9 p! v3 H
* f) }4 c7 S' b$ B! B 其中,collection 是数据库中某一个表的名称,而 minKey 和 maxKey 是 shard key的范围。每一个 document 的shard key 的值,决定了这条document应该存放在哪个chunk中。+ H3 G& ^$ f) Z) ]7 ^, h% v
! {! V8 m! w' s! H 如果两条 documents 的 shard keys 的值很接近,这两条 documents 很可能被存放在同一个 chunk 中。
$ | U+ u1 @7 V8 Y2 R7 y+ T p u
Shard key 的值的顺序,决定了 document 存放的 chunk。在 MongoDB 的文献中,这种切割 collection 的方式,称为order-preserving。+ X G8 r& |* V0 q* `2 s0 m
7 d+ f4 L! f! |6 n! X0 M5 S9 C 一个 chunk最多能够存储64MB的数据。 当某个chunk存储的 documents包含的数据量,接近这个阈值时,一个chunk会被切分成两个新的chunks。
9 }# e- N7 T( i* T/ Z0 u% D! G& N/ Z! B# p# |, N: u
当一个shard存储了过多的chunks,这个shard中的某些chunks会被迁移到其它 shard中。
D- y0 F* V# s" ]2 H" Y
, _8 `+ F1 z7 k H. w4 W 这里有个问题,假如某一条 document 包含的数据量很大,超过 64MB,一个 chunk 存放不下,怎么办?在后续章节介绍 GridFS 时,我们会详细讨论。
* b s: p7 J$ O1 S* \! T+ h! ^, _: q" e) n8 i* L4 }
Replica set
& |* r$ i9 x, m. g- n G
; J& V2 f$ B% m$ B. U9 O+ {# h 在生产环境中,为了保证数据不丢失,为了提高系统的可用性(availability),每一个shard被存储多份,每个备份所在的servers,组成了一个replica set。6 @$ a; O6 \( @ {. y& v
, h8 y( f/ T Y9 K2 X ]$ W6 _6 _/ n 这个replica set包括一个primary DB和多个secondary DBs。为了数据的一致性,所有的修改(insert / update / deletes) 请求都交给primary处理。处理结束之后,再异步地备份到其他secondary中。; h- J6 z3 r k2 l
3 H/ ^- _! ^5 @" L3 {( u- S$ T
Primary DB由replica set中的所有servers,共同选举产生。当这个primaryDB server出错的时候,可以从replica set中重新选举一个新的primaryDB,从而避免了单点故障。
* ` Y3 K9 U- b: K5 Y7 p. Y9 z& |
" k& o: \( w& F3 N% Y) l Replica set的选举策略和数据同步机制,确保了系统的数据的一致性。后文详述。
: [ E% U- g7 X8 _ F& d y) W! Z
Config Server9 X8 H. E: B O, M# m
T) M' ^7 \! Y8 _! ~
Config servers用于存储MongoDB集群的元数据 metadata,这些元数据包括如下两个部分,每一个shard server包括哪些chunks,每个chunk存储了哪些 collections 的哪些 documents。) n) M& s. t1 d" N i% j
0 f, _8 C' @5 A1 C9 p 每一个config server都包括了MongoDB中所有chunk的信息。
0 T" x; h. \" x6 t( V/ p( Q4 D) V0 n: W1 M. K- {
Config server也需要 replication。但是有趣的是,config server 采用了自己独特的replication模式,而没有沿用 replica set。
- L3 ^9 o% g7 e4 Y8 y' V; w+ v! M, c2 V( U
如果任何一台config server挂了,整个 config server 集群中,其它 config server变成只读状态。这样做的原因,是避免在系统不稳定的情况下,冒然对元数据做任何改动,导致在不同的 config servers 中,出现元数据不一致的情况。
0 T) _! M0 |8 Q& Y5 y' U& u' n$ Z0 N7 F; e, k' g
MongoDB的官方文档建议,配置3个config servers比较合适,既提供了足够的安全性,又避免了更多的config servers实例之间的数据同步,引起的元数据不一致的麻烦。0 B; I! B" M% L* @7 g" n
0 {2 ~! K2 m( w, w
Mongos
5 `: s& H- Z3 A q% n. I9 T3 Y
& [# {* h7 ~" s# w* g! m' B 用户使用MongoDB 时,用户的操作请求,全部由mongos来转发。. Y" w: {1 S [- s0 c5 u
3 K% x- R U) J! @ 当 mongos 接收到用户请求时,它先查询 config server,找到存放相应数据的shard servers。然后把用户请求,转发到这些 shard servers。当这些 shard servers完成操作后,它们把结果分别返回给 mongos。而当 mongos 汇总了所有的结果后,它把结果返回给用户。
2 D8 s2 L$ e4 c5 F9 O3 ~. t5 y! V' K4 E' I$ L3 Z9 R1 H9 [8 I
Mongos每次启动的时候,都要到config servers中读取元数据,并缓存在本地。每当 config server中的元数据有改动,它都会通知所有的mongos。- I5 b7 E) q: d7 J
1 o# k/ d( S0 c8 B7 A, v, k4 Y Mongos之间,不存在彼此协同工作的问题。因此,MongoDB所需要配置的mongos server的数量,没有限制。! d$ u3 j7 j2 ~- ?
6 C# j7 ~3 @) A/ ~! b 通过以上的介绍,我们对每个组成部分都有了基本的了解,但是涉及到工作的细节,我们尚有诸多疑问,例如,一个chunk的数据太大,如何切分?一个shard数据太多,如何迁移?在replica set中,如何选择primary?server挂了,怎么进行故障恢复?接下来的章节,我们逐个回答这些问题。
" R* Z5 \8 L4 K4 P
7 f+ {2 r( A; N& Z8 Y9 W% q/ T3 C* [0 A( R6 b
Reference,
6 n9 l5 E6 o, S3 R
0 c5 V D L/ K: X4 T[0] Architectural Overview
, Q) U; X7 o# f! A+ M& \http://www.mongodb.org/display/DOCS/Sharding+Introduction
G* y0 k' ~6 s3 D0 v( m" n6 u |
评分
-
查看全部评分
|