C100DBA Application Administration — 20 Questions

Question 1

An application is experiencing high latency during bulk inserts. The DBA notices that the application uses a default write concern and acknowledges every write before proceeding. Which strategy should be implemented to improve write throughput while ensuring data safety?

Choose an answer to begin — your selection is scored in the full session.

Accepted Answer

Change the write concern to 'w: 1' to allow the primary to acknowledge immediately.. Increasing write throughput requires reducing the round-trip time spent waiting for synchronous acknowledgement from every replica set member. By setting the write concern to 'w: 1', the application acknowledges the write once the primary processes it, significantly reducing latency. This approach balances performance with sufficient durability for most non-critical high-volume ingestions, provided the replication lag is monitored closely by the operations team to ensure secondary data remains consistent.

Answer

Disable the oplog on the secondary members to remove replication overhead.

Answer

Use an unacknowledged write concern (w: 0) for all application operations.

Answer

Increase the number of secondary nodes to distribute the write load.

Question 2

A developer is optimizing queries for an e-commerce application. Which TWO of the following strategies are best for reducing the impact of large result sets on the application server memory?

Accepted Answer

Implement cursor-based pagination using .limit() and .skip().. Handling large data volumes effectively requires shifting the memory burden away from the application server. Using cursors allows for incremental fetching of data, while projection limits the amount of raw data transferred over the network. Both strategies combined minimize the heap usage on the application server, preventing OutOfMemory errors and ensuring the application remains responsive under load, which is critical for scaling MongoDB-backed applications efficiently.

Answer

Use the .toArray() method on every query result to ensure data is accessible.

Answer

Increase the batch size to the maximum allowed by the driver.

Answer

Store the result set in a global variable for reuse by other threads.

Question 3

Refer to the exhibit. The query is performing a collection scan despite having an index on the 'status' field. What is the most likely reason for this performance issue?

Accepted Answer

The index on 'status' is missing the 'created' field.. The query uses a sort order that does not match the index prefix, forcing the engine to perform an in-memory sort or a collection scan. When the filter and sort fields are decoupled from the index, MongoDB cannot utilize the index for sorting, leading to inefficient execution plans. Ensuring the index covers both the filter and the sort criteria is essential for optimal query performance.

Answer

The database is running out of memory for the sort operation.

Answer

The 'status' field contains too many duplicate values.

Answer

The explain('executionStats') method is slowing down the query.

Question 4

Which THREE actions should an administrator perform to prepare an application for a seamless transition from a standalone instance to a replica set?

Accepted Answer

Update the connection string to include all replica set members.. Transitioning to a replica set requires updating the connection configuration to ensure the application can discover the current primary node. Enabling authentication and ensuring proper firewall rules between nodes are also essential for security and stability. These steps ensure that the application handles failover events automatically, which is the primary benefit of moving from a standalone instance to a resilient replica set architecture.

Answer

Manually restart the application every time a node fails.

Answer

Increase the read preference to 'secondary' for all operations.

Question 5

An application is using a compound index on {region: 1, date: -1}. A query filters by 'region' and sorts by 'date'. If the index is not used, what is the most likely cause?

Accepted Answer

The query filters by 'date' instead of 'region'.. The order of fields in a compound index is critical. MongoDB utilizes the index prefix for both filtering and sorting. If the query does not follow the index field order or includes an incompatible sort direction, the optimizer may bypass the index. Understanding index prefix rules is vital for ensuring that queries are supported by available indexes, preventing full collection scans and performance degradation.

Answer

The index is not 'unique'.

Answer

The collection has more than 10 indexes.

Answer

The 'date' field is a BSON Date type.

Question 6

What is the recommended way to handle a 'WiredTiger' cache pressure situation in a production environment?

Accepted Answer

Optimize indexes to reduce the number of documents scanned.. Cache pressure occurs when the working set exceeds the assigned cache size. Increasing the cache size (if system RAM allows) or optimizing query performance through better indexing are the two primary ways to alleviate this. Properly indexed queries reduce the number of documents scanned, which directly decreases the amount of data that needs to be loaded into the WiredTiger cache, improving performance.

Answer

Clear the cache manually using the dropDatabase command.

Answer

Disable the WiredTiger journal to reduce write overhead.

Answer

Restart the mongod process to reset memory usage.

Question 7

An application reports that a specific query is occasionally slow. The DBA finds that the query sometimes performs an index scan and other times a collection scan. What is the most likely reason?

Accepted Answer

The query uses a parameter that changes the selectivity significantly.. If the query optimizer is choosing different plans, it often means the statistics used to make that decision are stale or the query is sensitive to parameter variability. Ensuring that indexes are properly defined and that statistics are accurate helps the optimizer make consistent, optimal decisions. This variability in query plans is a major cause of intermittent performance issues in production applications and requires careful analysis of execution plans.

Answer

The database process is randomly switching storage engines.

