Skip to content

Skill 1.1.1: Extract data from data sources - Practice Questions

Question 1 - Bedrock Knowledge Base Ingestion with KMS Encryption

A financial services company is building a regulatory document search system using Amazon Bedrock Knowledge Bases and Amazon OpenSearch Serverless. The compliance team requires that all vector embeddings be stored at rest with a customer-managed key (CMK) from AWS KMS, and the engineering team must minimize ongoing maintenance of the ingestion pipeline.

Which TWO actions should the ML engineer take to meet these requirements? (Select TWO)

  • A) Create an encryption policy in OpenSearch Serverless that references the KMS CMK ARN, then create the vector collection referencing that policy.
  • B) After the vector collection is created, attach a KMS CMK policy to the collection using the OpenSearch Serverless UpdateCollection API.
  • C) Configure a Bedrock Knowledge Base data source pointing to the S3 bucket containing PDFs and call StartIngestionJob to parse, embed, and index documents.
  • D) Deploy an AWS Glue job that converts PDFs to text, invokes Amazon Titan Embeddings via Lambda, and writes vectors to OpenSearch using boto3.
  • E) Store the OpenSearch Serverless vector index in Amazon RDS with TDE encryption to satisfy the CMK requirement.
Click to reveal Answer & Explanation

Correct Answers: A and C

Correct Options Analysis

  • A is Correct: OpenSearch Serverless encryption policies must be created before the collection itself. Defining the KMS CMK ARN in the encryption policy ensures the vector index is encrypted at rest with the customer-managed key, satisfying compliance requirements.
  • C is Correct: Amazon Bedrock Knowledge Bases natively handles the full ingestion workflow—document parsing, semantic chunking, embedding generation using a selected model (e.g., Amazon Titan), and indexing into the connected OpenSearch Serverless vector collection—without requiring custom pipeline code.

Distractor Analysis

  • B is Incorrect: Encryption policies in OpenSearch Serverless cannot be modified after collection creation. The encryption configuration must be specified in a security policy prior to creating the collection, making post-creation updates infeasible.
  • D is Incorrect: Deploying a custom Glue + Lambda pipeline introduces significant operational overhead (job scheduling, error handling, scaling, monitoring) compared to Bedrock's fully managed ingestion job. The requirement explicitly states minimizing maintenance.
  • E is Incorrect: Amazon RDS is a relational database service, not a vector database. Vector storage for Bedrock Knowledge Bases requires OpenSearch Serverless (or other supported vector databases like Pinecone or Amazon Aurora PostgreSQL with pgvector), and RDS TDE is unrelated to OpenSearch Serverless.

Key Takeaway: Bedrock Knowledge Bases eliminates custom ETL compute for RAG ingestion, and OpenSearch Serverless requires encryption policies configured before collection creation.

Question 2 - Choosing Ingestion Method for Streaming Semi-Structured Data

An e-commerce company streams clickstream analytics data through Amazon Kinesis Data Streams into an ML feature store for real-time recommendation inference. The schema evolves frequently as new features are added, and the team needs to transform incoming JSON records into Apache Parquet format for downstream training jobs in Amazon SageMaker. Operational overhead must be minimized, and the pipeline must be serverless.

Which solution should the ML engineer implement? (Select ONE)

  • A) Use AWS Glue Streaming ETL with a visual job that reads from Kinesis, applies transforms, and outputs Parquet to S3.
  • B) Deploy a self-managed Apache Flink cluster on EC2 instances to consume Kinesis streams and convert records to Parquet.
  • C) Configure a Kinesis Data Firehose delivery stream to ingest from the Kinesis Data Stream and convert records to Parquet using the built-in format conversion feature.
  • D) Schedule an AWS Glue Python Shell job every 5 minutes to batch-read Kinesis records and write Parquet files to S3.
  • E) Use an Amazon EMR cluster running Apache Spark Structured Streaming to continuously read from Kinesis and write Parquet to S3.
