MongoDB Security, Profiling, Indexing, Cursors and Bulk Operations Guide

This article is part of our Academy Course titled MongoDB – A Scalable NoSQL DB.

In this course, you will get introduced to MongoDB. You will learn how to install it and how to operate it via its shell. Moreover, you will learn how to programmatically access it via Java and how to leverage Map Reduce with it. Finally, more advanced concepts like sharding and replication will be explained. Check it out here!
 
 
 
 

Do you want to know how to develop your skillset to become a Java Rockstar?

Subscribe to our newsletter to start Rocking right now!

To get you started we give you our best selling eBooks for FREE!

1. JPA Mini Book

2. JVM Troubleshooting Guide

3. JUnit Tutorial for Unit Testing

4. Java Annotations Tutorial

5. Java Interview Questions

and many more ....

I agree to the Terms and Privacy Policy

Sign up

Thank you!

We will contact you soon.

1. Introduction

In this final part of the tutorial we are going to take a look on MongoDB security model, different types of indexes, query plans and profiling, server-side cursors and bulk operations.

2. Security

MongoDB security features include authentication, authorization and auditing. Its foundation is a role-based access control with flexible set of privileges. It is worth mentioning that MongoDB provides a basis for user-defined roles by defining a set of build-in roles (for more details please refer to official documentation). As always, MongoDB shell provides rich set of command helpers to deal with security configuration.

{
    createUser: <username>,
    pwd: <password>,
    customData: { <any information> },
    roles: [
        { role: <role>, db: <database> } | <role>,
        ...
    ],
    writeConcern: { <write concern> }
}

db.createUser(  
    {
        user: "testuser",
        pwd: "testpassword",
        customData: { 
            "firstName": "John",
            "lastName": "Smith"
        },
        roles: [
            { role: "readWrite", db: "test" }
        ]
    },	
    { 
        w: "majority" , 
        wtimeout: 5000 
    }
)

{
    updateUser: <username>,
    pwd: <password>,
    customData: { <any information> },
    roles: [
        { role: <role>, db: <database> } | <role>,
        ...
    ],
    writeConcern: { <write concern> }
}

createUser command):

db.updateUser(
    "testuser",  
    {
        customData: { 
            "firstName": "John",
            "lastName": "Smith",
            "country": "US"
        },
        roles: [
            "read"
        ]
    },	
    { 
        w: "majority" , 
        wtimeout: 5000 
    }
)

{
    dropUser: <username>,
    writeConcern: { <write concern> }
}

db.dropUser(
    "testuser",  
    { 
        w: "majority" , 
        wtimeout: 5000 
    }
)

{ 
    dropAllUsersFromDatabase: 1,
    writeConcern: { <write concern> }
}

{ 
    grantRolesToUser: <username>,
    roles: [
        { role: <role>, db: <database> } | <role>,
        ...
    ],
    writeConcern: { <write concern> }
}

db.grantRolesToUser(
    "testuser",
    [ "read" ],
    { w: "majority" }
)

{ 
    revokeRolesFromUser: <username>,
    roles: [
        { role: <role>, db: <database> } | <role>,
        ...
    ],
    writeConcern: { <write concern> }
}

db.revokeRolesFromUser(
    "testuser",
    [ "readWrite" ],
    { w: "majority" }
)

{ 
    usersInfo: { user: <username>, db: <db> } | <name> | 1,
    showCredentials: <true|false>,
    showPrivileges: <true|false>
}

{ 
    createRole: <rolename>,
    privileges: [
        { resource: { <resource> }, actions: [<action>, ... ] },
        ...
    ],
    roles: [
        { role: <role>, db: <database> } | <role>,
        ...
    ],
    writeConcern: { <write concern> }
}

db.createRole(
    { 
        role: "testrole",
        privileges: [
            { resource: { 
                db: "test", 
                collection: "test" 
            }, actions: [ "find" ] }
        ],
        roles: [
            { role: "read", db: "test" }
        ],
    },
    { w: "majority" , wtimeout: 5000 }
)

{ 
    updateRole: <rolename>,
    privileges: [
        { resource: { <resource> }, actions: [<action>, ... ] },
        ...
    ],
    roles: [
        { role: <role>, db: <database> } | <role>,
        ...
    ],
    writeConcern: { <write concern> }
}

