Knowledge + Practice

CCNA Data Ingestion and Transformation Questions

75 of 591 questions · Page 3/8 · Data Ingestion and Transformation · Answers revealed

Practice these questions Domain overview All questions

151

Multi-Selecteasy

A company wants to ingest streaming data from social media feeds into AWS for real-time analytics. Which TWO services can directly ingest streaming data without writing custom code? (Choose TWO.)

Select 2 answers

A.AWS Glue

B.Amazon AppFlow

C.Amazon Kinesis Data Firehose

D.Amazon Kinesis Data Streams

E.Amazon S3 Transfer Acceleration

AnswersB, C

AppFlow can ingest data from SaaS applications (including social media) directly into AWS.

Why this answer

Amazon Kinesis Data Firehose can directly ingest streaming data and deliver to destinations. AWS Glue can stream from Kafka but not directly ingest from social media without custom connectors. Kinesis Data Streams requires producers to send data, not direct ingestion.

AppFlow can ingest from SaaS applications including social media.

Practice this question →

152

MCQeasy

A company uses AWS Lambda to process events from an S3 bucket. The Lambda function writes transformed data to another S3 bucket. Occasionally, the Lambda invocation fails with 'ResourceNotFoundException'. What is the MOST likely cause?

A.The Lambda function timed out.

B.The destination S3 bucket does not exist or the Lambda function's IAM role lacks permissions.

C.The S3 event notification is misconfigured.

D.The source S3 bucket has versioning disabled.

AnswerB

ResourceNotFoundException indicates missing resource or access denial.

Why this answer

The destination bucket may not exist or the Lambda function's IAM role lacks permissions to write to it. Option A is wrong because Lambda timeouts would cause 'Timeout' error. Option C is wrong because S3 event notifications are reliable.

Option D is wrong because the source bucket exists since it triggered the event.

Practice this question →

153

MCQmedium

A company uses AWS Glue to run ETL jobs that transform data from an Amazon S3 bucket (raw) to another S3 bucket (curated). The jobs run on a schedule and process data incrementally. The data engineer notices that the jobs are taking longer to complete each day, and the job metrics show that the number of DPUs (Data Processing Units) is underutilized. The engineer wants to improve job performance. What should the data engineer do?

A.Increase the number of DPUs allocated to the Glue job to enable more parallelism.

B.Switch from batch processing to streaming using AWS Glue Streaming.

C.Enable job bookmarks to skip already processed data more efficiently.

D.Decrease the number of DPUs to reduce resource contention.

AnswerA

Increasing DPUs can improve parallelism and reduce job duration if the workload is parallelizable and DPUs are underutilized.

Why this answer

Increasing the number of DPUs can improve parallelism and reduce job duration when the workload is parallelizable and DPUs are underutilized. Option B is wrong because AWS Glue Streaming is designed for real-time data, not scheduled batch processing, and would not address the performance issue. Option C is wrong because job bookmarks are already used for incremental processing and do not directly impact job speed.

Option D is wrong because decreasing DPUs would reduce parallelism and likely increase job duration.

Practice this question →

154

MCQeasy

A data engineering team needs to transform CSV files to Parquet format after they land in an S3 bucket. The transformation should be triggered automatically as soon as a new file arrives. Which AWS service is best suited for this task?

A.AWS Batch job submitted by S3 event

B.Amazon EMR cluster running continuously

C.AWS Lambda function triggered by S3 event

D.AWS Glue ETL job scheduled every 5 minutes

AnswerC

Lambda can be triggered immediately on S3 PUT events and perform the transformation.

Why this answer

AWS Lambda functions can be directly triggered by S3 events (e.g., `s3:ObjectCreated:*`) to process newly uploaded CSV files. This serverless approach provides near-instantaneous, event-driven transformation to Parquet without managing any infrastructure, making it the most cost-effective and simplest solution for this specific use case.

Exam trap

The trap here is that candidates often choose AWS Glue (Option D) because it is a dedicated ETL service, but they overlook the requirement for immediate, event-driven processing, which Glue's scheduled jobs cannot provide without additional event-bridge triggers.

How to eliminate wrong answers

Option A is wrong because AWS Batch requires provisioning compute resources and a job queue, adding latency and complexity for a simple file transformation that can be handled by a lightweight Lambda function. Option B is wrong because an Amazon EMR cluster running continuously incurs ongoing costs and management overhead, and is overkill for a simple CSV-to-Parquet conversion triggered by file arrival. Option D is wrong because a scheduled AWS Glue ETL job every 5 minutes introduces unnecessary polling and potential latency (up to 5 minutes), whereas the requirement is for immediate, event-driven processing.

Practice this question →

155

Multi-Selectmedium

A company uses Amazon Kinesis Data Firehose to deliver data to Amazon S3. The data engineer needs to transform the data before delivery. Which THREE options can be used to perform the transformation?

Select 3 answers

A.Amazon Athena queries

B.AWS Glue ETL job

C.Amazon Kinesis Data Firehose data format conversion (e.g., JSON to Parquet)

D.AWS Lambda function

E.Amazon Kinesis Data Firehose dynamic partitioning with Lambda

AnswersC, D, E

Firehose can convert data formats natively.

Why this answer

Amazon Kinesis Data Firehose can transform data natively using data format conversion (e.g., converting JSON to Parquet or ORC) without requiring external services. This is a built-in capability that applies schema-based conversion using AWS Glue tables, enabling efficient storage and querying in Amazon S3.

Exam trap

The trap here is that candidates often confuse AWS Glue ETL jobs (which are separate, batch-oriented) with the Glue Data Catalog schema used by Firehose's built-in format conversion, leading them to incorrectly select Glue ETL as a valid Firehose transformation option.

Practice this question →

156

Multi-Selecthard

Which THREE factors should be considered when selecting a data ingestion service for a high-volume, real-time streaming pipeline that requires exactly-once processing semantics? (Choose 3.)

Select 3 answers

A.Ability to replay records from a checkpoint

B.Support for idempotent record processing

C.Integration with Amazon S3 for checkpoint storage

D.Support for schema evolution

E.Ability to transform data in-flight

AnswersA, B, C

Replay allows recovery without duplication.

Why this answer

In high-volume streaming pipelines, the ability to replay records from a checkpoint is essential for achieving exactly-once processing semantics. Services like Amazon Kinesis Data Streams and Apache Kafka allow consumers to reset to a specific sequence number or offset, enabling reprocessing of unacknowledged records after a failure without data loss or duplication.

Exam trap

The DEA-C01 exam often tests the misconception that schema evolution or in-flight transformation are required for exactly-once semantics, when in fact they are unrelated to delivery guarantees and instead belong to data quality or processing domains.

Practice this question →

157

Multi-Selectmedium

Which TWO actions can improve the performance of an AWS Glue ETL job that processes large datasets in Amazon S3? (Choose two.)

Select 2 answers

A.Increase the frequency of the Glue crawler.

B.Use a single Availability Zone for the S3 bucket.

C.Increase the number of DPUs allocated to the job.

D.Use columnar file formats like Parquet or ORC.

E.Use a single large file instead of many small files.

AnswersC, D

More DPUs increase parallelism and memory.

Why this answer

Increasing the number of DPUs allocates more processing power to the Glue job, which can speed up data processing for large datasets. Option D is correct because columnar file formats like Parquet or ORC are more efficient for analytical queries, reduce I/O, and allow better compression compared to row-based formats. Option A is incorrect: increasing crawler frequency only affects the metadata catalog update frequency, not the ETL job performance.

Option B is incorrect: using a single Availability Zone for the S3 bucket does not improve performance and may reduce availability. Option E is incorrect: using a single large file can reduce parallelism, as distributed processing benefits from splitting data into multiple files to be processed in parallel by different executors.

Practice this question →

158

MCQmedium

A data engineer is responsible for ingesting log files from a fleet of on-premises servers into Amazon S3 for central analysis. Each server generates log files that are rotated every hour, resulting in files of about 500 MB each. The total daily data volume is approximately 1 TB. The network connection between the on-premises data center and AWS is a 100 Mbps VPN. The engineer needs to ensure that all log files are transferred to S3 within 24 hours of generation without data loss. The engineer is considering using AWS DataSync. However, the initial setup shows that the transfer speed is insufficient to meet the 24-hour SLA. What should the engineer do to meet the requirement?

A.Use AWS CLI with multipart uploads and parallel threads to maximize throughput.

B.Contact the network team to upgrade the VPN bandwidth to at least 1 Gbps.

C.Order an AWS Snowball Edge device to transfer the initial data and then use DataSync for incremental changes.

D.Configure AWS DataSync to run on a schedule with incremental transfers and enable data compression.

AnswerD

Incremental transfers reduce the amount of data transferred each day; compression further reduces size, meeting the SLA.

Why this answer

AWS DataSync can be configured for incremental transfers after an initial full sync, which reduces the amount of data transferred on a daily basis. Additionally, enabling data compression reduces the size of the log files during transfer, making it feasible to meet the 24-hour SLA over a 100 Mbps VPN. Option A is incorrect because while AWS CLI with multipart uploads can improve throughput, it still requires manual scripting and does not provide the same optimization as DataSync.

Option B is incorrect because upgrading the VPN bandwidth may not be immediately feasible or cost-effective. Option C is incorrect because ordering an AWS Snowball Edge device is intended for large initial data migrations, not for ongoing daily transfers; it would introduce delays and is not suitable for recurring incremental transfers.

Practice this question →

159

Multi-Selectmedium

A company is designing a data ingestion pipeline for real-time clickstream data. The data must be ingested with low latency (< 1 second) and then processed for real-time analytics. The processed data should be stored in Amazon S3 for batch analytics. Which THREE services should be used together?

Select 3 answers

A.Amazon Managed Streaming for Apache Kafka (MSK)

B.Amazon Kinesis Data Analytics

C.Amazon Kinesis Data Firehose

D.Amazon Kinesis Data Streams

E.AWS Glue ETL job

AnswersB, C, D

Performs real-time processing and analytics on streaming data.

Why this answer

Amazon Kinesis Data Analytics is correct because it enables real-time processing of streaming data using SQL or Apache Flink, allowing the company to perform real-time analytics on clickstream data with sub-second latency. It directly consumes data from Kinesis Data Streams and can output results to Kinesis Data Firehose for storage in Amazon S3, fulfilling the requirement for both real-time analytics and batch analytics storage.

Exam trap

The trap here is that candidates often confuse Kinesis Data Firehose as a real-time analytics service, but it is only a delivery stream for loading data into destinations like S3, not for performing real-time computations; the real-time analytics requirement is fulfilled by Kinesis Data Analytics, not Firehose.

Practice this question →

160

MCQhard

A data pipeline uses Amazon Kinesis Data Streams with enhanced fan-out consumers. The team notices that one consumer falls behind and data accumulates. Which action will help this consumer catch up without affecting other consumers?

A.Increase the retention period of the stream.

B.Register an enhanced fan-out consumer for the slow consumer.

C.Increase the number of shards in the stream.

D.Use a Lambda consumer instead of an enhanced fan-out consumer.

AnswerB

Enhanced fan-out provides dedicated throughput per consumer, allowing the slow consumer to catch up without impacting others.

Why this answer

Registering a new enhanced fan-out consumer with its own dedicated read throughput allows it to catch up independently. Increasing shards affects all consumers, and increasing iterator age may help but doesn't increase throughput.

Practice this question →

161

MCQhard

An e-commerce company uses AWS Glue to run ETL jobs that transform clickstream data from Amazon S3. The job reads Parquet files, performs aggregations, and writes the results to Amazon Redshift. The job runs successfully but takes longer than expected. The data volume is increasing. Which design change would MOST improve the job's performance?

A.Write the aggregated results to a single large file instead of multiple partitions.

B.Convert the Parquet files to CSV to simplify the schema.

C.Replace the Redshift target with Amazon Redshift Spectrum.

D.Increase the number of Glue worker nodes (DPUs) for the job.

AnswerD

More workers parallelize tasks and reduce runtime.

Why this answer

Increasing the number of Glue worker nodes (DPUs) directly scales the distributed processing capacity of the ETL job, allowing it to process larger volumes of Parquet data in parallel. This is the most straightforward way to reduce execution time when data volume is growing, as AWS Glue automatically partitions the workload across the additional workers.

Exam trap

The trap here is that candidates assume increasing DPUs always increases cost without considering that the job's runtime reduction often lowers total cost, and they mistakenly choose a data format or target change that does not address the core parallelism issue.

How to eliminate wrong answers

Option A is wrong because writing to a single large file eliminates parallelism in downstream reads and can cause bottlenecks in Redshift's COPY operation, which benefits from multiple files for concurrent loading. Option B is wrong because converting Parquet to CSV increases file size and I/O overhead due to lack of columnar compression and predicate pushdown, degrading performance. Option C is wrong because replacing Redshift with Redshift Spectrum would offload query processing to S3 but does not address the ETL job's performance bottleneck; the job still writes to Redshift, and Spectrum is a query engine, not a write target.

