All practice questions

1964 questions

Question 101Question

A financial services company is modernizing its on-premises core transaction processing API by refactoring it to a serverless architecture on AWS. The new architecture uses an Amazon API Gateway regional REST API integrated with AWS Lambda functions deployed in private subnets, which write transactions to an Amazon RDS for PostgreSQL database. The database is hosted in a dedicated database account, while the API Gateway and Lambda functions are hosted in an application account. During peak hours, transaction volume spikes unpredictably. The company must ensure that database connection limits are not exceeded, Lambda executions do not exhaust the regional concurrency limit, and database credentials stored in AWS Secrets Manager in the database account are automatically rotated using a cross-account IAM role.

Which architectural design meets these requirements?

Show answer & explanation

Answer: Configure Amazon RDS Proxy in the database account. Store the database credentials in AWS Secrets Manager in the database account, encrypted with an AWS KMS Customer Managed Key (CMK) configured with a cross-account key policy. Configure the Lambda functions in the application account to connect via the RDS Proxy, and set a specific reserved concurrency limit on the Lambda functions. Configure the Secrets Manager rotation Lambda to decrypt the credentials using the CMK.

Answer

Configure Amazon RDS Proxy in the database account. Store the credentials in AWS Secrets Manager encrypted with an AWS KMS Customer Managed Key (CMK) with a cross-account key policy. Set a reserved concurrency limit on the application account Lambda functions to protect regional concurrency pools, and configure the rotation Lambda to decrypt credentials using the CMK.
The correct design uses Amazon RDS Proxy to pool database connections and protect PostgreSQL from exhaustion. A Customer Managed Key (CMK) is used to encrypt database credentials in AWS Secrets Manager because it supports custom cross-account key policies, enabling the application account's Lambda functions to decrypt the secret. Setting a reserved concurrency limit on the Lambda function prevents it from scaling out of control, protecting both the database proxy connection limits and the regional Lambda concurrency pool.

Step-by-Step Solution

1
Address database connection exhaustion during peak traffic bursts.
Introduce Amazon RDS Proxy to establish connection pooling and reuse database connections.
Lambda functions scale rapidly and can easily exceed PostgreSQL connection limits if they establish direct connections.
2
Ensure secure, cross-account access and automatic rotation of database credentials.
Use AWS Secrets Manager with a Customer Managed Key (CMK) and set up cross-account policies.
AWS-managed KMS keys cannot have their key policies modified to allow access from other accounts, necessitating a Customer Managed Key.
3
Implement concurrency protection to secure the regional account limit.
Configure a reserved concurrency limit on the Lambda functions in the application account.
Reserved concurrency isolates the function's scaling capability, preventing it from consuming the entire regional concurrency pool (which would throttle other services).

Key Concept

Cross-account KMS policies, Amazon RDS Proxy connection pooling, and AWS Lambda reserved concurrency management.
Estimated Time:2m 30s
Question 102Question

A logistics company is designing a high-throughput package tracking ingestion API. During peak hours, the API must handle sudden spikes of up to 150,000150,000 write requests per second. The architecture must ingest the data with minimal latency, decouple the ingestion layer from the backend database processing, and scale automatically to prevent data loss. Which two options should the solutions architect select to meet these requirements?

Select all that apply

Show answer & explanation

Answer: Configure an Amazon API Gateway REST API with a direct service integration to write incoming payloads to an Amazon Kinesis Data Stream.; Configure an AWS Lambda function to consume events from the Kinesis data stream in batches, and write the processed tracking events to an Amazon DynamoDB table configured with on-demand capacity.

Answer

The correct options are the API Gateway REST API with direct integration to Kinesis Data Streams, and the AWS Lambda function consuming events from Kinesis to write to DynamoDB with on-demand capacity.
The correct architecture uses Amazon API Gateway directly integrated with Amazon Kinesis Data Streams to ingest write requests with minimal latency, buffering the traffic spike of 150,000150,000 requests per second. Decoupling ingestion from downstream database writes is then achieved by using AWS Lambda to consume from the stream in batches and store the data in Amazon DynamoDB using on-demand capacity mode to scale dynamically.

Step-by-Step Solution

1
Select a low-latency, high-throughput ingestion layer that decouples writing from processing.
Amazon API Gateway with direct service integration to Amazon Kinesis Data Streams provides sub-millisecond integration latency and can handle massive write spikes without compute overhead.
Bypassing Lambda during ingestion minimizes write response time and safely buffers the incoming payload.
2
Process buffered events asynchronously and scale database writes dynamically.
Use AWS Lambda to consume events from the Kinesis stream in batches and write to an Amazon DynamoDB table in on-demand capacity mode.
Batch processing optimizes throughput, while DynamoDB on-demand capacity automatically scales to handle the write load.

Key Concept

Decoupling high-throughput, bursty write ingestion from backend processing using API Gateway, Kinesis Data Streams, and DynamoDB.
Question 103Question

A municipal transit authority is modernizing its on-premises ticketing system by migrating to a serverless architecture on AWS. The application will expose a public API for third-party transit applications to query real-time schedule updates and purchase tickets, which is expected to experience sudden, massive spikes in traffic during rush hours. The backend database is an Amazon RDS PostgreSQL DB instance situated in private subnets within a VPC. The new design must scale dynamically to handle rush-hour spikes, protect the database from connection exhaustion, ensure that traffic bursts do not throttle other critical serverless workloads in the AWS account, and encrypt all data at rest using customer-managed keys (CMKs). Which architectural design meets these requirements?

Show answer & explanation

Answer: Deploy an Amazon API Gateway REST API. Configure an AWS Lambda function integrated with the API Gateway, deploying it inside the VPC private subnets. Create an Amazon RDS Proxy in the private subnets to manage connections to the RDS PostgreSQL database. Configure reserved concurrency on the Lambda function, and encrypt the RDS database and Lambda environment variables using a KMS customer managed key.

Answer

Deploy an Amazon API Gateway REST API with an AWS Lambda function in the VPC private subnets, an Amazon RDS Proxy to manage database connections, reserved concurrency configured on the Lambda function, and a KMS customer managed key for encryption.
The correct architecture integrates Amazon API Gateway with an AWS Lambda function in the VPC private subnets, utilizing Amazon RDS Proxy to manage connection pooling and prevent database resource exhaustion. Configuring reserved concurrency on the Lambda function sets a maximum scaling limit, which prevents rush-hour spikes from consuming the regional account's entire concurrency pool and throttling other workloads. Using a KMS customer managed key (CMK) satisfies the security policy for custom encryption management.

Step-by-Step Solution