Click to reveal Answer & Explanation

Correct Answer: C

Correct Options Analysis

  • C is Correct: Kinesis Data Firehose natively supports format conversion (JSON to Parquet/ORC via AWS Glue Data Catalog schema references) as a fully managed, serverless feature. Configuring a Firehose delivery stream to consume from the Kinesis Data Stream and enabling format conversion to Parquet requires zero infrastructure management and is serverless by design.

Distractor Analysis

  • A is Incorrect: While AWS Glue Streaming ETL is serverless and capable, it introduces ongoing ETL job management overhead (job scheduling, monitoring, troubleshooting) compared to Firehose's built-in format conversion, which is configuration-only.
  • B is Incorrect: Self-managed Flink on EC2 requires provisioning, patching, scaling, and cluster maintenance—substantial operational overhead that violates the serverless requirement.
  • D is Incorrect: Batch-reading from a real-time Kinesis stream every 5 minutes abandons the real-time nature of the ingestion and adds latency. Kinesis is designed for continuous consumers, not batch polling.
  • E is Incorrect: Amazon EMR with Spark Structured Streaming provides powerful streaming capabilities but requires cluster provisioning and lifecycle management, introducing unnecessary operational complexity for this use case.

Key Takeaway: Kinesis Data Firehose format conversion provides a serverless, zero-code path to transform streaming JSON into Parquet without managing any compute.

Question 3 - Extracting Data from On-Premises Oracle for SageMaker Training

A healthcare analytics team needs to extract patient records from an on-premises Oracle database into Amazon S3 on an ongoing weekly basis for SageMaker training jobs. Network connectivity between on-premises and AWS is established via AWS Direct Connect. The team wants to incrementally capture only changed rows since the previous extraction and minimize infrastructure management.

Which solution should the ML engineer implement? (Select ONE)

  • A) Install the AWS Schema Conversion Tool (SCT) on the on-premises Oracle server, configure ongoing replication to S3, and schedule weekly snapshots.
  • B) Use AWS Database Migration Service (DMS) with an ongoing replication task using change data capture (CDC) from Oracle to an S3 target.
  • C) Write a custom Oracle PL/SQL procedure to export changed rows as CSV files and use AWS DataSync to transfer them to S3 via Direct Connect.
  • D) Deploy an AWS Glue Elastic view that connects directly to the on-premises Oracle database and queries incremental changes via JDBC.
  • E) Use an AWS Lambda function that schedules weekly SSH connections to the Oracle server, executes SQL queries, and uploads results to S3.
Click to reveal Answer & Explanation

Correct Answer: B

Correct Options Analysis

  • B is Correct: AWS Database Migration Service (DMS) supports ongoing replication with Change Data Capture (CDC) from supported on-premises databases (including Oracle) to S3 targets. DMS reads transaction logs to identify changed rows, applies incremental changes, and writes to S3 in formats like CSV or Parquet. It is managed by AWS and works over Direct Connect.

Distractor Analysis

  • A is Incorrect: AWS Schema Conversion Tool (SCT) primarily converts database schemas for heterogeneous migrations (e.g., Oracle to PostgreSQL). It does not provide ongoing replication mechanisms for S3 extraction.
  • C is Incorrect: Custom PL/SQL procedures and DataSync add unnecessary operational overhead. DataSync is designed for file-level transfer, not database row-level incremental extraction. This requires custom maintenance of change-tracking logic.
  • D is Incorrect: AWS Glue Elastic views are a feature of Glue Data Catalog that provides a virtual view for querying across data stores, but it does not directly support on-premises Oracle connectivity without additional networking components (like Glue connections), and it does not persist incremental changes to S3 as files.
  • E is Incorrect: Using Lambda to SSH and run queries weekly introduces the complexity of managing SSH credentials, network routing through Direct Connect, and custom code for change tracking. Lambda's 15-minute maximum timeout may also be insufficient.

