Courseiva

AWS Certified Data Engineer Associate DEA-C01 (DEA-C01) — Questions 751–825

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

Take a mock examExam hub
Page 10

Page 11 of 23

Page 12
751
MCQhard

A company runs an e-commerce platform that generates clickstream data from user interactions on their website. The data is sent as JSON objects via HTTP POST to an API Gateway endpoint, which triggers a Lambda function that writes each record to a Kinesis Data Stream (100 shards). A second Lambda function consumes the stream, transforms the data (enriches with geolocation from a DynamoDB table), and writes to a Kinesis Data Firehose delivery stream that delivers Parquet files to an S3 data lake every 5 minutes. The system has been working for months, but recently the Firehose delivery stream started showing 'DeliveryFailed' errors for a subset of records. The errors point to 'InvalidData' from the Lambda transformation. The engineer reviews the Lambda transformation code and notices that the geolocation lookup occasionally fails because the DynamoDB table has a throttling issue. The engineer needs to handle these failures gracefully so that records that fail enrichment are still delivered to S3 with a null geolocation field, without blocking other records. Which course of action should the engineer take?

A.Configure the Kinesis Data Firehose delivery stream to send failed records to a dead-letter queue (DLQ) for later reprocessing.
B.Modify the Lambda function to send failed records to a separate Kinesis Data Stream for manual processing.
C.Modify the Lambda function to catch exceptions during the geolocation lookup, set the geolocation field to null, and continue processing the record.
D.Increase the read capacity units (RCUs) on the DynamoDB table to eliminate throttling.
AnswerC

This ensures all records are delivered with a default value, maintaining pipeline throughput.

Why this answer

It modifies the Lambda function to catch exceptions during the geolocation lookup, set the geolocation field to null, and continue processing. This ensures that records that fail enrichment are still delivered to S3 with a null geolocation field, without blocking other records, and without requiring additional infrastructure. Option A is incorrect because Kinesis Data Firehose does not natively support a dead-letter queue (DLQ); failed records can be sent to an S3 bucket for failed data, but that would not include the transformed data with null geolocation.

Option B is incorrect because sending failed records to a separate Kinesis Data Stream adds complexity and does not ensure they are delivered to S3 with the desired null geolocation field. Option D is incorrect because increasing RCUs may reduce throttling but does not eliminate the possibility of failures, and it increases cost; the requirement is to handle failures gracefully, not prevent them entirely.

Full explanation →
752
Multi-Selecthard

A company stores sensitive customer data in an Amazon S3 bucket. The security team requires that all data be encrypted at rest using server-side encryption with AWS KMS managed keys (SSE-KMS). Additionally, they want to ensure that the encryption context is enforced for all PutObject requests. Which THREE steps should be taken to meet these requirements?

Select 3 answers
A.Set the default encryption on the bucket to SSE-KMS with the desired KMS key.
B.Add a bucket policy that requires the s3:x-amz-server-side-encryption-aws-kms-key-id header and the kms:EncryptionContext condition.
C.Configure the bucket to use SSE-C and provide the encryption key.
D.Enable S3 Versioning on the bucket.
E.Create an IAM role that includes kms:GenerateDataKey and kms:Decrypt permissions for the KMS key.
AnswersA, B, E

Correct. Setting default encryption to SSE-KMS ensures new objects are encrypted with the specified KMS key if no encryption header is provided.

Why this answer

To enforce SSE-KMS and encryption context, three steps are needed. First, set default encryption on the bucket to SSE-KMS with the desired KMS key (A). Second, add a bucket policy that requires the s3:x-amz-server-side-encryption-aws-kms-key-id header and the kms:EncryptionContext condition key (B).

Third, ensure the IAM role used by applications has kms:GenerateDataKey and kms:Decrypt permissions for the KMS key (E). Option C (SSE-C) is incorrect because it uses a customer-provided key, not KMS. Option D (versioning) does not enforce encryption context.

Exam trap

Candidates might think that SSE-C is required to enforce encryption context, but encryption context can be enforced through a bucket policy condition with kms:EncryptionContext even with SSE-KMS.

Full explanation →
753
MCQhard

A company uses DynamoDB with global tables in two AWS Regions. The data engineer observes that a write to the table in us-east-1 is not immediately visible in a read from eu-west-1. What is the most likely reason?

A.Replication between regions is eventually consistent.
B.The read is using strongly consistent reads.
C.There is a write conflict that needs to be resolved.
D.DynamoDB Streams is not enabled on the table.
AnswerA

Global tables replicate asynchronously, so there is a propagation delay.

Why this answer

DynamoDB global tables use asynchronous replication between regions. When a write occurs in us-east-1, the change is propagated to eu-west-1 with a replication lag that is typically sub-second but not instantaneous. Reads in eu-west-1 are eventually consistent by default, meaning they may not reflect the most recent write until replication completes.

This is the expected behavior of DynamoDB global tables, which prioritize availability and partition tolerance over immediate consistency across regions.

Exam trap

The trap here is that candidates often assume DynamoDB global tables provide strong consistency across regions because they are familiar with single-region strongly consistent reads, but the exam tests the specific knowledge that cross-region replication is always eventually consistent and that strongly consistent reads are only valid within the same region.

How to eliminate wrong answers

Option B is wrong because strongly consistent reads would actually increase the chance of seeing stale data in a cross-region scenario, as they are only guaranteed to return the most recent write within the same region, not across regions; DynamoDB does not support cross-region strongly consistent reads. Option C is wrong because write conflicts in global tables are automatically resolved using a last-writer-wins algorithm based on the timestamp, and they do not cause writes to be invisible; a conflict would result in one write being overwritten, not a delay in visibility. Option D is wrong because DynamoDB Streams is not required for global table replication; global tables use their own internal replication mechanism, and enabling Streams is optional for change data capture or triggering Lambda functions, not for the core replication functionality.

Full explanation →
754
MCQhard

A company uses Amazon Redshift for analytics. A data engineer notices that queries are slow due to high disk usage on the compute nodes. The engineer needs to reclaim disk space without interrupting ongoing queries. Which action should the engineer take?

A.Use the COPY command to reload data
B.Run VACUUM FULL on all tables
C.Run VACUUM DELETE to reclaim space from deleted rows
D.Resize the cluster to a larger instance type
AnswerC

VACUUM DELETE reclaims space without exclusive locks and can run concurrently.

Why this answer

VACUUM DELETE specifically reclaims disk space from deleted rows without requiring an exclusive table lock, allowing ongoing queries to continue. In Amazon Redshift, deleted rows consume disk space until reclaimed, and VACUUM DELETE operates in the background to free that space while maintaining query concurrency.

Exam trap

The trap here is that candidates confuse VACUUM FULL with VACUUM DELETE, assuming any VACUUM operation reclaims space without considering the lock requirement and interruption to queries.

How to eliminate wrong answers

Option A is wrong because the COPY command loads data into Redshift but does not reclaim disk space; it only adds new data, potentially worsening disk usage. Option B is wrong because VACUUM FULL reclaims space and resorts rows but requires an exclusive table lock, which interrupts ongoing queries and is not suitable for a no-interruption requirement. Option D is wrong because resizing the cluster to a larger instance type adds more storage capacity but does not reclaim existing disk space; it also involves a temporary interruption during the resize process.

Full explanation →
755
MCQeasy

A data engineer needs to ingest daily CSV files from an external FTP server into Amazon S3. The files are 5 GB each. Which service is MOST suitable to automate this ingestion?

A.AWS AppSync
B.AWS DataSync
C.Amazon S3 Transfer Acceleration
D.AWS Glue
AnswerB

DataSync supports scheduled transfers from FTP servers to S3 with built-in monitoring.

Why this answer

AWS DataSync is the most suitable service for automated, scheduled transfers of large files from an external FTP server to Amazon S3. It supports both one-time and recurring transfers and can handle high throughput for files up to 5 GB. S3 Transfer Acceleration only speeds up uploads to S3, not transfers from FTP servers.

AWS Glue is an ETL service, not a file transfer tool. AWS AppSync is for real-time APIs, not batch file ingestion.

Full explanation →
756
MCQmedium

Refer to the exhibit. A data engineer is using a Kinesis Data Stream with one shard. The application writes 2000 records per second, each 1 KB. The put record calls are frequently throttled. What is the most likely cause?

A.The stream has only one shard, which limits writes to 1000 records per second
B.The retention period of 24 hours is too short
C.The stream uses KMS encryption, causing additional latency
D.Enhanced monitoring is not enabled, causing performance issues
AnswerA

Each shard supports 1000 records/sec write.

Why this answer

A Kinesis Data Stream shard has a write throughput limit of 1,000 records per second (or 1 MB per second). Since the application is writing 2,000 records per second (each 1 KB) to a single shard, it exceeds the shard's record-per-second quota, causing the PutRecord calls to be throttled. The solution is to increase the number of shards to at least two to distribute the load.

Exam trap

The DEA-C01 exam often tests the misconception that throttling is caused by encryption latency or monitoring settings, but the real trap is forgetting that each shard has a hard limit of 1,000 records per second, regardless of other configurations.

How to eliminate wrong answers

Option B is wrong because the retention period (default 24 hours, max 365 days) controls how long records are stored, not the write throughput; throttling is unrelated to retention. Option C is wrong because KMS encryption adds latency to encrypt/decrypt operations but does not reduce the shard-level write limit of 1,000 records per second; throttling is a capacity issue, not a latency issue. Option D is wrong because enhanced monitoring provides detailed metrics (e.g., user, request, stream-level) but does not affect the shard's write throughput limits; throttling occurs regardless of monitoring settings.

Full explanation →
757
MCQhard

A data engineering team uses AWS Glue Data Catalog to manage metadata for datasets in Amazon S3. The datasets contain personally identifiable information (PII). The team needs to implement column-level security so that only authorized users can access columns with PII. They use Amazon Athena for querying. The team has enabled AWS Lake Formation and defined data lake locations. They have created a Lake Formation tag called 'PII' and assigned it to the columns containing PII. They have also granted 'SELECT' permission on those columns to a specific IAM role. However, when a user assumes that role and queries the table using Athena, they can still see all columns, including the PII columns. What is the most likely cause?

A.The data in S3 is not encrypted, so Lake Formation cannot enforce column-level security.
B.The S3 bucket policy grants direct access to the IAM role, bypassing Lake Formation.
C.The IAM role does not have the necessary Lake Formation permissions; it only has IAM permissions to the S3 data.
D.The Lake Formation tag 'PII' is not properly associated with the columns.
AnswerC

Lake Formation column-level security requires that the principal has Lake Formation 'SELECT' permission on the table and columns, and that the principal does not have direct S3 access.

Why this answer

Lake Formation column-level security requires that the table be registered as a data lake location in Lake Formation and that the IAM role has Lake Formation permissions, not just IAM permissions. The IAM role might be bypassing Lake Formation if it has S3 permissions directly. Option A is wrong because the tags are applied correctly.

Option B is wrong because the S3 bucket policy should not allow direct access; Lake Formation should be the access point. Option D is wrong because disabling encryption would not cause this issue.

Full explanation →
758
Multi-Selecthard

A company uses Amazon Redshift for analytics. They notice that some queries are slow due to data redistribution. The data engineer wants to minimize data movement across nodes. Which table design strategy should be used? (Choose TWO.)

Select 2 answers
A.Set the distribution style to AUTO for all tables.
B.Define compound sort keys on frequently filtered columns.
C.Choose a distribution key that matches the join key for large tables.
D.Use EVEN distribution for all tables.
E.Use distribution style ALL for small dimension tables.
AnswersC, E

Matching distribution keys on joined tables keeps data co-located.

Why this answer

When large tables are joined on their distribution keys, Redshift can perform a collocated join, meaning the matching rows are already on the same node slice, eliminating the need to redistribute data across the network. This directly minimizes data movement and speeds up query execution.

Exam trap

The trap here is that candidates often confuse distribution keys with sort keys, thinking that sorting alone can reduce data movement, or they assume AUTO distribution always optimizes for joins, when in fact it may default to EVEN or ALL without guaranteeing collocation for specific join patterns.

Full explanation →
759
Drag & Dropmedium

Order the steps to set up an Amazon EMR cluster for processing data in S3 using Spark.

Drag steps to the numbered slots on the right, or tap a step then tap a slot.

Steps
Order
1Step 1
2Step 2
3Step 3
4Step 4

Why this order