1
Evaluate backend database connectivity and scaling.
Amazon RDS Proxy must be used between the Lambda function and the RDS PostgreSQL instance to pool database connections, ensuring the database does not exhaust its connection limit during rush-hour traffic spikes.
Serverless architectures using AWS Lambda spin up rapid concurrent instances, which can quickly exceed the connection limits of a relational database.
2
Ensure regional Lambda concurrency protection.
Configure reserved concurrency on the ticketing Lambda function.
Reserved concurrency limits the maximum number of concurrent executions for a specific function, preserving the remaining concurrency pool for other critical workloads in the AWS account.
3
Implement security and encryption policies.
Use a Customer Managed Key (CMK) in AWS KMS to encrypt database storage and Lambda environment variables.
AWS-managed keys (such as aws/rds) do not allow policy customization and fail to meet the customer-managed requirement.

Key Concept

To modernize database-backed applications with serverless compute, utilize Amazon RDS Proxy to manage connection pooling, configure Lambda reserved concurrency to protect regional concurrency pools from exhaustion, and use AWS KMS Customer Managed Keys for custom security policies.
Question 104Question

A manufacturing corporation is launching a global IoT device fleet configuration management platform. The primary system runs on Amazon EC2 instances within a private subnet across three Availability Zones in the us-east-1 Region, communicating externally through NAT Gateways. The database tier uses Amazon Aurora PostgreSQL. The business requires a disaster recovery solution in the us-west-2 Region with a Recovery Time Objective (RTO) of 15 minutes and a Recovery Point Objective (RPO) of 1 minute. Which two options should the Solutions Architect choose to implement a highly available and resilient architecture that meets these requirements?

Select all that apply

Show answer & explanation

Answer: Deploy an Amazon Aurora Global Database with the primary cluster in us-east-1 and a secondary cluster in us-west-2.; Configure Amazon Route 53 failover routing policies with active-passive settings, associating health checks with the Application Load Balancer endpoints in both Regions.

Answer

Deploying Amazon Aurora Global Database for cross-region replication combined with Route 53 active-passive failover routing policies linked to regional Application Load Balancers.
The correct strategy combines low-latency database replication and automated DNS failover. Deploying an Amazon Aurora Global Database meets the 1-minute RPO because replication lag is under 1 second, and the secondary cluster can be promoted to a primary cluster within minutes. Setting up Route 53 active-passive failover routing with health checks linked to the Application Load Balancer endpoints automates routing to the standby Region during a primary Region failure, helping achieve the 15-minute RTO.

Step-by-Step Solution

1
Determine the database replication strategy to satisfy the 1-minute RPO.
Identify that Amazon Aurora Global Database provides physical, storage-based replication with replication lag under 1 second, meeting the RPO.
Standard cross-region snapshots do not meet the 1-minute RPO target.
2
Determine the global traffic routing strategy to satisfy the 15-minute RTO.
Identify that Route 53 active-passive failover routing policies automatically steer client requests to the secondary Region when the primary Region's endpoint is determined to be unhealthy by Route 53 health checks.
Automated DNS failover is necessary to minimize manual intervention and ensure the recovery window stays under 15 minutes.
3
Review architectural constraints such as NAT Gateway redundancy and Private Hosted Zone configuration to identify potential failure points.
Ensure NAT Gateways are deployed per Availability Zone, and make sure that any Private Hosted Zone is associated with both regional VPCs.
Outbound connectivity and internal DNS resolution must remain functional during localized AZ outages or full-region failovers.

Key Concept

Selecting and configuring cross-region database replication and global DNS failover policies to meet precise RTO/RPO targets.
Question 105Question

A financial services company is designing a new compliance auditing architecture using AWS Organizations. The security team operates from a centralized Audit account (111122223333) and must analyze sensitive transaction logs stored in an Amazon S3 bucket within a separate Production account (444455556666). The logs must be encrypted at rest. The solution must enforce the principle of least privilege, allowing only the auditing IAM role AuditReaderRole in the Audit account to read the logs, while preventing any other access. Which configuration will successfully enable this cross-account access while meeting the security requirements?

Show answer & explanation

Answer: Configure the Amazon S3 bucket in the Production account to use server-side encryption with an AWS KMS customer managed key (CMK). In the Production account, configure the CMK's key policy to allow kms:Decrypt permissions for AuditReaderRole in the Audit account, and configure the S3 bucket policy to allow s3:GetObject permissions for AuditReaderRole. In the Audit account, attach an IAM policy to AuditReaderRole that grants s3:GetObject on the S3 bucket and kms:Decrypt on the CMK.

Answer

Configure the S3 bucket to use a customer managed key (CMK), update the CMK's key policy and the S3 bucket policy in the Production account to trust the external role, and attach an IAM policy to the role in the Audit account permitting both S3 read and KMS decryption operations.
The correct solution involves using an AWS KMS customer managed key (CMK) because AWS managed keys (such as aws/s3) do not allow modification of their key policies to grant cross-account permissions. The resource owner must update both the S3 bucket policy and the CMK key policy to trust the target role. Additionally, the caller account must attach an IAM policy to the target role allowing it to read the S3 bucket and decrypt using the CMK. This creates the necessary trust chain for secure, least-privilege cross-account access.

Step-by-Step Solution

1
Select the correct encryption key type.
Use an AWS KMS customer managed key (CMK) instead of the default AWS managed key (aws/s3).
AWS managed keys cannot be shared across accounts as their key policies cannot be modified.
2
Configure the KMS key policy in the Production account.
Modify the customer managed key policy to allow the cross-account role 'AuditReaderRole' to perform 'kms:Decrypt'.
Without explicit cross-account trust in the key policy, external roles cannot utilize the key even if they have local IAM permissions.
3
Configure the S3 bucket policy in the Production account.
Allow 'AuditReaderRole' to perform 's3:GetObject' on the objects inside the bucket.
Cross-account access to S3 resources requires the resource owner (Production account) to grant permission to the external principal.
4
Configure the IAM policy in the Audit account.
Attach an identity-based policy to 'AuditReaderRole' allowing 's3:GetObject' and 'kms:Decrypt' on the respective resources.
An IAM identity must have explicit authorization in its own account to perform operations on external resources.

Key Concept

Cross-account access to S3 buckets encrypted with custom KMS keys requires explicit configuration in the S3 bucket policy, the KMS key policy, and the caller's IAM policy, and must utilize a customer managed key.
Estimated Time:2m 30s
Question 106Question

CloudSentry Solutions is designing a new medical archiving system. The application runs on AWS Fargate inside a private subnet in an Application Account. The Fargate tasks need to write processed medical records directly to a centralized Amazon S3 bucket located in a dedicated Compliance Account. All data written to the S3 bucket must be encrypted at rest using SSE-KMS. Which of the following configurations should the solutions architect recommend to satisfy these requirements securely?

Show answer & explanation

Answer: Create a customer managed key in the Compliance Account. Configure the KMS key policy to grant `kms:GenerateDataKey` permissions to the Fargate execution IAM role in the Application Account. Configure the S3 bucket policy in the Compliance Account to allow `s3:PutObject` permissions for the Fargate execution IAM role, and configure the Fargate task to use the compliance key for encryption.