Practice this question →

162

Multi-Selecthard

A company is ingesting streaming data from social media feeds using Amazon Kinesis Data Streams. The data is consumed by multiple applications: one for real-time sentiment analysis and another for archival to S3. The data must be processed in order for each social media post. Which TWO approaches meet the requirements? (Choose TWO.)

Select 2 answers

A.Use Amazon Kinesis Data Firehose to buffer and deliver to S3

B.Use Amazon SQS FIFO queues between the stream and consumers

C.Use a single shard in the Kinesis Data Streams and have all consumers read from that shard

D.Use a partition key that ensures related records go to the same shard

E.Use multiple shards and assign each consumer to a specific shard

AnswersC, D

Single shard guarantees ordering.

Why this answer

Using a single shard ensures that all records are processed in the exact order they are ingested, as Kinesis Data Streams guarantees ordering within a shard. Since both consumers (real-time sentiment analysis and archival to S3) read from the same shard, they will each receive records in the same sequence, meeting the requirement for ordered processing of each social media post.

Exam trap

The trap here is that candidates often assume multiple shards are always better for throughput, but they overlook that ordering guarantees are per-shard only, so without a proper partition key, records across shards can be processed out of order.

Practice this question →

163

MCQeasy

A company needs to ingest data from multiple SaaS applications (e.g., Salesforce, Marketo) into Amazon S3 for centralized analytics. The data volume is several GB per day. Which AWS service is most suitable for this ingestion?

A.Amazon Kinesis Data Firehose

B.AWS Glue

C.Amazon Athena

D.AWS Data Pipeline

AnswerB

Glue can connect to SaaS sources via JDBC and perform ETL to S3.

Why this answer

AWS Glue is the most suitable service because it provides a fully managed ETL (Extract, Transform, Load) capability with built-in connectors for SaaS applications like Salesforce and Marketo. Glue can extract data from these sources, transform it as needed, and write it to Amazon S3, handling the several GB per day volume efficiently without requiring custom code for each source.

Exam trap

The trap here is that candidates often confuse AWS Glue with a data catalog or transformation-only service, overlooking its robust ETL ingestion capabilities with native SaaS connectors, and mistakenly choose Kinesis Data Firehose because it 'ingests' data, but it lacks the necessary source integrations for batch SaaS extraction.

How to eliminate wrong answers

Option A is wrong because Amazon Kinesis Data Firehose is designed for streaming data ingestion (e.g., real-time events, logs) and lacks native connectors for SaaS applications like Salesforce or Marketo; it would require custom producers to push data. Option C is wrong because Amazon Athena is an interactive query service for analyzing data already in S3, not an ingestion tool; it cannot pull data from external SaaS sources. Option D is wrong because AWS Data Pipeline is a legacy orchestration service that requires more manual setup and lacks the modern, pre-built SaaS connectors and serverless scalability that AWS Glue offers for this use case.

Practice this question →

164

Multi-Selecthard

A data pipeline uses AWS Glue to process large CSV files. The team notices that some jobs fail with out-of-memory errors. Which TWO configuration changes can help mitigate this issue?

Select 2 answers

A.Reduce the number of DPUs to limit concurrency.

B.Increase the number of DPUs for the Glue job.

C.Enable Glue job autoscaling.

D.Convert input files from CSV to Parquet.

E.Enable job bookmarks.

AnswersB, C

More DPUs provide more memory.

Why this answer

Options B and C are correct: increasing the number of DPUs provides more memory, and enabling autoscaling allows the job to automatically scale resources as needed. Option A (reducing DPUs) would worsen the problem by limiting resources. Option D (converting to Parquet) can improve performance but is not a direct configuration change for the Glue job itself.

Option E (job bookmarks) is for incremental processing and does not affect memory.

Practice this question →

165

MCQeasy

A company needs to ingest data from an on-premises Oracle database into Amazon Redshift for analytics. The data volume is 500 GB and the network bandwidth is limited. Which AWS service should be used for the initial one-time data migration?

A.AWS Snowball

B.AWS Direct Connect

C.Amazon S3 Transfer Acceleration

D.AWS Database Migration Service (DMS)

AnswerA

Snowball allows physical transfer of data, bypassing network limitations.

Why this answer

AWS Snowball is the correct choice for the initial one-time migration of 500 GB of data from an on-premises Oracle database to Amazon Redshift when network bandwidth is limited. Snowball provides a physical storage device that bypasses network constraints entirely, allowing you to transfer large volumes of data securely and quickly by shipping the device to AWS for ingestion into Amazon S3, which can then be loaded into Redshift. This approach avoids the prolonged transfer times and potential bottlenecks associated with limited bandwidth, making it ideal for a one-time, large-scale data migration.

Exam trap

The trap here is that candidates often choose AWS DMS (Option D) because it is a common database migration tool, but they overlook the explicit constraint of limited network bandwidth, which makes a physical appliance like Snowball the only practical solution for a one-time, large-volume migration.

How to eliminate wrong answers

Option B (AWS Direct Connect) is wrong because it establishes a dedicated network connection from on-premises to AWS, but it does not solve the limited bandwidth problem for a one-time 500 GB migration; the transfer would still be constrained by the available bandwidth, potentially taking days or weeks. Option C (Amazon S3 Transfer Acceleration) is wrong because it speeds up uploads to S3 over the public internet using optimized network paths, but it still relies on the existing limited bandwidth and does not eliminate the network bottleneck for a large initial load. Option D (AWS Database Migration Service (DMS)) is wrong because it is designed for ongoing replication and continuous data migration over a network connection, not for a one-time bulk transfer of 500 GB when bandwidth is limited; DMS would still be constrained by the network speed and is better suited for smaller or incremental migrations.

Practice this question →

166

MCQmedium

A data engineer is designing a data ingestion pipeline to load millions of small JSON files from an on-premises FTP server into Amazon S3. The pipeline should minimize cost and operational overhead. Which approach is most suitable?

A.Use S3 Transfer Acceleration to upload files directly from the FTP server

B.Deploy AWS DataSync to transfer files from the FTP server to S3

C.Use AWS Snowball Edge to ship the data to AWS

D.Set up an AWS Direct Connect connection and use AWS CLI to copy files

AnswerB

AWS DataSync is designed for efficient data transfer from on-premises to AWS, handling small files well with minimal operational overhead.

Why this answer

AWS DataSync is the most suitable option because it is designed to efficiently transfer large volumes of data from on-premises storage (including FTP servers) to AWS, handling millions of small files with minimal operational overhead. It automates data transfer, retries, and validation, and it is cost-effective as you pay only for the data transferred, with no need for additional infrastructure or complex scripting.

Exam trap

The trap here is that candidates often assume S3 Transfer Acceleration is a general-purpose acceleration tool for any source, but it only accelerates the upload leg from the client to AWS and does not address the FTP-to-S3 protocol conversion or the orchestration of millions of small files.

How to eliminate wrong answers

Option A is wrong because S3 Transfer Acceleration is a feature that speeds up uploads over the internet by using AWS edge locations, but it does not handle the protocol mismatch between FTP and S3; you would still need a client to read from FTP and write to S3, and it adds cost per GB transferred without solving the file ingestion logic. Option C is wrong because AWS Snowball Edge is designed for large-scale, offline data transfers (typically terabytes to petabytes) and is overkill and costly for millions of small files; it also introduces significant latency for shipping and manual handling. Option D is wrong because AWS Direct Connect provides a dedicated network connection but does not automate the transfer of files from an FTP server; you would still need to write custom scripts using AWS CLI to copy files, increasing operational overhead and complexity.

Practice this question →

167

MCQhard

A data engineer is troubleshooting a daily batch ingestion pipeline that uses AWS Glue to read CSV files from Amazon S3 and write Parquet files to another S3 bucket. The job runs successfully but takes significantly longer than expected. The engineer notices that the input data is highly skewed with many small files. Which is the most effective optimization to reduce job duration?

A.Change the output format to JSON

B.Enable the 'groupFiles' option in the S3 source configuration

C.Increase the number of DPUs allocated to the job

D.Enable the 'use_glue_schema_registry' option

AnswerB

Grouping small files into larger splits reduces task overhead and improves performance.

Why this answer

The 'groupFiles' option in AWS Glue's S3 source configuration allows Glue to combine small files into larger splits, reducing the number of tasks and the overhead associated with processing many small files. This directly addresses the high skew and small file issue, significantly reducing job duration. Option A is incorrect because changing the output format from Parquet to JSON would likely increase file size and processing time, not reduce it.

Option C is incorrect because increasing DPUs may improve parallelism but does not solve the file-level overhead; it could even be wasteful if the bottleneck is task scheduling. Option D is incorrect because enabling the schema registry is unrelated to file grouping; it is used for schema management and validation.

Practice this question →

168

MCQmedium

A retail company uses Amazon Kinesis Data Firehose to ingest clickstream data from its website into an Amazon S3 bucket. The data includes fields: user_id, event_type, timestamp, page_url. Recently, the data engineering team noticed that some records have malformed JSON (missing commas, extra brackets) causing delivery failures to S3. The Firehose delivery stream is configured to retry failed records for 300 seconds, after which the records are sent to an S3 bucket for failed records. The team wants to transform the data to correct malformed JSON before delivery to the main S3 bucket. They need a solution that does not require managing servers and can handle high throughput. What should the team do?

A.Configure an AWS Lambda function as a data transformation in Kinesis Data Firehose to correct malformed JSON.

B.Set up an Amazon EMR cluster with Apache Spark to process the data in micro-batches and fix JSON errors.

C.Use an AWS Glue streaming ETL job to read from Firehose and write corrected data to S3.

D.Use Amazon Kinesis Data Analytics with a SQL application to parse and fix JSON.

AnswerA

Firehose supports Lambda transformations for record-level processing; it scales automatically.

Why this answer

AWS Lambda can be used as a data transformation function within Kinesis Data Firehose to process each record individually, fixing malformed JSON without managing servers. The Lambda function receives records in batches, transforms them (e.g., parsing and correcting JSON syntax), and returns them to Firehose for delivery to S3. This serverless approach scales automatically with high throughput.

Option B (EMR with Spark) requires managing a cluster and adds latency, making it less suitable for real-time streaming. Option C (Glue streaming ETL) is serverless but introduces more complexity and potential latency compared to Firehose's built-in Lambda transformation. Option D (Kinesis Data Analytics) is designed for real-time analytics and not for record-level transformations like JSON correction.

Practice this question →

169

Drag & Dropmedium

Arrange the steps to create an AWS Glue job that transforms data from Amazon S3 to Amazon Redshift in the correct order.

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, catalog the source data with a crawler. Then, prepare the ETL script. Configure the job with connections, run it, and finally verify the results in Redshift.

Practice this question →

170

Multi-Selectmedium

A company uses AWS Glue to transform data in S3. The Glue job fails with memory errors. Which THREE actions can help resolve this?

Select 3 answers

A.Optimize the transformation to use pushdown predicates.

B.Use a larger worker type (e.g., G.2X).

C.Increase the number of DPUs.

D.Increase the job timeout.

E.Decrease the number of DPUs.

AnswersA, B, C

Pushdown predicates reduce data loaded into memory.

Why this answer

Options A, B, and C are correct. Using pushdown predicates (A) reduces the amount of data read by filtering at the data source, which can alleviate memory pressure. Using a larger worker type (B), such as G.2X, increases the memory available per worker, directly addressing out-of-memory errors.

Increasing the number of DPUs (C) adds more workers, distributing the memory load. Option D (increasing job timeout) does not solve memory issues, and Option E (decreasing DPUs) would reduce available memory, making the problem worse.

Practice this question →

171

MCQmedium

A company wants to migrate on-premises data to Amazon S3 using AWS DataSync. The data is 10 TB and the network bandwidth is 1 Gbps. The migration must be completed within 48 hours. What should the data engineer do to meet the deadline?

A.Use S3 Transfer Acceleration to speed up the transfer

B.Use AWS Snowball Edge to transfer the data physically

C.Use AWS DataSync with multiple agents and enable data compression

D.Request a bandwidth increase from the ISP

AnswerC

Multiple agents and compression maximize throughput to meet the deadline.

Why this answer

AWS DataSync can use multiple agents in parallel to increase throughput, and enabling data compression reduces the amount of data transferred over the network. With 10 TB at 1 Gbps, the theoretical minimum transfer time is about 22.2 hours, but real-world overhead (protocol, retransmissions) often exceeds 48 hours without parallelism and compression. Multiple agents and compression together can achieve the required throughput within the deadline.

Exam trap

