Mastering MongoDB 4.x : expert techniques to run high-volume and fault-tolerant database solutions using MongoDB 4.x

Title Page
Copyright and Credits
About Packt
Contributors
Table of Contents
Preface
Section 1: Basic MongoDB – Design Goals and Architecture
Chapter 1: MongoDB – A Database for Modern Web
	Technical requirements
	The evolution of SQL and NoSQL
		The evolution of MongoDB
			Major feature set for versions 1.0 and 1.2
			Version 2
			Version 3
			Version 4
		MongoDB for SQL developers
		MongoDB for NoSQL developers
	MongoDB's key characteristics and use cases
		Key characteristics
		Use cases for MongoDB
		MongoDB criticism
	MongoDB configuration and best practices
		Operational best practices
		Schema design best practices
		Best practices for write durability
		Best practices for replication
		Best practices for sharding
		Best practices for security
		Best practices for AWS
	Reference documentation
		MongoDB documentation
		Packt references
	Further reading 
	Summary
Chapter 2: Schema Design and Data Modeling
	Relational schema design
		MongoDB schema design
			Read-write ratio
	Data modeling
		Data types
			Comparing different data types
				Date type
				ObjectId
	Modeling data for atomic operations
		Write isolation
		Read isolation and consistency
	Modeling relationships
		One-to-one
		One-to-many and many-to-many
	Modeling data for keyword searches
	Connecting to MongoDB
		Connecting using Ruby
			Mongoid ODM
			Inheritance with Mongoid models
		Connecting using Python
			PyMODM ODM
			Inheritance with PyMODM models
		Connecting using PHP
			Doctrine ODM
			Inheritance with Doctrine
	Summary
Section 2: Querying Effectively
Chapter 3: MongoDB CRUD Operations
	CRUD using the shell
		Scripting for the mongo shell
			The differences between scripting for the mongo shell and using it directly
			Batch inserts using the shell
			Batch operations using the mongo shell
		Administration
			fsync
			compact
			currentOp and killOp
			collMod
			touch
		MapReduce in the mongo shell
			MapReduce concurrency
			Incremental MapReduce
			Troubleshooting MapReduce
		Aggregation framework
			SQL to aggregation
			Aggregation versus MapReduce
		Securing the shell
			Authentication and authorization
			Authorization with MongoDB
			Security tips for MongoDB
				Encrypting communication using TLS/SSL
				Encrypting data
				Limiting network exposure
				Firewalls and VPNs
				Auditing
				Using secure configuration options
		Authentication with MongoDB
			Enterprise Edition
				Kerberos authentication
				LDAP authentication
	Summary
Chapter 4: Advanced Querying
	MongoDB CRUD operations
		CRUD using the Ruby driver
			Creating documents
			Read
			Chaining operations in find()
			Nested operations
			Update
			Delete
			Batch operations
		CRUD in Mongoid
			Read
			Scoping queries
			Create, update, and delete
		CRUD using the Python driver
			Creating and deleting
			Finding documents
			Updating documents
		CRUD using PyMODM
			Creating documents
			Updating documents
			Deleting documents
			Querying documents
		CRUD using the PHP driver
			Creating and deleting
			BulkWrite
			Read
			Updating documents
		CRUD using Doctrine
			Creating, updating, and deleting
			Read
			Best practices
		Comparison operators
		Update operators
		Smart querying
			Using regular expressions
			Querying results and cursors
			Storage considerations for the delete operation
	Change streams
		Introduction
			Setup 
			Using change streams
			Specification
			Important notes
			Production recommendations
			Replica sets
			Sharded clusters
	Summary
Chapter 5: Multi-Document ACID Transactions
	Background
	ACID
		Atomicity
		Consistency
		Isolation
			Phantom reads
			Non-repeatable reads
			Dirty reads
		Durability
		When do we need ACID in MongoDB ?
		Building a digital bank using MongoDB
			Setting up our data
			Transferring between accounts – part 1
			Transferring between accounts – part 2
			Transferring between accounts – part 3
	E-commerce using MongoDB
		The best practices and limitations of multi-document ACID transactions
	Summary
Chapter 6: Aggregation
	Why aggregation?
	Aggregation operators
		Aggregation stage operators
		Expression operators
			Expression Boolean operators
			Expression comparison operators
			Set expression and array operators
			Expression date operators
			Expression string operators
			Expression arithmetic operators
			Aggregation accumulators
			Conditional expressions
			Type conversion operators
			Other operators
				Text search
				Variable
				Literal
				Parsing data type
	Limitations
	Aggregation use case
	Summary
Chapter 7: Indexing
	Index internals
		Index types
			Single field indexes
			Dropping indexes
				Indexing embedded fields
				Indexing embedded documents
				Background indexes
			Compound indexes
				Sorting with compound indexes
				Reusing compound indexes
			Multikey indexes
			Special types of indexes
				Text indexes
				Hashed indexes
				Time to live indexes
				Partial indexes
				Sparse indexes
				Unique indexes
				Case-insensitive
				Geospatial indexes
				2d geospatial indexes
				2dsphere geospatial indexes
				geoHaystack indexes
		Building and managing indexes
			Forcing index usage
				Hint and sparse indexes
				Building indexes on replica sets
			Managing indexes
				Naming indexes
				Special considerations
		Using indexes efficiently
			Measuring performance
				Improving performance
				Index intersection
	Further reading
	Summary