Answer

Create a customer managed key in the Compliance Account, configure the KMS key policy to grant `kms:GenerateDataKey` to the Fargate execution IAM role in the Application Account, and configure the S3 bucket policy to allow `s3:PutObject` for the role.
The correct solution involves creating a Customer Managed Key (CMK) in the Compliance Account. A CMK is required because its policy can be modified to grant cross-account permissions. To allow the Fargate tasks in the Application Account to upload objects, the CMK policy must grant `kms:GenerateDataKey` to the Fargate execution role, and the S3 bucket policy must allow `s3:PutObject` for the same role.

Step-by-Step Solution

1
Select the correct KMS key type.
Avoid using the default AWS-managed KMS key (`aws/s3`) since it does not support cross-account access, and opt for a Customer Managed Key (CMK) in the Compliance Account.
AWS-managed KMS key policies cannot be modified to add cross-account trust.
2
Configure the Customer Managed Key policy in the Compliance Account.
Add a statement in the CMK policy that grants `kms:GenerateDataKey` permissions to the ARN of the Fargate task execution IAM role in the Application Account.
This enables the Fargate task to request a data key from KMS to encrypt the object during upload.
3
Configure the S3 bucket policy in the Compliance Account.
Add a statement in the S3 bucket policy that allows the `s3:PutObject` action, specifying the Fargate task execution IAM role as the principal.
Cross-account access to S3 buckets requires explicit authorization from the bucket owner via a bucket policy.

Key Concept

Cross-account access to S3 buckets encrypted with SSE-KMS requires using a Customer Managed Key and explicitly granting permissions on both the S3 bucket policy and the KMS key policy.
Estimated Time:1m 30s
Question 107Question

A media company is launching a global mobile voting application for a live televised talent show. The show expects up to 55 million users to submit votes concurrently within a televised 55-minute window. The votes must be ingested, validated, and aggregated in real-time, with results displayed on screen. The ingestion tier must handle an immediate jump from zero traffic to over 100,000100,000 write requests per second. The backend database requires single-digit millisecond latency for write operations and must scale horizontally to handle the peak write volume. Which of the following architectures provides the most performant, scalable, and operationally efficient solution to meet these requirements?

Show answer & explanation

Answer: Deploy a Network Load Balancer (NLB) to route traffic to an Amazon Elastic Container Service (Amazon ECS) cluster on AWS Fargate. Pre-warm the ECS tasks by configuring scheduled scaling to launch the required number of tasks before the voting window opens. Write vote data to an Amazon DynamoDB table configured with provisioned capacity, pre-provisioned to 100,000100,000 Write Capacity Units (WCUs), using a partition key with high cardinality such as a combination of ContestantID and a random shard number.

Answer

Deploy a Network Load Balancer (NLB) to route traffic to an Amazon Elastic Container Service (Amazon ECS) cluster on AWS Fargate. Pre-warm the ECS tasks by configuring scheduled scaling to launch the required number of tasks before the voting window opens. Write vote data to an Amazon DynamoDB table configured with provisioned capacity, pre-provisioned to 100,000100,000 Write Capacity Units (WCUs), using a partition key with high cardinality such as a combination of ContestantID and a random shard number.
The correct architecture uses a Network Load Balancer (NLB) which natively handles sudden, massive spikes in traffic without the need for pre-warming. In addition, scheduling ECS task scaling before the event ensures that the compute tier is ready to process requests immediately. Pre-provisioning DynamoDB Write Capacity Units (WCUs) ensures that the database has the required throughput, and utilizing write sharding (ContestantID + random shard) avoids hot partitions by distributing write operations across multiple physical partitions.

Step-by-Step Solution

1
Analyze ingestion tier load patterns and select the load balancer.
An instantaneous jump from zero to over 100,000100,000 requests per second requires a load balancer that handles sudden spikes without pre-warming. A Network Load Balancer (NLB) is selected.
An Application Load Balancer (ALB) requires pre-warming to scale to massive volumes instantly, and without it, it will drop requests during sudden spikes. NLB can scale to millions of requests per second immediately.
2
Select and configure the compute tier scaling strategy.
Pre-warm the compute tier by configuring scheduled scaling on the ECS service to launch the required tasks before the televised voting window starts.
Target tracking or step scaling policies are reactive and take time to bootstrap new tasks, which would result in request failures during the initial minutes of the event.
3
Select and configure the database tier for high-throughput writes.
Use Amazon DynamoDB with provisioned capacity pre-scaled to 100,000100,000 WCUs and a sharded partition key design.
DynamoDB handles single-digit millisecond write latencies. Pre-provisioning WCUs avoids throttling that occurs when on-demand capacity attempts to scale up instantly from zero, and partition sharding prevents hot partition issues.

Key Concept

Handling sudden flash traffic spikes by combining NLB (which scales instantly without pre-warming), scheduled compute scaling, and pre-provisioned DynamoDB tables with partition key sharding.
Estimated Time:3m 0s
Question 108Question

A logistics company is designing the database strategy for a new delivery tracking application (OLTP workload). The application requires a relational database that can handle highly concurrent write operations and must scale read operations dynamically during peak hours. The database design must support a recovery point objective (RPO) of 00 (no data loss) and a recovery time objective (RTO) of less than 1010 minutes. The database administrator also needs to archive historical delivery logs to a central Amazon S3 bucket in a separate auditing account. The archived logs must be encrypted at rest using a KMS key where the auditing account controls key policies and rotation. Which database and storage design meets these requirements?

Show answer & explanation

Answer: Deploy Amazon Aurora PostgreSQL with Aurora Auto Scaling for read replicas to handle dynamic read scaling. Configure the application to write to the primary instance. Archive historical logs to the Amazon S3 bucket in the auditing account, encrypted using a Customer Managed Key (CMK) created in the auditing account.

Answer

Deploy Amazon Aurora PostgreSQL with Aurora Auto Scaling for read replicas, and archive logs to Amazon S3 in the auditing account encrypted with a Customer Managed Key created in the auditing account.
The correct architecture combines Amazon Aurora PostgreSQL for the OLTP workload with a cross-account S3 upload using a Customer Managed Key (CMK). Aurora satisfies the high-availability and performance requirements since its architecture separates compute and storage, allowing read replicas to scale dynamically via Auto Scaling and serve traffic, while offering near-zero replication lag (satisfying the RPO of 0) and automatic failover under 10 minutes (satisfying the RTO). For the cross-account storage audit requirement, AWS-managed keys cannot be shared across accounts; therefore, a Customer Managed Key created and managed in the auditing account is required to delegate key administration and access to the application account.

Step-by-Step Solution

