Domain 2.4: Reliability

An architecture uses Amazon API Gateway and AWS Lambda. During traffic spikes, the backend database becomes overwhelmed, causing Lambda functions to timeout and fail. How can the architect improve the reliability of this system with the LEAST architectural changes?

An architecture relies on a third-party API that frequently experiences latency spikes and temporary outages. The AWS application calling this API must not fail or hang indefinitely when the third-party API is unresponsive. Which architectural pattern should the architect implement?

An architect is designing a serverless data processing pipeline. Amazon S3 events trigger an AWS Lambda function, which processes the data and writes to Amazon DynamoDB. The Lambda function occasionally fails due to downstream throttling. How can the architect ensure no data is lost during these failures with the LEAST operational overhead?

An enterprise architecture uses Amazon EventBridge to route events between dozens of microservices. The architect needs to ensure that events are not lost if a target service is temporarily unavailable, and they need a mechanism to replay past events to recover from application logic errors. How should EventBridge be configured?

A company is building a highly scalable image processing pipeline. Users upload images to Amazon S3. The upload must trigger an AWS Lambda function to generate thumbnails. To handle massive spikes in traffic, the architecture must ensure that the Lambda function is not overwhelmed and that no image processing tasks are lost. Which THREE architectural choices should be made? (Select THREE)

An architect is designing a loosely coupled, event-driven architecture. A central order processing system needs to fan out order events to multiple downstream microservices. Some microservices only need to process specific types of orders (e.g., 'international' vs 'domestic'). Which THREE configurations provide the MOST scalable and decoupled solution? (Select THREE)

A company is building a serverless data lake architecture. They need to ingest streaming data, store it cost-effectively, catalog the metadata, and query it using standard SQL. Which THREE AWS services form the core of this architecture? (Select THREE)

A company is building an IoT application. Millions of devices will send MQTT messages to AWS IoT Core. The data needs to be buffered, processed in real-time to detect anomalies, and then stored in Amazon S3 for long-term analytics. Which THREE services should be integrated to build this pipeline? (Select THREE)

An architect is designing a data ingestion pipeline. Data is sent to an API Gateway, which triggers a Lambda function. The Lambda function writes the data to an RDS database. During traffic spikes, the RDS database becomes overwhelmed and drops connections. How can the architect decouple the architecture to prevent database overload?

A high-traffic e-commerce website experiences unpredictable traffic spikes. The backend uses an Auto Scaling group of EC2 instances processing orders from an SQS queue. During spikes, instances take 5 minutes to boot, causing order processing delays. How can the architect improve reliability and responsiveness?

A microservices architecture uses synchronous API calls between services. When a downstream service experiences latency, upstream services exhaust their thread pools, causing cascading failures. Which architectural pattern BEST prevents this?

An order processing system receives bursts of traffic. Currently, the web tier writes directly to an RDS database, which becomes overwhelmed during peaks, resulting in lost orders. How can the architect decouple the system to ensure no orders are lost?

An application uses Amazon Kinesis Data Streams to ingest telemetry data. During peak hours, the stream experiences ProvisionedThroughputExceeded exceptions. Which TWO actions will resolve this issue? (Select TWO)

A company is designing a serverless application using Amazon API Gateway, AWS Lambda, and Amazon DynamoDB. The application must handle sudden, massive spikes in traffic (up to 100,000 requests per second) without dropping requests or overwhelming the database. The business requires that all requests are eventually processed, even if delayed during peaks. Which combination of architectural patterns should be used? (Select TWO)

A retail company is building a new event-driven architecture. When a customer places an order, multiple downstream services (Inventory, Billing, Shipping, and Analytics) need to process the order. The Analytics service only needs to process orders over $1000. If the Billing service is temporarily down, the order messages must not be lost and should be retried. Which combination of services and configurations provides the MOST decoupled and resilient architecture? (Select TWO)

A company has a multi-tier web application running on Amazon EC2 instances. The application uses Amazon SQS to decouple the web tier from the worker tier. During peak hours, the worker instances cannot process the messages fast enough, causing the SQS queue to grow and delaying order processing. The Architect needs to scale the worker tier dynamically based on the queue backlog. Which scaling metric is the MOST appropriate?

