Amazon AWS Certified Solutions Architect - Associate SAA-C03 Bundle

Create AWS Backup copies to a protected backup vault in a separate account would help if a production table's backups require immutable cross-account custody. Cross-account vaults separate recovery control planes. That is not the symptom described here: a data analyst needs to identify personally sensitive S3 objects without moving them. The matching response is Use Amazon Macie classification results on the target buckets, because macie examines S3 data for sensitive content patterns.

For the alternative failure a DynamoDB table must be recoverable to a point within the recent history window, the control Enable DynamoDB point-in-time recovery for the table is relevant: pITR continuously protects eligible table state within the recovery window. Here the evidence instead is a data analyst needs to identify personally sensitive S3 objects without moving them. The selected technical mechanism is Use Amazon Macie classification results on the target buckets: macie examines S3 data for sensitive content patterns.

Supply only the required restore permissions and test recovery in isolation solves a different operational problem where a restore drill fails because service-linked IAM permissions are missing. Restore authorization is necessary even with usable backup data. It does not directly address a data analyst needs to identify personally sensitive S3 objects without moving them. The case calls for Use Amazon Macie classification results on the target buckets, since macie examines S3 data for sensitive content patterns.

Publish events to an SNS topic with multiple subscriptions would help if order-created events must reach billing, analytics, and fulfillment independently. SNS fanout delivers one event to separate subscribers. That is not the symptom described here: checkout requests time out while waiting for the inventory worker. The matching response is Buffer inventory work in Amazon SQS and process asynchronously, because a queue separates request latency from worker completion.

For the alternative failure poison messages repeatedly fail the same worker and block throughput, the control Configure an SQS dead-letter queue and appropriate redrive threshold is relevant: dLQs isolate repeatedly failing messages for inspection. Here the evidence instead is checkout requests time out while waiting for the inventory worker. The selected technical mechanism is Buffer inventory work in Amazon SQS and process asynchronously: a queue separates request latency from worker completion.

The competing option Make the consumer idempotent and delete a message only after success would be useful when a worker can receive the same message again after a visibility timeout. SQS delivery is at least once and retries require replay-safe processing. The present issue is checkout requests time out while waiting for the inventory worker; it is more directly addressed by Buffer inventory work in Amazon SQS and process asynchronously. A queue separates request latency from worker completion.

For the alternative failure a worker can receive the same message again after a visibility timeout, the control Make the consumer idempotent and delete a message only after success is relevant: sQS delivery is at least once and retries require replay-safe processing. Here the evidence instead is order-created events must reach billing, analytics, and fulfillment independently. The selected technical mechanism is Publish events to an SNS topic with multiple subscriptions: sNS fanout delivers one event to separate subscribers.

Configure an SQS dead-letter queue and appropriate redrive threshold solves a different operational problem where poison messages repeatedly fail the same worker and block throughput. DLQs isolate repeatedly failing messages for inspection. It does not directly address order-created events must reach billing, analytics, and fulfillment independently. The case calls for Publish events to an SNS topic with multiple subscriptions, since sNS fanout delivers one event to separate subscribers.

The option Buffer inventory work in Amazon SQS and process asynchronously addresses a separate condition: checkout requests time out while waiting for the inventory worker. A queue separates request latency from worker completion. The actual requirement is order-created events must reach billing, analytics, and fulfillment independently. Recommended corrective action: Publish events to an SNS topic with multiple subscriptions. SNS fanout delivers one event to separate subscribers.

The competing option Auto scale consumers using queue depth and age of oldest message would be useful when the queue backlog grows under flash-sale load. Queue metrics reveal when worker capacity lags submissions. The present issue is a worker can receive the same message again after a visibility timeout; it is more directly addressed by Make the consumer idempotent and delete a message only after success. SQS delivery is at least once and retries require replay-safe processing.

The option Buffer inventory work in Amazon SQS and process asynchronously addresses a separate condition: checkout requests time out while waiting for the inventory worker. A queue separates request latency from worker completion. The actual requirement is a worker can receive the same message again after a visibility timeout. Recommended corrective action: Make the consumer idempotent and delete a message only after success. SQS delivery is at least once and retries require replay-safe processing.

