Courseiva

AWS Certified Data Engineer Associate DEA-C01 (DEA-C01) — Questions 301–375

1711 questions total · 23pages · All types, answers revealed

Take a mock examExam hub
Page 4

Page 5 of 23

Page 6
301
Multi-Selecteasy

A data engineer needs to transfer 50 TB of data from an on-premises data center to Amazon S3 over a 1 Gbps network. The transfer must be completed within one week. Which TWO AWS services can be used for this task? (Choose TWO.)

Select 2 answers
A.AWS Glue
B.AWS DataSync
C.AWS Snowball
D.Amazon S3 Transfer Acceleration
E.AWS Direct Connect
AnswersB, C

Designed for network-based bulk data transfer.

Why this answer

AWS DataSync is correct because it is designed to efficiently transfer large datasets over the network using a purpose-built agent that parallelizes data transfer and optimizes network utilization. With a 1 Gbps link, DataSync can transfer 50 TB within a week by leveraging its built-in compression, encryption, and incremental transfer capabilities, making it suitable for this time-constrained migration.

Exam trap

The trap here is that candidates assume S3 Transfer Acceleration can accelerate any transfer, but it only optimizes the last-mile upload to S3 and does not address the bottleneck of moving data from on-premises storage to the internet, nor does it provide a mechanism to pull data from on-premises systems.

Full explanation →
302
MCQhard

A company is using Amazon Kinesis Data Streams to ingest real-time clickstream data. The data is consumed by a fleet of EC2 instances running a custom application that processes the records and writes to DynamoDB. The application is experiencing high latency and records are being processed slower than they are produced. The stream has 5 shards. Which action would MOST effectively improve processing speed?

A.Use the Kinesis Client Library (KCL) to automatically distribute shards among instances.
B.Increase the EC2 instance size to provide more CPU and memory.
C.Add more EC2 instances consuming from the same stream without changing shard count.
D.Increase the number of shards in the Kinesis stream.
AnswerD

More shards increase the stream's capacity and allow more parallel consumers.

Why this answer

The bottleneck is the number of shards in the Kinesis stream. Each shard provides a fixed read capacity of 2 MB/s and 5 read transactions per second. With only 5 shards, the total read throughput is limited regardless of how many EC2 instances consume the data.

Increasing the number of shards increases the total read capacity, allowing more records to be consumed in parallel and reducing processing latency.

Exam trap

The trap here is that candidates often think adding more consumers (EC2 instances) will automatically speed up processing, but they fail to recognize that each shard's read throughput is fixed, so without increasing shards, additional consumers cannot consume more data in parallel.

How to eliminate wrong answers

Option A is wrong because the Kinesis Client Library (KCL) manages shard-to-instance assignment and checkpointing, but it does not increase the total throughput of the stream; it only distributes existing shard capacity among consumers. Option B is wrong because increasing EC2 instance size improves compute resources but does not address the fundamental read throughput limit imposed by the number of shards; the application will still be throttled by the shard's 2 MB/s read limit. Option C is wrong because adding more EC2 instances without increasing the number of shards does not increase the total read capacity; each shard can only be consumed by one record processor at a time (within a single KCL application), so additional instances will remain idle or cause contention.

Full explanation →
303
Multi-Selectmedium

Which THREE of the following are valid storage classes in Amazon S3? (Choose THREE.)

Select 3 answers
A.S3 Standard
B.S3 Archive
C.S3 Intelligent-Tiering
D.S3 Cold
E.S3 One Zone-IA
AnswersA, C, E

S3 Standard is a general-purpose storage class.

Why this answer

S3 Standard is a valid storage class designed for frequently accessed data with low latency and high throughput. It offers 99.999999999% durability and 99.99% availability, making it suitable for a wide range of use cases like cloud applications, dynamic websites, and content distribution.

Exam trap

AWS often tests the distinction between valid S3 storage classes and fabricated names like 'S3 Archive' or 'S3 Cold', expecting candidates to recall the exact naming conventions (e.g., S3 Glacier, S3 Glacier Deep Archive) rather than generic terms.

Full explanation →
304
Multi-Selectmedium

A data engineer is designing a disaster recovery strategy for an Amazon RDS for PostgreSQL database. The primary database is in us-east-1. Which TWO approaches provide cross-region disaster recovery?

Select 2 answers
A.Configure cross-region automated backups to copy to us-west-2.
B.Take a manual snapshot and copy it to us-west-2 daily.
C.Use Amazon S3 cross-region replication for the database export.
D.Enable Multi-AZ in us-east-1.
E.Create a cross-region read replica in us-west-2.
AnswersA, E

Backups are automatically copied and can be restored.

Why this answer

Amazon RDS supports cross-region automated backups, which automatically copy backup data (snapshots and transaction logs) from the primary region (us-east-1) to a secondary region (us-west-2). This provides a fully managed, automated disaster recovery solution that allows point-in-time recovery in the secondary region without manual intervention.

Exam trap

The trap here is that candidates often confuse Multi-AZ (which provides in-region high availability) with cross-region disaster recovery, or they assume manual snapshot copying is equivalent to automated cross-region backups, not realizing the significant difference in RPO and operational overhead.

Full explanation →
305
Multi-Selectmedium

A data engineer needs to ensure that sensitive data stored in Amazon S3 is encrypted at rest. Which TWO options meet this requirement? (Choose TWO.)

Select 2 answers
A.Server-Side Encryption with AWS KMS-Managed Keys (SSE-KMS)
B.Server-Side Encryption with S3-Managed Keys (SSE-S3)
C.Using a VPC to restrict network access
D.Enabling MFA Delete on the S3 bucket
E.Client-Side Encryption with SSL/TLS
AnswersA, B

SSE-KMS encrypts objects at rest using KMS keys.

Why this answer

Server-Side Encryption with AWS KMS-Managed Keys (SSE-KMS) allows you to enforce encryption at rest for S3 objects using a customer-managed or AWS-managed KMS key. This option meets the requirement because the encryption is applied server-side by S3 before the data is written to disk, and the data is decrypted automatically when accessed with appropriate permissions. SSE-KMS also provides an audit trail via AWS CloudTrail for every key usage.

Exam trap

The trap here is that candidates often confuse encryption in transit (SSL/TLS) with encryption at rest, or they mistakenly think network controls like VPCs or access controls like MFA Delete provide data encryption, when they only address different security domains.

Full explanation →
306
MCQmedium

A data engineer is migrating an on-premises Apache HBase workload to Amazon DynamoDB. The application requires strongly consistent reads and the ability to query by a composite key (partition key + sort key). Which DynamoDB table design should be used?

A.Create a table with a partition key and sort key, and use ConsistentRead parameter.
B.Use a secondary index with strongly consistent reads.
C.Use a local secondary index (LSI) with the composite key.
D.Create a global secondary index (GSI) with the composite key.
AnswerA

Table key provides composite key querying; ConsistentRead ensures strong consistency.

Why this answer

DynamoDB natively supports strongly consistent reads when you use the `ConsistentRead` parameter set to `true` on GetItem, Query, or Scan operations. By defining a table with a partition key and sort key, you can directly query by the composite key (partition key + sort key) with strong consistency, meeting both requirements without additional infrastructure.

Exam trap

The trap here is that candidates assume secondary indexes (LSI or GSI) can provide strongly consistent reads, but DynamoDB explicitly restricts strong consistency to base table operations only.

How to eliminate wrong answers

Option B is wrong because secondary indexes (both LSI and GSI) in DynamoDB only support eventually consistent reads by default; strongly consistent reads are not supported on any secondary index. Option C is wrong because a local secondary index (LSI) does not replace the base table's composite key query capability; it provides an alternative sort key but still requires the base table for strongly consistent reads, and LSI itself cannot be read with strong consistency. Option D is wrong because a global secondary index (GSI) supports only eventually consistent reads and cannot be used for strongly consistent queries, regardless of the key schema.

Full explanation →
307
MCQhard

A company is using Amazon ElastiCache for Redis to cache frequently accessed data. The cache hit ratio is low, and the engineering team suspects that the eviction policy is causing important data to be removed. Which eviction policy should be used to minimize eviction of the most frequently accessed keys?

A.allkeys-lru
B.allkeys-lfu
C.noeviction
D.volatile-lru
AnswerB

LFU evicts least frequently used keys, retaining popular ones.

Why this answer

The allkeys-lfu (Least Frequently Used) eviction policy is the correct choice because it explicitly tracks and retains keys that are accessed most frequently across the entire keyspace. Since the cache hit ratio is low due to eviction of important data, LFU ensures that frequently accessed keys are evicted last, directly addressing the problem of important data being removed.

Exam trap

The trap here is that candidates often confuse recency (LRU) with frequency (LFU), assuming that 'least recently used' also implies 'least frequently used,' but LRU can evict a frequently accessed key that hasn't been touched recently, which is exactly the problem described.

How to eliminate wrong answers

Option A is wrong because allkeys-lru (Least Recently Used) evicts keys based on recency of access, not frequency, so a frequently accessed key that hasn't been used recently could be evicted. Option C is wrong because noeviction returns errors for write operations when memory is full, which would cause application failures rather than solving the low hit ratio. Option D is wrong because volatile-lru only applies to keys with a TTL set, leaving keys without TTLs unprotected and potentially evicting important data that lacks an expiration.

Full explanation →
308
MCQmedium

A company uses Amazon S3 to store images that are accessed by a web application. The application generates presigned URLs for users to download images. Recently, the application has been experiencing errors when generating presigned URLs for objects that were uploaded using multipart upload. The errors indicate that the presigned URL does not work. The data engineer needs to ensure that presigned URLs work for all objects, including those uploaded via multipart upload. What should the data engineer do?

A.Use a different signing algorithm when generating the presigned URL.
B.Ensure that the IAM user or role used to generate the presigned URL has s3:GetObject permission for the object.
C.Enable S3 Versioning on the bucket.
D.Re-upload the objects using single-part upload instead of multipart upload.
AnswerB

Permissions are required to generate a valid presigned URL.

Why this answer

Presigned URLs work regardless of whether the object was uploaded via single-part or multipart upload. The error typically occurs because the IAM user or role used to generate the presigned URL lacks the s3:GetObject permission for the object. Option B is correct.

Option A (changing signing algorithm) is unnecessary; SigV4 is the default and works for all cases. Option C (enabling versioning) does not affect presigned URL generation. Option D (re-uploading) is not required as multipart uploads do not break presigned URLs.

Full explanation →
309
Multi-Selecteasy

Which THREE actions can help improve read performance in Amazon DynamoDB? (Choose THREE.)

Select 3 answers
A.Use DynamoDB global tables to replicate data.
B.Use parallel scans to distribute read load across partitions.
C.Use strongly consistent reads for all queries.
D.Enable DynamoDB Accelerator (DAX) to cache reads.
E.Increase the read capacity units (RCU) for the table.
AnswersB, D, E

Parallel scans can improve scan performance.

Why this answer

Parallel scans in DynamoDB can improve read performance by dividing a scan operation into multiple segments that are processed concurrently across partitions. This reduces the overall latency of the scan by leveraging the distributed nature of DynamoDB's storage, though it consumes more read capacity units (RCUs) due to the parallel execution.

Exam trap

The DEA-C01 exam often tests the misconception that strongly consistent reads always improve performance, when in fact they increase latency and RCU consumption, making eventually consistent reads the better choice for read-heavy workloads.

Full explanation →
310
MCQhard

A data engineer runs the above AWS CLI command to investigate who uploaded a file to an S3 bucket. The output shows the event was recorded. Which additional step is needed to confirm the identity of the user?

A.No additional step is needed; the 'Username' field already identifies the IAM user.
B.Use the 'MFA' field to check if multi-factor authentication was used.
C.View the 'accessKeyId' field in the CloudTrailEvent JSON.
D.Look up the 'sourceIPAddress' in the CloudTrailEvent.
AnswerA

The 'Username' field contains the full ARN of the IAM user who made the request.

Why this answer

The 'Username' field in the CloudTrail event log directly identifies the IAM user who made the API call. No additional step is needed to confirm the identity. Options B, C, and D are unnecessary as they provide supplementary information but do not directly identify the user when the Username is already present.

Full explanation →
311
MCQeasy

A data engineer is ingesting streaming data from thousands of IoT devices into AWS. The data is JSON-formatted and must be stored in Amazon S3 for long-term analytics. Which service is most appropriate for real-time ingestion and routing to S3?

A.Amazon SQS
B.Amazon Kinesis Data Firehose
C.Amazon Kinesis Data Streams
D.AWS Glue
AnswerB

Kinesis Data Firehose can deliver streaming data directly to S3 without additional code.

Why this answer

Amazon Kinesis Data Firehose is the most appropriate service because it is designed for real-time ingestion of streaming data and can directly deliver data to Amazon S3 without requiring custom code. It automatically handles buffering, compression, and partitioning of JSON data, making it ideal for long-term analytics storage.