1
Analyze the primary workload requirements: OLTP relational database, dynamic read scaling, RPO of 00, and RTO of less than 1010 minutes.
Determine that Amazon Aurora PostgreSQL meets these database requirements, as it supports dynamic read replica auto-scaling, has near-zero replication lag, and fails over automatically in less than 1010 minutes.
Amazon RDS Multi-AZ standby instances cannot serve read traffic, and standard snapshot backup/restore strategies cannot achieve an RPO of 00.
2
Analyze the cross-account archive storage and encryption requirements.
Determine that a Customer Managed Key (CMK) owned by the auditing account must be used to encrypt the S3 archive objects.
AWS-managed KMS keys cannot be shared cross-account because their key policies cannot be modified.

Key Concept

Selecting high-availability database engines with dynamic read scaling and configuring secure cross-account storage encryption.
Estimated Time:2m 30s
Question 109Question

A global e-commerce company is designing a new microservice that runs on Amazon EC2 instances in an Auto Scaling Group in the Application Account (account ID 111122223333). The microservice needs to upload transaction records to a centralized Amazon S3 bucket located in a separate Compliance Account (account ID 444455556666). The transaction records contain sensitive customer data and must be encrypted at rest using a Customer Managed Key (CMK) in AWS KMS that is managed in the Compliance Account. The solutions architect must design a secure, cross-account access solution that adheres to the principle of least privilege. Which combination of actions will allow the microservice to securely write the encrypted transaction records to the S3 bucket? (Select TWO.)

Select all that apply

Show answer & explanation

Answer: In the Compliance Account, update the KMS CMK key policy to grant the EC2 instance role in the Application Account permissions to perform the kms:GenerateDataKey and kms:Decrypt operations.; In the Application Account, attach an IAM policy to the EC2 instance role that grants the s3:PutObject permission on the destination S3 bucket, and the kms:GenerateDataKey permission on the KMS CMK in the Compliance Account.

Answer

To securely write encrypted transaction records across accounts, you must update the KMS key policy in the Compliance Account to grant the EC2 instance role permissions for key generation and decryption, and attach an IAM policy to the EC2 instance role in the Application Account that permits writing to the bucket and using the KMS CMK.
For cross-account access, access must be allowed by both the IAM policy attached to the source principal (the EC2 instance role in the Application Account) and the resource-based policy (the S3 bucket policy and the KMS key policy in the Compliance Account). The EC2 instance role needs permissions to write to the destination bucket and use the KMS CMK to generate data keys for encryption. Correspondingly, the key policy in the Compliance Account must grant access to the external role.

Step-by-Step Solution

1
Configure permissions on the source IAM role in the Application Account.
The EC2 instance profile's IAM role is updated with a policy allowing s3:PutObject on the bucket arn:aws:s3:::compliance-bucket and kms:GenerateDataKey on the KMS CMK in the Compliance Account.
Source principals require explicit local IAM permissions to access resources in another account.
2
Configure the resource-based policy on the destination KMS CMK in the Compliance Account.
The KMS key policy is updated to include a statement allowing the EC2 instance role ARN from the Application Account to perform kms:GenerateDataKey and kms:Decrypt.
Since the KMS key is owned by the Compliance Account, the key policy must trust and authorize the external IAM role.
3
Configure the S3 bucket policy in the Compliance Account.
The S3 bucket policy is updated to grant s3:PutObject permission to the EC2 instance role ARN from the Application Account.
Cross-account S3 operations require both the bucket policy and the caller's IAM policy to allow the action.

Key Concept

Cross-Account Resource Access with KMS and S3
Estimated Time:2m 0s
Question 110Question

A company is designing a new cloud-native application that requires a relational database. The database must support high availability across multiple Availability Zones with a Recovery Point Objective (RPO) of 00. The application will generate sudden, unpredictable bursts of complex read queries, scaling from 100100 queries per second to over 10,00010,000 queries per second, which could saturate the database CPU. The solutions architect needs to design the database tier to handle these scaling spikes without affecting write performance or availability. Which database design meets these requirements?

Show answer & explanation

Answer: Use Amazon Aurora PostgreSQL. Configure Aurora Auto Scaling to dynamically adjust the number of Aurora Replicas based on target CPU utilization, and configure the application to use the reader endpoint for read queries.

Answer

Use Amazon Aurora PostgreSQL with Aurora Auto Scaling to scale Aurora Replicas dynamically and route read queries to the reader endpoint.
The correct design uses Amazon Aurora PostgreSQL with Aurora Replicas and Aurora Auto Scaling. In Aurora, the storage volume is shared and replicated synchronously across three Availability Zones, ensuring an RPO of 00. Aurora Replicas share the same storage volume as the primary writer and can be scaled dynamically using Auto Scaling policies based on CPU utilization. Routing read queries to the reader endpoint load-balances the queries across the replicas, preventing CPU saturation on the primary instance.

Step-by-Step Solution

1
Analyze high availability and RPO requirements
Amazon Aurora and Amazon RDS Multi-AZ both replicate data across multiple Availability Zones. However, Aurora's shared storage architecture replicates data synchronously across 33 Availability Zones, satisfying the RPO of 00 requirement.
Establishing the storage replication foundation ensures zero data loss during failover.
2
Evaluate read scaling options
Amazon RDS Multi-AZ deployments use a passive standby that cannot serve read traffic. Amazon Aurora supports active Aurora Replicas that share the same underlying storage volume and can serve read traffic with minimal replication lag.
Determining which database architecture can offload read queries from the primary writer node is necessary to prevent CPU saturation.
3
Select dynamic scaling and routing mechanism
Aurora Auto Scaling can add or remove Aurora Replicas based on target CPU utilization metrics. The application connects to the reader endpoint, which load-balances incoming read queries across the active replica pool.
Configuring automatic scaling and a reader endpoint satisfies the performance and scalability optimization requirement.

Key Concept

Scaling read-heavy database workloads using Amazon Aurora Replicas and Aurora Auto Scaling
Question 111Question

AeroQuest Diagnostics is developing a new telemetry analysis platform. Flight telemetries are collected from on-premises sensors and written to an Amazon S3 bucket in a Processing Account (111111111111). An analytics application running on Amazon EKS in an Analytics Account (222222222222) must read these objects to perform machine learning analysis. All objects in the S3 bucket are encrypted at rest using a Customer Managed Key (CMK) in the Processing Account. The solution must follow the principle of least privilege and use direct cross-account access without assuming cross-account IAM roles. Which combination of configurations must the Solutions Architect implement to allow the EKS application to successfully read the encrypted telemetry objects? (Select TWO.)

Select all that apply

Show answer & explanation

Answer: Configure the S3 bucket policy in the Processing Account (111111111111) to grant s3:GetObject permission to the specific IAM role ARN associated with the EKS service account in the Analytics Account (222222222222).; Configure the key policy of the Customer Managed Key in the Processing Account (111111111111) to grant kms:Decrypt permission to the specific IAM role ARN associated with the EKS service account in the Analytics Account (222222222222).

Answer

