Many customers run big data workloads such as extract, transform, and load (ETL) on Apache Hive to create a data warehouse on Hadoop. Apache Hive has performed pretty well for a long time. But with advancements in infrastructure such as cloud computing and multicore machines with large RAM, Apache Spark started to gain visibility by performing better than Apache Hive.

Customers now want to migrate their Apache Hive workloads to Apache Spark in the cloud to get the benefits of optimized runtime, cost reduction through transient clusters, better scalability by decoupling the storage and compute, and flexibility. However, migration from Apache Hive to Apache Spark needs a lot of manual effort to write migration scripts and maintain different Spark job configurations.

In this post, we walk you through a solution that automates the migration from HiveQL to Spark SQL. The solution was used to migrate Hive with Oozie workloads to Spark SQL and run them on Amazon EMR for a large gaming client. You can also use this solution to develop new jobs with Spark SQL and process them on Amazon EMR. This post assumes that you have a basic understanding of Apache Spark, Hive, and Amazon EMR.

Solution overview

In our example, we use Apache Oozie, which schedules Apache Hive jobs as actions to collect and process data on a daily basis.

We migrate these Oozie workflows with Hive actions by extracting the HQL files, and dynamic and static parameters, and converting them to be Spark compliant. Manual conversion is both time consuming and error prone. To convert the HQL to Spark SQL, you’ll need to sort through existing HQLs, replace the parameters, and change the syntax for a bunch of files.

Instead, we can use automation to speed up the process of migration and reduce heavy lifting tasks, costs, and risks.

We split the solution into two primary components: generating Spark job metadata and running the SQL on Amazon EMR. The first component (metadata setup) consumes existing Hive job configurations and generates metadata such as number of parameters, number of actions (steps), and file formats. The second component consumes the generated metadata from the first component and prepares the run order of Spark SQL within a Spark session. With this solution, we support basic orchestration and scheduling with the help of AWS services like Amazon DynamoDB and Amazon Simple Storage Service (Amazon S3). We can validate the solution by running queries in Amazon Athena.

In the following sections, we walk through these components and how to use these automations in detail.

Generate Spark SQL metadata

Our batch job consists of Hive steps scheduled to run sequentially. For each step, we run HQL scripts that extract, transform, and aggregate input data into one final Hive table, which stores data in HDFS. We use the following Oozie workflow parser script, which takes the input of an existing Hive job and generates configurations artifacts needed for running SQL using PySpark.

Oozie workflow XML parser

We create a Python script to automatically parse the Oozie jobs, including workflow.xml, co-ordinator.xml, job properties, and HQL files. This script can handle many Hive actions in a workflow by organizing the metadata at the step level into separate folders. Each step includes the list of SQLs, SQL paths, and their static parameters, which are input for the solution in the next step.

The process consists of two steps:

1. The Python parser script takes input of the existing Oozie Hive job and its configuration files.
2. The script generates a metadata JSON file for each step.

The following diagram outlines these steps and shows sample output.

Prerequisites

You need the following prerequisites:

• Python 3.8
• Python packages:
  • sqlparse==0.4.2
  • jproperties==2.1.1
  • defusedxml== 0.7.1

Setup

Complete the following steps:

1. Install Python 3.8.
2. Create a virtual environment:

python3 -m venv /path/to/new/virtual/environment

3. Activate the newly created virtual environment:

source /path/to/new/virtual/environment/bin/activate

4. Git clone the project:

git clone https://github.com/aws-samples/oozie-job-parser-extract-hive-sql

5. Install dependent packages:

cd oozie-job-parser-extract-hive-sqlpip install -r requirements.txt

Sample command

We can use the following sample command:

python xml\_parser.py --base-folder ./sample\_jobs/ --job-name sample\_oozie\_job\_name --job-version V3 --hive-action-version 0.4 --coordinator-action-version 0.4 --workflow-version 0.4 --properties-file-name job.coordinator.properties

The output is as follows:

{'nameNode': 'hdfs://@{{/cluster/${{cluster}}/namenode}}:54310', 'jobTracker': '@{{/cluster/${{cluster}}/jobtracker}}:54311', 'queueName': 'test\_queue', 'appName': 'test\_app', 'oozie.use.system.libpath': 'true', 'oozie.coord.application.path': '${nameNode}/user/${user.name}/apps/${appName}', 'oozie\_app\_path': '${oozie.coord.application.path}', 'start': '${{startDate}}', 'end': '${{endDate}}', 'initial\_instance': '${{startDate}}', 'job\_name': '${appName}', 'timeOut': '-1', 'concurrency': '3', 'execOrder': 'FIFO', 'throttle': '7', 'hiveMetaThrift': '@{{/cluster/${{cluster}}/hivemetastore}}', 'hiveMySQL': '@{{/cluster/${{cluster}}/hivemysql}}', 'zkQuorum': '@{{/cluster/${{cluster}}/zookeeper}}', 'flag': '\_done', 'frequency': 'hourly', 'owner': 'who', 'SLA': '2:00', 'job\_type': 'coordinator', 'sys\_cat\_id': '6', 'active': '1', 'data\_file': 'hdfs://${nameNode}/hive/warehouse/test\_schema/test\_dataset', 'upstreamTriggerDir': '/input\_trigger/upstream1'}

('./sample\_jobs/development/sample\_oozie\_job\_name/step1/step1.json', 'w')('./sample\_jobs/development/sample\_oozie\_job\_name/step2/step2.json', 'w')

Limitations

This method has the following limitations:

• The Python script parses only HiveQL actions from the Oozie workflow.xml.
• The Python script generates one file for each SQL statement and uses the sequence ID for file names. It doesn’t name the SQL based on the functionality of the SQL.

Run Spark SQL on Amazon EMR

After we create the SQL metadata files, we use another automation script to run them with Spark SQL on Amazon EMR. This automation script supports custom UDFs by adding JAR files to spark submit. This solution uses DynamoDB for logging the run details of SQLs for support and maintenance.

Architecture overview

The following diagram illustrates the solution architecture.

Prerequisites

You need the following prerequisites:

• Version:
  • Spark 3.X
  • Python 3.8
  • Amazon EMR 6.1

Setup

Complete the following steps:

1. Install the AWS Command Line Interface (AWS CLI) on your workspace by following the instructions in Installing or updating the latest version of the AWS CLI. To configure AWS CLI interaction with AWS, refer to Quick setup.
2. Create two tables in DynamoDB: one to store metadata about jobs and steps, and another to log job runs.
   • Use the following AWS CLI command to create the metadata table in DynamoDB:

aws dynamodb create-table --region us-east-1 --table-name dw-etl-metadata --attribute-definitions '[ { "AttributeName": "id","AttributeType": "S" } , { "AttributeName": "step\_id","AttributeType": "S" }]' --key-schema '[{"AttributeName": "id", "KeyType": "HASH"}, {"AttributeName": "step\_id", "KeyType": "RANGE"}]' --billing-mode PROVISIONED --provisioned-throughput ReadCapacityUnits=5,WriteCapacityUnits=5

You can check on the DynamoDB console that the table dw-etl-metadata is successfully created.

The metadata table has the following attributes.

1. • Use the following AWS CLI command to create the log table in DynamoDB:

aws dynamodb create-table --region us-east-1 --table-name dw-etl-pipelinelog --attribute-definitions '[ { "AttributeName":"job\_run\_id", "AttributeType": "S" } , { "AttributeName":"step\_id", "AttributeType": "S" } ]' --key-schema '[{"AttributeName": "job\_run\_id", "KeyType": "HASH"},{"AttributeName": "step\_id", "KeyType": "RANGE"}]' --billing-mode PROVISIONED --provisioned-throughput ReadCapacityUnits=5,WriteCapacityUnits=5

You can check on the DynamoDB console that the table dw-etl-pipelinelog is successfully created.

The log table has the following attributes.

The log table can grow quickly if there are too many jobs or if they are running frequently. We can archive them to Amazon S3 if they are no longer used or use the Time to Live feature of DynamoDB to clean up old records.

