Mongodb技術總結（version3.4.4）

mongodb的標準安裝與卸載

# 1. 導入包管理系統使用的公鑰
# Ubuntu 的軟件包管理工具（即dpkg和APT）要求軟件包的發佈者通過GPG密鑰
# 簽名來確保軟件包的一致性和真實性。通過以下命令導入MongoDB公共GPG密鑰：
sudo apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv 0C49F3730359A14518585931BC711F9BA15703C6


# 2. 創建list file
# 根據 Ubuntu 的版本使用適當的命令創建 list file: /etc/apt/sources.list.d/mongodb-org-3.4.list
# ubuntu14.04
echo "deb [ arch=amd64 ] http://repo.mongodb.org/apt/ubuntu trusty/mongodb-org/3.4 multiverse" | sudo tee /etc/apt/sources.list.d/mongodb-org-3.4.list
# ubuntu16.04
echo "deb [ arch=amd64,arm64 ] http://repo.mongodb.org/apt/ubuntu xenial/mongodb-org/3.4 multiverse" | sudo tee /etc/apt/sources.list.d/mongodb-org-3.4.list


# 3. 重新下載本地包數據庫索引
sudo apt-get update


# 4. 安裝 MongoDB
sudo apt-get install -y mongodb-org


# 5. 運行MongoDB
sudo service mongod start
# 或者
sudo systemctl start mongod

# 6. 命令行運行命令：
mongo

# 7. 卸載mongodb
# 關閉MongoDB
sudo service mongod stop
# 刪除所有相關軟件包
sudo apt-get purge mongodb-org*
# 刪除數據和日誌目錄
sudo rm -r /var/log/mongodb
sudo rm -r /var/lib/mongodb

mongodb直接解壓安裝

# 下載解壓軟件包
wget https://fastdl.mongodb.org/linux/mongodb-linux-x86_64-ubuntu1404-3.4.4.tgz
tar -zxvf mongodb-linux-x86_64-ubuntu1404-3.4.4.tgz -C .


# 創建數據庫數據、配置文件、日誌文件的存放目錄
mkdir -p data conf logs


# 創建和編寫mongodb配置文件
touch mongod.conf
vim mongod.conf
-------------------
#指定mongod端口
port = 27017
#指定數據存放目錄
dbpath = /home/ubuntu/mongodb-3.4.4/data
#指定日誌文件
logpath = /home/ubuntu/mongodb-3.4.4/logs/mongod.log
#指定啓動的是後臺進程，這個參數在windows下無效
fork = true
#是都啓用權限認證
auth = false
-------------------


# 啓動mongod進程，-f等價於--config
./bin/mongod -f conf/mongod.conf
# 加入開機啓動項
echo "xxx/mongod -f xxx/mongodb.conf;" >> /etc/rc.local


#關閉命令，前提是關閉了前端程序
xxx/mongod --shutdown -f xxx/mongodb.conf


#啓動客戶端交互
#在~/.mongorc.js中可以編寫mongod啓動時運行的js腳本，如這裏打印的 "hello kinglyjn!"
xxx/mongo localhost:27017/test
------------------------------
MongoDB shell version v3.4.4
connecting to: mongodb://localhost:27017/test
MongoDB server version: 3.4.4
hello kinglyjn!
Server has startup warnings: 
2017-06-08T18:38:52.632+0800 I CONTROL  [initandlisten] 
2017-06-08T18:38:52.632+0800 I CONTROL  [initandlisten] ** WARNING: /sys/kernel/mm/transparent_hugepage/enabled is 'always'.
2017-06-08T18:38:52.632+0800 I CONTROL  [initandlisten] ** We suggest setting it to 'never'
------------------------------

#我們發現有警告，按照提示修改即可，腳本如下(在root用戶下執行 sudo -i)：
if test -f /sys/kernel/mm/transparent_hugepage/enabled; then
   echo never > /sys/kernel/mm/transparent_hugepage/enabled
fi
if test -f /sys/kernel/mm/transparent_hugepage/defrag; then
   echo never > /sys/kernel/mm/transparent_hugepage/defrag
fi

常見客戶端命令

#數據庫和集合
show dbs
use dbname
db.getName()
db.stats()
db.getMongo()
show collections
db.dropDatabase()
db.cname.drop()
db.copyDatabase("src_dbname", "target_dbname", "127.0.0.1")
db.repairDatabase()