Configure an SQS dead-letter queue and appropriate redrive threshold would help if poison messages repeatedly fail the same worker and block throughput. DLQs isolate repeatedly failing messages for inspection. That is not the symptom described here: a worker can receive the same message again after a visibility timeout. The matching response is Make the consumer idempotent and delete a message only after success, because sQS delivery is at least once and retries require replay-safe processing.

The option Publish events to an SNS topic with multiple subscriptions addresses a separate condition: order-created events must reach billing, analytics, and fulfillment independently. SNS fanout delivers one event to separate subscribers. The actual requirement is the queue backlog grows under flash-sale load. Recommended corrective action: Auto scale consumers using queue depth and age of oldest message. Queue metrics reveal when worker capacity lags submissions.

Configure an SQS dead-letter queue and appropriate redrive threshold would help if poison messages repeatedly fail the same worker and block throughput. DLQs isolate repeatedly failing messages for inspection. That is not the symptom described here: the queue backlog grows under flash-sale load. The matching response is Auto scale consumers using queue depth and age of oldest message, because queue metrics reveal when worker capacity lags submissions.

For the alternative failure checkout requests time out while waiting for the inventory worker, the control Buffer inventory work in Amazon SQS and process asynchronously is relevant: a queue separates request latency from worker completion. Here the evidence instead is the queue backlog grows under flash-sale load. The selected technical mechanism is Auto scale consumers using queue depth and age of oldest message: queue metrics reveal when worker capacity lags submissions.

The option Publish events to an SNS topic with multiple subscriptions addresses a separate condition: order-created events must reach billing, analytics, and fulfillment independently. SNS fanout delivers one event to separate subscribers. The actual requirement is poison messages repeatedly fail the same worker and block throughput. Recommended corrective action: Configure an SQS dead-letter queue and appropriate redrive threshold. DLQs isolate repeatedly failing messages for inspection.

Auto scale consumers using queue depth and age of oldest message would help if the queue backlog grows under flash-sale load. Queue metrics reveal when worker capacity lags submissions. That is not the symptom described here: poison messages repeatedly fail the same worker and block throughput. The matching response is Configure an SQS dead-letter queue and appropriate redrive threshold, because dLQs isolate repeatedly failing messages for inspection.

Buffer inventory work in Amazon SQS and process asynchronously solves a different operational problem where checkout requests time out while waiting for the inventory worker. A queue separates request latency from worker completion. It does not directly address poison messages repeatedly fail the same worker and block throughput. The case calls for Configure an SQS dead-letter queue and appropriate redrive threshold, since dLQs isolate repeatedly failing messages for inspection.

Assign a client idempotency token and deduplicate on the backend would help if a client retries the same create request and duplicates an order. Idempotency keys make retried writes safe. That is not the symptom described here: web clients require a managed HTTPS entry for Lambda operations. The matching response is Use Amazon API Gateway with Lambda integration, because API Gateway fronts serverless APIs and routing.

For the alternative failure long-running video conversions exceed Lambda's maximum execution duration, the control Use AWS Step Functions plus suitable ECS/Batch tasks for longer jobs is relevant: orchestrated workloads avoid Lambda runtime-duration limits. Here the evidence instead is web clients require a managed HTTPS entry for Lambda operations. The selected technical mechanism is Use Amazon API Gateway with Lambda integration: API Gateway fronts serverless APIs and routing.

The competing option Apply reserved or provisioned concurrency and upstream retry/backpressure strategy as appropriate would be useful when lambda concurrency limits cause 429 and throttling during promotions. Lambda concurrency controls bound simultaneous executions. The present issue is web clients require a managed HTTPS entry for Lambda operations; it is more directly addressed by Use Amazon API Gateway with Lambda integration. API Gateway fronts serverless APIs and routing.

For the alternative failure the public API needs request validation and authorization before invoking business code, the control Configure API Gateway authentication and request validation for supported routes is relevant: API management filters unauthorized or malformed calls early. Here the evidence instead is lambda concurrency limits cause 429 and throttling during promotions. The selected technical mechanism is Apply reserved or provisioned concurrency and upstream retry/backpressure strategy as appropriate: lambda concurrency controls bound simultaneous executions.