3. Run the first command to set the variable in case you have an existing bucket that can be reused. If not, create a S3 bucket to store the Spark SQL code, which will be run by Amazon EMR.

export s3\_bucket\_name=unique-code-bucket-name # Change unique-code-bucket-name to a valid bucket name

aws s3api create-bucket --bucket $s3\_bucket\_name --region us-east-1

4. Enable secure transfer on the bucket:

aws s3api put-bucket-policy --bucket $s3\_bucket\_name --policy '{"Version": "2012-10-17", "Statement": [{"Effect": "Deny", "Principal": {"AWS": "*"}, "Action": "s3:*", "Resource": ["arn:aws:s3:::unique-code-bucket-name", "arn:aws:s3:::unique-code-bucket-name/*"], "Condition": {"Bool": {"aws:SecureTransport": "false"} } } ] }' # Change unique-code-bucket-name to a valid bucket name

5. Clone the project to your workspace:

git clone https://github.com/aws-samples/pyspark-sql-framework.git

6. Create a ZIP file and upload it to the code bucket created earlier:

cd pyspark-sql-framework/codezip code.zip -r *aws s3 cp ./code.zip s3://$s3\_bucket\_name/framework/code.zip

7. Upload the ETL driver code to the S3 bucket:

cd $OLDPWD/pyspark-sql-frameworkaws s3 cp ./code/etl\_driver.py s3://$s3\_bucket\_name/framework/

8. Upload sample job SQLs to Amazon S3:

aws s3 cp ./sample\_oozie\_job\_name/ s3://$s3\_bucket\_name/DW/sample\_oozie\_job\_name/ --recursive

9. Add a sample step (./sample\_oozie\_job\_name/step1/step1.json) to DynamoDB (for more information, refer to Write data to a table using the console or AWS CLI):

{ "name": "step1.q", "step\_name": "step1", "sql\_info": [ { "sql\_load\_order": 5, "sql\_parameters": { "DATE": "${coord:formatTime(coord:nominalTime(), 'yyyy-MM-dd')}", "HOUR": "${coord:formatTime(coord:nominalTime(), 'HH')}" }, "sql\_active\_flag": "Y", "sql\_path": "5.sql" }, { "sql\_load\_order": 10, "sql\_parameters": { "DATE": "${coord:formatTime(coord:nominalTime(), 'yyyy-MM-dd')}", "HOUR": "${coord:formatTime(coord:nominalTime(), 'HH')}" }, "sql\_active\_flag": "Y", "sql\_path": "10.sql" } ], "id": "emr\_config", "step\_id": "sample\_oozie\_job\_name#step1", "sql\_base\_path": "sample\_oozie\_job\_name/step1/", "spark\_config": { "spark.sql.parser.quotedRegexColumnNames": "true" }}

10. In the Athena query editor, create the database base:

create database base;

11. Copy the sample data files from the repo to Amazon S3:
    1. Copy us\_current.csv:

aws s3 cp ./sample\_data/us\_current.csv s3://$s3\_bucket\_name/covid-19-testing-data/base/source\_us\_current/;

2. Copy states\_current.csv:

aws s3 cp ./sample\_data/states\_current.csv s3://$s3\_bucket\_name/covid-19-testing-data/base/source\_states\_current/;

12. To create the source tables in the base database, run the DDLs present in the repo in the Athena query editor:
    1. Run the ./sample\_data/ddl/states\_current.q file by modifying the S3 path to the bucket you created.
    2. Run the ./sample\_data/ddl/us\_current.q file by modifying the S3 path to the bucket you created.

The ETL driver file implements the Spark driver logic. It can be invoked locally or on an EMR instance.

13. Launch an EMR cluster.
    1. Make sure to select Use for Spark table metadata under AWS Glue Data Catalog settings.

14. Add the following steps to EMR cluster.

