Amazon AWS Certified Solutions Architect - Associate SAA-C03 Bundle

The option Set failover priority tiers on Aurora Replicas to favor the approved recovery target addresses a separate condition: an existing Aurora cluster has replicas but the least suitable replica is ranked first for writer promotion. Aurora failover uses replica priorities when selecting promotion candidates. The actual requirement is a regional outage requires a geographically separate Aurora read copy. Recommended corrective action: Deploy supported Aurora Global Database or cross-region replicas as appropriate. Regional replication shortens cross-region recovery setup.

For the alternative failure an app requires write consistency and mistakenly sends mutations to reader endpoint, the control Direct transactional writes to the Aurora writer endpoint is relevant: aurora readers do not accept ordinary writes. Here the evidence instead is a regional outage requires a geographically separate Aurora read copy. The selected technical mechanism is Deploy supported Aurora Global Database or cross-region replicas as appropriate: regional replication shortens cross-region recovery setup.

Use the Aurora cluster reader endpoint solves a different operational problem where an app requires read balancing across Aurora replicas. Reader endpoints route connections to replicas. It does not directly address a regional outage requires a geographically separate Aurora read copy. The case calls for Deploy supported Aurora Global Database or cross-region replicas as appropriate, since regional replication shortens cross-region recovery setup.

Spread hot keys or introduce controlled write sharding would help if on-demand DynamoDB experiences new hot partition despite overall capacity. Single-partition heat can throttle before table-wide capacity. That is not the symptom described here: users need to query orders by status and creation time, not the base table key. The matching response is Build a GSI with matching partition/sort key access pattern, because gSIs support alternate key queries.

Use DynamoDB conditional writes with a version attribute solves a different operational problem where a low-volume item needs atomic update only if its revision version matches. Conditional expressions enable optimistic concurrency control. It does not directly address users need to query orders by status and creation time, not the base table key. The case calls for Build a GSI with matching partition/sort key access pattern, since gSIs support alternate key queries.

The competing option Rewrite to Query against a well-distributed key schema would be useful when an item collection grows but the app scans the full table every request. Queries target partition ranges rather than entire tables. The present issue is users need to query orders by status and creation time, not the base table key; it is more directly addressed by Build a GSI with matching partition/sort key access pattern. GSIs support alternate key queries.

For the alternative failure users need to query orders by status and creation time, not the base table key, the control Build a GSI with matching partition/sort key access pattern is relevant: gSIs support alternate key queries. Here the evidence instead is a GSI query requires attributes not projected and causes extra application requests. The selected technical mechanism is Project only needed non-key fields into the GSI after evaluating size: index projection balances read performance and storage.

Use DynamoDB conditional writes with a version attribute solves a different operational problem where a low-volume item needs atomic update only if its revision version matches. Conditional expressions enable optimistic concurrency control. It does not directly address a GSI query requires attributes not projected and causes extra application requests. The case calls for Project only needed non-key fields into the GSI after evaluating size, since index projection balances read performance and storage.

The competing option Spread hot keys or introduce controlled write sharding would be useful when on-demand DynamoDB experiences new hot partition despite overall capacity. Single-partition heat can throttle before table-wide capacity. The present issue is a GSI query requires attributes not projected and causes extra application requests; it is more directly addressed by Project only needed non-key fields into the GSI after evaluating size. Index projection balances read performance and storage.

Project only needed non-key fields into the GSI after evaluating size solves a different operational problem where a GSI query requires attributes not projected and causes extra application requests. Index projection balances read performance and storage. It does not directly address an item collection grows but the app scans the full table every request. The case calls for Rewrite to Query against a well-distributed key schema, since queries target partition ranges rather than entire tables.

The competing option Spread hot keys or introduce controlled write sharding would be useful when on-demand DynamoDB experiences new hot partition despite overall capacity. Single-partition heat can throttle before table-wide capacity. The present issue is an item collection grows but the app scans the full table every request; it is more directly addressed by Rewrite to Query against a well-distributed key schema. Queries target partition ranges rather than entire tables.