Exam trap

The trap here is that candidates often confuse Kinesis Data Streams with Kinesis Data Firehose, assuming both can directly write to S3, but Data Streams requires a downstream consumer to perform the write, making Firehose the correct choice for direct, managed ingestion to S3.

How to eliminate wrong answers

Option A is wrong because Amazon SQS is a message queue service for decoupling application components, not a streaming ingestion service; it lacks built-in data transformation and direct S3 delivery capabilities. Option C is wrong because Amazon Kinesis Data Streams is a real-time data streaming service that requires a separate consumer (e.g., Lambda or Firehose) to write data to S3, adding complexity and latency; it is not a direct ingestion-to-S3 solution. Option D is wrong because AWS Glue is a serverless ETL service for batch data processing and cataloging, not designed for real-time streaming ingestion or direct routing to S3.

Full explanation →
312
MCQhard

A healthcare company is ingesting patient data from a legacy system into an Amazon S3 data lake using AWS Glue. The legacy system produces CSV files with inconsistent schemas (columns may appear or disappear in different files). The data engineer needs to create a Glue ETL job that can handle schema evolution and transform the data into a standardized parquet format. The job should also be able to process new files as they arrive. Which approach should the data engineer use?

A.Use AWS Glue crawlers to create a schema in the Data Catalog and then use a standard Spark DataFrame for transformation.
B.Use AWS Glue DynamicFrames to read the CSV files and apply transformations using resolveChoice and applyMapping.
C.Use a Python shell job in Glue to manually parse each file and write to parquet.
D.Use a Glue ETL job with a static schema defined in the script and ignore files that don't match.
AnswerB

DynamicFrames support schema evolution.

Why this answer

AWS Glue DynamicFrames support schema evolution by allowing schema-on-read, and the `resolveChoice` and `applyMapping` transformations can handle inconsistent schemas across CSV files. Option A is wrong because crawlers only catalog schemas, not perform ETL transformations. Option C is wrong because Python shell jobs are not designed for large-scale ETL and lack native schema evolution handling.

Option D is wrong because a static schema would reject files with missing or extra columns, failing to handle schema evolution.

Full explanation →
313
Multi-Selecteasy

A data engineer is monitoring Amazon CloudWatch metrics for an Amazon Redshift cluster and notices high CPU utilization. The engineer wants to reduce CPU usage. Which TWO actions should the engineer take?

Select 2 answers
A.Enable concurrency scaling to offload read queries to additional clusters.
B.Increase the number of nodes in the cluster.
C.Optimize the table design by using sort keys and compression.
D.Run the VACUUM command on all tables.
E.Enable audit logging to monitor queries.
AnswersA, C

Offloads queries, reducing CPU on main cluster.

Why this answer

Options A and C are correct. Enabling concurrency scaling offloads read queries to additional clusters, reducing CPU load on the main cluster. Optimizing table design with sort keys and compression reduces the amount of data scanned per query, lowering CPU usage.

Option B (increasing node count) increases overall CPU capacity but does not reduce usage; it may even increase cost without addressing inefficiency. Option D (running VACUUM) primarily reclaims disk space and maintains data distribution, not CPU reduction. Option E (enabling audit logging) adds CPU overhead, making it counterproductive.

Full explanation →
314
Multi-Selectmedium

A data engineer needs to schedule a nightly ETL job that reads from an Amazon RDS database and writes to Amazon S3 in Parquet format. The solution must be serverless and minimize cost. Which TWO AWS services should be used? (Choose TWO.)

Select 2 answers
A.AWS Data Pipeline
B.AWS Lambda
C.Amazon Athena
D.Amazon S3
E.AWS Glue
AnswersD, E

S3 is the destination for the transformed data.

Why this answer

AWS Glue can run serverless ETL jobs. Amazon S3 is the destination. Lambda could trigger but not run the ETL itself; Data Pipeline is not serverless; Athena is query-only.

Full explanation →
315
MCQmedium

Refer to the exhibit. A data engineer sees this error in CloudWatch Logs from an AWS Glue ETL job. The job reads from an S3 location that contains both .parquet and .csv files. What is the most likely cause?

A.The S3 object was deleted during the job execution.
B.The IAM role does not have permission to read the S3 object.
C.The job is reading a CSV file that was incorrectly placed in the directory with .parquet extension.
D.The Glue job does not have enough memory to parse the Parquet file.
AnswerC

The file might have .parquet extension but be CSV, or the job is reading all files regardless of extension.

Why this answer

