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 7 )

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

A data engineer must ingest a source of structured data that is in .csv format into an Amazon S3 data lake. The .csv files contain 15 columns. Data analysts need to run Amazon Athena queries on one or two columns of the dataset. The data analysts rarely query the entire file.
Which solution will meet these requirements MOST cost-effectively?

  1. Use an AWS Glue PySpark job to ingest the source data into the data lake in .csv format.
  2. Create an AWS Glue extract, transform, and load (ETL) job to read from the .csv structured data source. Configure the job to ingest the data into the data lake in JSON format.
  3. Use an AWS Glue PySpark job to ingest the source data into the data lake in Apache Avro format.
  4. Create an AWS Glue extract, transform, and load (ETL) job to read from the .csv structured data source. Configure the job to write the data into the data lake in Apache Parquet format.

Answer(s): D

Explanation:

The most cost-effective solution is to use AWS Glue to transform the CSV data into Apache Parquet format before storing it in the S3 data lake.
Here's why:
Columnar Storage: Parquet is a columnar storage format. This means that data for each column is stored contiguously on disk.
When Athena queries only one or two columns, it only needs to read those specific columns, drastically reducing the amount of data scanned and, consequently, query costs. This contrasts with row-based formats like CSV or JSON, where the entire row must be read even if only a few columns are needed. Athena Cost Optimization: Athena charges based on the amount of data scanned. By reducing the data scanned with Parquet, query costs are significantly lowered. Data Compression: Parquet supports efficient data compression. This further reduces storage costs in S3 and decreases the amount of data that Athena needs to process, leading to faster query performance and lower costs. Glue ETL Capabilities: AWS Glue is a fully managed ETL service that can read CSV data, transform it, and write it to S3 in Parquet format. Glue provides the ability to define schema and handle data type conversions easily. Avro: While Avro is a row-based format and supports schema evolution, it does not offer the same cost benefits as Parquet for analytical queries that only need a subset of columns. CSV and JSON: Storing the data as CSV or JSON would be the least cost-effective option as Athena would have to scan the entire file for each query, regardless of the number of columns needed. This significantly increases query costs.
Therefore, using Glue to convert the CSV data to Parquet optimizes both storage and Athena query costs by leveraging columnar storage and compression, directly addressing the requirement of cost-effectiveness when analysts frequently query only a few columns.
Here are some authoritative links for further research:
Apache Parquet : Official Apache Parquet website. Amazon Athena Pricing : Details on how Athena is priced. AWS Glue : AWS Glue product page. Top 5 Performance Tuning Tips for Amazon Athena : AWS blog on Athena performance tuning.



A company has five offices in different AWS Regions. Each office has its own human resources (HR) department that uses a unique IAM role. The company stores employee records in a data lake that is based on Amazon S3 storage. A data engineering team needs to limit access to the records. Each HR department should be able to access records for only employees who are within the HR department's Region.
Which combination of steps should the data engineering team take to meet this requirement with the LEAST operational overhead? (Choose two.)

  1. Use data filters for each Region to register the S3 paths as data locations.
  2. Register the S3 path as an AWS Lake Formation location.
  3. Modify the IAM roles of the HR departments to add a data filter for each department's Region.
  4. Enable fine-grained access control in AWS Lake Formation. Add a data filter for each Region.
  5. Create a separate S3 bucket for each Region. Configure an IAM policy to allow S3 access. Restrict access based on Region.

Answer(s): B,D

Explanation:

The best approach for implementing regional access control on the employee records in the data lake while minimizing operational overhead is using AWS Lake Formation with fine-grained access control and data filters.
B: Register the S3 path as an AWS Lake Formation location: This is the foundation of the solution. Lake Formation acts as a central governance service for the data lake. Registering the S3 path with Lake Formation allows you to apply granular access control and data filters. Without this, you can't leverage Lake Formation's capabilities. https://aws.amazon.com/lake-formation/
D: Enable fine-grained access control in AWS Lake Formation. Add a data filter for each Region: This is how you implement the required access restriction. Fine-grained access control in Lake Formation enables you to define which users (in this case, IAM roles assumed by the HR departments) can access which data, based on criteria. Data filters allow you to restrict access to specific rows or columns based on conditions, in this instance, the Region. By defining a data filter for each Region, you ensure that each HR department can only see data for employees in their respective Region. This avoids the need to create multiple buckets or modify existing IAM roles. This approach allows for centralized management of security policies for the data lake. Furthermore, Lake Formation integrates with AWS Glue for data cataloging and also provides audit logs via CloudTrail. https://docs.aws.amazon.com/lake-formation/latest/dg/access-control-data-filtering.html
Why other options are incorrect:

A: Use data filters for each Region to register the S3 paths as data locations: This is not a standalone operation that secures the data. It requires using a governance service like Lake Formation.
C: Modify the IAM roles of the HR departments to add a data filter for each department's Region: While technically possible, modifying IAM roles can become complex and difficult to manage as the number of departments and Regions increases. This increases operational overhead significantly compared to using Lake Formation's centralized control. IAM policies become very large and complex.
E: Create a separate S3 bucket for each Region. Configure an IAM policy to allow S3 access. Restrict access based on Region: This creates unnecessary operational complexity due to managing multiple S3 buckets. The amount of S3 buckets that need to be managed increase as the company expands. It duplicates storage and potentially complicates data processing and analytics. Using data filters within Lake Formation on a single S3 bucket is more efficient.



A company uses AWS Step Functions to orchestrate a data pipeline. The pipeline consists of Amazon EMR jobs that ingest data from data sources and store the data in an Amazon S3 bucket. The pipeline also includes EMR jobs that load the data to Amazon Redshift. The company's cloud infrastructure team manually built a Step Functions state machine. The cloud infrastructure team launched an EMR cluster into a VPC to support the EMR jobs. However, the deployed Step Functions state machine is not able to run the EMR jobs.
Which combination of steps should the company take to identify the reason the Step Functions state machine is not able to run the EMR jobs? (Choose two.)

  1. Use AWS CloudFormation to automate the Step Functions state machine deployment. Create a step to pause the state machine during the EMR jobs that fail. Configure the step to wait for a human user to send approval through an email message. Include details of the EMR task in the email message for further analysis.
  2. Verify that the Step Functions state machine code has all IAM permissions that are necessary to create and run the EMR jobs. Verify that the Step Functions state machine code also includes IAM permissions to access the Amazon S3 buckets that the EMR jobs use. Use Access Analyzer for S3 to check the S3 access properties.
  3. Check for entries in Amazon CloudWatch for the newly created EMR cluster. Change the AWS Step Functions state machine code to use Amazon EMR on EKS. Change the IAM access policies and the security group configuration for the Step Functions state machine code to reflect inclusion of Amazon Elastic Kubernetes Service (Amazon EKS).
  4. Query the flow logs for the VPC. Determine whether the traffic that originates from the EMR cluster can successfully reach the data providers. Determine whether any security group that might be attached to the Amazon EMR cluster allows connections to the data source servers on the informed ports.
  5. Check the retry scenarios that the company configured for the EMR jobs. Increase the number of seconds in the interval between each EMR task. Validate that each fallback state has the appropriate catch for each decision state. Configure an Amazon Simple Notification Service (Amazon SNS) topic to store the error messages.

Answer(s): B,D

Explanation:

The correct answer is B
D. Here's why:
B - Verify IAM Permissions: Step Functions needs proper IAM permissions to interact with other AWS services like EMR and S3. If the state machine lacks the necessary permissions to create/run EMR jobs or access S3 buckets, it will fail. Access Analyzer for S3 can help identify if any S3 bucket policies are overly permissive or have unintended access. This is fundamental to AWS security and service integration. (Reference: https://docs.aws.amazon.com/step-functions/latest/dg/tutorial-iam-role.html , https://docs.aws.amazon.com/AmazonS3/latest/userguide/access-analyzer.html ) D - Query VPC Flow Logs: If the EMR cluster is in a VPC and unable to reach data sources or other necessary endpoints, VPC Flow Logs can pinpoint connectivity issues. They can reveal if traffic is being blocked by network ACLs, security groups, or routing configurations. This is critical for diagnosing network-related failures. (Reference: https://docs.aws.amazon.com/vpc/latest/userguide/flow-logs.html )
Here's why the other options are less suitable:
A - CloudFormation Automation (Not the Immediate Problem): While automation is beneficial, it doesn't directly address the cause of the failure. Debugging needs to precede automation. The suggested "pause" and "email" are workaround actions rather than diagnostic steps. C - EMR on EKS (Changing Technology): Switching to EMR on EKS would require substantial changes to the pipeline architecture and is not a necessary step for identifying the root cause of the initial problem with EMR on EC2. Checking CloudWatch for the existing cluster is important, but not the main focus. E - Retry Scenarios: While retry mechanisms are important for resilience, they don't solve the underlying issue causing the EMR jobs to fail in the first place. This is focused on a symptom not the cause.
Therefore, the most effective initial steps are to examine IAM permissions and VPC connectivity because these are common causes for Step Functions failures when interacting with services within a VPC.



A company is developing an application that runs on Amazon EC2 instances. Currently, the data that the application generates is temporary. However, the company needs to persist the data, even if the EC2 instances are terminated. A data engineer must launch new EC2 instances from an Amazon Machine Image (AMI) and configure the instances to preserve the data.
Which solution will meet this requirement?

  1. Launch new EC2 instances by using an AMI that is backed by an EC2 instance store volume that contains the application data. Apply the default settings to the EC2 instances.
  2. Launch new EC2 instances by using an AMI that is backed by a root Amazon Elastic Block Store (Amazon EBS) volume that contains the application data. Apply the default settings to the EC2 instances.
  3. Launch new EC2 instances by using an AMI that is backed by an EC2 instance store volume. Attach an Amazon Elastic Block Store (Amazon EBS) volume to contain the application data. Apply the default settings to the EC2 instances.
  4. Launch new EC2 instances by using an AMI that is backed by an Amazon Elastic Block Store (Amazon EBS) volume. Attach an additional EC2 instance store volume to contain the application data. Apply the default settings to the EC2 instances.

Answer(s): C

Explanation:

The correct answer is
C: Here's why:
The key requirement is persisting data even when EC2 instances are terminated. Instance store volumes are ephemeral, meaning their data is lost when the instance is stopped, terminated, or fails. This eliminates options A and D because they rely on instance store volumes for data persistence.
While an EBS-backed AMI (option B) can persist the root volume's data, it's not the most suitable approach for persisting application data generated during runtime. Modifying the root volume's AMI for every data change is inefficient and doesn't align with best practices. Also, it might be against security policies since we should not be modifying the core image with runtime application data.
Attaching a separate EBS volume (option C) is the ideal solution. EBS volumes are persistent block storage that can be detached from one instance and attached to another. This allows the application data to survive instance terminations. You can launch new EC2 instances from any suitable base AMI (doesn't need to pre-
contain the data) and then simply attach the existing EBS volume containing the application data. This offers flexibility, scalability, and data durability.
In summary, using a separate EBS volume provides the persistence needed, decouples the data from the EC2 instance lifecycle, and aligns with cloud storage best practices.
Relevant Links:
Amazon EBS: https://aws.amazon.com/ebs/ Amazon EC2 Instance Store: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/InstanceStorage.html Amazon Machine Images (AMIs): https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AMIs.html



A company uses Amazon Athena to run SQL queries for extract, transform, and load (ETL) tasks by using Create Table As Select (CTAS). The company must use Apache Spark instead of SQL to generate analytics.
Which solution will give the company the ability to use Spark to access Athena?

  1. Athena query settings
  2. Athena workgroup
  3. Athena data source
  4. Athena query editor

Answer(s): B

Explanation:

The correct answer is
B: Athena workgroup . Here's why:
The core requirement is to enable Apache Spark to access data managed by Amazon Athena. Athena's primary function is to execute SQL queries against data stored in Amazon S3. To integrate Spark with Athena, we need a mechanism for Spark to interact with Athena's data catalog and query engine.
Athena Workgroups: Workgroups are a key feature in Athena for isolating queries and managing resources. They also control access to Athena data and configurations. Creating a workgroup allows you to configure settings specific to Spark's interaction with Athena, particularly in terms of query execution and resource utilization. By using a workgroup, you can define settings for the Spark application to connect to Athena.
Why other options are incorrect:
Athena Query Settings: Query settings are associated with individual queries. They don't provide a centralized and reusable mechanism for Spark to consistently interact with Athena. Athena Data Source: While a data source configuration is necessary for Athena to access the underlying data in S3, it doesn't directly facilitate Spark's interaction with Athena. Spark needs to communicate with Athena's query engine, not just the underlying S3 data directly (although that's possible, it bypasses Athena's metadata management and query optimization). Athena Query Editor: The query editor is a web-based interface for manually running queries. It doesn't provide programmatic access for Spark.
Using a JDBC or ODBC driver, a Spark application can connect to an Athena workgroup. The driver uses the configured settings of the workgroup to correctly interact with Athena.
In summary, Athena workgroups provides a central and reusable mechanism for Spark to connect and use Athena.
For further research, check these links:
https://docs.aws.amazon.com/athena/latest/ug/workgroups-concept.html https://aws.amazon.com/blogs/big-data/using-apache-spark-with-amazon-athena-to-query-data-in-place/



A company needs to partition the Amazon S3 storage that the company uses for a data lake. The partitioning will use a path of the S3 object keys in the following format: s3://bucket/prefix/year=2023/month=01/day=01. A data engineer must ensure that the AWS Glue Data Catalog synchronizes with the S3 storage when the company adds new partitions to the bucket.
Which solution will meet these requirements with the LEAST latency?

  1. Schedule an AWS Glue crawler to run every morning.
  2. Manually run the AWS Glue CreatePartition API twice each day.
  3. Use code that writes data to Amazon S3 to invoke the Boto3 AWS Glue create_partition API call.
  4. Run the MSCK REPAIR TABLE command from the AWS Glue console.

Answer(s): C

Explanation:

The correct answer is C because it provides the lowest latency and most automated approach to synchronizing the AWS Glue Data Catalog with new partitions added to the S3 data lake.
Here's why:
Option C: (Correct) Proactive Partition Creation: Invoking the CreatePartition API using Boto3 (AWS SDK for
Python) immediately after writing data to S3 ensures that the Glue Data Catalog is updated in real-time (or very close to it). This reduces the time window where the Data Catalog is out of sync with the actual data in S3. The code writing the data can directly notify Glue about the new partition, leading to minimal latency. This approach avoids the need for scheduled scans or manual interventions.
Option A: Scheduled Crawler (Higher Latency): Scheduling a Glue crawler is a valid approach for discovering and registering partitions. However, it introduces latency because the crawler only runs periodically (in this case, every morning). Any partitions added after the crawler runs and before the next scheduled run won't be immediately reflected in the Data Catalog. This delay can hinder real-time or near real-time query performance.
Option B: Manual CreatePartition (Highest Latency, Error-Prone): Manually running the CreatePartition API is the least desirable option. It requires human intervention, which is prone to errors and delays. This solution is not scalable or maintainable, especially as the number of partitions grows.
Option D: MSCK REPAIR TABLE (Post-Facto, Potentially Inefficient): MSCK REPAIR TABLE is a Hive metastore command that scans the S3 path for partitions and updates the metastore (in this case, the Glue Data Catalog).
While it works, it's a reactive approach. It detects and fixes inconsistencies after they occur. Moreover, scanning the entire S3 path can be resource-intensive and slow, especially for large datasets. It also doesn't scale well because each execution requires scanning the entire bucket. It is best used for recovering from unexpected state corruption.
Therefore, using the CreatePartition API directly within the data writing process offers the most immediate and automated synchronization, ensuring that the Data Catalog reflects the current state of the S3 data lake with the least latency.
Supporting Links:
AWS Glue Crawlers: https://docs.aws.amazon.com/glue/latest/dg/add-crawler.html AWS Glue CreatePartition API: https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-catalog-partitions.html#aws-glue-api-catalog-partitions-CreatePartition Boto3 Glue Client: https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/glue.html MSCK REPAIR TABLE : https://docs.aws.amazon.com/athena/latest/ug/msck-repair-table.html



A media company uses software as a service (SaaS) applications to gather data by using third-party tools. The company needs to store the data in an Amazon S3 bucket. The company will use Amazon Redshift to perform analytics based on the data.
Which AWS service or feature will meet these requirements with the LEAST operational overhead?

  1. Amazon Managed Streaming for Apache Kafka (Amazon MSK)
  2. Amazon AppFlow
  3. AWS Glue Data Catalog
  4. Amazon Kinesis

Answer(s): B

Explanation:

Here's a detailed justification for why Amazon AppFlow is the best choice for this scenario, along with links for further reading:
The media company wants to transfer data from SaaS applications into an S3 bucket for analysis in Redshift, while minimizing operational overhead. Several AWS services could potentially move data, but AppFlow is specifically designed for this type of data transfer.
Why AppFlow is the best fit: Amazon AppFlow is a fully managed integration service that enables you to securely transfer data between SaaS applications and AWS services like S3. It requires minimal coding and has built-in connectors for common SaaS applications (e.g., Salesforce, Marketo, Google Analytics). The "least operational overhead" requirement is precisely what AppFlow addresses by automating the data transfer process.
Why other options are less suitable:
Amazon MSK: Amazon MSK is for streaming data, suitable for continuous data flow, which isn't explicitly required in this case. Setting up and managing a Kafka cluster involves significant operational overhead. AWS Glue Data Catalog: Glue Data Catalog is a metadata repository, useful for discovering and understanding data, but it doesn't transfer data. It would be useful after the data is in S3, for Redshift to access the data, but it isn't the solution for data ingestion itself. Amazon Kinesis: Similar to Amazon MSK, Kinesis is focused on real-time streaming data. It might be overkill and introduce unnecessary complexity if the data transfer from SaaS applications can be handled in batches or on a schedule.
AppFlow allows configuring data transformations during the transfer, if necessary, and automates the data transfer process, including error handling and monitoring. Using AppFlow significantly reduces the need for custom code and simplifies the overall data integration pipeline, directly addressing the "least operational overhead" requirement.
Supporting Links:
Amazon AppFlow: https://aws.amazon.com/appflow/ AWS Glue Data Catalog: https://aws.amazon.com/glue/ Amazon MSK: https://aws.amazon.com/msk/ Amazon Kinesis: https://aws.amazon.com/kinesis/



A data engineer is using Amazon Athena to analyze sales data that is in Amazon S3. The data engineer writes a query to retrieve sales amounts for 2023 for several products from a table named sales_data. However, the query does not return results for all of the products that are in the sales_data table. The data engineer needs to troubleshoot the query to resolve the issue. The data engineer's original query is as follows: SELECT product_name, sum(sales_amount) FROM sales_data -WHERE year = 2023 -GROUP BY product_name -How should the data engineer modify the Athena query to meet these requirements?

  1. Replace sum(sales_amount) with count(*) for the aggregation.
  2. Change WHERE year = 2023 to WHERE extract(year FROM sales_data) = 2023.
  3. Add HAVING sum(sales_amount) > 0 after the GROUP BY clause.
  4. Remove the GROUP BY clause.

Answer(s): B

Explanation:

The original query fails to return all expected results for 2023 sales data, indicating an issue with the WHERE
clause filtering. The most probable cause is that the 'year' column isn't a readily extractable year integer, potentially being embedded within a date or timestamp format in the 'sales_data' table.
Option B, changing WHERE year = 2023 to WHERE extract(year FROM sales_data) = 2023 , directly addresses this issue. The extract(year FROM sales_data) function extracts the year from the sales_data column (assuming it represents a date or timestamp), allowing the query to correctly filter for sales records specifically from the year 2023. This ensures that all sales figures for 2023 are included in the results, resolving the initial problem of missing data. Athena supports SQL standard functions like extract , making this a viable and efficient solution. https://prestodb.io/docs/current/functions/datetime.html
Option A, replacing sum(sales_amount) with count(*) , changes the query's purpose from calculating the total sales amount to counting the number of sales records.
While this might provide insights, it doesn't address the issue of filtering for the correct year, and would not resolve the problem of missing sales data.
Option C, adding HAVING sum(sales_amount) > 0 after the GROUP BY clause, filters out product groups with total sales less than or equal to zero.
While useful in some scenarios, it doesn't resolve the problem of the query not retrieving all data for 2023; it merely filters the existing results.
Option D, removing the GROUP BY clause, will result in an error because sales_amount is not part of group by clause and not aggregated in aggregate function.
Therefore, option B is the correct solution because it focuses on correctly filtering the sales data for the specific year, thus ensuring that the query retrieves all relevant records from the sales_data table.



  PDF
Viewing page 7 of 47
Viewing questions 49 - 56 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!