Key Takeaway: AWS DMS with CDC is the managed, low-overhead solution for ongoing incremental replication from on-premises databases to S3.

Question 4 - Consolidating Feature Extraction Across Multiple Sources

A retail ML team is building a customer churn prediction model that requires joining customer profile data from Amazon RDS for PostgreSQL, transaction history from Amazon Redshift, and web activity logs from Amazon S3 (JSON format). The team needs a consolidated, queryable dataset for feature engineering in SageMaker Data Wrangler. The pipeline should be serverless and minimize data movement duplication.

Which solution should the ML engineer use? (Select ONE)

  • A) Use Amazon Athena federated queries to query Postgres and Redshift as external sources and perform SQL joins in an Athena query saved as a view.
  • B) Export data from RDS and Redshift to S3 daily using Data Pipeline, then run a Glue job to join all three sources into a consolidated S3 dataset.
  • C) Use AWS Glue Studio to create an ETL job with connectors for PostgreSQL and Redshift, join with S3 data, and write the result to a Glue Data Catalog table.
  • D) Ingest all three sources into an Amazon OpenSearch Service cluster using Logstash plugins, then query the cluster for feature engineering.
  • E) Build a custom scheduler on EC2 that runs Python scripts using pandas and SQLAlchemy to pull data from all sources and write a consolidated CSV to S3.
Click to reveal Answer & Explanation

Correct Answer: C

Correct Options Analysis

  • C is Correct: AWS Glue ETL natively supports connectors for JDBC sources (PostgreSQL) and Amazon Redshift via Spark, and can join these with S3 data (JSON) in a single serverless job. The output written to the Glue Data Catalog becomes immediately queryable by SageMaker Data Wrangler, avoiding manual data movement orchestration.

Distractor Analysis

  • A is Incorrect: While Athena federated queries can query RDS and Redshift without moving data first, creating a consolidated view for Data Wrangler would still require an exported result set. Federated queries also incur connectivity configuration overhead and may perform poorly for large joins.
  • B is Incorrect: This multi-step approach (Data Pipeline exports + Glue job) introduces unnecessary orchestration and multiple copies of data. A single Glue job is simpler and the requirement asks for minimized duplication.
  • D is Incorrect: OpenSearch Service is a search and analytics engine, not an ETL or data warehousing solution. Using Logstash for three heterogeneous sources adds significant operational overhead and is not designed for relational joins across structured data.
  • E is Incorrect: A custom EC2 scheduler with Python scripts introduces substantial operational burden (instance management, cron scheduling, error handling, scaling) and violates the serverless requirement.

Key Takeaway: AWS Glue Studio with native connectors provides the lowest-operational-overhead path for joining multiple structured and semi-structured sources into a consolidated catalog table for SageMaker.

Question 5 - Real-Time Streaming Data Format for ML Inference

A logistics company processes IoT sensor data from a fleet of vehicles through Amazon Kinesis for real-time anomaly detection using a SageMaker real-time endpoint. Each vehicle emits JSON telemetry (location, speed, engine diagnostics) at 5-second intervals. The ML team wants the data available for immediate inference, but also needs it persisted for historical model retraining. The solution should be serverless and cost-efficient.

Which architecture should the ML engineer recommend? (Select ONE)

  • A) Send directly from IoT Core to a SageMaker endpoint for inference, then use a Kinesis Data Firehose with dynamic partitioning to persist raw data to S3.
  • B) Ingest into Kinesis Data Streams, use a Lambda consumer for real-time inference, and a Firehose delivery stream as a second consumer to persist to S3.
  • C) Ingest into Kinesis Data Streams, use a Firehose delivery stream with a Lambda transform to call the endpoint and persist both raw data and predictions to S3.
  • D) Send all data to S3 via IoT Core file upload, trigger a Lambda function on object creation to call the SageMaker endpoint, then use Athena for historical queries.
  • E) Ingest into Kinesis Data Analytics for Flink that writes directly to a SageMaker Feature Store online store, bypassing the need for a separate endpoint.