#數據庫狀態分析
mongostat -h 127.0.0.1:27017
# 0：profile操作記錄功能關閉  
# 1：記錄操作值大於slowms的操作  
# 2：記錄任何操作記錄
# 一般測試階段使用2，而生產環境profilingLevel的值爲0
db.getProfilingLevel()    
db.setProfilingLevel(2) 
db.getProfilingStatus() { "was" : 0, "slowms" : 100 }
# 通過mongodb的配置文件/etc/mongo.conf的 verbose參數可以配置日誌的詳細程序（一個v~5個v）


#配置文件開啓權限模式：
--------------------------
security:
    authorization: enabled

或者
auth = true
--------------------------
#在相應的庫下創建和刪除用戶：
#數據庫管理角色
#read、readWrite、dbAdmin、dbOwner、userAdmin
read：該角色只有讀取數據的權限
readWrite：該角色有數據的讀寫權限，但不能創建刪除索引，也不能創建和刪除數據庫
dbAdmin：該角色擁有數據庫管理權限（比如更改數據庫類型）
dbOwner：是read、readWrite、dbAdmin這三者角色的集合體
userAdmin：該角色可以對其他角色權限進行管理
#集羣管理角色
clusterAdmin：提供了最大的集羣管理功能。相當於clusterManager, clusterMonitor, 
              and hostManager和dropDatabase的權限組合
clusterManager：提供了集羣和複製集管理和監控操作。擁有該權限的用戶可以操作config
              和local數據庫（即分片和複製功能）
clusterMonitor：僅僅監控集羣和複製集
hostManager：提供了監控和管理服務器的權限，包括shutdown節點，logrotate, repairDatabase等。
#所有數據庫角色
readAnyDatabase：具有read每一個數據庫權限。但是不包括應用到集羣中的數據庫。
readWriteAnyDatabase：具有readWrite每一個數據庫權限。但是不包括應用到集羣中的數據庫。
userAdminAnyDatabase：具有userAdmin每一個數據庫權限，但是不包括應用到集羣中的數據庫。
dbAdminAnyDatabase：提供了dbAdmin每一個數據庫權限，但是不包括應用到集羣中的數據庫。
#超級管理員權限
root: dbadmin到admin數據庫、useradmin到admin數據庫以及UserAdminAnyDatabase。
      但它不具有備份恢復、直接操作system.*集合的權限，但是擁有root權限的超級用戶
      可以自己給自己賦予這些權限。

#backup、restore：備份角色權限
#客戶端創建用戶：
var user = {
    user:"usernamexx", 
    pwd:"passwordxx",
    customData:"xxxx",
    roles:[{role:"userAdmin", db:"admin"}, {role:"read", db:"response"}]
}
db.createUser(user); 
db.dropUser("usernamexxx");
#使用新創建的用戶登錄：
mongo 127.0.0.1:27017/test -u usernamexxx -p passwordxxx
或 db.auth('usernamexxx','passwordxxx')


#添加數據
#insert添加時如果主鍵重複則報錯，而save添加時主鍵重複則覆蓋
db.cname.insert({name:"zhangsan", age:23}) 
db.cname.save({name:"zhangsan", age:23})


#修改數據
#定位語句，更新語句，不存在是否更新插入，是否全部更新
db.cname.update(criteria, objNew, isUpsert, isMulti)
#局部修改
db.cname.update({age:25}, {$set:{name:"lisi"}}, false, false)
db.cname.update({age:25}, {$inc:{age:2}}, false, true)
db.cname.update({age:25}, {$push:{scores:{$each:[1,2,3,4]}}})
db.cname.update({age:25}, {$addToSet:{tags:{$each:["aaa", "bbb"]}}})
#整體修改
db.cname.update({age:25}, new_user)
#修改集合名稱
db.cname.renameCollection("target_name")

#刪除數據
db.cname.remove({name:"zhangsan"})


