M103: Basic Cluster Administration chapter 3 Sharding学习记录

运行环境

操作系统：windows 10 家庭中文版
Mongodb ：Mongodb 3.4

Mongodb安装路径：E:>MongoDB\Server\3.4\bin\
Mongodb存储路径：E:>MongoDB\data

课后问题

lab - Configure a Sharded Cluster

In this lab, you will turn your replica set into one shard in a sharded cluster. To begin your sharded cluster configuration in MongoDB, you will need to do the following:

Bring up config servers
Bring up mongos
Enable sharding on m103-repl
Add m103-repl as the primary shard in the cluster

1.Bring up the config server replica set (CSRS)

Config servers store all of the metadata for a sharded cluster, making them a necessary part of any sharded cluster. In this lab you will bring up a replica set of three config servers (m103-csrs) to store this metadata.

Here are the requirements for all three config servers:

Type	Primary	Secondary	Secondary
Port	26001	26002	26003
DBPath	/var/mongodb/db/csrs1	/var/mongodb/db/csrs2	/var/mongodb/db/csrs3
LogPath	/var/mongodb/db/csrs1/mongod.log	/var/mongodb/db/csrs2/mongod.log	/var/mongodb/db/csrs3/mongod.log
replSetName	m103-csrs	m103-csrs	m103-csrs
clusterRole	configsvr	configsvr	configsvr
keyFile	/var/mongodb/pki/m103-keyfile	/var/mongodb/pki/m103-keyfile	/var/mongodb/pki/m103-keyfile

Here is the config file for the primary config server:

sharding:clusterRole: configsvr
replication:replSetName: m103-csrs
security:keyFile: /var/mongodb/pki/m103-keyfile
net:bindIp: localhost,192.168.103.100port: 26001
systemLog:destination: filepath: /var/mongodb/db/csrs1/mongod.loglogAppend: true
processManagement:fork: true
storage:dbPath: /var/mongodb/db/csrs1

You may use this config file for your primary config server, but you will need to make two more to complete the replica set.

Notice that the CSRS has the same keyFile as the data-bearing replica set m103-repl. Because m103-repl uses internal keyfile authentication, all other mongod and mongos processes in your cluster must use internal keyfile authentication with the same keyfile.

When initializing m103-csrs, remember that keyfile authentication implies client authentication. This means that while no users are configured, the CSRS will only allow connections through the localhost.

As a reminder, here are the login credentials of the admin user from previous labs:

Role: root on admin database
Username: m103-admin
Password: m103-pass

2.Bring up the mongos

Once the CSRS is running, you can start up the mongos process. Here is the config file for the mongos:

sharding:configDB: m103-csrs/192.168.103.100:26001
security:keyFile: /var/mongodb/pki/m103-keyfile
net:bindIp: localhost,192.168.103.100port: 26000
systemLog:destination: filepath: /var/mongodb/db/mongos.loglogAppend: true
processManagement:fork: true

If your CSRS already has the m103-admin user when mongos is started, mongos will inherit that user. You will be able to authenticate to mongos immediately as m103-admin.

3.Reconfigure m103-repl

To enable m103-repl to be a shard, you must reconfigure the nodes in your replica set with the following lines added to each of their config files:

sharding:clusterRole: shardsvr
storage:wiredTiger:engineConfig:cacheSizeGB: .1

The clusterRole: shardsvr section tells mongod that the node can be used in a sharded cluster.

The cacheSizeGB: .1 section restricts the memory usage of each running mongod. Note that this is not good practice. However, in order to run a sharded cluster inside a virtual machine with only 2GB of memory, certain adjustments must be made.

All three nodes of the m103-repl replica set will need to be restarted with sharding enabled, but given that this is a replica set, you can do this operation without any downtime. This replica set will become the primary shard in your sharded cluster.

4.Add m103-repl as the first shard

Once m103-repl has sharding enabled, you can add it as the primary shard with:

sh.addShard("m103-repl/192.168.103.100:27001")

Check the output of sh.status() to make sure it’s included as a shard.

Now run the validation script and enter the validation key you receive below. If you receive an error, it should give you some idea of what went wrong.

validate_lab_first_sharded_cluster

Enter answer here:

解答

1. 配置服务器副本集（CSRS）

以下是m103-csrs的其余两个配置文件：

CSRS Node 2:

sharding:clusterRole: configsvr
replication:replSetName: m103-csrs
security:keyFile: /var/mongodb/pki/m103-keyfile
net:bindIp: localhost,192.168.103.100port: 26002
systemLog:destination: filepath: /var/mongodb/db/csrs2.loglogAppend: true
processManagement:fork: true
storage:dbPath: /var/mongodb/db/csrs2

CSRS Node 3:

sharding:clusterRole: configsvr
replication:replSetName: m103-csrs
security:keyFile: /var/mongodb/pki/m103-keyfile
net:bindIp: localhost,192.168.103.100port: 26003
systemLog:destination: filepath: /var/mongodb/db/csrs3.loglogAppend: true
processManagement:fork: true
storage:dbPath: /var/mongodb/db/csrs3

一旦所有三个mongod进程都运行完毕，我们可以像调用其他任何副本一样调用m103-csrs。

2. 配置mongos

一旦我们拥有了mongos进程的配置文件（mongos.conf），我们就可以导航到它所在的目录并调出mongos：

mongos -f mongos.conf

3. Reconfigure m103-repl

以下是m103-repl中三个节点的更新配置文件:

Node 1:

storage:dbPath: /var/mongodb/db/1wiredTiger:engineConfig:cacheSizeGB: .1
net:bindIp: 192.168.103.100,localhostport: 27001
security:keyFile: /var/mongodb/pki/m103-keyfile
systemLog:destination: filepath: /var/mongodb/db/mongod1/mongod.loglogAppend: true
processManagement:fork: true
operationProfiling:slowOpThresholdMs: 50
replication:replSetName: m103-repl
sharding:clusterRole: shardsvr

Node 2:

storage:dbPath: /var/mongodb/db/2wiredTiger:engineConfig:cacheSizeGB: .1
net:bindIp: 192.168.103.100,localhostport: 27002
security:keyFile: /var/mongodb/pki/m103-keyfile
systemLog:destination: filepath: /var/mongodb/db/mongod2/mongod.loglogAppend: true
processManagement:fork: true
operationProfiling:slowOpThresholdMs: 50
replication:replSetName: m103-repl
sharding:clusterRole: shardsvr

Node 3:

storage:dbPath: /var/mongodb/db/3wiredTiger:engineConfig:cacheSizeGB: .1
net:bindIp: 192.168.103.100,localhostport: 27003
security:keyFile: /var/mongodb/pki/m103-keyfile
systemLog:destination: filepath: /var/mongodb/db/mongod3/mongod.loglogAppend: true
processManagement:fork: true
operationProfiling:slowOpThresholdMs: 50
replication:replSetName: m103-repl
sharding:clusterRole: shardsvr

重启所有三个mongod进程，分片将自动应用在 m103-repl。

4. 添加m103-repl作为第一个碎片

从我们mongos的mongo shell中，我们可以运行以下命令将我们的副本集添加为此群集中的分片：

sh.addShard("m103-repl/192.168.103.100:27001")

请注意，我们只需要在新分片的副本集中指定一个节点。这个命令的响应应该包含这样的内容：

{"shardAdded" : "m103-repl"
}

运行sh.status（）应该在集群中显示我们新的分片：

shards:{  "_id" : "m103-repl",  "host" : "m103-repl/192.168.103.100:27001,192.168.103.100:27002,192.168.103.100:27003",  "state" : 1 }

从此之后，所有的CRUD操作都将通过mongos。我们不需要连接到单独的碎片，因为mongos会为我们提供查询。

执行脚本求出结果：

vagrant@m103:~$ validate_lab_first_sharded_cluster
5a57de1cb1575291ce6e560a

lab - Shard a Collection

At this point, your cluster is now configured for sharding. You should already have a CSRS, mongos, and primary shard.

In this lab, you will do the following with your cluster:

Add a second shard
Import a dataset onto your primary shard
Choose a shard key and shard your collection

1. Adding a Second Shard

Your second shard m103-repl-2 will be a three-node replica set, just like your primary shard.

You can create the data paths for each node in m103-repl-2 with the following command:

mkdir /var/mongodb/db/{4,5,6}

Here are the config files for this replica set:

Node 4:

storage:dbPath: /var/mongodb/db/4wiredTiger:engineConfig:cacheSizeGB: .1
net:bindIp: 192.168.103.100,localhostport: 27004
security:keyFile: /var/mongodb/pki/m103-keyfile
systemLog:destination: filepath: /var/mongodb/db/4/mongod.loglogAppend: true
processManagement:fork: true
operationProfiling:slowOpThresholdMs: 50
replication:replSetName: m103-repl-2
sharding:clusterRole: shardsvr

Node 5:

storage:dbPath: /var/mongodb/db/5wiredTiger:engineConfig:cacheSizeGB: .1
net:bindIp: 192.168.103.100,localhostport: 27005
security:keyFile: /var/mongodb/pki/m103-keyfile
systemLog:destination: filepath: /var/mongodb/db/5/mongod.loglogAppend: true
processManagement:fork: true
operationProfiling:slowOpThresholdMs: 50
replication:replSetName: m103-repl-2
sharding:clusterRole: shardsvr

Node 6:

storage:dbPath: /var/mongodb/db/6wiredTiger:engineConfig:cacheSizeGB: .1
net:bindIp: 192.168.103.100,localhostport: 27006
security:keyFile: /var/mongodb/pki/m103-keyfile
systemLog:destination: filepath: /var/mongodb/db/6/mongod.loglogAppend: true
processManagement:fork: true
operationProfiling:slowOpThresholdMs: 50
replication:replSetName: m103-repl-2
sharding:clusterRole: shardsvr

We can now initialize m103-repl-2 as a normal replica set.

Now exit the mongo shell and connect to mongos. We can add m103-repl-2 as a shard with the following command:

sh.addShard("m103-repl-2/192.168.103.100:27004")

The output of sh.status() should now reflect the new shard.

2. Importing Data onto the Primary Shard

The dataset products.json is contained in your Vagrant box, in the /dataset/ directory. You can import this dataset into mongos with the following command:

mongoimport --drop /dataset/products.json --port 26000 -u "m103-admin" \
-p "m103-pass" --authenticationDatabase "admin" \
--db m103 --collection products

You can verify that the entire dataset was imported by querying the m103 database on mongos. The collection products should contain exactly 516784 documents.

3. Sharding the Collection

Before you can shard your new products collection, you must enable sharding on the m103 database:

sh.enableSharding("m103")

Once you’ve done this, it’s time to choose a shard key on a single field in the products collection. To do this, you should review the qualities of a good shard key in the docs and the following information about the products collection:

_id is a serial number for each product in this collection, rarely used in queries but important for internal MongoDB usage
sku (Stock Keeping Unit) is a randomly generated integer unique to each product - this is commonly used to refer to specific products when updating stock quantities
name is the name of the product as it appears in the store and on the website
type is the type of product, with the possible values “Bundle”, “Movie”, “Music” and “Software”
regularPrice is the regular price of the product, when there is no sale - this price changes every season
salePrice is the price of a product during a sale - this price changes arbitrarily based on when sales occur
shippingWeight is the weight of the product in kilograms, ranging between 0.01 and 1.00 - this value is not known for every product in the collection

If you want a better understanding of the distribution and the nature of the fields and their types, you can do so using Compass.

Once you’ve chosen a shard key, you must create an index on the shard key field:

db.products.createIndex({"<shard_key>": 1})

Once the index is created, shard the collection with the following command:

db.adminCommand( { shardCollection: "m103.products", key: { <shard_key>: 1 } } )

Choosing the Correct Shard Key

Now run the validation script and enter the validation key you receive below:

validate_lab_shard_collection

If you chose the wrong shard key, the validation script will give you an error. However, if you already imported the dataset, you must drop the collection and reimport it in order to choose a different shard key.

Enter answer here:

解答

1. 添加第二个分片

一旦m103-repl-2启动并运行，我们退出mongo shell并连接到mongos。我们可以使用以下命令添加新的分片：

sh.addShard("m103-repl-2/192.168.103.100:27004")

sh.status（）的输出应该如下所示：

shards:{  "_id" : "m103-repl",  "host" : "m103-repl/192.168.103.100:27001,192.168.103.100:27002,192.168.103.100:27003",  "state" : 1 }{  "_id" : "m103-repl-2",  "host" : "m103-repl-2/192.168.103.100:27004,192.168.103.100:27005,192.168.103.100:27006",  "state" : 1 }

2. Importing Data onto the Primary Shard

将数据导入分片群集始终使用mongos完成。我们可以使用以下命令将数据集导入到m103.products中：

mongoimport /dataset/products.json --port 26000 -u "m103-admin" \
-p "m103-pass" --authenticationDatabase "admin" \
--db m103 --collection products

我们可以验证整个数据集是用count（）导入的：

use m103
db.products.count()
516784

516784为所求

3. 集合分片

我们可以用findOne（）来查看所有潜在的分片键：

use m103
db.products.findOne()

输出：