Click to reveal Answer & Explanation

Correct Answer: B

Correct Options Analysis

  • B is Correct: Kinesis Data Streams supports multiple consumers from the same stream. A Lambda consumer provides real-time inference by invoking the SageMaker endpoint, while a Firehose delivery stream (configured as another consumer) persists the raw telemetry to S3 for future retraining. This architecture is fully serverless, decoupled, and cost-efficient since both consumers read from one stream.

Distractor Analysis

  • A is Incorrect: Sending directly from IoT Core to a SageMaker endpoint couples ingestion and inference without buffering. If the endpoint is briefly unavailable or throttles, IoT messages could be lost. Firehose dynamic partitioning is useful but doesn't provide the stream-level decoupling needed for real-time consumption.
  • C is Incorrect: Using a Firehose Lambda transform to call the inference endpoint means the write to S3 waits for inference to complete, introducing latency into the persistence path and coupling inference performance with ingestion reliability.
  • D is Incorrect: File upload to S3 with object-creation triggers introduces unnecessary latency (file batching before upload) and abandons real-time stream processing for a batch-oriented pattern, which is unsuitable for real-time anomaly detection.
  • E is Incorrect: Kinesis Data Analytics for Flink is powerful but introduces significant operational overhead for this use case (job provisioning, scaling, state management). A simple Lambda consumer is more cost-efficient and serverless here.

Key Takeaway: Kinesis Data Streams supports multiple simultaneous consumers, allowing one stream to feed both real-time inference (Lambda) and persistence (Firehose) without duplicating ingestion.

Question 6 - Extracting Unstructured Text from S3 for Fine-Tuning

A legal tech company stores millions of scanned legal documents as PDF images (scanned) in Amazon S3 and wants to fine-tune a custom foundation model in Amazon Bedrock using the text contained in these documents. The pipeline must extract text accurately, respect the document hierarchy (headers, sections), and avoid building and maintaining custom OCR infrastructure.

Which solution should the ML engineer implement? (Select ONE)

  • A) Use Amazon Textract to process the PDF images, extracting text and layout information, then store the structured output in S3 for fine-tuning data preparation.
  • B) Use Amazon Rekognition to detect text in the scanned images and assemble the detected text lines into documents.
  • C) Deploy Tesseract OCR on a fleet of EC2 instances, process the PDFs in parallel using an SQS queue, and store extracted text to S3.
  • D) Use SageMaker Processing job with a custom Docker container running OCR libraries to batch-process the scanned PDFs into text files.
  • E) Convert the scanned PDFs to audio using Amazon Polly, then use Amazon Transcribe to generate text transcripts for training.
Click to reveal Answer & Explanation

Correct Answer: A

Correct Options Analysis

  • A is Correct: Amazon Textract is specifically designed for extracting text, forms, and table data from scanned documents. It preserves layout and hierarchy (blocks, lines, relationships) and is a fully managed service, eliminating OCR infrastructure management. The structured output is ideal for preparing fine-tuning datasets.

Distractor Analysis

  • B is Incorrect: Amazon Rekognition's text detection feature is designed for detecting and extracting text from images and videos (e.g., street signs, captions), not for high-accuracy document OCR with layout preservation. Textract is the purpose-built service for document text extraction.
  • C is Incorrect: Deploying and managing Tesseract OCR on EC2 instances requires significant operational overhead (patching, scaling, queue management, error handling) and violates the constraint of avoiding custom OCR infrastructure.
  • D is Incorrect: While SageMaker Processing is managed by AWS, building a custom Docker container with OCR libraries still requires maintaining the OCR software, debugging accuracy issues, and tuning. Textract is a simpler, fully managed alternative.
  • E is Incorrect: Converting documents to audio via Polly and then transcribing via Transcribe is nonsensical for extracting text from documents. Both services are speech-focused and would result in poor accuracy and wasted cost.