#查詢數據
db.cname.count()
db.cname.dataSize()
db.cname.totalSize()
db.cname.storageSize()
db.cname.getShardVersion()
db.cname.stats()
db.cname.distinct("name") #select distict name from user
db.cname.find()
db.cname.find({name:"zhangsan"})
db.cname.find({name:"zhangsan"}).pretty()  #友好顯示數據
db.cname.find({name:"zhangsan"}).explain() #性能分析函數
db.cname.find({name:"zhangsan", age:23})
db.cname.find({age:{$gt:22}}, {name:1, age:1}) #顯示name和age字段
db.cname.find({age:{$gte:22}})
db.cname.find({age:{$gt:23, $lt:26}})       #查詢age >= 23 並且 age <= 26 
db.cname.find({name:/mongo/})               #查詢name中包含 mongo的數據
db.cname.find({"data.map.key1":/regexxxx/}) #注意這裏必須加引號
db.cname.find().skip(3).limit(5).sort({age:-1})
db.cname.find().skip(3).limit(5).sort({$natural:-1}) #$natural一般按寫入順序排序
db.cname.find({$or:[{age:22}, {age:25}]})
db.cname.find({age:{$exists:true}})        #查詢存在age字段的記錄
db.cname.find({age:{$ne:23}})              #不等於
db.cname.find({age:{$in:[23,24,25]}})
db.cname.find({name:{$in:[null], $exists:true}}) #可以匹配 {name:null,sex:1,age:18}
db.cname.find({name:{$nin:["zhangsan"]}})
db.cname.find({x:{$all:[1,5]}})                #查詢x數組中全部包含1和5的記錄
db.cname.find({x:[1,2,3,4]})                #精確查詢爲該數組的記錄
db.cname.find({"x.0":1})                    #匹配數組中指定下標元素的值
db.cname.find({x:{$size:4}})               #匹配x數組長度爲4的記錄


#分組查詢
db.user.group({
    key:{name:true},
    initial:{users:[]}, #每組都分享的“初始化函數”，可以在此處初始化一些變量供每組進行使用
    $reduce:function(current, previor){previor.users.push(current.name);},
    condition:{name:{$exists:true}}, #過濾條件
    finalize:function(out){out.count=out.users.length}
})


#索引數據
#_id索引
#單建索引
#多鍵索引
#複合索引
#過期索引
#全文索引
#地理信息索引
db.cname.getIndexes()
db.cname.ensureIndex({name:1, age:-1})

#刪除索引
db.cname.dropIndex("name_1_age_-1")
db.cname.dropIndexes()

#創建唯一索引(以下創建的索引只允許集合中存在唯一一個name-address記錄)
db.cname.ensureIndex({name:1, adddress:1}, {unique:true})

#創建稀疏索引(不存在name的記錄不創建name索引，注意不能使用稀疏索引查找不存在name字段的記錄)
db.cname.ensureIndex({name:1}, {spare:true})

#加過期索引的字段必須爲ISODate或者ISODate的數組，超時後記錄被自動刪除（TTL）
#刪除的過程是不精確的，刪除過程是每60s跑一次，而且刪除也需要一定的時間，所以存在誤差
db.cname.ensureIndex({createTime:1}, {expireAfterSeconds:50}) 
db.cname.ensureIndex({name:1, age:-1}, {name:"name_age_idx", unique:true, sparse:true, expireAfterSeconds:50})
#強制使用索引查找
db.cname.find({name:"zs", age:23}).hint("name_1_age_-1"); 

#全文檢索索引
db.cname.ensureIndex({name:"text"}) 
db.cname.ensureIndex({"$**":"text"})
#全文檢索查詢
db.cname.find({$text:{$search:"aaa"}}) 
db.cname.find({$text:{$search:"aa bb cc"}})     #查詢包含aa或bb或cc的記錄
db.cname.find({$search:"\"aa\" \"bb\" \"cc\""}}) #查詢既包含aa又包含bb又包含cc的記錄
db.cname.find({$text:{$search:"aa bb -cc"}})    #查詢包含aa或bb，但是不包含cc的記錄
db.cname.find({$text:{$search:"/AA/i"}})        #正則匹配
db.cname.find({$text:{$search:"aaa"}, score:{$meta:"textScore"}}) 
db.cname.find({$text:{$search:"aaa"}}, {score:{$meta:"textScore"}}).sort({score:{$meta:"textScore"}}) #根據匹配度排序

#地理位置索引
#平面地理位置索引 經緯度範圍 -180~180 -90~90
db.cname.ensureIndex({p:"2d"}) 
#球面地理位置索引
db.cname.ensureIndex({p:"2dsphere"}) 
db.cname.insert({p:[0,0]})
db.cname.insert({p:[-180,-90]})
db.cname.insert({p:[180,90]})
#默認返回100個最近的點
db.cname.find({p:{$near:[0,0]}}) 
db.cname.find({p:{$near:[0,0]}, $maxDistance:10}) 
#查找圓內的點
db.cname.find({p:{$geoWithin:{$center:[[0,0], 5]}}}) 
#查找方塊內的點
db.cname.find({p:{$geoWithin:{$box:[[0,0], [3,3]]}}}) 
#查找多邊形內的點
db.cname.find({p:{$polygon:[[0,0],[1,3],[4,5]]}})