The trap here is that candidates assume S3 Transfer Acceleration is a bandwidth booster, but it only reduces latency for small objects over long distances, not the total transfer time for large datasets constrained by bandwidth.

How to eliminate wrong answers

Option A is wrong because S3 Transfer Acceleration improves latency for long-distance transfers by routing traffic through AWS edge locations, but it does not increase bandwidth or reduce the total data volume; it cannot compensate for the fundamental 1 Gbps bottleneck for 10 TB within 48 hours. Option B is wrong because AWS Snowball Edge is a physical device used for offline data transfer, which is unnecessary when the network is available and the deadline can be met with DataSync optimizations; it also introduces shipping delays that may exceed 48 hours. Option D is wrong because requesting a bandwidth increase from the ISP is not a practical or immediate solution within the control of the data engineer, and it assumes the ISP can provision higher bandwidth instantly, which is unrealistic for a 48-hour window.

Practice this question →

172

MCQhard

Refer to the exhibit. A data engineer runs an AWS Glue job that fails with an 'Access Denied' error when writing to S3. The IAM role attached to the job has s3:PutObject permission on the output bucket. What additional configuration is most likely missing?

A.The Glue job is not configured to write to S3 with the correct prefix

B.The S3 bucket policy does not grant access to the Glue job's IAM role

C.The Glue job is running in a VPC without an S3 VPC endpoint

D.The S3 bucket is encrypted with AWS KMS and the IAM role lacks kms:Decrypt permission

AnswerB

Even if IAM allows, bucket policy can deny; this is a common misconfiguration.

Why this answer

The IAM role attached to the Glue job has s3:PutObject permission, but the S3 bucket policy must explicitly grant access to that IAM role (or its principal) for the write operation to succeed. Even if the IAM role allows the action, the bucket policy acts as a separate access control layer; if it denies or does not include the role, the request fails with 'Access Denied'. This is a common cross-account or service-specific permission issue where both identity-based and resource-based policies must align.

Exam trap

The DEA-C01 exam often tests the misconception that IAM permissions alone are sufficient for S3 access, ignoring that bucket policies (resource-based policies) are a separate authorization layer that must also grant the action, especially in cross-account or service-specific contexts.

How to eliminate wrong answers

Option A is wrong because the prefix configuration affects the object key path, not the fundamental permission to write; an incorrect prefix would cause a different error (e.g., 'NoSuchKey' or a path mismatch), not an 'Access Denied' error. Option C is wrong because a missing S3 VPC endpoint would cause a connectivity timeout or 'No route to host' error, not an 'Access Denied' error; the error message specifically indicates a permissions failure, not a network issue. Option D is wrong because if KMS encryption were the issue, the error would explicitly mention 'kms:Decrypt' or 'kms:GenerateDataKey' in the denial message, and the IAM role would need kms:Encrypt (not decrypt) for writing; the generic 'Access Denied' without KMS context points to a bucket policy mismatch.

Practice this question →

173

MCQeasy

A company streams clickstream data from websites to Amazon Kinesis Data Streams. A Lambda function processes each record and writes it to Amazon S3. Recently, the function has been timing out under high load. Which solution should a data engineer implement to handle the increased throughput?

A.Increase the Lambda function's timeout value.

B.Increase the number of shards in the Kinesis data stream.

C.Increase the memory allocated to the Lambda function.

D.Configure Amazon S3 Event Notifications to trigger Lambda directly.

AnswerB

More shards increase parallelism and allow Lambda to process more records concurrently.

Why this answer

Increasing the number of shards in the Kinesis data stream increases the level of parallelism. Each shard can be processed by a separate Lambda invocation, allowing more concurrent processing of records. This directly addresses the high load and timeout issue.

Option A is incorrect because increasing the timeout does not increase throughput; it only allows the function to run longer, but under high load it will still timeout. Option C is incorrect because increasing memory may improve performance per invocation but does not increase the number of concurrent invocations; the bottleneck is limited by the number of shards. Option D is incorrect because S3 Event Notifications are for object creation events in S3, not for real-time streaming; they do not help with Kinesis ingestion.

Practice this question →

174

MCQeasy

A company is streaming clickstream data from a website into Amazon Kinesis Data Streams. The data must be transformed in near real-time and stored in Amazon S3 for analytics. Which AWS service should be used to transform the data as it is ingested?

A.AWS Lambda (streaming function)

B.Amazon EMR (Spark Streaming)

C.AWS Glue (ETL jobs)

D.Amazon Kinesis Data Analytics

AnswerD

Amazon Kinesis Data Analytics can process and transform streaming data in real-time using SQL or Apache Flink.

Why this answer

Amazon Kinesis Data Analytics is the correct choice because it can process and transform streaming data in near real-time using SQL or Apache Flink, and then output the transformed data to destinations like Amazon S3. This service is specifically designed for real-time stream processing, making it ideal for transforming clickstream data as it is ingested into Kinesis Data Streams.

Exam trap

The trap here is that candidates often confuse AWS Glue's batch ETL capabilities with real-time streaming, or assume Lambda is always the best choice for stream processing, overlooking Kinesis Data Analytics' native support for continuous, stateful transformations.

How to eliminate wrong answers

Option A is wrong because AWS Lambda (streaming function) can process Kinesis streams but is not optimized for complex transformations or stateful operations, and it has a maximum execution time of 15 minutes, making it less suitable for continuous near real-time transformations. Option B is wrong because Amazon EMR (Spark Streaming) is a heavy-weight, cluster-based solution that introduces significant latency and operational overhead for simple transformations, and it is not the most efficient choice for near real-time processing of streaming data. Option C is wrong because AWS Glue (ETL jobs) is designed for batch processing and scheduled ETL, not for real-time stream transformations, and it cannot directly consume data from Kinesis Data Streams in a streaming fashion.

Practice this question →

175

MCQmedium

A retail company uses AWS Glue to process daily sales data from multiple CSV files stored in Amazon S3. The Glue job runs a PySpark script that reads the files, performs joins, and writes the output as Parquet. Recently, the job has been failing with 'Out of Memory' errors. The data volume has grown from 10 GB to 50 GB per day. The Glue job uses 10 DPUs and the standard worker type. The data engineer needs to fix the job without rewriting the script. What should the data engineer do?

A.Split the input CSV files into smaller partitions.

B.Change the worker type to G.2X to get more memory per worker.

C.Decrease the number of DPUs to reduce memory contention.

D.Increase the number of DPUs for the Glue job to 20.

AnswerB

Changing to G.2X worker type doubles the memory per DPU, which directly addresses Out of Memory errors by providing more per-executor memory for operations like joins.

Why this answer

Out of Memory errors in AWS Glue are typically caused by insufficient per-executor memory during operations like joins. Changing the worker type to G.2X doubles the memory per DPU (from 16 GB to 32 GB), directly addressing the OOM issue without rewriting the script. Option D is wrong because increasing the number of DPUs adds more executors but does not increase the memory per executor; it only increases parallelism, which may not resolve OOM if a single executor runs out of memory.

Option A (splitting input files) does not reduce the memory footprint of joins. Option C (decreasing DPUs) reduces resources and worsens the problem.

Practice this question →

176

MCQhard

A company needs to ingest real-time clickstream data from a web application into Amazon Redshift with minimal latency. The data volume is high and requires processing before loading. Which architecture is MOST appropriate?

A.AWS Glue ETL jobs scheduled every 5 minutes -> Redshift

B.S3 -> Lambda -> Redshift

C.DynamoDB Streams -> Lambda -> Redshift

D.Kinesis Data Streams -> Kinesis Data Firehose -> Redshift

AnswerD

Provides real-time ingestion with transformation capability.

Why this answer

D is correct because Kinesis Data Streams captures high-volume clickstream data in real time, and Kinesis Data Firehose can buffer, transform (e.g., with Lambda), and load the data directly into Amazon Redshift with near-zero latency. This architecture is purpose-built for streaming ingestion with minimal overhead, unlike batch or intermediary storage approaches.

Exam trap

The trap here is that candidates often confuse 'real-time' with 'near-real-time' and choose a batch option like Glue (A) or an indirect streaming path like S3 -> Lambda (B), failing to recognize that Kinesis Data Firehose is the only AWS service that natively integrates streaming ingestion with Redshift without additional latency or complexity.

How to eliminate wrong answers

Option A is wrong because AWS Glue ETL jobs scheduled every 5 minutes introduce batch latency, which violates the 'minimal latency' requirement for real-time clickstream data. Option B is wrong because S3 -> Lambda -> Redshift requires Lambda to write to Redshift, which is inefficient for high-volume streaming data due to Lambda's invocation limits and lack of native streaming buffering, plus S3 adds an unnecessary intermediate storage hop. Option C is wrong because DynamoDB Streams are designed for change data capture from DynamoDB tables, not for ingesting raw clickstream data from a web application; it would require an additional service to capture the data into DynamoDB first, adding complexity and latency.

Practice this question →

177

Matchingmedium

Match each AWS database service to its primary use case.

Drag a concept onto its matching description — or click a concept then click the description.

Concepts

Matches

Relational database with managed operations

NoSQL key-value and document database

In-memory caching for low latency

Graph database for connected data

Time-series data for IoT and analytics

Why these pairings

Correct matches: RDS -> OLTP relational, DynamoDB -> NoSQL low-latency, Redshift -> data warehousing, ElastiCache -> in-memory caching. Common confusions include swapping RDS and DynamoDB use cases.

Practice this question →

178

MCQhard

A company is using AWS Database Migration Service (DMS) to migrate a 2 TB MySQL database to Amazon Aurora MySQL. The migration is taking longer than expected. The source database is in a different AWS region. Which change would MOST likely improve the migration speed?

A.Use a smaller DMS replication instance to reduce costs.

B.Use a Multi-AZ deployment for the DMS replication instance in the target region.

C.Increase the number of parallel tables being migrated.

D.Disable binary logging on the source MySQL database.

AnswerC

Increasing the number of parallel tables allows DMS to migrate multiple tables at once, utilizing more of the available bandwidth and reducing total migration time, especially for a large database.

Why this answer

Increasing the number of parallel tables allows DMS to migrate multiple tables simultaneously, leveraging available bandwidth and reducing overall migration time. This is particularly effective for large databases (2 TB) where serial migration would be slow. Option B is incorrect because Multi-AZ provides high availability, not performance improvement; it adds overhead and does not reduce network latency.

Option A reduces resources, making migration slower. Option D disables binary logging, which is needed for ongoing replication and can cause data loss or require a full re-sync.

Exam trap

Candidates often confuse Multi-AZ with performance improvement, but Multi-AZ is solely for high availability. For cross-region migrations, the bottleneck is network bandwidth; increasing parallelism is the most effective way to improve throughput.

Practice this question →

179

MCQmedium

A company is using AWS Glue to process data from Amazon S3. The Glue job reads CSV files and writes Parquet files to a different S3 bucket. The job occasionally fails with 'java.lang.OutOfMemoryError: Java heap space'. The data size varies. Which change should the engineer make to avoid this error?

A.Increase the number of DPUs allocated to the Glue job.

B.Convert the CSV files to JSON format before processing.

C.Decrease the Spark shuffle partitions in the job script.

D.Increase the job timeout setting.

AnswerA

More DPUs provide more memory and compute resources.

Why this answer

The 'java.lang.OutOfMemoryError: Java heap space' error in AWS Glue indicates that the Spark executors ran out of memory while processing the data. Increasing the number of DPUs (Data Processing Units) allocated to the Glue job increases the total memory available across the cluster, allowing larger datasets to be processed without hitting the heap limit. Each DPU provides 4 vCPUs and 16 GB of memory, so adding more DPUs scales memory linearly.

Exam trap

The trap here is that candidates often confuse 'increasing DPUs' with 'increasing parallelism' and assume it only speeds up jobs, but in reality it also increases total memory, which directly mitigates heap space errors.

How to eliminate wrong answers

Option B is wrong because converting CSV to JSON does not reduce memory pressure; JSON is typically more verbose than CSV and would increase memory consumption. Option C is wrong because decreasing Spark shuffle partitions reduces parallelism and can cause each partition to hold more data, worsening memory issues and potentially increasing the risk of OutOfMemoryError. Option D is wrong because increasing the job timeout setting only extends the maximum runtime before the job is killed; it does not address memory constraints or prevent heap space errors.

Practice this question →

180

MCQeasy

A company needs to ingest data from a relational database into Amazon S3 for analytics. The database is an Amazon RDS MySQL instance. Which AWS service should be used for a one-time historical data load?

A.AWS Database Migration Service (DMS)

B.AWS Glue ETL

C.Amazon Athena

D.Amazon Kinesis Data Firehose

AnswerA

DMS supports full load from RDS to S3.

Why this answer

