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

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

A company stores details about transactions in an Amazon S3 bucket. The company wants to log all writes to the S3 bucket into another S3 bucket that is in the same AWS Region.
Which solution will meet this requirement with the LEAST operational effort?

  1. Configure an S3 Event Notifications rule for all activities on the transactions S3 bucket to invoke an AWS Lambda function. Program the Lambda function to write the event to Amazon Kinesis Data Firehose. Configure Kinesis Data Firehose to write the event to the logs S3 bucket.
  2. Create a trail of management events in AWS CloudTraiL. Configure the trail to receive data from the transactions S3 bucket. Specify an empty prefix and write-only events. Specify the logs S3 bucket as the destination bucket.
  3. Configure an S3 Event Notifications rule for all activities on the transactions S3 bucket to invoke an AWS Lambda function. Program the Lambda function to write the events to the logs S3 bucket.
  4. Create a trail of data events in AWS CloudTraiL. Configure the trail to receive data from the transactions S3 bucket. Specify an empty prefix and write-only events. Specify the logs S3 bucket as the destination bucket.

Answer(s): D

Explanation:

Here's a detailed justification for why option D is the best solution and why the other options are not as suitable for logging S3 write operations with the least operational effort:
Why Option D is Correct: Create a CloudTrail data event trail
CloudTrail Data Events: CloudTrail allows you to log data events, which specifically track object-level API activity on S3 buckets, including PutObject (writes), GetObject (reads), and DeleteObject operations. This is exactly what the company needs – a record of writes to the S3 bucket. Data Event Selection: By configuring a trail to track data events for the transactions S3 bucket, you directly capture the required information without needing to create custom logic. Minimal Configuration: Specifying an empty prefix ensures that all objects within the bucket are monitored. Selecting "write-only" events focuses the logging on the specific operations of interest, reducing unnecessary data. Direct Delivery: CloudTrail directly delivers the logs to the specified logs S3 bucket, eliminating the need for intermediate services or custom code. Least Operational Effort: CloudTrail is a managed service designed for logging AWS API calls. This makes it much easier to set up and maintain than alternatives involving Lambda functions and Kinesis.
Why Other Options are Incorrect:
Option A (S3 Event Notifications, Lambda, Kinesis Data Firehose): This is an overly complex solution. S3 Event Notifications can trigger Lambda, but directing those events through Kinesis Data Firehose to another S3 bucket adds unnecessary overhead. It requires configuring and managing multiple services, writing and maintaining Lambda code, and dealing with potential Kinesis buffering issues. Option B (CloudTrail Management Events): CloudTrail management events track operations performed on AWS resources themselves (e.g., creating a bucket, modifying IAM roles). They do not track object-level API activity such as writing data to an S3 bucket. Therefore, they are unsuitable for this use case. Option C (S3 Event Notifications, Lambda): While simpler than Option A, this still involves writing and maintaining a Lambda function to handle the S3 events. It's also less efficient than CloudTrail's built-in logging, especially for capturing a comprehensive and auditable history of all writes.
In Summary:
Option D, leveraging CloudTrail data events, offers the most straightforward, efficient, and least operationally intensive way to log all writes to an S3 bucket into another S3 bucket. It utilizes a managed service specifically designed for logging API activity, minimizing the need for custom code and complex configurations.
Authoritative Links:
AWS CloudTrail: https://aws.amazon.com/cloudtrail/ CloudTrail Data Events: https://docs.aws.amazon.com/awscloudtrail/latest/userguide/logging-data-events-with-cloudtrail.html S3 Event Notifications: https://docs.aws.amazon.com/AmazonS3/latest/userguide/EventNotifications.html



A data engineer needs to maintain a central metadata repository that users access through Amazon EMR and Amazon Athena queries. The repository needs to provide the schema and properties of many tables. Some of the metadata is stored in Apache Hive. The data engineer needs to import the metadata from Hive into the central metadata repository.
Which solution will meet these requirements with the LEAST development effort?

  1. Use Amazon EMR and Apache Ranger.
  2. Use a Hive metastore on an EMR cluster.
  3. Use the AWS Glue Data Catalog.
  4. Use a metastore on an Amazon RDS for MySQL DB instance.