Build a GSI with matching partition/sort key access pattern would help if users need to query orders by status and creation time, not the base table key. GSIs support alternate key queries. That is not the symptom described here: an item collection grows but the app scans the full table every request. The matching response is Rewrite to Query against a well-distributed key schema, because queries target partition ranges rather than entire tables.

The option Rewrite to Query against a well-distributed key schema addresses a separate condition: an item collection grows but the app scans the full table every request. Queries target partition ranges rather than entire tables. The actual requirement is on-demand DynamoDB experiences new hot partition despite overall capacity. Recommended corrective action: Spread hot keys or introduce controlled write sharding. Single-partition heat can throttle before table-wide capacity.

Project only needed non-key fields into the GSI after evaluating size would help if a GSI query requires attributes not projected and causes extra application requests. Index projection balances read performance and storage. That is not the symptom described here: on-demand DynamoDB experiences new hot partition despite overall capacity. The matching response is Spread hot keys or introduce controlled write sharding, because single-partition heat can throttle before table-wide capacity.

For the alternative failure users need to query orders by status and creation time, not the base table key, the control Build a GSI with matching partition/sort key access pattern is relevant: gSIs support alternate key queries. Here the evidence instead is on-demand DynamoDB experiences new hot partition despite overall capacity. The selected technical mechanism is Spread hot keys or introduce controlled write sharding: single-partition heat can throttle before table-wide capacity.

Spread hot keys or introduce controlled write sharding would help if on-demand DynamoDB experiences new hot partition despite overall capacity. Single-partition heat can throttle before table-wide capacity. That is not the symptom described here: a low-volume item needs atomic update only if its revision version matches. The matching response is Use DynamoDB conditional writes with a version attribute, because conditional expressions enable optimistic concurrency control.

For the alternative failure users need to query orders by status and creation time, not the base table key, the control Build a GSI with matching partition/sort key access pattern is relevant: gSIs support alternate key queries. Here the evidence instead is a low-volume item needs atomic update only if its revision version matches. The selected technical mechanism is Use DynamoDB conditional writes with a version attribute: conditional expressions enable optimistic concurrency control.

Rewrite to Query against a well-distributed key schema solves a different operational problem where an item collection grows but the app scans the full table every request. Queries target partition ranges rather than entire tables. It does not directly address a low-volume item needs atomic update only if its revision version matches. The case calls for Use DynamoDB conditional writes with a version attribute, since conditional expressions enable optimistic concurrency control.

Send strongly consistent reads to DynamoDB when required would help if cache nodes are expected to provide strongly consistent reads by default. DynamoDB accelerator caches do not replace all consistency semantics. That is not the symptom described here: a mostly static product description is repeatedly retrieved from DynamoDB. The matching response is Use DynamoDB Accelerator (DAX) if its read-through cache semantics fit, because dAX caches eligible DynamoDB requests for low-latency reads.

For the alternative failure relational analytics need billions of rows scanned quickly, the control Use Amazon Redshift or suitable analytical lake services is relevant: analytics warehouses optimize bulk columnar scans. Here the evidence instead is a mostly static product description is repeatedly retrieved from DynamoDB. The selected technical mechanism is Use DynamoDB Accelerator (DAX) if its read-through cache semantics fit: dAX caches eligible DynamoDB requests for low-latency reads.

Use DynamoDB global tables with regional access patterns solves a different operational problem where a global app needs millisecond primary-key reads in several regions. Replicated region-local data improves global latency. It does not directly address a mostly static product description is repeatedly retrieved from DynamoDB. The case calls for Use DynamoDB Accelerator (DAX) if its read-through cache semantics fit, since dAX caches eligible DynamoDB requests for low-latency reads.

For the alternative failure relational analytics need billions of rows scanned quickly, the control Use Amazon Redshift or suitable analytical lake services is relevant: analytics warehouses optimize bulk columnar scans. Here the evidence instead is cache nodes are expected to provide strongly consistent reads by default. The selected technical mechanism is Send strongly consistent reads to DynamoDB when required: dynamoDB accelerator caches do not replace all consistency semantics.

