Amazon AWS Certified Solutions Architect - Associate SAA-C03 Bundle

The option Configure supported EKS node scaling with managed node groups or Karpenter addresses a separate condition: nodes run out of schedulable resources after pods scale out. Cluster capacity must follow workload pod growth. The actual requirement is container tasks must run without administering Kubernetes clusters. Recommended corrective action: Use ECS/Fargate for a simpler orchestration model when Kubernetes APIs are unnecessary. Purpose-built ECS can reduce orchestration complexity.

Use Amazon EKS rather than building an unmanaged master control plane would help if the app requires a managed Kubernetes control plane with workload portability. EKS runs the managed Kubernetes API control plane. That is not the symptom described here: container tasks must run without administering Kubernetes clusters. The matching response is Use ECS/Fargate for a simpler orchestration model when Kubernetes APIs are unnecessary, because purpose-built ECS can reduce orchestration complexity.

Configure Horizontal Pod Autoscaler with appropriate metrics solves a different operational problem where a Kubernetes deployment needs application pod replicas to rise with utilization. HPA scales pods based on resource or custom metrics. It does not directly address container tasks must run without administering Kubernetes clusters. The case calls for Use ECS/Fargate for a simpler orchestration model when Kubernetes APIs are unnecessary, since purpose-built ECS can reduce orchestration complexity.

For the alternative failure duplicate deliveries cause customers to receive two shipping emails, the control Make notification handlers idempotent using unique event IDs is relevant: at-least-once messaging requires consumer deduplication. Here the evidence instead is every purchase event must fan out to email and SMS workflows. The selected technical mechanism is Publish via an SNS topic with independent subscriptions: pub/sub fanout avoids per-consumer producer code.

Use SNS mobile push platform application endpoints solves a different operational problem where a mobile app needs direct push notification delivery through supported providers. SNS integrates app notifications with mobile push providers. It does not directly address every purchase event must fan out to email and SMS workflows. The case calls for Publish via an SNS topic with independent subscriptions, since pub/sub fanout avoids per-consumer producer code.

The competing option Apply an SNS subscription filter policy on message attributes or body would be useful when a topic subscriber should receive only high-value orders. Subscription filtering selects matching messages for each consumer. The present issue is every purchase event must fan out to email and SMS workflows; it is more directly addressed by Publish via an SNS topic with independent subscriptions. Pub/sub fanout avoids per-consumer producer code.

For the alternative failure every purchase event must fan out to email and SMS workflows, the control Publish via an SNS topic with independent subscriptions is relevant: pub/sub fanout avoids per-consumer producer code. Here the evidence instead is a mobile app needs direct push notification delivery through supported providers. The selected technical mechanism is Use SNS mobile push platform application endpoints: sNS integrates app notifications with mobile push providers.

Apply an SNS subscription filter policy on message attributes or body solves a different operational problem where a topic subscriber should receive only high-value orders. Subscription filtering selects matching messages for each consumer. It does not directly address a mobile app needs direct push notification delivery through supported providers. The case calls for Use SNS mobile push platform application endpoints, since sNS integrates app notifications with mobile push providers.

The competing option Make notification handlers idempotent using unique event IDs would be useful when duplicate deliveries cause customers to receive two shipping emails. At-least-once messaging requires consumer deduplication. The present issue is a mobile app needs direct push notification delivery through supported providers; it is more directly addressed by Use SNS mobile push platform application endpoints. SNS integrates app notifications with mobile push providers.

Publish via an SNS topic with independent subscriptions solves a different operational problem where every purchase event must fan out to email and SMS workflows. Pub/sub fanout avoids per-consumer producer code. It does not directly address a subscriber occasionally fails and must not lose its event. The case calls for Subscribe an SQS queue to the SNS topic for durable processing, since sQS buffers deliveries for independently retried consumers.

The competing option Use SNS mobile push platform application endpoints would be useful when a mobile app needs direct push notification delivery through supported providers. SNS integrates app notifications with mobile push providers. The present issue is a subscriber occasionally fails and must not lose its event; it is more directly addressed by Subscribe an SQS queue to the SNS topic for durable processing. SQS buffers deliveries for independently retried consumers.

