support@Free-Braindumps.com
Register Login
Cisco
CompTIA
ISC
EC-Council
EXIN
Fortinet
ITIL
Juniper
Microsoft
VMware
Avaya
SAP
Google
NVIDIA
Salesforce
Amazon
Palo Alto Networks
ISC2
Splunk
ServiceNow
All Vendors
  1. Home
  2. Exams
  3. Amazon
  4. Amazon-DEA-C01

Amazon Amazon-DEA-C01 Exam Actual Questions
AWS Certified Data Engineer - Associate (Page 5 )

Updated On: 1-Aug-2026
Page 5 of 47
PDF with 366 Questions

A data engineer needs to join data from multiple sources to perform a one-time analysis job. The data is stored in Amazon DynamoDB, Amazon RDS, Amazon Redshift, and Amazon S3.
Which solution will meet this requirement MOST cost-effectively?

  1. Use an Amazon EMR provisioned cluster to read from all sources. Use Apache Spark to join the data and perform the analysis.
  2. Copy the data from DynamoDB, Amazon RDS, and Amazon Redshift into Amazon S3. Run Amazon Athena queries directly on the S3 files.
  3. Use Amazon Athena Federated Query to join the data from all data sources.
  4. Use Redshift Spectrum to query data from DynamoDB, Amazon RDS, and Amazon S3 directly from Redshift.

Answer(s): C

Explanation:

C: Use Amazon Athena Federated Query to join the data from all data sources.
One-time analysis job
Data across multiple sources (DynamoDB, RDS, Redshift, S3)
Most cost-effective
Athena Federated Query allows you to:
Query multiple data sources directly without moving data
Join data using SQL
Pay only per query scanned
Avoid cluster provisioning or data duplication
Perfect for ad hoc or one-time analytics.



A company is planning to use a provisioned Amazon EMR cluster that runs Apache Spark jobs to perform big data analysis. The company requires high reliability. A big data team must follow best practices for running cost-optimized and long-running workloads on Amazon EMR. The team must find a solution that will maintain the company's current level of performance.
Which combination of resources will meet these requirements MOST cost-effectively? (Choose two.)

  1. Use Hadoop Distributed File System (HDFS) as a persistent data store.
  2. Use Amazon S3 as a persistent data store.
  3. Use x86-based instances for core nodes and task nodes.
  4. Use Graviton instances for core nodes and task nodes.
  5. Use Spot Instances for all primary nodes.

Answer(s): B,D

Explanation:

Here's a detailed justification for choosing options B and D to meet the company's requirements for a cost-optimized, reliable, and long-running Amazon EMR cluster for big data analysis:
B: Use Amazon S3 as a persistent data store:
HDFS (Option A) is typically used as the default file system within an EMR cluster. However, for long-running, cost-optimized workloads, it's not ideal as it couples data storage to the lifespan of the EMR cluster. If the cluster terminates (intentionally or unintentionally), the data stored in HDFS is lost, leading to data loss and increased costs to reload data every time. Amazon S3 provides a persistent, durable, and cost-effective object storage service that is decoupled from the EMR cluster's lifecycle. The EMR cluster can read and write data directly to S3, and the data persists even if the cluster terminates. This improves reliability and reduces costs in the long run, especially with long-running workloads. This approach aligns with AWS best practices for EMR. [ https://docs.aws.amazon.com/emr/latest/best-practices/best-practices-data-storage.html]
D: Use Graviton instances for core nodes and task nodes:
Graviton instances are based on the Arm architecture and offer significant price-performance benefits over x86-based instances (Option C) for many workloads. They are designed by AWS and optimized for cloud workloads. Using Graviton instances can reduce the cost of running core and task nodes without sacrificing performance. Spark and other big data tools are increasingly well-optimized for Arm architectures.
While the exact price-performance benefit will vary depending on the specific workload, Graviton instances generally offer a cost-effective alternative to x86. For EMR specifically, AWS has been promoting the use of Graviton for cost savings. [ https://aws.amazon.com/ec2/graviton/]
Why other options are incorrect:

A: Use Hadoop Distributed File System (HDFS) as a persistent data store: Already explained above.
C: Use x86-based instances for core nodes and task nodes: While perfectly viable, it's less cost-effective than option D.
E: Use Spot Instances for all primary nodes: Spot Instances can provide cost savings, but using them for all primary nodes significantly reduces reliability. Primary nodes (master and core) are crucial for the cluster's functionality. If the Spot Instances for these nodes are terminated, the cluster may fail, which directly contradicts the requirement for high reliability. Spot instances are better suited to task nodes.



A company wants to implement real-time analytics capabilities. The company wants to use Amazon Kinesis Data Streams and Amazon Redshift to ingest and process streaming data at the rate of several gigabytes per second. The company wants to derive near real-time insights by using existing business intelligence (BI) and analytics tools.
Which solution will meet these requirements with the LEAST operational overhead?

  1. Use Kinesis Data Streams to stage data in Amazon S3. Use the COPY command to load data from Amazon S3 directly into Amazon Redshift to make the data immediately available for real-time analysis.
  2. Access the data from Kinesis Data Streams by using SQL queries. Create materialized views directly on top of the stream. Refresh the materialized views regularly to query the most recent stream data.
  3. Create an external schema in Amazon Redshift to map the data from Kinesis Data Streams to an Amazon Redshift object. Create a materialized view to read data from the stream. Set the materialized view to auto refresh.
  4. Connect Kinesis Data Streams to Amazon Kinesis Data Firehose. Use Kinesis Data Firehose to stage the data in Amazon S3. Use the COPY command to load the data from Amazon S3 to a table in Amazon Redshift.

Answer(s): C

Explanation:

The most efficient solution for real-time analytics using Kinesis Data Streams and Redshift, while minimizing operational overhead, is option
C. Here's why:
Option C leverages Redshift's capabilities to directly access and query data within Kinesis Data Streams without intermediate staging. The creation of an external schema allows Redshift to treat the Kinesis stream almost like a table. A materialized view built on top of this external schema then provides a continuously updated snapshot of the stream data. Setting the materialized view to auto-refresh ensures that the view reflects the most recent stream data automatically. This approach avoids the need for manual data loading and transformation, reducing operational complexity.
Option A introduces unnecessary complexity by staging data in S3 before loading it into Redshift. This requires managing S3 buckets and configuring the COPY command, increasing operational overhead. Moreover, the "real-time analysis" requirement is not met using batch loading via COPY .
Option B, directly querying Kinesis Data Streams with SQL and materialized views, is not natively supported. Kinesis Data Streams primarily pushes data to consumers; it doesn't inherently support SQL-based queries on the stream itself from a data warehouse like Redshift.
Option D also introduces unnecessary complexity.
While Kinesis Data Firehose can deliver data to S3, this introduces an additional service and staging step, adding to operational overhead. The COPY command would still need to be configured and managed.
The key is to leverage Redshift's external tables and materialized views for direct access and near real-time insights with minimal operational effort. Auto-refreshing materialized views simplify the ingestion and transformation process by automatically updating the view as new data becomes available in the Kinesis Data Streams, without needing to implement custom update logic.
Here are resources for further reading:
Amazon Redshift External Tables: https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_EXTERNAL_TABLE.html Amazon Redshift Materialized Views: https://docs.aws.amazon.com/redshift/latest/dg/materialized-views.html Kinesis Data Streams: https://aws.amazon.com/kinesis/data-streams/



A company uses an Amazon QuickSight dashboard to monitor usage of one of the company's applications. The company uses AWS Glue jobs to process data for the dashboard. The company stores the data in a single Amazon S3 bucket. The company adds new data every day. A data engineer discovers that dashboard queries are becoming slower over time. The data engineer determines that the root cause of the slowing queries is long-running AWS Glue jobs.
Which actions should the data engineer take to improve the performance of the AWS Glue jobs? (Choose two.)

  1. Partition the data that is in the S3 bucket. Organize the data by year, month, and day.
  2. Increase the AWS Glue instance size by scaling up the worker type.
  3. Convert the AWS Glue schema to the DynamicFrame schema class.
  4. Adjust AWS Glue job scheduling frequency so the jobs run half as many times each day.
  5. Modify the IAM role that grants access to AWS glue to grant access to all S3 features.

Answer(s): A,B

Explanation:

The correct answer is AB. Here's why:
A: Partition the data that is in the S3 bucket. Organize the data by year, month, and day.
Partitioning data in S3 based on date (year, month, day) is a fundamental optimization technique for data lakes. AWS Glue and QuickSight can leverage these partitions to drastically reduce the amount of data scanned during queries and job processing.
When Glue jobs or QuickSight dashboards query the data, they can filter based on the partition keys (year, month, day), allowing them to read only the relevant data for a specific time period. Without partitioning, the jobs need to scan the entire dataset to find the data needed, which leads to longer execution times and slower dashboard performance. This concept is aligned with best practices for data lake design and query optimization in cloud environments. https://docs.aws.amazon.com/glue/latest/dg/partitioning.html
B: Increase the AWS Glue instance size by scaling up the worker type.
Increasing the AWS Glue instance size (worker type) provides more computational resources (CPU, memory, disk) to the Glue jobs. This helps accelerate data processing tasks such as data transformation, aggregation, and loading. By increasing the instance size, the Glue jobs can handle larger volumes of data and perform more complex computations in parallel. This directly addresses the problem of long-running Glue jobs and significantly improves processing time. Scaling worker type will allow Glue jobs to process a larger number of partitions in parallel. https://docs.aws.amazon.com/glue/latest/dg/monitor-performance.html
Why other options are incorrect:
C: Converting to DynamicFrame schema class does not necessarily improve job performance. The benefit of DynamicFrames mainly relates to managing schema evolution and complex data structures but not directly to runtime speed.
D: Adjusting job scheduling frequency by reducing the number of times a job is run each day will not improve performance. It reduces resource usage, but the jobs themselves will still be slow.
E: Modifying the IAM role to grant access to all S3 features does not improve Glue job performance and violates the principle of least privilege, creating a security risk.



A data engineer needs to use AWS Step Functions to design an orchestration workflow. The workflow must parallel process a large collection of data files and apply a specific transformation to each file.
Which Step Functions state should the data engineer use to meet these requirements?

  1. Parallel state
  2. Choice state
  3. Map state
  4. Wait state

Answer(s): C

Explanation:

The correct answer is C, the Map state. The Map state in AWS Step Functions is specifically designed for dynamic parallelism, enabling you to iterate over a collection of items (like data files) and execute the same steps for each item concurrently. This perfectly aligns with the requirement to process a large collection of data files and apply the same transformation to each. The Map state receives an array as input and then iterates over each element, executing a set of substates (defined within the Map state) for each element. This parallelism significantly reduces the overall processing time compared to sequential processing.
A Parallel state (option A) also executes multiple branches of execution in parallel, but it requires you to predefine those branches. It's not designed for iterating over a dynamically sized collection like the Map state. A Choice state (option B) adds conditional branching based on the input, which isn't relevant to processing each file in parallel. A Wait state (option D) simply delays the execution of the workflow for a specified duration, which doesn't contribute to parallel processing. Therefore, the Map state is the only option that directly facilitates parallel processing of data files based on iterating through a collection, fulfilling the stated requirements.
For further reading, refer to the AWS Step Functions documentation on Map state: https://docs.aws.amazon.com/step-functions/latest/dg/amazon-states-language-map-state.html and an overview of state types: https://docs.aws.amazon.com/step-functions/latest/dg/concepts-states.html .



A company is migrating a legacy application to an Amazon S3 based data lake. A data engineer reviewed data that is associated with the legacy application. The data engineer found that the legacy data contained some duplicate information. The data engineer must identify and remove duplicate information from the legacy application data.
Which solution will meet these requirements with the LEAST operational overhead?

  1. Write a custom extract, transform, and load (ETL) job in Python. Use the DataFrame.drop_duplicates() function by importing the Pandas library to perform data deduplication.
  2. Write an AWS Glue extract, transform, and load (ETL) job. Use the FindMatches machine learning (ML) transform to transform the data to perform data deduplication.
  3. Write a custom extract, transform, and load (ETL) job in Python. Import the Python dedupe library. Use the dedupe library to perform data deduplication.
  4. Write an AWS Glue extract, transform, and load (ETL) job. Import the Python dedupe library. Use the dedupe library to perform data deduplication.

Answer(s): B

Explanation:

The most efficient solution for identifying and removing duplicate information from legacy data during migration to an Amazon S3 data lake, with the least operational overhead, is to utilize an AWS Glue ETL job with the FindMatches ML Transform.
Option B is superior because AWS Glue is a fully managed ETL service, reducing the operational burden associated with managing infrastructure and scaling resources. The FindMatches transform within Glue specifically leverages machine learning to identify near-duplicate records, even if they aren't exact matches, which is a common scenario in legacy data. This automated, ML-driven approach avoids the need for writing complex custom deduplication logic.
Options A and C involve writing custom Python ETL jobs.
While these are viable, they require significantly more development and maintenance effort compared to using a pre-built Glue transform. Pandas' drop_duplicates() function (Option A) only removes exact duplicates, which might not be sufficient for the legacy data if there are inconsistencies. The dedupe library (Option C and D) is powerful but needs to be integrated and managed, adding to the overhead.
Option D, while using the dedupe library, is less efficient than using the FindMatches transform because it requires more configuration and fine-tuning, as well as integration within Glue. FindMatches is specifically designed to address this type of deduplication problem within AWS Glue, offering a simpler and more optimized solution.
In summary, AWS Glue's FindMatches transform is the ideal solution due to its managed nature, specialized functionality for fuzzy matching, and reduced operational overhead. It leverages ML for more accurate duplicate detection and simplifies the ETL process.
Relevant AWS Documentation:
AWS Glue FindMatches: https://docs.aws.amazon.com/glue/latest/dg/find-matches.html AWS Glue: https://aws.amazon.com/glue/



A company is building an analytics solution. The solution uses Amazon S3 for data lake storage and Amazon Redshift for a data warehouse. The company wants to use Amazon Redshift Spectrum to query the data that is in Amazon S3.
Which actions will provide the FASTEST queries? (Choose two.)

  1. Use gzip compression to compress individual files to sizes that are between 1 GB and 5 GB.
  2. Use a columnar storage file format.
  3. Partition the data based on the most common query predicates.
  4. Split the data into files that are less than 10 KB.
  5. Use file formats that are not splittable.

Answer(s): B,C

Explanation:

The correct answer is BC . Here's a detailed justification:
B: Use a columnar storage file format: Columnar storage formats like Parquet or ORC are highly optimized for analytical queries. Instead of storing data row by row (like CSV or JSON), these formats store data column by column. This is beneficial because Redshift Spectrum only needs to read the columns relevant to the query, significantly reducing I/O and improving query performance.
When only specific columns are selected, only those columns are scanned from S3, making queries faster.
C: Partition the data based on the most common query predicates: Partitioning data in S3 involves organizing files into folders based on the values of one or more columns, such as date or region.
When a query includes a WHERE clause that filters on one of these partitioned columns, Redshift Spectrum can use partition pruning. This means Spectrum only scans the folders (partitions) that contain the relevant data, skipping the rest, dramatically reducing the amount of data processed and improving query speed. Partitioning is one of the most effective optimizations for data lakes.
Why the other options are less optimal or incorrect:

A: Use gzip compression to compress individual files to sizes that are between 1 GB and 5 GB: While compression is generally good for reducing storage costs and network transfer times, specifically targeting 1-5 GB for gzip is not the primary factor for fastest Spectrum queries. Other compression algorithms such as Snappy or Zstandard can offer similar compression ratios with better performance for Spectrum.
While compression is important, columnar format and partitioning have larger impacts.
D: Split the data into files that are less than 10 KB: Having many small files can lead to increased overhead due to the number of S3 requests required to read the data. This overhead can negatively impact query performance. Redshift Spectrum performs best with larger files.
E: Use file formats that are not splittable: Splittable file formats allow Redshift Spectrum to parallelize the reading of data, utilizing multiple nodes to process the data simultaneously. Non-splittable file formats prevent this parallelism, limiting the query's potential speed.
In Summary:
Columnar storage minimizes data I/O by only reading relevant columns, and partitioning enables Spectrum to skip irrelevant data partitions entirely. These two optimizations work synergistically to significantly improve query performance in Redshift Spectrum when querying data in S3.
Authoritative Links:
Amazon Redshift Spectrum Best Practices: https://aws.amazon.com/blogs/big-data/top-10-performance-tuning-techniques-for-amazon-redshift-spectrum/ Optimizing Amazon S3 Performance: https://docs.aws.amazon.com/AmazonS3/latest/userguide/optimizing-performance.html



A company uses Amazon RDS to store transactional data. The company runs an RDS DB instance in a private subnet. A developer wrote an AWS Lambda function with default settings to insert, update, or delete data in the DB instance. The developer needs to give the Lambda function the ability to connect to the DB instance privately without using the public internet.
Which combination of steps will meet this requirement with the LEAST operational overhead? (Choose two.)

  1. Turn on the public access setting for the DB instance.
  2. Update the security group of the DB instance to allow only Lambda function invocations on the database port.
  3. Configure the Lambda function to run in the same subnet that the DB instance uses.
  4. Attach the same security group to the Lambda function and the DB instance. Include a self-referencing rule that allows access through the database port.
  5. Update the network ACL of the private subnet to include a self-referencing rule that allows access through the database port.

Answer(s): C,D

Explanation:

Here's a detailed justification for why options C and D are the correct choices to enable a Lambda function to privately connect to an RDS DB instance in the same VPC, with minimal operational overhead:
Option C: Configure the Lambda function to run in the same subnet that the DB instance uses.
This is crucial for private connectivity. By placing the Lambda function within the same private subnet as the RDS instance, the Lambda function can access the RDS instance using its private IP address, eliminating the need for public internet access. AWS Lambda inherently allows you to configure VPC access. This is a best practice when the function needs to interact with resources inside your VPC, such as databases. Using the VPC means the Lambda function operates within the private network you defined, enhancing security and potentially reducing latency. Subnets must have enough available IP addresses for the Lambda function to scale.
https://docs.aws.amazon.com/lambda/latest/dg/configuration-vpc.html
Option D: Attach the same security group to the Lambda function and the DB instance. Include a self-referencing rule that allows access through the database port.
Security groups act as virtual firewalls, controlling traffic in and out of your resources. Attaching the same security group to both the Lambda function and the RDS instance simplifies security management. The self-referencing rule (allowing traffic within the security group) enables the Lambda function to initiate a connection to the RDS instance on the database port (e.g., 3306 for MySQL, 5432 for PostgreSQL). A self-referencing rule is less restrictive than opening up access to all traffic on the port from any source. Using a single security group is more maintainable than managing separate rules for each resource.
https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html
Why other options are incorrect:

A: Turn on the public access setting for the DB instance: This defeats the purpose of private connectivity and exposes the database to the internet, increasing security risks.
B: Update the security group of the DB instance to allow only Lambda function invocations on the database port: While not inherently wrong, this is less efficient than using the same security group and a self-referencing rule as it requires specific knowledge and management of the Lambda function's network interface. Also, how would the security group identify traffic originating specifically from Lambda function invocations without tying the resources together?
E: Update the network ACL of the private subnet to include a self-referencing rule that allows access through the database port: While technically functional, Network ACLs (NACLs) are stateless and operate at the subnet level. Security groups are stateful and operate at the instance level providing a more granular and resource-specific control and are easier to manage in this scenario. You'd also have to manage inbound and outbound rules to make sure the packets can come back to the function.
In summary, by placing the Lambda function in the same subnet as the RDS instance and using a shared security group with a self-referencing rule, you achieve secure and private connectivity with the least amount of administrative overhead.



  PDF
Viewing page 5 of 47
Viewing questions 21 - 25 out of 366 questions


Post your Comments and Discuss Amazon Amazon-DEA-C01 exam prep with other Community members:

AI Tutor AI Tutor 👋 I’m here to help!