"localhost:30001" : [
"cursor" : "BasicCursor",
"nscanned" : 31303,
"nscannedObjects" : 31303,
"n" : 31303,
"millis" : 37,
"nYields" : 0,
"nChunkSkips" : 0,
"isMultiKey" : false,
"indexOnly" : false,
"indexBounds" : {
"localhost:30002" : [
"cursor" : "BasicCursor",
"nscanned" : 31304,
"nscannedObjects" : 31304,
"n" : 31304,
"millis" : 36,
"nYields" : 0,
"nChunkSkips" : 0,
"isMultiKey" : false,
"indexOnly" : false,
"indexBounds" : {
"n" : 100000,
"nChunkSkips" : 0,
"nYields" : 0,
"nscanned" : 100000,
"nscannedObjects" : 100000,
"millisTotal" : 111,
"millisAvg" : 37,
"numQueries" : 3,
"numShards" : 3
As you can see from this explain, this query has to visit all three shards to find all the
data. In general, if we are not using the shard key in the query, mongos will have to send
the query to every shard.
A One-Minute Test Setup | 239
Reader combine pdf pages - Merge, append PDF files in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Provide C# Demo Codes for Merging and Appending PDF Document
add two pdf files together; add pdf together
Reader combine pdf pages - VB.NET PDF File Merge Library: Merge, append PDF files in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
VB.NET Guide and Sample Codes to Merge PDF Documents in .NET Project
acrobat merge pdf files; batch pdf merger online
Queries that contain the shard key and can be sent to a single shard or subset of shards
are called targeted queries. Queries that must be sent to all shards are called scatter-
gather queries: mongos scatters the query to all the shards and then gathers up the results.
Once you are finished experimenting, shut down the set. Switch back to your original
shell and hit Enter a few times to get back to the command line. Then run clus
ter.stop() to cleanly shut down all of the servers:
> cluster.stop()
If you are ever unsure of what an operation will do, it can be helpful to use ShardingT
est to spin up a quick local cluster and try it out.
240 | Chapter 13: Introduction to Sharding
C# PDF: C#.NET PDF Document Merging & Splitting Control SDK
List<BaseDocument> docList, String destFilePath) { PDFDocument.Combine(docList, destFilePath); }. For example, if the target PDF file has 8 pages and you
acrobat split pdf into multiple files; acrobat combine pdf
C# PDF File Split Library: Split, seperate PDF into multiple files
which C# developers can split target PDF document file by specifying a page or pages. If needed, developers can also combine generated split PDF document files
acrobat merge pdf; reader create pdf multiple files
Configuring Sharding
In the previous chapter, you set up a “cluster” on one machine. This chapter covers how
to set up a more realistic cluster and how each piece fits, in particular:
• How to set up config servers, shards, and mongos processes
• How to add capacity to a cluster
• How data is stored and distributed
When to Shard
Deciding when to shard is a balancing act. You generally do not want to shard too early
because it adds operational complexity to your deployment and forces you to make
design decisions that are difficult to change later. On the other hand, you do not want
to wait too long to shard because it is difficult to shard an overloaded system without
In general, sharding is used to:
• Increase available RAM
• Increase available disk space
• Reduce load on a server
• Read or write data with greater throughput than a single mongod can handle
Thus, good monitoring is important to decide when sharding will be necessary. Care‐
fully measure each of these metrics. Generally people speed toward one of these bot‐
tlenecks much faster than the others, so figure out which one your deployment will need
to provision for first and make plans well in advance about when and how you plan to
convert your replica set.
C# Word - Merge Word Documents in C#.NET
Combine and Merge Multiple Word Files into One Using C#. This part illustrates how to combine three Word files into a new file in C# application.
pdf combine two pages into one; append pdf files reader
C# PowerPoint - Merge PowerPoint Documents in C#.NET
Combine and Merge Multiple PowerPoint Files into One Using C#. This part illustrates how to combine three PowerPoint files into a new file in C# application.
acrobat reader merge pdf files; merge pdf online
As you add shards, performance should increase roughly linearly per shard up to hun‐
dreds of shards. However, you will usually experience a performance drop if you move
from a non-sharded system to just a few shards. Due to the overhead of moving data,
maintaining metadata, and routing, small numbers of shards will generally have higher
latency and may even have lower throughput than a non-sharded system. Thus, you
may want to jump directly to three or more shards.
Starting the Servers
The first step in creating a cluster is to start up all of the processes required. As mentioned
in the previous chapter, we need to set up the mongos and the shards. There’s also a third
component, the config servers, which are an important piece. They are normal mon
god servers that store the cluster configuration: who the shards are, what collections are
sharded by, and the chunks.
Config Servers
Config servers are the brains of your cluster: they hold all of the metadata about which
servers hold what data. Thus, they must be set up first and the data they hold is ex‐
tremely important: make sure that they are running with journaling enabled and that
their data is stored on non-ephemeral drives. Each config server should be on a separate
physical machine, preferable geographically distributed.
The config servers must be started before any of the mongos processes, as mongos pulls
its configuration from them. Config servers are standalone mongod processes, so you
can start them up the same way you would a “normal” mongod:
$ # server-config-1
$ mongod --configsvr --dbpath /var/lib/mongodb -f /var/lib/config/mongod.conf
$ # server-config-2
$ mongod --configsvr --dbpath /var/lib/mongodb -f /var/lib/config/mongod.conf
$ # server-config-3
$ mongod --configsvr --dbpath /var/lib/mongodb -f /var/lib/config/mongod.conf
When you start up config servers, do not use the --replSet option: config servers are
not members of a replica set. mongos writes to all three config servers and does a two-
phase-commit-type operation to ensure that all three servers have the same data, so all
three must be writable (in a replica set, only the primary is writable by clients).
242 | Chapter 14: Configuring Sharding
VB.NET PDF Page Insert Library: insert pages into PDF file in vb.
add and insert one or multiple pages to existing RasterEdge XDoc.PDF SDK is compatible with Visual Studio ways to create VB application to combine .NET Imaging
reader combine pdf; reader combine pdf pages
VB.NET PDF: Use VB.NET Code to Merge and Split PDF Documents
VB.NET program and it includes all pages information in APIs for Merging PDF Documents in VB.NET. Private Sub Combine(source As List(Of BaseDocument), destn As
acrobat combine pdf files; break pdf into multiple files
A common question is why three config servers? The reasoning behind
the choice is that one config server is not enough: you need redundancy.
Conversely, you don’t want too many config servers, since confirming
actions with all of them would be prohibitively time consuming. Also,
if any of them goes down, you cluster’s metadata becomes read-only.
Thus, three was chosen as enough to give redundancy but not have the
downsides of having too many servers. It will probably be made more
flexible in the future.
The --configsvr option indicates to the mongod that you are planning to use it as a
config server. It is not strictly required, as all it does is change the default port mon
god listens on to 27019 and the default data directory to /data/configdb (you can override
either or both of these settings with --port and --dbpath).
It is recommended that you use this option because it makes it easier to tell, operation‐
ally, what these servers are doing. If you start up your config servers without the --
configsvr option, though, it’s not a problem.
In terms of provisioning, config servers do not need much space or many resources. A
generous estimate is 1 KB of config server space per 200 MB of actual data: they really
are just tables of contents. As they don’t use many resources, you can deploy config
servers on machines running other things, like app servers, shard mongods, or mon
gos processes.
If all of your config servers are lost, you must dig through the data on your shards to
figure out which data is where. This is possible, but slow and unpleasant. Take frequent
backups of config server data. Always take a backup of your config servers before per‐
forming any cluster maintenance.
The mongos Processes
Once you have three config servers running, start a mongos process for your application
to connect to. mongos processes need to know where the config servers are, so you must
always start mongos with the --configdb option:
$ mongos --configdb config-1:27019,config-2:27019,config-3:27019 \
> -f /var/lib/mongos.conf
By default, mongos runs on port 27017. Note that it does not need a data directory
(mongos holds no data itself, it loads the cluster configuration from the config servers
on startup). Make sure that you set logpath to save the mongos log somewhere safe.
You can start as many mongos processes as you’d like. A common setup is one mongos
process per application server (running on the same machine as the application server).
Starting the Servers | 243
VB.NET Image: Barcode Reader SDK, Read Intelligent Mail from Image
How to combine PDF Document Processing DLL with Barcode As String = FolderName & "Sample.pdf" Dim reImage own customized Word Intelligent Mail Barcode Reader.
attach pdf to mail merge; add pdf files together online
VB.NET PowerPoint: Merge and Split PowerPoint Document(s) with PPT
Just like we need to combine PPT files, sometimes, we also the split PPT document will contain slides/pages 1-4 If you want to see more PDF processing functions
break pdf file into multiple files; c# merge pdf files
Each mongos must use the exact same list of config servers, down to the order in which
they are listed.
Adding a Shard from a Replica Set
Finally, you’re ready to add a shard. There are two possibilities: you may have an existing
replica set or you may be starting from scratch. We will cover starting from an existing
set below. If you are starting from scratch, initialize an empty set and follow the steps
If you already have a replica set serving your application, that will become your first
shard. To convert it into a shard, you are going to tell the mongos the replica set name
and give it a seed list of replica set members.
For example, if you have a replica set named spock on server-1, server-2, server-3,
server-4, and server-5, you would connect to the mongos and run:
> sh.addShard("spock/server-1:27017,server-2:27017,server-4:27017")
"added" : "spock/server-1:27017,server-2:27017,server-4:27017",
"ok" : true
You can specify all the members of the set, but you do not have to. mongos will
automatically detect any members that were not included in the seed list. If you run
sh.status(), you’ll see that MongoDB soon lists the shard as "spock/server-
The set name, “spock”, is taken on as an identifier for this shard. If we ever want to
remove this shard or migrate data to it, we’ll use “spock” to describe it. This works better
than using a specific server (e.g., server-1), as replica set membership and status can
change over time.
Once you’ve added the replica set as a shard you can convert your application from
connecting to the replica set to connecting to the mongos. When you add the shard,
mongos registers that all the databases in the replica set are “owned” by that shard, so it
will pass through all queries to your new shard. mongos will also automatically handle
failover for your application as your client library would: it will pass the errors through
to you.
Test failing over a shard’s primary in a development environment to ensure that your
application handles the errors received from mongos correctly (they should be identical
to the errors that you receive from talking to the primary directly).
244 | Chapter 14: Configuring Sharding
Once you have added a shard, you must set up all clients to send requests
to the mongos instead of contacting the replica set. Sharding will not
function correctly if some clients are still making requests to the replica
set directly (not through the mongos). Switch all clients to contacting
the mongos immediately after adding the shard and set up a firewall rule
to ensure that they are unable to connect directly to the shard.
There is a --shardsvr option, analogous to the --configsvr option mentioned previ‐
ously. As before, --shardsvr has little practical effect (it changes the default port to
27018) but can be nice to include operationally.
You can also create stand-alone-mongod shards (instead of replica set shards), but this
is not recommend for production (ShardingTest in the previous chapter did this). To
add a single mongod as a shard simply specify the hostname of the standalone server in
the call to addShard:
> sh.addShard("some-server:27017")
Stand-alone-server shards default to being named shard0000, shard0001, and so on. If
you plan to switch to replica sets later, start with one-member replica sets instead of
standalone servers. Switching from a stand-alone-server shard to a replica set requires
downtime (see “Server Administration” on page 285).
Adding Capacity
When you want to add more capacity, you’ll need to add more shards. To add a new,
empty shard, create a replica set. Make sure it has a distinct name from any of your other
shards. Once it is initialized and has a primary, add it to your cluster by running the
addShard command through mongos, specifying the new replica set’s name and its hosts
as seeds.
If you have several existing replica sets that are not shards, you can add all of them as
new shards in your cluster so long as they do not have any database names in common.
For example, if you had one replica set with a “blog” database, one with a “calendar”
database, and one with the “mail”, “tel”, and “music” databases, you could add each
replica set as a shard and end up with a cluster with three shards and five databases.
However, if you had a fourth replica set that also had a database named “tel”, mongos
would refuse to add it to the cluster.
Sharding Data
MongoDB won’t distribute your data automatically until you tell it how to do so. You
must explicitly tell both the database and collection that you want them to be distributed.
Starting the Servers | 245
For example, suppose we want to shard the artists collection in the music database on
the "name" key. First, we enable sharding for the database, music:
> db.enableSharding("music")
Sharding a database is always prerequisite to sharding one of its collections.
Once you’ve enabled sharding on the database level, you can shard a collection by run‐
ning sh.shardCollection:
> sh.shardCollection("music.artists", {"name" : 1})
Now the collection will be sharded by the "name" key. If you are sharding an existing
collection there must be an index on the "name" field; otherwise the shardCollec
tion call will return an error. If you get an error, create the index (mongos will return
the index it suggests as part of the error message) and retry the shardCollection
If the collection you are sharding does not yet exist, mongos will automatically create
the shard key index for you.
The shardCollection command splits the collection into chunks, which are the unit
MongoDB uses to move data around. Once the command returns successfully, Mon‐
goDB will begin balancing the collection across the shards in your cluster. This process
is not instantaneous. For large collections it may take hours to finish this initial
How MongoDB Tracks Cluster Data
Each mongos must always know where to find a document, given its shard key. Theo‐
retically, MongoDB could track where each and every document lived, but this becomes
unwieldy for collections with millions or billions of documents. Thus, MongoDB groups
documents into chunks, which are documents in a given range of the shard key. A chunk
always lives on a single shard, so MongoDB can keep a small table of chunks mapped
to shards.
For example, if a user collection’s shard key is {"age" : 1}, one chunk might be all
documents with an "age" field between 3 and 17. If mongos gets a query for {"age" :
5}, it can route the query to the shard where the 3−17 chunk lives.
As writes occur, the number and size of the documents in a chunk might change. Inserts
can make a chunk contain more documents, removes fewer. If we were making a game
for children and preteens, our chunk for ages 3−17 might get larger and larger (one
would hope). Almost all of our users would be in that chunk, and so on a single shard,
somewhat defeating the point of distributing our data. Thus, once a chunk grows to a
certain size, MongoDB automatically splits it into two smaller chunks. In this example,
the chunk might be split into one chunk containing documents with ages 3 through 11
246 | Chapter 14: Configuring Sharding
and the another containing 12 through 17. Note that these two chunks still cover the
entire age range that the original chunk covered: 3−17. As these new chunks grow, they
can be split into still smaller chunks until there is a chunk for each age.
You cannot have chunks with overlapping ranges, like 3−15 and 12−17. If you could,
MongoDB would need to check both chunks when attempting to find an age in the
overlap, like 14. It is more efficient to only have to look in one place, particularly once
chunks begin moving around the cluster.
A document always belongs to one and only one chunk. One consequence to this rule
is that you cannot use an array field as your shard key, since MongoDB creates multiple
index entries for arrays. For example, if a document had [5, 26, 83] in its "age" field, it
would belong in up to three chunks.
A common misconception is that the data in a chunk is physically
grouped on disk. This is incorrect: chunks have no effect on how mon
god stores collection data.
Chunk Ranges
Each chunk is described by the range it contains. A newly sharded collection starts off
with a single chunk and every document lives in this chunk. This chunk’s bounds are
negative infinity to infinity, shown as $minKey and $maxKey in the shell.
As this chunk grows, MongoDB will automatically split it into two chunks, with the
range negative infinity to <some value> and <some value> to infinity. <some value>
is the same for both chunks: the lower chunk contains everything up to (but not in‐
cluding) <some value> and the upper chunk actually contains <some value>.
This may be more intuitive with an example: suppose we were sharding by "age" as
described earlier. All documents with "age" between 3 and 17 are contained on one
chunk: 3 ≤ age < 17. When this is split, we end up with two ranges: 3 ≤ age < 12 on
one chunk and 12 ≤ age < 17 on the other. 12 is called the split point.
Chunk information is stored in the config.chunks collection. If you looked at the contents
of that collection, you’d see documents that looked something like this (some fields have
been omitted for clarity):
> db.chunks.find(criteria, {"min" : 1"max" : 1})
"_id" : "test.users-age_-100.0",
"min" : {"age" : -100},
"max" : {"age" : 23}
"_id" : "test.users-age_23.0",
How MongoDB Tracks Cluster Data | 247
"min" : {"age" : 23},
"max" : {"age" : 100}
"_id" : "test.users-age_100.0",
"min" : {"age" : 100},
"max" : {"age" : 1000}
Based on the config.chunks documents shown, here are a few examples of where various
documents would live:
{"_id" : 123, "age" : 50}
This document would live in the second chunk, as that chunk contains all docu‐
ments with "age" between 23 and 100.
{"_id" : 456, "age" : 100}
This document would live on the third chunk, as lower bounds are inclusive. The
second chunk contains all documents up to "age" : 100, but not any documents
where "age" equals 100.
{"_id" : 789, "age" : -101}
This document would not be in any of these chunks. It would be in some chunk
with a range lower than the first chunk’s.
With a compound shard key, shard ranges work the same way that sorting by the two
keys would work. For example, suppose that we had a shard key on {"username" : 1,
"age" : 1}. Then we might have chunk ranges such as:
"_id" : "test.users-username_MinKeyage_MinKey",
"min" : {
"username" : { "$minKey" : 1 },
"age" : { "$minKey" : 1 }
"max" : {
"username" : "user107487",
"age" : 73
"_id" : "test.users-username_\"user107487\"age_73.0",
"min" : {
"username" : "user107487",
"age" : 73
"max" : {
"username" : "user114978",
"age" : 119
248 | Chapter 14: Configuring Sharding
Documents you may be interested
Documents you may be interested