AWS Database Migration Service (DMS) is the correct choice for a one-time historical data load from Amazon RDS MySQL to Amazon S3. DMS supports full-load migrations from relational databases to S3, making it ideal for this use case. AWS Glue ETL can also perform similar tasks but is more suited for complex transformations and scheduled jobs, and DMS is the dedicated service for database migrations.

Amazon Athena is a query service, not an ingestion tool. Amazon Kinesis Data Firehose is designed for streaming data, not one-time loads.

Practice this question →

181

MCQmedium

A data engineer is using AWS Glue ETL to transform data from an S3 data lake. The job fails with a memory error. Which approach should be used to resolve this issue without major code changes?

A.Rewrite the ETL script in PySpark instead of Scala

B.Change the input file format from CSV to Parquet

C.Increase the number of DPUs allocated to the Glue job

D.Use Amazon EMR instead of AWS Glue

AnswerC

Increasing the number of DPUs allocated to the Glue job directly increases memory and parallelism, which helps resolve memory errors without major code changes.

Why this answer

Increasing the number of DPUs (Data Processing Units) allocated to the Glue job provides more memory and parallelism. Option A is wrong because rewriting in PySpark is a major code change. Option B is wrong because using a smaller file format may not address memory issues.

Option D is wrong because using a different service is unnecessary.

Practice this question →

182

MCQeasy

A company uses Amazon Kinesis Data Firehose to deliver data to an Amazon S3 bucket. The data delivery is delayed by up to 5 minutes. The engineer wants to reduce the delay to under 1 minute. Which parameter should be adjusted?

A.Enable error logging to CloudWatch.

B.Increase the buffer size in Kinesis Data Firehose.

C.Enable data compression.

D.Decrease the buffer interval in Kinesis Data Firehose.

AnswerD

Lower buffer interval triggers deliveries more frequently.

Why this answer

Decreasing the buffer interval reduces the time Kinesis Data Firehose waits before delivering a batch, thus lowering latency to under 1 minute. Option A is incorrect because error logging to CloudWatch does not affect delivery timing. Option B is incorrect because increasing the buffer size would actually increase the delay as Firehose waits for more data to accumulate.

Option C is incorrect because enabling data compression reduces storage size but has no impact on delivery frequency.

Practice this question →

183

MCQeasy

A data pipeline uses Amazon Kinesis Data Firehose to deliver data to Amazon S3. The delivery occasionally fails with 'Firehose is throttled'. What should be done to reduce throttling?

A.Enable compression on the Firehose delivery stream

B.Increase the buffer size and buffer interval

C.Decrease the buffer size to flush more frequently

D.Increase the number of shards in the Kinesis stream

AnswerB

Larger buffer reduces the number of write requests.

Why this answer

Increasing the buffer size and buffer interval gives Kinesis Data Firehose more time and data volume to accumulate before delivering to S3, reducing the frequency of PutRecord.Batch calls to the underlying Kinesis stream. This directly mitigates throttling by lowering the request rate, as Firehose throttling typically occurs when the per-shard write throughput limit (1,000 records/second or 1 MB/second) is exceeded.

Exam trap

The DEA-C01 exam often tests the misconception that Firehose throttling is resolved by scaling shards (like in Kinesis Data Streams), but Firehose manages its own internal shards and the correct fix is to adjust buffer settings to reduce API call frequency.

How to eliminate wrong answers

Option A is wrong because enabling compression reduces the data size sent to S3 but does not reduce the number of API calls or the request rate to the Kinesis stream, so it does not address throttling at the stream level. Option C is wrong because decreasing the buffer size causes more frequent flushes, which increases the request rate and exacerbates throttling rather than reducing it. Option D is wrong because Kinesis Data Firehose does not use a Kinesis data stream as its source by default; it uses its own internal stream with a fixed number of shards (default 1), and increasing shards is not a configurable option for Firehose—this option confuses Firehose with Kinesis Data Streams.

Practice this question →

184

MCQmedium

A data engineering team is designing a data ingestion pipeline that will receive millions of small JSON files per hour from external partners via API. The files should be stored in Amazon S3 and then transformed into Parquet for querying. Which approach is MOST cost-effective and scalable?

A.Use Amazon Kinesis Data Firehose to buffer and deliver data to S3, then use AWS Glue to convert to Parquet.

B.Use AWS Lambda to process each file as it arrives and write to S3.

C.Use AWS Direct Connect to establish a dedicated network for file uploads.

D.Use Amazon EMR to process the files as they arrive in S3.

AnswerA

Firehose can ingest high throughput, buffer, and deliver to S3; Glue can run scheduled conversions.

Why this answer

Amazon Kinesis Data Firehose is the most cost-effective and scalable approach because it can buffer millions of small JSON files per hour, automatically batch them, and deliver them to S3 without requiring any server management. After delivery, AWS Glue can efficiently convert the JSON data to Parquet format for optimized querying, leveraging its serverless, pay-per-use model that scales with data volume.

Exam trap

The trap here is that candidates often choose AWS Lambda for its simplicity, overlooking its concurrency limits, timeout constraints, and cost inefficiency when handling high-frequency, small-file ingestion at scale.

How to eliminate wrong answers

Option B is wrong because AWS Lambda has a maximum execution timeout of 15 minutes and a concurrency limit, making it impractical for processing millions of small files per hour; it would also incur high costs due to per-invocation charges and cold starts. Option C is wrong because AWS Direct Connect is a dedicated network connection for consistent bandwidth and low latency, not a data ingestion or transformation service; it does not handle file processing or format conversion. Option D is wrong because Amazon EMR is designed for large-scale batch processing using frameworks like Spark or Hadoop, and using it for continuous, real-time ingestion of small files would be over-provisioned, costly, and inefficient due to cluster startup times and idle resource costs.

Practice this question →

185

MCQeasy

A data engineer is setting up a data pipeline to ingest data from an Amazon RDS for MySQL database into Amazon S3 using AWS Glue ETL. The Glue job uses a JDBC connection to read from the MySQL database. The job runs successfully, but the engineer notices that the job is taking longer than expected. The MySQL database is 500 GB in size and the Glue job uses 10 workers of type G.1X. The engineer wants to improve the performance of the extraction phase. The database is actively used by other applications, so the engineer must minimize the impact on the source database. Which approach should the engineer take?

A.Partition the table by a numeric column, such as the primary key, and use the 'hashex' or 'hashpar' partitioning option in the Glue JDBC connection.

B.Use an incremental extraction strategy with a watermark column to reduce the amount of data read each time.

C.Create a read replica of the MySQL database and configure the Glue job to read from the replica.

D.Increase the number of Glue workers to 20 to increase parallelism.

AnswerA

Partitioning the table by a numeric column (e.g., primary key) and using the 'hashex' or 'hashpar' partitioning option in the Glue JDBC connection enables parallel reads across multiple workers, reducing the load on the MySQL database and improving extraction performance.

Why this answer

Partitioning the table on a key column (e.g., primary key) allows Glue to read in parallel from multiple partitions, reducing the load on the database and improving performance. Option B is wrong because incremental extraction is for ongoing changes, not for an initial full load; it doesn't address the immediate performance issue of extracting 500 GB. Option C is wrong because using a read replica offloads read traffic but does not inherently improve parallelism; partitioning is still needed for performance.

Option D is wrong because simply increasing the number of workers may overwhelm the database with more simultaneous connections without partitioning, potentially causing performance degradation.

Practice this question →

186

MCQmedium

A company uses AWS Glue ETL jobs to transform data from Amazon RDS to Amazon S3 daily. The job recently started failing with memory errors. The data volume has grown 3x in the past month. Which change should the data engineer make to resolve the issue?

A.Increase the size of the Amazon RDS instance

B.Switch the Glue job type from Python Shell to Spark

C.Partition the output data in Amazon S3 by date

D.Increase the number of DPUs allocated to the Glue job

AnswerD

More DPUs provide more memory to handle larger data volumes.

Why this answer

The Glue job is failing with memory errors due to a 3x increase in data volume. Increasing the number of DPUs (Data Processing Units) allocated to the job provides more memory and compute resources, directly addressing the out-of-memory condition without changing the job logic or architecture.

Exam trap

The trap here is that candidates may confuse scaling the source database (RDS) with scaling the ETL compute (Glue), or assume that output partitioning (S3) will fix an in-memory processing error, when the actual solution is to increase the compute resources allocated to the Glue job.

How to eliminate wrong answers

Option A is wrong because increasing the RDS instance size does not affect the memory available to the Glue ETL job; the bottleneck is in the Glue execution environment, not the source database. Option B is wrong because switching from Python Shell to Spark would change the execution model but does not inherently resolve memory errors; Python Shell jobs are limited to a single executor with fixed memory, while Spark jobs distribute work but still require sufficient DPUs to handle the data volume. Option C is wrong because partitioning output data in S3 by date improves query performance and cost but does not reduce the memory footprint of the Glue job during the transformation phase; the memory error occurs during processing, not during writing.

Practice this question →

187

Multi-Selecthard

A company is streaming IoT sensor data from thousands of devices into Amazon Kinesis Data Firehose. The data is then delivered to Amazon S3 for long-term storage. Occasionally, some records fail to be delivered to S3. The company must capture and analyze these failed records. Which TWO actions should be taken? (Choose two.)

Select 2 answers

A.Configure an AWS Lambda function as a pre-processing step to catch and log failed records.

B.Use Amazon Kinesis Data Analytics to analyze the failed records in real time.

C.Send failed records to an Amazon Kinesis Data Stream for reprocessing.

D.Enable Amazon CloudWatch Logs for Kinesis Data Firehose to capture delivery errors.

E.Set up an S3 event notification to trigger a Lambda function to reprocess failed records.

AnswersA, D

Lambda can handle errors during transformation and log them.

Why this answer

Configuring an AWS Lambda function as a pre-processing step in Kinesis Data Firehose can catch and log failed records during data transformation. Option D is correct because enabling Amazon CloudWatch Logs for Kinesis Data Firehose captures delivery errors, allowing analysis of failed deliveries. Option B is incorrect because Amazon Kinesis Data Analytics is for real-time analytics, not for handling delivery failures from Firehose.

Option C is incorrect because sending failed records to a Kinesis Data Stream would require additional infrastructure and is not the direct way to capture failures; CloudWatch Logs provides the necessary error logging. Option E is incorrect because S3 event notifications are triggered after successful delivery, not for failed records.

Practice this question →

188

Multi-Selecthard

A data engineer needs to transform data in Amazon S3 using AWS Glue. The job must handle schema evolution and partition pruning. Which THREE features should be used?

Select 3 answers

A.AWS Glue Data Catalog

B.AWS Glue job bookmarks

C.AWS Glue FindMatches transform

D.AWS Glue crawlers

E.Partition indexes

AnswersA, D, E

The Data Catalog stores schema and partition metadata.

Why this answer

AWS Glue Data Catalog (A) is correct because it acts as a central metadata repository that stores table definitions and schema information. When schema evolution occurs (e.g., new columns are added in Parquet or JSON data), the Data Catalog can be updated via crawlers or manual schema registration, allowing Glue ETL jobs to dynamically adapt to changing schemas without hardcoding column structures.

Exam trap

The DEA-C01 exam often tests the distinction between 'incremental processing' (job bookmarks) and 'schema evolution' (Data Catalog + crawlers), leading candidates to incorrectly select job bookmarks for schema changes.

Practice this question →

189

MCQhard

A data engineer is designing a data ingestion pipeline for a social media analytics platform. The pipeline must ingest tweets in real-time, perform sentiment analysis, and store results in Amazon S3. The sentiment analysis is compute-intensive and must be done as the data arrives. The estimated throughput is 10,000 tweets per second. Which architecture is most suitable?

A.Amazon SQS with AWS Lambda pollers to process tweets and store in S3.

B.Amazon EMR with Spark Streaming to process tweets and write to S3.

C.Amazon Kinesis Data Streams with Amazon Kinesis Data Analytics for sentiment analysis, then Kinesis Data Firehose to S3.

D.Amazon API Gateway with AWS Lambda to process each tweet and store in S3.

AnswerC

Scalable real-time stream processing.

Why this answer

The most suitable because Amazon Kinesis Data Streams can ingest up to 10,000 records per second per shard (with shard-level scaling), and Kinesis Data Analytics provides built-in, low-latency stream processing for compute-intensive sentiment analysis using SQL or Apache Flink. Kinesis Data Firehose then reliably buffers and writes the processed results to Amazon S3 without custom code, ensuring near-real-time delivery.

Exam trap

The trap here is that candidates often choose SQS+Lambda (Option A) for simplicity, underestimating the throughput ceiling and polling overhead, while overlooking Kinesis Data Analytics as the only AWS-managed service that natively supports real-time, compute-intensive stream processing without custom infrastructure.

How to eliminate wrong answers