Answer

The mongos process is automatically deleting the index.

Answer

The network latency is affecting the optimizer's choice.

Question 8

An application intermittently fails with 'ExceededTimeLimit' errors during complex aggregation pipelines. Which approach best resolves this issue while maintaining performance?

Accepted Answer

Enable allowDiskUse and adjust maxTimeMS appropriately for the pipeline.. Allowing partial results is the standard strategy for long-running aggregations that do not require absolute consistency across the entire dataset. By setting allowDiskUse to true, MongoDB can spill temporary data to the _tmp directory, preventing memory exhaustion. Balancing these configurations ensures the application remains responsive without crashing. This is a critical DBA skill because balancing throughput and consistency is essential for maintaining high availability in distributed database systems under heavy analytical workloads.

Answer

Set the maxTimeMS to zero for all aggregation queries.

Answer

Always force all aggregation queries to execute on the primary node.

Answer

Reduce the batch size to one to force sequential processing.

Question 9

An application is experiencing latency during bulk write operations. Which TWO of the following adjustments effectively improve performance?

Accepted Answer

Use ordered: false in bulkWrite operations.. Optimizing write performance requires minimizing network round trips and reducing the overhead of waiting for disk persistence. Ordered bulk writes allow multiple operations to be sent in a single network request, while an appropriate write concern balances data safety with latency requirements. These settings are crucial for developers designing scalable high-throughput applications that require consistent ingestion rates without blocking the main application execution threads or unnecessarily stressing the underlying hardware storage sub-system.

Answer

Change write concern to w: 0.

Answer

Increase the batch size to the maximum allowed limit.

Answer

Convert all indexes to hashed indexes immediately.

Question 10

Which THREE actions should be taken when migrating an application to use MongoDB sharding?

Accepted Answer

Choose a shard key with high cardinality.. Successful sharding migrations require careful planning of the shard key, testing for query patterns, and ensuring connectivity through the mongos router. The shard key is the most critical component, as it dictates data distribution. These steps are essential for DBAs because an improperly sharded collection will suffer from hot spots or unbalanced data, leading to significant performance degradation that is difficult to correct after the collection has grown large in a production environment.

Answer

Configure the application to connect to mongod instances directly.

Answer

Ensure that the shard key is mutable for all documents.

Question 11

Refer to the exhibit. Why is the hint provided in this query beneficial?

Accepted Answer

It ensures the use of an index that covers both the filter and the sort order.. The hint forces the query planner to use a specific index, bypassing the potential for the query optimizer to choose a sub-optimal plan. This is useful when the application knows the workload patterns better than the optimizer, especially for queries involving both equality and sorting. Managing query plans via hints is a key DBA activity to prevent plan cache instability and ensure consistent query performance for critical application business processes during varying load levels.

Answer

It forces the query to use the primary node for execution.

Answer

It guarantees that the query will return the most recent data.

Answer

It reduces the amount of memory consumed by the mongod process.

Question 12

An application team reports that their queries against a large collection are timing out after 30 seconds. The database administrator needs to investigate and adjust the timeout setting for the active client sessions without restarting the mongod instances or interrupting current workload processing. Which method should the administrator use to implement this change?

Accepted Answer

Execute the db.adminCommand({ setParameter: 1, localOperationTimeoutMillis: 60000 }) command against the admin database to adjust the timeout dynamically.. Setting the maxTimeMS parameter globally or per operation limits execution time, but changing the default server-side operation timeout dynamically on running instances requires the setParameter command. Administrators can execute this runtime command directly against the admin database to alter localOperationTimeoutMillis without requiring a disruptive maintenance window or restarting the underlying database service instances across the production cluster.

Answer

Modify the configuration file directly to add maxConns and restart the mongod service during a scheduled maintenance window.

Answer

Update the application connection string parameters to include maxIdleTimeMS and deploy the new configuration through rolling application restarts.

Answer

Run the sh.setBalancerState(true) command to redistribute active workloads and free up resources for long-running queries across shards.

Question 13

A financial application requires that reads never see uncommitted or rolled-back data, and that once a write is acknowledged, all subsequent reads on the same session see that write. The replica set has three voting members and one analytics secondary. Which read concern should the application use?

Accepted Answer

"majority". The majority read concern ensures that data returned has been acknowledged by a majority of voting members in the replica set, so it will not be rolled back. This matches the financial application's requirement to never see uncommitted or rolled-back data and to have session-level read-your-writes consistency after an acknowledged write.

Answer

"local"

Answer

"snapshot"

Answer

"available"

Question 14

A development team is building an application that uses MongoDB transactions. They need to ensure that their transactions are retried automatically on transient errors and that they can read their own writes within the same transaction. Which TWO practices should they implement? (Choose two.)

Accepted Answer