Configure the S3 bucket policy in the Processing Account to grant s3:GetObject permission to the EKS service account IAM role ARN, and configure the key policy of the Customer Managed Key in the Processing Account to grant kms:Decrypt permission to the EKS service account IAM role ARN.
To allow an IAM role in an external account to retrieve objects encrypted with a Customer Managed Key, two resource-based policies in the source account must be updated: the S3 bucket policy (to grant read access to the objects) and the KMS key policy (to grant decryption rights to the CMK). The combination of these configurations allows direct, secure cross-account reading without the overhead of assuming cross-account roles.

Step-by-Step Solution

1
Identify the encryption mechanism of the source S3 bucket.
The bucket uses a Customer Managed Key (CMK) in the Processing Account (111111111111).
This determines that cross-account access is technically feasible since CMK key policies can be modified, unlike AWS managed keys (aws/s3).
2
Configure cross-account S3 bucket access.
Add an entry to the S3 bucket policy in the Processing Account allowing the specific IAM role ARN of the EKS service account in the Analytics Account to perform s3:GetObject.
For cross-account access, S3 bucket policies must explicitly trust the external principal role.
3
Configure cross-account KMS key access.
Add an entry to the key policy of the Customer Managed Key (CMK) in the Processing Account allowing the specific EKS IAM role ARN to perform kms:Decrypt.
Since the objects are encrypted, S3 needs to decrypt them on behalf of the reading principal, which requires explicit trust in the KMS key policy for cross-account roles.
4
Configure local IAM permissions in the destination account.
Ensure the EKS service account's IAM role in the Analytics Account has local permissions to call s3:GetObject on the bucket and kms:Decrypt on the CMK ARN.
Both local IAM authorization and source resource-based authorization (bucket policy + key policy) are required for cross-account actions.

Key Concept

Cross-account access to encrypted S3 objects requires explicit authorization in the local IAM policy, the remote S3 bucket policy, and the remote KMS Customer Managed Key policy.
Question 112Question

A healthcare organization is modernizing its on-premises patient registration system by migrating to a serverless architecture on AWS. The application will expose an internal API to multiple business partners operating in separate AWS accounts within the same AWS Organization.

The new architecture uses Amazon API Gateway private REST APIs and AWS Lambda functions that retrieve data from an Amazon Aurora PostgreSQL database.

The architecture must satisfy the following requirements:
- The API must only be accessible over private connections from the partners' VPCs.
- The API Gateway endpoint must resolve using the default private DNS hostnames, and cross-account DNS resolution must be functional.
- The Lambda functions must handle sudden bursts in registration requests without exhausting the database connection pool or throttling other critical workloads in the host account.

Which TWO configurations must a solutions architect implement to satisfy these requirements? (Select TWO.)

Select all that apply

Show answer & explanation

Answer: Create Amazon RDS Proxy between the Lambda functions and the Aurora database, and configure reserved concurrency on the registration Lambda functions.; Create an interface VPC endpoint for API Gateway in each partner VPC, associate the host account's Route 53 Private Hosted Zone with the partner VPCs, and apply an API Gateway resource policy allowing access from the VPC endpoints.

Answer

The correct configurations are to deploy Amazon RDS Proxy with reserved concurrency for the Lambda functions, and to establish cross-account private API access by creating interface VPC endpoints in the partner VPCs, associating the Route 53 Private Hosted Zone with the partner VPCs, and using an API Gateway resource policy.
Implementing Amazon RDS Proxy and Lambda reserved concurrency manages scaling behavior safely without overloading the database or exhausting the host account's shared regional concurrency. Creating interface VPC endpoints, associating the Route 53 Private Hosted Zone cross-account, and implementing resource policies allows secure, private DNS resolution and traffic routing across organizational boundaries.

Step-by-Step Solution

1
Analyze database connection limits and concurrency impacts.
Identify that sudden bursts of Lambda invocations will deplete Aurora's connection pool. Setting up Amazon RDS Proxy handles connection pooling, while reserved concurrency limits the maximum resource utilization of the Lambda function to protect the host account's other functions.
Ensures database availability under peak loads and maintains operational isolation for neighboring serverless workloads.
2
Design the private cross-account API Gateway integration.
Determine that private APIs require interface VPC endpoints in the client (partner) VPCs. To resolve DNS queries correctly across accounts, the Route 53 Private Hosted Zone in the host account must be explicitly associated with the partner VPCs.
Allows private network traffic to transit to the API Gateway without traversing the public internet, satisfying the private connectivity and DNS requirements.
3
Secure the private API Gateway endpoints.
Apply an API Gateway resource policy to the private REST API that explicitly allows the Action 'execute-api:Invoke' from the partner's VPC endpoints.
Restricts access to authorized VPC endpoints and prevents unauthorized entities from reaching the private endpoints.

Key Concept

Deploying cross-account private serverless APIs using API Gateway private REST endpoints, Route 53 Private Hosted Zones, and RDS Proxy with Lambda concurrency management.
Estimated Time:2m 0s
Question 113Question

An IoT energy company is launching a smart grid monitoring platform to ingest and analyze electricity consumption data from over 1212 million smart meters. During extreme weather events, the platform experiences sudden, massive surges in telemetry queries as utility providers run diagnostic reports. Read traffic is expected to spike from 500500 queries per second (QPS) to over 200,000200,000 QPS within less than 33 minutes. The backend application runs on Amazon ECS on AWS Fargate behind an Application Load Balancer (ALB), accessing data stored in an Amazon Aurora PostgreSQL database cluster. Which two actions should a solutions architect recommend to optimize the performance and scalability of the architecture to handle these traffic spikes? (Select TWO.)

Select all that apply

Show answer & explanation

Answer: Contact AWS Support to pre-warm the Application Load Balancer (ALB) with the expected traffic profile and ramp-up rate.; Configure Amazon Aurora Auto Scaling to dynamically scale reader instances based on CPU utilization, and configure the application to utilize the Aurora reader endpoint for read-only reporting queries.

Answer

To optimize performance and scalability for flash traffic, the solutions architect must contact AWS Support to pre-warm the Application Load Balancer, and configure Amazon Aurora Auto Scaling to scale reader replicas while using the reader endpoint for reporting queries.
Pre-warming the ALB ensures that the load balancer has enough capacity already provisioned to absorb the 400400-fold traffic spike without dropping connections. Scaling the database tier horizontally using Aurora Auto Scaling and routing the read-only reporting queries to the reader endpoint offloads CPU utilization from the primary instance and allows the read capacity to dynamically adjust to the spike.

Step-by-Step Solution