Use AWS Step Functions plus suitable ECS/Batch tasks for longer jobs solves a different operational problem where long-running video conversions exceed Lambda's maximum execution duration. Orchestrated workloads avoid Lambda runtime-duration limits. It does not directly address lambda concurrency limits cause 429 and throttling during promotions. The case calls for Apply reserved or provisioned concurrency and upstream retry/backpressure strategy as appropriate, since lambda concurrency controls bound simultaneous executions.

The competing option Assign a client idempotency token and deduplicate on the backend would be useful when a client retries the same create request and duplicates an order. Idempotency keys make retried writes safe. The present issue is lambda concurrency limits cause 429 and throttling during promotions; it is more directly addressed by Apply reserved or provisioned concurrency and upstream retry/backpressure strategy as appropriate. Lambda concurrency controls bound simultaneous executions.

The competing option Apply reserved or provisioned concurrency and upstream retry/backpressure strategy as appropriate would be useful when lambda concurrency limits cause 429 and throttling during promotions. Lambda concurrency controls bound simultaneous executions. The present issue is long-running video conversions exceed Lambda's maximum execution duration; it is more directly addressed by Use AWS Step Functions plus suitable ECS/Batch tasks for longer jobs. Orchestrated workloads avoid Lambda runtime-duration limits.

The option Configure API Gateway authentication and request validation for supported routes addresses a separate condition: the public API needs request validation and authorization before invoking business code. API management filters unauthorized or malformed calls early. The actual requirement is long-running video conversions exceed Lambda's maximum execution duration. Recommended corrective action: Use AWS Step Functions plus suitable ECS/Batch tasks for longer jobs. Orchestrated workloads avoid Lambda runtime-duration limits.

Use Amazon API Gateway with Lambda integration would help if web clients require a managed HTTPS entry for Lambda operations. API Gateway fronts serverless APIs and routing. That is not the symptom described here: long-running video conversions exceed Lambda's maximum execution duration. The matching response is Use AWS Step Functions plus suitable ECS/Batch tasks for longer jobs, because orchestrated workloads avoid Lambda runtime-duration limits.

The competing option Use Amazon API Gateway with Lambda integration would be useful when web clients require a managed HTTPS entry for Lambda operations. API Gateway fronts serverless APIs and routing. The present issue is a client retries the same create request and duplicates an order; it is more directly addressed by Assign a client idempotency token and deduplicate on the backend. Idempotency keys make retried writes safe.

Configure API Gateway authentication and request validation for supported routes would help if the public API needs request validation and authorization before invoking business code. API management filters unauthorized or malformed calls early. That is not the symptom described here: a client retries the same create request and duplicates an order. The matching response is Assign a client idempotency token and deduplicate on the backend, because idempotency keys make retried writes safe.

For the alternative failure lambda concurrency limits cause 429 and throttling during promotions, the control Apply reserved or provisioned concurrency and upstream retry/backpressure strategy as appropriate is relevant: lambda concurrency controls bound simultaneous executions. Here the evidence instead is a client retries the same create request and duplicates an order. The selected technical mechanism is Assign a client idempotency token and deduplicate on the backend: idempotency keys make retried writes safe.

The option Apply reserved or provisioned concurrency and upstream retry/backpressure strategy as appropriate addresses a separate condition: lambda concurrency limits cause 429 and throttling during promotions. Lambda concurrency controls bound simultaneous executions. The actual requirement is the public API needs request validation and authorization before invoking business code. Recommended corrective action: Configure API Gateway authentication and request validation for supported routes. API management filters unauthorized or malformed calls early.

For the alternative failure long-running video conversions exceed Lambda's maximum execution duration, the control Use AWS Step Functions plus suitable ECS/Batch tasks for longer jobs is relevant: orchestrated workloads avoid Lambda runtime-duration limits. Here the evidence instead is the public API needs request validation and authorization before invoking business code. The selected technical mechanism is Configure API Gateway authentication and request validation for supported routes: API management filters unauthorized or malformed calls early.

Use Amazon API Gateway with Lambda integration solves a different operational problem where web clients require a managed HTTPS entry for Lambda operations. API Gateway fronts serverless APIs and routing. It does not directly address the public API needs request validation and authorization before invoking business code. The case calls for Configure API Gateway authentication and request validation for supported routes, since API management filters unauthorized or malformed calls early.