Answer(s): C

Explanation:

The correct answer is
C. Use the AWS Glue Data Catalog.
Here's why this is the most suitable solution:
AWS Glue Data Catalog serves as a centralized metadata repository specifically designed for AWS data lakes and analytics services. It provides a persistent metastore to store table definitions, schema information, data lineage, and other metadata. Critically, it's integrated seamlessly with both Amazon EMR and Amazon Athena.
Importing metadata from Hive into the Glue Data Catalog can be achieved with minimal development effort. Glue provides built-in crawlers that can automatically scan data sources (including Hive metastores) and infer schema, creating table definitions in the Glue Data Catalog. This eliminates the need for manual schema definition and management.
Option A (Amazon EMR and Apache Ranger) is not ideal because Apache Ranger primarily focuses on security and access control.
While Ranger can integrate with Hive, it doesn't provide a central metadata repository as effectively as Glue Data Catalog. It requires more configuration and management for metadata consolidation.
Option B (Hive metastore on an EMR cluster) creates a Hive-centric solution tied to an EMR cluster's lifecycle. This isn't a central, persistent repository accessible independently by other services like Athena. Maintaining high availability for the EMR cluster would also add unnecessary complexity. It's also less scalable.
Option D (Metastore on an Amazon RDS for MySQL DB instance) is viable but requires more manual configuration and management.
While you could host a metastore on RDS, AWS Glue Data Catalog abstracts away the complexity of managing the underlying database, schema, and scaling. The Glue crawler is also a significant advantage for automatically discovering and importing metadata, which is lacking in a standalone RDS metastore setup.
Therefore, AWS Glue Data Catalog offers the most integrated, managed, and least-effort approach for maintaining a central metadata repository accessible by both Amazon EMR and Amazon Athena, especially when the initial metadata is housed in Hive.
Supporting Links:
AWS Glue Data Catalog: https://aws.amazon.com/glue/features/ AWS Glue Crawlers: https://docs.aws.amazon.com/glue/latest/dg/add-crawler.html



A company needs to build a data lake in AWS. The company must provide row-level data access and column-level data access to specific teams. The teams will access the data by using Amazon Athena, Amazon Redshift Spectrum, and Apache Hive from Amazon EMR.
Which solution will meet these requirements with the LEAST operational overhead?

  1. Use Amazon S3 for data lake storage. Use S3 access policies to restrict data access by rows and columns. Provide data access through Amazon S3.
  2. Use Amazon S3 for data lake storage. Use Apache Ranger through Amazon EMR to restrict data access by rows and columns. Provide data access by using Apache Pig.
  3. Use Amazon Redshift for data lake storage. Use Redshift security policies to restrict data access by rows and columns. Provide data access by using Apache Spark and Amazon Athena federated queries.
  4. Use Amazon S3 for data lake storage. Use AWS Lake Formation to restrict data access by rows and columns. Provide data access through AWS Lake Formation.

Answer(s): D

Explanation:

The correct answer is D. Use Amazon S3 for data lake storage. Use AWS Lake Formation to restrict data access by rows and columns. Provide data access through AWS Lake Formation.
Here's why:
S3 for Data Lake Storage: Amazon S3 is the ideal choice for data lake storage due to its scalability, durability, and cost-effectiveness. It can store vast amounts of structured, semi-structured, and unstructured data in its native formats. AWS Lake Formation for Granular Access Control: AWS Lake Formation provides fine-grained data access control at the row and column levels. It centralizes security management for data in the data lake, simplifying the process of granting and revoking permissions. It also integrates seamlessly with Athena, Redshift Spectrum, and EMR (Hive), addressing the question's specific access requirements. Least Operational Overhead: Lake Formation simplifies the data access control process, reducing the operational overhead compared to managing security policies directly in S3 or implementing complex solutions with Apache Ranger. It provides a central place to define and manage data access policies.
Let's examine why other options are less suitable:

A: S3 Access Policies: While S3 access policies can restrict access, they become complex and difficult to manage at row and column levels, especially across different services like Athena, Redshift Spectrum, and Hive. It lacks the central management capabilities offered by Lake Formation.
B. Apache Ranger: Apache Ranger, deployed through EMR, can provide row and column-level access control. However, setting it up and maintaining it introduces significant operational overhead, especially when integrating with services outside of the EMR ecosystem like Athena and Redshift Spectrum. This approach necessitates managing another service (Ranger) and its configurations. Moreover, Apache Pig is not used to provide data access by the specific teams, per the use-case. C. Amazon Redshift: Amazon Redshift is a data warehouse, not a data lake.
While it supports security policies, it's not designed for storing the large, diverse datasets typically found in a data lake. Also, it is not optimized for storing the data in its native raw format. In addition, forcing all data access through Redshift, particularly by Spark and Athena federated queries, can add complexity and latency.
In summary, AWS Lake Formation is designed to address the specific requirements of the question (row and column-level access control for Athena, Redshift Spectrum, and Hive with minimal overhead), making it the optimal solution.
Supporting Links:
AWS Lake Formation: https://aws.amazon.com/lake-formation/ Amazon S3: https://aws.amazon.com/s3/



An airline company is collecting metrics about flight activities for analytics. The company is conducting a proof of concept (POC) test to show how analytics can provide insights that the company can use to increase on-time departures. The POC test uses objects in Amazon S3 that contain the metrics in .csv format. The POC test uses Amazon Athena to query the data. The data is partitioned in the S3 bucket by date. As the amount of data increases, the company wants to optimize the storage solution to improve query performance.
Which combination of solutions will meet these requirements? (Choose two.)

  1. Add a randomized string to the beginning of the keys in Amazon S3 to get more throughput across partitions.
  2. Use an S3 bucket that is in the same account that uses Athena to query the data.
  3. Use an S3 bucket that is in the same AWS Region where the company runs Athena queries.
  4. Preprocess the .csv data to JSON format by fetching only the document keys that the query requires.
  5. Preprocess the .csv data to Apache Parquet format by fetching only the data blocks that are needed for predicates.

Answer(s): C,E

Explanation:

Let's break down why options C and E are the correct solutions for optimizing the airline company's data storage and query performance in this scenario.
Option C: Use an S3 bucket that is in the same AWS Region where the company runs Athena queries.
Athena's performance is significantly impacted by data locality.
When the S3 bucket and Athena reside in the same AWS Region, data transfer latency is minimized. This is because the data doesn't need to travel across regions, resulting in faster query execution. AWS prioritizes data transfer within a region over cross-region transfers, leading to lower costs and better performance. This is a fundamental best practice in AWS for any services that interact with S3 for data processing or querying. https://aws.amazon.com/blogs/big-data/top-10-performance-tuning-tips-for-amazon-athena/
Option E: Preprocess the .csv data to Apache Parquet format by fetching only the data blocks that are needed for predicates.
Apache Parquet is a columnar storage format optimized for analytical queries. Unlike row-based formats like CSV, Parquet stores data by column. This means Athena only reads the specific columns required by a query, reducing I/O and improving performance. Furthermore, Parquet supports predicate pushdown, allowing Athena to filter data based on WHERE clause conditions before reading the data from S3. This significantly reduces the amount of data that needs to be scanned, leading to substantial performance gains. Parquet also supports compression, reducing storage costs. https://aws.amazon.com/blogs/big-data/top-10-performance-tuning-tips-for-amazon-athena/
Why other options are incorrect:
Option A: Adding a randomized string to the S3 key is relevant for write throughput when dealing with S3's request rate limits and doesn't directly optimize Athena query performance once the data is stored. It's primarily about distributing write requests across different partitions to avoid throttling, not read performance.
Option B: Using an S3 bucket in the same account has no significant direct effect on Athena query performance. IAM permissions might be slightly simpler to manage within the same account, but the performance boost is negligible compared to regional locality and columnar storage.
Option D: While converting to JSON might offer some benefits over CSV, JSON is still a row-based format. It doesn't provide the columnar advantages and predicate pushdown offered by Parquet for analytical queries. Therefore, Parquet is the significantly better option for query performance.



