Amazon AWS Certified Solutions Architect - Associate SAA-C03 Bundle

Use ALB host-based routing to separate target groups would help if two services require distinct hostnames on the same public listener. Host-header rules map hostnames to backends. That is not the symptom described here: sticky session routing hides failure by keeping users on one bad instance. The matching response is Externalize state and reduce dependence on target stickiness, because stateless design improves replacement resilience.

For the alternative failure a newly launched target is marked healthy before dependencies are ready, the control Use meaningful health checks and readiness validation is relevant: healthy routing should wait for service readiness. Here the evidence instead is sticky session routing hides failure by keeping users on one bad instance. The selected technical mechanism is Externalize state and reduce dependence on target stickiness: stateless design improves replacement resilience.

Configure target deregistration delay and graceful shutdown solves a different operational problem where deployments replace instances while ALB is still sending in-flight requests. Connection draining allows in-flight requests to finish. It does not directly address sticky session routing hides failure by keeping users on one bad instance. The case calls for Externalize state and reduce dependence on target stickiness, since stateless design improves replacement resilience.

Orchestrate Lambda, ECS or Batch validation tasks in Step Functions would help if a multi-hour validation pipeline requires conditional retries. Managed workflow states coordinate long-running processing. That is not the symptom described here: external vendors use SFTP to upload batch files into AWS storage. The matching response is Use AWS Transfer Family with S3 or EFS backend, because transfer Family provides managed file transfer protocols.

For the alternative failure uploaded file metadata must trigger an ETL job without polling a server, the control Route supported S3 events to EventBridge and downstream processor is relevant: event-based triggers avoid continuous polling. Here the evidence instead is external vendors use SFTP to upload batch files into AWS storage. The selected technical mechanism is Use AWS Transfer Family with S3 or EFS backend: transfer Family provides managed file transfer protocols.

The competing option Use an object-version or business-key idempotency marker would be useful when an S3 event invokes Lambda twice and duplicates an import. S3 event delivery can be duplicate or unordered. The present issue is external vendors use SFTP to upload batch files into AWS storage; it is more directly addressed by Use AWS Transfer Family with S3 or EFS backend. Transfer Family provides managed file transfer protocols.

For the alternative failure a partner file is invalid but its event keeps retrying forever, the control Send failed import messages to a DLQ with controlled investigation is relevant: failure isolation prevents repeated invalid work. Here the evidence instead is uploaded file metadata must trigger an ETL job without polling a server. The selected technical mechanism is Route supported S3 events to EventBridge and downstream processor: event-based triggers avoid continuous polling.

Orchestrate Lambda, ECS or Batch validation tasks in Step Functions solves a different operational problem where a multi-hour validation pipeline requires conditional retries. Managed workflow states coordinate long-running processing. It does not directly address uploaded file metadata must trigger an ETL job without polling a server. The case calls for Route supported S3 events to EventBridge and downstream processor, since event-based triggers avoid continuous polling.

The option Use an object-version or business-key idempotency marker addresses a separate condition: an S3 event invokes Lambda twice and duplicates an import. S3 event delivery can be duplicate or unordered. The actual requirement is uploaded file metadata must trigger an ETL job without polling a server. Recommended corrective action: Route supported S3 events to EventBridge and downstream processor. Event-based triggers avoid continuous polling.

The competing option Send failed import messages to a DLQ with controlled investigation would be useful when a partner file is invalid but its event keeps retrying forever. Failure isolation prevents repeated invalid work. The present issue is an S3 event invokes Lambda twice and duplicates an import; it is more directly addressed by Use an object-version or business-key idempotency marker. S3 event delivery can be duplicate or unordered.

The option Orchestrate Lambda, ECS or Batch validation tasks in Step Functions addresses a separate condition: a multi-hour validation pipeline requires conditional retries. Managed workflow states coordinate long-running processing. The actual requirement is an S3 event invokes Lambda twice and duplicates an import. Recommended corrective action: Use an object-version or business-key idempotency marker. S3 event delivery can be duplicate or unordered.