Section 3: Administration and Data Management
Chapter 8: Monitoring, Backup, and Security
	Monitoring
		What should we monitor?
			Page faults
			Resident memory
			Virtual and mapped memory
			Working sets
		Monitoring memory usage in WiredTiger
		Tracking page faults
		Tracking B-tree misses
			I/O wait
			Read and write queues
			Lock percentage
			Background flushes
			Tracking free space
			Monitoring replication
			Oplog size
		Working set calculations
		Monitoring tools
			Hosted tools
			Open source tools
	Backups
		Backup options
			Cloud-based solutions
			Backups with filesystem snapshots
			Making a backup of a sharded cluster
			Making backups using mongodump
			Backing up by copying raw files
			Making backups using queuing
		EC2 backup and restore
		Incremental backups
	Security
		Authentication
		Authorization
			User roles
			Database administration roles
			Cluster administration roles
			Backup and restore roles
			Roles across all databases
				Superuser
		Network-level security
		Auditing security
		Special cases
		Overview
	Summary
Chapter 9: Storage Engines
	Pluggable storage engines
		WiredTiger
			Document-level locking
			Snapshots and checkpoints
			Journaling
			Data compression
			Memory usage
			readConcern
			WiredTiger collection-level options
			WiredTiger performance strategies
			WiredTiger B-tree versus LSM indexes
		Encrypted
		In-memory
		MMAPv1
			MMAPv1 storage optimization
		Mixed usage
		Other storage engines
			RocksDB
			TokuMX
	Locking in MongoDB
		Lock reporting
		Lock yield
		Commonly used commands and locks
		Commands requiring a database lock
	Further reading
	Summary
Chapter 10: MongoDB Tooling
	Introduction
		MongoDB Atlas
			Creating a new cluster
				Important notes
		MongoDB Cloud Manager
		MongoDB Ops Manager
		MongoDB Charts
		MongoDB Compass
		MongoDB Connector for Business Intelligence (BI)
	An introduction to Kubernetes
		Enterprise Kubernetes Operator
		MongoDB Mobile
		MongoDB Stitch
			QueryAnywhere
				Rules
			Functions
			Triggers
		Mobile Sync
	Summary
Chapter 11: Harnessing Big Data with MongoDB
	What is big data?
		The big data landscape
		Message queuing systems
			Apache ActiveMQ
			RabbitMQ
			Apache Kafka
		Data warehousing
			Apache Hadoop
			Apache Spark
			Comparing  Spark with Hadoop MapReduce
		MongoDB as a data warehouse
	A big data use case
		Setting up Kafka 
		Setting up Hadoop
			Steps for Hadoop setup
		Using a Hadoop to MongoDB pipeline
		Setting up Spark to MongoDB
	Further reading
	Summary
Section 4: Scaling and High Availability
Chapter 12: Replication
	Replication
		Logical or physical replication
		Different high availability types
	An architectural overview
	How do elections work?
	What is the use case for a replica set?
	Setting up a replica set
		Converting a standalone server into a replica set
		Creating a replica set
		Read preference
		Write concern
			Custom write concerns
		Priority settings for replica set members
			Zero priority replica set members
			Hidden replica set members
			Delayed replica set members
		Production considerations
	Connecting to a replica set
	Replica set administration
		How to perform maintenance on replica sets
		Re-syncing a member of a replica set
		Changing the oplog's size
		Reconfiguring a replica set when we have lost the majority of our servers
		Chained replication
	Cloud options for a replica set
		mLab
		MongoDB Atlas
	Replica set limitations
	Summary
Chapter 13: Sharding
	Why do we use sharding?
	Architectural overview
		Development, continuous deployment, and staging environments
		Planning ahead with sharding
	Sharding setup
		Choosing the shard key
			Changing the shard key
		Choosing the correct shard key
			Range-based sharding
			Hash-based sharding
			Coming up with our own key
			Location-based data
	Sharding administration and monitoring
		Balancing data – how to track and keep our data balanced
		Chunk administration
			Moving chunks
			Changing the default chunk size
			Jumbo chunks
			Merging chunks
			Adding and removing shards
		Sharding limitations
	Querying sharded data
		The query router
			Find
			Sort/limit/skip
			Update/remove
		Querying using Ruby
		Performance comparison with replica sets
	Sharding recovery
		mongos
		mongod
		Config server
		A shard goes down
		The entire cluster goes down
	Further reading
	Summary
Chapter 14: Fault Tolerance and High Availability
	Application design
		Schema-less doesn't mean schema design-less
		Read performance optimization
			Consolidating read querying
		Defensive coding
			Monitoring integrations
	Operations
	Security
		Enabling security by default
		Isolating our servers
		Checklists
	Further reading
	Summary
Other Books You May Enjoy
Index