- Summary 更新時間：2021-08-20 10:11:44
- References
- Checklists
- Isolating our servers
- Enabling security by default
- Security
- Operations
- Monitoring integrations
- Defensive coding
- Consolidating read querying
- Read performance optimization
- Schema-less doesn't mean schema design-less
- Application design
- Fault Tolerance and High Availability
- Summary
- References
- The entire cluster goes down
- A shard goes down
- Config server
- Mongod process
- Mongos
- Sharding recovery
- Performance comparison with replica sets
- Querying using Ruby
- Update/remove
- Sort/limit/skip
- Find
- The query router
- Querying sharded data
- Sharding limitations
- Adding and removing shards
- Merging chunks
- Jumbo chunks
- Changing the default chunk size
- Moving chunks
- Chunk administration
- Balancing data – how to track and keep our data balanced
- Sharding administration and monitoring
- Location-based data
- Coming up with our own key
- Hash-based sharding
- Range-based sharding
- Choosing the correct shard key
- Changing the shard key
- Choosing the shard key
- Sharding setup
- Planning ahead on sharding
- Development continuous deployment and staging environments
- Architectural overview
- Advantages of sharding
- Sharding
- Summary
- Replica set limitations
- MongoDB Atlas
- mLab
- Cloud options for a replica set
- Chained replication
- Reconfiguring a replica set when we have lost the majority of our servers
- Changing the oplog size
- Resyncing a member of a replica set
- How to perform maintenance on replica sets
- Replica set administration
- Connecting to a replica set
- Production considerations
- Delayed replica set members
- Hidden replica set members
- Priority zero replica set members
- Priority settings for replica set members
- Custom write concern
- Write concern
- Read preference
- Creating a replica set
- Converting a standalone server to a replica set
- Setting up a replica set
- What is the use case for a replica set?
- How do elections work?
- Architectural overview
- Different high availability types
- Logical or physical replication
- Replication
- Replication
- Summary
- References
- Spark to MongoDB
- Hadoop to MongoDB pipeline
- Steps
- Hadoop setup
- Kafka setup
- Big data use case
- MongoDB as a data warehouse
- Spark comparison with Hadoop MapReduce
- Apache Spark
- Apache Hadoop
- Data warehousing
- Apache Kafka
- RabbitMQ
- Apache ActiveMQ
- Message queuing systems
- Big data landscape
- What is big data?
- Harnessing Big Data with MongoDB
- Summary
- References
- Commands requiring a database lock
- Commonly used commands and locks
- Lock yield
- Lock reporting
- Locking in MongoDB
- TokuMX
- RocksDB
- Other storage engines
- Mixed usage
- MMAPv1 storage optimization
- MMAPv1
- In-memory
- Encrypted
- WiredTiger B-tree versus LSM indexes
- WiredTiger performance strategies
- WiredTiger collection-level options
- readConcern
- Memory usage
- Data compression
- Journaling
- Snapshots and checkpoints
- Document-level locking
- WiredTiger
- Pluggable storage engines
- Storage Engines
- Summary
- Overview
- Special cases
- Auditing security
- Network level security
- Superuser
- Roles across all databases
- Backup restore roles
- Cluster administration roles
- Database administration roles
- User roles
- Authorization
- Authentication
- Security
- Incremental backups
- EC2 backup and restore
- Backups using queueing
- Backups by copying raw files
- Backups using mongodump
- Taking a backup of a sharded cluster
- Backups with file system snapshots
- Cloud-based solutions
- Backup options
- Backups
- Open source tools
- Hosted tools
- Monitoring tools
- Working set calculations
- Oplog size
- Monitoring replication
- Tracking free space
- Background flushes
- Lock percentage
- Read and write queues
- I/O wait
- Tracking B-tree misses
- Tracking page faults
- Monitoring memory usage in WiredTiger
- Working set
- Virtual and mapped memory
- Resident memory
- Page faults
- What should we monitor?
- Monitoring
- Monitoring Backup and Security
- Summary
- References
- Index intersection
- Improving performance
- Measuring performance
- Using indexes efficiently
- Special considerations
- Naming indexes
- Managing indexes
- Building indexes on replica sets
- Hint and sparse indexes
- Forcing index usage
- Building and managing indexes
- Geospatial
- Case-insensitive
- Unique
- Sparse
- Partial
- TTL
- Hashed
- Text
- Special types of index
- Multikey indexes
- Reusing compound indexes
- Sorting using compound indexes
- Compound indexes
- Background indexes
- Indexing embedded documents
- Indexing embedded fields
- Single field indexes
- Index types
- Index internals
- Indexing
- Summary
- Aggregation use case
- Limitations
- Parsing data type
- Literal
- Variable
- Text search
- Other operators
- Conditional expressions
- Aggregation accumulators
- Expression arithmetic operators
- Expression string operators
- Expression date operators
- Set expression and array operators
- Expression comparison operators
- Expression Boolean operators
- Expression operators
- Aggregation stage operators
- Aggregation operators
- Why aggregation?
- Aggregation
- Summary
- Storage considerations on delete
- Query results and cursors
- Using regular expressions
- Smart querying
- Update operators
- Comparison operators
- Best practices
- Read
- Create update and delete
- CRUD using Doctrine
- Update
- Read
- Bulk write
- Create and delete
- CRUD using the PHP driver
- Querying documents
- Deleting documents
- Updating documents
- Creating documents
- CRUD using PyMODM
- Updating documents
- Finding documents
- Create and delete
- CRUD using the Python driver
- Create update and delete
- Scoping queries
- Read
- CRUD in Mongoid
- Batch operations
- Delete
- Update
- Nested operations
- Chaining operations in find()
- Read
- Creating documents
- CRUD using the Ruby driver
- MongoDB CRUD operations
- Advanced Querying
- Summary
- LDAP authentication
- Kerberos authentication
- Enterprise Edition
- Authentication with MongoDB
- Use secure configuration options
- Auditing
- Firewalls and VPNs
- Limiting network exposure
- Encrypting data
- Encrypting communication using TLS/SSL
- Security tips for MongoDB
- Authorization with MongoDB
- Authentication and authorization
- Securing the shell
- Aggregation versus MapReduce
- SQL to aggregation
- Aggregation framework
- Troubleshooting MapReduce
- Incremental MapReduce
- MapReduce concurrency
- MapReduce in the mongo shell
- touch
- collMod
- currentOp/killOp
- compact
- fsync
- Administration
- Batch operations using the mongo shell
- Batch inserts using the shell
- Differences between scripting for the mongo shell and using it directly
- Scripting for the mongo shell
- CRUD using the shell
- MongoDB CRUD Operations
- Summary
- Inheritance with Doctrine
- Doctrine ODM
- Connecting using PHP
- Inheritance with PyMODM models
- PyMODM ODM
- Connecting using Python
- Inheritance with Mongoid models
- Mongoid ODM
- Connecting using Ruby
- Connecting to MongoDB
- Modeling data for keyword searches
- One-to-many many-to-many
- One-to-one
- Modeling relationships
- Read isolation and consistency
- Write isolation
- Modeling data for atomic operations
- ObjectId
- Date type
- Comparing different data types
- Data types
- Data modeling
- Read-write ratio
- MongoDB schema design
- Relational schema design
- Schema Design and Data Modeling
- Summary
- Further reading
- Packt references
- MongoDB documentation
- Reference documentation
- Best practices for AWS
- Best practices for security
- Best practices for sharding
- Best practices for replication
- Best practices for write durability
- Schema design best practices
- Operational best practices
- MongoDB configuration and best practices
- MongoDB criticism
- What is the use case for MongoDB?
- Key characteristics
- MongoDB key characteristics and use cases
- MongoDB for NoSQL developers
- MongoDB for SQL developers
- Version 3+
- Version 3
- Version 2
- Major feature set for versions 1.0 and 1.2
- MongoDB evolution
- SQL and NoSQL evolution
- Web 3.0
- Web 2.0
- Web 1.0
- Web history
- MongoDB – A Database for the Modern Web
- Questions
- Piracy
- Errata
- Downloading the example code
- Customer support
- Reader feedback
- Conventions
- Who this book is for
- What you need for this book
- What this book covers
- Preface
- Customer Feedback
- Why subscribe?
- www.PacktPub.com
- About the Reviewers
- About the Author
- Credits
- Mastering MongoDB 3.x
- Copyright
- Title Page
- coverpage
- coverpage
- Title Page
- Copyright
- Mastering MongoDB 3.x
- Credits
- About the Author
- About the Reviewers
- www.PacktPub.com
- Why subscribe?
- Customer Feedback
- Preface
- What this book covers
- What you need for this book
- Who this book is for
- Conventions
- Reader feedback
- Customer support
- Downloading the example code
- Errata
- Piracy
- Questions
- MongoDB – A Database for the Modern Web
- Web history
- Web 1.0
- Web 2.0
- Web 3.0
- SQL and NoSQL evolution
- MongoDB evolution
- Major feature set for versions 1.0 and 1.2
- Version 2
- Version 3
- Version 3+
- MongoDB for SQL developers
- MongoDB for NoSQL developers
- MongoDB key characteristics and use cases
- Key characteristics
- What is the use case 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
- 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 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
- MongoDB CRUD Operations
- CRUD using the shell
- Scripting for the mongo shell
- 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/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
- Use secure configuration options
- Authentication with MongoDB
- Enterprise Edition
- Kerberos authentication
- LDAP authentication
- Summary
- 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
- Create and delete
- Finding documents
- Updating documents
- CRUD using PyMODM
- Creating documents
- Updating documents
- Deleting documents
- Querying documents
- CRUD using the PHP driver
- Create and delete
- Bulk write
- Read
- Update
- CRUD using Doctrine
- Create update and delete
- Read
- Best practices
- Comparison operators
- Update operators
- Smart querying
- Using regular expressions
- Query results and cursors
- Storage considerations on delete
- Summary
- 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
- Other operators
- Text search
- Variable
- Literal
- Parsing data type
- Limitations
- Aggregation use case
- Summary
- Indexing
- Index internals
- Index types
- Single field indexes
- Indexing embedded fields
- Indexing embedded documents
- Background indexes
- Compound indexes
- Sorting using compound indexes
- Reusing compound indexes
- Multikey indexes
- Special types of index
- Text
- Hashed
- TTL
- Partial
- Sparse
- Unique
- Case-insensitive
- Geospatial
- 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
- References
- Summary
- Monitoring Backup and Security
- Monitoring
- What should we monitor?
- Page faults
- Resident memory
- Virtual and mapped memory
- Working set
- 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 file system snapshots
- Taking a backup of a sharded cluster
- Backups using mongodump
- Backups by copying raw files
- Backups using queueing
- EC2 backup and restore
- Incremental backups
- Security
- Authentication
- Authorization
- User roles
- Database administration roles
- Cluster administration roles
- Backup restore roles
- Roles across all databases
- Superuser
- Network level security
- Auditing security
- Special cases
- Overview
- Summary
- 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
- References
- Summary
- Harnessing Big Data with MongoDB
- What is big data?
- Big data landscape
- Message queuing systems
- Apache ActiveMQ
- RabbitMQ
- Apache Kafka
- Data warehousing
- Apache Hadoop
- Apache Spark
- Spark comparison with Hadoop MapReduce
- MongoDB as a data warehouse
- Big data use case
- Kafka setup
- Hadoop setup
- Steps
- Hadoop to MongoDB pipeline
- Spark to MongoDB
- References
- Summary
- Replication
- Replication
- Logical or physical replication
- Different high availability types
- Architectural overview
- How do elections work?
- What is the use case for a replica set?
- Setting up a replica set
- Converting a standalone server to a replica set
- Creating a replica set
- Read preference
- Write concern
- Custom write concern
- Priority settings for replica set members
- Priority zero 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
- Resyncing a member of a replica set
- Changing the oplog 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
- Sharding
- Advantages of sharding
- Architectural overview
- Development continuous deployment and staging environments
- Planning ahead on 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 process
- Config server
- A shard goes down
- The entire cluster goes down
- References
- Summary
- 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
- References
- Summary 更新時間：2021-08-20 10:11:44