Key Takeaway: Amazon Textract is the managed AWS service for high-accuracy text extraction from scanned documents with layout preservation, eliminating the need for custom OCR infrastructure.

Question 7 - Ingesting Time-Series Data for SageMaker Feature Store

A manufacturing plant collects sensor measurements (temperature, pressure, vibration) from 10,000 machines every minute into AWS IoT Core. The downstream ML pipeline needs to store these measurements in SageMaker Feature Store for both online (real-time anomaly detection) and offline (training) use cases. The solution should minimize operational overhead and ensure exactly-once processing semantics.

Which solution should the ML engineer implement? (Select ONE)

  • A) Configure IoT Core rules to send messages directly to a SageMaker Feature Store endpoint using a Lambda function that calls PutRecord for online storage.
  • B) Ingest data into Kinesis Data Streams, use a Kinesis Data Analytics for Flink application to deduplicate and write to Feature Store online, with a Firehose delivery stream to S3 for offline ingestion.
  • C) Use Kinesis Data Firehose to batch IoT messages into S3, then use a scheduled Glue job every hour to run PutRecord batch operations into Feature Store.
  • D) Deploy a custom Kubernetes cluster on EKS running Kafka Connect with the SageMaker Feature Store connector to stream data with exactly-once guarantees.
  • E) Use Amazon Managed Streaming for Apache Kafka (MSK) to buffer IoT messages, then run a Lambda consumer that performs deduplication before writing to Feature Store.
Click to reveal Answer & Explanation

Correct Answer: B

Correct Options Analysis

  • B is Correct: Kinesis Data Streams provides durable ingestion from IoT Core. Kinesis Data Analytics for Flink is a managed service that supports exactly-once processing semantics via checkpointing and can deduplicate messages before writing to the Feature Store online store. A Firehose delivery stream from Kinesis Data Streams persists all data to S3 for offline training ingestion. This approach is managed, serverless, and ensures reliable processing.

Distractor Analysis

  • A is Incorrect: A simple Lambda function writing to Feature Store does not guarantee exactly-once processing—Lambda consumers may retry on failures, causing duplicate writes. The scenario requires exactly-once semantics.
  • C is Incorrect: Hourly batch processing introduces significant latency (up to an hour) and misses the real-time online storage requirement for anomaly detection.
  • D is Incorrect: Deploying and managing a custom Kubernetes cluster on EKS with Kafka Connect introduces massive operational overhead (cluster management, scaling, patching, connector configuration) and violates the minimize-operations constraint.
  • E is Incorrect: Amazon MSK is fully managed but still requires cluster configuration and maintenance. Lambda consumers from Kafka do not guarantee exactly-once processing without complex deduplication logic. Kinesis Data Analytics for Flink provides built-in exactly-once semantics via checkpoints.

Key Takeaway: Kinesis Data Analytics for Flink provides managed, exactly-once stream processing for writing to SageMaker Feature Store, while Firehose handles offline persistence to S3.

Question 8 - Optimizing Cost for Infrequent ML Ingestion

A small startup ingests quarterly marketing data from Salesforce into S3 for training a churn prediction model in SageMaker. The data volume is ~10 GB per quarter, and the team needs to refresh the training dataset within 24 hours of the quarter-end data being available in Salesforce. There is no dedicated data engineering team, and the solution should be cost-optimal.

Which solution should the ML engineer implement? (Select ONE)

  • A) Use AWS AppFlow with a scheduled flow that runs weekly and incrementally syncs changed Salesforce records to S3.
  • B) Deploy a Glue ETL job with a Salesforce connector that runs on-demand when triggered by a scheduled EventBridge rule.
  • C) Use AWS AppFlow with an on-demand flow that is triggered manually by the ML engineer each quarter.
  • D) Set up a self-managed Apache Airflow on EC2 with the Salesforce provider to schedule quarterly data extraction into S3.
  • E) Use Amazon Kinesis Data Firehose with a custom connector to continuously stream Salesforce events to S3.