1
Analyze the load balancer scaling characteristics under extreme flash traffic conditions.
The traffic scales from 500500 QPS to 200,000200,000 QPS in less than 33 minutes (a 400400-fold increase). Standard Application Load Balancer automatic scaling cannot cope with such rapid increases, necessitating pre-warming.
Requesting AWS Support to pre-warm the ALB ensures the load balancer is provisioned with sufficient capacity beforehand to prevent dropped connections.
2
Analyze database scaling options for the read-heavy reporting queries.
Amazon Aurora allows horizontal scaling of reads via Aurora Replicas. Configuring Aurora Auto Scaling allows the cluster to automatically add reader instances based on CPU utilization metrics.
Routing read traffic to the Aurora reader endpoint ensures the load is distributed across the dynamically scaled reader replicas, preventing database CPU exhaustion on the primary instance.
3
Evaluate the architectural limits of alternative options.
Multi-AZ standby database instances cannot serve read traffic, and ElastiCache for Memcached does not support multi-AZ replication.
Eliminating these invalid patterns ensures the design complies with high availability and operational requirements.

Key Concept

Handling massive, instantaneous traffic spikes requires pre-warming the load balancing layer and utilizing horizontal read scaling with Aurora reader endpoints and auto-scaling replicas.
Question 114Question

A company is designing a high-throughput IoT telemetry ingestion platform on AWS. The platform must process HTTPS data payloads from 500,000 IoT devices sending data every 10 seconds. The ingestion layer must handle sudden, unpredictable 10x spikes in traffic during device registration events without dropping messages. Additionally, the reporting interface requires real-time read access to consolidated sensor status. Which two actions should the solutions architect take to optimize the performance and scalability of this solution? (Select TWO.)

Select all that apply

Show answer & explanation

Answer: Deploy an Amazon SQS queue to buffer incoming telemetry payloads, allowing backend worker instances to process messages at a controlled rate and protect the database from write exhaustion.; Use an Amazon Aurora DB cluster for the database and configure Aurora Auto Scaling to dynamically scale the number of Aurora Replicas to handle read traffic from the reporting interface.

Answer

Deploying an Amazon SQS queue to buffer incoming writes, and using an Amazon Aurora DB cluster with Aurora Auto Scaling for replicas to handle read scaling.
To handle sudden write spikes without dropping messages, write workloads should be decoupled and buffered using a message queue like Amazon SQS. To scale reads for the reporting interface, Amazon Aurora's read replicas can be dynamically scaled using Aurora Auto Scaling.

Step-by-Step Solution

1
Address the write scalability and spike protection requirement.
Introduce a message queue (Amazon SQS) to decouple the ingestion layer and buffer the sudden 10x write spikes, shielding the backend database.
Sudden 10x spikes cannot be absorbed immediately by scaling load balancers or databases without buffering, which prevents request loss.
2
Address the read scaling requirement for the reporting interface.
Use Amazon Aurora DB cluster and enable Aurora Auto Scaling for the replicas.
Aurora Auto Scaling automatically adjusts the number of read replicas to handle reporting queries, offloading read traffic from the primary instance.

Key Concept

Decoupling write workloads with message queues and dynamically scaling read capacity using database replicas.
Question 115Question

A healthcare provider is designing a claims portal that will store digital claims documents and transaction metadata. The claims documents (average size 2 MB) are accessed by internal processes and must also be shared securely with a third-party auditor operating in a separate AWS account. The documents require immediate retrieval for the first 30 days. After 30 days, they must be archived to a cheaper storage tier, but must remain retrievable within 5 minutes. The transaction metadata workload is relational, requires high availability across multiple Availability Zones, and experiences frequent spikes in analytical reporting queries that must not impact active write transactions. Which two of the following database and storage configurations should the solutions architect select to satisfy these requirements? (Select TWO.)

Select all that apply

Show answer & explanation

Answer: Store the claims documents in an Amazon S3 bucket. Encrypt the bucket using a customer managed KMS key, and configure the key policy to allow cross-account decrypt permissions for the third-party auditor's AWS account. Use an S3 Lifecycle policy to transition the documents to Amazon S3 Glacier Flexible Retrieval after 30 days.; Store the transaction metadata in an Amazon Aurora PostgreSQL database cluster. Deploy the cluster with one writer instance and at least one reader replica in a different Availability Zone. Configure Aurora Auto Scaling to dynamically add reader replicas based on average CPU utilization to handle reporting query spikes.

Answer

The system should store the claims documents in an Amazon S3 bucket, encrypted with a customer managed KMS key, and transitioned to Amazon S3 Glacier Flexible Retrieval after 30 days. The database tier should utilize Amazon Aurora PostgreSQL with reader replicas and Auto Scaling.
Storing the claims documents in Amazon S3 and transitioning them to Amazon S3 Glacier Flexible Retrieval after 30 days meets both the archive and the sub-5-minute retrieval requirements because Glacier Flexible Retrieval supports expedited retrievals (1-5 minutes). Additionally, cross-account access to encrypted S3 objects requires a customer managed KMS key because the default AWS-managed KMS key (aws/s3) cannot be shared across accounts. For the database tier, Amazon Aurora PostgreSQL with reader replicas and Auto Scaling allows the system to automatically handle spikes in analytical reporting queries without affecting the primary writer instance.

Step-by-Step Solution

1
Determine the S3 storage class and lifecycle policy requirements for archiving claims documents.
Select Amazon S3 with an S3 Lifecycle transition to S3 Glacier Flexible Retrieval after 30 days.
S3 Glacier Flexible Retrieval supports expedited retrievals (1-5 minutes), meeting the 5-minute RTO requirement, whereas S3 Glacier Deep Archive only supports standard/bulk retrievals (12-48 hours).
2
Evaluate the encryption and cross-account access requirements for S3 objects.
Use a customer managed KMS key (CMK) with cross-account access granted via the key policy.
AWS-managed KMS keys (like aws/s3) cannot be shared with external AWS accounts because their policies cannot be customized, so a customer managed KMS key is required.
3
Determine the database architecture to support scaling reads for analytical reporting without affecting writes.
Deploy Amazon Aurora PostgreSQL with reader replicas and configure Aurora Auto Scaling.
Aurora Replicas handle read scaling, and Auto Scaling automatically handles query spikes. Amazon RDS Multi-AZ standby instances are passive and cannot be queried.

Key Concept

Selecting optimal storage tiers and encryption methods for cross-account access, and choosing high-availability database architectures to scale read-heavy analytical workloads.
Estimated Time:2m 0s
Question 116Question

An advertising technology company is designing a real-time bidding (RTB) platform that must process incoming bid requests from multiple ad exchanges. The system must handle a peak load of 300,000300,000 write requests per second with a target response latency of less than 2020 milliseconds. The bid request data is highly transient and only needs to be persisted for 2424 hours for auditing, but the active campaign budget data must be updated in real-time with strict consistency to prevent overspending. Which combination of architectural decisions should the Solutions Architect recommend to achieve these requirements with the lowest latency and highest scalability? (Select TWO.)

Select all that apply

Show answer & explanation

Answer: Use Amazon ElastiCache for Redis with Multi-AZ and auto-failover enabled to store and update active campaign budget balances in-memory, leveraging Redis hashes and Lua scripting to perform atomic operations.; Ingest the incoming transient bid request logs using Amazon Kinesis Data Streams, and configure an Amazon Kinesis Data Firehose delivery stream to batch and load the data into Amazon S3 for auditing.

