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

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

A company has a frontend ReactJS website that uses Amazon API Gateway to invoke REST APIs. The APIs perform the functionality of the website. A data engineer needs to write a Python script that can be occasionally invoked through API Gateway. The code must return results to API Gateway.
Which solution will meet these requirements with the LEAST operational overhead?

  1. Deploy a custom Python script on an Amazon Elastic Container Service (Amazon ECS) cluster.
  2. Create an AWS Lambda Python function with provisioned concurrency.
  3. Deploy a custom Python script that can integrate with API Gateway on Amazon Elastic Kubernetes Service (Amazon EKS).
  4. Create an AWS Lambda function. Ensure that the function is warm by scheduling an Amazon EventBridge rule to invoke the Lambda function every 5 minutes by using mock events.

Answer(s): B

Explanation:

The most suitable solution with the least operational overhead is
B: Create an AWS Lambda Python function with provisioned concurrency.
Here's why:
AWS Lambda is designed for event-driven, serverless execution. It's perfect for running Python scripts invoked via API Gateway without managing servers or containers. This significantly reduces operational overhead compared to managing ECS or EKS clusters. (Source: https://aws.amazon.com/lambda/ ) Provisioned Concurrency: The requirement states the script is occasionally invoked. By using provisioned concurrency, you ensure that Lambda function instances are pre-initialized and ready to respond to requests, minimizing cold starts and improving latency. (Source: https://aws.amazon.com/lambda/provisioned-concurrency/ )
Direct API Gateway Integration: Lambda has a direct integration with API Gateway, making it simple to invoke Lambda functions as backends for API endpoints. This streamlined integration simplifies the overall architecture. (Source: https://docs.aws.amazon.com/apigateway/latest/developerguide/services-lambda-integration.html ) Option A (ECS) and C (EKS) are overkill: ECS and EKS involve managing container orchestration, which introduces significant operational complexity and cost for a simple occasional script execution. These options are more appropriate for complex applications that require finer-grained control over the execution environment. Option D (Lambda with EventBridge warming) is less efficient: While keeping a Lambda function "warm" through scheduled invocations can reduce cold starts, it is not as efficient or cost-effective as using provisioned concurrency. EventBridge invocations consume resources even when the script is not actively needed. Provisioned concurrency dedicates resources and keeps them ready without unnecessary triggers. Cost Efficiency: Lambda's pay-per-execution model makes it cost-effective for occasional script executions. ECS/EKS require running infrastructure continuously, even when the script is idle. Using Provisioned Concurrency does incur a cost, but it is targetted, manageable, and more efficient than constant EventBridge triggers if minimizing latency is important.
In summary, Lambda with provisioned concurrency provides the best balance of performance, simplicity, and cost-effectiveness for this specific use case. It eliminates the operational burden of managing containers while ensuring responsive execution through pre-initialized function instances.



A company has a production AWS account that runs company workloads. The company's security team created a security AWS account to store and analyze security logs from the production AWS account. The security logs in the production AWS account are stored in Amazon CloudWatch Logs. The company needs to use Amazon Kinesis Data Streams to deliver the security logs to the security AWS account.
Which solution will meet these requirements?

  1. Create a destination data stream in the production AWS account. In the security AWS account, create an IAM role that has cross-account permissions to Kinesis Data Streams in the production AWS account.
  2. Create a destination data stream in the security AWS account. Create an IAM role and a trust policy to grant CloudWatch Logs the permission to put data into the stream. Create a subscription filter in the security AWS account.
  3. Create a destination data stream in the production AWS account. In the production AWS account, create an IAM role that has cross-account permissions to Kinesis Data Streams in the security AWS account.
  4. Create a destination data stream in the security AWS account. Create an IAM role and a trust policy to grant CloudWatch Logs the permission to put data into the stream. Create a subscription filter in the production AWS account.

Answer(s): D

Explanation:

Here's a detailed justification for why option D is the correct solution for streaming CloudWatch Logs from a production AWS account to Kinesis Data Streams in a security AWS account, along with supporting concepts and links:
The core requirement is to get security logs from CloudWatch Logs (in the production account) into Kinesis Data Streams (in the security account). CloudWatch Logs subscription filters are the primary mechanism for streaming log data to other AWS services. For cross-account delivery, a specific configuration is necessary involving IAM roles and trust policies.
Option D correctly places the Kinesis Data Stream in the security account, which aligns with the goal of storing and analyzing security logs in that account. It also correctly identifies the need for an IAM role in the security account that CloudWatch Logs assumes. The IAM role's trust policy is crucial; it explicitly grants CloudWatch Logs (running in the production account) permission to assume the role. This trust relationship is fundamental for cross-account access. The subscription filter is created in the production account, where the logs originate. This filter, when configured correctly, will invoke the IAM role and deliver the logs to the Kinesis Data Stream in the security account.
Option A is incorrect because the destination data stream should reside in the security account, not the production account.
Option B is incorrect because the subscription filter must be created in the production account to access the CloudWatch logs in the production account.
Option C is incorrect because the IAM role needs to be created in the security account and assumed by the CloudWatch logs service in the production account.
In summary, option D sets up the necessary cross-account IAM permissions and configures the CloudWatch Logs subscription filter correctly to achieve the desired data flow.
Relevant links for further research:
CloudWatch Logs Subscription Filters: https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/Subscriptions.html Cross-Account Access with IAM Roles: https://docs.aws.amazon.com/IAM/latest/UserGuide/tutorial_cross-account-with-roles.html Kinesis Data Streams: https://aws.amazon.com/kinesis/data-streams/



A company uses Amazon S3 to store semi-structured data in a transactional data lake. Some of the data files are small, but other data files are tens of terabytes. A data engineer must perform a change data capture (CDC) operation to identify changed data from the data source. The data source sends a full snapshot as a JSON file every day and ingests the changed data into the data lake.
Which solution will capture the changed data MOST cost-effectively?

  1. Create an AWS Lambda function to identify the changes between the previous data and the current data. Configure the Lambda function to ingest the changes into the data lake.
  2. Ingest the data into Amazon RDS for MySQL. Use AWS Database Migration Service (AWS DMS) to write the changed data to the data lake.
  3. Use an open source data lake format to merge the data source with the S3 data lake to insert the new data and update the existing data.
  4. Ingest the data into an Amazon Aurora MySQL DB instance that runs Aurora Serverless. Use AWS Database Migration Service (AWS DMS) to write the changed data to the data lake.

Answer(s): C

Explanation:

The correct answer is C because it offers the most cost-effective and efficient solution for CDC in a data lake environment compared to the other options.
Option A is not ideal.
While Lambda can compare data, processing large (tens of terabytes) JSON files daily using Lambda would be computationally expensive and likely exceed Lambda's execution time limits.
Moreover, managing state and handling potential errors during a full scan comparison becomes complex.
Options B and D are less efficient and unnecessarily involve relational databases. Ingesting full snapshots into RDS or Aurora solely for CDC introduces significant overhead. Setting up and maintaining database instances and DMS adds to the operational complexity and cost. Furthermore, the JSON format isn't naturally suited to relational database structures, requiring transformations that further increase processing time and cost. DMS, while good for database migrations, is overkill for this CDC use case where the source is simply a snapshot file.
Option C leverages open-source data lake formats like Apache Iceberg, Delta Lake, or Apache Hudi. These formats provide built-in support for ACID transactions, schema evolution, and efficient merging of data. They allow for direct processing of data in S3 without the need for intermediate databases. The merge operation updates existing data and inserts new data based on keys, efficiently identifying and applying changes from the daily snapshots. This is the most scalable and cost-effective approach since the data lake format handles the CDC logic directly within the storage layer, using S3 as the processing engine. Services like AWS Glue (with Spark) can be used to perform these merge operations, optimized for data lake workloads. This solution eliminates the need for a database for transient data storage, reducing cost and complexity.
Further Research:
Apache Iceberg: https://iceberg.apache.org/ Delta Lake: https://delta.io/ Apache Hudi: https://hudi.apache.org/ AWS Glue: https://aws.amazon.com/glue/



A data engineer runs Amazon Athena queries on data that is in an Amazon S3 bucket. The Athena queries use AWS Glue Data Catalog as a metadata table. The data engineer notices that the Athena query plans are experiencing a performance bottleneck. The data engineer determines that the cause of the performance bottleneck is the large number of partitions that are in the S3 bucket. The data engineer must resolve the performance bottleneck and reduce Athena query planning time.
Which solutions will meet these requirements? (Choose two.)

  1. Create an AWS Glue partition index. Enable partition filtering.
  2. Bucket the data based on a column that the data have in common in a WHERE clause of the user query.
  3. Use Athena partition projection based on the S3 bucket prefix.
  4. Transform the data that is in the S3 bucket to Apache Parquet format.
  5. Use the Amazon EMR S3DistCP utility to combine smaller objects in the S3 bucket into larger objects.

Answer(s): A,C

Explanation:

The problem is slow Athena query planning time due to a large number of partitions in S3 and the corresponding metadata in the Glue Data Catalog. This significantly increases the time Athena takes to identify and select the relevant partitions for a query.
Option A: Create an AWS Glue partition index. Enable partition filtering. is a correct solution. Glue partition indexes are designed to speed up partition discovery in Athena. By creating an index, Athena can quickly locate the partitions that match the query's filter criteria, drastically reducing planning time. Partition filtering helps to apply the filter conditions early in the query planning process, further minimizing the number of partitions that Athena needs to consider. https://docs.aws.amazon.com/glue/latest/dg/partition-indexes.html
Option C: Use Athena partition projection based on the S3 bucket prefix. is also a valid solution. Partition projection allows Athena to infer partition values directly from the S3 bucket structure, eliminating the need to store partition metadata in the Glue Data Catalog. If the partitions are organized in S3 in a predictable manner (e.g., s3://bucket/year=2023/month=12/ ), Athena can dynamically determine the partitions based on the bucket paths. This avoids reading a potentially large partition list from the Glue Data Catalog, significantly improving planning time. https://docs.aws.amazon.com/athena/latest/ug/partition-projection.html
Option B is relevant to query performance, but doesn't directly address query planning time. Bucketing improves data locality and helps Athena read only the necessary data during query execution, not during planning.
Option D, while beneficial for query performance due to Parquet's columnar storage and compression, doesn't solve the partition discovery problem directly. It addresses data retrieval efficiency, not the initial planning bottleneck caused by the large number of partitions.
Option E focuses on optimizing the size of individual S3 objects, which might indirectly improve performance by reducing the number of files Athena needs to access. However, it does not directly reduce the number of partitions or the overhead associated with Glue Data Catalog lookups during query planning. It's more about optimizing data storage rather than metadata management.



A data engineer must manage the ingestion of real-time streaming data into AWS. The data engineer wants to perform real-time analytics on the incoming streaming data by using time-based aggregations over a window of up to 30 minutes. The data engineer needs a solution that is highly fault tolerant.
Which solution will meet these requirements with the LEAST operational overhead?

  1. Use an AWS Lambda function that includes both the business and the analytics logic to perform time-based aggregations over a window of up to 30 minutes for the data in Amazon Kinesis Data Streams.
  2. Use Amazon Managed Service for Apache Flink (previously known as Amazon Kinesis Data Analytics) to analyze the data that might occasionally contain duplicates by using multiple types of aggregations.
  3. Use an AWS Lambda function that includes both the business and the analytics logic to perform aggregations for a tumbling window of up to 30 minutes, based on the event timestamp.
  4. Use Amazon Managed Service for Apache Flink (previously known as Amazon Kinesis Data Analytics) to analyze the data by using multiple types of aggregations to perform time-based analytics over a window of up to 30 minutes.

Answer(s): D

Explanation:

The correct answer is D because Amazon Managed Service for Apache Flink is specifically designed for real-time analytics on streaming data with minimal operational overhead. It provides built-in support for time-based windowing aggregations, allowing the data engineer to perform analytics over a 30-minute window. Flink handles fault tolerance automatically through checkpointing and state management, ensuring data consistency and availability even in the event of failures.
Option A and C involve using AWS Lambda, which while capable of processing streaming data, would require the data engineer to implement and manage the time-based aggregation logic and fault tolerance mechanisms manually. This significantly increases operational overhead. Lambda functions are also typically better suited for shorter processing times and might not be as efficient or cost-effective for continuous, long-running aggregations over 30-minute windows. Furthermore, Lambda doesn't inherently provide the fault tolerance required without additional complex configuration.
Option B mentions the possibility of duplicate data. Flink handles duplicates through exactly-once processing capabilities, ensuring accurate aggregation results.
While the question doesn't explicitly state there are duplicates, choosing Flink provides robustness.
In summary, Flink's native support for windowed aggregations, fault tolerance, and exactly-once processing makes it the most suitable solution for real-time analytics on streaming data with minimal operational overhead. It simplifies the development and deployment process, allowing the data engineer to focus on the analytics logic rather than infrastructure management.
Relevant documentation:
Amazon Managed Service for Apache Flink: https://aws.amazon.com/flink/ Flink Windowing: https://nightlies.apache.org/flink/flink-docs-stable/docs/dev/datastream/operators/windows/ Flink Fault Tolerance: https://nightlies.apache.org/flink/flink-docs-stable/docs/learn-flink/fault_tolerance/



A company is planning to upgrade its Amazon Elastic Block Store (Amazon EBS) General Purpose SSD storage from gp2 to gp3. The company wants to prevent any interruptions in its Amazon EC2 instances that will cause data loss during the migration to the upgraded storage.
Which solution will meet these requirements with the LEAST operational overhead?

  1. Create snapshots of the gp2 volumes. Create new gp3 volumes from the snapshots. Attach the new gp3 volumes to the EC2 instances.
  2. Create new gp3 volumes. Gradually transfer the data to the new gp3 volumes.
    When the transfer is complete, mount the new gp3 volumes to the EC2 instances to replace the gp2 volumes.
  3. Change the volume type of the existing gp2 volumes to gp3. Enter new values for volume size, IOPS, and throughput.
  4. Use AWS DataSync to create new gp3 volumes. Transfer the data from the original gp2 volumes to the new gp3 volumes.

Answer(s): C

Explanation:

Here's a detailed justification for why option C is the best solution for upgrading from gp2 to gp3 EBS volumes with minimal downtime and operational overhead:
The core requirement is to upgrade from gp2 to gp3 without interrupting the EC2 instances and causing data loss, all while minimizing operational overhead.
Option C, "Change the volume type of the existing gp2 volumes to gp3. Enter new values for volume size, IOPS, and throughput," is the most efficient approach. EBS volume type modification is an in-place upgrade. You directly modify the existing gp2 volume to become a gp3 volume. This avoids the need to create new volumes, copy data, and remount them, which inherently introduce downtime.
AWS EBS supports modifying the volume type on the fly without detaching the volume or stopping the instance. You can change the volume type, size, IOPS, and throughput using the AWS Management Console, AWS CLI, or AWS SDKs.
Options A, B, and D all involve creating new volumes and transferring data. Option A uses snapshots which will necessitate stopping the instance to ensure data consistency. Option B, gradually transfer data means application-level or OS level data sync tool is needed, which adds complexity and potential risk. Option D
introduces AWS DataSync, which is powerful but overkill for a simple EBS volume upgrade within the same availability zone. DataSync is suitable when migrating data across regions or between on-premises and AWS.
Changing the volume type in place (Option C) is significantly faster and less disruptive than creating new volumes and copying data. Furthermore, it requires the least amount of manual intervention and monitoring. This makes it the solution with the LEAST operational overhead while satisfying the critical requirement of preventing data loss and minimizing interruptions.
Therefore, option C is the best solution because it directly addresses the requirement with the lowest operational overhead and minimal downtime.
Relevant AWS documentation:
Modifying EBS Volumes: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-modify-volume.html EBS Volume Types: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-volume-types.html



A company is migrating its database servers from Amazon EC2 instances that run Microsoft SQL Server to Amazon RDS for Microsoft SQL Server DB instances. The company's analytics team must export large data elements every day until the migration is complete. The data elements are the result of SQL joins across multiple tables. The data must be in Apache Parquet format. The analytics team must store the data in Amazon S3.
Which solution will meet these requirements in the MOST operationally efficient way?

  1. Create a view in the EC2 instance-based SQL Server databases that contains the required data elements. Create an AWS Glue job that selects the data directly from the view and transfers the data in Parquet format to an S3 bucket. Schedule the AWS Glue job to run every day.
  2. Schedule SQL Server Agent to run a daily SQL query that selects the desired data elements from the EC2 instance-based SQL Server databases. Configure the query to direct the output .csv objects to an S3 bucket. Create an S3 event that invokes an AWS Lambda function to transform the output format from .csv to Parquet.
  3. Use a SQL query to create a view in the EC2 instance-based SQL Server databases that contains the required data elements. Create and run an AWS Glue crawler to read the view. Create an AWS Glue job that retrieves the data and transfers the data in Parquet format to an S3 bucket. Schedule the AWS Glue job to run every day.
  4. Create an AWS Lambda function that queries the EC2 instance-based databases by using Java Database Connectivity (JDBC). Configure the Lambda function to retrieve the required data, transform the data into Parquet format, and transfer the data into an S3 bucket. Use Amazon EventBridge to schedule the Lambda function to run every day.

Answer(s): C

Explanation:

The best solution for exporting large SQL Server data elements, transforming them to Parquet format, and storing them in S3 with operational efficiency is option C.
Here's why:
AWS Glue is purpose-built for ETL: Glue is specifically designed for Extract, Transform, and Load (ETL) operations. It simplifies the process of data extraction from various sources, transformation, and loading into data stores like S3.
Views simplify data selection: Creating a view in the SQL Server databases allows the Glue job to query a simplified, pre-defined dataset containing the joined data elements, rather than complex SQL joins within the Glue job itself. This improves maintainability and reduces the load on the SQL Server databases.
Glue Crawler for Schema Discovery: A Glue crawler can automatically infer the schema of the view. This reduces the manual effort involved in defining the data schema within the Glue job.
Parquet Conversion in Glue: Glue has built-in support for converting data into Parquet format, which is a columnar storage format optimized for analytical workloads.
Scheduled Glue Jobs for Automation: Scheduling the Glue job automates the daily export and transformation process.
Here's why other options are less optimal:
Option A: While similar, it skips the crawler and assumes you know the schema. In a dynamic environment, a crawler is best practice to ensure schema changes are reflected automatically.
Option B: Using SQL Server Agent to export to CSV and then transforming it with Lambda is less efficient and more complex than using Glue for the entire process. CSV is not an efficient format for large data volumes. Transforming CSV to Parquet via Lambda adds operational overhead.
Option D: Using Lambda with JDBC for large data transfers from SQL Server is not recommended due to potential performance bottlenecks and scaling limitations of Lambda functions. It also increases complexity compared to using AWS Glue. Also Lambda might timeout since its execution is limited to 15 minutes.
Therefore, Option C provides the most operationally efficient and scalable approach for the given requirements by leveraging the capabilities of AWS Glue for ETL and Parquet conversion, with the added benefit of automated schema discovery using Glue crawlers.
Relevant Links:
AWS Glue Documentation Apache Parquet AWS Glue Crawlers



A data engineering team is using an Amazon Redshift data warehouse for operational reporting. The team wants to prevent performance issues that might result from long- running queries. A data engineer must choose a system table in Amazon Redshift to record anomalies when a query optimizer identifies conditions that might indicate performance issues.
Which table views should the data engineer use to meet this requirement?

  1. STL_USAGE_CONTROL
  2. STL_ALERT_EVENT_LOG
  3. STL_QUERY_METRICS
  4. STL_PLAN_INFO

Answer(s): B

Explanation:

The correct answer is B: STL_ALERT_EVENT_LOG. This system table is specifically designed to capture alerts generated by the Amazon Redshift query optimizer when it detects conditions that could lead to performance problems. These alerts flag potential issues, such as missing statistics, suboptimal join orders, or the use of uncompressed data. By monitoring STL_ALERT_EVENT_LOG, the data engineering team can proactively identify and address these issues, preventing long-running queries and maintaining the overall performance of the Amazon Redshift data warehouse.
STL_USAGE_CONTROL (option A) is used for managing concurrency scaling usage and is not related to query performance anomalies. STL_QUERY_METRICS (option C) provides detailed performance metrics about executed queries but doesn't specifically highlight potential issues identified by the optimizer before or during query execution. STL_PLAN_INFO (option D) contains information about the query plan, but it does not directly provide alerts or anomaly detection information based on the optimizer's assessment. Therefore, STL_ALERT_EVENT_LOG is the most appropriate table for identifying query optimizer alerts that indicate potential performance issues in Amazon Redshift.
Amazon Redshift System Tables Reference



  PDF
Viewing page 6 of 47
Viewing questions 41 - 48 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!