搭建mongodb副本集

#準備三臺機器
172.16.127.129
172.16.127.130
172.16.127.131

#配置文件信息
port = 27017
dbpath = /home/ubuntu/mongodb-3.4.4/data
logpath = /home/ubuntu/mongodb-3.4.4/logs/mongod.log
logappend = true
fork = true
auth = false


#分別在這三臺機器上啓動mongodb
mongodb-3.4.4/bin/mongod -f mongodb-3.4.4/conf/mongod.conf --replSet rs01
mongodb-3.4.4/bin/mongod -f mongodb-3.4.4/conf/mongod.conf --replSet rs01
mongodb-3.4.4/bin/mongod -f mongodb-3.4.4/conf/mongod.conf --replSet rs01


#啓動以後我們發現副本集還沒有初始化配置信息,接下來便是初始化副本集
#在三臺機器上任意一臺登陸mongodb（我這裏在129上登陸）
#使用admin數據庫
use admin
#輸入如下內容:
#注：紅色字體的repset要和上面參數 “--replSet rs01” 保持一致.
config=
{_id:"rs01",members:[
...{_id:0,host:"172.16.127.129:27017"},
...{_id:1,host:"172.16.127.130:27017"},
...{_id:2,host:"172.16.127.131:27017"}]
}
#初始化副本集配置
#輸出成功{"ok",1}
rs.initiate(config)


#查看日誌，副本集啓動成功後，130爲主節點PRIMARY，129、131爲副本節點SECONDARY。(選舉機制似乎類似於zk)
#查看集羣節點的狀態
rs.status()
rs.isMaster()


#至此整個副本集就搭建成功了，接下來測試副本集數據複製功能
#回到130主節點連接進入終端
#建立test數據庫
use test
#往user測試表中插入數據
db.user.insert({name:"zhangsan", age:23})
#在副節點129,131上查看數據是否複製過來
use test
show tables
"errmsg" : "not master and slaveOk=false",
#mongodb默認是從主節點讀寫數據的，副本節點上不允許讀，需要設置副本節點可以讀(主節點可讀可寫，從節點可讀)
db.getMongo().setSlaveOk()
#可以看到數據已經複製到了副本集
db.user.find()


#容災測試
#此時如果主節點130宕機(關閉主節點)
mongodb-3.4.4/bin/mongod --shutdown -f mongodb-3.4.4/conf/mongod.conf
#查看129和131節點狀態發現，此時129節點變成了主節點，向主節點寫入數據ok
use test
db.user.insert({name:"lisi", age:24})
#查看131從節點，發現數據副本已經生成
db.user.find()


#在主庫130中添加從庫
rs.add("172.16.127.132:27017")
{ "ok" : 1 }

mongodb分片技術

注意：MongoDB 3.4, config servers must be deployed as a replica set (CSRS).

也就是說mongodb3.4以後【config節點】強制使用副本集。

什麼是分片？
分片是將數據進行拆分，將數據水平地分散到不同服務器的技術。

爲什麼要分片？

架構上：讀寫均衡，去中心化。

硬件上：解決單機內存和硬盤的限制。

總的來說，分片能夠改善單臺機器數據的存儲以及數據吞吐性能，提高在大量數據下隨機訪問的性能。

分片和副本集的比較

replication（副本集）	shard（分片）
實現意義	數據冗餘、實現讀寫分離（主寫副讀），提升讀的性能
架構上	中心化
實現原理上	數據鏡像
維護成本	相對容易

分片節點介紹

app—>mongos---->CONFIG_RS[config]---->RS01[shard01、shard02、shard03...]
                                 ---->RS02[shard01、shard02、shard03...]
                                 ---->RS03[shard01、shard02、shard03...]  

分片測試細節

分片節點信息：

# 分片節點信息：
172.16.127.128      mongos
172.16.127.129      [config_rs]configsvr0,configsvr1,configsvr2
172.16.127.130      shardsvr01
172.16.127.131      shardsvr02


# 配置信息
----------------------------
#shardsvr配置文件mongod.conf
port = 27017
dbpath = /home/ubuntu/mongodb-3.4.4/data
logpath = /home/ubuntu/mongodb-3.4.4/logs/mongod.log
logappend = true
fork = true
auth = false

#config_rs配置文件mongod.conf
port = 27017
dbpath = /home/ubuntu/mongodb-3.4.4/data
logpath = /home/ubuntu/mongodb-3.4.4/logs/mongod.log
logappend = true
fork = true
auth = false