db.updateRole(
    "testrole",
    { 
        privileges: [
            { resource: { 
                db: "test", 
                collection: "test" 
            }, actions: [ "find" ] }
        ],
        roles: [
            { role: "read", db: "test" },
            { role: "readWrite", db: "test" }
        ]
    },
    { w: "majority" , wtimeout: 5000 }
)

{ 
    dropRole: <rolename>,
    writeConcern: { <write concern> }
}

{
    dropAllRolesFromDatabase: 1,
    writeConcern: { <write concern> }
}

{ 
    grantPrivilegesToRole: <rolename>,
    privileges: [
        { resource: { <resource> }, actions: [<action>, ... ] },
        ...
    ],
    writeConcern: { <write concern> }
}

db.grantPrivilegesToRole(
    "testrole",
    [
        { resource: { 
            db: "test", 
            collection: "test" 
        }, actions: [ "insert" ] }
    ],
    { w: "majority" , wtimeout: 5000 }
)

{ 
    revokePrivilegesFromRole: <rolename>,
    privileges: [
        { resource: { <resource> }, actions: [<action>, ... ] },
        ...
    ],
    writeConcern: { <write concern> }
}

db.revokePrivilegesFromRole(
    "testrole",
    [
        { resource: { 
            db: "test", 
            collection: "test" 
        }, actions: [ "find" ] }
    ],
    { w: "majority" , wtimeout: 5000 }
)

{ 
    grantRolesToRole: <rolename>,
    roles: [
        { role: <role>, db: <database> } | <role>,
        ...
    ],
    writeConcern: { <write concern> }
}

db.grantRolesToRole(
    "testrole",
    [
        "readWrite"
    ],
    { w: "majority" , wtimeout: 5000 }
)

{ 
    revokeRolesFromRole: <rolename>,
    roles: [
        { role: <role>, db: <database> } | <role>,
        ...
    ],
    writeConcern: { <write concern> }
}

db.revokeRolesFromRole(
    "testrole",
    [
        { role: "read", db: "test" }
    ],
    { w: "majority" , wtimeout: 5000 }
)

{
    rolesInfo: <rolename> | { role: <rolename>, db: <database> },
    showPrivileges: <true|false>,
    showBuiltinRoles: <true|false>
}

{ 
    authenticate : 1, 
    user : <username>, 
    nonce : <nonce>, 
    key : <digest> 
}

Command	logout
Wrapper	db.logout()
Description	The command terminates the current authenticated session (if current session is not using authentication, the command has no effect).
Example	In MongoDB shell, let us issue the command: db.logout()
Reference	http://docs.mongodb.org/manual/reference/command/logout/ http://docs.mongodb.org/manual/reference/method/db.logout/

logout

2.1. Additional Resources

• MongoDB Security Part I: Design and Configuration http://blog.mongodb.org/post/86408399868/mongodb-security-part-1-design-and-configuration
• MongoDB Security Part II: 10 mistakes that can compromise your database http://blog.mongodb.org/post/87691901392/mongodb-security-part-ii-10-mistakes-that-can

3. Indexing

Choosing the right indexes may boost your query performance (and consequently applications performance) in most times. MongoDB supports different types of indexes to pick from:

• _id: all collections have an index on the _id field that exists by default
• single field: indexes on a single field of a document, f.e. { “title”: 1 }
• compound index: indexes on multiple fields, f.e. { “title”: 1, “price”: 1 }
• multikey index: indexes on content stored in arrays, f.e. { “categories”: 1 }
• geospatial index: 2d/2sphere indexes to support efficient geospatial queries, f.e. { “location”: “2d” }
• text indexes: indexes on string content to support full-text search, f.e. { “title”: “text” }
• hashed indexes: indexes to support hash-based sharding (please refer to Part 4. MongoDB Sharding Guide of the tutorial for more details)

Additionally, each index may be defined as:

• unique: duplicate values for the indexed field will be rejected
• sparse: index only contain entries for documents that have the indexed field

For indexed collections, the values for the indexed fields have a maximum index key length limit: the total size of an index entry must be less than 1024 bytes (please refer to limits and thresholds section of the official documentation).