Use a retryable write or a retryable transaction by including the transaction number in each operation.. To automatically retry transactions on transient errors, the application must use retryable transactions, which rely on a transaction number and session. Using the same session for all operations within the transaction ensures read-your-own-writes and enables the driver to retry the entire transaction safely. These two practices together provide the required behavior.

Answer

Set read concern to "majority" for all reads inside the transaction.

Answer

Disable retryable writes to avoid duplicate operations.

Answer

Set write concern to 0 (unacknowledged) to improve performance.

Question 15

An application uses a MongoDB connection string with readPreference=secondaryPreferred and readConcern=majority. The application performs reads during a period when the primary is overloaded and secondaries are lagging by 10 seconds. What behavior should the application expect?

Accepted Answer

Reads will be served from a secondary and may return data that is up to 10 seconds stale.. With secondaryPreferred, the driver reads from a secondary if one is available, even if it is lagging. Read concern majority ensures that the data read has been acknowledged by a majority of voting members, but if secondaries are lagging, the majority commit point may also be delayed, resulting in stale reads. The application should expect potentially stale data, not a fallback to the primary or a timeout.

Answer

Reads will be served from the nearest member regardless of its role.

Answer

Reads will be served from the primary because secondaries are lagging.

Answer

Reads will fail with a timeout because secondaries are lagging.

Question 16

An application uses a MongoDB deployment with a replica set and occasionally performs write operations that include a unique index constraint. The application team reports that during a network partition, some write operations fail with duplicate key errors even though the data does not actually duplicate existing documents. Which write concern setting could be causing this behavior?

Accepted Answer

w=majority with retryWrites=true. When retryWrites=true is enabled, the driver may retry a write operation that it believes failed due to a network error, but the original write might have actually succeeded on the primary. The retry attempt then fails with a duplicate key error because the unique index constraint is violated by the already-inserted document. This is expected behavior and does not indicate data duplication. The write concern itself does not cause the duplicate key error; it is the combination with retryWrites.

Answer

w=1 with j=false

Answer

w=0

Answer

w=1 with wtimeout=1000

Question 17

A database administrator is configuring a MongoDB replica set for a new application that requires high availability and the ability to perform reads from secondary nodes to reduce load on the primary. The application must also ensure that reads from secondaries do not return data that could be rolled back. Which two read preference and read concern combinations should be used? (Choose two.)

Accepted Answer

readPreference: "nearest", readConcern: "majority". The application needs to read from secondaries to reduce primary load while ensuring that reads are not rollback-able. "majority" read concern provides that guarantee. It can be combined with read preferences that allow secondary reads, such as "secondary" and "nearest". The combination with "secondary" directly reads from secondaries, while "nearest" may read from secondaries if they are closer. Both satisfy the requirements.

Answer

readPreference: "primary", readConcern: "majority"

Answer

readPreference: "secondary", readConcern: "linearizable"

Answer

readPreference: "secondaryPreferred", readConcern: "local"

Question 18

A MongoDB application uses a replica set and requires that reads never return data that has not been acknowledged by a majority of replica set members. The application also needs to minimize read latency by reading from secondaries when possible. Which two read concern and read preference combinations satisfy these requirements? (Choose two.)

Accepted Answer

readConcern: majority with readPreference: primary. The two valid combinations are majority read concern with either secondary or primary read preference. Both ensure that reads return data acknowledged by a majority of replica set members, preventing rollback. The secondary read preference also minimizes latency. The other options either lack majority acknowledgment or use an incompatible read preference.

Answer

readConcern: local with readPreference: secondary

Answer

readConcern: linearizable with readPreference: secondary

Answer

readConcern: available with readPreference: secondary

Question 19

An application needs to update a user's balance. Which method ensures the operation is atomic for a single document?

Accepted Answer

Use the $inc operator with the updateOne method.. Atomic updates are a cornerstone of MongoDB's document model. Using update operators like $inc ensures that the update is performed in a single, atomic step at the document level. This prevents race conditions where two threads might attempt to update the same balance simultaneously, ensuring that data integrity is maintained without the need for manual locking mechanisms in the application layer.

Answer

Read the document, update the value in application code, and save the document.

Answer

Wrap the operation in a multi-document transaction every time.

Answer

Use a global application-level mutex lock before updating.

Question 20

Refer to the exhibit. An aggregation pipeline is failing with an error. How can you modify the pipeline to allow it to process the large dataset?

Accepted Answer

Set 'allowDiskUse' to true in the aggregation options.. The error indicates that the group operation is exceeding the 100MB RAM limit. By setting 'allowDiskUse: true', you permit the MongoDB server to use temporary files for the aggregation process. This is a common requirement for complex analytics where the data working set is larger than the available RAM, ensuring that long-running operations can complete successfully without crashing due to memory exhaustion.

Answer

Increase the RAM allocated to the mongod process configuration.

Answer

Remove the $group stage and perform the grouping in application code.

Answer

Reduce the batch size in the cursor options.