A company uses Amazon RDS for MySQL as the database for a critical application. The database workload is mostly writes, with a small number of reads. A data engineer notices that the CPU utilization of the DB instance is very high. The high CPU utilization is slowing down the application. The data engineer must reduce the CPU utilization of the DB Instance.
Which actions should the data engineer take to meet this requirement? (Choose two.)

  1. Use the Performance Insights feature of Amazon RDS to identify queries that have high CPU utilization. Optimize the problematic queries.
  2. Modify the database schema to include additional tables and indexes.
  3. Reboot the RDS DB instance once each week.
  4. Upgrade to a larger instance size.
  5. Implement caching to reduce the database query load.

Answer(s): A,D

Explanation:

The correct answer is A
D. Here's a detailed justification:

A: Use the Performance Insights feature of Amazon RDS to identify queries that have high CPU utilization. Optimize the problematic queries.
Performance Insights is an RDS feature specifically designed to diagnose database performance issues. It allows you to identify the queries that are consuming the most CPU resources. These queries are often inefficient or poorly written. By identifying and optimizing these "top" queries (e.g., through query rewriting, adding indexes, or optimizing table structures), you can significantly reduce the CPU load on the database server. This is a direct approach to addressing the root cause of the high CPU utilization.
Authoritative Link: Amazon RDS Performance Insights
D: Upgrade to a larger instance size.
Upgrading to a larger instance size (e.g., from db.m5.large to db.m5.xlarge) provides the database with more CPU cores and memory. This increased capacity allows the database to handle the workload with less strain on the existing CPU resources.
While this doesn't solve the underlying problem of inefficient queries, it can provide immediate relief from the high CPU utilization and improve application performance. It's akin to upgrading the engine in a car to handle the same load more easily. However, this is often a more expensive solution than query optimization and should ideally be pursued in tandem with option A.
Why other options are not ideal:
B: Modify the database schema to include additional tables and indexes: While adding indexes can improve query performance for read-heavy workloads, the question specifies a write-heavy workload. Adding indexes to a write-heavy database can actually increase CPU utilization due to the overhead of maintaining the indexes on every write operation. Splitting tables without a clear performance benefit is unlikely to solve the CPU problem and may complicate the application. Therefore, this is generally an incorrect approach without more information about specific queries.
C: Reboot the RDS DB instance once each week: Rebooting the instance only provides temporary relief. It clears the cache and restarts processes, but the same high CPU utilization will return as soon as the workload resumes. This is not a sustainable or effective solution to the problem.
E: Implement caching to reduce the database query load. Caching is beneficial primarily for read-heavy workloads. The scenario specifically mentions the workload being mostly write, so caching has less of an impact on reducing the CPU utilization due to writes.
In summary, identifying and optimizing CPU-intensive queries (A) and scaling up the instance size (D) are the most appropriate actions to reduce CPU utilization in a write-heavy RDS for MySQL database.



A company has used an Amazon Redshift table that is named Orders for 6 months. The company performs weekly updates and deletes on the table. The table has an interleaved sort key on a column that contains AWS Regions. The company wants to reclaim disk space so that the company will not run out of storage space. The company also wants to analyze the sort key column.
Which Amazon Redshift command will meet these requirements?

  1. VACUUM FULL Orders
  2. VACUUM DELETE ONLY Orders
  3. VACUUM REINDEX Orders
  4. VACUUM SORT ONLY Orders

Answer(s): C

Explanation:

Here's a detailed justification for why option C, VACUUM REINDEX Orders , is the most appropriate answer,
and why the other options are less suitable, given the scenario.
The company's primary concerns are reclaiming disk space due to weekly updates and deletes, and analyzing the sort key column. Amazon Redshift's VACUUM command family helps with these tasks, but each variation addresses a different aspect of table maintenance.
VACUUM FULL Orders : This option performs a full vacuum, which involves both sorting and merging deleted rows.
While it reclaims space and sorts, it is the most resource-intensive and time-consuming vacuum operation. Since the table already uses an interleaved sort key, repeatedly performing VACUUM FULL might be overkill if only deleted rows are the immediate concern. VACUUM DELETE ONLY Orders : This option removes rows marked for deletion without re-sorting the table.
This is a good solution for reclaiming space quickly, but it does not analyze or reorganize the interleaved sort key, which the company wants to do. VACUUM SORT ONLY Orders : This option sorts the table without removing deleted rows.
While this helps maintain sort order, it doesn't address the primary concern of reclaiming disk space consumed by deleted rows. VACUUM REINDEX Orders : This option is specifically designed to rebuild the indexes on the sort key columns.
In the context of an interleaved sort key, VACUUM REINDEX not only reclusters the data according to the sort key (which improves query performance based on the sort key column), but also removes deleted rows in the process of re-indexing. This accomplishes both goals of reclaiming space and optimizing the interleaved sort key, which is based on the AWS Regions column. Because interleaved sort keys are designed to optimize queries where multiple columns are used in WHERE clauses, re-indexing ensures that the blocks of data are optimally arranged based on all interleaved key columns. It achieves the required disk space reclamation because rows marked for deletion will not be included in the rebuilt indexes.
Therefore, VACUUM REINDEX Orders is the most suitable command. It reclaims disk space by removing deleted rows during index rebuilding and analyzes and optimizes the interleaved sort key column for improved query performance based on AWS Regions and possibly other columns involved in the interleaved index. This is a more targeted approach than VACUUM FULL while also addressing the need to optimize the interleaved sort key, which other options omit.
Authoritative Links:
Amazon Redshift VACUUM command: https://docs.aws.amazon.com/redshift/latest/dg/r_VACUUM.html Working with interleaved sort keys: https://docs.aws.amazon.com/redshift/latest/dg/tutorial-sort-
interleaved.html



A manufacturing company wants to collect data from sensors. A data engineer needs to implement a solution that ingests sensor data in near real time. The solution must store the data to a persistent data store. The solution must store the data in nested JSON format. The company must have the ability to query from the data store with a latency of less than 10 milliseconds.
Which solution will meet these requirements with the LEAST operational overhead?

  1. Use a self-hosted Apache Kafka cluster to capture the sensor data. Store the data in Amazon S3 for querying.
  2. Use AWS Lambda to process the sensor data. Store the data in Amazon S3 for querying.
  3. Use Amazon Kinesis Data Streams to capture the sensor data. Store the data in Amazon DynamoDB for querying.
  4. Use Amazon Simple Queue Service (Amazon SQS) to buffer incoming sensor data. Use AWS Glue to store the data in Amazon RDS for querying.

Answer(s): C

Explanation:

The correct answer is C because it provides the best balance of near real-time ingestion, persistent storage of nested JSON data, low-latency querying, and minimal operational overhead.
Let's analyze why the other options are less suitable:
A: Apache Kafka + Amazon S3: While Kafka is excellent for high-throughput streaming, setting up and managing a self-hosted Kafka cluster introduces significant operational overhead, including managing brokers, zookeepers, and ensuring high availability. S3, being an object store, is not designed for low-latency (sub-10ms) queries. Although services like Athena can query S3 data, the latency would be much higher than 10ms, especially for complex JSON structures. B: AWS Lambda + Amazon S3: Lambda can process data, but it's not a dedicated streaming ingestion service. Using Lambda as a continuous data ingestion mechanism might lead to invocation limits and cold start issues if the data flow is continuous. Again, S3 doesn't provide the required low-latency querying. D: Amazon SQS + AWS Glue + Amazon RDS: SQS acts as a message queue, suitable for buffering, but not optimized for continuous high-velocity streams. AWS Glue is an ETL service used for data preparation and transformation, but not ideal for real-time data ingestion. Relational databases (RDS) can provide low latency but are not inherently suited for storing nested JSON.
While JSON datatypes are supported, querying complex nested structures often requires more complex SQL and doesn't scale as well as a NoSQL database.
Justification for C: Kinesis Data Streams + DynamoDB:
1. Near Real-time Ingestion: Kinesis Data Streams is specifically designed for high-throughput,
continuous data ingestion in near real-time. It can handle sensor data streams efficiently. https://aws.amazon.com/kinesis/data-streams/ 2. Persistent Storage: DynamoDB, a NoSQL database, provides persistent storage and supports storing data in JSON format (including nested structures) natively using its document model. https://aws.amazon.com/dynamodb/ 3. Low-Latency Queries: DynamoDB is a key-value and document database designed for extremely low-latency reads and writes. It can easily meet the requirement of queries with a latency of less than 10 milliseconds, especially if the data model and access patterns are optimized. 4. Least Operational Overhead: Kinesis Data Streams and DynamoDB are fully managed services. AWS
handles scaling, patching, and availability, minimizing the operational overhead for the data engineer.
You don't need to manage servers or infrastructure components as you would with Kafka. 5. Data Format Flexibility: DynamoDB's schema-less nature allows it to easily handle nested JSON
structures. 6. Scalability: Both Kinesis and DynamoDB are highly scalable, allowing the manufacturing company to increase data ingestion and storage without significant architectural changes.
Therefore, Kinesis Data Streams and DynamoDB offer the most suitable solution for the manufacturing company's needs by combining near real-time ingestion, nested JSON storage, low-latency querying, and minimal operational overhead.