Option A is wrong because Amazon SQS with Lambda pollers introduces polling latency and cannot efficiently handle 10,000 tweets per second; Lambda has a maximum concurrency limit and SQS batch sizes are capped at 10 messages, leading to throttling and backpressure. Option B is wrong because Amazon EMR with Spark Streaming is designed for large-scale batch and micro-batch processing, not for true real-time, per-record sentiment analysis at 10,000 TPS; it incurs startup overhead and is better suited for historical analysis. Option D is wrong because Amazon API Gateway with Lambda processes each tweet synchronously, which cannot sustain 10,000 requests per second without aggressive throttling and cold starts; it also lacks built-in stream buffering and ordering for real-time ingestion.

Practice this question →

190

MCQhard

A data engineer runs an AWS Glue crawler that is configured to crawl an S3 bucket named 'my-data-lake' and update the Glue Data Catalog. The crawler fails with an access denied error. The IAM role attached to the crawler has the policy shown in the exhibit. What is the likely cause of the failure?

A.The policy does not allow glue:CreateTable on the 'my-data-lake' database.

B.The policy does not allow s3:PutObject on the 'my-data-lake' bucket.

C.The policy does not allow logging to CloudWatch Logs.

D.The policy does not allow s3:ListBucket on the 'my-data-lake' bucket.

AnswerC

Glue crawlers require permissions to create log groups and streams and write logs; the policy lacks logs:CreateLogGroup, logs:CreateLogStream, and logs:PutLogEvents.

Why this answer

AWS Glue crawlers require permissions to write logs to CloudWatch Logs for monitoring and debugging. Without the `logs:CreateLogGroup`, `logs:CreateLogStream`, and `logs:PutLogEvents` actions, the crawler fails with an access denied error even if it has S3 and Glue Data Catalog permissions. The IAM policy shown does not include these CloudWatch Logs permissions, making option C the correct answer.

Exam trap

The trap here is that candidates focus on S3 and Glue Data Catalog permissions, overlooking the mandatory CloudWatch Logs permissions required for AWS Glue crawlers to run successfully.

How to eliminate wrong answers

Option A is wrong because the policy includes `glue:CreateTable` on the `my-data-lake` database (as shown in the exhibit), so this is not the cause of the failure. Option B is wrong because the crawler does not need `s3:PutObject` on the bucket; it only reads data from S3, and the policy includes `s3:GetObject` and `s3:ListBucket` for the bucket. Option D is wrong because the policy explicitly allows `s3:ListBucket` on the `my-data-lake` bucket, so this permission is not missing.

Practice this question →

191

MCQmedium

A logistics company ingests real-time GPS location data from thousands of delivery vehicles into Amazon Kinesis Data Streams. Each vehicle sends a JSON payload every 10 seconds containing vehicle_id, latitude, longitude, timestamp, and speed. The data must be stored in Amazon S3 for historical analysis, but the company wants to first aggregate the data per vehicle per minute (average speed, min/max coordinates) to reduce storage costs. The solution must be serverless and handle potential duplicate records without double-counting. What should the engineer do?

A.Use Amazon EMR with Spark Streaming to perform the aggregation and write to S3.

B.Use Amazon Kinesis Data Analytics for Apache Flink to aggregate data in a 1-minute tumbling window with deduplication logic, then output to Kinesis Data Firehose for delivery to S3.

C.Use Kinesis Data Firehose with a Lambda transformation to aggregate records in a 1-minute window.

D.Use an AWS Glue streaming ETL job with Spark Structured Streaming to aggregate and deduplicate.

AnswerB

Flink supports windowed aggregations and stateful deduplication; Firehose delivers to S3.

Why this answer

Amazon Kinesis Data Analytics for Apache Flink can process streaming data with tumbling windows (1-minute) to aggregate per vehicle per minute, and Flink's stateful processing allows deduplication to avoid double-counting. The output is then sent to Kinesis Data Firehose for persistent storage in Amazon S3, all serverless. Option A (EMR with Spark Streaming) is not serverless.

Option C (Kinesis Data Firehose with Lambda transformation) cannot perform stateful windowed aggregation and deduplication efficiently—it processes events individually without maintaining state across records. Option D (AWS Glue streaming ETL job) is serverless but adds higher latency and complexity compared to Kinesis Data Analytics, and is not as optimized for low-latency streaming aggregations with deduplication.

Practice this question →

192

MCQmedium

A company uses AWS Glue to process streaming data from Amazon Kinesis Data Streams. The data is JSON formatted and includes a timestamp field. The company wants to partition the output in Amazon S3 by date and hour, and ensure exactly-once processing semantics. Which combination of configurations should be used?

A.Disable checkpointing and use the 'exactly_once' delivery option in Kinesis Data Streams.

B.Enable checkpointing in the AWS Glue streaming job and specify an S3 location for checkpoint data.

C.Use Amazon DynamoDB as a checkpoint store by configuring the Glue job with a DynamoDB connection.

D.Use Kinesis Client Library (KCL) checkpointing with a DynamoDB table.

AnswerB

Glue streaming jobs support checkpointing to S3 for exactly-once processing.

Why this answer

AWS Glue streaming jobs require checkpointing to track the progress of data consumption from Kinesis Data Streams and to ensure exactly-once processing semantics. By enabling checkpointing and specifying an S3 location, Glue periodically saves the state of processed records, allowing it to resume from the last committed offset in case of failures, thus preventing duplicates or data loss.

Exam trap

The trap here is that candidates confuse the checkpointing mechanism of AWS Glue (which uses S3) with the Kinesis Client Library (KCL) pattern (which uses DynamoDB), leading them to select option D or C, even though Glue streaming jobs do not support DynamoDB for checkpointing.

How to eliminate wrong answers

Option A is wrong because disabling checkpointing removes the mechanism for tracking processed records, making exactly-once semantics impossible; the 'exactly_once' delivery option in Kinesis Data Streams refers to producer-side delivery guarantees, not consumer-side processing semantics. Option C is wrong because AWS Glue streaming jobs do not support DynamoDB as a checkpoint store; they only support S3 for checkpoint data. Option D is wrong because Kinesis Client Library (KCL) checkpointing with DynamoDB is a pattern for custom applications, not for AWS Glue streaming jobs, which manage checkpointing internally via S3.

Practice this question →

193

Multi-Selecthard

A company is building a data lake on S3. They have a large volume of CSV files (hundreds of GB) in a source bucket. They need to convert them to Parquet, partition by date, and ensure the data is encrypted at rest with SSE-KMS. The pipeline must be triggered automatically when new files arrive. Which THREE steps should be part of the solution? (Choose THREE.)

Select 3 answers

A.Configure S3 Event Notification to send events to an SQS queue

B.Use Amazon Kinesis Data Firehose to ingest new files

C.Create an AWS Glue ETL job that converts to Parquet and partitions by date

D.Use Amazon Athena CTAS query to convert files in batch

E.Configure the Glue job to use a KMS key for server-side encryption in S3

AnswersA, C, E

SQS can buffer events and trigger a Lambda or Step Functions workflow.

Why this answer

S3 Event Notifications can be configured to send events to an SQS queue when new CSV files arrive. This decouples the ingestion pipeline, allowing the Glue job to poll the queue for new file notifications and trigger processing without tight coupling or polling the S3 bucket directly. SQS provides reliable, scalable message delivery that can trigger downstream ETL workflows.

Exam trap

The trap here is that candidates often confuse batch conversion tools like Athena CTAS with event-driven pipelines, or assume Kinesis Firehose can process existing S3 files, when in fact Firehose only ingests streaming data and cannot read from S3 buckets.

Practice this question →

194

MCQmedium

A data engineer is designing a data lake on Amazon S3. The data ingestion pipeline must handle both batch and streaming data. The engineer wants to use a single service to ingest both types of data. Which service should the engineer choose?

A.Amazon Athena

B.Amazon Kinesis Data Firehose

C.S3 Transfer Acceleration

D.AWS Glue

AnswerB

Firehose can ingest streaming data and deliver to S3 in near real-time; batch data can be sent via Firehose API.

Why this answer

Amazon Kinesis Data Firehose is the correct choice because it is a fully managed service that can ingest both batch and streaming data and deliver it directly to Amazon S3 without requiring custom code. It can receive streaming data from sources like Kinesis Data Streams or Amazon CloudWatch Logs, and also handle batch data via API calls, making it a single ingestion point for both patterns. While AWS Glue does support both batch and streaming ETL, it is primarily an ETL service that requires writing and managing jobs, and is not designed as a direct data ingestion service to S3 without additional configuration.

Therefore, Kinesis Data Firehose is the most appropriate service for this requirement.

Exam trap

The trap here is that candidates often confuse Amazon Kinesis Data Firehose with Amazon Kinesis Data Streams, but the question specifically asks for a single service that handles both batch and streaming data and delivers to S3, which Firehose does directly without requiring a separate consumer.

How to eliminate wrong answers

Option A is wrong because Amazon Athena is an interactive query service for analyzing data in S3 using SQL, not a data ingestion service. Option C is wrong because S3 Transfer Acceleration is a feature that speeds up uploads to S3 over long distances using edge locations, but it does not handle streaming data or provide a unified ingestion pipeline. Option D is wrong because AWS Glue is a serverless data integration service primarily used for ETL (extract, transform, load) jobs and cataloging, not for real-time streaming ingestion.

Practice this question →

195

MCQeasy

A data engineering team needs to ingest streaming data from an application into Amazon S3 for analytics. The data volume is moderate and the team wants the lowest operational overhead. Which AWS service should they use?

A.Amazon SQS

B.AWS Glue

C.Amazon Kinesis Data Streams

D.Amazon Kinesis Data Firehose

AnswerD

Fully managed, automatically writes streaming data to S3.

Why this answer

Amazon Kinesis Data Firehose is a fully managed service for loading streaming data into S3 with no code required and minimal operational overhead. Option A is incorrect because Amazon SQS is a message queue service, not designed for streaming data ingestion into S3. Option B is incorrect because AWS Glue is primarily a batch ETL service, not suitable for real-time streaming.

Option C is incorrect because Amazon Kinesis Data Streams requires custom consumers and more management, increasing operational overhead.

Practice this question →

196

MCQhard

A data engineering team is ingesting data from multiple sources into Amazon S3 using AWS Glue ETL jobs. The jobs are failing intermittently with the error: 'Task ran out of memory'. The input data size varies widely from 100 MB to 10 GB per job. Which configuration change would best mitigate this issue?

A.Increase the number of workers in the Glue job

B.Enable job bookmarking to process only incremental data

C.Reduce the batch size in the S3 source node

D.Change the job type from Spark to Python shell

AnswerB

Bookmarking reduces the data processed each run, lowering memory requirements.

Why this answer

Enabling job bookmarking allows the Glue ETL job to process only incremental (new or changed) data, which directly addresses the intermittent out-of-memory errors caused by widely varying input sizes (100 MB to 10 GB). By skipping previously processed data, the job consistently handles smaller data volumes per run, reducing memory pressure on the Spark executors.

Exam trap

The trap here is that candidates often assume increasing parallelism (Option A) is the universal fix for memory errors, but the root cause is the variable data volume per run, which job bookmarking mitigates by ensuring each run processes only a manageable subset of data.

How to eliminate wrong answers

Option A is wrong because increasing the number of workers adds more parallelism but does not reduce the per-executor memory load when processing large datasets; the job may still run out of memory on individual tasks if the data is skewed or the shuffle operations are memory-intensive. Option C is wrong because reducing the batch size in the S3 source node only affects how many files are listed per batch, not the volume of data loaded into memory for transformation; it does not prevent memory exhaustion from large input files. Option D is wrong because changing the job type from Spark to Python shell would remove distributed processing entirely, making the job unable to handle even moderate data sizes (e.g., 10 GB) and likely causing more frequent failures due to single-node memory limits.

Practice this question →

197

MCQhard

A company is migrating its on-premises data warehouse to Amazon Redshift. The daily batch load from the source database takes 6 hours using a single-node Redshift cluster. The engineer needs to reduce load time to under 2 hours without increasing cost significantly. Which strategy should the engineer adopt?

A.Use COPY with compression (gzip) to reduce data volume.

B.Use a VPC endpoint to improve network throughput to S3.

C.Change the table distribution style to EVEN to distribute data evenly.

D.Increase the number of nodes in the Redshift cluster and use parallel COPY from multiple files.

AnswerD

More nodes enable parallel data loading.

Why this answer

Increasing the number of nodes in the Redshift cluster provides more compute and I/O capacity, and using parallel COPY from multiple files allows Redshift to automatically split the load across the node slices, dramatically reducing load time. This approach scales performance linearly with the number of nodes, enabling the engineer to meet the sub-2-hour target without significantly increasing cost if the cluster is sized appropriately.

Exam trap

The trap here is that candidates assume compression or network optimizations are the primary bottleneck, when in reality the single-node Redshift cluster's lack of parallelism is the root cause of the slow load time.