port = 27018
dbpath = /home/ubuntu/mongodb-3.4.4-01/data
logpath = /home/ubuntu/mongodb-3.4.4-01/logs/mongod.log
logappend = true
fork = true
auth = false

port = 27019
dbpath = /home/ubuntu/mongodb-3.4.4-02/data
logpath = /home/ubuntu/mongodb-3.4.4-02/logs/mongod.log
logappend = true
fork = true
auth = false

#mongos配置文件mongod.conf
port = 27017
logpath = /home/ubuntu/mongodb-3.4.4/logs/mongod.log
logappend = true
fork = true

啓動各個分片節點

# shardsvr01 & shardsvr02
mongodb-3.4.4/bin/mongod -f mongodb-3.4.4/conf/mongod.conf --shardsvr
mongodb-3.4.4/bin/mongod -f mongodb-3.4.4/conf/mongod.conf --shardsvr

# configsvr(正常應該配置至少三個configsvr)
mongodb-3.4.4/bin/mongod -f mongodb-3.4.4/conf/mongod.conf --configsvr --replSet config_rs
mongodb-3.4.4-01/bin/mongod -f xxx/conf/mongod.conf --configsvr --replSet config_rs
mongodb-3.4.4-02/bin/mongod -f xxx/conf/mongod.conf --configsvr --replSet config_rs
# 初始化CONFIG_RS
use admin
var config = {_id:"config_rs", configsvr:true,members:[{_id:0, host:"172.16.127.129:27017"}]}
rs.initiate(config)
rs.add({_id:1, host:"172.16.127.129:27018"})
rs.add({_id:2, host:"172.16.127.129:27019"})

# mongos
mongodb-3.4.4/bin/mongos -f mongodb-3.4.4/conf/mongod.conf --configdb config_rs/172.16.127.129:27017,172.16.127.129:27018,172.16.127.129:27019

給具體的庫表添加分片：

#1. 連接到mongos
    mongodb-3.4.4/bin/mongo
    use admin

#2. add shard [需要在admin數據庫下操作]
    #注意如果你的mongos和shard在同一臺機器上，添加分片不能使用localhost，建議使用ip
    #對於單個數據庫實例,maxSize表示分片節點最大存儲大小
    #db.runCommand({addShard:"<hostname><:port>", maxSize:<size>, name:"<shard_name>"})
    #對於副本集羣
    #db.runCommand({addShard:"<replica_set>/<hostname><:port>", 
    #               maxSize:<size>, name:"<shard_name>"})
    db.runCommand({addShard:"172.16.127.130:27017"})
    db.runCommand({addShard:"172.16.127.131:27017"})
    #或者
    sh.addShard('172.16.127.130:27017')
    sh.addShard('172.16.127.131:27017')
    sh.status()
    sh.status({verbose:true})

#3. enable sharding [admin，這裏只是標識這個數據庫可以啓用分片，但實際上並沒有進行分片]
    db.runCommand({enableSharding:"<dbname>"})
    #或者(啓用test庫的分片)
    sh.enableSharding('test')

#4. 對一個集合進行分片(key爲片件，指定爲片件的字段需要索引，punique表示對shard-key的唯一性的約束)
    db.user.ensureIndex({name:1})
    db.runCommand({shardcollection:"dbname.cname", key:{"userid":1}, unique:<true/false>})
    #或者
    db.user.ensureIndex({name:1})
    sh.shardCollection("test.user", {name:1})

#5. 如果要加驗證，官網說只要在mongos上操作即可，簡單地添加一個用戶：
    use test
    db.createUser({
        user:'test',
        pwd:'123456',
        roles:[
            {role:'readWrite',db:'test'}
        ]
    })

#分片測試
#1.查看集合狀態
db.shard_cname.stats()
#2.查看分片狀態
db.printShardingStatus()
#3.在mongos節點插入數據
#for(var i=0; i<1000; i++) db.user.insert({name:String.fromCharCode(i%26+97), age:i})
for (var i=0; i<1000; i++) db.user.insert({name:"zhangsan"+i, age:i})
for (var i=0; i<1000; i++) db.user.insert({name:"lisi"+i, age:i})
#4.查看shard01和shard02兩個節點，可以看到數據已經均攤到這兩個節點上了(mongos節點上是不保存插入數據的)
db.user.find()

刪除分片