First, prepare the S3 bucket. Then launch the EMR cluster with Spark, configure instances, submit the job, and terminate.

Full explanation →
760
Multi-Selecteasy

A data engineer is setting up an Amazon Redshift cluster. Which TWO measures can be taken to secure the data at rest?

Select 2 answers
A.Enable encryption on the Redshift cluster using AWS KMS
B.Encrypt data on the client side before loading into Redshift
C.Enable AWS IAM database authentication
D.Use VPC security groups to restrict network access
E.Use an HSM (Hardware Security Module) to manage encryption keys
AnswersA, E

KMS encryption protects data at rest in Redshift.

Why this answer

Redshift supports encryption at rest using KMS or HSM. Cluster encryption can be enabled at launch. Client-side encryption before loading protects data before it reaches Redshift, but not necessarily at rest.

VPC security groups control network access. IAM roles control who can access the cluster.

Full explanation →
761
MCQhard

A multinational corporation uses AWS Organizations to manage multiple accounts. The data engineering team has a central data lake account that stores all data in S3. The security team requires that all cross-account access to the data lake be logged and that any access from outside the organization be blocked. The team has enabled S3 server access logs and AWS CloudTrail. However, they notice that some requests from an external AWS account are still able to read data from the data lake. The bucket policy currently allows cross-account access to a specific partner account for data exchange. What additional step should the team take to block access from all other external accounts?

A.Add a condition to the existing Allow statement to require that the source account be in the organization.
B.Remove the cross-account access statement from the bucket policy.
C.Add a Deny statement to the bucket policy that denies access to any principal not in the organization or the partner account.
D.Use S3 Access Points to restrict access to only the partner account.
AnswerC

Blocks all external accounts except the partner.

Why this answer

To block access from all external accounts except the allowed partner, you can add a Deny statement with a condition that checks if the account is not in the organization and not the partner account. Option A is wrong because disabling cross-account access would block the partner. Option B is wrong because the bucket policy already allows the partner.

Option D is wrong because S3 Access Points do not inherently block external accounts unless explicitly configured.

Full explanation →
762
MCQmedium

A company uses AWS Lambda to process messages from an Amazon SQS queue. The messages contain JSON payloads that need to be transformed and written to an Amazon DynamoDB table. Recently, the Lambda function has been timing out and messages are being sent to the dead-letter queue (DLQ). What is the BEST way to troubleshoot and resolve this issue?

A.Use a standard SQS queue instead of a DLQ to reprocess failed messages automatically.
B.Increase the Lambda function timeout and monitor DynamoDB write capacity to ensure it is not throttling.
C.Switch the SQS queue to a FIFO queue to ensure exactly-once processing.
D.Increase the visibility timeout of the SQS queue to 30 minutes.
AnswerB

Increasing timeout allows longer processing; DynamoDB throttling could cause delays.

Why this answer

The Lambda function is timing out, which suggests the function's execution duration is exceeding its configured timeout. Increasing the timeout gives the function more time to process messages. Additionally, if DynamoDB write capacity is insufficient, throttling can cause retries that further delay processing, so monitoring and possibly increasing write capacity units addresses the root cause of timeouts.

Exam trap

The trap here is that candidates often focus on SQS queue configuration (visibility timeout, queue type) rather than addressing the actual performance bottleneck in the Lambda function or downstream DynamoDB service.

How to eliminate wrong answers

Option A is wrong because using a standard SQS queue instead of a DLQ does not automatically reprocess failed messages; it only changes the queue type and does not address the underlying timeout or throttling issue. Option C is wrong because switching to a FIFO queue enforces exactly-once processing and message ordering, but it does not resolve timeouts or DynamoDB throttling; it could even introduce additional latency. Option D is wrong because increasing the visibility timeout to 30 minutes only delays when a message becomes visible again after a failure, but it does not fix the root cause of timeouts or throttling; it may mask the problem.

Full explanation →
763
MCQhard

A data engineer is troubleshooting an AWS Glue job that writes data to an Amazon S3 bucket in Parquet format. The job runs successfully but the output files are smaller than the configured 'groupFiles' size. The engineer has set 'groupFiles' to 'inPartition' and 'groupSize' to 1 GB. The input data is 10 GB in a single partition. What is the most likely reason for the small files?

A.The 'groupFiles' parameter is deprecated in the current Glue version.
B.The 'groupFiles' parameter only affects the input read phase, not the output write phase.
C.The 'groupFiles' parameter is misspelled or set incorrectly.
D.The engineer must also set 'repartition' to 1 to merge output files.
AnswerB

Grouping coalesces small input files during reading but does not control output file size.

Why this answer

'groupFiles' only works when the input data is already small and needs to be coalesced. However, if the input is large and the job writes output, the output file size is determined by the number of Spark partitions, not grouping. The grouping feature only applies to reading input files.

Option A is wrong because the setting is correct. Option C is wrong because grouping is a read-time feature, not write-time. Option D is wrong because grouping does not require repartitioning.

Full explanation →
764
MCQeasy

The command returns an empty result, but you know there are objects in the 'logs/' prefix larger than 1000 bytes. What is the MOST likely reason?

A.The prefix 'logs/' is incorrect; the objects are in a different prefix.
B.The comparison 'Size > '1000'' uses a string instead of a number, so it never matches.
C.The command does not paginate, so it only checks the first 1000 objects.
D.The output format is set to text, but the query requires JSON.
AnswerB

Size is a numeric field; comparing to a string causes the filter to be false.

Why this answer

The `Size > '1000'` comparison treats `'1000'` as a string literal rather than a numeric value. In AWS CLI commands like `list-objects-v2` combined with JMESPath queries, numeric comparisons require unquoted numbers; a quoted string will never match a numeric field, resulting in an empty result even when objects larger than 1000 bytes exist.

Exam trap

The DEA-C01 exam often tests the subtle distinction between string and numeric comparisons in JMESPath queries, where candidates mistakenly assume that quoted numbers are automatically coerced to integers.

How to eliminate wrong answers

Option A is wrong because the question states you know objects exist in the 'logs/' prefix, so an incorrect prefix would contradict that given knowledge. Option C is wrong because the AWS S3 `list-objects-v2` command paginates by default (up to 1000 objects per page) and will continue to fetch all objects across pages unless `--max-items` is explicitly set; the empty result is not due to pagination limits. Option D is wrong because the output format (text vs.

JSON) does not affect the query logic; the JMESPath filter operates on the JSON response internally, and text output simply formats the result differently.

Full explanation →
765
MCQmedium

A company is migrating its on-premises Oracle database to Amazon Aurora PostgreSQL. The migration must have minimal downtime. The source database is 2 TB and runs on a single server. Which AWS service should be used for the migration?

A.AWS DataSync
B.Amazon S3 Transfer Acceleration
C.AWS Database Migration Service (DMS)
D.AWS Snowball Edge
AnswerC

DMS provides minimal downtime migration with change data capture.

Why this answer

AWS Database Migration Service (DMS) is the correct choice because it supports homogeneous migrations from Oracle to Amazon Aurora PostgreSQL with minimal downtime using ongoing replication (change data capture). DMS can handle a 2 TB source database by performing a full load followed by continuous replication of changes from the Oracle redo logs, allowing the target Aurora database to stay nearly in sync until cutover.

Exam trap

The trap here is that candidates may confuse AWS DataSync or Snowball Edge as viable for database migrations because they handle large data volumes, but they lack the schema conversion and ongoing replication capabilities required for minimal-downtime database migrations.

How to eliminate wrong answers

Option A is wrong because AWS DataSync is designed for moving large datasets over the network between on-premises storage and AWS storage services (e.g., S3, EFS, FSx), not for database migrations with schema conversion and ongoing replication. Option B is wrong because Amazon S3 Transfer Acceleration only speeds up uploads to S3 buckets over the internet using optimized network paths; it does not migrate databases or handle schema conversion and CDC. Option D is wrong because AWS Snowball Edge is a physical data transfer device for offline bulk data movement, which would introduce significant downtime and cannot perform live replication or schema conversion for a database migration.

Full explanation →
766
Multi-Selecteasy

A company uses AWS Glue to run ETL jobs daily. The data engineer wants to reduce costs by optimizing the job configuration. Which two actions will help reduce costs? (Choose TWO.)

Select 2 answers
A.Use G.1X worker type instead of G.2X
B.Increase the job timeout to 48 hours
C.Enable Spark UI logging for debugging
D.Reduce the number of DPUs allocated to the job if the data volume is small
E.Increase the number of job retries to handle transient failures
AnswersA, D

G.1X is half the cost of G.2X.

Why this answer

G.1X workers provide 16 GB of memory and 4 vCPUs, while G.2X workers provide 32 GB and 8 vCPUs. For many ETL jobs, especially those with smaller data volumes or less complex transformations, G.1X workers are sufficient, and using them instead of G.2X directly reduces the cost per DPU-hour since AWS Glue pricing is based on DPU capacity. This optimization lowers costs without sacrificing performance if the job is not memory- or CPU-bound.

Exam trap

The trap here is that candidates often confuse cost optimization with reliability improvements, such as retries or timeouts, and may overlook that reducing worker size or DPU count directly lowers resource consumption and cost.

Full explanation →
767
MCQmedium

A data engineer sees the CloudWatch log entry in the exhibit for a Lambda function that processes data from an Amazon SQS queue. What is the MOST likely cause of the timeout?

A.The Lambda function's reserved concurrency is set too low.
B.The Lambda function is running out of memory.
C.The Lambda function's timeout is too short for the processing required.
D.The SQS queue's visibility timeout is set too low.
AnswerC

The function timed out at exactly the 30-second limit.

Why this answer

The CloudWatch log shows the Lambda function timed out after 30 seconds (duration 30001.23 ms), which is the default timeout. Increasing the timeout allows the function to complete its processing. Option A is incorrect because reserved concurrency affects throughput, not a single function's timeout.

Option B is incorrect because memory usage is low (64 MB out of 128 MB), so memory is not the issue. Option D is incorrect because the SQS visibility timeout controls how long a message is hidden after being picked up, but the Lambda timeout is independent.

Full explanation →
768
MCQeasy

A data engineer wants to ensure that only users with a specific tag (e.g., "Department": "DataEngineering") can access an S3 bucket. How can this be enforced?

A.Use a bucket policy with aws:PrincipalTag condition
B.Use S3 object tags and a bucket policy condition
C.Attach an IAM policy to each user with the tag
D.Use S3 Object Lambda to check user tags
AnswerA

This is correct. The 'aws:PrincipalTag' condition key in a bucket policy evaluates the tags attached to the IAM principal (user or role) making the request, allowing fine-grained access control based on those tags.

Why this answer

S3 bucket policies support condition keys like aws:PrincipalTag, which allow access control based on tags attached to IAM principals (users or roles). Option A is correct because it uses aws:PrincipalTag in the bucket policy to restrict access to users with the specific tag. Option B is incorrect because S3 object tags are for objects, not principals, and cannot be used to filter users.

Option C is incorrect because attaching an IAM policy to each user is less scalable and does not leverage the bucket policy's centralized control. Option D is incorrect because S3 Object Lambda is for modifying data during retrieval, not for access control decisions.

Exam trap

Be careful not to confuse principal tags with resource tags. The condition 'aws:PrincipalTag' checks the requester's IAM user/role tags, while 's3:ExistingObjectTag' checks tags on the S3 object itself. This question tests the distinction.

Full explanation →
769
MCQeasy

A data engineer needs to store semi-structured JSON data for a real-time analytics application. The data will be queried using SQL-like statements and must support high-speed ingestion with minimal latency. Which AWS service is best suited for this use case?

A.Amazon S3
B.Amazon Redshift
C.Amazon DynamoDB
D.Amazon Kinesis Data Analytics
AnswerD

Kinesis Data Analytics can query streaming data using SQL in real time.

Why this answer

Amazon Kinesis Data Analytics is best suited because it natively processes streaming JSON data using SQL-like statements (via Kinesis Data Analytics for SQL applications) with sub-second latency, enabling real-time analytics on semi-structured data without requiring a separate storage layer for ingestion. It directly integrates with Kinesis Data Streams or Firehose for high-speed ingestion and supports in-application queries on JSON payloads using the `json_extract` function or schema discovery.

Exam trap

The trap here is that candidates often confuse 'SQL-like queries' with traditional relational databases and pick Amazon Redshift, overlooking that Kinesis Data Analytics provides SQL-on-streaming capabilities specifically designed for real-time, semi-structured data without the batch-oriented latency of data warehouses.