How to eliminate wrong answers

Option A is wrong because COPY with compression (gzip) reduces the data volume transferred over the network and the storage footprint, but it does not significantly reduce the load time on a single-node cluster; the bottleneck is the single node's compute and I/O capacity, not the data size. Option B is wrong because a VPC endpoint improves network throughput between the VPC and S3 by avoiding internet gateways, but the load time is dominated by Redshift's processing speed, not network bandwidth, especially for a single-node cluster. Option C is wrong because changing the table distribution style to EVEN distributes data evenly across slices, but on a single-node cluster there is only one slice, so EVEN distribution provides no performance benefit; distribution styles only matter for multi-node clusters to enable parallel processing.

Practice this question →

198

MCQeasy

A marketing analytics team needs to ingest customer transaction data from an on-premises PostgreSQL database into Amazon S3 for analysis. The data volume is about 10 GB daily, and the team wants to perform full refresh daily (truncate and load) into S3 as Parquet files. The company has a Direct Connect connection to AWS. The team needs a simple, managed solution that minimizes operational overhead. What should the team use?

A.Set up AWS Database Migration Service (DMS) to continuously replicate data to S3 in Parquet format.

B.Use Amazon EMR with a Spark job that reads from PostgreSQL and writes to S3.

C.Use an AWS Glue ETL job with a JDBC connection to the PostgreSQL database, extract data, and write to S3 in Parquet format.

D.Use AWS Data Pipeline with a SQLActivity to extract data and copy to S3.

AnswerC

Glue is serverless and can handle daily full refresh with minimal setup.

Why this answer

AWS Glue ETL job is the best choice for this scenario. It is a fully managed service that can connect to on-premises PostgreSQL via a JDBC connection (using an AWS Glue connection with the appropriate network configuration over Direct Connect). It can perform a full extract (truncate and load) each day and write the data directly to S3 in Parquet format, minimizing operational overhead.

Option A (AWS DMS) is designed for ongoing change data capture (CDC) and continuous replication, not for daily full refreshes without incremental changes. Option B (Amazon EMR with Spark) requires managing clusters and is more complex than necessary for a simple daily load. Option D (AWS Data Pipeline) requires custom scripting and more configuration compared to Glue's built-in ETL capabilities.

Therefore, option C is correct.

Practice this question →

199

MCQmedium

A data engineer is ingesting data from an on-premises database to Amazon S3 using AWS DataSync. The data transfer is scheduled to run daily at midnight. The engineer notices that the transfer takes longer than expected and sometimes does not complete before the next scheduled task. What should the engineer do to ensure the transfer completes within the window?

A.Increase the bandwidth limit in the DataSync task settings.

B.Decrease the bandwidth limit to reduce network congestion.

C.Increase the schedule frequency to every 12 hours.

D.Use S3 Transfer Acceleration instead of DataSync.

AnswerA

Higher bandwidth limit allows faster data transfer.

Why this answer

Increase the bandwidth limit in the DataSync task settings. Increasing the bandwidth limit allows DataSync to use more available network capacity, thereby speeding up the data transfer and ensuring it completes within the scheduled window. Option B is incorrect because decreasing the bandwidth limit would slow the transfer further.

Option C is incorrect because increasing the schedule frequency does not address the underlying bandwidth issue; it would merely start more transfers that would still be slow. Option D is incorrect because S3 Transfer Acceleration is designed for long-distance transfers over public internet and may not help if the bottleneck is on-premises bandwidth; additionally, DataSync is the recommended service for this scenario.

Practice this question →

200

Multi-Selectmedium

A data engineer is designing a data ingestion pipeline for IoT sensor data. The data is generated at a high velocity and must be processed in near real-time. The pipeline must also handle bursty traffic. Which TWO AWS services should be combined to achieve this? (Choose TWO.)

Select 2 answers

A.Amazon S3

B.Amazon Kinesis Data Analytics

C.Amazon Simple Queue Service (SQS)

D.AWS Glue

E.Amazon Kinesis Data Streams

AnswersB, E

Can process streaming data in near real-time.

Why this answer

Amazon Kinesis Data Streams is designed for real-time, high-velocity data ingestion, providing durable, ordered data streams that can handle bursty traffic by scaling shard capacity. Amazon Kinesis Data Analytics can process these streams in near real-time using SQL or Apache Flink, enabling immediate transformations and analytics without needing to store data first.

Exam trap

The DEA-C01 exam often tests the distinction between streaming services (Kinesis Data Streams) and batch/queue services (SQS, S3), so the trap here is assuming SQS can handle real-time streaming or that S3 can serve as a primary ingestion point for high-velocity data.

Practice this question →

201

MCQmedium

A company is using AWS Database Migration Service (DMS) to migrate a 2 TB Oracle database to Amazon Aurora PostgreSQL. The migration must have minimal downtime. The source database is highly active with continuous writes. Which DMS migration type and additional configuration should the engineer use?

A.Use a CDC-only migration task to capture changes from the source.

B.Use a full load migration task and stop the source database before starting.

C.Use a full load migration task with task restart enabled.

D.Use a full load migration task followed by ongoing replication (CDC).

AnswerD

Full load migrates existing data, then CDC replicates new changes, minimizing downtime.

Why this answer

A full load migration followed by ongoing replication (CDC) allows the initial data copy to complete while continuously capturing and applying incremental changes from the highly active source. This minimizes downtime by keeping the target database nearly synchronized, requiring only a brief cutover window to stop writes and finalize replication.

Exam trap

The trap here is that candidates often assume a CDC-only task can handle both initial load and ongoing changes, but DMS requires a full load phase to populate the target before CDC can start, and they overlook that a full load alone cannot capture writes occurring during the migration.

How to eliminate wrong answers

Option A is wrong because a CDC-only task cannot migrate the existing 2 TB of data; it only captures ongoing changes, so the target would lack the initial dataset. Option B is wrong because stopping the source database before starting the migration would cause significant downtime, which contradicts the requirement for minimal downtime. Option C is wrong because a full load migration task with task restart enabled only retries the full load on failure; it does not capture ongoing writes after the initial load, so changes made during the migration would be lost, leading to data inconsistency.

Practice this question →

202

Multi-Selectmedium

A data engineer is designing a data ingestion pipeline for streaming data from IoT devices. The devices send JSON messages every second. The engineer needs to ingest the data with low latency and store it in Amazon S3 in Parquet format. Which TWO services should the engineer use together?

Select 2 answers

A.AWS Lambda

B.Amazon Athena

C.Amazon Kinesis Data Streams

D.AWS Glue

E.Amazon Kinesis Data Firehose

AnswersC, E

Provides low-latency ingestion.

Why this answer

The correct answers are C and E. Amazon Kinesis Data Streams (KDS) provides low-latency, real-time ingestion of streaming data from IoT devices, handling JSON messages sent every second. Amazon Kinesis Data Firehose (KDF) can then consume data from KDS, automatically convert it to Parquet format, and deliver it to Amazon S3.

This combination meets the low-latency and Parquet conversion requirements without custom code. Option A (Lambda) could transform data but requires additional management and is not necessary for Parquet conversion as Firehose handles it natively. Option B (Athena) is a query service, not for ingestion.

Option D (Glue) is batch-oriented and not suited for low-latency streaming.

Practice this question →

203

Multi-Selectmedium

A company is using AWS Glue ETL to transform and load data from Amazon S3 to Amazon Redshift. The data engineer notices that the job is taking longer than expected. Which TWO actions can improve the job performance?

Select 2 answers

A.Use Amazon Redshift Spectrum to query data directly.

B.Partition the source data in S3.

C.Increase the number of DPUs for the Glue job.

D.Enable S3 Transfer Acceleration.

E.Use a larger Redshift node type.

AnswersB, C

Partitioning reduces data scanned.

Why this answer

Options B and C are correct because partitioning the source data in S3 reduces the amount of data scanned by Glue, improving I/O efficiency, and increasing the number of DPUs adds more parallelism for transformations. Option A is incorrect because Redshift Spectrum is for querying data in S3 directly from Redshift, not for Glue ETL jobs. Option D is incorrect because S3 Transfer Acceleration speeds up uploads to S3 but does not affect Glue job performance during ETL processing.

Option E is incorrect because larger Redshift node types do not impact Glue job execution; they only affect Redshift query performance.

Practice this question →

204

Multi-Selecthard

A company uses AWS Glue to process large datasets. The Glue job occasionally fails with 'DiskFull' errors. Which TWO actions should the engineer take to resolve this issue? (Choose two.)

Select 2 answers

A.Increase the number of workers for the Glue job.

B.Store intermediate results in Amazon S3 instead of local disk.

C.Enable job bookmark to skip already processed data.

D.Use a Python shell job instead of Spark.

E.Use G.2X worker type which provides more disk space per worker.

AnswersA, E

More workers provide more aggregate disk space.

Practice this question →

205

MCQeasy

A company needs to ingest data from multiple SaaS applications into Amazon S3. The data sources provide REST APIs. Which AWS service can be used to build a fully managed data ingestion pipeline without writing custom code?

A.Amazon AppFlow

B.Amazon Kinesis Data Streams

C.AWS Lambda with custom code

D.AWS Glue with Python shell

AnswerA

AppFlow is a fully managed integration service for SaaS applications.

Why this answer

Amazon AppFlow is a fully managed service designed to transfer data from SaaS applications to AWS services like Amazon S3 without writing custom code. Option B is wrong because Amazon Kinesis Data Streams is primarily for real-time streaming data, not for directly ingesting from SaaS APIs. Option C is wrong because AWS Lambda requires custom code to integrate with SaaS APIs.

Option D is wrong because AWS Glue with Python shell is for ETL transformations and also requires custom scripting.

Practice this question →

206

MCQmedium

A company is using AWS Glue to run ETL jobs that process data from Amazon S3 and load it into Amazon Redshift. The jobs are failing with the error 'Unable to connect to Redshift cluster'. The Redshift cluster is in the same VPC as the Glue job. What is the MOST likely cause?

A.The Redshift cluster's security group does not allow inbound traffic from the Glue job's security group.

B.The IAM role associated with the Glue job does not have permission to access Redshift.

C.The Glue job is not configured to use the same VPC as the Redshift cluster.

D.The Redshift cluster is not publicly accessible and Glue is trying to connect from outside the VPC.

AnswerC

Glue jobs need VPC configuration to access resources in a private VPC.

Why this answer

The most likely cause is that the Glue job is not configured to use the same VPC as the Redshift cluster. By default, AWS Glue jobs run in a separate VPC managed by Glue. To connect to resources in a customer VPC (like a Redshift cluster), the Glue job must be explicitly associated with that VPC via a Glue connection or job configuration.

Option C is correct. Option A is incorrect because even if the security group allows inbound traffic, the Glue job's network may not be routed to the Redshift cluster if it is in a different VPC. Option B is incorrect because the IAM role handles authentication, not network connectivity.

Option D is incorrect because the Redshift cluster is in the same VPC, so public accessibility is not required; the error indicates a network connectivity issue, not a public access issue.

Practice this question →

207

MCQhard

A data pipeline uses AWS Glue to read CSV files from an S3 bucket, transform them, and write Parquet back to S3. The pipeline runs daily and processes about 500 GB per run. The team wants to reduce costs without increasing runtime. Which approach is most effective?

A.Pre-convert the CSV files to Parquet in S3 using a separate process.

B.Enable job bookmarks to skip already processed data.

C.Increase the number of DPUs for the Glue job to improve parallelism.

D.Optimize the Glue script to select only required columns and filter rows early.

AnswerD

Selecting only required columns and filtering rows early reduces data scanned, lowering Glue job costs without increasing runtime.

Why this answer

Optimizing the Glue script to use column pruning and predicate pushdown reduces the amount of data scanned, lowering costs without increasing runtime. Option A (pre-converting CSV to Parquet) adds an extra processing step and cost, making it less effective. Option B (enabling job bookmarks) tracks already processed data but does not reduce the cost per run.

Option C (increasing DPUs) may actually increase costs and can cause unpredictable runtime.

Practice this question →

208

MCQhard

Refer to the exhibit. A data engineer runs the AWS CLI command to describe a Glue job. The job is expected to process new data incrementally using job bookmarks. However, the job reprocesses all data every time it runs. What is the MOST likely reason?

A.The job bookmark option is set to 'job-bookmark-enable' but should be 'job-bookmark-disable'.

B.The job's MaxRetries is set to 0, which disables bookmarks.

C.The ETL script does not use the 'transformation_ctx' parameter in its DynamicFrame transformations.

D.The Glue job's command name is 'glueetl', which does not support job bookmarks.

AnswerC

Without transformation_ctx, Glue cannot track bookmarks.

Why this answer