Click to reveal Answer & Explanation

Correct Answer: A

Correct Options Analysis

  • A is Correct: AWS AppFlow is a fully managed integration service designed for SaaS-to-AWS data flows (including Salesforce). A scheduled flow with incremental sync (using Salesforce change tracking) minimizes data transfer costs, is serverless with no infrastructure to manage, and aligns with the no-dedicated-engineering-team constraint. Weekly incremental syncs ensure data is fresh within 24 hours.

Distractor Analysis

  • B is Incorrect: AWS Glue ETL with a Salesforce connector requires Glue job management, JDBC connection configuration, and introduces overhead that AppFlow eliminates. Glue also doesn't natively support Salesforce without additional connectors.
  • C is Incorrect: An on-demand flow triggered manually is feasible but violates the "within 24 hours" freshness requirement if the ML engineer forgets or is unavailable. Scheduling removes the human dependency.
  • D is Incorrect: Self-managed Apache Airflow on EC2 introduces persistent infrastructure costs (EC2 instance running continuously), maintenance overhead (upgrades, patching, DAG management), and is overengineered for a quarterly 10 GB ingestion.
  • E is Incorrect: Salesforce does not natively emit a continuous event stream for all record types. Kinesis Data Firehose is designed for high-throughput streaming ingestion, not infrequent bulk data extraction from SaaS applications. This architecture is misaligned with the use case.

Key Takeaway: AWS AppFlow is the managed, serverless service for scheduled or on-demand data extraction from SaaS sources like Salesforce into S3, with incremental sync to minimize costs.

Question 9 - Choosing Between Batch and Streaming for Feature Computation

An insurance company needs to compute policyholder risk scores for 50 million policies every morning before business hours (9 AM) to support same-day underwriting decisions. Each risk score requires aggregating the policyholder's historical claims data from Amazon Redshift and their recent web interaction logs from Amazon S3 (Parquet), then running a compute-intensive feature pipeline. The pipeline runs daily and results are stored in SageMaker Feature Store for online serving during business hours.

Which solution should the ML engineer implement for computing and ingesting these features? (Select ONE)

  • A) Use a SageMaker Processing job with a large instance type scheduled by EventBridge to run at 2 AM daily, computing features from Redshift and S3 and writing to Feature Store.
  • B) Set up a real-time feature pipeline using Kinesis and Lambda to continuously compute risk scores and write to Feature Store as new data arrives from Redshift.
  • C) Use a Glue Streaming job that polls Redshift every 15 minutes for new claims data and continuously updates Feature Store records.
  • D) Configure Redshift Spectrum to query S3 logs and Redshift data simultaneously, then use a Glue crawler to populate the Feature Store every morning.
  • E) Use Amazon Kinesis Data Analytics to join streaming claims data with S3 logs in real-time and write results to Feature Store online.
Click to reveal Answer & Explanation

Correct Answer: A

Correct Options Analysis

  • A is Correct: This is a batch use case with a daily deadline—all 50 million policies need processing before 9 AM. A SageMaker Processing job with appropriate instance sizing provides the compute flexibility for this compute-intensive workload. EventBridge scheduling ensures execution at 2 AM, and Processing jobs have native integration with SageMaker Feature Store for writing features. Running nightly with sufficient capacity ensures completion before business hours.