Answer

To support high-throughput, low-latency, and consistent state updates, the architect should recommend storing active budget balances in Amazon ElastiCache for Redis with Lua scripting, and ingesting transient logging payloads using Amazon Kinesis Data Streams for downstream audit storage.
The correct architecture uses Amazon ElastiCache for Redis to manage campaign budgets because its in-memory processing provides sub-20 millisecond performance, and server-side Lua scripts ensure atomic, thread-safe updates to prevent budget overruns. For the log ingestion pipeline, Amazon Kinesis Data Streams acts as a highly scalable buffer that can handle arbitrary throughput levels by partitioning traffic across shards, transferring data asynchronously to Amazon S3 via Kinesis Data Firehose.

Step-by-Step Solution

1
Analyze write performance and consistency requirements.
Real-time campaign budget updates require sub-millisecond response latencies and atomic consistency to avoid overspending.
Relational databases cannot scale writes to 300,000300,000 requests per second within a 2020 millisecond SLA. In-memory datastores like Redis are required.
2
Select the correct caching technology.
Amazon ElastiCache for Redis is chosen over Memcached.
Redis supports replication, multi-AZ failover, and Lua scripting for transactional operations, whereas Memcached lacks replication and atomic scripting features.
3
Design the ingestion pipeline for transient audit logs.
Select Amazon Kinesis Data Streams integrated with Kinesis Data Firehose.
Kinesis Data Streams scales horizontally by adjusting shard capacity, decoupling high-velocity write ingestion from the long-term S3 storage layer.

Key Concept

Handling high-throughput writes at sub-20ms latency requires combining in-memory datastores for consistent state tracking and horizontally scalable streaming ingestion pipelines for transient logs.
Estimated Time:2m 0s
Question 117Question

A European Union public sector agency is designing a secure document archiving solution across a multi-account organization. The architecture includes a centralized Archive Account (account 111122223333) with an Amazon S3 bucket, and multiple departmental Agency Accounts. Applications in the Agency Accounts run on Amazon EC2 instances and must upload official records directly to the centralized S3 bucket.

To meet strict data sovereignty compliance, all uploaded objects must be encrypted using server-side encryption with AWS KMS (SSE-KMS) using a key managed by the security team in the Archive Account. The security team wants to ensure that:
1. Departmental applications can upload files only if they are encrypted with the approved key.
2. The Archive Account retains full control over the encryption key and the data.
3. The departmental applications cannot delete or modify archives once uploaded.

The security team creates a Customer Managed Key (CMK) in the Archive Account. How should the security team configure the policies to allow the Agency Account (account 444455556666) applications to upload encrypted documents to the S3 bucket?

Show answer & explanation

Answer: Create a Customer Managed Key (CMK) in the Archive Account. In the CMK's key policy, grant the Agency Account's IAM role (`AgencyUploadRole`) permissions for the `kms:GenerateDataKey` and `kms:Decrypt` actions. In the Archive Account's S3 bucket policy, grant the `AgencyUploadRole` permissions for the `s3:PutObject` action, with conditions enforcing encryption using the CMK. In the Agency Account, attach an IAM policy to the `AgencyUploadRole` that permits `s3:PutObject` on the S3 bucket and `kms:GenerateDataKey` and `kms:Decrypt` on the CMK.

Answer

Create a Customer Managed Key (CMK) in the Archive Account. In the CMK's key policy, grant the Agency Account's IAM role (`AgencyUploadRole`) permissions for the `kms:GenerateDataKey` and `kms:Decrypt` actions. In the Archive Account's S3 bucket policy, grant the `AgencyUploadRole` permissions for the `s3:PutObject` action, with conditions enforcing encryption using the CMK. In the Agency Account, attach an IAM policy to the `AgencyUploadRole` that permits `s3:PutObject` on the S3 bucket and `kms:GenerateDataKey` and `kms:Decrypt` on the CMK.
The correct solution involves creating a Customer Managed Key (CMK) in the Archive Account, which allows key policy customization. For cross-account access to work with encrypted S3 buckets, permissions must be explicitly allowed at three layers: the KMS key policy, the S3 bucket policy, and the IAM policy of the source role. The key policy and bucket policy in the Archive Account must trust the external role principal (or trust the root account and have the root account delegate it), and the IAM policy in the Agency Account must grant the role the permission to use the external S3 bucket and CMK.

Step-by-Step Solution

1
Evaluate the key type requirements for cross-account encryption and decryption.
Identify that AWS-managed KMS keys (like `aws/s3`) cannot be used for cross-account uploads because their key policies are fixed and cannot be modified. A Customer Managed Key (CMK) must be created in the destination account (Archive Account) to enable policy customization.
AWS-managed keys do not support cross-account sharing.
2
Configure permissions on the resource policies in the destination account (Archive Account).
Modify the KMS key policy to permit the external IAM role (`AgencyUploadRole`) to perform `kms:GenerateDataKey` and `kms:Decrypt`. Modify the S3 bucket policy to permit the external IAM role to perform `s3:PutObject` with conditions requiring SSE-KMS with the specific CMK.
Resource-based policies must trust the external account or role for cross-account access.
3
Configure the local IAM policy in the source account (Agency Account).
Attach an IAM policy to the `AgencyUploadRole` that explicitly allows `s3:PutObject` on the destination S3 bucket and `kms:GenerateDataKey` and `kms:Decrypt` on the CMK in the Archive Account.
Even if the target resource policies trust the external principal or account, the source account must still explicitly grant its own roles permission to perform the cross-account actions.

Key Concept

Cross-account access to encrypted S3 buckets requires configuring permissions on the destination resource policies (S3 bucket policy and KMS key policy) and the source account's IAM policies, utilizing a Customer Managed Key (CMK) rather than an AWS-managed key.
Question 118Question

A company is launching a ticket booking platform that expects an instantaneous surge of 150,000150,000 concurrent users within a 33-minute window when a major event is announced. The application is hosted on Amazon ECS tasks behind an Application Load Balancer. The database tier uses an Amazon Aurora MySQL DB cluster. The initial user activity is heavily read-intensive, with users repeatedly checking ticket availability.

Which architectural design will provide the most performant and scalable solution to handle this traffic spike while minimizing latency?

Show answer & explanation

Answer: Implement Amazon ElastiCache for Redis to cache ticket availability status. Enable Aurora Auto Scaling for the read replicas to handle any backend read traffic. Submit a support ticket to AWS to pre-warm the Application Load Balancer before the ticket sale starts.

Answer

Implement Amazon ElastiCache for Redis to cache ticket availability status, enable Aurora Auto Scaling for the read replicas to handle residual backend read traffic, and submit a support ticket to AWS to pre-warm the Application Load Balancer prior to the sale.
The correct answer combines Application Load Balancer pre-warming to handle the instant network surge, ElastiCache for Redis to cache repetitive database reads, and Aurora Auto Scaling for replicas to handle database read scaling. This meets the performance and scalability requirements of a flash traffic scenario.