aws emr add-steps --cluster-id <<cluster id created above>> --steps 'Type=CUSTOM\_JAR,Name="boto3",ActionOnFailure=CONTINUE,Jar=command-runner.jar,Args=[bash,-c,"sudo pip3 install boto3"]'aws emr add-steps --cluster-id <<cluster id created above>> --steps 'Name="sample\_oozie\_job\_name",Jar="command-runner.jar",Args=[spark-submit,--py-files,s3://unique-code-bucket-name-#####/framework/code.zip,s3://unique-code-bucket-name-#####/framework/etl\_driver.py,--step\_id,sample\_oozie\_job\_name#step1,--job\_run\_id,sample\_oozie\_job\_name#step1#2022-01-01-12-00-01, --code\_bucket=s3://unique-code-bucket-name-#####/DW,--metadata\_table=dw-etl-metadata,--log\_table\_name=dw-etl-pipelinelog,--sql\_parameters,DATE=2022-02-02::HOUR=12::code\_bucket=s3://unique-code-bucket-name-#####]' # Change unique-code-bucket-name to a valid bucket name

The following table summarizes the script arguments.

Validation

After completion of EMR step you should have data on S3 bucket for the table base.states\_daily. We can validate the data by querying the table base.states\_daily in Athena.

Congratulations, you have converted an Oozie Hive job to Spark and run on Amazon EMR successfully.

Solution highlights

This solution has the following benefits:

• It avoids boilerplate code for any new pipeline and offers less maintenance of code
• Onboarding any new pipeline only needs the metadata set up—the DynamoDB entries and SQL to be placed in the S3 path
• Any common modifications or enhancements can be done at the solution level, which will be reflected across all jobs
• DynamoDB metadata provides insight into all active jobs and their optimized runtime parameters
• For each run, this solution persists the SQL start time, end time, and status in a log table to identify issues and analyze runtimes
• It supports Spark SQL and UDF functionality. Custom UDFs can be provided externally to the spark submit command

Limitations

This method has the following limitations:

• The solution only supports SQL queries on Spark
• Each SQL should be a Spark action like insert, create, drop, and so on

In this post, we explained the scenario of migrating an existing Oozie job. We can use the PySpark solution independently for any new development by creating DynamoDB entries and SQL files.

Clean up

Delete all the resources created as part of this solution to avoid ongoing charges for the resources:

1. Delete the DynamoDB tables:

aws dynamodb delete-table --table-name dw-etl-metadata --region us-east-1aws dynamodb delete-table --table-name dw-etl-pipelinelog --region us-east-1

2. Delete the S3 bucket:

aws s3 rm s3://$s3\_bucket\_name --region us-east-1 --recursiveaws s3api create-bucket --bucket $s3\_bucket\_name --region us-east-1

3. Stop the EMR cluster if it wasn’t a transient cluster:

aws emr terminate-clusters --cluster-ids <<cluster id created above>> 

Conclusion

In this post, we presented two automated solutions: one for parsing Oozie workflows and HiveQL files to generate metadata, and a PySpark solution for running SQLs using generated metadata. We successfully implemented these solutions to migrate a Hive workload to EMR Spark for a major gaming customer and achieved about 60% effort reduction.

For a Hive with Oozie to Spark migration, these solutions help complete the code conversion quickly so you can focus on performance benchmark and testing. Developing a new pipeline is also quick—you only need to create SQL logic, test it using Spark (shell or notebook), add metadata to DynamoDB, and test via the PySpark SQL solution. Overall, you can use the solution in this post to accelerate Hive to Spark code migration.

About the authors

Vinay Kumar Khambhampati is a Lead Consultant with the AWS ProServe Team, helping customers with cloud adoption. He is passionate about big data and data analytics.

Sandeep Singh is a Lead Consultant at AWS ProServe, focused on analytics, data lake architecture, and implementation. He helps enterprise customers migrate and modernize their data lake and data warehouse using AWS services.

Amol Guldagad is a Data Analytics Consultant based in India. He has worked with customers in different industries like banking and financial services, healthcare, power and utilities, manufacturing, and retail, helping them solve complex challenges with large-scale data platforms. At AWS ProServe, he helps customers accelerate their journey to the cloud and innovate using AWS analytics services.