How to eliminate wrong answers

Option A is wrong because Amazon S3 is an object store optimized for batch storage and retrieval, not for real-time streaming ingestion or SQL querying with low latency; querying JSON in S3 via Athena or S3 Select incurs seconds of overhead and does not support continuous, sub-second analytics. Option B is wrong because Amazon Redshift is a data warehouse designed for complex analytical queries on large, structured datasets, not for high-speed, real-time ingestion of semi-structured JSON; loading JSON into Redshift requires batch COPY commands or streaming via Kinesis Firehose with transformation, adding latency and complexity. Option C is wrong because Amazon DynamoDB is a NoSQL key-value and document database that supports JSON documents but does not natively support SQL-like queries; it uses a limited query language (PartiQL) with no support for complex analytical SQL operations like joins or aggregations, and its write capacity is constrained by provisioned throughput, making it unsuitable for high-speed ingestion with minimal latency for analytics.

Full explanation →
770
MCQhard

A company runs a data pipeline on Amazon EMR that processes terabytes of data daily. The pipeline reads from Amazon S3, performs transformations using Spark, and writes results back to S3. Recently, the data engineer noticed that the EMR cluster's spot instances are frequently reclaimed, causing job failures and delays. The cluster uses a mix of On-Demand and Spot instances. The engineer wants to minimize job interruptions while keeping costs low. The current configuration uses a single EMR cluster with a core node group of 10 On-Demand instances and a task node group of 20 Spot instances. The job failures occur during the shuffle phase when tasks on Spot instances are lost. The engineer has no control over when spot instances are reclaimed. Which action will MOST effectively reduce job failures while maintaining cost efficiency?

A.Increase the number of On-Demand instances in the core node group to 20.
B.Configure the task node group to use only Spot instances and increase the bid price to the On-Demand price.
C.Change the task node group to use only On-Demand instances.
D.Enable EMR managed scaling to automatically add On-Demand instances when Spot instances are reclaimed.
AnswerD

Managed scaling dynamically adjusts the cluster capacity, adding On-Demand instances to maintain cluster stability during Spot interruptions.

Why this answer

Enabling EMR managed scaling allows the cluster to automatically add On-Demand instances when Spot instances are reclaimed, providing dynamic capacity to prevent job failures during the shuffle phase without significantly increasing costs. Option A is incorrect because increasing On-Demand instances in the core node group does not directly address the loss of Spot task nodes and can increase costs. Option B is incorrect because increasing the bid price to the On-Demand price does not guarantee avoidance of reclaims and still relies on Spot instances.

Option C is incorrect because using only On-Demand instances would eliminate Spot savings and increase costs significantly.

Full explanation →
771
MCQhard

Refer to the exhibit. A data engineer runs the command on an object in S3. The engineer expected the object to have a tag 'type=raw' but sees no metadata. What is the likely cause?

A.Object tags are not returned by head-object; use get-object-tagging instead
B.The S3 bucket is in a different AWS Region
C.The bucket policy blocks reading tags
D.The object was created without tags because of lifecycle rules
AnswerA

Tags are separate from metadata.

Why this answer

The head-object command does not return object tags; you must use the get-object-tagging command to retrieve tags. Option B is incorrect because the head-object command succeeds regardless of region, and region does not affect tag visibility. Option C is incorrect because bucket policies can deny access but do not prevent tags from being returned by head-object; they would affect get-object-tagging instead.

Option D is incorrect because lifecycle rules do not remove tags from objects; they may transition or expire objects but do not strip metadata.

Full explanation →
772
MCQeasy

A company needs to ingest CSV files from an FTP server into Amazon S3 daily. The files are typically 50 MB each, and the process should be fully managed with minimal operational overhead. Which AWS service should be used?

A.AWS Lambda with FTP library
B.AWS DataSync
C.AWS Transfer Family
D.Amazon AppFlow
AnswerC

Managed FTP/SFTP service that writes directly to S3.

Why this answer

AWS Transfer Family is the correct choice because it provides a fully managed, serverless solution for transferring files to and from Amazon S3 using FTP, FTPS, or SFTP protocols. It eliminates the need to manage any FTP infrastructure, directly integrates with S3 as a destination, and handles the daily ingestion of 50 MB CSV files with minimal operational overhead, aligning perfectly with the requirement for a fully managed service.

Exam trap

The trap here is that candidates often confuse AWS DataSync as a general-purpose file transfer service, but it does not support FTP protocol natively and requires an agent, making it unsuitable for a fully managed FTP-to-S3 ingestion without infrastructure management.

How to eliminate wrong answers

Option A is wrong because AWS Lambda with an FTP library would require custom code, management of execution timeouts (Lambda has a 15-minute maximum), and handling of stateful FTP connections, which introduces significant operational overhead and is not fully managed. Option B is wrong because AWS DataSync is designed for high-speed, large-scale data transfers between on-premises storage and AWS, but it does not natively support the FTP protocol; it requires an agent installed on-premises and is optimized for bulk transfers, not simple daily FTP pulls. Option D is wrong because Amazon AppFlow supports data ingestion from SaaS applications (e.g., Salesforce, Slack) and AWS services, but it does not support FTP servers as a source, making it incompatible with the requirement.

Full explanation →
773
MCQhard

A data engineer is designing a data ingestion pipeline for IoT sensor data. The sensors send JSON messages every second. The data must be available in Amazon S3 within 5 minutes and must be transformed (JSON to Parquet) before storage. Which combination of services meets these requirements?

A.Amazon Kinesis Data Streams with AWS Glue streaming ETL
B.Amazon Kinesis Data Firehose with data transformation and Parquet conversion
C.Amazon Kinesis Data Analytics with output to S3
D.Amazon S3 with S3 Event Notifications to AWS Lambda for transformation
AnswerB

Firehose can transform and convert to Parquet before delivery.

Why this answer

Amazon Kinesis Data Firehose can ingest streaming data, apply a transformation (e.g., convert JSON to Parquet), and deliver the transformed data to Amazon S3 with a buffer interval of up to 60 seconds, easily meeting the 5-minute latency requirement. Option A is incorrect because AWS Glue streaming ETL adds complexity and is not necessary for simple JSON-to-Parquet conversion; Kinesis Data Firehose handles this natively. Option C is incorrect because Kinesis Data Analytics is designed for real-time analytics and does not directly output to S3 in a transformed format without additional components.

Option D is incorrect because S3 Event Notifications to Lambda would incur impractically high invocation costs and latency for per-second sensor data, and transforming on write to S3 would exceed the 5-minute window.

Full explanation →
774
MCQhard

A company uses Amazon RDS for PostgreSQL with encryption at rest using AWS KMS. The company needs to share a database snapshot with a different AWS account. What must be done to allow the target account to restore the snapshot?

A.Copy the snapshot to the target account's region and share it
B.Create an IAM role in the source account that allows cross-account snapshot access
C.Share the snapshot and update the KMS key policy to allow the target account to use the key
D.Disable encryption on the snapshot before sharing
AnswerC

The target account needs decrypt permission on the KMS key.

Why this answer

Cross-account snapshot sharing of an encrypted snapshot requires both sharing the snapshot and granting the target account permission to use the KMS key via the key policy. Option A is incorrect because copying does not grant the necessary key access. Option B is incorrect because IAM roles are not used for this purpose; KMS key policies are the mechanism for cross-account access.

Option D is incorrect because encryption cannot be disabled on an existing encrypted snapshot.

Full explanation →
775
MCQhard

A data engineer is designing a data lake on Amazon S3. The data is ingested from multiple sources in Parquet format, partitioned by date. The engineer needs to ensure that queries using Amazon Athena are cost-effective and perform well. Which approach should the engineer take?

A.Store data in uncompressed CSV format and partition by year, month, day, hour.
B.Use JSON format with Snappy compression and partition by date only.
C.Use Gzip-compressed CSV files with no partitioning.
D.Use Parquet format with Snappy compression and partition by year, month, day.
AnswerD

Parquet is columnar, reducing I/O, and partitioning limits data scanned.

Why this answer

Parquet is a columnar storage format that reduces the amount of data scanned by Athena, and Snappy compression provides a good balance between compression ratio and decompression speed. Partitioning by year, month, and day allows Athena to use partition pruning to skip irrelevant data, minimizing scanned bytes and reducing query cost.

Exam trap

The DEA-C01 exam often tests the misconception that any compression or any partitioning is sufficient, but the trap here is that row-based formats (CSV, JSON) and non-hierarchical partitioning fail to optimize Athena’s columnar scan and partition pruning capabilities, leading to higher costs and slower performance.

How to eliminate wrong answers

Option A is wrong because uncompressed CSV is not columnar, leading to full table scans and higher costs, and partitioning by hour adds unnecessary granularity that can increase the number of small files. Option B is wrong because JSON is a row-oriented format that is less efficient for Athena than columnar formats, and partitioning by date only (without year/month/day hierarchy) can still result in scanning large partitions. Option C is wrong because Gzip-compressed CSV with no partitioning forces Athena to decompress and scan the entire dataset for every query, eliminating cost savings from partition pruning.

Full explanation →
776
MCQeasy

A company runs an Amazon EMR cluster that processes data from S3 and writes results back to S3. The cluster uses Spot Instances for task nodes. Some tasks are failing due to Spot Instance interruptions. What is the BEST way to handle this without manual intervention?

A.Enable automatic node replacement in the EMR cluster
B.Manually relaunch the cluster after failures
C.Configure the application to checkpoint to S3 every few minutes
D.Use only On-Demand instances for task nodes
AnswerA

EMR can automatically replace Spot Instances that are interrupted.

Why this answer

Amazon EMR's automatic node replacement feature automatically detects when a Spot Instance is interrupted and launches a replacement instance, ensuring the cluster continues processing without manual intervention. Option B is incorrect because manually relaunching the cluster requires human intervention and is not automated. Option C is incorrect because while checkpointing to S3 can help recover data after failures, it does not automatically replace interrupted instances.

Option D is incorrect because using only On-Demand instances eliminates cost savings from Spot Instances and does not address the interruption handling problem—it avoids interruptions entirely by not using Spot Instances, but the best approach is to handle interruptions automatically with automatic node replacement.

Full explanation →
777
MCQhard

A data engineer is monitoring an Amazon Redshift cluster and notices that some queries are experiencing high disk usage and slow performance. The engineer wants to identify the queries that are causing the most disk spills to temporary files. Which system table should the engineer query to get this information?

A.SVL_QUERY_SUMMARY
B.SYS_QUERY_DETAIL
C.STL_SCAN
D.STV_TBL_PERM
AnswerA

SVL_QUERY_SUMMARY includes bytes spilled to disk per query step.

Why this answer

SVL_QUERY_SUMMARY. This system view provides information about disk spills for each query step, including the number of bytes spilled to temporary files. It is used to identify queries causing high disk usage and slow performance due to spills.

Option B, SYS_QUERY_DETAIL, contains general query execution details but not spill information. Option C, STL_SCAN, tracks table scan operations, not disk spills. Option D, STV_TBL_PERM, shows permanent table storage statistics, not temporary spill data.

Full explanation →
778
MCQhard

A data engineer is designing a data pipeline that ingests JSON files from an S3 bucket, transforms them using AWS Glue, and loads into Amazon Redshift. The data is updated daily, and the pipeline must handle late-arriving data from the previous day. Which approach minimizes reprocessing?

A.Use AWS Glue job bookmarks to process only new files based on S3 event notifications.
B.Stream data using Amazon Kinesis Data Firehose to Redshift.
C.Enable S3 versioning and process only the latest version of each object.
D.Schedule a full reload of all data from S3 to Redshift each day.
AnswerA

AWS Glue job bookmarks track previously processed files and process only new or changed files, which handles late-arriving data without reprocessing all data.

Why this answer

AWS Glue job bookmarks track previously processed files and process only new or changed files, which handles late-arriving data without reprocessing all data. Option B uses Amazon Kinesis Data Firehose to stream data to Redshift; this is designed for real-time streaming, not a batch pipeline with daily updates, and does not inherently handle late-arriving data without custom logic. Option C (S3 versioning) can manage multiple versions but does not provide incremental processing for late-arriving data; it would require custom logic to determine which version to process.

Option D (scheduling a full reload) would reprocess all data daily, which is inefficient and does not handle late-arriving data efficiently.