{"_id" : ObjectId("573f706ff29313caab7d7395"),"sku" : 1000000749,"name" : "Gods And Heroes: Rome Rising - Windows [Digital Download]","type" : "Software","regularPrice" : 39.95,"salePrice" : 39.95,"shippingWeight" : "0.01"
}

确定正确分片键的技巧是消除过程。我们可以排除不符合基数，频率，变化率和查询模式规则的潜在分片密钥。

我们可以排除_id，因为它很少用在查询中，同样的在索引上建分片会浪费掉索引。另外，它是单调递增的，所以它会一直持续增长，并在我们的集群中引起热点。

我们可以排除type字段，因为这个字段没有高基数。实际上，它只有四个可能的值 - 我们可以通过在m103.products上运行以下命令来看到这一点：

db.products.distinct("type")

我们可以排除regularPrice和salePrice，因为它们都可能会发生变化，分片键是不可变的。如果我们在这些字段中的一个字段上分片，则对该字段的任何未来更新都会导致错误。

我们可以排除shippingWeight，因为集合中的每个文档都必须具有分片键，而不是这里的每个文档都有一个shippingWeight。

从这里，我们只有两个好的分片键：
name
sku

这两个字段都具有高基数，低频率和非单调递增值。它们也常用于查询。

验证脚本将接受任一解决方案。

在我们分片之前，我们必须在m103数据库上启用分片：

sh.enableSharding("m103")

然后，我们必须在分片键上创建一个索引（此题中使用name字段):

db.products.createIndex({"name": 1})

为了在name字段分片，我们指定集合：

db.adminCommand( { shardCollection: "m103.products", key: { name: 1 } } )

选择正确的分片键

要选择不同的分片键，必须删除该集合，并且必须重新导入数据集。

从mongos shell中，我们可以使用以下命令删除产品集合：

use m103
db.products.drop()

现在我们退出mongodb shell并重新导入数据集：

mongoimport /dataset/products.json --port 26000 -u "m103-admin" \
-p "m103-pass" --authenticationDatabase "admin" \
--db m103 --collection products

现在我们可以再次分割集合，因为数据集被导入到主分片上。

执行题目函数：

vagrant@m103:~$ validate_lab_shard_collection
5a621149d083824c6d889865

lab - Documents in Chunks

Lab Prerequisites

This lab assumes that the m103.products collection is sharded on sku. If you sharded on name instead, you must reimport the dataset and shard it on sku. Here are the instructions to do this:

1. Drop the collection m103.products and reimport the dataset:

mongoimport --drop /dataset/products.json --port 26000 -u "m103-admin" \
-p "m103-pass" --authenticationDatabase "admin" \
--db m103 --collection products

2. Create an index on sku:

db.products.createIndex({"sku":1})

3. Shard the collection on sku:

db.adminCommand({shardCollection: "m103.products", key: {sku: 1}})

Once you’ve sharded your cluster on sku, any queries that use sku will be routed by mongos to the correct shards.

Lab Description

In this lab, you are going to use the sharded cluster you created earlier in this lesson and derive which chunk a given document resides.

Connect to the mongos and authenticate as the m103-admin user you created in an earlier lab.

Once connected, execute the following operation:

db.getSiblingDB("m103").products.find({"sku" : 21572585 })

Locate the chunk that the specified document resides on and pass the full chunk ID to the validation script provided in the handout.

hint sh.status() does not provide sufficient information for this lab. Look in the config database for the collection that stores all chunk information. Think in ranges - you want to find the chunk whose range is min <= key < max.

validate_lab_document_chunks <chunk-id>

Enter the validation key you receive below. The script returns verbose errors that should provide you with guidance on what went wrong.

Enter answer here:

解答

首先，以m103-admin用户身份连接到mongos：

mongo -u m103-admin -p mypass123 --authenticationDatabase admin --port 26000

使用sh.status（）来确认产品集合在sku上分片。

由于我们的分片键的值是正常整数，因此可以直观地识别文档属于哪个块。但是，sh.status（）不提供必需的块ID。

查询config.chunks集合以确定哪个块包含相关文档。首先，确保你只过滤属于m103.products命名空间的块：

db.getSiblingDB("config").chunks.find({"ns" : "m103.products"}
)

此查询的结果是与分片产品集合关联的所有块。我们可以通过查看min.sku和max.sku字段来直观地识别我们的文档属于哪个块，这些字段定义了与该块关联的碎片键值的包含最小和最大范围。

但是，对于较大的数据集，可能会有数百或数千个数据块，使视觉识别耗时或不现实。相反，我们可以针对config.chunks数据库执行查询以确定min <= sku