#==========================================================
#刪除分片(在mongos節點操作)
use admin
#下面這句會立即返回，實際在後臺執行
db.runCommand({removeshard:"172.16.127.130:27017"})
#我們可以反覆執行上面語句，查看執行結果
db.runCommand({removeshard:"172.16.127.130:27017"})
{ msg: "draining ongoing" , state: "ongoing", remaining: { chunks: 42, dbs : 1 }, ok: 1 }
#從上面可以看到，正在遷移，還剩下42塊沒遷移完，當remain爲0之後，這一步就結束了，因爲我們有兩個分片節點，shard01從集羣被移除之後，shard01（1002條）的分片數據全部被遷往到了shard02(1001+1002條)，但是shard01物理節點上的數據背不會被刪除

#有一些分片上保存上一些unsharded data，需要遷移到其他分片上，
#可以用sh.status()查看分片上是否有unsharded data，如果有則顯示：
{  "_id" : "test",  "primary" : "shard0000",  "partitioned" : true }

#用下面的命令遷移(只有全部遷移完上面的命令纔會返回，執行完畢後shard01的未分片的1002條數據也被刪除了)
mongos> db.runCommand({movePrimary:"test", to:"shard0001"})
shards:
        {"_id":"shard0000", "host":"172.16.127.130:27017", "state":1, "draining": true }
        {"_id":"shard0001", "host":"172.16.127.131:27017", "state":1 }
databases:
        { "primary" : "shard0001:172.16.127.131:27017", "ok" : 1 }

#最後運行命令進行徹底刪除
db.runCommand({removeshard:"172.16.127.130:27017"})
sh.status()
shards:
        {"_id":"shard0001", "host":"172.16.127.131:27017", "state":1}
databases:
        {"_id":"test", "primary":"shard0001", "partitioned":true }

添加被刪除的分片

#重新添加剛纔刪除的分片，將遇到以下錯誤，提示test數據庫已經存在
db.runCommand({addShard:"172.16.127.130:27017"})
{
  "code" : 96,
  "ok" : 0,
  "errmsg" : "can't add shard '172.16.127.130:27017' 
  "because a local database 'test' exists in another shard0001"
}
#這時，就需要通過MongoDB shell連接到shard01實例，刪除test數據庫，然後重新添加
use test
db.dropDatabase()
#回到mongos節點
use admin
mongos> sh.addShard('172.16.127.130:27017')
{
        "code" : 11000,
        "ok" : 0,
        "errmsg" : "E11000 duplicate key error collection: 
            "admin.system.version index: _id_ dup key: { : \"shardIdentity\" }"
}
#這時候再連接到shard01節點，刪除admin.system.version集合中記錄
db.system.version.remove({})
db.system.version.remove({"_id":"shardIdentity"})
WriteResult({
        "nRemoved" : 0,
        "writeError" : {
                "code" : 40070,
                "errmsg" : "cannot delete shardIdentity document while in --shardsvr mode"
        }
})
#刪除時報錯，意思是說不能在分片模式下刪除這張表中的這條記錄，然後我們關閉shard01，然後以非shardsvr的方式啓動，刪除這條記錄後，再以shardsvr方式啓動
db.shutdownServer()
mongodb-3.4.4/bin/mongod -f mongodb-3.4.4/conf/mongod.conf 
use admin
db.system.version.remove({})
db.shutdownServer()
mongodb-3.4.4/bin/mongod -f mongodb-3.4.4/conf/mongod.conf --shardsvr
#最後添加之前被刪除的分片shard01，大功告成
db.runCommand({addShard:"172.16.127.130:27017"})
{ "shardAdded" : "shard0002", "ok" : 1 }

關於兩個概念的說明：

片件（shardid）：
當設置分片時，需要從集合裏面選擇一個或幾個鍵，把選擇出來的鍵作爲數據拆分的依據，這個鍵叫做片鍵或複合片鍵。選好片鍵後，MongoDB將不允許插入沒有片鍵的文檔，但是允許不同文檔的片鍵類型不一樣。

塊（chunk）：
在一個shard server內部，MongoDB還是會把數據分爲chunks，每個chunk（默認64m）代表這個shard server內部一部分數據。chunk的產生，會有以下兩個用途：
    - Splitting：當一個chunk的大小超過配置中的chunk size時，MongDB的後臺
                進程會把這個chunk切分成更小的chunk，從而避免chunk過大的情況
    - Balancing：在MongoDB中，balancer是一個後臺進程，負責chunk的遷移，
                從而均衡各個shard server的負載

數據塊的拆分（split）和均衡(balance)：