Full explanation →
779
MCQhard

A data engineer is building a streaming pipeline using Amazon Kinesis Data Streams and AWS Lambda. The Lambda function processes records and writes to Amazon DynamoDB. The engineer notices that the Lambda function is throttled during high traffic. Which action should the engineer take to reduce throttling?

A.Increase the Lambda function timeout
B.Disable retries on the Lambda function
C.Increase the number of shards in the Kinesis data stream
D.Use an Amazon SQS queue as an intermediate buffer
AnswerC

More shards allow more Lambda concurrent executions, reducing throttling.

Why this answer

Increasing the number of shards in the Kinesis data stream increases the overall throughput of the stream, which allows the Lambda event source mapping to poll more shards concurrently. Each shard is processed by one Lambda invocation at a time, so more shards mean more concurrent Lambda executions, reducing the per-invocation load and the likelihood of throttling.

Exam trap

The DEA-C01 exam often tests the misconception that throttling is caused by Lambda function performance (timeout or retries) rather than the stream's shard count, leading candidates to choose options that affect execution duration or error handling instead of scaling the source.

How to eliminate wrong answers

Option A is wrong because increasing the Lambda function timeout does not reduce throttling; it only allows the function to run longer, which does not affect the rate at which Lambda invokes the function. Option B is wrong because disabling retries on the Lambda function would cause records to be dropped or sent to a dead-letter queue, but it does not prevent throttling; throttling occurs when the concurrent execution limit is reached, not from retries. Option D is wrong because using an Amazon SQS queue as an intermediate buffer would decouple the stream from Lambda but does not directly address the root cause of throttling, which is insufficient shard count to handle the incoming data volume; SQS would add latency and complexity without increasing concurrency.

Full explanation →
780
MCQhard

A data engineer is troubleshooting an AWS Glue ETL job that suddenly started failing with 'An error occurred while calling o103.pyWriteDynamicFrame. Unknown error'. The job writes data to an Amazon Redshift table. Which step should the engineer take FIRST?

A.Recreate the Redshift table with a different distribution style.
B.Test the job with a small sample dataset to isolate the issue.
C.Update the Redshift JDBC driver version in the Glue job.
D.Review the job's CloudWatch Logs for detailed error messages.
AnswerD

The error message 'An error occurred while calling o103.pyWriteDynamicFrame. Unknown error' is generic and does not specify the root cause. The first troubleshooting step should be to review the job's CloudWatch Logs, which provide detailed error messages, stack traces, and other diagnostic information.

Why this answer

The error message 'An error occurred while calling o103.pyWriteDynamicFrame. Unknown error' is generic and does not specify the root cause. The first troubleshooting step should be to review the job's CloudWatch Logs, which provide detailed error messages, stack traces, and other diagnostic information.

Option A is incorrect because recreating the table with a different distribution style is a premature action without understanding the cause. Option B is incorrect because testing with a small dataset may not reproduce the issue and is not the first step; logs can help determine if the issue is data-related. Option C is incorrect because updating the Redshift JDBC driver version is not the first step; log analysis should precede any changes.

Full explanation →
781
MCQhard

A data engineer is troubleshooting an AWS Step Functions workflow that calls a Lambda function to process data. The workflow sometimes fails with a 'StateMachineExecutionLimitExceeded' error. What is the MOST likely cause?

A.Number of concurrent executions exceeds the account limit
B.Execution time exceeds the maximum allowed duration
C.Lambda function memory limit exceeded
D.Lambda function concurrency limit reached
AnswerA

Step Functions has a default limit of 1 million state transitions per account; exceeding it causes this error.

Why this answer

The error 'StateMachineExecutionLimitExceeded' indicates that the account's limit for concurrent Step Functions executions has been exceeded. Option A correctly identifies this as the most likely cause. Option B would result in an 'ExecutionTimedOut' error, not a limit error.

Option C would cause a Lambda-specific error, such as 'MemorySize', not a Step Functions limit error. Option D would result in a Lambda throttling error, not a state machine execution limit error.

Full explanation →
782
MCQeasy

A company needs to ingest streaming data from multiple sources and store it in Amazon S3. The data volume is up to 5 GB per hour. What is the MOST cost-effective ingestion service?

A.AWS Glue
B.Amazon Kinesis Data Streams
C.Amazon Kinesis Data Firehose
D.AWS Lambda
AnswerC

Amazon Kinesis Data Firehose is fully managed, scales automatically, and charges based on data volume, making it cost-effective.

Why this answer

Amazon Kinesis Data Firehose is the most cost-effective service for ingesting streaming data into Amazon S3 at 5 GB/hour. It is fully managed, automatically scales, and charges only for data ingested (per GB), with no upfront provisioning. While Amazon Kinesis Data Streams (KDS) may have lower throughput cost for steady loads, it requires manual shard management and typically needs additional components (e.g., Lambda functions) to deliver data to S3, increasing operational overhead and total cost.

AWS Glue is a batch ETL service, not designed for streaming. AWS Lambda is a compute service and would require custom code and scaling logic, making it more expensive and complex for this use case. Therefore, Kinesis Data Firehose provides the simplest and most cost-effective solution for streaming data ingestion directly to S3.

Full explanation →
783
MCQmedium

A company uses AWS Glue to process CSV files stored in Amazon S3. The data pipeline runs daily, but recently some jobs have failed with a 'MemoryError'. The data volume has grown from 1 GB to 10 GB per day. What is the MOST cost-effective solution to resolve this issue?

A.Change the Glue worker type from Standard to G.2X.
B.Increase the number of DPUs (Data Processing Units) allocated to the Glue job.
C.Convert the CSV files to Parquet format using an S3 batch operation.
D.Migrate the job to Amazon EMR with a larger cluster.
AnswerB

More DPUs provide more memory and processing power.

Why this answer

Increasing the number of DPUs allocates more memory and processing capacity to the Glue job, directly addressing the MemoryError caused by data growth from 1 GB to 10 GB. Option A is wrong because changing the worker type to G.2X provides more memory per worker, but it is a more expensive option compared to simply increasing DPUs, which scales horizontally. Option C is wrong because converting CSV to Parquet improves performance and reduces storage but does not add memory to the Glue job; the job still runs with the same DPU allocation.

Option D is wrong because migrating to Amazon EMR introduces additional operational complexity and cost; increasing DPUs in Glue is simpler and more cost-effective for scaling an existing job.

Full explanation →
784
MCQmedium

A data engineer runs the AWS CLI command to retrieve the lifecycle configuration of the 'my-data-lake' bucket. The output is shown in the exhibit. What is the effect of this lifecycle policy?

A.Objects in the 'logs/' prefix are deleted after 365 days and their delete markers are removed.
B.All objects in the bucket are moved to STANDARD_IA after 30 days.
C.Objects in the 'logs/' prefix are moved to S3 Standard-IA after 30 days, to Glacier after 90 days, and deleted after 365 days.
D.Objects in the 'logs/' prefix are moved to Glacier after 90 days and expired after 90 days.
AnswerC

Matches the transitions and expiration.

Why this answer

The lifecycle policy explicitly applies to the 'logs/' prefix, transitioning objects to S3 Standard-IA after 30 days, then to Glacier after 90 days, and finally expiring (deleting) them after 365 days. The 'Expiration' action with 'Days: 365' permanently removes the objects, while the 'Transitions' define the storage class changes at the specified intervals.

Exam trap

The trap here is that candidates often overlook the prefix filter and assume the policy applies to the entire bucket, or they misread the expiration as occurring at 90 days instead of 365 days, leading to incorrect answers like B or D.

How to eliminate wrong answers

Option A is wrong because the lifecycle policy does not include any action to remove delete markers; the 'Expiration' action simply deletes the objects after 365 days, and delete marker removal would require a separate 'ExpiredObjectDeleteMarker' setting. Option B is wrong because the policy only applies to objects under the 'logs/' prefix, not to all objects in the bucket, and the transition to STANDARD_IA occurs after 30 days, not immediately. Option D is wrong because it omits the initial transition to S3 Standard-IA after 30 days and incorrectly states that objects are expired after 90 days, whereas the actual expiration is after 365 days.

Full explanation →
785
MCQeasy

A data engineer needs to grant an IAM user read-only access to an S3 bucket named 'data-lake-bucket'. Which IAM policy statement should be attached to the user?

A.{"Effect":"Allow","Action":"s3:GetObject","Resource":"arn:aws:s3:::data-lake-bucket/*"}
B.{"Effect":"Allow","Action":"s3:ListBucket","Resource":"arn:aws:s3:::data-lake-bucket"}
C.{"Effect":"Allow","Action":"s3:PutObject","Resource":"arn:aws:s3:::data-lake-bucket/*"}
D.{"Effect":"Allow","Action":"s3:*","Resource":"arn:aws:s3:::data-lake-bucket/*"}
AnswerA

Read-only access to objects.

Why this answer