AWS Glue job bookmarks rely on the `transformation_ctx` parameter to track state. Without it, Glue cannot identify which data has already been processed, causing the job to reprocess all data on every run. The `transformation_ctx` must be passed to each DynamicFrame transformation (e.g., `apply_mapping`, `filter`, `join`) to enable bookmark-based incremental processing.

Exam trap

The trap here is that candidates often assume bookmarks are controlled only by the job configuration setting (`job-bookmark-enable`) and overlook the critical role of `transformation_ctx` in the ETL script, which is a common oversight in AWS Glue exam questions.

How to eliminate wrong answers

Option A is wrong because `job-bookmark-enable` is the correct setting to enable bookmarks; setting it to `job-bookmark-disable` would disable them, not fix the reprocessing issue. Option B is wrong because `MaxRetries` controls the number of retry attempts on failure and has no effect on job bookmark behavior. Option D is wrong because `glueetl` is the standard command name for ETL jobs and fully supports job bookmarks; the command name does not disable bookmarks.

Practice this question →

209

MCQmedium

A company uses AWS Glue to process streaming data from Amazon Kinesis Data Streams. The job reads JSON records and writes Parquet to Amazon S3. Recently, the job started failing with 'Out of Memory' errors. Which change is MOST likely to resolve the issue?

A.Enable compression on the Kinesis stream.

B.Change the output format from Parquet to ORC.

C.Increase the number of DPUs allocated to the Glue job.

D.Reduce the streaming batch size in the Glue job configuration.

AnswerC

More DPUs provide more memory and CPU.

Why this answer

The 'Out of Memory' error in AWS Glue indicates that the job's allocated resources are insufficient for the data volume or processing complexity. Increasing the number of DPUs (Data Processing Units) directly increases the available memory and compute capacity, which is the most straightforward fix for OOM errors in Glue streaming jobs. Option C is correct because it addresses the root cause—resource exhaustion—by scaling the job horizontally.

Exam trap

The trap here is that candidates often confuse 'Out of Memory' with a data format or compression issue, leading them to choose options like A or B, when the real solution is to scale compute resources via DPUs.

How to eliminate wrong answers

Option A is wrong because enabling compression on the Kinesis stream reduces data transfer size but does not affect the memory footprint of the Glue job processing the data; the job still decompresses records into memory. Option B is wrong because changing the output format from Parquet to ORC does not reduce memory usage—both are columnar formats with similar memory profiles, and the error is not related to serialization efficiency. Option D is wrong because reducing the streaming batch size can help with latency but does not guarantee resolution of OOM errors; the job may still fail if individual records or transformations are memory-intensive, and the core issue is insufficient total memory allocation.

Practice this question →

210

MCQeasy

A company needs to ingest data from an on-premises Oracle database into Amazon S3 on a daily basis. The data volume is about 100 GB per day. Which AWS service is BEST suited for this task?

A.Use AWS DataSync to copy the database files to S3.

B.Use Amazon Kinesis Data Firehose with a database connector.

C.Use AWS Database Migration Service (DMS) to replicate data to S3.

D.Use AWS Glue to extract data from Oracle and write to S3.

AnswerC

DMS supports continuous replication from Oracle to S3.

Why this answer

AWS Database Migration Service (DMS) can continuously replicate data from Oracle to S3, and it supports full load and change data capture (CDC). Option A (AWS DataSync) is for file-based transfers, not database replication. Option B (Amazon Kinesis Data Firehose) is for streaming data, not database pull.

Option D (AWS Glue) is for ETL but does not natively support continuous CDC from Oracle.

Practice this question →

211

MCQmedium

Refer to the exhibit. An IAM policy is attached to an EC2 instance role that runs a data ingestion application. The application reads files from an S3 bucket 'data-lake-primary' and sends records to a Kinesis stream named 'clickstream'. The application is failing with an 'AccessDenied' error when trying to read from S3. What is the MOST likely cause?

A.The actions are specified incorrectly; they should be s3:GetObject and s3:PutObject only.

B.The policy is not attached to the EC2 instance role.

C.The Kinesis stream name is incorrect.

D.The policy does not include the s3:ListBucket permission.

AnswerD

Reading objects often requires ListBucket permission for the bucket.

Why this answer

The application reads files from an S3 bucket, which requires both s3:GetObject (to read the object) and s3:ListBucket (to list objects in the bucket, typically needed for operations like listing or navigating the bucket). Without s3:ListBucket, the SDK may fail with an AccessDenied error when it tries to enumerate objects or validate the bucket path, even if s3:GetObject is present. Option D correctly identifies this missing permission as the most likely cause.

Exam trap

The DEA-C01 exam often tests the misconception that only s3:GetObject is needed for reading from S3, ignoring that many SDK operations require s3:ListBucket for discovery or navigation, leading candidates to overlook this permission.

How to eliminate wrong answers

Option A is wrong because the actions are not specified incorrectly; s3:GetObject is correct for reading objects, and s3:PutObject is not needed for reading. Option B is wrong because the question states the policy is attached to the EC2 instance role, so the issue is not about attachment but about missing permissions. Option C is wrong because the error is 'AccessDenied' when trying to read from S3, not from Kinesis, so an incorrect Kinesis stream name would cause a different error (e.g., ResourceNotFoundException) or a different access denied error on the Kinesis side.

Practice this question →

212

MCQeasy

A company uses AWS Glue to process CSV files from an S3 bucket. The job fails intermittently with a 'SchemaDetectionError' for files that have inconsistent column counts. What is the most efficient way to handle this?

A.Use the 'mergeSchema' option when reading the DynamicFrame.

B.Convert all CSV files to Parquet format using a separate preprocessing job.

C.Define a fixed schema in the Glue job using 'apply_mapping' to map columns.

D.Set the job to 'ignore' schema mismatches in the job parameters.

AnswerC

Correct. Defining a fixed schema and using `apply_mapping` to map columns effectively handles inconsistent column counts by ensuring a consistent schema is applied to all files.

Why this answer

Defining a fixed schema using the `schema` parameter in the DynamicFrame reader forces Glue to apply that schema to all CSV files. With `apply_mapping`, you can map the actual columns present to the fixed schema, handling inconsistent column counts by ignoring extra columns and filling missing columns with nulls. This avoids schema detection errors without extra preprocessing.

Exam trap

The trap is assuming `mergeSchema` works for CSV files. In AWS Glue, `mergeSchema` is only supported for Parquet/ORC formats. For CSV, you must define a fixed schema and use `apply_mapping` to handle inconsistencies.

How to eliminate wrong answers

Option B is wrong because converting to Parquet does not inherently solve schema inconsistency; Parquet also requires a consistent schema across files unless mergeSchema is explicitly enabled, and adding a preprocessing job is less efficient than handling it inline. Option C is wrong because 'apply_mapping' only remaps existing columns after the schema is resolved; it does not handle files with missing or extra columns that cause the initial schema detection to fail. Option D is wrong because AWS Glue does not have a job parameter to 'ignore' schema mismatches; the error occurs during schema detection, and ignoring it would lead to data corruption or job failure.

Practice this question →

213

MCQhard

A company uses Kinesis Data Streams to ingest clickstream data. They notice that the data processing latency increases as the number of shards grows. What is the most likely cause and solution?

A.Reduce the number of shards or increase the number of consumers.

B.Increase the Kinesis Producer Library (KPL) batch size.

C.Use enhanced fan-out to allow multiple consumers per shard.

D.Increase the number of shards to handle more data.

AnswerA

Balancing shards and consumers ensures each shard is processed, reducing latency.

Why this answer

As the number of shards increases, the total throughput of the stream increases, but each shard has a fixed limit of 5 read transactions per second. If the number of consumers remains constant, each consumer must poll more shards sequentially, increasing the per-record processing latency. Reducing the number of shards or adding more consumers distributes the polling load, reducing the time each consumer spends waiting for shard-level throttling.

Exam trap

The trap here is that candidates often assume more shards always improve performance, but the DEA-C01 exam tests the understanding that read-side latency scales inversely with the number of consumers relative to shards, not with shard count alone.

How to eliminate wrong answers

Option B is wrong because increasing the KPL batch size only affects the write side (producer throughput), not the read-side latency caused by too many shards per consumer. Option C is wrong because enhanced fan-out provides dedicated 2 MB/second read throughput per consumer per shard, but it does not reduce the latency introduced by a single consumer having to poll many shards sequentially; it only helps when multiple consumers need to read the same shard concurrently. Option D is wrong because increasing the number of shards would worsen the problem by forcing each consumer to poll even more shards, further increasing latency.

Practice this question →

214

MCQhard

A company uses AWS Glue to process JSON logs from S3. The logs have a nested structure and the schema evolves over time. The data engineer needs to ensure the Glue job can handle schema changes without failing. Which configuration should be used?

A.Manually update the table schema in the Glue Data Catalog before each run

B.Use Spark SQL with a static schema definition in the script

C.Set the job parameter '--enable-glue-datacatalog' and '--mergeDynamicColumns' to true

D.Enable AWS Glue Schema Registry and define a schema version

AnswerC

This allows Glue DynamicFrame to merge schema variations automatically.

Why this answer

Setting '--enable-glue-datacatalog' allows the Glue job to use the Data Catalog as the metastore, and '--mergeDynamicColumns' (or the equivalent '--enable-schema-evolution' in newer Glue versions) instructs the job to dynamically merge new columns from the evolving JSON schema into the existing table schema during runtime, preventing job failures due to schema mismatches. This is specifically designed for nested, schema-evolving data like JSON logs, as it automatically reconciles differences between the source data and the catalog definition.

Exam trap

The trap here is that candidates often confuse the AWS Glue Schema Registry (which enforces schema compatibility and versioning) with the schema evolution capabilities of the Glue DynamicFrame, leading them to choose Option D even though it would reject schema changes rather than adapt to them.

How to eliminate wrong answers

Option A is wrong because manually updating the table schema before each run is not scalable, error-prone, and defeats the purpose of automated schema evolution; it also introduces operational overhead and potential downtime. Option B is wrong because using Spark SQL with a static schema definition in the script will cause the job to fail when new fields appear in the JSON logs, as Spark's static schema cannot adapt to dynamic changes without manual code modifications. Option D is wrong because the AWS Glue Schema Registry is designed for schema validation and serialization/deserialization (e.g., Avro, Protobuf) to enforce compatibility rules, not for dynamically merging evolving schemas during ETL processing; it would reject records that don't conform to the registered schema version, causing job failures instead of handling changes gracefully.

Practice this question →

215

MCQmedium

A data engineer needs to ingest data from an on-premises Oracle database into Amazon S3 on a daily basis. The data volume is approximately 500 GB per day. The source database is behind a firewall that does not allow direct internet access. Which service should the engineer use to transfer the data securely?

A.AWS DataSync with a network path through AWS Direct Connect or VPN.

B.AWS Database Migration Service (AWS DMS) with ongoing replication from Oracle to S3.

C.Amazon S3 Transfer Acceleration with a public endpoint.

D.AWS Snowball Edge device for daily transfers.

AnswerA

DataSync is designed for scheduled transfers to S3.

Why this answer

AWS DataSync can transfer data from on-premises storage to AWS over a network path established through AWS Direct Connect or a VPN, which is necessary because the source database is behind a firewall that blocks direct internet access. DataSync automates the movement of large datasets (up to 500 GB daily) and integrates with Oracle databases via a supported agent, handling incremental transfers efficiently. This makes it the correct choice for secure, scheduled, and high-volume data ingestion into Amazon S3.

Exam trap

The trap here is that candidates may assume AWS DMS is the only tool for database-to-S3 transfers, overlooking that DataSync is purpose-built for scheduled, large-volume file transfers from on-premises systems behind firewalls, while DMS is optimized for ongoing replication and schema conversion, not daily bulk dumps.

How to eliminate wrong answers

Option B is wrong because AWS DMS with ongoing replication is designed for continuous change data capture (CDC) and database migration, not for daily bulk file transfers to S3; it would require a network path through Direct Connect or VPN anyway, and its S3 target is for full-load snapshots, not optimized for repeated 500 GB daily dumps. Option C is wrong because Amazon S3 Transfer Acceleration uses public internet endpoints and requires direct internet access, which the firewall blocks; it also does not handle the extraction from Oracle, only accelerates uploads to S3. Option D is wrong because AWS Snowball Edge is a physical device intended for offline, one-time or periodic large-scale data transfers (e.g., terabytes to petabytes), not for daily 500 GB transfers, as the logistics of shipping and processing a device each day would be impractical and violate the daily frequency requirement.

Practice this question →

216

MCQmedium

A company runs a SQL Server transactional database on Amazon RDS. They need to capture change data (inserts, updates, deletes) in near real-time and replicate them to an Amazon S3 data lake. Which AWS service is most suitable?

A.AWS Database Migration Service (DMS) with change data capture

B.AWS Glue DataBrew

