Amazon AWS Certified Solutions Architect - Associate SAA-C03 Bundle

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.

Segment critical services into appropriate load balancer and target groups would help if a load balancer serves too many unrelated production services in one shared failure domain. Failure-domain separation limits correlated downtime. That is not the symptom described here: eCS tasks are replaced frequently and callers use stale container IPs. The matching response is Use Cloud Map or internal load-balancer service discovery, because service discovery follows dynamic task endpoints.

Use internal ALB and scoped security-group ingress solves a different operational problem where independent services must communicate through private HTTP routing. Internal load balancers centralize private routing. It does not directly address eCS tasks are replaced frequently and callers use stale container IPs. The case calls for Use Cloud Map or internal load-balancer service discovery, since service discovery follows dynamic task endpoints.

The competing option Use Route 53 alias records to the load balancer would be useful when a public domain must resolve to an ALB target without hardcoded addresses. Alias records integrate managed endpoints into DNS. The present issue is eCS tasks are replaced frequently and callers use stale container IPs; it is more directly addressed by Use Cloud Map or internal load-balancer service discovery. Service discovery follows dynamic task endpoints.

Segment critical services into appropriate load balancer and target groups solves a different operational problem where a load balancer serves too many unrelated production services in one shared failure domain. Failure-domain separation limits correlated downtime. It does not directly address a public domain must resolve to an ALB target without hardcoded addresses. The case calls for Use Route 53 alias records to the load balancer, since alias records integrate managed endpoints into DNS.

The competing option Use internal ALB and scoped security-group ingress would be useful when independent services must communicate through private HTTP routing. Internal load balancers centralize private routing. The present issue is a public domain must resolve to an ALB target without hardcoded addresses; it is more directly addressed by Use Route 53 alias records to the load balancer. Alias records integrate managed endpoints into DNS.

The option Adjust health-check grace and readiness endpoint behavior addresses a separate condition: an ECS service handles startup slowly and fails deployment health checks. Healthy deployment needs initialization-aware checks. The actual requirement is a public domain must resolve to an ALB target without hardcoded addresses. Recommended corrective action: Use Route 53 alias records to the load balancer. Alias records integrate managed endpoints into DNS.

Use Route 53 alias records to the load balancer solves a different operational problem where a public domain must resolve to an ALB target without hardcoded addresses. Alias records integrate managed endpoints into DNS. It does not directly address independent services must communicate through private HTTP routing. The case calls for Use internal ALB and scoped security-group ingress, since internal load balancers centralize private routing.

The option Use Cloud Map or internal load-balancer service discovery addresses a separate condition: eCS tasks are replaced frequently and callers use stale container IPs. Service discovery follows dynamic task endpoints. The actual requirement is independent services must communicate through private HTTP routing. Recommended corrective action: Use internal ALB and scoped security-group ingress. Internal load balancers centralize private routing.

Adjust health-check grace and readiness endpoint behavior would help if an ECS service handles startup slowly and fails deployment health checks. Healthy deployment needs initialization-aware checks. That is not the symptom described here: independent services must communicate through private HTTP routing. The matching response is Use internal ALB and scoped security-group ingress, because internal load balancers centralize private routing.

The competing option Use Route 53 alias records to the load balancer would be useful when a public domain must resolve to an ALB target without hardcoded addresses. Alias records integrate managed endpoints into DNS. The present issue is a load balancer serves too many unrelated production services in one shared failure domain; it is more directly addressed by Segment critical services into appropriate load balancer and target groups. Failure-domain separation limits correlated downtime.

Adjust health-check grace and readiness endpoint behavior would help if an ECS service handles startup slowly and fails deployment health checks. Healthy deployment needs initialization-aware checks. That is not the symptom described here: a load balancer serves too many unrelated production services in one shared failure domain. The matching response is Segment critical services into appropriate load balancer and target groups, because failure-domain separation limits correlated downtime.

For the alternative failure eCS tasks are replaced frequently and callers use stale container IPs, the control Use Cloud Map or internal load-balancer service discovery is relevant: service discovery follows dynamic task endpoints. Here the evidence instead is a load balancer serves too many unrelated production services in one shared failure domain. The selected technical mechanism is Segment critical services into appropriate load balancer and target groups: failure-domain separation limits correlated downtime.

Use Route 53 alias records to the load balancer would help if a public domain must resolve to an ALB target without hardcoded addresses. Alias records integrate managed endpoints into DNS. That is not the symptom described here: an ECS service handles startup slowly and fails deployment health checks. The matching response is Adjust health-check grace and readiness endpoint behavior, because healthy deployment needs initialization-aware checks.

For the alternative failure independent services must communicate through private HTTP routing, the control Use internal ALB and scoped security-group ingress is relevant: internal load balancers centralize private routing. Here the evidence instead is an ECS service handles startup slowly and fails deployment health checks. The selected technical mechanism is Adjust health-check grace and readiness endpoint behavior: healthy deployment needs initialization-aware checks.

Use Cloud Map or internal load-balancer service discovery solves a different operational problem where eCS tasks are replaced frequently and callers use stale container IPs. Service discovery follows dynamic task endpoints. It does not directly address an ECS service handles startup slowly and fails deployment health checks. The case calls for Adjust health-check grace and readiness endpoint behavior, since healthy deployment needs initialization-aware checks.