It grants read-only access by allowing only the s3:GetObject action, which permits downloading objects from the bucket. The resource ARN includes the wildcard /* to cover all objects within 'data-lake-bucket', ensuring the user can read but not list or modify data.

Exam trap

The trap here is that candidates often confuse 'read-only access' with just s3:GetObject, forgetting that listing objects (s3:ListBucket) is typically needed for practical read-only use, but the question specifically asks for read-only access to the bucket, not listing, so s3:GetObject alone suffices for the stated requirement.

How to eliminate wrong answers

Option B is wrong because s3:ListBucket alone only allows listing objects in the bucket, not reading their contents; without s3:GetObject, the user cannot download or view object data. Option C is wrong because s3:PutObject grants write access, which violates the read-only requirement. Option D is wrong because s3:* grants full administrative access to all S3 actions on the bucket, far exceeding read-only permissions.

Full explanation →
786
MCQeasy

A data engineer needs to grant an IAM user access to query a specific table in Amazon Athena, but the user should not be able to view other tables in the same database. Which method should the engineer use?

A.Attach an IAM policy that allows athena:StartQueryExecution and restrict the query by table name
B.Use AWS Lake Formation to grant SELECT permission on the specific table to the user
C.Apply an S3 bucket policy that restricts access to the table's underlying data
D.Create a separate Athena workgroup with a query limit that only allows queries on that table
AnswerB

Lake Formation enables table-level access control.

Why this answer

Lake Formation provides fine-grained table-level permissions. Option A is wrong because IAM policies alone cannot restrict access to a specific table in Athena without Lake Formation. Option C is wrong because S3 bucket policies do not control Athena table access.

Option D is wrong because Workgroup policies do not provide table-level security.

Full explanation →
787
MCQhard

A financial services company runs a critical data pipeline using AWS Step Functions to orchestrate multiple AWS Lambda functions and AWS Glue jobs. The pipeline processes transaction data and must complete within 15 minutes to meet a service-level agreement (SLA). Recently, the pipeline has been failing intermittently with a 'StateMachineExecutionLimitExceeded' error. The Step Functions state machine is configured with a Standard type. The company has a single state machine that runs on demand. The error occurs when multiple requests are submitted simultaneously. What should the team do to prevent this error?

A.Increase the state machine execution timeout to 30 minutes.
B.Switch the state machine type to Express Workflow to handle higher throughput.
C.Request a service quota increase for concurrent executions of Standard Workflows.
D.Increase the Lambda function reserved concurrency to 100.
AnswerC

The error is due to hitting the account-level limit for concurrent Standard Workflow executions; a quota increase resolves it.

Why this answer

The 'StateMachineExecutionLimitExceeded' error indicates that the account-level limit for concurrent Standard Workflow executions has been reached. The default limit is 1,000 concurrent executions per account per region. To handle simultaneous submissions, requesting a service quota increase is the appropriate action.

Option A (increasing timeout) does not affect concurrent execution limits. Option B (switching to Express Workflow) is not ideal because Express Workflows have a maximum duration of 5 minutes, which cannot meet the 15-minute SLA, and the error is not about throughput but about concurrency limits. Option D (increasing Lambda reserved concurrency) is unrelated to Step Functions execution limits.

Full explanation →
788
MCQeasy

A company is designing a data ingestion pipeline to load CSV files from an SFTP server into Amazon S3. The files are generated hourly and range from 10 MB to 500 MB. Which AWS service should be used to orchestrate the transfer with minimal operational overhead?

A.AWS Glue
B.Amazon AppFlow
C.AWS Transfer Family
D.AWS DataSync
AnswerC

AWS Transfer Family provides managed SFTP with automatic uploads to S3.

Why this answer

AWS Transfer Family is the correct choice because it provides a fully managed, serverless SFTP endpoint that can directly receive files from an SFTP server and automatically store them in Amazon S3. This eliminates the need to manage any compute infrastructure or write custom code for the transfer, minimizing operational overhead for hourly CSV file ingestion.

Exam trap

The trap here is that candidates often confuse AWS DataSync (which requires an on-premises agent and does not support SFTP) with Transfer Family, or they mistakenly think AWS Glue can handle SFTP ingestion because it supports custom connectors, but Glue is not designed for real-time file transfer orchestration.

How to eliminate wrong answers

Option A is wrong because AWS Glue is a serverless data integration service primarily for ETL (extract, transform, load) jobs, not for orchestrating file transfers from an SFTP server; it lacks native SFTP connectors and would require custom scripts or additional services to handle the transfer. Option B is wrong because Amazon AppFlow supports data ingestion from SaaS applications (e.g., Salesforce, Slack) and does not support SFTP as a source, so it cannot be used to pull files from an SFTP server. Option D is wrong because AWS DataSync is designed for large-scale, recurring data transfers between on-premises storage and AWS, but it requires installing an agent on the on-premises network and does not natively support SFTP as a source protocol; it is optimized for NFS/SMB, not SFTP.

Full explanation →
789
MCQeasy

A data pipeline uses AWS Glue to process data from an S3 data lake. The pipeline fails intermittently with a 'ThrottlingException' when writing to a DynamoDB table. What is the MOST likely cause?

A.The DynamoDB table's write capacity is insufficient for the workload.
B.The network connection between Glue and DynamoDB is unstable.
C.The Glue job's timeout setting is too low.
D.The Glue job does not have sufficient IAM permissions to write to DynamoDB.
AnswerA

ThrottlingException indicates the write capacity is exceeded; increasing capacity or using auto-scaling resolves it.

Why this answer

A ThrottlingException from DynamoDB indicates that the request rate to the table has exceeded the provisioned write capacity. AWS Glue jobs can generate high-throughput writes, and if the DynamoDB table's write capacity units (WCUs) are not sufficient to handle the burst, DynamoDB will throttle the requests. This is the most direct cause of the intermittent failure described.

Exam trap

The trap here is that candidates may confuse ThrottlingException with permission errors (Option D) or network issues (Option B), but AWS specifically tests the understanding that DynamoDB throttling is a capacity management mechanism, not a connectivity or authorization problem.

How to eliminate wrong answers

Option B is wrong because network instability between Glue and DynamoDB would typically result in connection timeouts or retryable network errors, not a specific ThrottlingException which is an application-level error from DynamoDB's API. Option C is wrong because a Glue job's timeout setting controls how long the job can run before being terminated, not how it handles individual API throttling errors; a timeout would cause a different error (e.g., 'Timeout exceeded'). Option D is wrong because insufficient IAM permissions would result in an AccessDeniedException, not a ThrottlingException; the error message directly indicates capacity limits, not authorization failures.

Full explanation →
790
Multi-Selectmedium

A company is building a data lake on Amazon S3 and needs to ingest data from multiple sources. The ingestion must be automated and handle schema changes. Which THREE services can be used together to achieve this? (Choose THREE.)

Select 3 answers
A.Amazon Redshift
B.AWS Glue Crawler
C.Amazon Kinesis Data Firehose
D.Amazon EMR
E.AWS Lambda
AnswersB, C, E

Glue Crawler can discover schema and update the Data Catalog.

Why this answer

AWS Glue Crawler (B) automatically discovers and catalogs schemas from data sources. Amazon Kinesis Data Firehose (C) ingests streaming data into S3. AWS Lambda (E) can transform data on the fly.

Together, they automate ingestion and handle schema changes. Amazon Redshift (A) is a data warehouse, not a data lake ingestion service. Amazon EMR (D) is a big data processing framework, not primarily for automated schema change handling.

Full explanation →
791
MCQeasy

A company stores IoT sensor data in S3 as JSON files. They need to convert the data to Parquet format for efficient querying with Amazon Athena. Which AWS service can perform this transformation with minimal effort?

A.Kinesis Data Firehose
B.Amazon Athena
C.AWS Glue ETL job
D.AWS Lambda
AnswerC

Glue ETL can convert JSON to Parquet.

Why this answer

AWS Glue ETL jobs can easily convert JSON to Parquet with built-in transforms. Option A is wrong because Kinesis Data Firehose is for streaming data ingestion, not batch transformations. Option B is wrong because Amazon Athena is a query engine, not a transformation service.

Option D is wrong because AWS Lambda is for small, event-driven transformations and is not ideal for large-scale batch conversion.

Full explanation →
792
MCQhard

A data engineering team uses Amazon Redshift for analytics. They notice that queries on a large fact table are slow. The table is distributed using DISTSTYLE ALL. Which design change would most likely improve query performance?

A.Change DISTSTYLE to EVEN to distribute rows evenly across slices.
B.Increase the number of nodes in the Redshift cluster.
C.Change the table to use a SORTKEY on the most frequently filtered column.
D.Change DISTSTYLE to KEY on a column used in frequent joins.
AnswerD

KEY distribution collocates rows on the same node, reducing data movement during joins.

Why this answer

DISTSTYLE ALL copies the entire table to every node, which is inefficient for large fact tables because it wastes storage and network bandwidth during data loading and query execution. Changing to DISTSTYLE KEY on a column used in frequent joins collocates related rows on the same slice, reducing the need to broadcast or redistribute data across the network during joins, which directly improves query performance.

Exam trap

The trap here is that candidates often assume adding a SORTKEY (Option C) is the universal performance fix, but for large fact tables the dominant bottleneck is data distribution and join collocation, not scan efficiency.

How to eliminate wrong answers

Option A is wrong because DISTSTYLE EVEN distributes rows randomly across slices, which can still cause significant data movement during joins and does not leverage join key locality, often leading to slower queries on large fact tables. Option B is wrong because simply increasing the number of nodes adds more slices and parallelism but does not address the root cause of inefficient data distribution; it may even worsen the overhead of broadcasting the ALL-distributed table. Option C is wrong because adding a SORTKEY improves the efficiency of range-restricted scans and ORDER BY operations, but it does not reduce the network shuffling required during joins, which is the primary bottleneck for a large fact table with DISTSTYLE ALL.

Full explanation →
793
Multi-Selecteasy

A data engineer needs to ingest JSON files from an Amazon S3 bucket into an Amazon DynamoDB table. The files are uploaded every hour. Which THREE services can be used together to build this ingestion pipeline?

Select 3 answers
A.AWS Step Functions
B.Amazon SQS
C.Amazon DynamoDB Streams
D.Amazon S3 Event Notifications
E.AWS Lambda
AnswersB, D, E

SQS can decouple S3 events from Lambda for reliability.

Why this answer

Amazon SQS is correct because it decouples the ingestion pipeline, allowing S3 Event Notifications to send messages to an SQS queue when new JSON files arrive. AWS Lambda can then poll the SQS queue to process the files and write to DynamoDB, ensuring reliable, asynchronous ingestion without data loss.

Exam trap

The trap here is that candidates often confuse DynamoDB Streams (for capturing table changes) with the ingestion pipeline itself, or incorrectly assume Step Functions is needed for simple event-driven workflows, when SQS+Lambda is the standard serverless pattern for this use case.

Full explanation →
794
Multi-Selecthard

A company uses Amazon Kinesis Data Analytics for Apache Flink to process streaming data. The application is experiencing high latency and checkpoint failures. Which THREE actions should the data engineer take to improve performance and reliability? (Choose three.)

Select 3 answers
A.Increase the parallelism of the Flink application
B.Configure the application to use event time processing instead of processing time
C.Increase the checkpoint interval to reduce the frequency of checkpoints
D.Decrease the parallelism to reduce resource contention
E.Disable checkpointing to avoid checkpoint failures
AnswersA, B, C

Higher parallelism improves throughput.

Why this answer

Options A, B, and C are correct. Option A: Increasing parallelism improves throughput by distributing workload across more resources. Option B: Using event time processing helps handle out-of-order data and can reduce latency and checkpoint failures by allowing more accurate watermarks.

Option C: Increasing the checkpoint interval reduces the frequency of checkpoint operations, which can reduce checkpoint failures under high load. Option D is incorrect because decreasing parallelism reduces throughput, worsening latency. Option E is incorrect because disabling checkpointing removes fault tolerance and does not improve performance.

Full explanation →
795
MCQeasy

A company uses Amazon Kinesis Data Streams to ingest clickstream data from a website. The data is then consumed by a custom application for real-time analytics. Recently, the application has been experiencing high latency. The operations team suspects the shard count is insufficient. How should the team increase the shard count of the existing stream?

A.Use the UpdateShardCount API to increase the shard count for the stream.
B.Delete the existing stream and create a new one with a higher shard count.
C.Manually split a shard using the SplitShard API on each existing shard.
D.Modify the PutRecord calls to include a new shard key that distributes data across more shards.
AnswerA

UpdateShardCount correctly increases shards.

Why this answer

The UpdateShardCount API is the correct method to increase the shard count of an existing Kinesis Data Stream without data loss or downtime. It allows you to specify a target shard count, and Kinesis automatically splits shards to achieve that count, redistributing the hash key range across the new shards. This directly addresses the high latency caused by insufficient shard count by increasing the stream's throughput capacity.

Exam trap

The trap here is that candidates might think manually splitting shards (Option C) is the only way to increase shard count, but the UpdateShardCount API is the designed, automated method that avoids the complexity and risk of manual splits.

How to eliminate wrong answers

Option B is wrong because deleting and recreating the stream would cause data loss and downtime, which is unnecessary when the UpdateShardCount API can dynamically scale the existing stream. Option C is wrong because manually splitting each shard using the SplitShard API is not the recommended approach for increasing the overall shard count; it requires careful planning of hash key ranges and is error-prone, whereas UpdateShardCount automates the process. Option D is wrong because modifying PutRecord calls to include a new shard key does not increase the shard count; it only changes how data is distributed among existing shards, which does not solve the throughput bottleneck.

Full explanation →
796
MCQmedium

A company uses Amazon Kinesis Data Streams to ingest clickstream data from a website. The data must be transformed (e.g., enrich with user location) before being stored in Amazon S3. Which architecture is MOST efficient for this transformation?

A.Use AWS Glue to run a streaming ETL job.
B.Use Amazon EMR to consume the stream using Spark Streaming.
C.Use AWS Lambda to process each record from the stream and write to S3.
D.Use Amazon Kinesis Data Analytics to transform the stream and output to Amazon Kinesis Data Firehose, which writes to S3.
AnswerD

Kinesis Data Analytics can run SQL on the stream, and Firehose delivers to S3 in batches.

Why this answer

Amazon Kinesis Data Analytics (KDA) can perform real-time transformations (e.g., enriching clickstream data with user location via SQL or Flink) on the stream, then output the transformed data to Kinesis Data Firehose, which can batch and compress records before writing to S3. This architecture minimizes operational overhead and is purpose-built for streaming transformations, avoiding the latency and complexity of Lambda cold starts or the provisioning overhead of Glue/EMR.

Exam trap

The trap here is that candidates often choose AWS Lambda (Option C) because it seems serverless and simple, but they overlook Lambda's lack of native batching to S3 and its 15-minute timeout, which makes it inefficient for continuous, high-volume streaming transformations compared to KDA + Firehose.

How to eliminate wrong answers

Option A is wrong because AWS Glue streaming ETL jobs are designed for batch-oriented transformations and incur higher startup latency and cost compared to KDA for simple per-record enrichments. Option B is wrong because Amazon EMR with Spark Streaming requires managing a persistent cluster, which adds operational complexity and cost for a continuous, low-latency transformation that could be handled serverlessly. Option C is wrong because AWS Lambda has a maximum invocation duration of 15 minutes and is not ideal for high-throughput, sustained streaming transformations; it also lacks native integration with Kinesis Data Firehose for batching and compression to S3, leading to excessive S3 PUT requests and higher costs.

Full explanation →
797
MCQmedium

A company is using AWS Glue to process streaming data from Amazon Kinesis Data Streams. The job fails intermittently with a 'MemoryError' when the stream has a sudden spike in data volume. Which configuration change would best prevent this error?

A.Increase the number of DPUs (Data Processing Units) for the Glue job.
B.Store intermediate results in Amazon RDS.
C.Use a batch transformation instead of streaming.
D.Increase the number of shards in the Kinesis data stream.
AnswerA

Increasing DPUs adds more memory and compute capacity to the Glue job, directly addressing the MemoryError during data spikes.

Why this answer

Increasing the number of DPUs in the AWS Glue job provides more memory and compute capacity to handle data spikes. Option B is wrong because storing intermediate results in Amazon RDS does not prevent memory errors in Glue; it introduces a database dependency and does not increase Glue's memory. Option C is wrong because switching to batch transformation is not a solution for a streaming job; the job is designed for streaming and batch does not address the memory issue.

Option D is wrong because increasing the number of shards in Kinesis increases throughput but does not directly solve memory errors in Glue; it may even increase the data volume per unit time and worsen the problem.

Full explanation →
798
MCQeasy

A company uses AWS Glue ETL jobs to transform data in Amazon S3. The data arrives in JSON format but needs to be converted to Parquet for efficient querying. Which AWS Glue feature should be used to infer the schema and generate transformation code?

A.Amazon S3 Select
B.Amazon Athena
C.Amazon Kinesis Data Analytics
D.AWS Glue crawlers
AnswerD

Crawlers populate the Data Catalog with schema information used by Glue ETL jobs.

Why this answer

AWS Glue crawlers are the correct feature because they automatically connect to data stores (like S3), infer the schema of JSON data by sampling it, and populate the AWS Glue Data Catalog with table definitions. This catalog schema can then be used by AWS Glue ETL jobs to generate transformation code (e.g., converting JSON to Parquet) without manual schema definition.

Exam trap

The trap here is that candidates confuse AWS Glue crawlers with Amazon Athena or S3 Select, assuming any query or analysis tool can infer schemas for ETL, but only crawlers are designed to automatically discover and catalog schemas for Glue ETL jobs.

How to eliminate wrong answers

Option A is wrong because Amazon S3 Select is a query-in-place service that retrieves subsets of data from S3 objects using SQL, but it does not infer schemas or generate ETL transformation code. Option B is wrong because Amazon Athena is an interactive query service that uses SQL to analyze data directly in S3, but it does not generate ETL transformation code or automatically infer schemas for Glue ETL jobs (though it can query Glue Data Catalog tables). Option C is wrong because Amazon Kinesis Data Analytics processes streaming data in real time using SQL or Apache Flink, not batch transformation of JSON to Parquet in S3, and it does not infer schemas for Glue ETL jobs.

Full explanation →
799
MCQeasy

A company wants to transform data in Amazon S3 using SQL queries without provisioning servers. The transformations are ad-hoc and run occasionally. Which service should be used?

A.AWS Glue
B.Amazon Redshift Spectrum
C.Amazon EMR
D.Amazon Athena
AnswerD

Athena is serverless and supports SQL queries directly on S3 data.

Why this answer

Amazon Athena is the correct choice because it enables serverless, ad-hoc SQL querying directly on data stored in Amazon S3 without requiring any infrastructure provisioning. Since the transformations are occasional and ad-hoc, Athena's pay-per-query model and zero setup overhead align perfectly with the requirement.

Exam trap

The trap here is that candidates often confuse AWS Glue's ability to run SQL via Spark SQL or Athena as a transformation engine, but Glue requires provisioning resources and is not designed for ad-hoc serverless SQL queries.

How to eliminate wrong answers

Option A is wrong because AWS Glue is primarily an ETL service that requires provisioning and managing crawlers, jobs, and triggers, and is designed for scheduled or event-driven batch transformations, not lightweight ad-hoc SQL queries. Option B is wrong because Amazon Redshift Spectrum extends Redshift's query capabilities to S3 but still requires a provisioned Redshift cluster to run, which violates the 'without provisioning servers' constraint. Option C is wrong because Amazon EMR is a managed big data platform that requires provisioning EC2 instances and configuring clusters, making it unsuitable for occasional, serverless SQL queries.

Full explanation →
800
MCQmedium

A company is using AWS DMS to migrate a 5 TB SQL Server database to Amazon Aurora PostgreSQL. The migration is using full load plus CDC. After the full load completes, the ongoing replication task is failing with errors related to large transactions on the source. The team needs to ensure that CDC continues without falling behind. What should the team do?

A.Use Amazon Kinesis Data Streams as an intermediate target for CDC.
B.Increase the DMS replication instance size to provide more memory and CPU.
C.Modify the DMS task settings to increase MaxFileSize and decrease the CommitRate.
D.Disable foreign key constraints on the target Aurora database.
AnswerB

Increasing the DMS replication instance size provides more memory and CPU, allowing the instance to process large transactions more efficiently and keep up with CDC changes without falling behind.

Why this answer

Increasing the DMS replication instance size provides more memory and CPU, enabling the instance to process large transactions more efficiently and keep up with CDC changes without falling behind. Option C (modifying MaxFileSize and decreasing CommitRate) is not the best solution because decreasing CommitRate means less frequent commits, which could worsen the problem by accumulating more data per commit. The more direct approach is to scale the instance vertically to handle the load.

Full explanation →
801
MCQmedium

A data engineer needs to audit all access to an S3 bucket for compliance. They want to capture object-level operations such as GetObject and PutObject, as well as bucket-level operations like ListBucket. Which AWS service should be used?

A.Amazon CloudWatch Logs
B.S3 server access logs
C.AWS CloudTrail management events
D.AWS Config
AnswerB

S3 server access logs provide detailed records about requests made to a bucket, including object-level and bucket-level operations.

Why this answer

S3 server access logs record both object-level operations (e.g., GetObject, PutObject) and bucket-level operations (e.g., ListBucket). AWS CloudTrail can also capture S3 API calls, but by default it logs bucket-level management events only; object-level data events must be explicitly enabled. Amazon CloudWatch Logs (Option A) is a log storage and monitoring service, not a source of S3 access logs; logs must be sent to it from another service.

AWS CloudTrail management events (Option C) capture only bucket-level operations, not object-level. AWS Config (Option D) monitors resource configuration changes, not API calls. Therefore, the correct service for auditing all S3 access is S3 server access logs.

Full explanation →
802
MCQhard

A data engineering team uses Amazon Kinesis Data Analytics for Apache Flink to process streaming data. They notice that the application's checkpointing is failing intermittently, causing data reprocessing. The application uses a large state. Which configuration change should the team make to improve checkpoint reliability?

A.Disable checkpointing to avoid failures.
B.Switch the state backend from in-memory to RocksDB.
C.Increase the parallelism of the application.
D.Increase the checkpointing interval.
AnswerD

Longer intervals reduce checkpoint frequency and associated failures.

Why this answer

Increasing the checkpointing interval reduces the frequency of checkpoint operations, giving the system more time to complete each checkpoint before the next one starts. This alleviates backpressure and resource contention, which is critical when dealing with large state, as checkpointing large state is I/O and CPU intensive and can fail if intervals are too tight.

Exam trap

The trap here is that candidates often confuse improving state backend performance (RocksDB) with fixing checkpoint reliability, when the root cause is checkpoint timing pressure, not state storage efficiency.

How to eliminate wrong answers

Option A is wrong because disabling checkpointing eliminates fault tolerance entirely, which would cause data loss on failure and is not a valid reliability improvement. Option B is wrong because switching to RocksDB improves state storage efficiency and reduces memory pressure, but it does not directly address checkpoint failures caused by overly frequent checkpointing; RocksDB can even increase checkpoint duration due to disk I/O. Option C is wrong because increasing parallelism distributes workload but also increases the number of concurrent checkpoint operations and network overhead, potentially worsening checkpoint failures when state is large.

Full explanation →
803
MCQmedium

Refer to the exhibit. A data engineer runs the above CLI command and sees the output. The security team requires that the RDS instance not be accessible from the internet. Which change should the engineer make?

A.Change the storage type to io1 for better performance.
B.Modify the DB instance to set PubliclyAccessible to false.
C.Enable Multi-AZ deployment to improve security.
D.Update the VPC security group to deny inbound traffic from 0.0.0.0/0.
AnswerB

This removes the public IP address.

Why this answer

Setting the `PubliclyAccessible` attribute to `false` ensures that the RDS instance is not assigned a public IP address and is not reachable from the internet. This directly satisfies the security team's requirement, as the instance will only be accessible from within the VPC. The CLI command shown modifies the DB instance, and this parameter is the standard AWS mechanism to control internet accessibility for RDS.

Exam trap

The DEA-C01 exam often tests the misconception that modifying a security group to block all inbound traffic is sufficient to make an RDS instance private, but the trap here is that the instance can still have a public IP address and be reachable from the internet if the security group rule is later removed or if the instance is in a public subnet.

How to eliminate wrong answers

Option A is wrong because changing the storage type to io1 (provisioned IOPS) improves I/O performance, not security or internet accessibility. Option C is wrong because enabling Multi-AZ deployment provides high availability and failover support, but does not restrict internet access; it can still leave the instance publicly accessible. Option D is wrong because updating the VPC security group to deny inbound traffic from 0.0.0.0/0 is a valid security measure, but it does not prevent the RDS instance from having a public IP address; the instance could still be assigned a public IP and be reachable if the security group rule is misconfigured or overridden, making this an incomplete solution compared to directly setting PubliclyAccessible to false.

Full explanation →
804
MCQmedium

A data engineer is designing a data lake on Amazon S3 and needs to ensure that objects are automatically encrypted at rest using server-side encryption with AWS KMS. Which bucket policy statement achieves this?

A.Deny PutObject requests where the x-amz-server-side-encryption header is not set to aws:kms.
B.Deny PutObject requests that do not include the x-amz-server-side-encryption header.
C.Deny PutObject requests where the x-amz-server-side-encryption header is not set to AES256.
D.Allow PutObject requests only if the x-amz-server-side-encryption header is set to AES256.
AnswerA

Enforces SSE-KMS encryption.

Why this answer

It enforces server-side encryption with AWS KMS (SSE-KMS) by denying any PutObject request that does not include the `x-amz-server-side-encryption` header set to `aws:kms`. This bucket policy ensures that all objects written to the S3 bucket are automatically encrypted at rest using AWS KMS, meeting the requirement for mandatory encryption with a specific key management service.

Exam trap

The trap here is that candidates often confuse the encryption header values (`aws:kms` vs `AES256`) and mistakenly choose an option that enforces SSE-S3 (AES256) instead of SSE-KMS, or they pick a Deny statement that only checks for the presence of the header without validating its specific value.

How to eliminate wrong answers

Option B is wrong because it denies PutObject requests that do not include the `x-amz-server-side-encryption` header at all, but it does not enforce the use of `aws:kms`; a request with the header set to `AES256` (SSE-S3) would still be denied, which is overly restrictive and not aligned with the requirement for KMS encryption. Option C is wrong because it denies PutObject requests where the header is not set to `AES256`, which would enforce SSE-S3 instead of SSE-KMS, directly contradicting the requirement for AWS KMS encryption. Option D is wrong because it allows PutObject requests only if the header is set to `AES256`, which again enforces SSE-S3, not SSE-KMS, and an Allow statement alone does not block requests that omit the header entirely, leaving a gap for unencrypted uploads.

Full explanation →
805
MCQhard

A data pipeline using Amazon Kinesis Data Streams is experiencing high consumer lag. The stream has 10 shards. The consumer is an AWS Lambda function that processes each record and writes to Amazon DynamoDB. What is the MOST likely cause of the lag?

A.The Lambda function's reserved concurrency is set too low
B.The DynamoDB table's write capacity is throttling writes
C.The number of shards is insufficient for the data volume
D.The Lambda function is not authorized to read from Kinesis
AnswerA

Low concurrency limits parallel processing of shards.

Why this answer

The most likely cause of high consumer lag is that the Lambda function's reserved concurrency is set too low (Option A). Each Kinesis shard is processed by a single Lambda invocation, and if the function's concurrency limit is less than the number of shards (10), some shards will not be processed in parallel, leading to lag. Option B (DynamoDB write capacity throttling) could cause lag but is less common if the table is properly provisioned.

Option C (insufficient shards) is unlikely because 10 shards already provide parallelism; increasing shards would improve throughput only if Lambda concurrency is not the bottleneck. Option D (authorization) would cause errors, not just lag.

Full explanation →
806
MCQeasy

An e-commerce company wants to capture clickstream data from its website and store it in Amazon S3 for analytics. The data arrives continuously and the company needs near-real-time processing. Which solution is most appropriate?

A.AWS Data Pipeline
B.AWS Snowball Edge
C.Amazon Kinesis Data Firehose
D.Amazon S3 Transfer Acceleration
AnswerC

Firehose captures streaming data and delivers to S3 with low latency.

Why this answer

Amazon Kinesis Data Firehose is the most appropriate solution because it is a fully managed service designed to ingest streaming data and deliver it to destinations like Amazon S3 with near-real-time latency. The company needs continuous clickstream capture and near-real-time processing, which Firehose provides. Option A (AWS Data Pipeline) is for batch processing, not streaming.

Option B (AWS Snowball Edge) is for offline data transfer, not real-time. Option D (S3 Transfer Acceleration) improves upload speed but is not a streaming ingestion service.

Full explanation →
807
MCQhard

A company uses Amazon Kinesis Data Firehose to deliver data to Amazon S3. The data is compressed with GZIP and partitioned by year, month, day, and hour. The delivery stream is configured to buffer up to 5 MB or 60 seconds. Some records are missing from S3. What is the most likely cause?

A.The S3 bucket does not have sufficient permissions
B.The data compression format is incompatible with S3
C.The Lambda transformation function timed out and records were skipped
D.The partition key configuration is incorrect
AnswerC

Firehose drops records if the transformation Lambda exceeds the timeout.

Why this answer

When a Lambda transformation function times out, Kinesis Data Firehose will skip the affected records by default. The delivery stream configuration (5 MB or 60 seconds) only controls buffering, not Lambda invocation failures. If the Lambda function exceeds its timeout limit, Firehose treats the invocation as failed and, depending on the error handling configuration, may drop the records entirely, leading to missing data in S3.

Exam trap

The trap here is that candidates often assume buffering settings (5 MB or 60 seconds) guarantee delivery, but they overlook that Lambda transformation failures can silently drop records without explicit error logging unless CloudWatch monitoring is set up.

How to eliminate wrong answers

Option A is wrong because insufficient S3 bucket permissions would cause delivery failures or error logs, not selective missing records; Firehose would report a permission error in CloudWatch Logs. Option B is wrong because GZIP compression is fully compatible with S3 and is a standard compression format supported by Firehose for S3 delivery. Option D is wrong because the partition key configuration (year/month/day/hour) is correctly defined and does not cause record loss; incorrect partitioning would only affect the folder structure, not the presence of records.

Full explanation →
808
MCQhard

Refer to the exhibit. A data engineer is configuring an IAM policy for a Lambda function that writes transformed data to S3. The function writes to both 'example-bucket/data/' and 'example-bucket/public/'. The policy is intended to enforce server-side encryption with SSE-S3 for all objects written to the 'public/' prefix, while allowing all operations on other prefixes. However, the Lambda function is failing with an AccessDenied error when writing to 'example-bucket/public/'. What is the most likely cause?

A.The policy denies DeleteObject on 'public/'.
B.The policy denies PutObject on 'public/' unconditionally.
C.The policy does not allow GetObject for 'public/'.
D.The Lambda function is not setting the 'x-amz-server-side-encryption' header to 'AES256' when writing to 'public/'.
AnswerD

The Deny condition requires AES256 encryption.

Why this answer

The policy enforces SSE-S3 encryption for objects written to the 'public/' prefix. When a Lambda function writes to S3 without setting the 'x-amz-server-side-encryption' header to 'AES256', the request fails with an AccessDenied error if the bucket policy requires SSE-S3. The policy explicitly denies PutObject unless the encryption header is present, so the function must include this header to succeed.

Exam trap

The DEA-C01 exam often tests the nuance that bucket policies can conditionally deny operations based on request headers, and candidates mistakenly think the error is due to missing IAM permissions rather than a missing encryption header.

How to eliminate wrong answers

Option A is wrong because the error is about writing (PutObject), not deleting (DeleteObject), and the policy focuses on encryption enforcement, not delete permissions. Option B is wrong because the policy does not unconditionally deny PutObject; it denies PutObject only when the required SSE-S3 encryption header is missing, which is a conditional denial. Option C is wrong because GetObject is not relevant to the write operation failing; the error occurs during PutObject, and the policy does not restrict read access for 'public/'.

Full explanation →
809
MCQmedium

A company is using an Amazon RDS for MySQL database for an e-commerce application. During a sales event, the database experiences high read traffic, causing slow query performance. The company wants to reduce the read load on the primary database without changing the application code. Which solution meets these requirements?

A.Enable Multi-AZ on the RDS instance.
B.Create an Amazon RDS read replica and direct read traffic to it.
C.Increase the instance size of the RDS database.
D.Deploy Amazon ElastiCache to cache query results.
AnswerB

Read replicas handle read-only traffic, reducing load on the primary.

Why this answer

An Amazon RDS read replica is a read-only copy of the primary database that can offload read traffic without requiring any application code changes. By directing read queries to the replica, the primary database's load is reduced, improving performance during high-read events. This solution is specifically designed for read-heavy workloads and integrates seamlessly with existing MySQL connections.

Exam trap

The trap here is that candidates often confuse Multi-AZ with read replicas, assuming Multi-AZ provides read scaling, when in fact Multi-AZ only ensures failover redundancy and does not serve read traffic.

How to eliminate wrong answers

Option A is wrong because enabling Multi-AZ provides high availability through a standby replica in a different Availability Zone, but it does not offload read traffic; the standby is not used for reads unless a failover occurs. Option C is wrong because increasing the instance size scales the primary database vertically, which can improve performance but does not reduce read load on the primary instance and may incur higher costs without addressing the read traffic distribution. Option D is wrong because deploying Amazon ElastiCache caches query results in memory, which can reduce database load, but it requires application code changes to implement caching logic, violating the requirement of no code changes.

Full explanation →
810
Multi-Selecteasy

A data engineer is designing a data ingestion pipeline for real-time clickstream data. Which TWO services can be used to ingest the data into Amazon Kinesis Data Streams?

Select 2 answers
A.Amazon S3
B.Kinesis Producer Library (KPL)
C.Kinesis Data Firehose
D.AWS SDK
E.AWS Glue
AnswersB, D

KPL is designed to send data to Kinesis Data Streams efficiently.

Why this answer

Options B and D are correct. The Kinesis Producer Library (KPL) is a library for producers to send data to Kinesis Data Streams. AWS SDK can also be used directly.

Option A is wrong because Amazon S3 is a storage service, not a producer. Option C is wrong because Kinesis Data Firehose is a downstream consumer or delivery service, not a producer. Option E is wrong because AWS Glue is an ETL service, not a producer.

Full explanation →
811
Multi-Selectmedium

A data engineer is setting up Amazon CloudWatch alarms for an Amazon Redshift cluster. The engineer wants to be alerted when the disk space usage exceeds 80% for more than 5 minutes and when the CPU utilization exceeds 90% for more than 10 minutes. Which TWO CloudWatch metrics and conditions should the engineer use? (Choose two.)

Select 2 answers
A.Metric: CPUUtilization; Condition: > 90 for 10 minutes
B.Metric: DatabaseConnections; Condition: > 500 for 5 minutes
C.Metric: NetworkReceiveThroughput; Condition: > 1 GB for 10 minutes
D.Metric: WLMQueueLength; Condition: > 100 for 5 minutes
E.Metric: PercentageDiskSpace; Condition: > 80 for 5 minutes
AnswersA, E

This alarm triggers on CPU usage.

Why this answer

The correct metrics and conditions are: for disk space usage exceeding 80% for more than 5 minutes, use PercentageDiskSpace with a threshold of 80 and a period of 5 minutes; for CPU utilization exceeding 90% for more than 10 minutes, use CPUUtilization with a threshold of 90 and a period of 10 minutes. These correspond to options A and E. Option B (DatabaseConnections) monitors connections, not disk or CPU.

Option C (NetworkReceiveThroughput) measures network traffic. Option D (WLMQueueLength) tracks query queue length, not disk or CPU.

Full explanation →
812
MCQhard

A company has multiple AWS accounts and wants to centrally manage permissions and access to data lakes. They have enabled AWS Organizations and want to use a single set of policies that apply to all accounts. Which policy type should be used at the organization level?

A.IAM policies
B.KMS key policies
C.S3 bucket policies
D.Service control policies (SCPs)
AnswerD

Service control policies (SCPs) are used in AWS Organizations to centrally manage permissions and access across all member accounts, making them the correct choice.

Why this answer

Service Control Policies (SCPs) are used in AWS Organizations to centrally manage permissions across accounts. Option A (IAM policies) are attached to IAM users/roles within an account, not across accounts. Option B (KMS key policies) control access to KMS keys.

Option C (S3 bucket policies) are specific to S3 buckets.

Full explanation →
813
Multi-Selectmedium

Which TWO actions should a data engineer take to protect sensitive data in an Amazon S3 bucket from being accessed by unauthorized users? (Select TWO.)

Select 2 answers
A.Create a VPC endpoint for S3
B.Enable S3 server access logging
C.Add a bucket policy with a Deny effect for unauthorized principals
D.Enable AWS CloudTrail for the bucket
E.Enable S3 Block Public Access
AnswersC, E

A Deny policy explicitly denies access.

Why this answer

Options C and E are correct. Option C (bucket policy with Deny effect) explicitly denies access to unauthorized users, preventing unauthorized access. Option E (S3 Block Public Access) prevents public access to the bucket, ensuring it is not publicly accessible.

Option A (VPC endpoint) is for network connectivity, not access control. Option B (server access logging) is for auditing, not prevention. Option D (CloudTrail) is for logging and monitoring, not access control.

Full explanation →
814
MCQeasy

A company needs to ingest data from an on-premises MySQL database into Amazon S3 for analytics. The database is 2 TB in size. The company has a low-bandwidth internet connection (10 Mbps). They need to perform an initial full load and then incremental updates every hour. Which approach should they use?

A.Use Kinesis Data Firehose to stream data from MySQL to S3.
B.Use AWS Database Migration Service (DMS) to perform the full load and ongoing replication.
C.Use AWS Glue ETL jobs to extract data and load into S3.
D.Use AWS Snowball Edge to transfer the initial full load, then use AWS DataSync for incremental updates.
AnswerB

AWS DMS can perform a full 2 TB load from MySQL to S3 even over a 10 Mbps link because it uses change data capture (CDC) to track incremental changes after the initial load, enabling hourly updates without re-scanning the entire source. This satisfies the low-bandwidth constraint by minimising repeated data transfer.

Why this answer

AWS Database Migration Service (DMS) supports full load and ongoing replication, and can be used with limited bandwidth. Option A is wrong because Kinesis Data Firehose is for streaming data, not database replication. Option C is wrong because Glue ETL is not optimized for continuous replication.

Option D is wrong because Snowball Edge is for offline transfer, not ongoing replication.

Full explanation →
815
MCQmedium

Refer to the exhibit. A data engineer is troubleshooting a Kinesis Data Streams consumer that is falling behind. The stream has 2 shards and is receiving data at a rate of 2 MB/s. The consumer is an AWS Lambda function with a batch size of 100 records. What should the engineer do to improve consumer throughput?

A.Decrease the Lambda batch size to 10 records
B.Increase the retention period of the stream to 168 hours
C.Increase the number of shards in the stream to 4
D.Increase the memory allocation of the Lambda function
AnswerC

More shards increase parallelism and throughput for both producers and consumers.

Why this answer

Increasing the number of shards to 4 doubles the stream's total ingestion capacity to 4 MB/s, which directly increases the number of concurrent Lambda invocations and thus consumer throughput. With 2 shards, each shard can support up to 1 MB/s input and 2 MB/s output, so the current 2 MB/s load is at the shard-level output limit, causing the consumer to fall behind.

Exam trap

The DEA-C01 exam often tests the misconception that Lambda memory or batch size adjustments are the primary levers for throughput, when in fact the shard count directly controls the parallelism and read capacity of a Kinesis stream consumer.

How to eliminate wrong answers

Option A is wrong because decreasing the batch size reduces the number of records processed per invocation, which increases the number of Lambda invocations and overhead, potentially worsening throughput rather than improving it. Option B is wrong because increasing the retention period (up to 365 days) only affects how long records are stored in the stream, not the rate at which the consumer can read or process data. Option D is wrong because while increasing Lambda memory can improve CPU performance, the bottleneck here is the shard-level read throughput limit (2 MB/s per shard for the consumer), not Lambda compute capacity.

Full explanation →
816
MCQmedium

A data engineer is tasked with reducing costs for an Amazon Redshift cluster. The cluster is used for both ETL workloads and BI reporting. The engineer observes that the cluster is over-provisioned during off-peak hours. Which action would be MOST effective in reducing costs while maintaining performance during peak hours?

A.Switch to RA3 node types for managed storage.
B.Enable concurrency scaling to automatically add cluster capacity during peak hours.
C.Purchase Reserved Instances for the cluster.
D.Reduce the number of nodes in the cluster.
AnswerB

Concurrency scaling adds transient clusters only when needed, reducing cost during off-peak hours.

Why this answer

Concurrency scaling adds additional capacity on demand and is cost-effective for variable workloads. Option A is incorrect because RA3 nodes with managed storage are more about storage scaling and may not directly reduce costs for variable workloads as effectively. Option C is incorrect because Reserved Instances require upfront payment and are best for steady-state, not variable workloads.

Option D is incorrect because reducing node count may impact performance during peak hours.

Full explanation →
817
MCQhard

A company is ingesting streaming data from multiple sources using Amazon Kinesis Data Streams. The data is then processed by an AWS Lambda function that transforms the records and writes them to an Amazon S3 bucket. The Lambda function is failing intermittently with timeout errors. The average record size is 5 KB, and the shard count is 2. What is the MOST likely cause of the timeout errors?

A.The Lambda function timeout is set too low for the processing time required.
B.The Kinesis data retention period is too short, causing data to be lost before processing.
C.The Lambda function's reserved concurrency is set too low, causing throttling.
D.The Lambda function is receiving too many records per invocation, exceeding the 6 MB payload limit.
AnswerA

The default Lambda timeout is 3 seconds, which may not be sufficient for processing each batch of records and writing to S3.

Why this answer

The Lambda function is timing out, indicating that the configured timeout is insufficient for the actual processing time. Lambda has a default timeout of 3 seconds, but it can be set from 1 second to 15 minutes. If the transformation logic or S3 write operation takes longer than the configured timeout, the function will fail with a timeout error.

Option B is incorrect because the Kinesis data retention period (default 24 hours) affects data availability, not Lambda execution time. Option C is incorrect because reserved concurrency controls the number of concurrent invocations and can cause throttling, not timeouts. Option D is incorrect because with an average record size of 5 KB, even the default batch size of 100 records results in only 500 KB per invocation, well below the 6 MB payload limit.

Full explanation →
818
Multi-Selecthard

A company uses Amazon RDS for MySQL as a source for AWS DMS to replicate data to S3. The replication task is failing with 'OutOfMemory' errors on the DMS instance. The source table has 10 million rows with large BLOB columns. Which THREE changes would most likely resolve the issue?

Select 3 answers
A.Set the LOB column settings to 'Limited LOB mode' and specify a max LOB size.
B.Disable logging for the DMS task to free memory.
C.Enable Full LOB mode to handle LOBs more efficiently.
D.Increase the DMS replication instance size to a compute-optimized class.
E.Increase the number of parallel threads in the task settings.
AnswersA, D, E

Limited LOB mode avoids loading entire LOBs into memory.

Why this answer

Setting LOB columns to 'Limited LOB mode' with a specified max LOB size prevents DMS from loading entire LOBs into memory. Instead, DMS truncates LOBs to the specified size, reducing memory consumption and avoiding OutOfMemory errors when replicating large BLOB columns from MySQL to S3.

Exam trap

The trap here is that candidates often assume Full LOB mode is always the safest choice for large objects, but it actually increases memory usage and can cause OutOfMemory errors, whereas Limited LOB mode with a max size is the correct memory-saving approach.

Full explanation →
819
MCQmedium

A data engineer is troubleshooting a slow-running query on an Amazon Redshift cluster. The query involves joining two large tables. The engineer notices that the query plan shows a large number of distribution and broadcast operations. Which design change would most likely improve query performance?

A.Change the distribution style of both tables to ALL
B.Change the distribution style of both tables to KEY on the join column
C.Change the distribution style of both tables to EVEN
D.Add a sort key on the join column
AnswerB

KEY distribution on the join column ensures matching rows are on the same node, reducing redistribution.

Why this answer

Changing the distribution style of both tables to KEY on the join column ensures that rows with the same join key value are co-located on the same node. This eliminates the need for expensive broadcast or redistribution operations during the join, as Redshift can perform the join locally on each slice without moving data across the network.

Exam trap

The trap here is that candidates often confuse distribution and sort keys, thinking a sort key on the join column will reduce data movement, when in fact only distribution key alignment eliminates broadcast/redistribution operations in the query plan.

How to eliminate wrong answers

Option A is wrong because setting both tables to ALL distribution replicates the entire table to every node, which increases storage and maintenance overhead, and does not address the root cause of excessive data movement during joins; it can also degrade performance for large tables due to increased load and memory pressure. Option C is wrong because EVEN distribution distributes rows round-robin across nodes, which does not co-locate join keys and forces Redshift to redistribute or broadcast rows during the join, exacerbating the problem. Option D is wrong because adding a sort key on the join column improves the efficiency of range-restricted scans and merge joins but does not reduce the number of distribution or broadcast operations; the query plan's large number of such operations indicates a distribution mismatch, not a sorting issue.

Full explanation →
820
MCQeasy

A data engineer is monitoring an Amazon EMR cluster and notices that one core node is running out of disk space. The cluster is running a Spark job that processes large Parquet files. What should the engineer do to prevent the issue?

A.Terminate the core node and replace it with a larger instance type
B.Use Spark's in-memory processing to avoid writing intermediate data to disk
C.Enable Snappy compression for intermediate data
D.Increase the number of core nodes
AnswerC

Compression reduces disk usage for intermediate data.

Why this answer

Enabling Snappy compression for intermediate data reduces the volume of data written to disk during Spark shuffle operations, directly addressing the disk space issue on the core node. Snappy provides a good balance between compression ratio and speed, minimizing I/O overhead while conserving storage. This is a standard tuning practice in Amazon EMR for Spark jobs that process large Parquet files.

Exam trap

The trap here is that candidates may confuse increasing cluster capacity (options A or D) with optimizing data handling, whereas the exam tests the understanding that compression of intermediate data directly reduces disk usage without requiring hardware changes.

How to eliminate wrong answers

Option A is wrong because terminating the core node and replacing it with a larger instance type is disruptive and does not prevent the recurrence of disk space issues; it only temporarily increases capacity without addressing the root cause of excessive intermediate data. Option B is wrong because Spark's in-memory processing cannot fully avoid writing intermediate data to disk during shuffle operations, as spill-to-disk is inherent when memory is insufficient; relying solely on in-memory processing does not prevent disk exhaustion. Option D is wrong because increasing the number of core nodes distributes the storage load but does not reduce the amount of intermediate data written per node; it may delay but not prevent disk space issues if the data volume per node remains high.

Full explanation →
821
MCQeasy

Refer to the exhibit. A data engineer runs this AWS Glue Data Catalog DDL statement to create a table. The CSV files in 's3://my-bucket/sales/' use a pipe delimiter (|) instead of a comma. What change is needed to correctly read the data?

A.Change the 'field.delim' property to '|'.
B.Change the LOCATION to read from a subfolder.
C.Add a partition projection configuration.
D.Run a crawler to detect the schema automatically.
AnswerA

The delimiter must match the actual file format.

Why this answer

The AWS Glue Data Catalog DDL statement uses the default 'field.delim' property, which expects comma-separated values. Since the CSV files use a pipe delimiter (|), the table will not parse rows correctly. Setting 'field.delim' to '|' in the SerDe properties tells the Hive-compatible SerDe to split on pipes instead of commas, enabling correct data ingestion.

Exam trap

The DEA-C01 exam often tests the misconception that changing the LOCATION or adding partition projection will fix parsing issues, when in fact the core problem is the SerDe delimiter property not matching the actual file format.

How to eliminate wrong answers

Option B is wrong because changing the LOCATION to a subfolder does not alter the delimiter interpretation; it only changes the source path, leaving the parsing issue unresolved. Option C is wrong because partition projection configuration optimizes partition pruning for partitioned tables, but it does not affect how individual records are parsed within files. Option D is wrong because running a crawler would detect the schema and delimiter automatically, but the question explicitly asks what change is needed to the given DDL statement, and a crawler is an alternative approach, not a modification to the existing DDL.

Full explanation →
822
MCQeasy

A data engineer needs to transform JSON data into CSV format using AWS Glue. The transformation is simple and must be executed on a schedule. Which Glue component is MOST suitable?

A.Glue Crawler
B.Glue Data Catalog
C.Glue Development Endpoint
D.Glue ETL job
AnswerD

Glue ETL jobs run transformations and can be scheduled.

Why this answer

A Glue ETL job is the most suitable component because it can execute a script (Python/Scala) to transform JSON data into CSV format and can be scheduled to run on a recurring basis. Glue Crawlers only discover and catalog metadata, not transform data. The Glue Data Catalog is a metadata repository, not a transformation tool.

A Glue Development Endpoint is used for interactive development and testing, not for scheduled production jobs.

Full explanation →
823
Multi-Selectmedium

An e-commerce company is building a near-real-time dashboard to monitor customer clickstream data. The data is ingested via Amazon Kinesis Data Streams, transformed using AWS Lambda, and stored in Amazon S3. The team needs to query the data using Amazon Athena. Which THREE steps should be taken to optimize cost and performance? (Choose three.)

Select 3 answers
A.Use AWS Glue Data Catalog to store the table metadata.
B.Store the data in JSON format for flexibility.
C.Convert the data to Apache Parquet or ORC format.
D.Compress the data using gzip or snappy.
E.Partition the data by date in S3 (e.g., year/month/day).
AnswersC, D, E

Columnar formats reduce data scanned and improve compression.

Why this answer

To optimize cost and performance when querying data with Athena, use columnar formats like Parquet or ORC (C) to reduce data scanned and improve compression. Compress data with gzip or Snappy (D) to reduce storage costs and data transferred during queries. Partition data by date (E) to limit the amount of data scanned per query.

Option A (Glue Data Catalog) is a prerequisite, not an optimization step. Option B (JSON) is less efficient than columnar formats for analytical queries.

Exam trap

A common trap is to consider AWS Glue Data Catalog as an optimization step, but it is merely a requirement; the actual optimizations are compression, partitioning, and columnar formats.

Full explanation →
824
MCQeasy

A small startup is building a data pipeline to ingest customer orders from a web application into Amazon Redshift for analytics. The orders are written to an Amazon RDS MySQL database. The startup wants to replicate the orders to Redshift in near-real time (within 5 minutes) with minimal operational overhead. The data volume is low, averaging 100 new orders per minute. The startup has a single data engineer who is also responsible for other tasks. What is the simplest solution?

A.Use AWS Glue with a scheduled job every 5 minutes to copy data from MySQL to Redshift
B.Use Amazon EMR with Spark streaming to read from MySQL and write to Redshift
C.Use an AWS Lambda function to query MySQL every minute and insert into Redshift
D.Use AWS Database Migration Service (DMS) with continuous replication
AnswerD

DMS is purpose-built for database replication and easy to set up.

Why this answer

AWS DMS can continuously replicate from MySQL to Redshift with minimal setup and low overhead. Option A (AWS Glue) is batch-oriented and may not meet the 5-minute latency. Option B (Amazon EMR) is overkill for low data volumes.

Option C (AWS Lambda) requires custom code and may not efficiently handle the replication.

Full explanation →
825
Multi-Selecteasy

A data engineer needs to securely store database credentials for an RDS instance. Which TWO AWS services can be used?

Select 2 answers
A.AWS KMS
B.AWS Secrets Manager
C.AWS IAM
D.AWS CloudFormation
E.AWS Systems Manager Parameter Store
AnswersB, E

Secrets Manager is designed for managing secrets, including automatic rotation.

Why this answer

AWS Secrets Manager is a dedicated service for managing secrets, including automatic rotation. AWS Systems Manager Parameter Store can also securely store secrets like database credentials as secure string parameters. AWS KMS is used for encryption key management, not for storing secrets.

AWS IAM is for identity and access management. AWS CloudFormation is for infrastructure as code and does not natively store secrets.

Full explanation →
Page 10

Page 11 of 23

Page 12

All pages

1234567891011121314151617181920212223

Practice DEA-C01 by domain

Target a specific domain to shore up weak areas.

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