Route supported S3 events to EventBridge and downstream processor would help if uploaded file metadata must trigger an ETL job without polling a server. Event-based triggers avoid continuous polling. That is not the symptom described here: an S3 event invokes Lambda twice and duplicates an import. The matching response is Use an object-version or business-key idempotency marker, because s3 event delivery can be duplicate or unordered.

The option Use AWS Transfer Family with S3 or EFS backend addresses a separate condition: external vendors use SFTP to upload batch files into AWS storage. Transfer Family provides managed file transfer protocols. The actual requirement is a multi-hour validation pipeline requires conditional retries. Recommended corrective action: Orchestrate Lambda, ECS or Batch validation tasks in Step Functions. Managed workflow states coordinate long-running processing.

Route supported S3 events to EventBridge and downstream processor would help if uploaded file metadata must trigger an ETL job without polling a server. Event-based triggers avoid continuous polling. That is not the symptom described here: a multi-hour validation pipeline requires conditional retries. The matching response is Orchestrate Lambda, ECS or Batch validation tasks in Step Functions, because managed workflow states coordinate long-running processing.

For the alternative failure an S3 event invokes Lambda twice and duplicates an import, the control Use an object-version or business-key idempotency marker is relevant: s3 event delivery can be duplicate or unordered. Here the evidence instead is a multi-hour validation pipeline requires conditional retries. The selected technical mechanism is Orchestrate Lambda, ECS or Batch validation tasks in Step Functions: managed workflow states coordinate long-running processing.

Route supported S3 events to EventBridge and downstream processor would help if uploaded file metadata must trigger an ETL job without polling a server. Event-based triggers avoid continuous polling. That is not the symptom described here: a partner file is invalid but its event keeps retrying forever. The matching response is Send failed import messages to a DLQ with controlled investigation, because failure isolation prevents repeated invalid work.

For the alternative failure a multi-hour validation pipeline requires conditional retries, the control Orchestrate Lambda, ECS or Batch validation tasks in Step Functions is relevant: managed workflow states coordinate long-running processing. Here the evidence instead is a partner file is invalid but its event keeps retrying forever. The selected technical mechanism is Send failed import messages to a DLQ with controlled investigation: failure isolation prevents repeated invalid work.

Use AWS Transfer Family with S3 or EFS backend solves a different operational problem where external vendors use SFTP to upload batch files into AWS storage. Transfer Family provides managed file transfer protocols. It does not directly address a partner file is invalid but its event keeps retrying forever. The case calls for Send failed import messages to a DLQ with controlled investigation, since failure isolation prevents repeated invalid work.

For the alternative failure a queue worker has an open connection for minutes waiting for new work, the control Use SQS long polling instead of frequent empty ReceiveMessage calls is relevant: long polling reduces empty responses and processing overhead. Here the evidence instead is a producer account must publish events to a consumer EventBridge bus. The selected technical mechanism is Configure cross-account event-bus policy and appropriate source rule: eventBridge buses support controlled cross-account delivery.

Split ordering groups by independent business keys solves a different operational problem where several consumers contend on one FIFO message group and cannot run concurrently. FIFO ordering is serialized within a message group. It does not directly address a producer account must publish events to a consumer EventBridge bus. The case calls for Configure cross-account event-bus policy and appropriate source rule, since eventBridge buses support controlled cross-account delivery.

The competing option Publish to SNS or EventBridge fanout with separate subscriptions would be useful when all consumer systems must receive the same inventory event independently. Fanout removes producer coupling to each consumer. The present issue is a producer account must publish events to a consumer EventBridge bus; it is more directly addressed by Configure cross-account event-bus policy and appropriate source rule. EventBridge buses support controlled cross-account delivery.

For the alternative failure a consumer needs full replay after a code bug corrupted its output, the control Retain replayable events in a suitable Kinesis stream or EventBridge archive is relevant: durable event history supports downstream reprocessing. Here the evidence instead is all consumer systems must receive the same inventory event independently. The selected technical mechanism is Publish to SNS or EventBridge fanout with separate subscriptions: fanout removes producer coupling to each consumer.