Use DynamoDB global tables with regional access patterns solves a different operational problem where a global app needs millisecond primary-key reads in several regions. Replicated region-local data improves global latency. It does not directly address cache nodes are expected to provide strongly consistent reads by default. The case calls for Send strongly consistent reads to DynamoDB when required, since dynamoDB accelerator caches do not replace all consistency semantics.

The competing option Use DynamoDB Accelerator (DAX) if its read-through cache semantics fit would be useful when a mostly static product description is repeatedly retrieved from DynamoDB. DAX caches eligible DynamoDB requests for low-latency reads. The present issue is cache nodes are expected to provide strongly consistent reads by default; it is more directly addressed by Send strongly consistent reads to DynamoDB when required. DynamoDB accelerator caches do not replace all consistency semantics.

Use DynamoDB Accelerator (DAX) if its read-through cache semantics fit solves a different operational problem where a mostly static product description is repeatedly retrieved from DynamoDB. DAX caches eligible DynamoDB requests for low-latency reads. It does not directly address relational analytics need billions of rows scanned quickly. The case calls for Use Amazon Redshift or suitable analytical lake services, since analytics warehouses optimize bulk columnar scans.

The competing option Materialize or cache approved aggregate results with refresh rules would be useful when the database struggles on repeated expensive aggregations of infrequently changing results. Precomputation trades freshness for lower query cost. The present issue is relational analytics need billions of rows scanned quickly; it is more directly addressed by Use Amazon Redshift or suitable analytical lake services. Analytics warehouses optimize bulk columnar scans.

Send strongly consistent reads to DynamoDB when required would help if cache nodes are expected to provide strongly consistent reads by default. DynamoDB accelerator caches do not replace all consistency semantics. That is not the symptom described here: relational analytics need billions of rows scanned quickly. The matching response is Use Amazon Redshift or suitable analytical lake services, because analytics warehouses optimize bulk columnar scans.

The competing option Send strongly consistent reads to DynamoDB when required would be useful when cache nodes are expected to provide strongly consistent reads by default. DynamoDB accelerator caches do not replace all consistency semantics. The present issue is a global app needs millisecond primary-key reads in several regions; it is more directly addressed by Use DynamoDB global tables with regional access patterns. Replicated region-local data improves global latency.

Use Amazon Redshift or suitable analytical lake services would help if relational analytics need billions of rows scanned quickly. Analytics warehouses optimize bulk columnar scans. That is not the symptom described here: a global app needs millisecond primary-key reads in several regions. The matching response is Use DynamoDB global tables with regional access patterns, because replicated region-local data improves global latency.

For the alternative failure a mostly static product description is repeatedly retrieved from DynamoDB, the control Use DynamoDB Accelerator (DAX) if its read-through cache semantics fit is relevant: dAX caches eligible DynamoDB requests for low-latency reads. Here the evidence instead is a global app needs millisecond primary-key reads in several regions. The selected technical mechanism is Use DynamoDB global tables with regional access patterns: replicated region-local data improves global latency.

The option Send strongly consistent reads to DynamoDB when required addresses a separate condition: cache nodes are expected to provide strongly consistent reads by default. DynamoDB accelerator caches do not replace all consistency semantics. The actual requirement is the database struggles on repeated expensive aggregations of infrequently changing results. Recommended corrective action: Materialize or cache approved aggregate results with refresh rules. Precomputation trades freshness for lower query cost.

For the alternative failure a global app needs millisecond primary-key reads in several regions, the control Use DynamoDB global tables with regional access patterns is relevant: replicated region-local data improves global latency. Here the evidence instead is the database struggles on repeated expensive aggregations of infrequently changing results. The selected technical mechanism is Materialize or cache approved aggregate results with refresh rules: precomputation trades freshness for lower query cost.

Use Amazon Redshift or suitable analytical lake services solves a different operational problem where relational analytics need billions of rows scanned quickly. Analytics warehouses optimize bulk columnar scans. It does not directly address the database struggles on repeated expensive aggregations of infrequently changing results. The case calls for Materialize or cache approved aggregate results with refresh rules, since precomputation trades freshness for lower query cost.