The option Make notification handlers idempotent using unique event IDs addresses a separate condition: duplicate deliveries cause customers to receive two shipping emails. At-least-once messaging requires consumer deduplication. The actual requirement is a subscriber occasionally fails and must not lose its event. Recommended corrective action: Subscribe an SQS queue to the SNS topic for durable processing. SQS buffers deliveries for independently retried consumers.

The competing option Publish via an SNS topic with independent subscriptions would be useful when every purchase event must fan out to email and SMS workflows. Pub/sub fanout avoids per-consumer producer code. The present issue is a topic subscriber should receive only high-value orders; it is more directly addressed by Apply an SNS subscription filter policy on message attributes or body. Subscription filtering selects matching messages for each consumer.

The option Use SNS mobile push platform application endpoints addresses a separate condition: a mobile app needs direct push notification delivery through supported providers. SNS integrates app notifications with mobile push providers. The actual requirement is a topic subscriber should receive only high-value orders. Recommended corrective action: Apply an SNS subscription filter policy on message attributes or body. Subscription filtering selects matching messages for each consumer.

Make notification handlers idempotent using unique event IDs would help if duplicate deliveries cause customers to receive two shipping emails. At-least-once messaging requires consumer deduplication. That is not the symptom described here: a topic subscriber should receive only high-value orders. The matching response is Apply an SNS subscription filter policy on message attributes or body, because subscription filtering selects matching messages for each consumer.

The option Apply an SNS subscription filter policy on message attributes or body addresses a separate condition: a topic subscriber should receive only high-value orders. Subscription filtering selects matching messages for each consumer. The actual requirement is duplicate deliveries cause customers to receive two shipping emails. Recommended corrective action: Make notification handlers idempotent using unique event IDs. At-least-once messaging requires consumer deduplication.

Publish via an SNS topic with independent subscriptions would help if every purchase event must fan out to email and SMS workflows. Pub/sub fanout avoids per-consumer producer code. That is not the symptom described here: duplicate deliveries cause customers to receive two shipping emails. The matching response is Make notification handlers idempotent using unique event IDs, because at-least-once messaging requires consumer deduplication.

For the alternative failure a mobile app needs direct push notification delivery through supported providers, the control Use SNS mobile push platform application endpoints is relevant: sNS integrates app notifications with mobile push providers. Here the evidence instead is duplicate deliveries cause customers to receive two shipping emails. The selected technical mechanism is Make notification handlers idempotent using unique event IDs: at-least-once messaging requires consumer deduplication.

Place Amazon RDS Proxy in front of supported RDS instances would help if every application service connects directly to RDS and exhausts connections. RDS Proxy pools and reuses database connections. That is not the symptom described here: a presentation server directly writes to a database and blocks on slow reports. The matching response is Move reports to asynchronous workers via SQS and isolate databases, because queued workers separate report latency from front-end requests.

For the alternative failure a file-processing service depends on a manual cron job on one EC2 host, the control Trigger events through S3 EventBridge integration and managed workers is relevant: managed event routing removes host-specific scheduling. Here the evidence instead is a presentation server directly writes to a database and blocks on slow reports. The selected technical mechanism is Move reports to asynchronous workers via SQS and isolate databases: queued workers separate report latency from front-end requests.

Store session state in an external cache or session store solves a different operational problem where users' sessions are stored in each EC2 instance's memory. Externalized sessions support load-balanced stateless servers. It does not directly address a presentation server directly writes to a database and blocks on slow reports. The case calls for Move reports to asynchronous workers via SQS and isolate databases, since queued workers separate report latency from front-end requests.

Trigger events through S3 EventBridge integration and managed workers solves a different operational problem where a file-processing service depends on a manual cron job on one EC2 host. Managed event routing removes host-specific scheduling. It does not directly address users' sessions are stored in each EC2 instance's memory. The case calls for Store session state in an external cache or session store, since externalized sessions support load-balanced stateless servers.