For more details about indexing, please refer to official documentation.

4. Profiling

MongoDB provides a very useful tool to collect server performance data: the database profiler. It collects fine grained data about queries, write operations, cursors, and other database commands on a running server instance. The profiling can be enabled on a per-database or per-server instance level.

Command	Profile
Parameters	{ profile: <level> }
Wrapper	db.setProfilingLevel(level, slowms)
Description	The command modifies the current profiler level used by the database profiling system to capture data about performance. The level parameter has the following meaning: -1 – No change. Returns the current profile level. 0 – Off. No profiling. 1 – On. Only includes slow operations. 2 – On. Includes all operations.
Example	In MongoDB shell, let us issue the command: db.setProfilingLevel(2)
Reference	http://docs.mongodb.org/manual/reference/command/profile/ http://docs.mongodb.org/manual/reference/method/db.setProfilingLevel/

Profile

Command	db.getProfilingLevel()
Description	The command returns the current profiling level for database operations.
Example	In MongoDB shell, let us issue the command: db.getProfilingLevel()
Reference	http://docs.mongodb.org/manual/reference/method/db.getProfilingLevel/
Command	db.getProfilingStatus()
Description	The command returns a document that reflects the current profiling level and the profiling threshold.
Example	In MongoDB shell, let us issue the command: db.getProfilingStatus()
Reference	http://docs.mongodb.org/manual/reference/method/db.getProfilingStatus/

db.getProfilingLevel

To get more insights about analyzing the performance of database operations please refer to official documentation.

5. Query Cache

Among many other new features, MongoDB 2.6 supports a new set of commands to view and manipulate the query cache:

• list all known query shapes
• display cached plans for a query shape
• remove a query shape from the cache
• clear the whole cache

The query optimizer executes queries and picks the most efficient query plan for a query given the defined indexes. Later on, this query plan is used each time the query (with such a shape) runs. The query optimizer only caches the plans for those query shapes that can have more than one viable plan and occasionally reevaluates query plans as the content of the collection changes.

To experiment with query plans, we need a small dataset and the example from Part 3. MongoDB and Java Tutorial is going to be handy again. Let us switch to books collection in bookstore database, create couple of indexes and insert a few documents into it using MongoDB shell.

use bookstore

db.books.ensureIndex( { "publisher.name": 1 } )
db.books.ensureIndex( { "publisher.name": 1, "price": 1 } )

db.books.insert( { 
    "title" : "MongoDB: The Definitive Guide", 
    "publisher" : { "name" : "O'Reilly" },
    "price" : 32.99
} );

db.books.insert( { 
    "title" : "MongoDB Applied Design Patterns", 
    "publisher" : { "name" : "O'Reilly" },
    "price" : 32.99 
} );

db.books.insert( { 
    "title" : "MongoDB in Action, 2nd Edition", 
    "publisher" : { "name" : "Manning" },
    "price" : 26.66  
} );

Once the preparation is done, let us run simple query which will trigger the query plans evaluation: db.books.find( { "publisher.name": "O'Reilly" }, { "title": 1 } )

{ 
    planCacheListFilters: <collection> 
}

{
    planCacheSetFilter: <collection>,
    query: <query>,
    sort: <sort>,
    projection: <projection>,
    indexes: [ <index1>, <index2>, ...]
}

db.runCommand({ 
    planCacheSetFilter: "books" ,
    query: { "publisher.name": "O'Reilly" }, 
    sort: {},
    projection: { "title": 1 },
    indexes: [ { "publisher.name": 1 } ]
})

{
    planCacheClearFilters: <collection>,
    query: <query>,
    sort: <sort>,
    projection: <projection>
}

db.runCommand({ 
    planCacheClearFilters: "books" ,
    query: { "publisher.name": "O'Reilly" }, 
    sort: {},
    projection: { "title": 1 }
})

{
    planCacheListQueryShapes: <collection>
}

{
    planCacheListPlans: <collection>,
    query: <query>,
    sort: <sort>,
    projection: <projection>
}

{
    planCacheClear: <collection>,
    query: <query>,
    sort: <sort>,
    projection: <projection>
}

