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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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).
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.
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.
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.
A data engineer needs to store event data from IoT devices that arrives in bursts. The data is key-value and requires single-digit millisecond read and write latency. The engineer also needs to run complex analytical queries on the data for reporting. Which TWO services should be used together? (Choose TWO.)
Select 2 answers
A.Amazon DynamoDB
B.Amazon ElastiCache for Redis
C.Amazon Redshift
D.Amazon S3
E.Amazon RDS for MySQL
AnswersA, C
Provides low-latency access for key-value data.
Why this answer
Amazon DynamoDB is correct because it provides single-digit millisecond read and write latency at any scale, making it ideal for IoT event data arriving in bursts. Its key-value data model matches the requirement, and it can serve as the operational data store for fast ingestion while supporting complex analytical queries when integrated with Amazon Redshift.
Exam trap
The trap here is that candidates often choose ElastiCache for Redis because of its low latency, forgetting that it is not a durable data store for analytical queries, or they pick S3 thinking it can serve as a primary database, ignoring its lack of single-digit millisecond latency for key-value access.
Which TWO options are valid ways to reduce storage costs for an Amazon S3 data lake that stores historical data rarely accessed after 30 days? (Choose TWO.)
Select 2 answers
A.Enable S3 Transfer Acceleration for all uploads.
B.Create a lifecycle policy to transition objects to S3 Standard-IA after 30 days.
C.Create a lifecycle policy to delete objects after 30 days.
D.Create a lifecycle policy to transition objects to S3 Glacier Deep Archive after 90 days.
E.Enable S3 Versioning to preserve all object versions.
AnswersB, D
Standard-IA reduces storage cost for infrequent access.
Why this answer
S3 Standard-IA (Infrequent Access) is designed for data accessed less frequently but requires rapid access when needed. Transitioning objects to Standard-IA after 30 days reduces storage costs compared to S3 Standard while maintaining low-latency retrieval, making it ideal for a data lake where historical data is rarely accessed after the first month.
Exam trap
The trap here is that candidates often confuse data protection features (like Versioning) with cost optimization, or they assume that deleting data is the only way to reduce costs, overlooking lifecycle transitions to lower-cost storage classes that retain data accessibility.
A company stores IoT sensor data in an Amazon S3 bucket. The data is ingested every minute and each object is about 10 KB. The data must be stored for at least 7 years for compliance. Which lifecycle policy configuration minimizes storage costs?
A.Transition to S3 One Zone-IA after 30 days, then to S3 Glacier Deep Archive after 365 days, and expire after 2555 days.
B.Transition to S3 Glacier Flexible Retrieval after 90 days and expire after 2555 days.
C.Transition to S3 Glacier Deep Archive after 30 days and expire after 2555 days.
D.Transition to S3 Standard-IA after 30 days, then to S3 Glacier Deep Archive after 365 days, and expire after 2555 days.
AnswerC
This minimizes cost by moving to the cheapest storage class early and retaining for 7 years.
Why this answer
S3 Glacier Deep Archive is the lowest-cost storage class for long-term archival data, and transitioning directly after 30 days minimizes costs for 10 KB objects that are accessed infrequently. The 2555-day expiration (7 years) meets the compliance requirement. Other options incur higher costs by using more expensive intermediate tiers or by delaying the transition to the cheapest storage class.
Exam trap
The DEA-C01 exam often tests the misconception that using multiple intermediate transitions (e.g., Standard-IA then Glacier) is always more cost-effective, but for long-term archival of small objects, the cheapest path is to go directly to the lowest-cost storage class as soon as the minimum transition period allows.
How to eliminate wrong answers
Option A is wrong because transitioning to S3 One Zone-IA after 30 days is unnecessary and more expensive than going directly to Glacier Deep Archive, especially for 10 KB objects where minimum storage charges apply. Option B is wrong because S3 Glacier Flexible Retrieval is more expensive than Glacier Deep Archive for long-term archival, and the 90-day transition delay incurs higher costs than the 30-day transition in Option C. Option D is wrong because transitioning to S3 Standard-IA after 30 days adds unnecessary cost compared to directly transitioning to Glacier Deep Archive, and the intermediate tier does not provide cost savings for data that will be archived for 7 years.
A data engineer needs to migrate an on-premises Apache Hadoop cluster to AWS. The cluster stores data in HDFS and runs MapReduce jobs. The company wants to minimize operational overhead and leverage serverless technologies where possible. Which AWS service should the data engineer use to replace HDFS storage?
A.Amazon EBS
B.Amazon EMR
C.Amazon S3
D.Amazon Redshift
AnswerC
S3 is the recommended storage for Hadoop on AWS, replacing HDFS with durable object storage.
Why this answer
Amazon S3 is the correct replacement for HDFS because it provides highly durable, scalable, and serverless object storage that can be used as the primary storage layer for Amazon EMR. Unlike HDFS, S3 decouples storage from compute, eliminating the need to manage cluster storage and allowing jobs to run on ephemeral clusters, which minimizes operational overhead. S3 integrates with EMR via the EMR File System (EMRFS), enabling MapReduce jobs to read/write data directly from S3 as if it were HDFS.
Exam trap
The trap here is that candidates confuse Amazon EMR (a compute service) with a storage service, assuming it replaces HDFS, when in fact EMR can use either HDFS or S3 for storage, and the question explicitly asks for the storage replacement.
How to eliminate wrong answers
Option A is wrong because Amazon EBS provides block-level storage volumes attached to EC2 instances, which is not serverless and requires manual management of volume size, snapshots, and replication; it also ties storage to a specific compute instance, defeating the purpose of decoupling storage from compute for a Hadoop migration. Option B is wrong because Amazon EMR is a managed big data platform that runs MapReduce jobs, not a storage service; it can use HDFS or S3 for storage, but the question specifically asks for a replacement of HDFS storage, not the compute framework. Option D is wrong because Amazon Redshift is a fully managed data warehouse optimized for SQL-based analytics and structured data, not a general-purpose distributed file system for Hadoop workloads; it does not support HDFS semantics or MapReduce jobs natively.
A data engineering team is using Amazon DynamoDB to store user session data for a web application. The application experiences sudden spikes in traffic, causing throttling on the DynamoDB table. The team wants to minimize throttling without over-provisioning read/write capacity. Which solution should the team implement?
A.Enable DynamoDB Time to Live (TTL) to automatically delete expired items.
B.Disable auto scaling and manually set a high provisioned capacity.
C.Use Amazon RDS read replicas to offload read traffic.
DynamoDB Accelerator (DAX) is a fully managed, in-memory cache that reduces read latency from single-digit milliseconds to microseconds. By caching frequently accessed items, DAX offloads read requests from the DynamoDB table, directly reducing the read capacity consumption and thus minimizing throttling during traffic spikes without requiring over-provisioning of read capacity units.
Exam trap
The trap here is that candidates may confuse DynamoDB with relational databases and incorrectly assume RDS read replicas can offload DynamoDB traffic, or they may think TTL or manual provisioning are appropriate solutions for throttling, when the correct approach is to use a caching layer like DAX to absorb read spikes.
How to eliminate wrong answers
Option A is wrong because Time to Live (TTL) only deletes expired items to reduce storage costs and does not address read/write throttling caused by sudden traffic spikes. Option B is wrong because disabling auto scaling and manually setting a high provisioned capacity leads to over-provisioning and increased costs, which contradicts the goal of minimizing throttling without over-provisioning. Option C is wrong because Amazon RDS read replicas are designed for relational databases (RDS), not DynamoDB, and cannot offload traffic from a NoSQL DynamoDB table.
A data engineer is configuring Amazon S3 Lifecycle policies to transition objects between storage classes. The data is accessed frequently for the first 30 days, then rarely for the next 90 days, after which it must be archived. The engineer wants to minimize costs while ensuring immediate retrieval for the first 30 days. Which lifecycle policy should the engineer implement?
A.Transition to Glacier Flexible Retrieval after 30 days, then delete after 120 days
B.Transition to One Zone-IA after 30 days, then to Glacier Deep Archive after 120 days
C.Transition to Glacier Deep Archive after 30 days, then delete after 120 days
D.Transition to Standard-IA after 30 days, then to Glacier Deep Archive after 120 days
AnswerD
Standard-IA is cost-effective for rarely accessed data; Glacier Deep Archive is cheapest for archiving.
Why this answer
It transitions objects from S3 Standard (immediate retrieval, frequent access) to S3 Standard-IA (lower cost for infrequent access, immediate retrieval) after 30 days, then to S3 Glacier Deep Archive (lowest-cost archival storage) after 120 days. This matches the access pattern: frequent for 30 days, rare for 90 days, then archived, while minimizing cost and maintaining immediate retrieval for the first 30 days.
Exam trap
The trap here is that candidates often choose Glacier Deep Archive too early (e.g., after 30 days) to minimize cost, forgetting that the data must be immediately retrievable for the first 30 days and rarely accessed but still retrievable for the next 90 days, which requires a storage class with immediate retrieval (Standard-IA) before archiving.
How to eliminate wrong answers
Option A is wrong because transitioning to Glacier Flexible Retrieval after 30 days would incur retrieval delays (minutes to hours) for data that is still accessed rarely but may need immediate retrieval within the next 90 days, and it does not archive after 120 days (it deletes). Option B is wrong because transitioning to One Zone-IA after 30 days does not provide the durability or availability of Standard-IA for rarely accessed data that may still need immediate retrieval, and it is not cost-optimal for data that is not accessed frequently enough to justify the higher cost of One Zone-IA. Option C is wrong because transitioning to Glacier Deep Archive after 30 days would make retrieval impossible for the next 90 days (retrieval time is 12-48 hours), violating the requirement for immediate retrieval during the first 30 days and failing to minimize costs for the rare-access period.
A data engineer is designing a data pipeline that ingests streaming data from IoT devices into Amazon S3 using Amazon Kinesis Data Firehose. The data must be transformed from JSON to Parquet format before storage. Which TWO actions should the data engineer take to achieve this?
Select 2 answers
A.Enable Firehose's built-in Parquet conversion without any additional configuration.
B.Use Amazon Kinesis Data Analytics to convert the data format.
C.Configure Firehose to convert the data to Apache Avro format.
D.Create a Glue Data Catalog table defining the schema and configure Firehose to use the table for Parquet conversion.
E.Create an AWS Lambda function to transform the data to Parquet and use it as a Firehose transformation.
AnswersD, E
Firehose can use the schema from Glue Data Catalog to convert to Parquet.
Why this answer
Amazon Kinesis Data Firehose can directly convert incoming JSON data to Parquet format by referencing a table schema defined in the AWS Glue Data Catalog. This allows Firehose to perform the schema-aware conversion without custom code, leveraging the Glue table's column definitions and SerDe for Parquet serialization.
Exam trap
The DEA-C01 exam often tests the misconception that Firehose can automatically convert to Parquet without a schema definition, leading candidates to select Option A, but in reality, Firehose requires an explicit schema (via Glue or Lambda) for Parquet conversion.
A company uses Amazon S3 to store sensitive financial data. The security team requires that all objects be encrypted at rest using AWS KMS with a customer-managed key. Additionally, they want to audit all KMS decrypt calls for compliance. Which configuration should be used to meet these requirements?
A.Enable default encryption on the bucket with SSE-KMS using an AWS managed key.
B.Use SSE-S3 with a bucket policy that denies uploads without encryption.
C.Use SSE-KMS with a customer-managed KMS key and enable CloudTrail data events for the key.
D.Use SSE-C with client-managed keys and log S3 API calls.
AnswerC
SSE-KMS with customer-managed key and CloudTrail auditing meets requirements.
Why this answer
SSE-KMS with a customer-managed key allows the company to control the encryption key lifecycle and meet the requirement for customer-managed keys. Enabling CloudTrail data events for the KMS key captures all decrypt API calls, providing the necessary audit trail for compliance.
Exam trap
The trap here is that candidates may confuse enabling default encryption on the bucket (which can use SSE-KMS) with the need for a customer-managed key and CloudTrail data events, or they may think SSE-S3 or SSE-C can satisfy the audit requirement without KMS-specific logging.
How to eliminate wrong answers
Option A is wrong because it uses an AWS managed key, not a customer-managed key, so the security team cannot control key rotation or access policies. Option B is wrong because SSE-S3 uses server-side encryption with S3-managed keys, which does not provide customer-managed key control, and the bucket policy only enforces encryption, not auditing of decrypt calls. Option D is wrong because SSE-C requires the client to manage the encryption keys, which does not meet the requirement for AWS KMS, and logging S3 API calls alone does not capture KMS decrypt events.
A startup is building a mobile application that requires a database to store user profiles and preferences. The database must scale automatically with minimal administration. Which AWS service should they use?
A.Amazon Redshift
B.Amazon Aurora
C.Amazon DynamoDB
D.Amazon RDS for PostgreSQL
AnswerC
DynamoDB scales automatically with on-demand capacity.
Why this answer
Amazon DynamoDB is a fully managed NoSQL key-value and document database that delivers single-digit millisecond performance at any scale. It supports automatic scaling of throughput capacity and storage with no downtime, making it ideal for a mobile application that requires minimal administrative overhead. The serverless, pay-per-request billing model aligns perfectly with the startup's need for automatic scaling and low operational burden.
Exam trap
The trap here is that candidates often choose a relational database like Aurora or RDS because they assume user profiles require complex joins or ACID transactions, but DynamoDB's single-table design and conditional updates can handle most mobile app patterns with simpler, more scalable operations.
How to eliminate wrong answers
Option A is wrong because Amazon Redshift is a petabyte-scale data warehouse optimized for complex analytical queries, not for transactional user profile storage, and it requires manual scaling and cluster management. Option B is wrong because Amazon Aurora is a relational database that, while offering some auto-scaling for storage, still requires manual provisioning of compute resources and is not as fully serverless as DynamoDB for this use case. Option D is wrong because Amazon RDS for PostgreSQL is a managed relational database but requires manual scaling of instance size and storage, and does not offer the same level of automatic, seamless scaling as DynamoDB for a mobile app's unpredictable workload.
Which TWO of the following are best practices for Amazon Redshift table design? (Choose TWO.)
Select 2 answers
A.Choose sort keys based on query patterns
B.Use INSERT statements for large data loads
C.Avoid compression encoding to reduce CPU overhead
D.Specify distribution keys to minimize data movement
E.Set distribution style to ALL for all tables
AnswersA, D
Sort keys improve query performance for range-filtered queries.
Why this answer
Options A and D are correct. Choosing sort keys based on query patterns optimizes data organization for faster retrieval, and specifying distribution keys minimizes data movement across nodes. Option B is wrong because large data loads should use the COPY command, not INSERT statements.
Option C is wrong because compression encoding reduces storage and I/O, improving performance despite slightly higher CPU overhead. Option E is wrong because setting distribution style to ALL for all tables can cause excessive data duplication and storage costs; distribution keys should be selected based on table size and join patterns.
A company is migrating a large Oracle data warehouse to Amazon Redshift. Which THREE considerations are important for optimizing the Redshift cluster?
Select 3 answers
A.Purchasing reserved instances for the cluster.
B.Using columnar storage format.
C.Defining appropriate sort keys for the tables.
D.Applying compression encoding to columns.
E.Choosing the right distribution style (KEY, ALL, EVEN).
AnswersC, D, E
Improves query performance by reducing scans.
Why this answer
Sort keys in Amazon Redshift determine the physical order of data on disk, which directly impacts the efficiency of range-restricted queries and compression. By defining appropriate sort keys (compound or interleaved), the query optimizer can use zone maps to skip large blocks of data that don't match the filter criteria, significantly reducing the number of blocks scanned and improving query performance.
Exam trap
The trap here is that candidates confuse cost-saving measures (reserved instances) or inherent architecture features (columnar storage) with active optimization choices, when in fact only sort keys, distribution styles, and compression encoding are configurable settings that directly impact query performance in Redshift.
A company has an Amazon DynamoDB table with on-demand capacity mode. The table stores session data for a web application. Recently, the application experienced throttling errors during a traffic spike. The team wants to prevent future throttling while optimizing costs. What should they do?
A.Implement a DynamoDB Accelerator (DAX) cluster
B.Enable DynamoDB auto scaling on the table
C.Switch to provisioned capacity with auto scaling
D.Increase the read and write capacity of the table
AnswerA
DAX provides in-memory caching to reduce read throttling.
Why this answer
A DynamoDB Accelerator (DAX) cluster provides an in-memory cache that absorbs read-heavy traffic spikes, reducing the number of read requests that reach the underlying DynamoDB table. Since the throttling errors occurred during a traffic spike and the table uses on-demand capacity, which already scales automatically for writes and reads, the bottleneck is likely read-heavy traffic overwhelming the table's throughput. DAX offloads reads from the table, preventing throttling without requiring any changes to capacity mode, and it is cost-effective because it reduces read capacity unit consumption.
Exam trap
The trap here is that candidates assume throttling in on-demand mode must be fixed by switching to provisioned capacity or enabling auto scaling, but they overlook that on-demand already scales automatically and the real solution is to reduce read load via caching with DAX.
How to eliminate wrong answers
Option B is wrong because DynamoDB auto scaling is only available for provisioned capacity mode, not on-demand mode; on-demand already scales automatically, so enabling auto scaling is not applicable. Option C is wrong because switching to provisioned capacity with auto scaling would introduce management overhead and potential cost inefficiency compared to on-demand, and it does not address the root cause of read throttling during spikes as effectively as caching. Option D is wrong because increasing read and write capacity is only possible in provisioned mode; in on-demand mode, you cannot manually increase capacity, and doing so would not prevent throttling caused by read-heavy spikes without incurring unnecessary costs.
A company is using Amazon RDS for MySQL and wants to automate backups for point-in-time recovery. Which TWO actions should be taken? (Choose TWO.)
Select 2 answers
A.Enable automated backups with a retention period.
B.Use AWS Backup to schedule backups.
C.Set the backup retention period to the desired number of days.
D.Enable Multi-AZ deployment.
E.Take manual snapshots daily.
AnswersA, C
Automated backups provide point-in-time recovery and are enabled by default.
Why this answer
Enabling automated backups in Amazon RDS for MySQL allows point-in-time recovery (PITR) to any second within the retention period. Option C is correct because setting the backup retention period to the desired number of days (1–35 days) defines how far back you can perform PITR, and it must be explicitly configured to enable automated backups.
Exam trap
The trap here is that candidates often confuse Multi-AZ deployment (which provides failover) with backup automation, or assume AWS Backup is required for automated backups, when in fact RDS native automated backups are sufficient and the primary method for PITR.
A company stores sensitive financial data in an Amazon Redshift cluster. The data engineer must ensure that all queries are logged for audit purposes and that the logs are stored in Amazon S3 with server-side encryption. Which THREE steps should the data engineer take to meet these requirements?
Select 3 answers
A.Configure audit logs to be stored in an Amazon S3 bucket.
B.Enable encryption on the Redshift cluster.
C.Enable AWS CloudTrail to log Redshift queries.
D.Enable audit logging on the Redshift cluster.
E.Enable default encryption on the S3 bucket using SSE-S3 or SSE-KMS.
AnswersA, D, E
Audit logs can be delivered to an S3 bucket.
Why this answer
Amazon Redshift audit logs can be configured to be stored directly in an Amazon S3 bucket, which is a native feature for exporting connection logs, user logs, and query logs. This satisfies the requirement to log all queries for audit purposes without relying on external services.
Exam trap
The trap here is confusing AWS CloudTrail (which logs control-plane API calls) with Redshift's native audit logging (which logs data-plane SQL queries), leading candidates to incorrectly select CloudTrail as a solution for query auditing.
A data engineer needs to store streaming data from multiple sources into Amazon S3. The data should be organized by source, date, and hour. The engineer wants to minimize processing overhead. Which THREE S3 features should the engineer use to achieve this? (Choose THREE.)
Select 3 answers
A.S3 Inventory to list objects and their metadata.
B.S3 Object Lock to prevent object modifications.
C.S3 Batch Operations to rename objects after upload.
D.S3 Event Notifications to invoke Lambda functions for data processing.
E.S3 prefixes to create a folder structure (e.g., source=.../date=.../hour=...).
AnswersA, D, E
Inventory helps audit and manage the stored data.
Why this answer
S3 prefixes organize objects into a hierarchy. S3 Inventory provides a list of objects. S3 Event Notifications trigger downstream processing.
Batch Operations are for bulk actions, not organization. Object Lock is for retention. S3 Select is for querying within files.
A company uses Amazon Redshift for analytics. The data engineer notices that queries are slow and the system is experiencing high disk usage. The engineer suspects that the distribution style is suboptimal. Which action should the engineer take to improve query performance?
A.Convert all tables to use SORTKEY on the most frequently filtered column.
B.Increase the number of nodes in the cluster to distribute data across more slices.
C.Use the DISTSTYLE AUTO setting and analyze query patterns to let Redshift choose.
D.Set all tables to DISTSTYLE EVEN to distribute data evenly.
AnswerC
AUTO adapts distribution based on workload.
Why this answer
DISTSTYLE AUTO allows Amazon Redshift to automatically assign distribution styles (KEY, EVEN, or ALL) based on query patterns and table size, optimizing data distribution for improved query performance. This is particularly effective when the engineer suspects suboptimal distribution but lacks detailed knowledge of the ideal key, as Redshift analyzes workload patterns to reduce data movement and disk usage.
Exam trap
The trap here is that candidates often confuse distribution style with sort key or node scaling, leading them to choose options that address symptoms (e.g., disk usage via node count) rather than the root cause of suboptimal data distribution.
How to eliminate wrong answers
Option A is wrong because SORTKEY improves query performance by reducing the amount of data scanned via block-level filtering, but it does not address distribution style or high disk usage caused by data skew. Option B is wrong because increasing the number of nodes distributes data across more slices but does not fix the root cause of suboptimal distribution; it may even exacerbate disk usage if data is already skewed. Option D is wrong because setting all tables to DISTSTYLE EVEN distributes rows evenly across slices, which can eliminate data skew but may cause excessive data movement (broadcast or redistribution) during joins, degrading query performance for tables that are frequently joined on specific columns.
A data engineer is migrating an on-premises PostgreSQL database to Amazon RDS for PostgreSQL. The database is 2 TB in size and has a tight migration window. Which migration approach minimizes downtime?
A.Use AWS Database Migration Service (DMS) with full load only.
B.Use pg_dump to export the database and pg_restore to import into RDS.
C.Create a read replica in RDS and promote it when ready.
D.Use AWS DMS with ongoing replication to capture changes during migration.
AnswerD
Ongoing replication syncs changes until cutover, minimizing downtime.
Why this answer
AWS DMS with ongoing replication (change data capture, CDC) allows you to perform a full load of the existing data and then continuously replicate incremental changes from the source PostgreSQL database to the target RDS for PostgreSQL. This minimizes downtime because you can keep the source database fully operational during the migration and only switch applications over after the target is fully synchronized, resulting in a very short cutover window.
Exam trap
The trap here is that candidates often confuse the concept of a read replica (which is an AWS-internal feature for RDS instances) with a migration tool, and mistakenly think they can replicate from an on-premises database to an RDS read replica, which is not supported.
How to eliminate wrong answers
Option A is wrong because using AWS DMS with full load only copies the current state of the database and does not capture any changes made during the migration, so you would need to stop writes on the source to ensure consistency, causing significant downtime. Option B is wrong because pg_dump and pg_restore are logical backup and restore tools that require the source database to be in a consistent state (often requiring a read-only or quiesced state) and do not support ongoing replication, leading to a longer downtime window for a 2 TB database. Option C is wrong because Amazon RDS for PostgreSQL does not support creating a read replica from an on-premises PostgreSQL instance; read replicas in RDS are only available within the AWS ecosystem and cannot be used for cross-environment migrations.
A data engineer ran the command shown in the exhibit on the bucket 'my-data-lake'. The engineer then tries to delete an object version but receives an 'AccessDenied' error. The engineer has full S3 permissions via IAM. What is the most likely reason for the error?
A.Versioning is suspended on the bucket
B.MFA Delete is enabled, requiring multi-factor authentication
C.The bucket policy denies s3:DeleteObjectVersion
D.An S3 Object Lock retention policy is in effect
AnswerB
MFA Delete requires additional authentication to delete versions.
Why this answer
The command shown in the exhibit (likely `aws s3api put-bucket-versioning --bucket my-data-lake --versioning-configuration Status=Enabled,MFADelete=Enabled`) enables both versioning and MFA Delete on the bucket. When MFA Delete is enabled, any operation that permanently deletes an object version or changes the versioning state requires the request to include a multi-factor authentication token. Even though the engineer has full S3 permissions via IAM, the missing MFA token causes the 'AccessDenied' error.
This is a bucket-level setting that overrides IAM permissions for these specific operations.
Exam trap
The trap here is that candidates assume 'full S3 permissions via IAM' guarantees all operations succeed, but MFA Delete is a bucket-level condition that overrides IAM permissions for version deletion and versioning state changes, requiring explicit MFA authentication.
How to eliminate wrong answers
Option A is wrong because suspending versioning does not prevent deletion of existing object versions; it only stops new versions from being created, and the engineer would still be able to delete versions with appropriate IAM permissions. Option C is wrong because the engineer has full S3 permissions via IAM, and there is no indication of a bucket policy explicitly denying s3:DeleteObjectVersion; the error is not caused by a deny statement. Option D is wrong because an S3 Object Lock retention policy prevents deletion or overwrite of objects during the retention period, but the error message is 'AccessDenied' specifically due to missing MFA, not a retention-based block.
A data engineer is designing a multi-Region disaster recovery solution for an Amazon DynamoDB table. The table must be available in a secondary Region with minimal data loss and automatic failover. Which feature should be used?
A.DynamoDB on-demand backup and restore in the secondary Region
B.DynamoDB global tables
C.DynamoDB point-in-time recovery (PITR)
D.DynamoDB cross-Region snapshot export to S3
AnswerB
Global tables replicate data across Regions and support automatic failover.
Why this answer
DynamoDB global tables provide a fully managed, multi-Region, multi-active database solution that replicates data automatically across selected AWS Regions. This ensures automatic failover with eventual consistency and minimal data loss, meeting the disaster recovery requirements for high availability and automatic failover without manual intervention.
Exam trap
The trap here is that candidates often confuse point-in-time recovery (PITR) with cross-Region disaster recovery, but PITR is a single-Region feature that does not provide automatic failover or multi-Region replication.
How to eliminate wrong answers
Option A is wrong because on-demand backup and restore is a manual process that requires user intervention to initiate a restore in the secondary Region, not providing automatic failover or minimal data loss in real time. Option C is wrong because point-in-time recovery (PITR) protects against accidental writes or deletes within a single Region by restoring to a point in time, but it does not replicate data across Regions or enable automatic failover. Option D is wrong because cross-Region snapshot export to S3 is a manual, batch-oriented process that exports table data to Amazon S3 in another Region, requiring manual import and setup for failover, and does not provide automatic, continuous replication or failover.
A company is using an Amazon RDS for MySQL database for its e-commerce platform. During a recent flash sale, the database experienced high read traffic, causing slow query performance. The company needs a solution that offloads read traffic with minimal application changes. Which action should be taken?
A.Enable DynamoDB Accelerator (DAX) on the RDS instance.
B.Migrate the database to Amazon Aurora and enable Aurora Global Database.
C.Implement Amazon ElastiCache for Redis to cache database queries.
D.Create an Amazon RDS read replica in the same region.
AnswerD
Read replicas offload read traffic from the primary instance with minimal application changes.
Why this answer
Creating an Amazon RDS read replica in the same region offloads read traffic from the primary DB instance by directing read queries to a read-only copy. This requires minimal application changes—only modifying the database connection string to point read queries to the replica endpoint. RDS read replicas use MySQL's native asynchronous replication, making them ideal for scaling read-heavy workloads like flash sales.
Exam trap
The trap here is that candidates may choose ElastiCache (Option C) because it is a caching solution, but they overlook the explicit requirement for minimal application changes, which caching typically does not satisfy without code modifications.
How to eliminate wrong answers
Option A is wrong because DynamoDB Accelerator (DAX) is an in-memory cache for Amazon DynamoDB, not for RDS for MySQL; it cannot be enabled on an RDS instance. Option B is wrong because migrating to Aurora and enabling Aurora Global Database is designed for cross-region disaster recovery and global reads, not for offloading read traffic within a single region, and it requires significant application and migration effort. Option C is wrong because while ElastiCache for Redis can cache query results, it requires application code changes to implement caching logic (e.g., cache-aside pattern), which contradicts the requirement for minimal application changes.
Which TWO actions can help optimize Amazon S3 storage costs for a data lake? (Choose two.)
Select 2 answers
A.Enable S3 Replication to another region
B.Use S3 Intelligent-Tiering for unpredictable access patterns
C.Use S3 Select to retrieve only needed data
D.Enable S3 Transfer Acceleration
E.Implement S3 Lifecycle policies to transition objects to Glacier
AnswersB, E
Intelligent-Tiering automatically optimizes costs based on access patterns.
Why this answer
S3 Intelligent-Tiering automatically moves objects between two access tiers (frequent and infrequent) when access patterns change, with no retrieval fees and a small monthly monitoring fee. This is ideal for a data lake where access patterns are unpredictable, as it optimizes costs without requiring manual lifecycle rule adjustments.
Exam trap
The trap here is that candidates confuse cost optimization for storage (reducing stored data cost) with cost optimization for data transfer or retrieval, leading them to select options like S3 Select or Transfer Acceleration that address different cost dimensions.
A company uses Amazon S3 to store customer documents. The data engineer needs to ensure that all objects uploaded to a specific S3 bucket are automatically encrypted with a customer-managed AWS KMS key. What should the data engineer do?
A.Use pre-signed URLs for all uploads that include encryption parameters.
B.Create a bucket policy that denies uploads without encryption.
C.Enable S3 Versioning on the bucket.
D.Set default encryption on the bucket to use SSE-KMS with the customer-managed key.
AnswerD
Default encryption automatically encrypts all objects with the specified KMS key.
Why this answer
Setting default encryption on the S3 bucket to SSE-KMS with the customer-managed key ensures that all objects uploaded without explicit encryption headers are automatically encrypted using that KMS key. This satisfies the requirement without relying on client-side behavior, as S3 applies the encryption server-side at the time of write.
Exam trap
The trap here is that candidates often confuse bucket policies that deny unencrypted uploads (which only reject non-compliant requests) with default encryption (which automatically encrypts objects), leading them to choose Option B instead of D.
How to eliminate wrong answers
Option A is wrong because pre-signed URLs only grant temporary access to upload or download objects; they do not enforce encryption on the uploaded data, and including encryption parameters in the URL is optional and client-dependent. Option B is wrong because a bucket policy that denies uploads without encryption can enforce that clients must include encryption headers, but it does not automatically encrypt objects; if the client fails to include the header, the upload is denied rather than encrypted. Option C is wrong because S3 Versioning preserves multiple versions of an object but has no effect on encryption; it does not encrypt objects or enforce encryption policies.
A data engineer is troubleshooting an Amazon Redshift cluster that is running out of disk space. The engineer runs STV_PARTITIONS and notices that some slices have significantly more data than others. What is the most likely cause and solution?
A.Poorly chosen sort keys; redefine sort keys
B.Data distribution skew due to uneven distribution style; change distribution style to EVEN or correct KEY
C.Some nodes are underutilized; add more nodes
D.Concurrency scaling is disabled; enable concurrency scaling
AnswerB
Uneven distribution can cause some slices to fill up faster.
Why this answer
B is correct because STV_PARTITIONS shows per-slice disk usage, and significant variation indicates data distribution skew. Uneven distribution causes some slices to fill faster, leading to premature disk-full errors. Changing the distribution style to EVEN (for tables without join keys) or correcting the KEY distribution style (using a high-cardinality, evenly distributed column) rebalances data across slices.
Exam trap
The trap here is that candidates confuse sort keys (which improve query performance via zone maps) with distribution keys (which control data placement across slices), leading them to incorrectly select sort key redefinition as the fix for disk space skew.
How to eliminate wrong answers
Option A is wrong because sort keys affect query performance (min/max zone maps and block pruning), not how data is distributed across slices; disk space skew is a distribution issue, not a sort key issue. Option C is wrong because adding nodes increases total cluster capacity but does not fix existing data skew; the problem is uneven data placement, not insufficient total nodes. Option D is wrong because concurrency scaling handles workload bursts by adding transient compute capacity, not disk space; it does not affect how data is stored on existing slices.
A data engineer is designing a data store for a real-time analytics application that requires sub-millisecond read and write latency. The data is accessed via a REST API. Which AWS services should the engineer consider? (Choose THREE.)
Select 3 answers
A.Amazon S3
B.Amazon RDS for MySQL
C.Amazon ElastiCache for Redis
D.Amazon DynamoDB
E.DynamoDB Accelerator (DAX)
AnswersC, D, E
Redis provides sub-millisecond latency.
Why this answer
Amazon ElastiCache for Redis is correct because it provides an in-memory data store that delivers sub-millisecond read and write latency, ideal for real-time analytics. Redis supports data structures like strings, hashes, and sorted sets, and can be accessed via REST API through a caching layer or directly with Redis commands. This makes it suitable for low-latency, high-throughput workloads where disk-based storage would introduce unacceptable delays.
Exam trap
The trap here is that candidates may overlook DAX as a separate service and assume DynamoDB alone provides sub-millisecond latency, but DynamoDB's base latency is typically 1-10 milliseconds for strongly consistent reads, and DAX is required to achieve sub-millisecond performance for read-heavy workloads.
A company stores sensitive data in an S3 bucket. To meet compliance requirements, they must ensure that all objects are encrypted at rest using server-side encryption with AWS KMS. Which bucket policy statement should be applied to deny uploads that do not use the required encryption?
Correctly denies PutObject if the encryption is not SSE-KMS.
Why this answer
It uses the `s3:x-amz-server-side-encryption` condition key with `StringNotEquals` set to `aws:kms`, which denies any `s3:PutObject` request where the encryption header does not specify `aws:kms`. This ensures all uploaded objects are encrypted at rest using server-side encryption with AWS KMS, meeting the compliance requirement.
Exam trap
The trap here is that candidates often confuse the condition keys for encryption type (`s3:x-amz-server-side-encryption`) with the specific KMS key ID (`s3:x-amz-server-side-encryption-aws-kms-key-id`), or mistakenly use `Null` to check for the presence of encryption instead of enforcing the correct encryption algorithm.
How to eliminate wrong answers
Option B is wrong because it checks for `AES256`, which corresponds to SSE-S3 (Amazon S3-managed keys), not SSE-KMS (AWS KMS keys), so it would allow objects encrypted with SSE-S3 instead of enforcing KMS encryption. Option C is wrong because it uses the `s3:x-amz-server-side-encryption-aws-kms-key-id` condition key to require a specific KMS key ID, but the requirement is only to use KMS encryption, not a particular key; this would deny uploads using any other KMS key, even if they use KMS encryption. Option D is wrong because it uses the `Null` condition to deny uploads where the `s3:x-amz-server-side-encryption` header is not present (i.e., null), but it does not enforce that the encryption must be `aws:kms`; it would also allow uploads with `AES256` or other encryption values, failing to meet the KMS-specific requirement.
A company is using Amazon S3 to store sensitive data. They need to ensure that all objects are encrypted at rest. Which combination of actions should be taken? (Choose TWO.)
C.Configure S3 Access Points with network policies.
D.Use a bucket policy to deny PutObject requests that do not include the x-amz-server-side-encryption header.
E.Enable default encryption on the S3 bucket.
AnswersD, E
Policy enforces encryption at upload time.
Why this answer
A bucket policy that denies PutObject requests lacking the `x-amz-server-side-encryption` header enforces encryption at the time of upload, ensuring that any object written without explicit encryption headers is rejected. Option E is correct because enabling default encryption on the S3 bucket automatically applies server-side encryption (SSE-S3 or SSE-KMS) to any object uploaded without specifying encryption headers, providing a fallback that covers all objects. Together, these actions ensure that every object stored in the bucket is encrypted at rest, either by explicit client request or by default bucket settings.
Exam trap
The trap here is that candidates often confuse data protection features like Versioning or MFA Delete with encryption controls, or assume that network policies (Access Points) somehow enforce encryption, when in reality only explicit bucket policies and default encryption settings directly ensure objects are encrypted at rest.
A data engineer needs to store semi-structured JSON logs from multiple sources in a centralized data store for querying using SQL. The logs are immutable and need to be retained for 90 days. Which AWS service should be used?
Amazon S3 with Amazon Athena is the correct choice because S3 provides durable, cost-effective storage for immutable semi-structured JSON logs, and Athena enables serverless SQL querying directly against the data in S3 without needing to load or transform it. This combination meets the 90-day retention requirement and supports querying semi-structured data using standard SQL via Athena's built-in JSON SerDe.
Exam trap
The trap here is that candidates may choose DynamoDB for its JSON support and querying flexibility, overlooking that it is not designed for cost-effective long-term retention of immutable logs and lacks native SQL querying, while S3 with Athena directly addresses both requirements.
How to eliminate wrong answers
Option A is wrong because Amazon RDS for MySQL is a relational database designed for structured data with predefined schemas, not optimized for storing large volumes of immutable semi-structured JSON logs, and it incurs higher costs for long-term retention. Option B is wrong because Amazon DynamoDB is a NoSQL key-value and document database that can store JSON, but it is not cost-effective for 90-day retention of immutable logs due to per-request pricing and storage costs, and it lacks native SQL querying capabilities without additional services like DynamoDB Accelerator or PartiQL. Option D is wrong because Amazon ElastiCache for Redis is an in-memory cache designed for low-latency access to transient data, not for durable, long-term storage of immutable logs, and it does not support SQL querying.
A company has an Amazon S3 bucket with versioning enabled. They want to automatically delete noncurrent versions of objects after 30 days. Which lifecycle rule action should be used?
A.Expiration
B.NoncurrentVersionExpiration
C.NoncurrentVersionTransition
D.AbortIncompleteMultipartUpload
AnswerB
This action deletes noncurrent versions after a specified number of days.
Why this answer
The NoncurrentVersionExpiration lifecycle action is specifically designed to remove noncurrent object versions after a specified number of days. Since versioning is enabled and the requirement is to delete noncurrent versions after 30 days, this action directly meets the goal without affecting current versions or other lifecycle aspects.
Exam trap
The trap here is confusing NoncurrentVersionExpiration with Expiration, as candidates often mistakenly apply the standard Expiration action to delete old versions, not realizing it only affects the current version.
How to eliminate wrong answers
Option A is wrong because Expiration deletes the current version of an object (or marks it for deletion in non-versioned buckets), not noncurrent versions. Option C is wrong because NoncurrentVersionTransition moves noncurrent versions to a different storage class (e.g., S3 Glacier), but does not delete them. Option D is wrong because AbortIncompleteMultipartUpload only aborts incomplete multipart uploads that are older than a specified number of days, and has no effect on existing object versions.
A company wants to store data from thousands of IoT devices with varying data rates. The data must be stored in a schema-on-read fashion and support SQL queries. Which AWS service should be used?
A.Amazon RDS for MySQL
B.Amazon S3 with Amazon Athena
C.Amazon DynamoDB
D.Amazon Redshift
AnswerB
S3 provides scalable storage, and Athena enables SQL queries with schema-on-read.
Why this answer
Amazon S3 stores data in its native format (e.g., JSON, Parquet) without requiring a predefined schema, enabling schema-on-read. Amazon Athena uses Presto-based SQL to query data directly from S3, making it ideal for IoT data with varying rates and ad-hoc SQL analysis without provisioning servers.
Exam trap
The trap here is that candidates confuse schema-on-read with schema-on-write, assuming DynamoDB's flexible schema or Redshift's SQL support fits, but they miss that DynamoDB lacks native SQL and Redshift requires upfront table definitions, while Athena directly queries raw files in S3 with SQL.
How to eliminate wrong answers
Option A is wrong because Amazon RDS for MySQL requires a fixed schema defined before writing data, which contradicts the schema-on-read requirement and cannot handle the high write throughput of thousands of IoT devices without scaling limitations. Option C is wrong because Amazon DynamoDB is a NoSQL key-value and document database that does not support SQL queries natively (it uses PartiQL with limited SQL compatibility) and is not designed for schema-on-read. Option D is wrong because Amazon Redshift is a columnar data warehouse that requires schema-on-write (tables must be defined before loading data) and is optimized for structured, batch-loaded analytics rather than streaming IoT ingestion with varying data rates.
Which TWO of the following are features of Amazon RDS Multi-AZ deployments? (Choose 2.)
Select 2 answers
A.Read replicas in the same region for offloading read traffic.
B.Automatic failover to a standby instance in case of an AZ failure.
C.A standby instance that is not accessible for reads or writes.
D.Automatic storage scaling based on usage.
E.Synchronous replication across AWS Regions.
AnswersB, C
Multi-AZ automatically fails over to the standby in another AZ.
Why this answer
Amazon RDS Multi-AZ deployments automatically handle failover to a standby instance in a different Availability Zone when the primary instance fails or the AZ becomes unavailable. This synchronous replication ensures zero data loss and minimal downtime, with the standby instance automatically promoted to primary without manual intervention.
Exam trap
The DEA-C01 exam often tests the distinction between Multi-AZ (high availability with a passive standby) and read replicas (scaling reads with active replicas), leading candidates to incorrectly associate read offloading with Multi-AZ deployments.
A data engineer is designing a data store for a real-time leaderboard application that requires sub-millisecond read and write latency. The leaderboard stores scores for millions of users and needs to be sorted by score. Which AWS service should the engineer use?
A.Amazon RDS for PostgreSQL with an index on score
B.Amazon DynamoDB with a global secondary index on score
C.Amazon ElastiCache for Redis with a sorted set
D.Amazon Neptune with a graph model
AnswerC
Redis sorted sets provide O(log N) operations and sub-millisecond latency.
Why this answer
Amazon ElastiCache for Redis provides a sorted set data structure (ZADD/ZRANGE commands) that maintains elements ordered by a numeric score with O(log N) complexity for both writes and reads, enabling sub-millisecond latency for real-time leaderboard updates and queries. This is the only option purpose-built for in-memory, sorted, real-time leaderboards at scale.
Exam trap
The trap here is that candidates often choose DynamoDB (Option B) because it is a common NoSQL choice for high-performance applications, but they overlook that DynamoDB lacks a native sorted data structure and requires costly scan operations to retrieve a globally sorted leaderboard, whereas Redis sorted sets are purpose-built for this exact use case.
How to eliminate wrong answers
Option A is wrong because Amazon RDS for PostgreSQL, even with an index on score, is a disk-based relational database that cannot guarantee sub-millisecond read/write latency under high concurrency due to disk I/O and transaction overhead. Option B is wrong because Amazon DynamoDB with a global secondary index on score does not natively maintain a globally sorted order; it requires expensive scan operations to retrieve the top scores, and write latency can exceed sub-millisecond under heavy load due to throughput limits and index propagation. Option D is wrong because Amazon Neptune is a graph database designed for traversing relationships, not for sorted, real-time score retrieval, and its query latency is not optimized for sub-millisecond leaderboard operations.
Which THREE steps are recommended for migrating an on-premises Oracle database to Amazon RDS for Oracle with minimal downtime? (Choose 3.)
Select 3 answers
A.Set up a VPN or Direct Connect between on-premises and AWS
B.Disable archiving on the source database
C.Use AWS Schema Conversion Tool (SCT) to convert the schema
D.Perform a full load migration without change data capture
E.Use AWS Database Migration Service (DMS) for ongoing replication
AnswersA, C, E
Secure connectivity is essential.
Why this answer
Establishing a VPN or Direct Connect provides a secure, private, and low-latency network connection between the on-premises environment and AWS. This is essential for minimizing downtime during a migration, as it ensures reliable and fast data transfer for both the initial full load and ongoing replication, reducing the risk of network interruptions that could extend the migration window.
Exam trap
The trap here is that candidates often think disabling archiving simplifies the migration, but they miss that CDC requires archived logs for minimal downtime, and they may also assume a full load alone is sufficient without realizing it forces a longer outage to ensure data consistency.
A data engineer is setting up Amazon S3 bucket policies for a data lake. The security team requires that all objects uploaded to the bucket be encrypted at rest using server-side encryption. Which TWO methods can enforce encryption at upload time?
Select 2 answers
A.Enable S3 Transfer Acceleration.
B.Enable AWS CloudTrail to monitor uploads.
C.Enable AWS KMS automatic key rotation.
D.Enable S3 default encryption on the bucket.
E.Create a bucket policy that denies PutObject if the x-amz-server-side-encryption header is missing.
Enabling S3 default encryption on the bucket automatically applies server-side encryption (SSE-S3 or SSE-KMS) to all objects uploaded without an encryption header, ensuring encryption at rest. Option E is correct because a bucket policy with a Deny effect on PutObject when the x-amz-server-side-encryption header is missing enforces encryption at upload time by rejecting unencrypted uploads, providing a complementary enforcement mechanism.
Exam trap
The trap here is that candidates often confuse default encryption (which applies encryption automatically but does not block unencrypted uploads) with a bucket policy that explicitly denies unencrypted uploads, thinking either alone is sufficient, when both are needed for full enforcement.
A data engineer applies the bucket policy shown in the exhibit to an S3 bucket. The bucket contains sensitive data that must be encrypted at rest and accessed only over HTTPS. Which of the following statements is true?
B.The policy allows anonymous access to list objects in the bucket.
C.The policy enforces that all PutObject requests must include the x-amz-server-side-encryption header with value AES256.
D.The policy requires the use of AWS KMS for server-side encryption.
AnswerC
The Allow statement requires the condition s3:x-amz-server-side-encryption equals AES256 for PutObject.
Why this answer
The bucket policy includes a condition that denies PutObject requests unless the `s3:x-amz-server-side-encryption` header is present and set to `AES256`. This enforces server-side encryption with S3-managed keys (SSE-S3) for all uploads, ensuring data at rest is encrypted.
Exam trap
AWS often tests the distinction between SSE-S3 (`AES256`) and SSE-KMS (`aws:kms`) in bucket policy conditions, and candidates may mistakenly think the policy requires KMS when it actually specifies AES256.
How to eliminate wrong answers
Option A is wrong because the policy includes a `Deny` statement that blocks requests when `aws:SecureTransport` is `false`, which effectively denies HTTP access and allows only HTTPS. Option B is wrong because the policy does not grant any `s3:ListBucket` permission to anonymous principals; it only denies requests that fail encryption or transport conditions, but does not allow anonymous listing. Option D is wrong because the policy requires the `x-amz-server-side-encryption` header with value `AES256`, which corresponds to SSE-S3, not AWS KMS (which would require `aws:kms`).
A company is migrating its on-premises PostgreSQL database to Amazon RDS for PostgreSQL. The database is 5 TB in size and supports a critical application that requires less than 30 minutes of downtime. The company has a 1 Gbps network connection to AWS. The data engineering team plans to use AWS Database Migration Service (DMS) with change data capture (CDC) to keep the target in sync. During the full load phase, DMS is taking longer than expected, and the team is concerned about meeting the downtime window. Which action should the team take to speed up the full load?
A.Increase the compute capacity of the target RDS instance.
B.Enable DMS validation to ensure data integrity.
C.Use AWS Snowball Edge to transfer the data offline.
D.Create multiple DMS tasks to load different tables in parallel.
AnswerD
Parallel tasks increase throughput.
Why this answer
Creating multiple DMS tasks to load different tables in parallel (Option D) is the correct action because DMS performs full load sequentially within a single task. By splitting tables across multiple tasks, the team can parallelize the data transfer, utilizing the 1 Gbps network more efficiently and reducing the overall full load time to meet the 30-minute downtime window.
Exam trap
The trap here is that candidates assume increasing target instance size (Option A) will speed up the full load, but they overlook that DMS's single-task architecture is the primary bottleneck, not the target's write capacity.
How to eliminate wrong answers
Option A is wrong because increasing the compute capacity of the target RDS instance does not address the bottleneck of DMS's sequential full load process; the target can ingest data faster, but DMS still processes tables one at a time. Option B is wrong because enabling DMS validation adds overhead by comparing source and target records, which would slow down the full load further, not speed it up. Option C is wrong because AWS Snowball Edge is designed for offline data transfer over multiple days, not for a migration requiring less than 30 minutes of downtime; the 1 Gbps network connection is sufficient if parallelism is used.
A data engineer needs to store semi-structured JSON logs from an application for up to 30 days, with infrequent access. Which storage solution is the most cost-effective?
A.Amazon S3 Glacier Deep Archive
B.Amazon S3 One Zone-Infrequent Access (S3 One Zone-IA)
Cost-effective for infrequently accessed data with rapid access needs.
Why this answer
Amazon S3 Standard-Infrequent Access (S3 Standard-IA) is the most cost-effective choice for storing semi-structured JSON logs for up to 30 days with infrequent access. It offers low storage cost (compared to S3 Standard) while providing low-latency retrieval and high durability (99.999999999%) across multiple Availability Zones, making it ideal for data that is accessed less frequently but needs immediate availability when requested.
Exam trap
The trap here is that candidates often choose S3 One Zone-IA (Option B) thinking it is cheaper due to single-AZ storage, but they overlook the durability and availability requirements for logs that may need to be recovered from an AZ failure, and the fact that S3 Standard-IA is actually more cost-effective for this 30-day retention scenario when considering retrieval costs and minimum storage charges.
How to eliminate wrong answers
Option A is wrong because Amazon S3 Glacier Deep Archive is designed for long-term archival (retrieval times of 12-48 hours) and has a minimum storage duration of 180 days, making it unsuitable for a 30-day retention period with infrequent but potentially immediate access needs. Option B is wrong because Amazon S3 One Zone-Infrequent Access stores data in a single Availability Zone, which does not provide the multi-AZ durability required for logs that may need to be recovered from failures; it is also not the most cost-effective for this use case due to its higher retrieval costs and lower resilience. Option C is wrong because Amazon S3 Standard is optimized for frequently accessed data with higher storage costs per GB, making it overpriced for logs that are accessed infrequently over a 30-day period.
A company stores its application logs in an Amazon S3 bucket. The logs are accessed frequently for the first 30 days, after which they are rarely accessed but must be retained for 7 years for compliance. The company wants to optimize storage costs while maintaining immediate retrieval availability for the first 30 days and the ability to retrieve logs within 12 hours after that. Which lifecycle policy should the data engineer configure?
A.Delete objects after 30 days to minimize storage costs.
B.Transition objects to S3 Standard-IA after 30 days and then to S3 Glacier Deep Archive after 1 year.
C.Transition objects to S3 One Zone-IA after 30 days and delete after 7 years.
D.Transition objects to S3 Glacier Flexible Retrieval after 30 days and delete after 7 years.
AnswerB
Standard-IA provides immediate retrieval for the first 30 days, then Deep Archive for cost-effective long-term retention.
Why this answer
It uses S3 Standard-IA for the first 30 days (frequent access, immediate retrieval) and then transitions to S3 Glacier Deep Archive after 1 year, which provides retrieval within 12 hours at the lowest cost for long-term retention. This meets the compliance requirement of 7-year retention while optimizing costs by moving data to progressively cheaper storage classes based on access patterns.
Exam trap
The DEA-C01 exam often tests the misconception that S3 Glacier Flexible Retrieval is the cheapest option for long-term archival, but S3 Glacier Deep Archive is significantly cheaper for data that is rarely accessed and can tolerate a 12-hour retrieval time.
How to eliminate wrong answers
Option A is wrong because deleting objects after 30 days violates the 7-year compliance retention requirement. Option C is wrong because S3 One Zone-IA does not provide the durability (99.999999999% vs 99.9999999999%) or availability needed for compliance data, and it lacks the 12-hour retrieval capability required after 30 days. Option D is wrong because S3 Glacier Flexible Retrieval has a retrieval time of minutes to hours (typically 1-5 minutes for expedited, 3-5 hours for standard), but the requirement is for retrieval within 12 hours, which is met; however, transitioning directly to Glacier Flexible Retrieval after 30 days is more expensive than using Standard-IA first, and the option does not include a transition to Deep Archive for further cost optimization over 7 years.
A data engineer is migrating an on-premises PostgreSQL database to Amazon RDS for PostgreSQL. The database is 2 TB in size. The engineer needs to minimize downtime. Which AWS service should be used for the migration?
A.AWS Data Pipeline
B.AWS Database Migration Service (DMS)
C.AWS Snowball
D.Amazon S3
AnswerB
DMS supports continuous replication with minimal downtime.
Why this answer
AWS Database Migration Service (DMS) is the correct choice because it supports continuous replication (change data capture) from an on-premises PostgreSQL source to Amazon RDS for PostgreSQL, enabling near-zero downtime migration. DMS can handle a 2 TB database by using a large replication instance and tuning task settings, and it automatically converts the source schema to the target RDS engine.
Exam trap
The trap here is that candidates often choose AWS Snowball for large databases, mistakenly thinking physical transfer is faster, but they overlook that Snowball requires stopping writes to the source database during the export and shipping process, causing unacceptable downtime for a live migration.
How to eliminate wrong answers
Option A is wrong because AWS Data Pipeline is a batch-oriented workflow orchestration service for moving and transforming data between AWS services, but it does not support live, ongoing replication or schema conversion for database migrations, making it unsuitable for minimizing downtime. Option C is wrong because AWS Snowball is a physical data transfer device designed for large-scale offline data movement (e.g., petabyte-scale), but it introduces significant downtime due to shipping and manual transfer, and it cannot perform continuous replication for a live migration. Option D is wrong because Amazon S3 is an object storage service and cannot directly migrate a live PostgreSQL database to RDS; it would require an intermediate export/import process that causes extended downtime and lacks native change data capture.
C.Server-Side Encryption with S3-Managed Keys (SSE-S3)
D.IAM Policy Encryption
E.Server-Side Encryption with AWS KMS-Managed Keys (SSE-KMS)
AnswersC, E
SSE-S3 is a server-side encryption option.
Why this answer
Server-Side Encryption with S3-Managed Keys (SSE-S3) is a valid method for encrypting data at rest in Amazon S3 because it uses AES-256 encryption to automatically encrypt objects when they are written to S3 and decrypt them when accessed, with the encryption keys managed entirely by AWS. This option is correct as it directly addresses data at rest encryption within S3, requiring no client-side effort beyond setting the `x-amz-server-side-encryption` header to `AES256`.
Exam trap
The trap here is that candidates often confuse encryption in transit (SSL/TLS) or client-side encryption with data at rest encryption, or mistakenly think IAM policies can encrypt data, when only server-side encryption options (SSE-S3, SSE-KMS, SSE-C) are valid for encrypting data at rest in S3.
A company has an Amazon Redshift cluster with a mix of frequently accessed hot data and rarely accessed cold data. They want to reduce storage costs without affecting query performance for the hot data. Which strategy is MOST effective?
A.Use RA3 nodes with managed storage to automatically offload cold data to Amazon S3.
B.Reduce the number of nodes and increase the number of slices.
C.Create external tables in Redshift Spectrum to query cold data in S3.
D.Use Dense Compute nodes and unload cold data to Amazon S3 manually.
AnswerA
RA3 nodes use managed storage that automatically moves cold data to S3, reducing local storage costs.
Why this answer
RA3 nodes with managed storage automatically separate compute and storage, offloading cold data to Amazon S3 while keeping hot data on local SSD for fast queries. This reduces storage costs without manual intervention or affecting hot data performance.
Exam trap
The trap here is that candidates may choose Redshift Spectrum (Option C) thinking it automatically offloads cold data, but Spectrum requires manual external table creation and does not integrate with the cluster's automatic storage tiering.
How to eliminate wrong answers
Option B is wrong because reducing nodes and increasing slices does not address cold data storage; it changes cluster configuration without reducing storage costs for cold data. Option C is wrong because creating external tables in Redshift Spectrum allows querying cold data in S3 but does not automatically offload cold data from the cluster; it requires manual data movement and schema management. Option D is wrong because Dense Compute nodes are compute-optimized and do not support managed storage offloading; manually unloading cold data to S3 adds operational overhead and does not leverage automatic tiering.
A data engineer runs this CLI command. Which query is MOST efficient against this table?
A.Query the CustomerIndex GSI by CustomerID and OrderDate.
B.Scan the table to find all orders for a CustomerID.
C.Create a local secondary index on CustomerID.
D.Query by OrderID and filter by OrderDate.
AnswerA
The GSI is designed for this query pattern.
Why this answer
The CLI command likely created a global secondary index (GSI) named CustomerIndex on CustomerID and OrderDate. Querying this GSI directly is the most efficient because it uses the index's sort key to retrieve only the relevant items without scanning the entire table, minimizing read capacity consumption.
Exam trap
The trap here is that candidates often default to scanning or creating a local secondary index without recognizing that a GSI already exists and is purpose-built for the query pattern, leading to inefficient or invalid solutions.
How to eliminate wrong answers
Option B is wrong because scanning the entire table to find orders for a specific CustomerID is inefficient and costly, as it reads every item rather than using an index to directly locate the data. Option C is wrong because creating a local secondary index on CustomerID alone would require the table to have the same partition key as the base table (OrderID), which may not align with the query pattern, and it cannot be created after table creation if the table already exists without one. Option D is wrong because querying by OrderID and filtering by OrderDate is inefficient if OrderID is not the partition key for the query pattern; it would either require a scan or an index that supports the filter, and filtering after a query still consumes read capacity for all items returned by the query.
A company is using Amazon DynamoDB with on-demand capacity for a gaming application that experiences unpredictable traffic spikes. The application consistently sees 'ProvisionedThroughputExceededException' errors during spikes. The data engineer needs to resolve this issue without changing the application code. What should the engineer do?
A.Switch the table to on-demand capacity mode
B.Enable DynamoDB Accelerator (DAX) to cache read requests
C.Increase the read capacity units
D.Enable auto scaling for the table with a higher maximum capacity
AnswerA
On-demand mode automatically scales to handle traffic spikes without throttling.
Why this answer
The application is already using on-demand capacity, but the error 'ProvisionedThroughputExceededException' indicates the table is actually in provisioned mode, not on-demand. Switching to on-demand capacity mode eliminates throttling by automatically scaling throughput to match traffic spikes, with no code changes required.
Exam trap
The trap here is that candidates assume the table is already on-demand because the question states 'on-demand capacity,' but the error message 'ProvisionedThroughputExceededException' reveals the table is actually in provisioned mode, testing whether you recognize the mismatch between the stated configuration and the error.
How to eliminate wrong answers
Option B is wrong because DynamoDB Accelerator (DAX) only caches read requests to reduce latency and read load, but it does not resolve write throttling or provisioned throughput exceptions, and the error occurs during spikes regardless of read caching. Option C is wrong because increasing read capacity units only addresses read throughput, not write throughput, and the error is generic to both reads and writes; also, it requires manual intervention and does not handle unpredictable spikes. Option D is wrong because enabling auto scaling with a higher maximum capacity still uses provisioned mode, which can throttle during rapid spikes before scaling triggers, and the question specifies the table is already on-demand (though the error suggests it is not), so auto scaling is unnecessary and would not eliminate throttling for unpredictable traffic.
A company is using Amazon S3 to store sensitive data. They need to automatically transition objects to S3 Glacier Deep Archive after 90 days and delete them after 7 years. Which S3 lifecycle configuration action should be used?
A.Transition
B.AbortIncompleteMultipartUpload
C.Expiration
D.NoncurrentVersionExpiration
AnswerA
Transition moves objects to another storage class based on age.
Why this answer
The S3 lifecycle 'Transition' action is specifically designed to move objects between storage classes. To automatically move objects to S3 Glacier Deep Archive after 90 days, you define a transition rule with a 'Days' value of 90 and a 'StorageClass' of 'DEEP_ARCHIVE'. This action directly meets the requirement for transitioning data to a colder storage tier.
Exam trap
The trap here is that candidates often confuse 'Expiration' with 'Transition', thinking that deleting objects after a period is the same as moving them to a colder storage class, but expiration deletes data while transition preserves it in a different tier.
How to eliminate wrong answers
Option B is wrong because 'AbortIncompleteMultipartUpload' is used to abort multipart uploads that are not completed within a specified number of days; it does not transition or delete objects. Option C is wrong because 'Expiration' is used to delete objects after a specified time period, but the question requires a transition to Glacier Deep Archive after 90 days, not deletion at that point; expiration would delete the objects prematurely. Option D is wrong because 'NoncurrentVersionExpiration' is used to delete noncurrent versions of versioned objects, not to transition or delete current objects based on age.
A company uses Amazon Redshift for a data warehouse. They notice that queries are slow due to heavy data skew. Which optimization technique should be applied first?
A.Configure workload management (WLM) queues
B.Define sort keys on frequently filtered columns
C.Set an appropriate distribution style
D.Apply compression encodings to columns
AnswerC
Correct distribution style reduces data skew and improves query performance.
Why this answer
Data skew occurs when rows are distributed unevenly across Redshift slices, causing some nodes to process far more data than others. Setting an appropriate distribution style (e.g., KEY, EVEN, or ALL) redistributes the data to balance the workload, directly addressing the root cause of the slowness. This is the first optimization to apply because skew is a fundamental distribution issue that other tuning steps cannot fix.
Exam trap
The trap here is that candidates often confuse distribution skew with sort key optimization or compression, mistakenly believing that improving data organization on disk (sort keys) or reducing I/O (compression) will fix uneven data distribution across nodes.
How to eliminate wrong answers
Option A is wrong because WLM queues manage concurrency and memory allocation for query slots, not the physical distribution of data across nodes; they cannot fix performance degradation caused by data skew. Option B is wrong because sort keys optimize the order of data on disk to improve range-restricted scans and merge joins, but they do not redistribute data or alleviate skew across slices. Option D is wrong because compression encodings reduce storage footprint and I/O by compressing column data, but they have no effect on how rows are distributed across nodes or on query parallelism.
Which THREE factors should a data engineer consider when choosing between Amazon S3 and Amazon DynamoDB for storing time-series data? (Choose three.)
Select 3 answers
A.Required query complexity (simple key lookups vs. range scans)
B.Application latency requirements
C.Cost per GB of storage
D.Data access patterns (random vs. sequential)
E.Total data volume
AnswersA, B, D
DynamoDB excels at key lookups; S3 is better for scans.
Why this answer
Amazon S3 supports range scans via its ListObjectsV2 API with prefix and delimiter parameters, but it is not optimized for complex queries like filtering on non-key attributes or aggregations. DynamoDB, on the other hand, excels at simple key lookups and range scans on its sort key, but lacks native support for complex query patterns such as multi-attribute filtering or joins. Therefore, the required query complexity directly influences the choice: S3 is better for simple prefix-based scans, while DynamoDB is better for key-value lookups and sort-key range queries.
Exam trap
The DEA-C01 exam often tests the misconception that cost per GB is a primary factor for choosing between S3 and DynamoDB for time-series data, when in reality query complexity, latency, and access patterns are far more decisive due to the fundamentally different data models (key-value vs. object storage).
A company uses Amazon Redshift for its data warehouse. The data engineer notices that queries are running slower than expected. The system administrator reports that the cluster's disk space is 80% full. Which action should the engineer take to improve query performance?
A.Redesign the sort keys to optimize query performance.
B.Run the VACUUM command to reclaim space.
C.Add more nodes to the cluster to increase storage and compute capacity.
D.Enable concurrency scaling to handle more queries.
AnswerC
Adding nodes increases both storage and compute, improving performance.
Why this answer
When a Redshift cluster's disk space is 80% full, query performance degrades because Redshift relies on large sequential I/O operations, and high disk utilization forces more random I/O and increases the likelihood of spilling to disk. Adding nodes increases both storage capacity and compute resources, directly alleviating the I/O bottleneck and improving query throughput. This is the recommended scaling action when disk space exceeds 70-80% utilization.
Exam trap
The trap here is that candidates often confuse the symptom (slow queries) with a need for sort key optimization or vacuuming, when the root cause is insufficient storage capacity causing I/O bottlenecks, which only adding nodes can resolve.
How to eliminate wrong answers
Option A is wrong because redesigning sort keys optimizes data distribution and pruning for specific query patterns, but it does not address the fundamental issue of insufficient storage capacity causing I/O contention. Option B is wrong because the VACUUM command reclaims space from deleted rows and sorts data, but it does not increase total disk capacity; with 80% disk full, vacuuming may only recover a small amount of space and will not resolve the performance degradation caused by high disk utilization. Option D is wrong because concurrency scaling adds transient compute capacity to handle increased query concurrency, but it does not increase the primary cluster's storage or reduce disk space pressure; performance issues from disk fullness persist even with concurrency scaling enabled.
A data engineer needs to store semi-structured JSON logs from AWS CloudTrail. The logs are append-only and rarely accessed after 90 days. Which storage solution is MOST cost-effective?
A.Amazon S3 Glacier Deep Archive
B.Amazon S3 Standard
C.Amazon EBS with cold HDD volumes
D.Amazon DynamoDB with on-demand capacity
AnswerA
Glacier Deep Archive offers the lowest cost for long-term archival data.
Why this answer
Amazon S3 Glacier Deep Archive is the most cost-effective storage solution for CloudTrail logs that are append-only and rarely accessed after 90 days. It offers the lowest storage cost among AWS options (approximately $0.00099 per GB/month) and is designed for data that is accessed at most once or twice per year, with retrieval times of 12–48 hours. Since the logs are rarely accessed after 90 days, the retrieval latency is acceptable, and the cost savings over S3 Standard (which costs ~$0.023 per GB/month) are substantial.
Exam trap
The trap here is that candidates may choose S3 Standard or DynamoDB because they assume CloudTrail logs need frequent querying, but the question explicitly states 'rarely accessed after 90 days,' making Glacier Deep Archive the correct cost-optimal choice despite its longer retrieval time.
How to eliminate wrong answers
Option B is wrong because Amazon S3 Standard is designed for frequently accessed data and costs significantly more than Glacier Deep Archive, making it cost-inefficient for data that is rarely accessed after 90 days. Option C is wrong because Amazon EBS with cold HDD volumes (sc1) is a block storage service intended for attached EC2 instances, not for storing append-only logs as a standalone object store; it also incurs per-GB costs and requires managing EC2 instances, leading to higher total cost and complexity. Option D is wrong because Amazon DynamoDB with on-demand capacity is a NoSQL database optimized for low-latency queries and high-frequency access, not for cost-effective archival of append-only logs; its storage cost ($0.25 per GB/month) is orders of magnitude higher than Glacier Deep Archive, and it is not designed for infrequent access patterns.
A data engineering team is managing an Amazon Redshift cluster that is used for BI reporting. The cluster has a mix of large tables (some over 1 TB) and many smaller tables. The team notices that queries on a large fact table are slow. The fact table is distributed using KEY distribution on the customer_id column, which has high cardinality. The team wants to improve query performance. They have the option to change the distribution style and sort key. Which redesign should they implement?
A.Keep the distribution style as AUTO and set the sort key to customer_id.
B.Change the distribution style to ALL and set the sort key to customer_id.
C.Change the distribution style to KEY on a different column with high cardinality.
D.Change the distribution style to EVEN and set the sort key to a date column used in WHERE clauses.
AnswerD
EVEN distributes evenly; sort key on date improves query performance.
Why this answer
Using EVEN distribution ensures data is evenly distributed across all nodes, avoiding data skew that can occur with KEY distribution on a high-cardinality column like customer_id. Setting the sort key to a date column used in WHERE clauses enables range-restricted scans, significantly reducing the amount of data scanned for common BI queries that filter by date. This combination improves query performance by maximizing parallelism and minimizing I/O.
Exam trap
The trap here is that candidates often assume KEY distribution on a high-cardinality column is optimal for large tables, but they overlook that even high-cardinality keys can cause severe data skew if the distribution key values are not uniformly distributed across nodes, leading to poor query performance.
How to eliminate wrong answers
Option A is wrong because AUTO distribution may default to KEY on customer_id, which already causes data skew and slow performance, and setting the sort key to customer_id does not address the distribution imbalance. Option B is wrong because ALL distribution copies the entire table to every node, which is impractical for a 1 TB fact table due to excessive storage and maintenance overhead, and it does not improve scan efficiency for large tables. Option C is wrong because changing the KEY distribution to a different high-cardinality column does not guarantee even distribution and may still lead to skew; the core issue is that KEY distribution on a high-cardinality column does not inherently balance data across slices.
A data engineer needs to transfer 10 TB of data from an on-premises Hadoop cluster to Amazon S3. The network bandwidth is limited to 100 Mbps, and the transfer must be completed within 48 hours. Which solution meets the requirements?
A.Use AWS DataSync to transfer data online
B.Use AWS Snowball Edge device to transfer data offline
C.Use S3 Transfer Acceleration over the internet
D.Set up AWS Direct Connect to increase bandwidth
AnswerB
Snowball Edge can transfer 10 TB offline within days.
Why this answer
The on-premises Hadoop cluster has 10 TB of data to transfer, but the network bandwidth is only 100 Mbps. At 100 Mbps, the theoretical maximum transfer rate is about 12.5 MB/s, which would take approximately 10 TB / 12.5 MB/s ≈ 800,000 seconds ≈ 222 hours — far exceeding the 48-hour window. AWS Snowball Edge is an offline, physical device that bypasses network constraints entirely, allowing you to transfer the data by shipping the device, which completes within days regardless of bandwidth.
Exam trap
The trap here is that candidates may assume S3 Transfer Acceleration or Direct Connect can magically overcome a hard bandwidth cap, but neither increases the last-mile bandwidth; the only way to transfer 10 TB in under 48 hours with a 100 Mbps link is to use an offline physical device like Snowball Edge.
How to eliminate wrong answers
Option A is wrong because AWS DataSync is an online data transfer service that still relies on network bandwidth; at 100 Mbps, it cannot transfer 10 TB within 48 hours due to the same bandwidth limitation. Option C is wrong because S3 Transfer Acceleration only optimizes routing over the internet using AWS edge locations, but it does not increase the underlying 100 Mbps bandwidth; the transfer would still take far longer than 48 hours. Option D is wrong because AWS Direct Connect provides a dedicated network connection, but it does not inherently increase bandwidth beyond the 100 Mbps limit unless you provision a higher-capacity circuit, which is not specified and would still require time to set up; the question assumes the bandwidth is fixed at 100 Mbps.
Which THREE of the following are benefits of using Amazon DynamoDB Accelerator (DAX)? (Choose three.)
Select 3 answers
A.Offloads read traffic from the DynamoDB table.
B.Improves write throughput by batching writes.
C.Reduces read latency from single-digit milliseconds to microseconds.
D.Supports write-through caching to improve write performance.
E.Provides in-memory caching for DynamoDB tables.
AnswersA, C, E
DAX handles read requests, reducing load on the table.
Why this answer
DAX acts as a read-through cache that offloads read traffic from the DynamoDB table, reducing the number of read requests that hit the underlying table and thus lowering the consumed read capacity units (RCUs). This allows the table to handle more concurrent reads without scaling up provisioned capacity.
Exam trap
The trap here is that candidates often assume DAX improves write performance or supports write-through caching, but DAX is strictly a read cache and does not accelerate or batch writes.
A company wants to migrate its on-premises MySQL database to Amazon RDS for MySQL with minimal downtime. Which AWS service should be used for the migration?
A.AWS Database Migration Service (DMS)
B.AWS Schema Conversion Tool (SCT)
C.AWS DataSync
D.AWS Direct Connect
AnswerA
Supports minimal downtime via ongoing replication.
Why this answer
AWS Database Migration Service (DMS) is purpose-built for migrating databases to AWS with minimal downtime by using ongoing replication (change data capture, CDC) from the source MySQL database to the target Amazon RDS for MySQL instance. This allows the source to remain fully operational during the migration, meeting the minimal-downtime requirement.
Exam trap
The trap here is that candidates confuse AWS DMS with AWS DataSync or SCT, assuming any data transfer tool works for database migration, but DMS is the only service that supports ongoing replication for minimal downtime database migrations.
How to eliminate wrong answers
Option B (AWS Schema Conversion Tool) is wrong because SCT is used for converting database schemas from one engine to another (e.g., Oracle to Aurora), not for migrating data with minimal downtime; it does not handle ongoing replication. Option C (AWS DataSync) is wrong because DataSync is designed for moving large volumes of file data (e.g., NFS, SMB) to Amazon S3 or EFS, not for database migrations or CDC replication. Option D (AWS Direct Connect) is wrong because Direct Connect establishes a dedicated network connection between on-premises and AWS, but it is a connectivity service, not a migration tool; it does not perform data migration or replication.
A data engineer is migrating an on-premises Apache HBase workload to Amazon DynamoDB. The HBase table has a row key with composite structure: customer_id (10 chars) + timestamp (10 digits). The access pattern is to query by customer_id and retrieve the latest entries. How should the DynamoDB table be designed to optimize performance?
A.Create a table with partition key = customer_id and sort key = timestamp.
B.Use Amazon S3 with customer_id as prefix and timestamp as object name.
C.Create a table with partition key = concatenated customer_id and timestamp.
D.Create a table with partition key = timestamp and sort key = customer_id.
AnswerA
Allows querying by customer_id and sorting by timestamp to get latest entries.
Why this answer
DynamoDB's partition key (customer_id) evenly distributes data across partitions, while the sort key (timestamp) enables efficient range queries using Query with ScanIndexForward=false to retrieve the latest entries. This design directly maps the HBase composite row key pattern to DynamoDB's primary key structure, optimizing for the described access pattern.
Exam trap
The trap here is that candidates may think concatenating the row key into a single partition key (Option C) preserves the query pattern, but DynamoDB requires the partition key to be known exactly for queries, making it impossible to query by customer_id alone without a full scan.
How to eliminate wrong answers
Option B is wrong because Amazon S3 is an object store, not a low-latency NoSQL database; it lacks native support for range queries and cannot efficiently retrieve the latest entries by timestamp without scanning all objects. Option C is wrong because using a concatenated partition key (customer_id + timestamp) prevents querying by customer_id alone, as DynamoDB requires the exact partition key value for queries, forcing a full scan. Option D is wrong because using timestamp as the partition key leads to hot partitions (e.g., all writes for the same second hit one partition) and does not allow efficient retrieval by customer_id without a scan.
Refer to the exhibit. A data engineer is troubleshooting an IAM policy attached to a user. The user reports that they cannot upload objects to the S3 bucket 'data-lake-bucket' unless they explicitly specify the 'x-amz-server-side-encryption' header with value 'AES256'. The engineer wants to modify the policy to allow uploads without requiring encryption headers, but still enforce encryption on the bucket itself. Which change should the engineer make?
A.Remove the entire Deny statement.
B.Remove the Condition block from the Allow statement.
C.Change the Condition in the Allow statement to use aws:kms instead of AES256.
D.Set the bucket's default encryption to AES256 and keep the policy unchanged.
AnswerA
Removing the Deny allows uploads without encryption header; bucket default encryption can be used.
Why this answer
Removing the Deny statement eliminates the explicit denial that blocks uploads without the 'x-amz-server-side-encryption' header set to 'AES256'. The Allow statement already grants s3:PutObject, and by removing the Deny, users can upload without specifying encryption headers. The bucket's default encryption setting (e.g., AES256) will then automatically encrypt objects at rest, enforcing encryption without requiring the header in the request.
Exam trap
The DEA-C01 exam often tests the misconception that bucket default encryption can override an IAM Deny statement, but in reality, an explicit Deny always takes precedence regardless of bucket settings.
How to eliminate wrong answers
Option B is wrong because removing the Condition block from the Allow statement would still leave the Deny statement in place, which explicitly denies uploads without the required encryption header; the Deny overrides any Allow. Option C is wrong because changing the Condition to 'aws:kms' would require the header to specify 'aws:kms' instead of 'AES256', still mandating an encryption header and not resolving the user's issue. Option D is wrong because setting the bucket's default encryption to AES256 does not override the explicit Deny statement; the Deny still blocks uploads that lack the required header, even if the bucket would apply encryption automatically.
A company is using Amazon Redshift for analytics. The cluster has 20 nodes and the data is evenly distributed. Query performance has degraded over time. The data engineer suspects that table maintenance is needed. Which set of operations should be performed to improve query performance?
A.Run VACUUM and ANALYZE commands on all tables
B.Run VACUUM FULL on all tables
C.Run REINDEX on all tables
D.Run ALTER TABLE APPEND to reorganize data
AnswerA
VACUUM reclaims space and sorts rows; ANALYZE updates statistics for the optimizer.
Why this answer
Over time, Amazon Redshift tables accumulate deleted rows and unsorted data due to UPDATE and DELETE operations, which degrades query performance. Running VACUUM reclaims space and re-sorts data according to the table's sort key, while ANALYZE updates table statistics used by the query optimizer. Together, these operations restore data layout and enable efficient query planning, directly addressing the performance degradation.
Exam trap
The trap here is that candidates familiar with PostgreSQL may mistakenly apply PostgreSQL-specific maintenance commands like VACUUM FULL or REINDEX, not realizing that Amazon Redshift is based on a different architecture (columnar storage, no indexes) and only supports VACUUM and ANALYZE for table maintenance.
How to eliminate wrong answers
Option B is wrong because VACUUM FULL is a PostgreSQL command that is not supported in Amazon Redshift; Redshift only offers VACUUM (standard) and VACUUM DELETE ONLY, and FULL is not a valid option. Option C is wrong because REINDEX is a PostgreSQL command for rebuilding indexes, but Amazon Redshift does not use traditional indexes; it uses sort keys and distribution keys, so REINDEX has no effect. Option D is wrong because ALTER TABLE APPEND is used to move data between tables efficiently by remapping blocks, not to reorganize or maintain existing tables; it does not reclaim space or update statistics.
A company runs an Amazon RDS for PostgreSQL database. To meet disaster recovery requirements, they set up a cross-Region read replica. The replica has been lagging by several minutes. Which action is MOST effective to reduce the replica lag?
A.Enable Multi-AZ on the primary database.
B.Increase the instance size (memory and CPU) of the replica.
C.Increase the instance size of the primary database.
D.Decrease the instance size of the replica to reduce cost.
AnswerB
A larger replica can apply changes faster.
Why this answer
Increasing the instance size (memory and CPU) of the cross-Region read replica is the most effective action because replica lag in Amazon RDS for PostgreSQL is often caused by the replica being unable to keep up with the volume of write-ahead log (WAL) data arriving from the primary. A larger replica instance provides more compute and memory resources to apply WAL changes faster, reducing the replay lag. This directly addresses the bottleneck at the replica side without impacting the primary database.
Exam trap
The trap here is that candidates often assume the primary database is the bottleneck and choose to scale it up, but the lag is caused by the replica's inability to apply changes quickly enough, making the replica's instance size the correct lever to adjust.
How to eliminate wrong answers
Option A is wrong because enabling Multi-AZ on the primary database provides high availability within a single Region but does not reduce cross-Region replica lag; it may even increase lag due to synchronous replication overhead on the primary. Option C is wrong because increasing the instance size of the primary database improves its write performance but does not help the replica apply WAL data faster; the bottleneck is on the replica side, not the primary. Option D is wrong because decreasing the instance size of the replica would reduce its CPU and memory resources, worsening the replica lag by making it even harder to keep up with WAL replay.