Step-by-Step Solution

1
Address the immediate network ingestion layer capacity.
Requesting ALB pre-warming ensures that the load balancer is provisioned with sufficient capacity before the surge of 150,000150,000 users arrives.
Standard ALB auto-scaling reacts to traffic increases and takes time to scale out, resulting in dropped requests during sudden spikes.
2
Address the high-frequency query load on the database.
Caching the ticket availability queries in Amazon ElastiCache for Redis offloads the database tier.
Repeated read queries for the same availability data can be served with sub-millisecond latency from memory, preserving database resources.
3
Provide horizontal scale for database cache misses.
Enable Aurora Auto Scaling to dynamically provision additional Aurora Replicas based on CPU or connection metrics.
This scales database read capacity horizontally to handle any traffic that bypasses the cache.

Key Concept

Handling sudden, massive traffic spikes requires pre-provisioning capacity at the entry point (ALB pre-warming), caching repeating read queries using a fast caching layer (ElastiCache), and scaling the database horizontally using dedicated read replicas rather than passive standby instances.
Estimated Time:2m 0s
Question 119Question

A global ride-sharing platform is designing a backend for its new real-time driver tracking and rider-matching service. The platform must ingest location telemetry from 600,000600,000 active drivers every 33 seconds (approximately 200,000200,000 write requests per second). Riders will query the database to find the 55 nearest available drivers within a 33-mile radius, requiring sub-1010 millisecond response times. The location telemetry database must scale seamlessly during peak hours without administrative overhead. Which architecture represents the most performant, scalable, and operationally efficient solution to meet these requirements?

Show answer & explanation

Answer: Ingest driver telemetry using Amazon Kinesis Data Streams. Process the stream with AWS Lambda and store the location coordinates in an Amazon ElastiCache for Redis cluster with cluster mode enabled. Perform nearby driver searches using Redis geospatial commands (GEOADD and GEORADIUS) against the cluster.

Answer

Ingest driver telemetry using Amazon Kinesis Data Streams, process the stream with AWS Lambda, and store the location coordinates in an Amazon ElastiCache for Redis cluster with cluster mode enabled, performing nearby driver searches using Redis geospatial commands.
The correct architecture uses Amazon Kinesis Data Streams to ingest the telemetry and AWS Lambda to process it. Storing the coordinates in Amazon ElastiCache for Redis with cluster mode enabled allows horizontal scaling of both writes and reads across multiple shards. Redis natively supports geospatial indices and commands (such as GEOADD and GEORADIUS) which provide sub-1010 millisecond latency and satisfy the application's query requirements.

Step-by-Step Solution

1
Analyze the write throughput and scale requirements.
The system must process 200,000200,000 write requests per second, which requires a highly scalable ingestion and storage layer.
Choosing a backend that supports horizontal write scaling is critical to prevent write bottlenecks.
2
Evaluate the database choices for geospatial querying and write throughput.
Amazon ElastiCache for Redis with cluster mode enabled supports sharding (horizontal scaling of writes) and native geospatial commands (GEOADD, GEORADIUS), whereas Memcached lacks geospatial functions and Aurora PostgreSQL cannot scale writes horizontally via read replicas.
This determines the data store that can meet the sub-1010 millisecond latency and scale requirements.
3
Compare ingestion mechanisms for high-throughput stream data.
Amazon Kinesis Data Streams combined with AWS Lambda can efficiently ingest and batch partition the telemetry streams, whereas using an Application Load Balancer without pre-warming for sudden spikes is prone to failure.
Ensuring the ingestion tier matches the backend capacity and handles spikes gracefully.

Key Concept

Scaling database write throughput using Amazon ElastiCache for Redis Cluster mode and native geospatial indexing for low-latency queries.
Question 120Question

A financial technology company is designing a new international transaction processing system (OLTP workload). The system must meet the following requirements:

* The transactional database must handle high-volume write traffic, support complex relational queries, and maintain a recovery point objective (RPO) of less than 1 second and a recovery time objective (RTO) of less than 1 minute across two AWS regions.
* The database must scale read capacity dynamically to handle regional analytics queries based on CPU utilization.
* Transaction receipts must be archived to an Amazon S3 bucket in a separate auditing AWS account. The archived data must be encrypted at rest, and the application in the primary account must write directly to this bucket using cross-account encryption key delegation.

Which database and storage strategy meets these requirements?

Show answer & explanation

Answer: Deploy an Amazon Aurora PostgreSQL Global Database with a primary cluster in the primary region and a secondary cluster in the secondary region. Configure Aurora Auto Scaling to scale reader instances within the database clusters. Configure the transaction receipts to be written to the auditing account's Amazon S3 bucket, encrypted using a Customer Managed Key (CMK) in the auditing account with key policy and bucket policy permissions delegated to the primary account's IAM role.

Answer

Deploy an Amazon Aurora PostgreSQL Global Database with a primary cluster in the primary region and a secondary cluster in the secondary region. Configure Aurora Auto Scaling to scale reader instances within the database clusters. Configure the transaction receipts to be written to the auditing account's Amazon S3 bucket, encrypted using a Customer Managed Key (CMK) in the auditing account with key policy and bucket policy permissions delegated to the primary account's IAM role.
The correct answer proposes Amazon Aurora Global Database, which uses storage-based replication to achieve sub-second replication lag (RPO < 1s) and failover in less than 1 minute (RTO < 1m). Aurora Auto Scaling dynamically scales the number of Aurora Replicas based on CPU utilization to handle read capacity. Additionally, cross-account S3 writes with KMS encryption require a Customer Managed Key (CMK) in the target auditing account with a key policy that delegates usage rights to the primary account's IAM role, as AWS-managed keys cannot be shared cross-account.

Step-by-Step Solution

1
Evaluate database configurations for multi-region disaster recovery objectives.
Amazon Aurora Global Database is selected because it uses storage-based replication to achieve sub-second replication lag (RPO < 1s) and quick failover (RTO < 1m).
Alternative options using hourly snapshot replication fail the 1-second RPO requirement.
2
Determine the proper method to scale read capacity dynamically.
Aurora Auto Scaling is configured to adjust the number of Aurora Replicas (readers) based on CPU utilization.
RDS Multi-AZ standby instances are passive and cannot be used to serve read queries.
3
Design the cross-account encryption and S3 bucket write configuration.
Create a Customer Managed Key (CMK) in the auditing account and delegate key permissions to the primary account's IAM role.
AWS-managed keys (like aws/s3) cannot be shared across accounts due to immutable key policies.

Key Concept

Database and Storage Strategy
PreviousPage 6 / 99Next
All practice questions — AWS Certified Solutions Architect - Professional | Examkin