Distractor Analysis

  • B is Incorrect: A real-time pipeline is unnecessary—features only need refreshing once daily. Continuous processing would incur constant compute costs (Lambda invocations, Kinesis stream charges) for the entire day when the data is only needed at 9 AM. This is a classic over-engineering error.
  • C is Incorrect: Polling Redshift every 15 minutes is inefficient for a daily batch job. This introduces 96 executions per day instead of 1, each with query latency and compute overhead. Glue Streaming jobs are designed for continuous stream processing, not intermittent polling.
  • D is Incorrect: Glue crawlers do not write data to Feature Store. Crawlers populate the Glue Data Catalog metadata (schemas, table definitions). This solution confuses data cataloging with feature storage and would not produce the required Feature Store records.
  • E is Incorrect: Claims data in Redshift is not a streaming source. There is no natural event stream to join against in real-time. This approach misapplies stream processing technology to what is fundamentally a batch workload.

Key Takeaway: Batch workloads should use batch tools (SageMaker Processing + EventBridge), not streaming infrastructure. Understanding the cadence and latency requirements is the first step in choosing between batch and streaming ingestion.

Question 10 - Extracting Data from Multiple S3 Buckets with Different Formats for Bedrock Fine-Tuning

A marketing analytics firm wants to fine-tune a foundation model in Amazon Bedrock on customer feedback data stored across multiple S3 buckets. One bucket contains CSV exports from a CRM, another contains JSON files from a mobile app, and a third contains unstructured text files from a content management system. The data must be consolidated, deduplicated, and formatted as JSONL for Bedrock model customization. The ML team has no experience with Spark and wants a visual, serverless experience.

Which solution should the ML engineer implement? (Select ONE)

  • A) Use AWS Glue Studio to create a visual ETL job that reads all three data formats, deduplicates, and outputs JSONL to S3 for Bedrock fine-tuning.
  • B) Write Lambda functions for each data format that parse and deduplicate the data, then use Step Functions to orchestrate the pipeline, outputting JSONL to S3.
  • C) Use SageMaker Data Wrangler to import all three S3 data sources, apply deduplication transformations visually, and export the final dataset as JSONL.
  • D) Launch an EMR cluster, write PySpark code to read all three formats, deduplicate, and write JSONL to S3.
  • E) Use Amazon Athena with Glue crawlers to create external tables for each data source, write SQL queries to deduplicate and transform, and output JSONL via CTAS.
Click to reveal Answer & Explanation

Correct Answer: A

Correct Options Analysis

  • A is Correct: AWS Glue Studio provides a visual, no-code/low-code interface for building ETL jobs that can read multiple data formats (CSV, JSON, text) from different S3 locations. It natively supports deduplication transforms and can output to JSONL format. It is serverless, eliminating infrastructure management, and the visual interface accommodates the team's lack of Spark expertise while still leveraging Spark under the hood.

Distractor Analysis

  • B is Incorrect: Writing custom Lambda functions for three different formats requires significant custom code development. While Step Functions orchestrates the pipeline, the team would need to write parsing, deduplication, and JSONL serialization logic from scratch. This is operational overhead when Glue Studio provides these functions visually.
  • C is Incorrect: SageMaker Data Wrangler is designed for interactive data preparation and feature engineering for ML workflows, not for large-scale ETL pipelines. While it can deduplicate data, it does not natively output JSONL for Bedrock fine-tuning and is meant for smaller interactive datasets, not potentially millions of records across multiple buckets.
  • D is Incorrect: Amazon EMR requires cluster management and PySpark coding expertise. The team explicitly has no Spark experience and wants serverless. This introduces unnecessary operational overhead and a steep learning curve.
  • E is Incorrect: While Athena can query all three formats via external tables, using CTAS (CREATE TABLE AS SELECT) to output to S3 as JSONL is less straightforward. CTAS output formats are typically Parquet, ORC, Avro, or text—JSONL specifically is not a native CTAS format. This also requires SQL proficiency and Glue crawler management.

Key Takeaway: AWS Glue Studio provides a visual, serverless ETL experience that handles multiple data formats, deduplication, and custom output formats like JSONL—ideal for teams without Spark expertise preparing Bedrock fine-tuning datasets.