With log level set to 1 or greater MongoDB will log plan cache changes. The log level could be set using the following command (please notice that it should be run in context of admin database): db.adminCommand( { setParameter: 1, logLevel: 1 } )

6. Cursors

Cursors are the basic way to access documents returned by read operations, f.e. db.<collection>.find(). In MongoDB shell, if the returned cursor is not assigned to a variable, then only first 20 documents are taken from the cursor and shown as the result. However, cursors are very powerful and provide a lot of useful methods.

{
    parallelCollectionScan: <collection>,
    numCursors: <integer>
}

Armored with deeper knowledge about cursors, let us take a look on the example of different cursor methods in action using the books collection from section Query Cache.

[
    {
        "title" : "MongoDB in Action, 2nd Edition",
        "publisher" : {
            "name" : "Manning"
        },
        "price" : 26.66,
        "$diskLoc" : {
            "file" : 0,
            "offset" : 17072
        }
    },
    {
        "title" : "MongoDB: The Definitive Guide",
        "publisher" : {
            "name" : "O'Reilly"
        },
        "price" : 32.99,
        "$diskLoc" : {
            "file" : 0,
            "offset" : 16560
        }
    }
]

7. Bulk Operations

One of the coolest features of latest MongoDB 2.6 release is the introduction of bulk API. In a nutshell, this new API supports ordered and unordered bulk operations. In an ordered bulk operation, the execution of every operation follows the order it was added to the bulk operation. Consequently, in an unordered bulk operation the order of every operation is not guaranteed.

Command	db.<collection>.initializeOrderedBulkOp()
Description	The command Initializes and returns a new ordered bulk operation builder for a collection collection. The builder constructs an ordered list of the operations to be executed in bulk.
Example	In MongoDB shell, let us issue the command: var bulk = db.testcollection.initializeOrderedBulkOp()
Reference	http://docs.mongodb.org/manual/reference/method/db.collection.initializeOrderedBulkOp/

initializeOrderedBulkOp

Those two commands are the starting point to begin using the bulk API. They return bulk builder object (of type Bulk) which provides the fluent API to construct bulk operation.

To finish with the bulk API, let us create and execute an example bulk operation using MongoDB shell and initialization commands. In the example we are going to bulk the following actions:

• insert 3 books into books collection
• update all books by setting the categories field
• update book’s (with title “MongoDB: The Definitive Guide”) categories with additional category
• remove all books published by Manning

var bulk = db.books.initializeOrderedBulkOp();
bulk.insert( { 
    "title" : "MongoDB: The Definitive Guide", 
    "publisher" : { "name" : "O'Reilly" },
    "price" : 32.99
} );
bulk.insert( { 
    "title" : "MongoDB Applied Design Patterns", 
    "publisher" : { "name" : "O'Reilly" },
    "price" : 32.99 
} );
bulk.insert( { 
    "title" : "MongoDB in Action, 2nd Edition", 
    "publisher" : { "name" : "Manning" },
    "price" : 26.66  
} );
bulk.find( { "publisher.name": "O'Reilly" } )
    .update( { $set: { "categories" : [ "Databases", "NoSQL" ] } } );
bulk.find( { "title": "MongoDB: The Definitive Guide" } )
    .updateOne( { $addToSet: { "categories" : "Programming" } } );
bulk.find( { "publisher.name": "Manning" } )
    .remove();
bulk.execute( { w: "majority" ,  wtimeout: 5000  } );

As you can see, each action within ordered bulk operation may rely on previous actions to succeed (for example, find/update depends on insert). This is not the case for unordered bulk operation. The execution of this bulk operation in MongoDB shell yields the following result document:

BulkWriteResult({
    "writeErrors" : [ ],
    "writeConcernErrors" : [ ],
    "nInserted" : 3,
    "nUpserted" : 0,
    "nMatched" : 3,
    "nModified" : 3,
    "nRemoved" : 1,
    "upserted" : [ ]
})

7.1. Additional Resources

• MongoDB’s New Bulk API: http://blog.mongodb.org/post/84922794768/mongodbs-new-bulk-api

8. What’s next

This section concludes the MongoDB tutorial. Hopefully, you have found this NoSQL document database fitting your current or future application demands and this tutorial has helped you to make the right decisions.