目錄(378章)
倒序
- 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
推薦閱讀
- Deep Learning Quick Reference
- 工業機器人產品應用實戰
- Verilog HDL數字系統設計入門與應用實例
- Blockchain Quick Start Guide
- Visual C# 2008開發技術實例詳解
- Mastering Salesforce CRM Administration
- Pentaho Analytics for MongoDB
- C++程序設計基礎（上）
- SQL Server數據庫應用基礎（第2版）
- Web璀璨：Silverlight應用技術完全指南
- 漢字錄入技能訓練
- Visual Basic項目開發案例精粹
- RealFlow流體制作經典實例解析
- Moodle 2.0 Course Conversion（Second Edition）
- 分布式Java應用
- Wireshark Revealed：Essential Skills for IT Professionals
- Modern Big Data Processing with Hadoop
- Deep Learning with PyTorch Quick Start Guide
- Deployment with Docker
- IBM Watson Projects
- 智能機器人制作完全手冊（第2版）
- Learning PostgreSQL 10（Second Edition）
- 機器人力觸覺感知技術
- R Deep Learning Projects
- 計算機控制技術（第2版）
- 數據庫應用基礎學習指導
- Learning Quantitative Finance with R
- 絕美Maya
- Scala for Machine Learning
- 工業機器人工作站系統集成設計