The error indicates that the job encountered an object that is not a valid Parquet file. Since the S3 location contains both .parquet and .csv files, the Glue job likely attempted to read a CSV file as if it were Parquet, causing the invalid Parquet error. Option C is correct because the CSV file was incorrectly placed in the directory with a .parquet extension (or the job's schema inference expects all files to be Parquet).

Option A is incorrect because the error is about format, not a missing file. Option B is incorrect because the error is about the object's format, not a permissions issue. Option D is incorrect because insufficient memory would typically cause out-of-memory or capacity errors, not an invalid Parquet error.

Full explanation →
316
MCQhard

A company has a Glue ETL job that reads from an Amazon RDS for MySQL table and writes to Amazon S3. The job runs hourly and processes new records based on a 'last_modified' timestamp column. Recently, the job started missing some records because the timestamp in MySQL is stored with microsecond precision but Glue's job bookmark only tracks second precision. Which solution addresses this issue?

A.Use a job parameter to store the last processed timestamp with millisecond precision and query records greater than that value.
B.Increase the job frequency to every 30 minutes.
C.Run a full refresh of the table each time instead of incremental.
D.Modify the MySQL table to use a DATE data type instead of TIMESTAMP.
AnswerA

Custom job bookmark with higher precision.

Why this answer

AWS Glue job bookmarks track timestamps with only second precision, so records with microsecond differences within the same second are missed. By using a custom job parameter to store the last processed timestamp with millisecond precision and querying records greater than that value, you bypass Glue's bookmark limitation and capture all new or modified records.

Exam trap

The trap here is that candidates assume Glue job bookmarks automatically handle all timestamp precisions, but the exam tests awareness that bookmarks default to second-level granularity and that custom logic is required for sub-second precision.

How to eliminate wrong answers

Option B is wrong because increasing job frequency does not address the precision mismatch; it only reduces the window for missed records but does not eliminate the root cause of second-level granularity. Option C is wrong because running a full refresh each time is inefficient and costly, and it does not solve the precision issue—it simply avoids incremental processing. Option D is wrong because changing the column to DATE data type would lose time-of-day information entirely, making incremental processing based on last_modified impossible.

Full explanation →
317
MCQhard

A company stores sensitive customer data in an Amazon S3 bucket with versioning enabled. A data engineer accidentally deleted the current version of an object. What is the quickest way to restore the object to its previous state without additional data transfer costs?

A.Use S3 Batch Operations to restore the object from the Recycle Bin.
B.Delete the delete marker that was created by the deletion.
C.Copy the previous version from the bucket to itself.
D.Use the S3 sync command to restore the previous version.
AnswerB

Deleting the delete marker restores the previous version as the current object without copying data.

Why this answer

With S3 versioning enabled, deleting an object does not permanently remove it; instead, a delete marker is placed. To restore the object to its previous state, you simply remove the delete marker, which makes the previous version the current version again. Option A is incorrect because S3 does not have a Recycle Bin; S3 Batch Operations are for bulk actions but not for restoring from a recycle bin.

Option C would not restore the object properly; copying the previous version to itself would create a new version, not restore the original. Option D is incorrect because the s3 sync command synchronizes objects between locations and does not restore previous versions.

Full explanation →
318
MCQhard

A data pipeline uses AWS Glue ETL jobs to process data from Amazon RDS for MySQL to Amazon S3. Recently, the jobs have been failing with the error 'Communications link failure' during the connection phase. The RDS instance is in a private subnet, and the Glue job uses a VPC endpoint for S3. What is the most likely cause?

A.The RDS database has reached the maximum number of connections.
B.The Glue job does not have IAM permissions to decrypt the RDS database using AWS KMS.
C.The JDBC driver used by Glue is incompatible with the MySQL version.
D.The Glue job does not have a network path to the RDS instance because it is not attached to the same VPC subnet.
AnswerD

Glue jobs need an ENI in the same VPC to connect to RDS.

Why this answer

The 'Communications link failure' error during connection indicates a network connectivity issue between the AWS Glue job and the RDS instance. Even if the Glue job uses a VPC endpoint for S3, that endpoint does not provide connectivity to RDS. To connect to an RDS instance in a private subnet, the Glue job must be attached to the same VPC (e.g., via an elastic network interface) or have a network path through VPC peering or VPN.

Option A (max connections) would yield a 'too many connections' error, not a communications link failure. Option B (KMS permissions) would cause an access denied error, not a connection failure. Option C (JDBC driver incompatibility) would typically produce a 'No suitable driver' or driver class not found error.

Therefore, the most likely cause is that the Glue job lacks a network path to the RDS instance.

Full explanation →
319
MCQeasy

A company uses AWS Glue to process sensitive data stored in Amazon S3. The security team requires that all data in transit between AWS Glue and S3 be encrypted. Which configuration should be used to meet this requirement?

A.Use an S3 bucket policy that denies requests not using HTTPS.
B.Use an AWS KMS key to encrypt the data before uploading to S3.
C.Configure AWS Glue to use SSL by setting the 'ssl' parameter to 'true'.
D.Enable default encryption on the S3 bucket using SSE-S3.
AnswerA

This enforces encryption in transit for all requests.

Why this answer

Requiring HTTPS for all requests to the S3 bucket ensures that data in transit between AWS Glue and S3 is encrypted using TLS. By using an S3 bucket policy with a condition that denies requests where `aws:SecureTransport` is false, the company enforces encryption for all connections, including those from AWS Glue. This meets the security requirement without needing to modify Glue or S3 configurations beyond the bucket policy.

Exam trap

The trap here is that candidates often confuse encryption at rest (SSE-S3, SSE-KMS, client-side encryption) with encryption in transit (TLS/HTTPS), and may incorrectly assume that enabling default encryption or using KMS keys secures the data during transfer.

How to eliminate wrong answers

Option B is wrong because encrypting data with an AWS KMS key before uploading to S3 (client-side encryption) protects data at rest, not data in transit; the security team specifically requires encryption in transit. Option C is wrong because AWS Glue does not have an 'ssl' parameter; Glue uses HTTPS by default when connecting to S3, and this setting is not configurable via a simple parameter. Option D is wrong because enabling default encryption on the S3 bucket (SSE-S3) only encrypts data at rest, not data in transit between Glue and S3.

Full explanation →
320
MCQhard

A company is using Amazon DynamoDB for an e-commerce application. The application experiences sudden spikes in traffic, causing throttling errors. The data engineer needs to handle the spikes cost-effectively. Which solution should be used?

A.Implement DynamoDB Accelerator (DAX) to cache reads.
B.Switch to DynamoDB on-demand capacity mode.
C.Use DynamoDB auto scaling with a target utilization of 70%.
D.Provision high read and write capacity units to handle peak traffic.
AnswerC

Auto scaling adjusts capacity dynamically based on traffic.

Why this answer

DynamoDB auto scaling with a target utilization of 70% allows the table to dynamically adjust provisioned read/write capacity based on actual traffic patterns, handling sudden spikes without manual intervention while avoiding over-provisioning. This balances performance and cost by scaling up during spikes and scaling down during low traffic, preventing throttling errors cost-effectively.

Exam trap

The trap here is that candidates often confuse caching (DAX) with scaling, or assume on-demand mode is always the best for spikes without considering cost, when the question explicitly requires a cost-effective solution for sudden but intermittent traffic.

How to eliminate wrong answers

Option A is wrong because DynamoDB Accelerator (DAX) is an in-memory cache that only improves read latency and reduces read throttling, but it does not address write throttling or handle sudden spikes in write traffic, which is the primary issue here. Option B is wrong because DynamoDB on-demand capacity mode automatically scales to handle spikes but is significantly more expensive for predictable or moderate workloads, making it less cost-effective than auto scaling for this scenario. Option D is wrong because provisioning high read and write capacity units to handle peak traffic leads to over-provisioning and wasted cost during normal or low traffic periods, as you pay for the provisioned capacity regardless of actual usage.

Full explanation →
321
MCQmedium

An e-commerce company ingests clickstream data from their website into Amazon S3. The data is in JSON format, and each file is about 10 MB. They need to transform the data into a columnar format for analytics and load it into Amazon Redshift nightly. The transformation should be cost-effective and require minimal operational overhead. Which approach meets these requirements?

A.Use AWS Glue ETL job to convert to Parquet and load into Redshift.
B.Use Amazon Redshift COPY command to load JSON directly.
C.Use Amazon EMR with Spark to transform and load data.
D.Use AWS Lambda to transform each file and write to Redshift.
AnswerA

Serverless and minimal overhead.

Why this answer

AWS Glue ETL is the correct choice because it is a serverless, managed service that can efficiently convert JSON to Parquet (a columnar format optimized for Redshift) and load the data into Redshift with minimal operational overhead. The nightly batch processing of 10 MB files is well-suited for Glue's pay-per-use pricing, making it cost-effective without requiring infrastructure management.

Exam trap

The trap here is that candidates may choose Amazon EMR or Lambda because they are familiar with Spark or serverless functions, but they overlook the operational overhead of EMR and the execution limits of Lambda for batch workloads, while Glue provides a balanced, managed solution for this specific use case.

How to eliminate wrong answers

Option B is wrong because the Redshift COPY command can load JSON directly, but it does not transform the data into a columnar format like Parquet; it loads JSON as-is, which is less efficient for analytics and may require additional schema handling. Option C is wrong because Amazon EMR with Spark introduces significant operational overhead for managing clusters, tuning, and monitoring, which is unnecessary for a simple nightly transformation of small 10 MB files. Option D is wrong because AWS Lambda has a maximum execution timeout of 15 minutes and limited memory (up to 10 GB), making it unsuitable for batch processing multiple files or handling large datasets; it is designed for event-driven, short-lived tasks, not nightly ETL workloads.

Full explanation →
322
MCQhard

A data engineer is troubleshooting a failed AWS Glue job that reads from an Apache Hive metastore in an Amazon EMR cluster. The error message indicates 'ClassNotFoundException: org.apache.hadoop.hive.ql.metadata.HiveException'. The Glue job uses a custom Python shell script. What is the most likely cause of this error?

A.Check the network connectivity between Glue and the EMR cluster.
B.Include the Hive JAR files in the 'Python library path' or use a Glue version with Hive support.
C.Modify the Python script to import the Hive libraries manually.
D.Update the IAM role to allow 'hive:Describe*' actions.
AnswerB

Glue needs Hive JARs in the classpath to connect to Hive metastore.

Why this answer

The ClassNotFoundException for Hive classes indicates that the required Hive JARs are not available in the Glue job's classpath. The solution is to include the Hive JAR files in the 'Python library path' or use a Glue version that supports Hive connectivity. Option A is incorrect because a network connectivity issue would cause a different error, such as a timeout or connection refused.

Option C is incorrect because simply adding an import statement in the Python script does not provide the underlying JAR files; the JARs must be included via library path. Option D is incorrect because IAM permissions do not affect class loading; the error is related to missing dependencies, not authorization.

Full explanation →
323
MCQeasy

A data engineer is tasked with transforming JSON data from an S3 bucket into Parquet format for efficient querying. The transformation should run on a schedule every hour. Which AWS service is best suited for this task?

A.AWS Lambda
B.Amazon Athena
C.AWS Glue
D.Amazon EMR
AnswerC

Glue provides managed ETL jobs that can be scheduled and support Parquet conversion.

Why this answer

AWS Glue is the best choice because it is a fully managed ETL service designed specifically for transforming and cataloging data at scale. It can natively read JSON from S3, convert it to Parquet, and run on a scheduled hourly basis using a Glue job with a trigger, without requiring server management or custom infrastructure.

Exam trap

The trap here is that candidates often confuse Athena's ability to query Parquet with the ability to transform data into Parquet, but Athena is a query engine, not an ETL service, and cannot perform scheduled data format conversions.

How to eliminate wrong answers

Option A is wrong because AWS Lambda has a maximum execution timeout of 15 minutes and a 10 GB memory limit, making it unsuitable for processing large JSON datasets or running long-running hourly transformations. Option B is wrong because Amazon Athena is an interactive query service for analyzing data directly in S3, not a transformation engine; it cannot convert JSON to Parquet and write the output back to S3 in a scheduled, automated manner. Option D is wrong because Amazon EMR requires provisioning and managing a cluster of EC2 instances, which adds operational overhead and cost, whereas the task calls for a serverless, scheduled transformation with minimal management.

Full explanation →
324
MCQmedium

A data engineer notices that an AWS Glue ETL job processing data from Amazon S3 to Amazon Redshift has been failing intermittently with the error 'S3ServiceException: SlowDown'. Which action is MOST likely to resolve this issue?

A.Increase the number of partitions in the Glue job to parallelize reads.
B.Switch from a Standard to a G.2X large Glue worker type.
C.Implement exponential backoff and retry logic in the Glue job.
D.Enable S3 Transfer Acceleration on the source bucket.
AnswerC

Exponential backoff reduces request rate and handles throttling gracefully.

Why this answer

The 'S3ServiceException: SlowDown' error indicates that the AWS Glue job is making requests to Amazon S3 at a rate that exceeds the bucket's request rate limits. Implementing exponential backoff and retry logic (option C) is the most effective solution because it reduces the effective request rate by introducing delays between retries, allowing S3 to recover from throttling. Option A is incorrect because increasing partitions would likely increase the number of concurrent requests, exacerbating throttling.

Option B is incorrect because switching to a larger worker type does not affect the rate of S3 requests. Option D is incorrect because S3 Transfer Acceleration improves network transfer speed but does not reduce request throttling.

Full explanation →
325
MCQmedium

An organization needs to audit all access to their S3 buckets for compliance purposes. They want to log both successful and failed API calls. Which AWS service should be used?

A.Amazon CloudWatch Logs
B.AWS Config
C.AWS CloudTrail
D.VPC Flow Logs
AnswerC

CloudTrail logs API calls for auditing.

Why this answer

AWS CloudTrail is the correct service because it records all API calls made to S3, including both successful and failed requests, and delivers log files to an S3 bucket for auditing and compliance. CloudTrail captures management events (e.g., CreateBucket) and, when enabled, data events (e.g., GetObject, PutObject) for S3, providing a complete audit trail of access.

Exam trap

The trap here is that candidates often confuse AWS CloudTrail (API auditing) with AWS Config (configuration auditing) or VPC Flow Logs (network traffic logging), failing to recognize that only CloudTrail captures the specific API call details needed for access auditing.

How to eliminate wrong answers

Option A is wrong because Amazon CloudWatch Logs is used for monitoring, storing, and accessing log files from various AWS services (e.g., EC2, Lambda), but it does not natively capture S3 API calls; it can only receive logs forwarded from CloudTrail or other sources. Option B is wrong because AWS Config is a service for evaluating resource configurations against desired policies and tracking configuration changes, not for logging API calls or access events. Option D is wrong because VPC Flow Logs capture IP traffic metadata (source/destination IP, ports, protocol) at the network interface level, not S3 API-level operations or authentication details.

Full explanation →
326
MCQhard

A company runs an Amazon Redshift cluster for analytics. During peak hours, query performance degrades significantly. The data engineer notices that disk space usage is above 80% on many nodes. Which of the following is the MOST effective long-term solution to improve query performance?

A.Increase the workload management (WLM) queue slots.
B.Resize the cluster to include additional nodes.
C.Apply compression encoding to all columns.
D.Run the VACUUM command to reclaim space.
AnswerB

Adding nodes increases both storage and compute resources, directly addressing disk usage and performance.

Why this answer

Resizing the cluster to include additional nodes increases both storage and compute capacity, directly addressing the high disk usage and improving query performance. Increasing WLM queue slots (Option A) only manages concurrency but does not add capacity. Compression encoding (Option C) reduces storage but may not alleviate immediate performance degradation, and is not a long-term solution for capacity.

Running VACUUM (Option D) reclaims space from deleted rows but does not add new capacity.

Full explanation →
327
Multi-Selectmedium

A data engineer is designing a data store for a real-time analytics application that requires sub-millisecond read and write latency for time-series data. The data volume is expected to grow to hundreds of terabytes. Which TWO AWS services should the engineer consider? (Choose TWO.)

Select 2 answers
A.Amazon Redshift
B.Amazon DynamoDB with Time-to-Live (TTL)
C.Amazon ElastiCache for Redis
D.Amazon RDS for PostgreSQL
E.Amazon Timestream
AnswersB, E

DynamoDB supports low-latency reads/writes and TTL for automatic expiration of old data.

Why this answer

Amazon DynamoDB with TTL is correct because it provides single-digit millisecond read and write latency at any scale, making it suitable for real-time time-series data. The TTL feature automatically expires old records, which helps manage the hundreds of terabytes of data without manual intervention, keeping storage costs predictable.

Exam trap

The trap here is that candidates may overlook Amazon Timestream because it is a newer, specialized service, and instead choose ElastiCache for Redis due to its low latency, failing to consider the hundreds of terabytes storage requirement that makes Redis impractical.

Full explanation →
328
MCQmedium

A company uses AWS Glue ETL jobs to process data from an S3 data lake. The job reads data in CSV format, transforms it, and writes to Parquet. The job runs daily and takes 2 hours to complete. The data volume is increasing by 20% each month. The engineer wants to reduce the job runtime. Which action is most effective?

A.Increase the number of DPUs for the Glue job
B.Enable compression on the input CSV files
C.Switch from Python Shell to Spark ETL
D.Partition the input data in S3 by date and use partition pruning in the job
AnswerD

Partition pruning limits the data read to only relevant partitions, drastically reducing processing time.

Why this answer

Most effective because partitioning the input data by date and using partition pruning allows the Glue ETL job to read only the relevant partitions instead of scanning the entire S3 data lake. This drastically reduces the amount of data processed, which directly addresses the growing data volume and shortens job runtime. Partition pruning is a core optimization for Spark-based Glue jobs, as it leverages Hive-style partitioning to skip unnecessary files.

Exam trap

The trap here is that candidates often assume increasing DPUs or enabling compression is the universal fix, but they fail to recognize that reducing the data scanned via partition pruning is the most impactful optimization for growing datasets in S3-based Glue jobs.

How to eliminate wrong answers

Option A is wrong because increasing DPUs (Data Processing Units) adds more parallelism but does not reduce the volume of data read; it may help only if the job is CPU-bound, but the primary bottleneck here is the increasing data volume, not compute capacity. Option B is wrong because enabling compression on input CSV files reduces storage size and I/O overhead, but CSV is not splittable when compressed (e.g., Gzip), which can actually harm parallelism and increase runtime; moreover, the job still reads all data. Option C is wrong because the question states the job already uses AWS Glue ETL, which is Spark-based by default; switching from Python Shell to Spark ETL would be a regression, as Python Shell is single-node and slower for large datasets, but the current job is already using Spark (implied by Glue ETL), so this change is irrelevant or counterproductive.

Full explanation →
329
MCQmedium

A streaming application sends data to Amazon Kinesis Data Streams. The data must be enriched with reference data from an Amazon DynamoDB table in real-time. Which AWS service can be used to perform this enrichment with minimal latency?

A.Amazon Kinesis Data Analytics for Apache Flink
B.Amazon Kinesis Data Firehose with Lambda transformation
C.AWS Lambda function triggered by Kinesis Data Streams
D.AWS Glue streaming ETL
AnswerA

Flink can perform low-latency stream processing and join with DynamoDB.

Why this answer

Amazon Kinesis Data Analytics for Apache Flink is correct because it allows you to run Apache Flink applications that can read from a Kinesis data stream, perform stateful stream processing, and enrich records in real-time by joining with reference data stored in DynamoDB. Flink's asynchronous I/O and managed state enable sub-second enrichment latency without the cold-start delays or concurrency limits of Lambda-based approaches.

Exam trap

The DEA-C01 exam often tests the distinction between real-time stream processing (Kinesis Data Analytics for Flink) and near-real-time or batch-oriented services (Firehose, Glue ETL), leading candidates to choose Lambda because they assume serverless functions are always the lowest-latency option, ignoring concurrency and cold-start limitations in streaming contexts.

How to eliminate wrong answers

Option B is wrong because Amazon Kinesis Data Firehose is a near-real-time delivery service with a minimum buffer interval of 60 seconds, making it unsuitable for real-time enrichment with minimal latency. Option C is wrong because AWS Lambda triggered by Kinesis Data Streams has a maximum concurrency limit per shard (e.g., 10 concurrent invocations per shard) and incurs cold-start latency, which can cause backpressure and increased processing delays for high-throughput streaming workloads. Option D is wrong because AWS Glue streaming ETL is based on Apache Spark Structured Streaming, which introduces higher startup overhead and micro-batch latency (typically seconds), making it less optimal for sub-second real-time enrichment compared to Flink's event-at-a-time processing.

Full explanation →
330
MCQeasy

A data engineer is investigating why Amazon Athena queries on the 'my-data-lake' bucket are slow. The table is partitioned by year/month/day. The exhibit shows the objects in one partition. What is the MOST likely cause of poor query performance?

A.The files are too small, causing excessive read overhead
B.The files are not compressed
C.The partition columns are not appropriately chosen
D.The data format is CSV instead of Parquet
AnswerA

Many small files cause many S3 GET requests and slow performance.

Why this answer

The exhibit shows tiny files (50 bytes), which cause excessive metadata overhead and read operations in Athena, leading to poor query performance. Option B (compression) is not indicated as the primary issue. Option C (partition columns) is likely appropriate given the partition structure.

Option D (CSV format) is not necessarily the cause; while Parquet may improve performance, the main issue here is the file size, not the format.

Full explanation →
331
MCQeasy

A company uses Amazon RDS for MySQL to store application data. The database contains personally identifiable information (PII). The security team requires that all data be encrypted at rest using AWS KMS. The database is currently unencrypted. The data engineer needs to enable encryption without significant downtime. Which approach should the data engineer take?

A.Use AWS DMS to migrate data to a new encrypted RDS instance continuously.
B.Take a snapshot of the database, copy it with encryption enabled, and restore from the encrypted snapshot.
C.Create a read replica with encryption enabled and promote it to primary.
D.Modify the RDS instance and enable encryption in the configuration.
AnswerB

Standard procedure to enable encryption on existing RDS.

Why this answer

To enable encryption on an existing unencrypted RDS instance, you must take a snapshot of the database, copy it with encryption enabled (using AWS KMS), and restore from the encrypted snapshot. This process involves downtime during the restore but is the only supported method. Option A is incorrect because AWS DMS can migrate data to a new encrypted RDS instance, but that adds complexity and is not the simplest approach.

Option C is incorrect because read replicas cannot be promoted to primary if encryption is enabled on the replica but not on the source; also, the source must be encrypted. Option D is incorrect because you cannot modify an existing RDS instance to enable encryption directly; encryption can only be enabled when creating a new instance from an encrypted snapshot.

Full explanation →
332
MCQeasy

A company runs an Amazon RDS for PostgreSQL database and wants to capture change data (inserts, updates, deletes) to stream into Amazon Kinesis Data Streams for real-time processing. Which AWS service should be used to capture the changes directly from the database?

A.Amazon RDS automated snapshots
B.AWS Glue ETL job scheduled to run every minute
C.Amazon Kinesis Agent
D.AWS Database Migration Service (DMS) with ongoing replication
AnswerD

DMS supports CDC and can stream changes to Kinesis.

Why this answer

AWS DMS with ongoing replication (change data capture) is the correct service because it can continuously capture insert, update, and delete operations from the PostgreSQL transaction logs (WAL) and stream them to a Kinesis Data Streams endpoint. This allows real-time processing without modifying the source database or requiring application-level triggers.

Exam trap

The trap here is that candidates confuse scheduled polling (Glue) or file-based agents (Kinesis Agent) with true CDC, failing to recognize that only DMS ongoing replication can stream row-level changes directly from the database transaction log in real time.

How to eliminate wrong answers

Option A is wrong because Amazon RDS automated snapshots are point-in-time backups of the entire database, not a mechanism to capture individual row-level changes in real time. Option B is wrong because an AWS Glue ETL job scheduled every minute introduces at least 60 seconds of latency and cannot capture every single change as it happens, making it unsuitable for true real-time streaming. Option C is wrong because Amazon Kinesis Agent is designed to stream log files (e.g., from EC2 instances) to Kinesis, not to connect directly to a database and read transactional changes from its WAL.

Full explanation →
333
MCQmedium

A company is running a production Amazon RDS for MySQL Multi-AZ DB instance. The database experiences a sudden spike in read requests, causing performance degradation. The company needs to improve read scalability with minimal application changes. Which solution should the data engineer recommend?

A.Implement DynamoDB Accelerator (DAX) in front of the database.
B.Enable Multi-AZ on the existing DB instance.
C.Increase the DB instance size to a larger instance class.
D.Create an Amazon RDS Read Replica and update the application to use it for read queries.
AnswerD

Read Replicas handle read traffic, offloading the primary instance and improving scalability.

Why this answer

Amazon RDS Read Replicas allow you to offload read traffic from the primary DB instance by creating asynchronous replicas that can serve read queries. This directly addresses the spike in read requests with minimal application changes—only the connection string for read queries needs to be updated. Multi-AZ is for high availability, not read scaling, and increasing instance size is a vertical scaling approach that doesn't leverage the horizontal read scalability of replicas.

Exam trap

The trap here is that candidates often confuse Multi-AZ with read scaling, assuming the standby replica can serve reads, but AWS explicitly disables reads on the Multi-AZ standby to maintain data consistency and failover integrity.

How to eliminate wrong answers

Option A is wrong because DynamoDB Accelerator (DAX) is an in-memory cache for Amazon DynamoDB, not for Amazon RDS for MySQL; it cannot be placed in front of a relational database. Option B is wrong because enabling Multi-AZ on the existing DB instance provides a standby replica for failover only—it does not serve read traffic and thus does not improve read scalability. Option C is wrong because increasing the DB instance size (vertical scaling) can improve performance but does not scale read capacity horizontally and may still be insufficient during extreme spikes, plus it requires downtime or a reboot and does not minimize application changes as effectively as a Read Replica.

Full explanation →
334
Multi-Selecteasy

A company is designing a data lake on Amazon S3. The data includes CSV files, Parquet files, and images. The data engineering team needs to catalog the metadata and enable SQL queries. Which TWO AWS services should be used together?

Select 2 answers
A.Amazon EMR
B.Amazon Redshift Spectrum
C.Amazon QuickSight
D.Amazon Athena
E.AWS Glue
AnswersD, E

Athena can directly query data in S3 using the Glue Data Catalog.

Why this answer

Amazon Athena is correct because it is a serverless interactive query service that can directly query data stored in Amazon S3 using standard SQL, without needing to load or transform data. AWS Glue is correct because it provides a fully managed data catalog (AWS Glue Data Catalog) that stores metadata about the data lake's schema, partitions, and locations, which Athena can use to discover and query the data efficiently.

Exam trap

The trap here is that candidates often confuse Amazon Redshift Spectrum (which requires a Redshift cluster) with Athena (which is serverless), or they think Amazon EMR is needed for SQL queries on S3, not realizing Athena provides a simpler, cluster-free solution.

Full explanation →
335
MCQmedium

A company uses AWS Lake Formation to manage permissions on a data lake stored in S3. A data scientist is unable to query a table in Amazon Athena, receiving an 'Access Denied' error. The data scientist has IAM permissions to call Athena and has been granted SELECT permission on the table in Lake Formation. What is the most likely cause?

A.The data scientist does not have DESCRIBE permission on the table.
B.The data is encrypted with SSE-KMS and the data scientist lacks kms:Decrypt permission.
C.The S3 bucket policy denies access to the data scientist's IAM role.
D.The S3 bucket containing the data is not registered as a Lake Formation location.
AnswerD

Prevents Lake Formation from granting S3 access.

Why this answer

The most likely cause is that the S3 bucket containing the data is not registered as a Lake Formation location. Lake Formation manages permissions for registered S3 locations, but if the bucket is not registered, Lake Formation cannot enforce its permissions, and the data scientist would rely on S3 bucket policies, which may deny access. Option A is incorrect because DESCRIBE permission is not required for querying.

Option B is incorrect because encryption is not mentioned as an issue. Option C is incorrect because bucket policies are not the primary issue if the bucket is registered; the error occurs because the bucket is not registered.

Full explanation →
336
MCQhard

A company uses AWS Glue to transform data stored in Amazon S3. During a run, the job fails with a 'OutOfMemoryError' in the Spark executor. The job processes 2 TB of parquet files using 10 DPUs. The data is evenly distributed across partitions. Which action would MOST likely resolve the issue without impacting the job logic?

A.Enable S3 request rate increase to speed up data reading.
B.Increase the number of DPUs allocated to the Glue job.
C.Repartition the data to a larger number of partitions.
D.Change the input format from Parquet to Snappy-compressed CSV.
AnswerB

More DPUs increase total memory available.

Why this answer

The OutOfMemoryError in the Spark executor indicates that the available memory per executor is insufficient for the data being processed. Increasing the number of DPUs allocated to the Glue job increases the total memory and compute resources available, allowing Spark to handle the 2 TB dataset without changing the job logic.

Exam trap

The trap here is that candidates may confuse memory issues with I/O bottlenecks or data skew, leading them to choose repartitioning or format changes, but the direct fix for insufficient executor memory is to increase DPUs.

How to eliminate wrong answers

Option A is wrong because enabling S3 request rate increase speeds up data reading but does not address the memory exhaustion in the Spark executor; the bottleneck is memory, not I/O throughput. Option C is wrong because repartitioning the data to a larger number of partitions can actually increase memory overhead due to more shuffle operations and task metadata, potentially worsening the OutOfMemoryError. Option D is wrong because changing the input format from Parquet to Snappy-compressed CSV would increase data size (Parquet is columnar and more efficient) and processing complexity, likely increasing memory pressure rather than resolving it.

Full explanation →
337
MCQeasy

A data engineer runs a Spark job on Amazon EMR that reads data from Amazon S3 and writes results back to S3. The job fails with an 'S3AccessDenied' error. The engineer verifies that the IAM role attached to the EMR cluster has s3:GetObject and s3:PutObject permissions on the relevant buckets. What is the MOST likely cause of the error?

A.S3 Transfer Acceleration is not enabled on the bucket.
B.EMRFS consistent view is not configured.
C.The S3 bucket is in a different AWS Region than the EMR cluster.
D.The IAM role does not have s3:ListBucket permission on the bucket.
AnswerD

EMR requires ListBucket permission to access objects in the bucket.

Why this answer

The IAM role attached to the EMR cluster must have the s3:ListBucket permission on the bucket to allow the Spark job to enumerate objects when reading from S3. Without this permission, even with s3:GetObject and s3:PutObject, the job fails with an 'S3AccessDenied' error because the S3 list operation is required for directory listing and file discovery.

Exam trap

The trap here is that candidates often assume GetObject and PutObject are sufficient for S3 read/write operations, overlooking that the ListBucket permission is required for directory listing and file discovery in Spark jobs.

How to eliminate wrong answers

Option A is wrong because S3 Transfer Acceleration is a feature for faster uploads over long distances and is not required for basic read/write operations; its absence does not cause an access denied error. Option B is wrong because EMRFS consistent view is a consistency mechanism for eventually consistent S3 buckets, not a permission or access control feature; its absence would not produce an S3AccessDenied error. Option C is wrong because while cross-region access can cause latency or additional costs, it does not inherently cause an access denied error as long as the IAM role has the correct permissions and the bucket policy allows cross-region access.

Full explanation →
338
MCQmedium

A data engineer needs to ensure that an S3 bucket can only be accessed from a specific VPC. Which policy element should be used?

A.Use the condition key aws:VpcSourceIp in the bucket policy.
B.Use the condition key aws:SourceIp in the bucket policy.
C.Use the condition key aws:SourceVpce in the bucket policy.
D.Use the condition key aws:SourceVpc in the bucket policy.
AnswerD

This restricts access to requests from the specified VPC.

Why this answer

The condition key aws:SourceVpc restricts requests to originate from a specific VPC. Option C (aws:SourceVpce) limits access to a VPC endpoint, not the VPC itself. Option B (aws:SourceIp) restricts by IP address, not VPC.

Option A (aws:VpcSourceIp) is not a valid condition key.

Full explanation →
339
MCQeasy

A data engineer receives an alert that a Kinesis Data Stream has a 'WriteProvisionedThroughputExceeded' error. The stream has 5 shards with 1 MB/s write capacity per shard. The producer application is sending data at 8 MB/s sustained. What should the engineer do to resolve the issue?

A.Reduce the record size to below 1 MB per record.
B.Enable enhanced fan-out on the stream.
C.Increase the number of shards from 5 to 10.
D.Use Kinesis Firehose as an intermediary to buffer data.
AnswerC

More shards increase the total write capacity, matching the 8 MB/s requirement.

Why this answer

The 'WriteProvisionedThroughputExceeded' error indicates that the total write throughput to the Kinesis Data Stream exceeds the provisioned capacity. With 5 shards, each offering 1 MB/s write capacity, the total write capacity is 5 MB/s. The producer is sending 8 MB/s, which is above this limit.

Increasing the number of shards to 10 raises the total write capacity to 10 MB/s, accommodating the sustained 8 MB/s throughput and resolving the throttling.

Exam trap

The trap here is that candidates confuse write-side throttling with read-side limitations, leading them to choose enhanced fan-out (a read-side optimization) instead of scaling shards to increase write capacity.

How to eliminate wrong answers

Option A is wrong because reducing record size below 1 MB does not address the throughput limit; the error is about aggregate write throughput exceeding shard capacity, not individual record size limits. Option B is wrong because enhanced fan-out is a feature for increasing read throughput (up to 2 MB/s per shard per consumer) and does not affect write capacity or resolve write-side throttling. Option D is wrong because Kinesis Firehose is a delivery service that reads from a Kinesis stream; it cannot buffer data before it is written to the stream, so it does not solve the write throughput exceedance at the producer side.

Full explanation →
340
MCQeasy

A data engineer needs to grant an IAM role read-only access to Amazon DynamoDB tables in a specific AWS account. Which IAM policy element should be used to restrict access to only the 'GetItem' and 'Query' actions?

A.Resource
B.Action
C.Effect
D.Condition
AnswerB

Action specifies the API actions like GetItem and Query.

Why this answer

The 'Action' element specifies the allowed API actions. 'Effect' is 'Allow' or 'Deny'. 'Resource' specifies the ARN. 'Condition' adds conditions. So Action is correct.

Full explanation →
341
MCQmedium

An e-commerce company uses Amazon DynamoDB as the primary data store for its product catalog. The table has a simple primary key (ProductID) and handles 10,000 writes per second during peak hours. Recently, the engineering team noticed increased write latency and throttled requests during peak times. The table's provisioned write capacity is set to 12,000 WCU. What is the most likely cause of the throttling?

A.The table has reached the maximum number of partitions
B.DynamoDB Accelerator (DAX) is not configured
C.Write traffic is unevenly distributed across partitions
D.A global secondary index is consuming write capacity
AnswerC

Uneven distribution can cause some partitions to throttle even if total capacity is adequate.

Why this answer

DynamoDB partitions data by the primary key's hash value. If write traffic is unevenly distributed across partitions (e.g., a few ProductIDs receive most writes), those hot partitions can exceed their individual throughput limits (3,000 WCU per partition for provisioned tables), causing throttling even when the table's total provisioned WCU of 12,000 is not fully utilized.

Exam trap

The trap here is that candidates assume throttling only occurs when total provisioned capacity is exceeded, overlooking the per-partition throughput limits that cause throttling on hot partitions even when the table's overall WCU is underutilized.

How to eliminate wrong answers

Option A is wrong because DynamoDB tables do not have a maximum number of partitions; partitions are automatically added or removed based on storage and throughput needs. Option B is wrong because DAX is an in-memory cache for reads, not writes; it does not affect write capacity or throttling. Option D is wrong because while a global secondary index (GSI) does consume write capacity from the table's WCU pool, the question states the table has 12,000 WCU provisioned, and throttling occurs during peak writes of 10,000 writes per second, so the GSI would only contribute to throttling if its own provisioned WCU were insufficient, but the scenario does not indicate that.

Full explanation →
342
MCQmedium

A media company stores video metadata in Amazon RDS for PostgreSQL. The database is 500 GB and experiences high write traffic. The data engineer notices that the transaction log (WAL) is growing rapidly, causing storage issues. The company needs to retain backups for 30 days for compliance. The database is currently using automated backups with a retention period of 7 days. Which solution should the engineer implement to address the WAL growth while meeting compliance requirements?

A.Create manual snapshots daily and delete automated backups.
B.Change the instance type to a larger one with more storage.
C.Increase the backup retention period to 30 days.
D.Configure the database to stream WAL files to Amazon S3.
AnswerA

Correct. By creating manual snapshots daily and reducing or disabling automated backups, the WAL retention is minimized, reducing storage. Manual snapshots provide 30-day retention for compliance.

Why this answer

Creating manual snapshots daily and reducing or eliminating automated backups addresses WAL growth. Automated backups in RDS for PostgreSQL depend on WAL files to enable point-in-time recovery. By disabling automated backups or setting a very short retention period, RDS can purge WAL segments more aggressively, preventing accumulation.

Manual snapshots can be retained for 30 days to meet compliance requirements without relying on WAL. Increasing backup retention (Option C) would worsen WAL storage, while streaming WAL to S3 (Option D) is not natively supported in RDS. Option B only adds storage without addressing the root cause.

Exam trap

The trap is that candidates may think that increasing backup retention to 30 days (Option C) meets compliance and helps WAL cleanup, but in reality, longer retention retains more WAL segments, exacerbating storage issues. The correct approach is to decouple compliance backups (via manual snapshots) from automated backups, which control WAL retention.

How to eliminate wrong answers

Option A is wrong because creating manual snapshots daily and deleting automated backups removes the ability to perform point-in-time recovery (PITR) within the retention window, and manual snapshots do not manage WAL growth—WAL files are still retained for automated backup purposes until they are no longer needed. Option B is wrong because changing the instance type to a larger one with more storage only addresses the symptom (storage filling up) but does not stop the underlying WAL growth; it merely postpones the storage issue and increases cost without solving the root cause. Option D is wrong because streaming WAL files to Amazon S3 is not a native feature of Amazon RDS for PostgreSQL; RDS manages WAL internally and does not expose direct WAL streaming to S3—this option reflects a misunderstanding of RDS architecture.

Full explanation →
343
MCQeasy

A data engineer needs to ingest data from an external partner's FTP server to Amazon S3. The data arrives once daily as a CSV file. Which AWS service should be used for this ingestion?

A.AWS DataSync
B.Amazon Kinesis Data Firehose
C.Amazon AppFlow
D.AWS Transfer Family
AnswerD

AWS Transfer Family provides managed FTP and SFTP support for S3.

Why this answer

AWS Transfer Family provides fully managed support for file transfers over SFTP, FTPS, and FTP protocols, making it the correct choice for ingesting CSV files from an external partner's FTP server. It integrates directly with Amazon S3 as a destination, enabling automated, secure, and scheduled transfers without custom infrastructure.

Exam trap

The trap here is that candidates often confuse AWS DataSync (which is for NFS/SMB, not FTP) with a general-purpose file transfer service, or they incorrectly assume Kinesis Data Firehose can handle batch file ingestion from external sources.

How to eliminate wrong answers

Option A is wrong because AWS DataSync is designed for high-speed, large-scale data transfers between on-premises storage and AWS, but it does not support the FTP protocol; it uses its own agent-based architecture over NFS/SMB. Option B is wrong because Amazon Kinesis Data Firehose is a streaming ingestion service for real-time data (e.g., logs, events) and cannot connect to an FTP server or handle scheduled batch file transfers. Option C is wrong because Amazon AppFlow supports SaaS application integrations (e.g., Salesforce, Slack) and does not support FTP as a source or destination.

Full explanation →
344
MCQmedium

A data engineer is troubleshooting a Kinesis Data Analytics application that processes streaming data. The application is falling behind, and the metric 'MillisBehindLatest' is consistently above 60000. The source Kinesis stream has 10 shards, and the application uses a Flink application with default parallelism. What is the MOST likely cause of the lag?

A.The sink (destination) is throttling writes.
B.The Flink application parallelism is set to 1.
C.The Kinesis stream has too few shards.
D.The retention period of the Kinesis stream is too short.
AnswerB

Default parallelism of 1 causes a single consumer to process all shards.

Why this answer

In Kinesis Data Analytics with Flink, the default parallelism is 1. With 10 shards in the source Kinesis stream, a single parallel task must read from all shards, creating a bottleneck and causing the 'MillisBehindLatest' metric to be consistently high (above 60000). Option A is wrong because while a throttling sink can cause backpressure, the question specifically states the application is falling behind and the metric is high, which is more directly explained by insufficient parallelism.

Option C is wrong because 10 shards is typically sufficient; the issue is how they are consumed. Option D is wrong because the retention period does not affect the lag metric; it only controls how long data is stored.

Full explanation →
345
MCQeasy

A company is using Amazon Kinesis Data Firehose to ingest data into Amazon S3. The data must be transformed from JSON to Parquet format before delivery. Which feature should be enabled on the Firehose delivery stream?

A.Amazon Kinesis Data Analytics
B.Amazon S3 event notifications
C.Format conversion (Parquet/ORC)
D.AWS Lambda transformation
AnswerC

Firehose natively supports converting JSON to Parquet or ORC.

Why this answer

Amazon Kinesis Data Firehose has a built-in format conversion feature that can automatically convert input data from JSON to Parquet or ORC format before delivery to Amazon S3. Option A (Amazon Kinesis Data Analytics) is for real-time stream processing, not format conversion within Firehose. Option B (Amazon S3 event notifications) triggers notifications on S3 events, not data transformation.

Option D (AWS Lambda transformation) allows custom code for data transformation but is not specifically for converting JSON to Parquet; the built-in format conversion is the appropriate feature for this task.

Full explanation →
346
Multi-Selectmedium

A data engineer is configuring a data lake on Amazon S3 that contains sensitive customer information. The company requires that all access to this data be logged and monitored, and that any data shared with external partners must be anonymized before leaving the S3 bucket. Which combination of AWS services should the engineer use to meet these requirements? (Choose THREE.)

Select 3 answers
A.AWS WAF
B.AWS Lake Formation
C.AWS CloudTrail
D.AWS Direct Connect
E.Amazon Macie
AnswersB, C, E

Lake Formation provides fine-grained access control and can be used to enforce anonymization policies.

Why this answer

AWS Lake Formation (B) is correct because it provides fine-grained access control and data anonymization capabilities for data lakes on Amazon S3. It allows you to define column-level and row-level security policies, and can automatically anonymize sensitive data (e.g., via masking or tokenization) before it is shared with external partners, ensuring compliance with data governance requirements.

Exam trap

The trap here is that candidates often confuse AWS WAF (a web-layer security tool) with data-level security, or assume Direct Connect provides logging and monitoring, when in fact neither service addresses S3 data access logging or anonymization.

Full explanation →
347
MCQeasy

A company needs to store streaming data from IoT devices with a retention period of 7 days for real-time analysis. Which AWS service is most suitable?

A.Amazon DynamoDB
B.Amazon Kinesis Data Firehose
C.Amazon Kinesis Data Streams
D.Amazon S3
AnswerC

Kinesis Data Streams supports real-time data ingestion with adjustable retention.

Why this answer

Amazon Kinesis Data Streams is the most suitable service because it is designed for real-time ingestion and processing of streaming data, such as IoT device telemetry, with a default retention period of 24 hours, extendable up to 365 days. The requirement for a 7-day retention period for real-time analysis aligns perfectly with Kinesis Data Streams' ability to retain data for exactly that duration, allowing consumers to process records in near real-time using the Kinesis Client Library (KCL) or AWS Lambda.

Exam trap

The trap here is that candidates often confuse Kinesis Data Firehose with Kinesis Data Streams, assuming Firehose can retain data for a period, but Firehose is a delivery service with no retention—data is immediately delivered to a destination, whereas Data Streams provides a durable buffer with configurable retention for real-time consumption.

How to eliminate wrong answers

Option A is wrong because Amazon DynamoDB is a NoSQL key-value and document database optimized for low-latency reads and writes, not for streaming data ingestion or temporary buffering with a retention period; it stores data indefinitely unless TTL is configured, and lacks native streaming ingestion capabilities. Option B is wrong because Amazon Kinesis Data Firehose is designed for loading streaming data into destinations like S3, Redshift, or Elasticsearch, but it does not support custom retention periods or real-time processing by multiple consumers—data is delivered immediately and not retained for 7 days. Option D is wrong because Amazon S3 is an object storage service with eventual consistency and no built-in streaming ingestion or real-time processing; it is a destination for stored data, not a buffer for real-time analysis with a 7-day retention window.

Full explanation →
348
Multi-Selectmedium

A data engineer needs to design a data ingestion pipeline that captures streaming data from mobile app events into Amazon S3 for analytics. The pipeline must support real-time processing of events and allow for schema evolution over time. Which AWS services should the engineer use? (Choose THREE.)

Select 3 answers
A.Amazon Kinesis Data Analytics
B.Amazon Kinesis Data Firehose
C.AWS Glue ETL jobs
D.Amazon Kinesis Data Streams
E.AWS AppFlow
AnswersA, B, D

Enables real-time processing and schema evolution.

Why this answer

Amazon Kinesis Data Analytics is correct because it enables real-time processing of streaming data using SQL or Apache Flink, allowing the engineer to analyze mobile app events as they arrive. This supports the requirement for real-time processing before the data is stored in Amazon S3 for analytics.

Exam trap

The trap here is that candidates often confuse AWS Glue ETL jobs as a streaming solution, but Glue is fundamentally batch-oriented and cannot meet real-time processing requirements, while AppFlow is mistakenly chosen for its integration capabilities despite lacking streaming ingestion support.

Full explanation →
349
MCQhard

A company uses Amazon Kinesis Data Analytics for Apache Flink to process streaming data. The application reads from a Kinesis data stream and writes results to an S3 bucket. The application is consistently running out of memory and failing. The operator has already increased the Parallelism and TaskManager memory. What is the next BEST step to troubleshoot?

A.Change the processing mode from exactly-once to at-least-once
B.Reduce the number of shards in the source stream
C.Enable Apache Flink metrics in Amazon CloudWatch to monitor heap and checkpoint details
D.Increase the buffer timeout for the S3 sink
AnswerC

Detailed metrics help identify root cause of OOM.

Why this answer

Enabling Apache Flink metrics in Amazon CloudWatch provides visibility into heap usage, checkpoint sizes, and backpressure, which can help diagnose the root cause of memory failures. After increasing parallelism and TaskManager memory without success, the next best step is to monitor these metrics to identify the specific bottleneck. Option A changes processing semantics from exactly-once to at-least-once, which can reduce overhead but does not help diagnose the memory issue and may alter data delivery guarantees.

Option B reduces the number of shards in the source stream, which decreases throughput and might not address the underlying memory consumption. Option D increases the buffer timeout for the S3 sink, which could accumulate more data in memory before writing, potentially worsening the memory problem.

Full explanation →
350
MCQhard

A financial services company has an Amazon DynamoDB table named 'Transactions' with provisioned read capacity of 10,000 RCU and write capacity of 5,000 WCU. The table stores transaction records for the past 90 days. The application performs point reads by transaction ID (partition key) and range queries by customer ID and timestamp (GSI). Recently, the company started a new marketing campaign, causing a sudden spike in write traffic. The write capacity is now at 4,500 WCU, and the application is experiencing occasional throttling on writes. The data engineer needs to ensure that writes are not throttled during future campaigns, while keeping costs low. The table currently has auto scaling enabled with a maximum capacity of 10,000 WCU. Which solution should the engineer implement?

A.Switch the table to DynamoDB on-demand capacity mode.
B.Use DynamoDB Accelerator (DAX) to cache write requests.
C.Implement an Amazon SQS queue to buffer write requests and process them in batches.
D.Increase the maximum write capacity in the auto scaling configuration to 20,000 WCU.
AnswerA

DynamoDB on-demand capacity mode automatically scales to accommodate traffic spikes, eliminating throttling without manual intervention and without fixed capacity limits, making it cost-effective for unpredictable traffic.

Why this answer

DynamoDB on-demand capacity mode automatically scales to accommodate traffic spikes, eliminating throttling without manual intervention and without fixed capacity limits, making it cost-effective for unpredictable traffic. Option B is wrong because DAX is a read cache and does not handle write throttling. Option C is wrong because using SQS adds latency and complexity; not ideal for real-time writes.

Option D is wrong because increasing the maximum write capacity still has a limit and may not react quickly enough to sudden spikes, and may increase costs.

Full explanation →
351
MCQmedium

A data engineer is responsible for a data warehouse on Amazon Redshift that stores 5 TB of data. The engineer needs to load 50 GB of new data daily from Amazon S3 into Redshift. The current load process uses the COPY command and takes 2 hours, which is within the maintenance window. However, the engineer wants to optimize the load time and reduce the impact on concurrent queries. The engineer notices that the tables are not distributed evenly across the slices. The cluster has 4 nodes of dc2.large. Which approach will best improve load performance?

A.Increase the cluster size to 8 nodes.
B.Change the distribution style of the tables to EVEN.
C.Use GZIP compression on the S3 files.
D.Add sort keys to the tables based on the load timestamp.
AnswerB

EVEN distribution ensures each slice gets an equal amount of data, improving parallelism.

Why this answer

The COPY command distributes data across slices based on the table's distribution style. With dc2.large nodes, each node has 2 slices, so a 4-node cluster has 8 slices. If tables are not distributed evenly, some slices handle more data, causing bottlenecks.

Changing the distribution style to EVEN forces rows to be spread uniformly across all slices, maximizing parallelism during the COPY load and reducing load time.

Exam trap

The trap here is that candidates often assume adding more nodes (scaling out) always improves load performance, but the real bottleneck is slice-level data skew, which EVEN distribution directly fixes without additional cost.

How to eliminate wrong answers

Option A is wrong because increasing the cluster size to 8 nodes adds cost and complexity without addressing the root cause of uneven data distribution; the load time improvement would be marginal if slices are still unbalanced. Option C is wrong because using GZIP compression on S3 files reduces storage and transfer time, but the COPY command already decompresses data automatically; the bottleneck here is slice imbalance, not I/O or network bandwidth. Option D is wrong because adding sort keys based on load timestamp improves query performance for range-restricted scans, but does not affect how the COPY command distributes data across slices during the load process.

Full explanation →
352
Multi-Selecthard

A company is using Amazon Kinesis Data Analytics for Apache Flink to process real-time clickstream data. The application reads from a Kinesis stream and writes aggregated results to an Amazon S3 bucket. The company notices that the application is falling behind and the checkpoint duration is increasing. Which THREE actions should the data engineer take to improve performance? (Choose THREE.)

Select 3 answers
A.Decrease the number of shards in the source Kinesis stream.
B.Use multiple S3 prefixes in the output path to avoid throttling.
C.Increase the heap memory of the Flink application.
D.Increase the checkpoint interval to reduce checkpoint overhead.
E.Increase the parallelism of the Flink application.
AnswersB, D, E

Multiple prefixes increase S3 write performance.

Why this answer

Options B, D, and E are correct. Using multiple S3 prefixes in the output path (B) reduces the risk of S3 write throttling by distributing writes across multiple partition keys. Increasing the checkpoint interval (D) reduces the frequency of checkpointing, thus decreasing the overhead and allowing the application to process more data between checkpoints.

Increasing parallelism (E) allows the Flink application to process more data in parallel, improving throughput. Decreasing the number of shards (A) would reduce the incoming data rate and potentially worsen the lag. Increasing heap memory (C) might help with memory pressure but does not directly address checkpoint duration or processing lag; the primary issues are related to parallelism and checkpoint overhead.

Full explanation →
353
MCQhard

A data team uses AWS Glue ETL jobs to process data from an S3 bucket (s3://data-lake-raw) and write results to another S3 bucket (s3://data-lake-processed). Both buckets are encrypted with SSE-KMS using the same KMS key (alias 'data-key'). The Glue job runs in the same account. The team recently enabled S3 Server Access Logging for the raw bucket, sending logs to a separate logging account. After enabling logging, the Glue job starts failing with 'AccessDenied' when reading from the raw bucket. The Glue job's IAM role has s3:GetObject permission on the raw bucket. Which additional permission is most likely missing?

A.s3:GetBucketLocation on the raw bucket.
B.kms:Decrypt on the KMS key (alias 'data-key').
C.s3:PutObject on the processed bucket.
D.kms:GenerateDataKey on the KMS key.
AnswerB

The Glue job needs permission to decrypt the objects using the KMS key.

Why this answer

When S3 Server Access Logging is enabled for a bucket encrypted with SSE-KMS, the S3 service must write log objects to the target bucket. If the target bucket is in a different account, the S3 service needs permission to use the KMS key. However, the failure is on the Glue job reading from the raw bucket, not writing logs.

The issue could be that the raw bucket's S3 access log delivery writes to a target bucket that uses a different KMS key, but that would affect logging, not Glue reads. Re-reading: The Glue job reading the raw bucket fails after enabling logging. It's likely that the raw bucket policy was modified to allow log delivery, inadvertently restricting other access.

Actually, the most likely cause is that the S3 bucket policy now includes a condition that denies access unless a specific header is present, or the KMS key policy was changed. Given the options, the correct answer is that the KMS key policy for the data-key now denies the Glue role because the S3 service principal was added for cross-account logging. But the Glue role needs kms:Decrypt permission.

The scenario says the same key is used for both buckets. The correct answer is B: The KMS key policy does not allow the Glue role to decrypt because the S3 log delivery service is using the key and the key policy may have a condition. Actually, the most direct answer: The Glue role is missing kms:Decrypt permission on the KMS key.

But the team might have added a statement to allow S3 logging that inadvertently denies the Glue role. However, the simplest answer is that the Glue role lacks kms:Decrypt. But the question says 'Which additional permission is most likely missing?' The options are specific permissions.

I'll go with the need for kms:Decrypt on the KMS key.

Full explanation →
354
MCQhard

A company uses Amazon Redshift for its data warehouse. The data engineer notices that queries are slow on a large table that is frequently filtered on a column 'transaction_date'. Which optimization technique best improves query performance?

A.Apply compression encoding to 'transaction_date'.
B.Set the sort key to 'transaction_date'.
C.Set the distribution key to 'transaction_date'.
D.Run VACUUM on the table.
AnswerB

Sort keys enable zone maps to skip irrelevant blocks.

Why this answer

Setting the sort key to 'transaction_date' organizes the table data physically by that column, which allows Redshift to use zone maps to skip blocks that don't match query filters. This dramatically reduces the amount of data scanned for range-restricted queries on 'transaction_date', improving query performance.

Exam trap

The trap here is that candidates confuse distribution keys (which optimize joins) with sort keys (which optimize filtering and range scans), leading them to pick distribution key as the answer for a single-table filter performance issue.

How to eliminate wrong answers

Option A is wrong because compression encoding reduces storage size and I/O but does not directly optimize query filtering on a column; it can even slow down scans if the column is frequently used in predicates. Option C is wrong because setting the distribution key to 'transaction_date' distributes rows across nodes based on that column, which can help with joins but does not improve the efficiency of range-restricted scans on a single table. Option D is wrong because VACUUM reclaims space and re-sorts data but does not improve query performance unless the table is already sorted on a key; without a sort key on 'transaction_date', VACUUM has no effect on filter performance.

Full explanation →
355
MCQmedium

A data engineering team is ingesting streaming data from IoT devices into Amazon Kinesis Data Streams. The data is then consumed by an AWS Lambda function that transforms each record and writes it to Amazon S3. Recently, the Lambda function started failing with 'ProvisionedThroughputExceededException' errors when writing to S3. The team has already increased the Lambda function's memory and timeout. Which action should the team take to resolve the issue?

A.Use S3 Batch Operations to write data in batches.
B.Increase the number of shards in the Kinesis data stream.
C.Enable S3 Transfer Acceleration on the destination bucket.
D.Implement retries with exponential backoff in the Lambda function for S3 put operations.
AnswerD

This handles transient S3 throttling by retrying with backoff.

Why this answer

The 'ProvisionedThroughputExceededException' error indicates that the Lambda function is being throttled by S3 due to exceeding the bucket's request rate limits. Implementing retries with exponential backoff in the Lambda function for S3 put operations is the correct solution because it allows the function to gracefully handle transient throttling errors by waiting progressively longer between retries, which aligns with AWS's guidance for managing S3 request rate limits.

Exam trap

The trap here is that candidates confuse the source of the error (Kinesis vs. S3) and incorrectly assume that increasing Kinesis shards will fix the S3 throttling, or they mistake S3 Transfer Acceleration for a solution to rate limits when it only improves network latency.

How to eliminate wrong answers

Option A is wrong because S3 Batch Operations is designed for bulk processing of existing objects in S3, not for handling real-time streaming writes from Lambda, and it does not address the immediate throttling issue during individual put operations. Option B is wrong because increasing the number of shards in the Kinesis data stream would increase the parallelism of data ingestion into Lambda, but the error occurs when writing to S3, not when reading from Kinesis, so it would not resolve the S3 throttling. Option C is wrong because S3 Transfer Acceleration optimizes network transfer speed by using AWS edge locations, but it does not affect S3's internal request rate limits or throttle errors, which are based on bucket-level throughput capacity.

Full explanation →
356
MCQhard

A company is using Amazon RDS for SQL Server with Multi-AZ. The database has a 500 GB data file and 100 GB log file. The application experiences high latency during peak hours. Monitoring shows high WriteIOPS on the primary. Which change will reduce latency without losing the ability to failover?

A.Reduce the log file size by changing recovery model
B.Increase the provisioned IOPS on the RDS instance
C.Create a Read Replica in a different Availability Zone
D.Switch to Multi-AZ with two readable standbys
AnswerB

Higher IOPS reduces write latency.

Why this answer

The high WriteIOPS on the primary indicates that the storage layer is saturated, causing latency. Increasing provisioned IOPS on the RDS instance directly addresses the bottleneck by providing more I/O capacity, and since Multi-AZ is already enabled, the standby remains synchronized and failover capability is preserved.

Exam trap

The trap here is that candidates often confuse read replicas or Multi-AZ standby features with write performance improvements, but neither reduces write latency on the primary; only increasing storage performance (IOPS) or scaling the instance class addresses write-heavy I/O bottlenecks.

How to eliminate wrong answers

Option A is wrong because reducing the log file size by changing the recovery model (e.g., to Simple) would break point-in-time recovery and does not address the root cause of high WriteIOPS; it may even increase I/O due to more frequent log truncation. Option C is wrong because a Read Replica in a different Availability Zone does not reduce write latency on the primary; it only offloads read traffic, and the application's high latency is due to writes, not reads. Option D is wrong because switching to Multi-AZ with two readable standbys (a feature not available for SQL Server on RDS) would not reduce write latency; the standby replicas are for read scaling and failover, but the primary still handles all writes and the same I/O bottleneck persists.

Full explanation →
357
MCQmedium

A company stores log files in Amazon S3. They want to automatically move logs older than 90 days to S3 Glacier Deep Archive to reduce costs. Which S3 feature should be used?

A.S3 Intelligent-Tiering
B.S3 Lifecycle configuration
C.S3 Replication
D.S3 Object Lock
AnswerB

Lifecycle policies can move objects to Glacier Deep Archive after 90 days.

Why this answer

S3 Lifecycle configuration allows you to define rules that automatically transition objects to colder storage classes, such as S3 Glacier Deep Archive, based on age. By setting a rule to move objects older than 90 days to S3 Glacier Deep Archive, you reduce storage costs without manual intervention. This is the correct feature for automating tier-based data lifecycle management.

Exam trap

The trap here is that candidates may confuse S3 Intelligent-Tiering with lifecycle policies, but Intelligent-Tiering does not support age-based transitions to Glacier Deep Archive and is designed for unpredictable access patterns, not fixed retention schedules.

How to eliminate wrong answers

Option A is wrong because S3 Intelligent-Tiering automatically moves data between access tiers based on changing access patterns, not on a fixed age-based schedule, and it does not support direct transition to S3 Glacier Deep Archive. Option C is wrong because S3 Replication is used to copy objects across buckets or regions for redundancy or compliance, not to transition objects to colder storage classes. Option D is wrong because S3 Object Lock is designed to prevent object deletion or overwrites for a specified retention period, not to manage storage tier transitions.

Full explanation →
358
Multi-Selecteasy

A data engineer is designing a serverless data ingestion pipeline that uses Amazon Kinesis Data Firehose to deliver data to Amazon S3. The data must be transformed using AWS Lambda before being written to S3. Which two steps are required to enable this transformation? (Select TWO.)

Select 2 answers
A.Set up an S3 event notification to trigger the Lambda function on object creation.
B.Configure a Lambda function as a data transformation source in the Firehose delivery stream.
C.Ensure the Lambda function returns the transformed data in the format required by Firehose.
D.Subscribe the Lambda function to the CloudWatch Logs log group for the Firehose stream.
E.Have the Lambda function write the transformed data directly to the S3 bucket.
AnswersB, C

This enables Firehose to invoke Lambda for transformation.

Why this answer

Amazon Kinesis Data Firehose can be configured to invoke a Lambda function as a data transformation source. This allows Firehose to pass incoming records to the Lambda function, which processes and returns the transformed records before they are delivered to the S3 destination. Option C is correct because the Lambda function must return data in the specific format that Firehose expects, including a record ID, result status, and base64-encoded data, otherwise the transformation will fail.

Exam trap

The trap here is that candidates often confuse post-delivery transformations (using S3 event notifications) with in-stream transformations (using Firehose's built-in Lambda integration), leading them to select Option A instead of the correct Firehose-specific configuration.

Full explanation →
359
Multi-Selectmedium

A data engineer is designing a data lake on Amazon S3. The data lake must support both batch and streaming ingestion. Which TWO AWS services can ingest data directly into S3? (Choose TWO.)

Select 2 answers
A.Amazon RDS
B.AWS Glue
C.Amazon EMR
D.Amazon DynamoDB
E.Amazon Kinesis Data Firehose
AnswersB, E

AWS Glue can ingest batch data and write to S3.

Why this answer

AWS Glue is correct because it can ingest data directly into S3 via AWS Glue crawlers and ETL jobs, which read from various sources and write the processed data to S3. Amazon Kinesis Data Firehose is correct because it is a fully managed service that can capture, transform, and load streaming data directly into S3 without requiring custom code.

Exam trap

The trap here is that candidates often confuse services that can process data from S3 (like EMR) with services that can directly ingest data into S3, or they mistakenly think RDS or DynamoDB can natively write to S3 without additional services.

Full explanation →
360
MCQhard

A data engineer runs the command shown in the exhibit to check the bucket policy. A user from another AWS account is trying to download an object using HTTP (not HTTPS). What will happen?

A.The download will succeed because the principal is not specified
B.The download will fail with an access denied error
C.The download will succeed if the object is encrypted at rest
D.The download will succeed because the policy only denies write operations
AnswerB

The policy denies access when using HTTP.

Why this answer

The bucket policy denies all actions when aws:SecureTransport is false (i.e., HTTP). Therefore, HTTP requests are denied. Option A is wrong because the policy denies HTTP requests.

Option C is wrong because the policy does not require encryption at rest. Option D is wrong because the policy explicitly denies HTTP.

Full explanation →
361
MCQhard

A company uses Amazon DynamoDB with on-demand capacity. They notice higher than expected costs due to a sudden spike in read traffic from a reporting job. The reporting job scans the entire table daily. What is the most cost-effective way to reduce costs while maintaining the same reporting output?

A.Enable DynamoDB Accelerator (DAX) for caching.
B.Use a Global Secondary Index (GSI) with a sort key that matches the reporting query pattern.
C.Set a TTL attribute to automatically expire old data.
D.Reduce the read capacity units (RCU) in the table.
AnswerB

A GSI allows efficient querying instead of scanning, reducing read costs.

Why this answer

Using a Global Secondary Index (GSI) with a sort key tailored to the reporting query pattern allows the reporting job to query only the relevant items instead of scanning the entire table. This reduces the read capacity units consumed per operation, directly lowering costs under on-demand capacity, which charges per RCU consumed. The reporting output remains identical because the GSI returns the same data filtered by the query pattern.

Exam trap

The trap here is that candidates may confuse DAX as a general cost-saver for all read patterns, but DAX only helps with repeated, cached reads, not with unique full-table scans that read different data each time.

How to eliminate wrong answers

Option A is wrong because DynamoDB Accelerator (DAX) is an in-memory cache that reduces read latency and cost for repeated reads, but the reporting job scans the entire table daily, meaning each scan reads unique data that is not cached from previous runs, so DAX would not reduce costs. Option C is wrong because setting a TTL attribute automatically expires old data after a specified time, which reduces storage costs but does not affect the read cost of the daily scan; the reporting job still scans all remaining items. Option D is wrong because the table uses on-demand capacity, which does not have provisioned read capacity units (RCU) to reduce; on-demand capacity automatically scales and charges per RCU consumed, so reducing RCU is not applicable.

Full explanation →
362
MCQeasy

A data engineer notices that an Amazon RDS for PostgreSQL instance's CPU utilization is consistently above 90% during business hours. The database is used for reporting queries. Which action should be taken FIRST to improve performance?

A.Enable Multi-AZ deployment for automatic failover.
B.Enable Performance Insights and review slow queries.
C.Create a read replica to offload reporting queries.
D.Increase the instance size to a larger instance class.
AnswerB

Identifying and optimizing slow queries reduces CPU usage.

Why this answer

The first step in diagnosing high CPU utilization on an RDS for PostgreSQL instance used for reporting queries is to identify the root cause. Enabling Performance Insights provides a detailed view of database load, wait events, and SQL query performance, allowing the data engineer to pinpoint slow or inefficient queries that are consuming CPU resources. Without this diagnostic data, any other action would be premature and could lead to unnecessary cost or complexity.

Exam trap

The trap here is that candidates often jump to scaling solutions (like increasing instance size or adding a read replica) without first diagnosing the root cause, but AWS emphasizes observability and optimization before capacity changes.

How to eliminate wrong answers

Option A is wrong because enabling Multi-AZ deployment improves availability and failover, not performance; it does not reduce CPU utilization or address query performance issues. Option C is wrong because creating a read replica offloads read traffic but does not fix the underlying inefficient queries that are causing high CPU on the source instance; the replica would also suffer from the same workload if queries are poorly optimized. Option D is wrong because increasing the instance size may temporarily mask the problem by providing more CPU capacity, but it does not resolve the root cause of inefficient queries and incurs higher costs without guaranteeing sustained performance improvement.

Full explanation →
363
MCQmedium

A data pipeline using AWS Glue ETL jobs is failing intermittently with the error 'Rate exceeded' when writing to an Amazon Redshift cluster. Which action is MOST effective to resolve this issue?

A.Increase the timeout of the Glue ETL job to allow more time for retries.
B.Disable workload management (WLM) concurrency scaling in Redshift.
C.Enable auto-tuning on the Redshift cluster and use concurrency scaling.
D.Change the output file format from Parquet to CSV to reduce write size.
AnswerC

Auto-tuning with concurrency scaling dynamically adds capacity to handle increased write requests.

Why this answer

Enabling auto-tuning on the Redshift cluster and using concurrency scaling dynamically adds cluster capacity to absorb spikes in write requests, directly addressing the 'Rate exceeded' error. This error typically occurs when the Glue ETL job's write throughput exceeds the cluster's current capacity, and concurrency scaling provides additional query queues to handle the load without manual intervention.

Exam trap

The trap here is that candidates often confuse 'Rate exceeded' with a timeout issue and choose to increase the job timeout (Option A), failing to recognize that the error is a capacity constraint on the Redshift side, not a duration issue.

How to eliminate wrong answers

Option A is wrong because increasing the Glue ETL job timeout only allows more time for retries but does not resolve the underlying rate limit; the job will still fail if the Redshift cluster cannot accept writes at the required rate. Option B is wrong because disabling WLM concurrency scaling would reduce the cluster's ability to handle concurrent write operations, making the rate limit issue worse. Option D is wrong because changing the output file format from Parquet to CSV does not reduce the write size significantly (Parquet is already compressed) and does not address the rate limit; the error is about throughput capacity, not file size.

Full explanation →
364
MCQmedium

Refer to the exhibit. A data engineer applied this bucket policy to an S3 bucket. What is the effect of this policy?

A.Allows only HTTPS requests to get objects
B.Blocks HTTP requests to get objects
C.Allows only HTTP requests to get objects
D.Blocks all access to the bucket
AnswerB

The Deny effect with condition aws:SecureTransport false blocks HTTP requests.

Why this answer

The bucket policy denies the s3:GetObject action when the request is made over HTTP (i.e., when aws:SecureTransport equals false). This effectively blocks HTTP requests to get objects, while allowing HTTPS requests. Therefore, Option B is correct.

Option A is incorrect because the policy blocks HTTP, not allows it. Option C is incorrect because the policy blocks HTTP, not allows it. Option D is incorrect because the policy only blocks insecure transport, not all access.

Full explanation →
365
MCQeasy

A company wants to grant read-only access to an S3 bucket for a data analyst. The analyst should be able to list objects and read object content. Which IAM policy effect and action combination is correct?

A.Effect: Allow, Actions: s3:GetObject, s3:DeleteObject
B.Effect: Allow, Actions: s3:ListAllMyBuckets, s3:GetObject
C.Effect: Allow, Actions: s3:PutObject, s3:GetObject
D.Effect: Allow, Actions: s3:ListBucket, s3:GetObject
AnswerD

Provides read-only access to list and read objects.

Why this answer

S3:ListBucket allows listing objects in the bucket, and s3:GetObject allows reading object content. This combination provides read-only access. Option A is incorrect because s3:DeleteObject grants delete permissions.

Option B is incorrect because s3:ListAllMyBuckets lists all buckets, not bucket contents. Option C is incorrect because s3:PutObject grants write access.

Full explanation →
366
MCQeasy

A data engineer needs to store semi-structured JSON data that is accessed infrequently but requires immediate retrieval when needed. The data must be durable and cost-effective. Which Amazon S3 storage class should be used?

A.S3 Standard-IA
B.S3 Glacier
C.S3 Standard
D.S3 One Zone-IA
AnswerA

Standard-IA is for infrequent access with immediate retrieval.

Why this answer

S3 Standard-IA is the correct choice because it offers the same durability and low-latency retrieval as S3 Standard but at a lower storage cost, making it ideal for infrequently accessed data that still needs immediate retrieval when requested. The scenario specifies 'infrequently accessed' and 'immediate retrieval,' which aligns with Standard-IA's design for data accessed less than once a month but with millisecond first-byte latency.

Exam trap

The trap here is that candidates often confuse 'infrequently accessed' with 'archival' and choose S3 Glacier, overlooking the 'immediate retrieval' requirement that rules out Glacier's multi-minute or multi-hour retrieval times.

How to eliminate wrong answers

Option B (S3 Glacier) is wrong because it is designed for archival data with retrieval times ranging from minutes to hours, not immediate retrieval. Option C (S3 Standard) is wrong because it is optimized for frequently accessed data and would be less cost-effective for infrequently accessed data, incurring higher storage costs without benefit. Option D (S3 One Zone-IA) is wrong because it stores data in a single Availability Zone, which does not meet the durability requirement of the scenario (data must be durable, implying multi-AZ resilience).

Full explanation →
367
MCQeasy

A company is using AWS Lake Formation to manage permissions on a data lake. They want to grant a data scientist the ability to query tables in the 'analytics' database using Amazon Athena, but prevent them from accessing the underlying S3 data directly. What is the best way to achieve this?

A.Grant the data scientist an IAM policy with s3:GetObject on the S3 bucket.
B.Grant SELECT permission on the 'analytics' database tables in Lake Formation.
C.Create an IAM policy that allows Athena queries only.
D.Add the data scientist to a Lake Formation data lake location with read access.
AnswerB

Lake Formation fine-grained permissions allow querying via Athena without direct S3 access.

Why this answer

Lake Formation grants SELECT permission on named database tables, which allows querying via Athena without granting direct S3 access. Option A is incorrect because granting s3:GetObject on the entire bucket would allow the data scientist to bypass Lake Formation and access the data directly. Option C is incorrect because a policy that allows Athena queries only does not grant the necessary permissions to access the database tables.

Option D is incorrect because adding the user to a data lake location with read access is too broad and would also grant direct S3 access, which does not meet the requirement of preventing direct S3 access.

Full explanation →
368
MCQhard

A company uses a DynamoDB table with on-demand capacity for a gaming application. During a new game launch, the table experienced throttling errors. The engineer checks CloudWatch metrics and sees that the 'ConsumedWriteCapacityUnits' exceeded the 'ProvisionedWriteCapacityUnits' (on-demand uses the table's previous peak). The application is writing at 50,000 WCU but the table's peak was 30,000 WCU. What should the engineer do to resolve throttling?

A.Add a DynamoDB Accelerator (DAX) cluster in front of the table.
B.Increase the number of partitions by splitting the partition key.
C.Contact AWS Support to pre-warm the table for higher throughput.
D.Switch the table to provisioned capacity and set WCU to 50,000.
AnswerC

Pre-warming increases the table's initial throughput limit to handle spikes.

Why this answer

DynamoDB on-demand capacity automatically scales based on traffic but has a maximum throughput limit determined by the table's previous peak usage. When a new peak exceeds this limit, throttling occurs until the table adapts. Contacting AWS Support to pre-warm the table raises the initial throughput limit, allowing higher bursts immediately.

Option B is incorrect because increasing partition count does not directly increase the overall throughput limit; it affects distribution of throughput. Option A is incorrect because DAX is a caching layer that improves read performance, not write throughput. Option D is incorrect because switching to provisioned capacity would require setting WCU to 50,000, but this changes the billing model and may still require a limit increase; pre-warming is the direct solution for on-demand throttling.

Full explanation →
369
Multi-Selectmedium

A company uses Amazon RDS for MySQL with Multi-AZ deployment. The primary instance fails, and automatic failover occurs. After failover, the data engineer notices that the new primary instance has a different DNS endpoint. Which TWO statements are true about this scenario? (Choose TWO.)

Select 2 answers
A.The standby instance is created in the same Availability Zone as the failed primary.
B.A manual DNS update is required to connect to the new primary.
C.The DNS CNAME record is updated to point to the new primary.
D.The endpoint changes to the standby instance's endpoint.
E.The applications can continue using the same database endpoint.
AnswersC, E

RDS updates the CNAME automatically.

Why this answer

When Amazon RDS performs automatic failover in a Multi-AZ deployment, it updates the DNS CNAME record for the primary DB instance to point to the new primary (formerly the standby). This ensures that applications using the original endpoint are transparently redirected to the new primary without manual intervention.

Exam trap

The trap here is that candidates may think the endpoint changes to the standby's endpoint (Option D) or that a manual DNS update is needed (Option B), when in fact the original endpoint remains the same and RDS handles the DNS update automatically via CNAME.

Full explanation →
370
MCQhard

Refer to the exhibit. An IAM policy is attached to an IAM role used by an application. The application needs to decrypt objects in an S3 bucket using a customer managed KMS key. What is the effect of this policy?

A.The application cannot perform any KMS operations.
B.The application can decrypt objects from any service.
C.The application can decrypt objects only when accessing them through S3.
D.The application can encrypt but not decrypt objects.
AnswerC

The Deny with condition allows decrypt only via S3 service.

Why this answer

The IAM policy grants the `kms:Decrypt` permission with a `kms:ViaService` condition key set to `s3.amazonaws.com`. This condition restricts the decryption operation to only when the request is made through the S3 service. Therefore, the application can decrypt objects only when accessing them through S3, not via direct KMS API calls or other services.

Exam trap

AWS often tests the `kms:ViaService` condition key to trap candidates who assume that granting `kms:Decrypt` alone allows decryption from any source, ignoring the service-specific restriction.

How to eliminate wrong answers

Option A is wrong because the policy explicitly allows `kms:Decrypt` under the condition, so the application can perform KMS decryption operations when invoked via S3. Option B is wrong because the `kms:ViaService` condition restricts decryption to S3 only, preventing decryption from any other service or direct KMS API calls. Option D is wrong because the policy grants `kms:Decrypt` permission, not `kms:Encrypt`, so the application can decrypt but not encrypt objects.

Full explanation →
371
MCQeasy

A data engineer is using AWS Glue to run an ETL job that reads data from Amazon DynamoDB and writes to Amazon Redshift. The job fails with a 'ThroughputExceededException' error. What is the most likely cause?

A.The Glue job has a timeout setting that is too low
B.The Redshift cluster's concurrency scaling is insufficient
C.The DynamoDB table's read capacity is insufficient for the Glue job's read rate
D.The S3 bucket where Glue writes temporary data does not have proper permissions
AnswerC

Glue reads from DynamoDB and may exceed provisioned read capacity, causing throttling.

Why this answer

The 'ThroughputExceededException' error occurs when AWS Glue reads from DynamoDB at a rate that exceeds the table's provisioned read capacity, causing DynamoDB to throttle requests. Option A is incorrect because a timeout setting would result in a different error (e.g., 'Job run timeout'). Option B is incorrect because Redshift concurrency scaling affects query performance, not DynamoDB read throttling.

Option D is incorrect because S3 permissions issues would cause 'AccessDenied' errors, not throughput exceedance.

Full explanation →
372
MCQhard

A data pipeline uses AWS Glue ETL to process data from an S3 bucket and write results to a Redshift cluster. The job fails with a 'DiskFull' error on the Glue worker nodes. What is the best way to resolve this issue?

A.Increase the number of Glue DPUs or use G.1X worker type.
B.Decrease the number of partitions in the output.
C.Use a different file format like Parquet to reduce storage.
D.Increase the job timeout setting.
AnswerA

More DPUs or larger workers provide additional disk and memory.

Why this answer

The 'DiskFull' error on Glue worker nodes indicates that the local storage allocated per worker is insufficient for the data being processed. Increasing the number of DPUs or switching to a G.1X worker type (which provides more disk space per worker) directly addresses this by either distributing the workload across more workers or upgrading to a worker type with higher storage capacity.

Exam trap

The trap here is that candidates often confuse storage on the worker nodes with storage in the output target, leading them to choose file format optimization (Option C) instead of addressing the worker-level resource constraint.

How to eliminate wrong answers

Option B is wrong because decreasing the number of output partitions reduces parallelism and can actually increase the data volume per worker, worsening the disk space issue. Option C is wrong because using Parquet reduces storage in the output target (e.g., S3 or Redshift), not on the Glue worker nodes' local ephemeral storage where the 'DiskFull' error occurs. Option D is wrong because increasing the job timeout only extends the maximum execution duration; it does not affect the disk space available on worker nodes.

Full explanation →
373
MCQhard

A data engineer is troubleshooting a Kinesis Data Firehose delivery stream that is experiencing high error rates when writing to an S3 bucket. The error logs indicate 'AccessDenied' errors. The S3 bucket policy allows access from the Firehose service, but the errors persist. What is the most likely cause?

A.The S3 bucket has a lifecycle policy that is deleting objects too quickly
B.The IAM role assumed by Firehose does not have the s3:PutObject permission
C.The S3 bucket has default encryption enabled
D.The S3 bucket uses an AWS KMS key for encryption and Firehose does not have kms:Decrypt permission
AnswerB

Firehose requires the IAM role to have S3 write permissions.

Why this answer

The most likely cause is that the IAM role assumed by Kinesis Data Firehose lacks the `s3:PutObject` permission. Even if the S3 bucket policy allows access from the Firehose service, the IAM role must explicitly grant the necessary S3 write permissions for Firehose to deliver data. Without this permission, Firehose receives 'AccessDenied' errors when attempting to write objects to the bucket.

Exam trap

The trap here is that candidates assume a bucket policy allowing Firehose access is sufficient, but the IAM role assumed by Firehose must also explicitly grant the write permissions, as AWS evaluates both identity-based and resource-based policies.

How to eliminate wrong answers

Option A is wrong because a lifecycle policy that deletes objects too quickly would not cause 'AccessDenied' errors; it would cause data to be deleted after delivery, not prevent writes. Option C is wrong because default encryption on the S3 bucket does not block write access; Firehose can write encrypted objects as long as it has the necessary permissions. Option D is wrong because the error is 'AccessDenied', not a KMS-related error; if the issue were KMS permissions, the error would typically be 'KMS.AccessDeniedException' or similar, and Firehose would need `kms:GenerateDataKey` (not `kms:Decrypt`) to encrypt objects with SSE-KMS.

Full explanation →
374
MCQeasy

A company uses Amazon RDS for MySQL with encryption at rest enabled. The security team requires that all database audit logs be stored in Amazon S3 for at least 7 years. Which AWS service should the data engineer use to collect and store the logs?

A.Amazon S3 with S3 Object Lock enabled for write-once-read-many (WORM) protection.
B.Amazon Kinesis Data Firehose to stream logs directly to Amazon S3.
C.Amazon CloudWatch Logs with a subscription filter to Amazon S3.
D.AWS CloudTrail to capture database queries and store in S3.
AnswerC

RDS audit logs can be sent to CloudWatch Logs, and then exported to S3.

Why this answer

Amazon RDS for MySQL can publish audit logs to Amazon CloudWatch Logs. A subscription filter can then forward these logs to Amazon S3 for long-term storage, satisfying the 7-year retention requirement. Option A is wrong because S3 Object Lock is a storage feature, not a log collection service.

Option B is wrong because Kinesis Data Firehose is not natively integrated with RDS audit logs. Option D is wrong because AWS CloudTrail captures API calls, not database audit logs.

Full explanation →
375
MCQhard

A company uses Amazon DynamoDB as a session store for a web application. During peak hours, the application experiences high latency and throttling on the DynamoDB table. The table has a read capacity of 5000 RCU and write capacity of 2000 WCU. The application reads and writes session data using the session ID as the partition key. What is the most cost-effective solution to reduce throttling?

A.Enable Auto Scaling on the table to automatically adjust capacity.
B.Increase the read capacity units (RCU) and write capacity units (WCU) to 10000 each.
C.Enable DynamoDB global tables to distribute read traffic.
D.Implement DynamoDB Accelerator (DAX) to cache frequent reads.
AnswerD

DAX reduces read load on the table, mitigating throttling cost-effectively.

Why this answer

DynamoDB Accelerator (DAX) provides an in-memory cache that absorbs read-heavy traffic, reducing the load on the underlying DynamoDB table. Since the application reads session data using the session ID as the partition key, DAX can serve frequent reads with microsecond latency, eliminating throttling without requiring a capacity increase. This is the most cost-effective solution because it avoids provisioning additional RCUs for reads that are repetitive and cacheable.

Exam trap

The trap here is that candidates assume throttling always requires scaling capacity (Auto Scaling or manual increase), but they overlook that caching with DAX is often the most cost-effective solution for read-heavy, repetitive access patterns like session stores.

How to eliminate wrong answers

Option A is wrong because Auto Scaling adjusts capacity based on utilization, but during peak hours the table is already throttling at 5000 RCU and 2000 WCU; Auto Scaling would only increase capacity after throttling occurs, leading to continued latency spikes and higher costs without addressing the root cause of read-heavy traffic. Option B is wrong because increasing RCU and WCU to 10000 each is not cost-effective; it doubles provisioned capacity, incurring significant cost, while the throttling is likely due to read spikes that can be mitigated by caching rather than scaling the table. Option C is wrong because DynamoDB global tables replicate data across regions for disaster recovery and low-latency global access, but they do not reduce throttling on a single table in one region; they increase write costs and complexity without solving the local read congestion.

Full explanation →
Page 4

Page 5 of 23

Page 6

All pages

1234567891011121314151617181920212223

Practice DEA-C01 by domain

Target a specific domain to shore up weak areas.

Data Ingestion and TransformationData Operations and SupportData Security and GovernanceData Store Management
See all domains with question counts →