Question 440
A design review identifies: A Cosmos DB container contains temporary sessions that should expire automatically thirty days after creation unless renewed. The failure is: Old session JSON documents accumulate indefinitely until a manual cleanup job runs. Select TWO distinct decisions that together provide the immediate technical solution AND an ongoing prevention control. A verification-only step does not replace either responsibility.
- Configure supported Azure Cosmos DB multi-region writes with an explicit conflict resolution strategy and appropriate consistency.
- Consume the appropriate Azure Cosmos DB change feed with a checkpointed processor for the supported API.
- Monitor partition key distribution and provisioned/request-unit usage before scaling.
- Configure Cosmos DB time-to-live behavior for the container or items as appropriate.
- Monitor TTL policy and RU consumption when session expiration rates increase.
Explanation
Correct Answers
D:The evidence (Old session JSON documents accumulate indefinitely until a manual cleanup job runs.) identifies the following cause: TTL was not enabled for the required automatic item expiration lifecycle. The design that removes it is: Configure Cosmos DB time-to-live behavior for the container or items as appropriate. The acceptance check is: Create a short-lived item and confirm expiration is enforced without a separate cleanup service.
E:The key follow-up control is: Monitor TTL policy and RU consumption when session expiration rates increase. It avoids recurrence of the scenario in which: Old session JSON documents accumulate indefinitely until a manual cleanup job runs. It addresses: TTL was not enabled for the required automatic item expiration lifecycle.
Incorrect Answers
A:Multi-region writes address distributed availability and conflicts; they do not configure a 30-day item expiry policy for temporary sessions.
B:The change feed records item changes for processing, but it does not automatically expire old session documents without a TTL policy.
C:Partition and request-unit monitoring can support capacity management, but it does not provide the TTL-based automatic deletion described in the requirement.
Question 441
A design workshop has this requirement: A customer data platform must trigger downstream work on inserts and updates in Cosmos DB without full-container scans. Operators currently observe: A nightly full scan misses time-sensitive document updates. Select the ONE design remedy that best addresses the root cause.
- Consume the appropriate Azure Cosmos DB change feed with a checkpointed processor for the supported API.
- Configure supported Azure Cosmos DB multi-region writes with an explicit conflict resolution strategy and appropriate consistency.
- Redesign the logical partition key or introduce an appropriate synthetic/hierarchical key strategy to distribute hot requests.
- Configure Cosmos DB time-to-live behavior for the container or items as appropriate.
Explanation
Correct Answer
A:The targeted implementation is: Consume the appropriate Azure Cosmos DB change feed with a checkpointed processor for the supported API. The problem is not generic resource availability: No change feed consumer exists for incremental document changes. Verify the result by: Insert and update a test document and confirm change feed processor receives it with tracked continuation state.
Incorrect Answers
B:The alternative diagnosis “Configure supported Azure Cosmos DB multi-region writes with an explicit conflict resolution strategy and appropriate consistency” does not match the observed symptom: A nightly full scan misses time-sensitive document updates. The targeted implementation is: Consume the appropriate Azure Cosmos DB change feed with a checkpointed processor for the supported API. The problem is not generic resource availability: No change feed consumer exists for incremental document changes. The evidence instead supports “Consume the appropriate Azure Cosmos DB change feed with a checkpointed processor for the supported API”.
C:The alternative diagnosis “Redesign the logical partition key or introduce an appropriate synthetic/hierarchical key strategy to distribute hot requests” does not match the observed symptom: A nightly full scan misses time-sensitive document updates. The targeted implementation is: Consume the appropriate Azure Cosmos DB change feed with a checkpointed processor for the supported API. The problem is not generic resource availability: No change feed consumer exists for incremental document changes. The evidence instead supports “Consume the appropriate Azure Cosmos DB change feed with a checkpointed processor for the supported API”.
D:The alternative diagnosis “Configure Cosmos DB time-to-live behavior for the container or items as appropriate” does not match the observed symptom: A nightly full scan misses time-sensitive document updates. The targeted implementation is: Consume the appropriate Azure Cosmos DB change feed with a checkpointed processor for the supported API. The problem is not generic resource availability: No change feed consumer exists for incremental document changes. The evidence instead supports “Consume the appropriate Azure Cosmos DB change feed with a checkpointed processor for the supported API”.
Question 442
The planned architecture is: Consume the appropriate Azure Cosmos DB change feed with a checkpointed processor for the supported API. Workload context: A customer data platform must trigger downstream work on inserts and updates in Cosmos DB without full-container scans. Which acceptance test demonstrates that the required behavior works?
- Insert and update a test document and confirm change feed processor receives it with tracked continuation state.
- Create a short-lived item and confirm expiration is enforced without a separate cleanup service.
- Compare request-unit throttling and logical partition distribution before and after the key design.
- Write from two configured regions and verify cross-region propagation and conflict outcomes under controlled concurrent updates.
Explanation
Correct Answer
A:The decisive evidence is: Insert and update a test document and confirm change feed processor receives it with tracked continuation state. This measures the mechanism of the planned change, not an unrelated Azure service: Consume the appropriate Azure Cosmos DB change feed with a checkpointed processor for the supported API.
Incorrect Answers
B:The decisive evidence is: Insert and update a test document and confirm change feed processor receives it with tracked continuation state.
C:That observation pertains to a separate failure: One logical partition gets 429 throttles despite plenty of total provisioned RU/s. Its cause is: The partition key concentrates high-throughput tenant traffic into a hot logical partition. It does not confirm the result of this design. The direct proof would be: Insert and update a test document and confirm change feed processor receives it with tracked continuation state.
D:The alternative test targets: Configure supported Azure Cosmos DB multi-region writes with an explicit conflict resolution strategy and appropriate consistency. The scenario's actual proposed remedy is: Consume the appropriate Azure Cosmos DB change feed with a checkpointed processor for the supported API. Verify that one by: Insert and update a test document and confirm change feed processor receives it with tracked continuation state.
Question 443
The customer states: A customer data platform must trigger downstream work on inserts and updates in Cosmos DB without full-container scans. An incident reveals: A nightly full scan misses time-sensitive document updates. What cause best accounts for this evidence?
- The partition key concentrates high-throughput tenant traffic into a hot logical partition.
- No change feed consumer exists for incremental document changes.
- TTL was not enabled for the required automatic item expiration lifecycle.
- Multi-region write capability and conflict resolution were not designed for the active-active requirement.
Explanation
Correct Answer
B:The incident is explained by: No change feed consumer exists for incremental document changes. The reported symptom is: A nightly full scan misses time-sensitive document updates. The corresponding design fix is: Consume the appropriate Azure Cosmos DB change feed with a checkpointed processor for the supported API.
Incorrect Answers
A:The partition key concentrates high-throughput tenant traffic into a hot logical partition. No change feed consumer exists for incremental document changes.
C:TTL was not enabled for the required automatic item expiration lifecycle. No change feed consumer exists for incremental document changes.
D:Multi-region write capability and conflict resolution were not designed for the active-active requirement. No change feed consumer exists for incremental document changes.
Question 444
Workload context: A customer data platform must trigger downstream work on inserts and updates in Cosmos DB without full-container scans. The implemented remedy is: Consume the appropriate Azure Cosmos DB change feed with a checkpointed processor for the supported API. Which ongoing practice most specifically prevents recurrence of this failure: A nightly full scan misses time-sensitive document updates.?
- Persist checkpoints and make downstream processing idempotent for retries/replays.
- Monitor replication and conflict metrics, documenting bounded consistency tradeoffs.
- Review top partition keys and request charge distribution as tenant traffic patterns change.
- Monitor TTL policy and RU consumption when session expiration rates increase.
Explanation
Correct Answer
A:The key follow-up control is: Persist checkpoints and make downstream processing idempotent for retries/replays. It avoids recurrence of the scenario in which: A nightly full scan misses time-sensitive document updates. It addresses: No change feed consumer exists for incremental document changes.
Incorrect Answers
B:Monitoring replication and conflict metrics, documenting bounded consistency tradeoffs would not address the need for persist checkpoints and make downstream processing idempotent for retries/replays.
C:Reviewing top partition keys and requesting charge distribution as tenant traffic patterns change would not address the need for persist checkpoints and make downstream processing idempotent for retries/replays.
D:Monitoring TTL policy and RU consumption when session expiration rates increase would not address the need for persist checkpoints and make downstream processing idempotent for retries/replays.
Question 445
A solution architect is reviewing a workload: A key-value application holds simple per-entity attributes with massive horizontal scale and does not need relational joins. The observed incident is: SQL JOINs are purchased for a workload that only retrieves small records by composite key. Which architecture choice most directly removes the identified weakness?
- Select Azure Cosmos DB for NoSQL with an appropriate partition key and RU/s model when its APIs meet the workload.
- Use Azure Table Storage or compatible table API with partition/row keys chosen for access patterns.
- Choose Azure Blob Storage with suitable access tier and lifecycle rules rather than a relational database BLOB column.
- Redesign the logical partition key or introduce an appropriate synthetic/hierarchical key strategy to distribute hot requests.
Explanation
Correct Answer
B:The evidence (SQL JOINs are purchased for a workload that only retrieves small records by composite key.) identifies the following cause: Relational database services were chosen despite a simple scalable key-attribute access pattern. The design that removes it is: Use Azure Table Storage or compatible table API with partition/row keys chosen for access patterns. The acceptance check is: Issue point entity queries with partition and row keys and confirm performance and scale behavior.
Incorrect Answers
A:Selecting Azure Cosmos DB for NoSQL with an appropriate partition key and RU/s model when its APIs meet the workload would not meet the need for Azure Table Storage or compatible table API with partition/row keys chosen for access patterns.
C:Choosing Azure Blob Storage with suitable access tier and lifecycle rules rather than a relational database BLOB column would not meet the need for Azure Table Storage or compatible table API with partition/row keys chosen for access patterns.
D:Redesigning the logical partition key or introduce an appropriate synthetic/hierarchical key strategy to distribute hot requests would not meet the need for Azure Table Storage or compatible table API with partition/row keys chosen for access patterns.
Question 446
An architect proposes this change: Use Azure Table Storage or compatible table API with partition/row keys chosen for access patterns. The workload context is: A key-value application holds simple per-entity attributes with massive horizontal scale and does not need relational joins. Which evidence would most directly validate the change?
- Upload a sample object and verify HTTP object retrieval, metadata and lifecycle behavior.
- Compare request-unit throttling and logical partition distribution before and after the key design.
- Issue point entity queries with partition and row keys and confirm performance and scale behavior.
- Insert heterogeneous JSON documents and measure point reads using full partition-key and item-ID values.
Explanation
Correct Answer
C:The decisive evidence is: Issue point entity queries with partition and row keys and confirm performance and scale behavior. This measures the mechanism of the planned change, not an unrelated Azure service: Use Azure Table Storage or compatible table API with partition/row keys chosen for access patterns.
Incorrect Answers
A:Upload a sample object and verify HTTP object retrieval, metadata and lifecycle behavior would not issue point entity queries with partition and row keys and confirm performance and scale behavior.
B:That observation pertains to a separate failure: One logical partition gets 429 throttles despite plenty of total provisioned RU/s. Its cause is: The partition key concentrates high-throughput tenant traffic into a hot logical partition. It does not confirm the result of this design. The direct proof would be: Issue point entity queries with partition and row keys and confirm performance and scale behavior.
D:Insert heterogeneous JSON documents and measure point reads using full partition-key and item-ID values would not issue point entity queries with partition and row keys and confirm performance and scale behavior.
Question 447
During architecture troubleshooting, a team reports: SQL JOINs are purchased for a workload that only retrieves small records by composite key. Context: A key-value application holds simple per-entity attributes with massive horizontal scale and does not need relational joins. Which underlying design mistake explains the observed behavior most precisely?
- The partition key concentrates high-throughput tenant traffic into a hot logical partition.
- Relational database services were chosen despite a simple scalable key-attribute access pattern.
- The datastore was chosen without matching the flexible document and multi-region serving requirements.
- Object storage's independent capacity and access tiers were not used for unstructured media.
Explanation
Correct Answer
B:This is the failure mechanism rather than an incidental symptom: Relational database services were chosen despite a simple scalable key-attribute access pattern. It accounts for: SQL JOINs are purchased for a workload that only retrieves small records by composite key. The architectural repair is: Use Azure Table Storage or compatible table API with partition/row keys chosen for access patterns.
Incorrect Answers
A:The alternative diagnosis “The partition key concentrates high-throughput tenant traffic into a hot logical partition” does not match the observed symptom: SQL JOINs are purchased for a workload that only retrieves small records by composite key. Context: A key-value application holds simple per-entity attributes with massive horizontal scale and does not need relational joins. This is the failure mechanism rather than an incidental symptom: Relational database services were chosen despite a simple scalable key-attribute access pattern. It accounts for: SQL JOINs are purchased for a workload that only retrieves small records by composite key. The evidence instead supports “Relational database services were chosen despite a simple scalable key-attribute access pattern”.
C:The alternative diagnosis “The datastore was chosen without matching the flexible document and multi-region serving requirements” does not match the observed symptom: SQL JOINs are purchased for a workload that only retrieves small records by composite key. Context: A key-value application holds simple per-entity attributes with massive horizontal scale and does not need relational joins. This is the failure mechanism rather than an incidental symptom: Relational database services were chosen despite a simple scalable key-attribute access pattern. It accounts for: SQL JOINs are purchased for a workload that only retrieves small records by composite key. The evidence instead supports “Relational database services were chosen despite a simple scalable key-attribute access pattern”.
D:The alternative diagnosis “Object storage's independent capacity and access tiers were not used for unstructured media” does not match the observed symptom: SQL JOINs are purchased for a workload that only retrieves small records by composite key. Context: A key-value application holds simple per-entity attributes with massive horizontal scale and does not need relational joins. This is the failure mechanism rather than an incidental symptom: Relational database services were chosen despite a simple scalable key-attribute access pattern. It accounts for: SQL JOINs are purchased for a workload that only retrieves small records by composite key. The evidence instead supports “Relational database services were chosen despite a simple scalable key-attribute access pattern”.
Question 448
The design change is: Use Azure Table Storage or compatible table API with partition/row keys chosen for access patterns. The original failure was: SQL JOINs are purchased for a workload that only retrieves small records by composite key. Which ongoing control best prevents recurrence of the same root cause?
- Monitor partition key distribution and provisioned/request-unit usage before scaling.
- Review top partition keys and request charge distribution as tenant traffic patterns change.
- Validate hot partitions and query patterns as entity counts increase.
- Review blob lifecycle and access policies when data temperature changes.
Explanation
Correct Answer
C:The key follow-up control is: Validate hot partitions and query patterns as entity counts increase. It avoids recurrence of the scenario in which: SQL JOINs are purchased for a workload that only retrieves small records by composite key. It addresses: Relational database services were chosen despite a simple scalable key-attribute access pattern.
Incorrect Answers
A:The alternative diagnosis “Monitor partition key distribution and provisioned/request-unit usage before scaling” does not match the observed symptom: The design change is: Use Azure Table Storage or compatible table API with partition/row keys chosen for access patterns. The original failure was: SQL JOINs are purchased for a workload that only retrieves small records by composite key. Which ongoing control best prevents recurrence of the same root cause?. The key follow-up control is: Validate hot partitions and query patterns as entity counts increase. It avoids recurrence of the scenario in which: SQL JOINs are purchased for a workload that only retrieves small records by composite key. The evidence instead supports “Validate hot partitions and query patterns as entity counts increase”.
B:The alternative diagnosis “Review top partition keys and request charge distribution as tenant traffic patterns change” does not match the observed symptom: The design change is: Use Azure Table Storage or compatible table API with partition/row keys chosen for access patterns. The original failure was: SQL JOINs are purchased for a workload that only retrieves small records by composite key. Which ongoing control best prevents recurrence of the same root cause?. The key follow-up control is: Validate hot partitions and query patterns as entity counts increase. It avoids recurrence of the scenario in which: SQL JOINs are purchased for a workload that only retrieves small records by composite key. The evidence instead supports “Validate hot partitions and query patterns as entity counts increase”.
D:The alternative diagnosis “Review blob lifecycle and access policies when data temperature changes” does not match the observed symptom: The design change is: Use Azure Table Storage or compatible table API with partition/row keys chosen for access patterns. The original failure was: SQL JOINs are purchased for a workload that only retrieves small records by composite key. Which ongoing control best prevents recurrence of the same root cause?. The key follow-up control is: Validate hot partitions and query patterns as entity counts increase. It avoids recurrence of the scenario in which: SQL JOINs are purchased for a workload that only retrieves small records by composite key. The evidence instead supports “Validate hot partitions and query patterns as entity counts increase”.
Question 449
A design workshop has this requirement: A retailer must copy nightly data from an on-prem SQL Server to Azure Data Lake, with parameterized pipelines and scheduled retries. Operators currently observe: The pipeline cannot access a private on-prem SQL instance using only Azure-hosted integration runtime. Select the ONE design remedy that best addresses the root cause.
- Use Azure Databricks or supported managed Spark compute with storage access through managed identities where supported.
- Use Azure Data Factory with supported linked services, self-hosted integration runtime and a scheduled copy pipeline.
- Use Data Factory managed identity and Key Vault-backed linked service secret references or identity-based access where supported.
- Use Azure Data Factory pipelines with activity dependencies, parameters and failure branches.
Explanation
Correct Answer
B:The targeted implementation is: Use Azure Data Factory with supported linked services, self-hosted integration runtime and a scheduled copy pipeline. The problem is not generic resource availability: A suitable self-hosted connectivity runtime was not provided for private data movement. Verify the result by: Run the pipeline and compare source/target counts and integration-runtime activity logs.
Incorrect Answers
A:The alternative diagnosis “Use Azure Databricks or supported managed Spark compute with storage access through managed identities where supported” does not match the observed symptom: The pipeline cannot access a private on-prem SQL instance using only Azure-hosted integration runtime. The targeted implementation is: Use Azure Data Factory with supported linked services, self-hosted integration runtime and a scheduled copy pipeline. The problem is not generic resource availability: A suitable self-hosted connectivity runtime was not provided for private data movement. The evidence instead supports “Use Azure Data Factory with supported linked services, self-hosted integration runtime and a scheduled copy pipeline”.
C:The alternative diagnosis “Use Data Factory managed identity and Key Vault-backed linked service secret references or identity-based access where supported” does not match the observed symptom: The pipeline cannot access a private on-prem SQL instance using only Azure-hosted integration runtime. The targeted implementation is: Use Azure Data Factory with supported linked services, self-hosted integration runtime and a scheduled copy pipeline. The problem is not generic resource availability: A suitable self-hosted connectivity runtime was not provided for private data movement. The evidence instead supports “Use Azure Data Factory with supported linked services, self-hosted integration runtime and a scheduled copy pipeline”.
D:The alternative diagnosis “Use Azure Data Factory pipelines with activity dependencies, parameters and failure branches” does not match the observed symptom: The pipeline cannot access a private on-prem SQL instance using only Azure-hosted integration runtime. The targeted implementation is: Use Azure Data Factory with supported linked services, self-hosted integration runtime and a scheduled copy pipeline. The problem is not generic resource availability: A suitable self-hosted connectivity runtime was not provided for private data movement. The evidence instead supports “Use Azure Data Factory with supported linked services, self-hosted integration runtime and a scheduled copy pipeline”.
Question 450
The planned architecture is: Use Azure Data Factory with supported linked services, self-hosted integration runtime and a scheduled copy pipeline. Workload context: A retailer must copy nightly data from an on-prem SQL Server to Azure Data Lake, with parameterized pipelines and scheduled retries. Which acceptance test demonstrates that the required behavior works?
- Run a controlled pipeline and verify downstream activities execute only when prerequisite steps succeed.
- Run the pipeline and compare source/target counts and integration-runtime activity logs.
- Run a Spark transformation, inspect output parquet partitions and compare row counts to input.
- Rotate a test secret and verify the pipeline continues with approved identity and network access.
Explanation
Correct Answer
B:The decisive evidence is: Run the pipeline and compare source/target counts and integration-runtime activity logs. This measures the mechanism of the planned change, not an unrelated Azure service: Use Azure Data Factory with supported linked services, self-hosted integration runtime and a scheduled copy pipeline.
Incorrect Answers
A:That observation pertains to a separate failure: Downstream joins run before required source datasets are loaded. Its cause is: The orchestration omitted required activity dependencies and validation guards. It does not confirm the result of this design. The direct proof would be: Run the pipeline and compare source/target counts and integration-runtime activity logs.
C:This measures the mechanism of the planned change, not an unrelated Azure service: Use Azure Data Factory with supported linked services, self-hosted integration runtime and a scheduled copy pipeline.
D:That observation pertains to a separate failure: The integration pipeline fails when a hard-coded database password expires. Its cause is: Credential management was not separated from pipeline definitions and access scopes. It does not confirm the result of this design. The direct proof would be: Run the pipeline and compare source/target counts and integration-runtime activity logs.
Designing Microsoft Azure Infrastructure Solutions (AZ-305) Practice Tests