db.getSiblingDB("config").chunks.find({"ns" : "m103.products",$expr: {$and : [{$gte : [ 21572585, "$min.sku"]},{$lt : [21572585, "$max.sku"]}]}}
)

expr允许我们在普通查询中使用聚合运算符和语法。如果没有expr允许我们在普通查询中使用聚合运算符和语法。如果没有 expr允许我们在普通查询中使用聚合运算符和语法。如果没有 expr，我们将无法使用min.sku和min.sku和 min.sku和 max.sku变量表达式来表示任何给定产品的最小值或最大值。查询返回文档所在的单个块：

{"_id" : "m103.products-sku_19765188","ns" : "m103.products","min" : {"sku" : 19765188},"max" : {"sku" : 22935319},"shard" : "shard2","lastmod" : Timestamp(1, 4),"lastmodEpoch" : ObjectId("5a6103511d9376be96849296")
}

_id字段的值是本实验所需的块ID。

执行脚本函数：

5ac28a604c7baf1f5c25d51b

lab - Detect Scatter Gather Queries

Lab Prerequisites

This lab assumes that the m103.products collection is sharded on sku. If you sharded on name instead, you must reimport the dataset and shard it on sku. Here are the instructions to do this:

1. Drop the collection m103.products and reimport the dataset:

mongoimport --drop /dataset/products.json --port 26000 -u "m103-admin" \
-p "m103-pass" --authenticationDatabase "admin" \
--db m103 --collection products

2. Create an index on sku:

db.products.createIndex({"sku":1})

3. Shard the collection on sku:

db.adminCommand({shardCollection: "m103.products", key: {sku: 1}})

Once you’ve sharded your cluster on sku, any queries that use sku will be routed by mongos to the correct shards.

In addition to the index on sku, you must create an index on shippingWeight for this lab. You can create this index with the following command:

db.products.createIndex({"shippingWeight": 1})

Lab Description

In this lab, you will use the output of the explain() command to distinguish between routed queries (routed by mongos) and scatter gather queries (sent to all shards).

Here are a few definitions regarding the output of explain():

SHARDING_FILTER: The step performed by mongos used to make sure that documents fetched from a particular shard are supposed to be from that shard. To do this, mongos compares the shard key of the document with the metadata on the config servers.
IXSCAN: An index scan, used to scan through index keys.
FETCH: A document fetch, used to retrieve an entire document because one or more of the fields is necessary.

You can find more information about explain() in the official MongoDB documentation.

Now, given the explain() output of the following two queries:

Query 1:

db.products.explain().find({"sku": 23153496})

Query 2:

db.products.explain().find({"shippingWeight": 1.00})

Which of the following is true?

Check all that apply:

Both queries perform a sharding filter before the document fetch.
Query 2 uses the shard key.
Query 2 performs a collection scan.
Query 1 performs a document fetch.
Both queries perform an index scan before the sharding filter.

解答

Both queries perform a sharding filter before the document fetch.

这两个查询在文档提取之前执行分片过滤器。错误。
查询1使用分片键，因此从索引扫描返回的值是分片键本身的值。这可以立即用在分片过滤器中，该过滤器将分片键的值与块范围进行比较。在分片过滤器之后，文档的其余部分被提取并返回。
但是，查询2使用shippingWeight，它不是分片键。因此，查询2必须获取整个文档以检索分片键的值，然后将该值传递给分片过滤器。

Query 2 uses the shard key.

查询2使用分片键。错误。
查询2不使用分片键，因为分片键不在查询谓词中。

Query 2 performs a collection scan.

查询2执行收集扫描。错误。
我们之前在本实验中为shippingWeight创建了一个索引。这意味着查询2可以执行索引扫描而不是集合扫描，即使shippingWeight不是分片键。

Query 1 performs a document fetch.

查询1执行文档提取。正确。
分片键sku上必须有索引，但查询1仍然返回整个文档，而不仅仅是sku。为了检索不在索引中的字段，查询1必须执行文档提取。

Both queries perform an index scan before the sharding filter.

两个查询都在分片过滤器之前执行索引扫描。正确。
分片过滤器确保每个分片返回的文档不是孤立文档。它通过比较分片键的值和特定分片内的分块范围来实现。
为了最小化要检查的文档数量，只有与查询相匹配的文档（即索引扫描返回的文档）将与块范围进行比较。

所以最后答案为：

Query 1 performs a document fetch.
Both queries perform an index scan before the sharding filter.