You save $69.98
DP-900 Premium Bundle
- Premium File 332 Questions & Answers
- Last Update: Nov 14, 2026
- Training Course 32 Lectures
- Study Guide 672 Pages
You save $69.98
A mobile app uploads user-generated documents directly as HTTP-addressed objects and must avoid giving every caller a storage account key. If the team ignores the targeted approach (Use Blob Storage with scoped authorized access such as appropriately permissioned SAS or identity-based requests.), which consequence or limitation MOST directly follows from leaving that requirement unaddressed?
Exposing the storage account root key gives broader permissions than the upload requires. This risk follows from the exact scenario: A mobile app uploads user-generated documents directly as HTTP-addressed objects and must avoid giving every caller a storage account key. The reason is blob authorization should be scoped to the needed operation and resource. The direct mitigation is: Use Blob Storage with scoped authorized access such as appropriately permissioned SAS or identity-based requests.
Choosing the offline Blob archive tier would require rehydration before ordinary access. This is a real potential problem in a different scenario: A backup archive contains objects rarely read but they must be retrieved without the separate archive rehydration process. The present case instead concerns A mobile app uploads user-generated documents directly as HTTP-addressed objects and must avoid giving every caller a storage account key. With the targeted action omitted, the direct exposure is Exposing the storage account root key gives broader permissions than the upload requires.
Treating the table as a SQL table with foreign keys assumes unsupported relational constraints. This is a real potential problem in a different scenario: A lightweight application stores sparse sensor settings keyed by region and sensor identifier. The present case instead concerns A mobile app uploads user-generated documents directly as HTTP-addressed objects and must avoid giving every caller a storage account key. With the targeted action omitted, the direct exposure is Exposing the storage account root key gives broader permissions than the upload requires.
Merely creating blob objects does not automatically synchronize the branch file server namespace. This is a real potential problem in a different scenario: A company wants to preserve file-server workflows locally while synchronizing an Azure file share as the central data copy. The present case instead concerns A mobile app uploads user-generated documents directly as HTTP-addressed objects and must avoid giving every caller a storage account key. With the targeted action omitted, the direct exposure is Exposing the storage account root key gives broader permissions than the upload requires.
A globally distributed app stores flexible JSON shopping carts and must scale without a fixed relational schema. Which solution or configuration choice MOST directly satisfies the stated requirement without changing unrelated behavior?
Use Azure Cosmos DB for NoSQL with an appropriate partition key. This directly addresses the case: A globally distributed app stores flexible JSON shopping carts and must scale without a fixed relational schema. The deciding technical reason is that cosmos DB for NoSQL stores JSON items in partitioned containers. Verify the solution by checking: Cart documents with optional properties are read by the app at the designed global scale.
Use the Azure Cosmos DB API for Apache Gremlin for graph-oriented access. This is a legitimate approach for a different problem: A connected-fraud model stores customers and transaction-to-account edges and queries multi-hop relationships. Gremlin models vertices, edges, and traversals for graph workloads. It does not directly satisfy the present constraint: A globally distributed app stores flexible JSON shopping carts and must scale without a fixed relational schema. The needed outcome is: Cart documents with optional properties are read by the app at the designed global scale.
Consider Azure Cosmos DB API for Apache Cassandra with verified CQL compatibility. This is a legitimate approach for a different problem: A legacy wide-column application uses Cassandra Query Language and needs a compatible globally distributed cloud endpoint. The Cassandra API provides compatibility for Cassandra-style wide-column clients. It does not directly satisfy the present constraint: A globally distributed app stores flexible JSON shopping carts and must scale without a fixed relational schema. The needed outcome is: Cart documents with optional properties are read by the app at the designed global scale.
Replicate the Cosmos DB account to selected regions and choose suitable read routing and consistency. This is a legitimate approach for a different problem: An enterprise configures multiple Cosmos DB regions and needs low-latency reads near international users. Cosmos DB supports global distribution and configurable consistency across regions. It does not directly satisfy the present constraint: A globally distributed app stores flexible JSON shopping carts and must scale without a fixed relational schema. The needed outcome is: Cart documents with optional properties are read by the app at the designed global scale.
A globally distributed app stores flexible JSON shopping carts and must scale without a fixed relational schema. A team proposes: Use Azure Cosmos DB for NoSQL with an appropriate partition key. Which observation would BEST demonstrate that this exact requirement was met?
Cart documents with optional properties are read by the app at the designed global scale. Cosmos DB for NoSQL stores JSON items in partitioned containers. It is tied to this case: A globally distributed app stores flexible JSON shopping carts and must scale without a fixed relational schema.
A Gremlin traversal finds connected entities across recorded edges. This would validate a different scenario: A connected-fraud model stores customers and transaction-to-account edges and queries multi-hop relationships. The proposed change here is Use Azure Cosmos DB for NoSQL with an appropriate partition key. and its decisive acceptance check is Cart documents with optional properties are read by the app at the designed global scale.
The CQL client reads and writes data using supported Cassandra operations. This would validate a different scenario: A legacy wide-column application uses Cassandra Query Language and needs a compatible globally distributed cloud endpoint. The proposed change here is Use Azure Cosmos DB for NoSQL with an appropriate partition key. and its decisive acceptance check is Cart documents with optional properties are read by the app at the designed global scale.
Readers in the configured regions use the designed replica path with documented consistency. This would validate a different scenario: An enterprise configures multiple Cosmos DB regions and needs low-latency reads near international users. The proposed change here is Use Azure Cosmos DB for NoSQL with an appropriate partition key. and its decisive acceptance check is Cart documents with optional properties are read by the app at the designed global scale.
During an architecture review, the team proposes: Use Azure Cosmos DB for NoSQL with an appropriate partition key. The requirement is: A globally distributed app stores flexible JSON shopping carts and must scale without a fixed relational schema. Which technical explanation BEST justifies this specific recommendation?
Cosmos DB for NoSQL stores JSON items in partitioned containers. Evidence would be: Cart documents with optional properties are read by the app at the designed global scale. The choice avoids this risk: Assuming every document has an identical set of relational columns undermines the flexible schema requirement.
Gremlin models vertices, edges, and traversals for graph workloads. That principle applies to the separate requirement: A connected-fraud model stores customers and transaction-to-account edges and queries multi-hop relationships. It may be true in that setting, but does not specifically explain why Use Azure Cosmos DB for NoSQL with an appropriate partition key. is the best fit here. The relevant reason is Cosmos DB for NoSQL stores JSON items in partitioned containers.
The Cassandra API provides compatibility for Cassandra-style wide-column clients. That principle applies to the separate requirement: A legacy wide-column application uses Cassandra Query Language and needs a compatible globally distributed cloud endpoint. It may be true in that setting, but does not specifically explain why Use Azure Cosmos DB for NoSQL with an appropriate partition key. is the best fit here. The relevant reason is Cosmos DB for NoSQL stores JSON items in partitioned containers.
Cosmos DB supports global distribution and configurable consistency across regions. That principle applies to the separate requirement: An enterprise configures multiple Cosmos DB regions and needs low-latency reads near international users. It may be true in that setting, but does not specifically explain why Use Azure Cosmos DB for NoSQL with an appropriate partition key. is the best fit here. The relevant reason is Cosmos DB for NoSQL stores JSON items in partitioned containers.
A globally distributed app stores flexible JSON shopping carts and must scale without a fixed relational schema. If the team ignores the targeted approach (Use Azure Cosmos DB for NoSQL with an appropriate partition key.), which consequence or limitation MOST directly follows from leaving that requirement unaddressed?
Assuming every document has an identical set of relational columns undermines the flexible schema requirement. This risk follows from the exact scenario: A globally distributed app stores flexible JSON shopping carts and must scale without a fixed relational schema. The reason is cosmos DB for NoSQL stores JSON items in partitioned containers. The direct mitigation is: Use Azure Cosmos DB for NoSQL with an appropriate partition key.
Storing the edges only as unrelated flat key-value rows makes graph traversals cumbersome. This is a real potential problem in a different scenario: A connected-fraud model stores customers and transaction-to-account edges and queries multi-hop relationships. The present case instead concerns A globally distributed app stores flexible JSON shopping carts and must scale without a fixed relational schema. With the targeted action omitted, the direct exposure is Assuming every document has an identical set of relational columns undermines the flexible schema requirement.
A MongoDB interface does not automatically accept Cassandra Query Language. This is a real potential problem in a different scenario: A legacy wide-column application uses Cassandra Query Language and needs a compatible globally distributed cloud endpoint. The present case instead concerns A globally distributed app stores flexible JSON shopping carts and must scale without a fixed relational schema. With the targeted action omitted, the direct exposure is Assuming every document has an identical set of relational columns undermines the flexible schema requirement.
A single distant region cannot automatically provide the same regional data locality. This is a real potential problem in a different scenario: An enterprise configures multiple Cosmos DB regions and needs low-latency reads near international users. The present case instead concerns A globally distributed app stores flexible JSON shopping carts and must scale without a fixed relational schema. With the targeted action omitted, the direct exposure is Assuming every document has an identical set of relational columns undermines the flexible schema requirement.
An existing application uses MongoDB drivers and query syntax and needs a compatible managed Azure service. Which solution or configuration choice MOST directly satisfies the stated requirement without changing unrelated behavior?
Choose the Azure Cosmos DB API for MongoDB option compatible with the application. This directly addresses the case: An existing application uses MongoDB drivers and query syntax and needs a compatible managed Azure service. The deciding technical reason is that cosmos DB for MongoDB exposes MongoDB-compatible interfaces. Verify the solution by checking: Existing MongoDB client operations function under the tested protocol compatibility subset.
Consider Azure Cosmos DB API for Apache Cassandra with verified CQL compatibility. This is a legitimate approach for a different problem: A legacy wide-column application uses Cassandra Query Language and needs a compatible globally distributed cloud endpoint. The Cassandra API provides compatibility for Cassandra-style wide-column clients. It does not directly satisfy the present constraint: An existing application uses MongoDB drivers and query syntax and needs a compatible managed Azure service. The needed outcome is: Existing MongoDB client operations function under the tested protocol compatibility subset.
Use the Azure Cosmos DB API for Apache Gremlin for graph-oriented access. This is a legitimate approach for a different problem: A connected-fraud model stores customers and transaction-to-account edges and queries multi-hop relationships. Gremlin models vertices, edges, and traversals for graph workloads. It does not directly satisfy the present constraint: An existing application uses MongoDB drivers and query syntax and needs a compatible managed Azure service. The needed outcome is: Existing MongoDB client operations function under the tested protocol compatibility subset.
Include the relevant partition key in targeted item lookups and review RU charges. This is a legitimate approach for a different problem: A distributed service sees unusually costly Cosmos DB queries that scan every customer partition despite always knowing CustomerId. Cosmos DB request units measure throughput consumption; key-based access can be efficient. It does not directly satisfy the present constraint: An existing application uses MongoDB drivers and query syntax and needs a compatible managed Azure service. The needed outcome is: Existing MongoDB client operations function under the tested protocol compatibility subset.
An existing application uses MongoDB drivers and query syntax and needs a compatible managed Azure service. A team proposes: Choose the Azure Cosmos DB API for MongoDB option compatible with the application. Which observation would BEST demonstrate that this exact requirement was met?
Existing MongoDB client operations function under the tested protocol compatibility subset. Cosmos DB for MongoDB exposes MongoDB-compatible interfaces. It is tied to this case: An existing application uses MongoDB drivers and query syntax and needs a compatible managed Azure service.
The CQL client reads and writes data using supported Cassandra operations. This would validate a different scenario: A legacy wide-column application uses Cassandra Query Language and needs a compatible globally distributed cloud endpoint. The proposed change here is Choose the Azure Cosmos DB API for MongoDB option compatible with the application. and its decisive acceptance check is Existing MongoDB client operations function under the tested protocol compatibility subset.
A Gremlin traversal finds connected entities across recorded edges. This would validate a different scenario: A connected-fraud model stores customers and transaction-to-account edges and queries multi-hop relationships. The proposed change here is Choose the Azure Cosmos DB API for MongoDB option compatible with the application. and its decisive acceptance check is Existing MongoDB client operations function under the tested protocol compatibility subset.
A point read obtains the intended item with a smaller measurable request charge. This would validate a different scenario: A distributed service sees unusually costly Cosmos DB queries that scan every customer partition despite always knowing CustomerId. The proposed change here is Choose the Azure Cosmos DB API for MongoDB option compatible with the application. and its decisive acceptance check is Existing MongoDB client operations function under the tested protocol compatibility subset.
During an architecture review, the team proposes: Choose the Azure Cosmos DB API for MongoDB option compatible with the application. The requirement is: An existing application uses MongoDB drivers and query syntax and needs a compatible managed Azure service. Which technical explanation BEST justifies this specific recommendation?
Cosmos DB for MongoDB exposes MongoDB-compatible interfaces. Evidence would be: Existing MongoDB client operations function under the tested protocol compatibility subset. The choice avoids this risk: Selecting the API for NoSQL without adapting the driver may break MongoDB wire-protocol expectations.
The Cassandra API provides compatibility for Cassandra-style wide-column clients. That principle applies to the separate requirement: A legacy wide-column application uses Cassandra Query Language and needs a compatible globally distributed cloud endpoint. It may be true in that setting, but does not specifically explain why Choose the Azure Cosmos DB API for MongoDB option compatible with the application. is the best fit here. The relevant reason is Cosmos DB for MongoDB exposes MongoDB-compatible interfaces.
Gremlin models vertices, edges, and traversals for graph workloads. That principle applies to the separate requirement: A connected-fraud model stores customers and transaction-to-account edges and queries multi-hop relationships. It may be true in that setting, but does not specifically explain why Choose the Azure Cosmos DB API for MongoDB option compatible with the application. is the best fit here. The relevant reason is Cosmos DB for MongoDB exposes MongoDB-compatible interfaces.
Cosmos DB request units measure throughput consumption; key-based access can be efficient. That principle applies to the separate requirement: A distributed service sees unusually costly Cosmos DB queries that scan every customer partition despite always knowing CustomerId. It may be true in that setting, but does not specifically explain why Choose the Azure Cosmos DB API for MongoDB option compatible with the application. is the best fit here. The relevant reason is Cosmos DB for MongoDB exposes MongoDB-compatible interfaces.
An existing application uses MongoDB drivers and query syntax and needs a compatible managed Azure service. If the team ignores the targeted approach (Choose the Azure Cosmos DB API for MongoDB option compatible with the application.), which consequence or limitation MOST directly follows from leaving that requirement unaddressed?
Selecting the API for NoSQL without adapting the driver may break MongoDB wire-protocol expectations. This risk follows from the exact scenario: An existing application uses MongoDB drivers and query syntax and needs a compatible managed Azure service. The reason is cosmos DB for MongoDB exposes MongoDB-compatible interfaces. The direct mitigation is: Choose the Azure Cosmos DB API for MongoDB option compatible with the application.
A MongoDB interface does not automatically accept Cassandra Query Language. This is a real potential problem in a different scenario: A legacy wide-column application uses Cassandra Query Language and needs a compatible globally distributed cloud endpoint. The present case instead concerns An existing application uses MongoDB drivers and query syntax and needs a compatible managed Azure service. With the targeted action omitted, the direct exposure is Selecting the API for NoSQL without adapting the driver may break MongoDB wire-protocol expectations.
Storing the edges only as unrelated flat key-value rows makes graph traversals cumbersome. This is a real potential problem in a different scenario: A connected-fraud model stores customers and transaction-to-account edges and queries multi-hop relationships. The present case instead concerns An existing application uses MongoDB drivers and query syntax and needs a compatible managed Azure service. With the targeted action omitted, the direct exposure is Selecting the API for NoSQL without adapting the driver may break MongoDB wire-protocol expectations.
Cross-partition scans use more resources when the partition and id are already known. This is a real potential problem in a different scenario: A distributed service sees unusually costly Cosmos DB queries that scan every customer partition despite always knowing CustomerId. The present case instead concerns An existing application uses MongoDB drivers and query syntax and needs a compatible managed Azure service. With the targeted action omitted, the direct exposure is Selecting the API for NoSQL without adapting the driver may break MongoDB wire-protocol expectations.
A connected-fraud model stores customers and transaction-to-account edges and queries multi-hop relationships. Which solution or configuration choice MOST directly satisfies the stated requirement without changing unrelated behavior?
Use the Azure Cosmos DB API for Apache Gremlin for graph-oriented access. This directly addresses the case: A connected-fraud model stores customers and transaction-to-account edges and queries multi-hop relationships. The deciding technical reason is that gremlin models vertices, edges, and traversals for graph workloads. Verify the solution by checking: A Gremlin traversal finds connected entities across recorded edges.
Use Azure Cosmos DB for NoSQL with an appropriate partition key. This is a legitimate approach for a different problem: A globally distributed app stores flexible JSON shopping carts and must scale without a fixed relational schema. Cosmos DB for NoSQL stores JSON items in partitioned containers. It does not directly satisfy the present constraint: A connected-fraud model stores customers and transaction-to-account edges and queries multi-hop relationships. The needed outcome is: A Gremlin traversal finds connected entities across recorded edges.
Evaluate Azure Cosmos DB for Table while confirming supported behavior differences. This is a legitimate approach for a different problem: A customer currently uses Azure Table Storage SDK entities and wants global distribution with a familiar Table API. Cosmos DB for Table provides Table-compatible entity operations with added distribution capabilities. It does not directly satisfy the present constraint: A connected-fraud model stores customers and transaction-to-account edges and queries multi-hop relationships. The needed outcome is: A Gremlin traversal finds connected entities across recorded edges.
Design a partition key that distributes request traffic and aligns with frequent queries. This is a legitimate approach for a different problem: An event application places every device event into one Cosmos DB logical partition despite heavy ingestion from many regions. Cosmos DB partition keys shape data placement and request distribution. It does not directly satisfy the present constraint: A connected-fraud model stores customers and transaction-to-account edges and queries multi-hop relationships. The needed outcome is: A Gremlin traversal finds connected entities across recorded edges.
A connected-fraud model stores customers and transaction-to-account edges and queries multi-hop relationships. A team proposes: Use the Azure Cosmos DB API for Apache Gremlin for graph-oriented access. Which observation would BEST demonstrate that this exact requirement was met?
A Gremlin traversal finds connected entities across recorded edges. Gremlin models vertices, edges, and traversals for graph workloads. It is tied to this case: A connected-fraud model stores customers and transaction-to-account edges and queries multi-hop relationships.
Cart documents with optional properties are read by the app at the designed global scale. This would validate a different scenario: A globally distributed app stores flexible JSON shopping carts and must scale without a fixed relational schema. The proposed change here is Use the Azure Cosmos DB API for Apache Gremlin for graph-oriented access. and its decisive acceptance check is A Gremlin traversal finds connected entities across recorded edges.
The Azure Tables SDK accesses the migrated key/attribute records using its intended account type. This would validate a different scenario: A customer currently uses Azure Table Storage SDK entities and wants global distribution with a familiar Table API. The proposed change here is Use the Azure Cosmos DB API for Apache Gremlin for graph-oriented access. and its decisive acceptance check is A Gremlin traversal finds connected entities across recorded edges.
Requests distribute across relevant logical partitions without a single hot tenant key. This would validate a different scenario: An event application places every device event into one Cosmos DB logical partition despite heavy ingestion from many regions. The proposed change here is Use the Azure Cosmos DB API for Apache Gremlin for graph-oriented access. and its decisive acceptance check is A Gremlin traversal finds connected entities across recorded edges.
or Guarantee your success by buying the full version which covers the full latest pool of questions. (332 Questions, Last Updated on Nov 14, 2026)
Please check your mailbox for a message from support@examlabs.com and follow the directions.