For the alternative failure a bank transfer must commit both debit and credit consistently, the control Keep financial atomicity within an appropriate transaction boundary is relevant: queues alone do not provide atomic cross-account bookkeeping. Here the evidence instead is a web frontend calls three downstream services in sequence and fails when the slowest is unavailable. The selected technical mechanism is Move noncritical downstream tasks to durable queued event processing: async boundaries prevent optional dependencies from blocking user requests.

Publish a confirmed payment event to a durable queue or event bus solves a different operational problem where a customer payment event has to trigger an independent fulfillment process. Event publication follows confirmed business state transitions. It does not directly address a web frontend calls three downstream services in sequence and fails when the slowest is unavailable. The case calls for Move noncritical downstream tasks to durable queued event processing, since async boundaries prevent optional dependencies from blocking user requests.

The competing option Require unique request tokens and atomic duplicate detection would be useful when a web application has no idempotency design for client retries. Request idempotency preserves business semantics under retries. The present issue is a web frontend calls three downstream services in sequence and fails when the slowest is unavailable; it is more directly addressed by Move noncritical downstream tasks to durable queued event processing. Async boundaries prevent optional dependencies from blocking user requests.

For the alternative failure a web frontend calls three downstream services in sequence and fails when the slowest is unavailable, the control Move noncritical downstream tasks to durable queued event processing is relevant: async boundaries prevent optional dependencies from blocking user requests. Here the evidence instead is a bank transfer must commit both debit and credit consistently. The selected technical mechanism is Keep financial atomicity within an appropriate transaction boundary: queues alone do not provide atomic cross-account bookkeeping.

The competing option Use a transactional outbox or supported change-event pattern would be useful when an integration event is lost when a producer fails between database commit and publish. Outbox coordination avoids lost events between commit and notification. The present issue is a bank transfer must commit both debit and credit consistently; it is more directly addressed by Keep financial atomicity within an appropriate transaction boundary. Queues alone do not provide atomic cross-account bookkeeping.

The option Publish a confirmed payment event to a durable queue or event bus addresses a separate condition: a customer payment event has to trigger an independent fulfillment process. Event publication follows confirmed business state transitions. The actual requirement is a bank transfer must commit both debit and credit consistently. Recommended corrective action: Keep financial atomicity within an appropriate transaction boundary. Queues alone do not provide atomic cross-account bookkeeping.

Require unique request tokens and atomic duplicate detection solves a different operational problem where a web application has no idempotency design for client retries. Request idempotency preserves business semantics under retries. It does not directly address a customer payment event has to trigger an independent fulfillment process. The case calls for Publish a confirmed payment event to a durable queue or event bus, since event publication follows confirmed business state transitions.

The option Use a transactional outbox or supported change-event pattern addresses a separate condition: an integration event is lost when a producer fails between database commit and publish. Outbox coordination avoids lost events between commit and notification. The actual requirement is a customer payment event has to trigger an independent fulfillment process. Recommended corrective action: Publish a confirmed payment event to a durable queue or event bus. Event publication follows confirmed business state transitions.

Keep financial atomicity within an appropriate transaction boundary would help if a bank transfer must commit both debit and credit consistently. Queues alone do not provide atomic cross-account bookkeeping. That is not the symptom described here: a customer payment event has to trigger an independent fulfillment process. The matching response is Publish a confirmed payment event to a durable queue or event bus, because event publication follows confirmed business state transitions.

The competing option Use a transactional outbox or supported change-event pattern would be useful when an integration event is lost when a producer fails between database commit and publish. Outbox coordination avoids lost events between commit and notification. The present issue is a web application has no idempotency design for client retries; it is more directly addressed by Require unique request tokens and atomic duplicate detection. Request idempotency preserves business semantics under retries.

Publish a confirmed payment event to a durable queue or event bus would help if a customer payment event has to trigger an independent fulfillment process. Event publication follows confirmed business state transitions. That is not the symptom described here: a web application has no idempotency design for client retries. The matching response is Require unique request tokens and atomic duplicate detection, because request idempotency preserves business semantics under retries.

For the alternative failure a web frontend calls three downstream services in sequence and fails when the slowest is unavailable, the control Move noncritical downstream tasks to durable queued event processing is relevant: async boundaries prevent optional dependencies from blocking user requests. Here the evidence instead is a web application has no idempotency design for client retries. The selected technical mechanism is Require unique request tokens and atomic duplicate detection: request idempotency preserves business semantics under retries.

The option Publish a confirmed payment event to a durable queue or event bus addresses a separate condition: a customer payment event has to trigger an independent fulfillment process. Event publication follows confirmed business state transitions. The actual requirement is an integration event is lost when a producer fails between database commit and publish. Recommended corrective action: Use a transactional outbox or supported change-event pattern. Outbox coordination avoids lost events between commit and notification.

Move noncritical downstream tasks to durable queued event processing would help if a web frontend calls three downstream services in sequence and fails when the slowest is unavailable. Async boundaries prevent optional dependencies from blocking user requests. That is not the symptom described here: an integration event is lost when a producer fails between database commit and publish. The matching response is Use a transactional outbox or supported change-event pattern, because outbox coordination avoids lost events between commit and notification.

For the alternative failure a web application has no idempotency design for client retries, the control Require unique request tokens and atomic duplicate detection is relevant: request idempotency preserves business semantics under retries. Here the evidence instead is an integration event is lost when a producer fails between database commit and publish. The selected technical mechanism is Use a transactional outbox or supported change-event pattern: outbox coordination avoids lost events between commit and notification.