Sharding Components

In this video we are explaining sharding components

So what are the main components of this sharding? So what is sharding

The following diagram shows the sharding in MongoDB using sharded cluster. So now we can find that here we are having some set of shirts are there

So two or more such shirts will be there in the respective shirt cluster

And we know that in each and every shard we are having the replica set

Replica set means multiple MongoD applications or instances will be running on the same

data set and that is known as a replica set and out of all this MongoDi instances

one instance will be the respective primary and rest of the instances will be the secondary nodes

So only one primary node and multiple secondary nodes will be there in one replica set

In this way you can have multiple such replica sets are there in the shared cluster

Now, this is the application server from where multiple applications are running and those applications are generating queries

And these are known as the query routers You can find that we are having multiple such query routers two or more query routers are there Now why such more query routers Because when multiple applications are generating huge number of queries at the same instance of time

so to do the load sharing, we can have two or more query routers are there

And these query routers are nothing but Mongo's instances. So, we are having the application servers and they're generating multiple different queries

to get satisfied from this MongoDB and that's why we're having multiple query routers

depending upon the number of queries or the density of the queries getting generated at that

instant of time we can go on increasing the number of query routers and this query routers

are nothing but we're having the Mongo's instances are there so Mongo's means we know

that it is the client it is a client process okay now we're having this one that is the

three config servers. We're having three config servers, exactly three. There's a config server

another config server, and another config server. These config servers are actually containing

the metadata, that is the data about data. That means, how this data have got mapped onto this

shared cluster So this is the config servers are there These queries will take the help of this config servers to get the information to get the metadata so that the query can get executed

on this shared cluster. So, there is the basic architecture and we have defined what is a sharding

Now, the components of the sharding components are, first one is the shards, and the shards

are used to store data, they provide high availability and data consistency

We know that in a same shirt where having multiple shirts will be there, they are nothing

but the replica sets, one primary node and multiple secondary nodes are there

And these secondary nodes will contain the replica of the data so that it enhance the availability

of the data. In production environment, each shirt is a separate replica set as I have discussed

Next one is the config servers. You know that in the previous diagram we are having three config servers are there

So config servers stored the clusters metadata and these data contains a mapping of the

cluster data set to the shirts. How the data has got mapped onto the shirts So that information that metadata will be kept in this config servers The query routers uses this metadata to target operations to specific shards

So, these query routers will access this config servers data, that is a metadata, and accordingly

it knows that on which shared you should execute the respective query

So in production environment, sharded clusters have exactly three config servers. In the previous diagram also, we have shown you this

that we are having three config servers. Next, we are considering this query routers

Query routers are basically Mongo instances and interface with the client applications

and direct operations to the appropriate shard. So in the diagram also we have seen that this particular query routers, they are connected

with this application servers and they are also communicating with these shirts after

getting the required information from the config servers. When these particular queries will be coming in many number of, that means when the query

will be in large number of, then we can have multiple such query routers to shear the load

So we are having this one. So the query router processes and targets the operation to the shorts and then return