C.Amazon Kinesis Data Streams with Kinesis Client Library

D.Amazon Redshift Spectrum

AnswerA

DMS supports ongoing replication with CDC and can write to S3.

Why this answer

AWS DMS with change data capture (CDC) is the most suitable service because it can continuously capture and replicate incremental changes (inserts, updates, deletes) from a SQL Server transactional database on Amazon RDS to an S3 data lake in near real-time. DMS uses native SQL Server transaction logs (e.g., MS-CDC or log-based replication) to read changes without impacting source performance, and it supports target S3 in formats like Parquet or CSV. This directly meets the requirement for near-real-time CDC replication to a data lake.

Exam trap

The trap here is that candidates may confuse Kinesis Data Streams as a general-purpose streaming solution for any real-time data, but it lacks native CDC capabilities for relational databases without additional custom code or connectors, making DMS the correct choice for database-to-S3 replication.

How to eliminate wrong answers

Option B is wrong because AWS Glue DataBrew is a visual data preparation tool for cleaning and normalizing data, not a service for capturing and replicating change data from a live database. Option C is wrong because Amazon Kinesis Data Streams is a real-time streaming service that requires custom producers and consumers (e.g., KCL) to ingest and process data, but it cannot natively capture CDC from a SQL Server database without additional middleware like Debezium or a custom application. Option D is wrong because Amazon Redshift Spectrum is a query engine that allows running SQL queries directly against data in S3, not a service for ingesting or replicating change data from a source database.

Practice this question →

217

Multi-Selectmedium

Which TWO practices improve the performance of AWS Glue ETL jobs? (Choose two.)

Select 2 answers

A.Use pushdown predicates to filter data at the source

B.Increase the number of DPUs to the maximum allowed

C.Use the smallest possible file size for input data

D.Enable AWS Glue job metrics and debug logging

E.Use column pruning to select only required columns

AnswersA, E

Filters data early, reducing data scanned.

Why this answer

Pushdown predicates (Option A) improve AWS Glue ETL performance by filtering data at the source before it is read into the job. This reduces the volume of data transferred and processed, which is especially effective when using formats like Parquet or ORC that support predicate pushdown natively. By applying filters early, Glue avoids scanning unnecessary partitions or rows, leading to faster execution and lower costs.

Exam trap

The trap here is that candidates often confuse monitoring features (like enabling metrics and logging) with performance optimizations, or mistakenly believe that maximizing resources (DPUs) always improves speed, ignoring the overhead of small files and the benefits of early filtering and column selection.

Practice this question →

218

MCQhard

A company uses Amazon Kinesis Data Analytics for Apache Flink to process streaming data. The application reads from a Kinesis data stream, performs a 1-minute tumbling window aggregation, and writes results to an S3 bucket. Recently, the application started experiencing checkpoint failures and increasing processing delay. Which action should the engineer take FIRST to diagnose the issue?

A.Increase the parallelism of the Flink application.

B.Monitor CPU and memory utilization of the Flink application using Amazon CloudWatch metrics.

C.Switch to the Kinesis Client Library (KCL) for checkpointing.

D.Increase the checkpoint interval to reduce checkpoint frequency.

AnswerB

Checkpoint failures are often due to insufficient resources (CPU/memory). Monitoring CPU and memory utilization via CloudWatch metrics directly helps identify resource bottlenecks.

Why this answer

Checkpoint failures are often due to insufficient resources (CPU/memory) for the Flink job. Monitoring CPU and memory utilization via CloudWatch metrics directly helps identify resource bottlenecks. Option A (increasing parallelism) is a tuning step that might help but is not diagnostic.

Option C (switching to KCL) is not relevant for Flink checkpointing. Option D (increasing checkpoint interval) might reduce checkpoint frequency but does not address the root cause of checkpoint failures. The first step is to check resource utilization.

Practice this question →

219

Multi-Selecthard

A company is ingesting real-time financial transactions into Amazon Kinesis Data Streams. The data is then consumed by a Kinesis Data Analytics for Apache Flink application that calculates running totals. The application is experiencing high latency and checkpoint failures. Which TWO steps should the engineer take to improve performance and reliability? (Select TWO.)

Select 2 answers

A.Enable enhanced fan-out for the Flink application.

B.Reduce the batch size of records processed per checkpoint.

C.Increase the number of shards in the Kinesis data stream.

D.Increase the number of KPUs (Kinesis Processing Units) for the Flink application.

E.Decrease the checkpoint interval to reduce state size.

AnswersC, D

More shards increase parallelism, reducing latency and improving throughput.

Why this answer

Options C and D are correct. Increasing the number of shards (C) increases the throughput and parallelism of the stream, reducing latency. Increasing KPUs (D) provides more compute resources for the Flink application, helping to prevent checkpoint failures.

Option A (enhanced fan-out) is designed for multiple consumers, not for a single Flink job. Option B (reducing batch size) may not improve overall throughput. Option E (decreasing checkpoint interval) could lead to more frequent checkpointing, increasing overhead and potentially causing more failures.

Practice this question →

220

MCQhard

A media company uses Amazon Kinesis Data Firehose to ingest log data from web servers into Amazon S3. The data is then processed by AWS Glue jobs. The company wants to ensure that data is delivered to S3 within 5 minutes of ingestion. Currently, the Firehose delivery stream is configured with a buffer interval of 300 seconds and a buffer size of 5 MB. The log data arrives at a rate of 2 MB per second. The data engineer notices that some log files are delayed by up to 10 minutes. The company cannot change the buffer size due to downstream requirements. What should the data engineer do to meet the 5-minute delivery requirement?

A.Increase the buffer interval to 600 seconds to reduce the number of delivery attempts.

B.Increase the buffer size to 10 MB to ensure data is delivered in larger chunks.

C.Enable GZIP compression on the Firehose stream to reduce data size.

D.Decrease the buffer interval to 120 seconds.

AnswerD

Lower interval triggers delivery more often, reducing latency.

Why this answer

Decreasing the buffer interval to 120 seconds ensures that data is delivered to S3 within 2 minutes, meeting the 5-minute requirement. The current buffer interval of 300 seconds (5 minutes) is the primary cause of delays up to 10 minutes. Option A is incorrect because increasing the buffer interval would increase delay.

Option B is incorrect because increasing buffer size would also increase delay, as it takes longer to fill. Option C is incorrect because compression does not affect the buffer interval; data still waits up to 300 seconds.

Practice this question →

221

MCQmedium

A company wants to ingest streaming data from thousands of IoT devices into Amazon S3 with minimal latency and then transform the data using Spark SQL. Which AWS service should be used for data ingestion?

A.Amazon EMR

B.AWS Glue

C.Amazon Athena

D.Amazon Kinesis Data Firehose

AnswerD

Kinesis Data Firehose can ingest streaming data and deliver it to S3 with near-real-time latency.

Why this answer

Amazon Kinesis Data Firehose is the correct choice because it is a fully managed service designed for ingesting streaming data into Amazon S3 with near-real-time latency (typically 60 seconds or less). It can directly write data to S3 without requiring custom code or additional infrastructure, and it supports optional transformations via AWS Lambda, making it ideal for the described use case of streaming IoT data ingestion.

Exam trap

The trap here is confusing data ingestion services (Kinesis Data Firehose) with data processing or query services (EMR, Glue, Athena), leading candidates to pick EMR for its Spark SQL capability instead of recognizing that Firehose handles the ingestion step before transformation.

How to eliminate wrong answers

Option A is wrong because Amazon EMR is a big data processing service for running frameworks like Spark and Hadoop, not a streaming ingestion service; it would require additional setup (e.g., Kinesis or Kafka) to ingest data into S3. Option B is wrong because AWS Glue is a serverless ETL service primarily for batch data transformation and cataloging, not designed for real-time streaming ingestion into S3. Option C is wrong because Amazon Athena is an interactive query service for analyzing data in S3 using SQL, not an ingestion tool; it cannot ingest streaming data.

Practice this question →

222

MCQhard

A data streaming application uses Kinesis Data Streams with 10 shards. The data producer is throttled frequently. Which action should be taken to resolve this issue?

A.Decrease the data retention period

B.Use enhanced fan-out for consumers

C.Enable server-side encryption

D.Increase the number of shards

AnswerD

Each shard provides 1 MB/s write capacity, so more shards increase capacity.

Why this answer

Throttling in Kinesis Data Streams occurs when the write throughput exceeds the shard limits. Each shard supports up to 1 MB/s or 1,000 records/s for writes. With 10 shards, the total write capacity is 10 MB/s or 10,000 records/s.

Increasing the number of shards (Option D) directly increases the write capacity, resolving the throttling issue by distributing the load across more shards.

Exam trap

The trap here is that candidates confuse consumer-side features (like enhanced fan-out or retention period) with producer-side capacity issues, leading them to pick options that do not address the root cause of write throttling.

How to eliminate wrong answers

Option A is wrong because decreasing the data retention period (default 24 hours, up to 365 days) does not affect write throughput or throttling; it only controls how long records are stored. Option B is wrong because enhanced fan-out is a consumer-side feature that provides dedicated read throughput (2 MB/s per consumer per shard) and does not address producer-side write throttling. Option C is wrong because enabling server-side encryption (SSE-S3 or SSE-KMS) secures data at rest but has no impact on write throughput or throttling.

Practice this question →

223

Matchingmedium

Match each AWS security service to its purpose in data protection.

Drag a concept onto its matching description — or click a concept then click the description.

Concepts

Matches

Managed encryption keys

User and role access control

Audit API activity

Discover and protect sensitive data

Web application firewall

Why these pairings

The correct matches are: AWS KMS for encryption key management, AWS IAM for access control, and AWS CloudTrail for API auditing. Common confusions include swapping these services' purposes.

Practice this question →

224

MCQhard

A company uses Amazon Kinesis Data Firehose to deliver data to an Amazon S3 bucket. The data is in JSON format and contains a 'timestamp' field with a Unix epoch value. The company wants to partition the S3 objects by year, month, day, and hour based on the timestamp. What is the MOST efficient method to achieve this?

A.Use the dynamic partitioning feature of Kinesis Data Firehose with inline parsing to extract the timestamp and create the S3 prefix.

B.Configure a custom S3 prefix in Firehose using the 'YYYY/MM/dd/HH' format based on the current time.

C.Use an AWS Glue ETL job to read from Firehose, partition, and write to S3.

D.Use Amazon Athena to run a CTAS query that partitions the data by timestamp.

AnswerA

Correct. Kinesis Data Firehose dynamic partitioning allows inline parsing to extract the timestamp from JSON data and automatically creates S3 prefixes based on the specified keys (year, month, day, hour).

Why this answer

Kinesis Data Firehose supports dynamic partitioning with inline parsing to extract the timestamp and create the S3 prefix by year, month, day, and hour. Option B is incorrect because a custom prefix based on current time would use the delivery time, not the event timestamp, so partitioning would not reflect the actual data timestamps. Option C is incorrect because using an AWS Glue ETL job introduces additional latency and complexity; Firehose can partition directly without needing an extra service.

Option D is incorrect because Amazon Athena is a query engine, not an ingestion tool; running a CTAS query would require the data to already be in S3 and adds overhead.

Practice this question →

225

MCQeasy

A company wants to ingest real-time data from a social media API into Amazon S3 for analysis. The API provides data as JSON records. Which AWS service is best suited for this ingestion?

A.AWS Glue

B.Amazon Kinesis Data Firehose

C.Amazon Simple Queue Service (SQS)

D.Amazon DataZone

AnswerB

Firehose is designed for streaming data ingestion into S3.

Why this answer

Amazon Kinesis Data Firehose is the best choice because it is a fully managed service designed to ingest real-time streaming data, such as JSON records from a social media API, and automatically load it into Amazon S3 with optional data transformation and compression. It handles scaling, buffering, and delivery without requiring custom code or infrastructure management, making it ideal for this use case.

Exam trap

The trap here is that candidates often confuse Amazon Kinesis Data Streams (which requires custom consumers) with Kinesis Data Firehose (which is serverless and directly writes to S3), or they incorrectly assume SQS can directly deliver to S3 without additional processing.

How to eliminate wrong answers

Option A is wrong because AWS Glue is a serverless data integration service for batch ETL (extract, transform, load) jobs and cataloging, not designed for real-time streaming ingestion from an API. Option C is wrong because Amazon Simple Queue Service (SQS) is a message queue for decoupling application components, but it does not natively write data to S3; you would need additional compute to poll and deliver messages, adding complexity. Option D is wrong because Amazon DataZone is a data governance and catalog service for managing data assets across an organization, not a data ingestion service for real-time streaming.

Practice this question →

← PreviousPage 3 of 8 · 591 questions totalNext →

Ready to test yourself?

Try a timed practice session using only Data Ingestion and Transformation questions.

Start 20-question session