Split ordering groups by independent business keys solves a different operational problem where several consumers contend on one FIFO message group and cannot run concurrently. FIFO ordering is serialized within a message group. It does not directly address all consumer systems must receive the same inventory event independently. The case calls for Publish to SNS or EventBridge fanout with separate subscriptions, since fanout removes producer coupling to each consumer.

The competing option Configure cross-account event-bus policy and appropriate source rule would be useful when a producer account must publish events to a consumer EventBridge bus. EventBridge buses support controlled cross-account delivery. The present issue is all consumer systems must receive the same inventory event independently; it is more directly addressed by Publish to SNS or EventBridge fanout with separate subscriptions. Fanout removes producer coupling to each consumer.

Publish to SNS or EventBridge fanout with separate subscriptions solves a different operational problem where all consumer systems must receive the same inventory event independently. Fanout removes producer coupling to each consumer. It does not directly address a consumer needs full replay after a code bug corrupted its output. The case calls for Retain replayable events in a suitable Kinesis stream or EventBridge archive, since durable event history supports downstream reprocessing.

The competing option Split ordering groups by independent business keys would be useful when several consumers contend on one FIFO message group and cannot run concurrently. FIFO ordering is serialized within a message group. The present issue is a consumer needs full replay after a code bug corrupted its output; it is more directly addressed by Retain replayable events in a suitable Kinesis stream or EventBridge archive. Durable event history supports downstream reprocessing.

The option Use SQS long polling instead of frequent empty ReceiveMessage calls addresses a separate condition: a queue worker has an open connection for minutes waiting for new work. Long polling reduces empty responses and processing overhead. The actual requirement is a consumer needs full replay after a code bug corrupted its output. Recommended corrective action: Retain replayable events in a suitable Kinesis stream or EventBridge archive. Durable event history supports downstream reprocessing.

The competing option Publish to SNS or EventBridge fanout with separate subscriptions would be useful when all consumer systems must receive the same inventory event independently. Fanout removes producer coupling to each consumer. The present issue is a queue worker has an open connection for minutes waiting for new work; it is more directly addressed by Use SQS long polling instead of frequent empty ReceiveMessage calls. Long polling reduces empty responses and processing overhead.

The option Split ordering groups by independent business keys addresses a separate condition: several consumers contend on one FIFO message group and cannot run concurrently. FIFO ordering is serialized within a message group. The actual requirement is a queue worker has an open connection for minutes waiting for new work. Recommended corrective action: Use SQS long polling instead of frequent empty ReceiveMessage calls. Long polling reduces empty responses and processing overhead.

For the alternative failure a producer account must publish events to a consumer EventBridge bus, the control Configure cross-account event-bus policy and appropriate source rule is relevant: eventBridge buses support controlled cross-account delivery. Here the evidence instead is a queue worker has an open connection for minutes waiting for new work. The selected technical mechanism is Use SQS long polling instead of frequent empty ReceiveMessage calls: long polling reduces empty responses and processing overhead.

The option Configure cross-account event-bus policy and appropriate source rule addresses a separate condition: a producer account must publish events to a consumer EventBridge bus. EventBridge buses support controlled cross-account delivery. The actual requirement is several consumers contend on one FIFO message group and cannot run concurrently. Recommended corrective action: Split ordering groups by independent business keys. FIFO ordering is serialized within a message group.

For the alternative failure all consumer systems must receive the same inventory event independently, the control Publish to SNS or EventBridge fanout with separate subscriptions is relevant: fanout removes producer coupling to each consumer. Here the evidence instead is several consumers contend on one FIFO message group and cannot run concurrently. The selected technical mechanism is Split ordering groups by independent business keys: fIFO ordering is serialized within a message group.

Retain replayable events in a suitable Kinesis stream or EventBridge archive solves a different operational problem where a consumer needs full replay after a code bug corrupted its output. Durable event history supports downstream reprocessing. It does not directly address several consumers contend on one FIFO message group and cannot run concurrently. The case calls for Split ordering groups by independent business keys, since fIFO ordering is serialized within a message group.