A company is building a serverless application using AWS AppSync (GraphQL), AWS Lambda, and Amazon DynamoDB. The application allows users to post messages. The company wants to implement real-time updates so that when a user posts a message, all other users viewing the application see the new message instantly without refreshing the page. They also want to ensure that users can only see messages in channels they are authorized to access. Which combination of features should be used? (Select TWO)

A retail company experiences massive, unpredictable spikes in traffic during flash sales. Their architecture consists of an Application Load Balancer, an Amazon EC2 Auto Scaling group, and an Amazon Aurora MySQL database. During a recent sale, the Auto Scaling group took 5 minutes to launch new instances, causing the application to crash under the sudden load. How can the Architect ensure the compute capacity is available IMMEDIATELY when a flash sale begins, without over-provisioning 24/7?

A microservices architecture uses Amazon ECS. Service A calls Service B synchronously. Under heavy load, Service B becomes slow, causing Service A to exhaust its threads waiting for responses, leading to cascading failures. How should the architect redesign this to improve reliability?

An e-commerce application processes orders. Currently, the web tier writes orders directly to an RDS database. During flash sales, the database is overwhelmed and drops connections, resulting in lost orders. How can the architect decouple this architecture to ensure no orders are lost?

A data processing pipeline uses AWS Step Functions to orchestrate AWS Batch jobs. Occasionally, a Batch job fails due to a transient API error. The architect wants to ensure the workflow automatically retries the failed job before marking the execution as failed. What is the BEST approach?

A global application uses Amazon DynamoDB. Users in the US and Australia experience different latencies. The business requires read and write latencies under 10 milliseconds for all users globally, and data must be synchronized across regions. Which solution meets these requirements?

A media company is designing a video streaming platform. The architecture uses Amazon S3 for storage, Amazon CloudFront for delivery, and AWS Lambda for video processing. During peak events, the Lambda functions experience throttling, and users report high latency. Which combination of architectural changes will improve reliability and performance? (Select THREE)

A company is designing a serverless application using Amazon API Gateway, AWS Lambda, and Amazon DynamoDB. The application must handle unpredictable spikes in traffic. During load testing, the API Gateway returns 504 Gateway Timeout errors, and DynamoDB returns ProvisionedThroughputExceededException errors. Which combination of actions will resolve these issues? (Select TWO)

An architecture relies on an Amazon SQS queue to decouple a web frontend from a backend processing tier running on EC2 instances in an Auto Scaling group. The processing time per message varies significantly. The company wants to scale the backend instances based on the backlog of work, rather than CPU utilization. Which metric should be used for the Auto Scaling policy?

A company is designing an event-driven architecture. An Amazon API Gateway receives orders and places them in an Amazon SQS queue. An AWS Lambda function processes the orders. The company wants to ensure that if the Lambda function fails to process an order after multiple retries, the order data is not lost and can be analyzed later. Which combination of steps should be taken? (Select TWO)

A company is designing a highly available architecture for a stateful legacy application. The application runs on a single EC2 instance and stores session data locally on its EBS volume. The application cannot be refactored. How can the architect ensure that if the EC2 instance fails, the application is automatically recovered with its session data intact?

A company is building a serverless data ingestion pipeline. Data is sent to an Amazon API Gateway, which triggers an AWS Lambda function. The Lambda function transforms the data and writes it to an Amazon Kinesis Data Stream. During peak hours, the API Gateway receives 10,000 requests per second, causing the Lambda function to hit concurrency limits and drop data. Which combination of architectural changes will resolve this issue and ensure no data is lost? (Select TWO)

An architecture uses AWS Step Functions to orchestrate a complex order fulfillment process. One of the steps invokes an AWS Lambda function that interacts with a third-party payment API. The third-party API occasionally experiences rate limiting and returns 429 Too Many Requests errors. How should the architect handle these errors to ensure the order process eventually succeeds without manual intervention?

An architecture uses Amazon SQS and AWS Lambda. The Lambda function processes messages from the SQS queue and writes data to Amazon DynamoDB. Occasionally, the DynamoDB write fails due to a temporary network issue. How should the architect ensure the message is not lost and is retried?