A company stores data in a data lake that is in Amazon S3. Some data that the company stores in the data lake contains personally identifiable information (PII). Multiple user groups need to access the raw data. The company must ensure that user groups can access only the PII that they require.
Which solution will meet these requirements with the LEAST effort?

  1. Use Amazon Athena to query the data. Set up AWS Lake Formation and create data filters to establish levels of access for the company's IAM roles. Assign each user to the IAM role that matches the user's PII access requirements.
  2. Use Amazon QuickSight to access the data. Use column-level security features in QuickSight to limit the PII that users can retrieve from Amazon S3 by using Amazon Athena. Define QuickSight access levels based on the PII access requirements of the users.
  3. Build a custom query builder UI that will run Athena queries in the background to access the data. Create user groups in Amazon Cognito. Assign access levels to the user groups based on the PII access requirements of the users.
  4. Create IAM roles that have different levels of granular access. Assign the IAM roles to IAM user groups. Use an identity-based policy to assign access levels to user groups at the column level.

Answer(s): A

Explanation:

The correct answer is A. Here's a detailed justification:
The requirement is to provide different user groups with access to PII data in an S3 data lake, granting them access only to the specific PII they need, while minimizing effort.
Option A utilizes AWS Lake Formation and Athena. Lake Formation provides centralized governance over data lakes, making it easier to define, secure, and manage access to data. By setting up data filters in Lake Formation, you can define row and column-level security policies. These filters are then applied when users query the data using Athena. IAM roles are used to control which users can access the data and which data filters apply to them. This ensures that users only see the data they are authorized to see. This leverages a managed service designed for this purpose, resulting in the least operational overhead.
Option B, using QuickSight, is not ideal. QuickSight's column-level security works on visualizations, not directly on the underlying data source (S3 via Athena). This means the data is still accessible in Athena, and the security is enforced in the QuickSight layer, which could be circumvented.
Option C, building a custom query builder, introduces significant complexity and operational overhead. It requires development, maintenance, and potentially security vulnerabilities introduced through custom code.
While Cognito handles user authentication, it doesn't directly integrate with Athena for fine-grained access control like Lake Formation does.
Option D involves managing granular IAM policies directly, which quickly becomes complex and difficult to maintain, especially with multiple user groups and varying PII access requirements. IAM policies for data access are best managed through a service like Lake Formation for simplification and clarity.
Therefore, using Athena with Lake Formation offers the most efficient and secure solution for managing PII access in a data lake, meeting the requirements with the least amount of effort. Lake Formation simplifies security management by centralizing access policies and integrating seamlessly with Athena.
Supporting links:
AWS Lake Formation: https://aws.amazon.com/lake-formation/ Amazon Athena: https://aws.amazon.com/athena/ AWS IAM: https://aws.amazon.com/iam/



  PDF
Viewing page 18 of 47
Viewing questions 137 - 144 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!