The competing option Move reports to asynchronous workers via SQS and isolate databases would be useful when a presentation server directly writes to a database and blocks on slow reports. Queued workers separate report latency from front-end requests. The present issue is users' sessions are stored in each EC2 instance's memory; it is more directly addressed by Store session state in an external cache or session store. Externalized sessions support load-balanced stateless servers.

The option Place Amazon RDS Proxy in front of supported RDS instances addresses a separate condition: every application service connects directly to RDS and exhausts connections. RDS Proxy pools and reuses database connections. The actual requirement is users' sessions are stored in each EC2 instance's memory. Recommended corrective action: Store session state in an external cache or session store. Externalized sessions support load-balanced stateless servers.

Move reports to asynchronous workers via SQS and isolate databases solves a different operational problem where a presentation server directly writes to a database and blocks on slow reports. Queued workers separate report latency from front-end requests. It does not directly address teams deploy all services together although only one changes frequently. The case calls for Break components into independently deployed ECS services or Lambda functions, since independent deployables reduce coupling between update cycles.

The competing option Place Amazon RDS Proxy in front of supported RDS instances would be useful when every application service connects directly to RDS and exhausts connections. RDS Proxy pools and reuses database connections. The present issue is teams deploy all services together although only one changes frequently; it is more directly addressed by Break components into independently deployed ECS services or Lambda functions. Independent deployables reduce coupling between update cycles.

The option Trigger events through S3 EventBridge integration and managed workers addresses a separate condition: a file-processing service depends on a manual cron job on one EC2 host. Managed event routing removes host-specific scheduling. The actual requirement is teams deploy all services together although only one changes frequently. Recommended corrective action: Break components into independently deployed ECS services or Lambda functions. Independent deployables reduce coupling between update cycles.

The competing option Move reports to asynchronous workers via SQS and isolate databases would be useful when a presentation server directly writes to a database and blocks on slow reports. Queued workers separate report latency from front-end requests. The present issue is a file-processing service depends on a manual cron job on one EC2 host; it is more directly addressed by Trigger events through S3 EventBridge integration and managed workers. Managed event routing removes host-specific scheduling.

The option Break components into independently deployed ECS services or Lambda functions addresses a separate condition: teams deploy all services together although only one changes frequently. Independent deployables reduce coupling between update cycles. The actual requirement is a file-processing service depends on a manual cron job on one EC2 host. Recommended corrective action: Trigger events through S3 EventBridge integration and managed workers. Managed event routing removes host-specific scheduling.

Place Amazon RDS Proxy in front of supported RDS instances would help if every application service connects directly to RDS and exhausts connections. RDS Proxy pools and reuses database connections. That is not the symptom described here: a file-processing service depends on a manual cron job on one EC2 host. The matching response is Trigger events through S3 EventBridge integration and managed workers, because managed event routing removes host-specific scheduling.

The option Trigger events through S3 EventBridge integration and managed workers addresses a separate condition: a file-processing service depends on a manual cron job on one EC2 host. Managed event routing removes host-specific scheduling. The actual requirement is every application service connects directly to RDS and exhausts connections. Recommended corrective action: Place Amazon RDS Proxy in front of supported RDS instances. RDS Proxy pools and reuses database connections.

For the alternative failure a presentation server directly writes to a database and blocks on slow reports, the control Move reports to asynchronous workers via SQS and isolate databases is relevant: queued workers separate report latency from front-end requests. Here the evidence instead is every application service connects directly to RDS and exhausts connections. The selected technical mechanism is Place Amazon RDS Proxy in front of supported RDS instances: rDS Proxy pools and reuses database connections.

Store session state in an external cache or session store solves a different operational problem where users' sessions are stored in each EC2 instance's memory. Externalized sessions support load-balanced stateless servers. It does not directly address every application service connects directly to RDS and exhausts connections. The case calls for Place Amazon RDS Proxy in front of supported RDS instances, since rDS Proxy pools and reuses database connections.