Introduction

AWS provides nearly twenty-five different open-source data analytics applications that can be automatically installed and configured on Amazon Elastic MapReduce (Amazon EMR). Of all those options, EMR doesn’t offer a general-purpose data exploration and visualization tool. However, with EMR, you can automate the installation of additional software as part of the cluster creation process or post cluster creation. This brief post will explore how to install, configure, and access Apache Superset, the modern data exploration and visualization platform on Amazon EMR’s Master Node, as a post-cluster creation step. You can use these same techniques to install other software packages on EMR as well, manually or as part of an automated Data Pipeline.

Amazon EMR

According to AWS, Amazon EMR is a cloud-based big data platform for processing vast amounts of data using open source tools such as Apache Spark, Hive, HBase, Flink, Hudi, and Zeppelin, Jupyter, and Presto. Using Amazon EMR, data analysts, engineers, and scientists are free to explore, process, and visualize data. EMR takes care of provisioning, configuring, and tuning the underlying compute clusters, allowing you to focus on running analytics.

AWS currently offers 5.x and 6.x versions of Amazon EMR. The latest Amazon EMR releases are Amazon EMR Release 6.2.0 and Amazon EMR Release 5.32.0. Each version of Amazon EMR offers incremental major and minor releases of nearly 25 different, popular open-source big-data software packages to choose from, which Amazon EMR will install and configure when the cluster is created.

Apache Superset

According to its website, Apache Superset is a modern data exploration and visualization platform. Superset is fast, lightweight, intuitive, and loaded with options that make it easy for users of all skill sets to explore and visualize their data, from simple line charts to highly detailed geospatial charts.

Superset natively supports over twenty-five data sources, including Amazon Athena and Redshift, Apache Drill, Druid, Hive, Impala, Kylin, Pinot, and Spark SQL, Elasticsearch, Google BigQuery, Hana, MySQL, Oracle, Postgres, Presto, Snowflake, Microsoft SQL Server, and Teradata.

As shown in their Gallery, Superset includes dozens of visualization types, including Pivot Table, Line Chart, Markup, Pie Chart, Filter Box, Bubble Chart, Box Plot, Histogram, Heatmap, Sunburst, Calendar Heatmap, and several geospatial types.

Setup

Using this git clone command, download a copy of this post’s open-source GitHub repository to your local environment.

git clone --branch main --single-branch --depth 1 --no-tags \
    https://github.com/garystafford/emr-superset-demo.git

To demonstrate how to install Apache Superset on EMR, I have prepared an AWS CloudFormation template. Deploying the template, cloudformation/superset-emr-demo.yml, to AWS will result in the AWS CloudFormation stack, superset-emr-demo-dev. The stack creates a minimally-sized, two-node EMR cluster, two Amazon S3 buckets, and several AWS Systems Manager (SSM) Parameter Store parameters.

There is also a JSON-format CloudFormation parameters file, cloudformation/superset-emr-demo-params-dev.json. The parameters file contains values for eight of the ten required parameters in the CloudFormation template, all of which you can adjust. For the remaining two required parameters, you will need to supply the name of an existing EC2 key pair to access the EMR Master node. The key pair will need to be deployed to the same AWS Account into which you are deploying EMR. You will also need to supply a Subnet ID for the EMR cluster to be installed into. The subnet must have access to the Internet to install Superset’s required system and Python packages and to access Superset’s web-based user interface. If you need help creating a VPC and subnet to deploy EMR into, refer to my previous blog post, Running PySpark Applications on Amazon EMR: Methods for Interacting with PySpark on Amazon Elastic MapReduce.

The CloudFormation stack is created using a Python script, create_cfn_stack.py. The python script uses the AWS boto3 Python SDK.

	#!/usr/bin/env python3
	# Purpose: Create EMR bootstrap script bucket and deploy the cfn stack
	# Author: Gary A. Stafford (December 2020)
	# Reference: https://gist.github.com/svrist/73e2d6175104f7ab4d201280acba049c
	# Usage Example: python3 ./create_cfn_stack.py \
	# –ec2-key-name emr-demo-123456789012-us-east-1 \
	# –ec2-subnet-id subnet-06aa61f790a932b32 \
	# –environment dev
	import argparse
	import json
	import logging
	import os
	import boto3
	from botocore.exceptions import ClientError
	sts_client = boto3.client('sts')
	cfn_client = boto3.client('cloudformation')
	region = boto3.DEFAULT_SESSION.region_name
	s3_client = boto3.client('s3', region_name=region)
	logging.basicConfig(format='[%(asctime)s] %(levelname)s – %(message)s', level=logging.INFO)
	def main():
	args = parse_args()
	# create bootstrap bucket
	account_id = sts_client.get_caller_identity()['Account']
	bootstrap_bucket = f'superset-emr-demo-bootstrap-{account_id}–{region}'
	create_bucket(bootstrap_bucket)
	# upload bootstrap script
	dir_path = os.path.dirname(os.path.realpath(__file__))
	upload_file(f'{dir_path}/bootstrap_emr/bootstrap_actions.sh', bootstrap_bucket, 'bootstrap_actions.sh')
	# set variables
	stack_name = f'emr-superset-demo-{args.environment}'
	cfn_template_path = f'{dir_path}/cloudformation/superset-emr-demo.yml'
	cfn_params_path = f'{dir_path}/cloudformation/superset-emr-demo-params-{args.environment}.json'
	ec2_key_name = args.ec2_key_name
	# append new parameters
	cfn_params = _parse_parameters(cfn_params_path)
	cfn_params.append({'ParameterKey': 'Ec2KeyName', 'ParameterValue': ec2_key_name})
	cfn_params.append({'ParameterKey': 'Ec2SubnetId', 'ParameterValue': args.ec2_subnet_id})
	cfn_params.append({'ParameterKey': 'BootstrapBucket', 'ParameterValue': bootstrap_bucket})
	logging.info(json.dumps(cfn_params, indent=4))
	# create the cfn stack
	create_stack(stack_name, cfn_template_path, cfn_params)
	def create_bucket(bootstrap_bucket):
	"""Create an S3 bucket in a specified region
	:param bootstrap_bucket: Bucket to create
	:return: True if bucket created, else False
	"""
	try:
	s3_client.create_bucket(Bucket=bootstrap_bucket)
	logging.info(f'New bucket name: {bootstrap_bucket}')
	except ClientError as e:
	logging.error(e)
	return False
	return True
	def upload_file(file_name, bootstrap_bucket, object_name):
	"""Upload a file to an S3 bucket
	:param file_name: File to upload
	:param bootstrap_bucket: Bucket to upload to
	:param object_name: S3 object name
	:return: True if file was uploaded, else False
	"""
	# Upload the file
	try:
	response = s3_client.upload_file(file_name, bootstrap_bucket, object_name)
	logging.info(f'File {file_name} uploaded to bucket {bootstrap_bucket} as object {object_name}')
	except ClientError as e:
	logging.error(e)
	return False
	return True
	def create_stack(stack_name, cfn_template, cfn_params):
	"""Create EMR Cluster CloudFormation stack"""
	template_data = _parse_template(cfn_template)
	create_stack_params = {
	'StackName': stack_name,
	'TemplateBody': template_data,
	'Parameters': cfn_params,
	'TimeoutInMinutes': 60,
	'Capabilities': [
	'CAPABILITY_NAMED_IAM',
	],
	'Tags': [
	{
	'Key': 'Project',
	'Value': 'Superset EMR Demo'
	},
	]
	}
	try:
	response = cfn_client.create_stack(**create_stack_params)
	logging.info(f'Response: {response}')
	except ClientError as e:
	logging.error(e)
	return False
	return True
	def _parse_template(template):
	with open(template) as template_file_obj:
	template_data = template_file_obj.read()
	cfn_client.validate_template(TemplateBody=template_data)
	return template_data
	def _parse_parameters(parameters):
	with open(parameters) as parameter_file_obj:
	parameter_data = json.load(parameter_file_obj)
	return parameter_data
	def parse_args():
	"""Parse argument values from command-line"""
	parser = argparse.ArgumentParser(description='Arguments required for script.')
	parser.add_argument('-e', '–environment', required=True, choices=['dev', 'test', 'prod'], help='Environment')
	parser.add_argument('-k', '–ec2-key-name', required=True, help='Ec2KeyName: Name of EC2 Keypair')
	parser.add_argument('-s', '–ec2-subnet-id', required=True, help='Ec2SubnetId: Name of EC2 Keypair')
	args = parser.parse_args()
	return args
	if __name__ == '__main__':
	main()

view raw create_cfn_stack.py hosted with ❤ by GitHub

To execute the Python script and create the CloudFormation stack, which will create the EMR cluster, run the following command. Remember to update the parameters to the name of your EC2 key pair and the Subnet ID for the EMR cluster.

python3 ./create_cfn_stack.py \
    --ec2-key-name <your_key_pair_name> \
    --ec2-subnet-id <your_subnet_id> \
    --environment dev

Here is what the complete CloudFormation workflow looks like.

Security Group Ingress Rules

To install Superset on the EMR cluster’s Master node via SSH, you need to open port 22 on the Security Group associated with the EMR cluster’s Master Node, allowing access from your IP address. You can use the AWS Management Console or AWS CLI to open port 22. We will use jq and AWS ec2 API from the AWS CLI to get the Security Group ID associated with the EMR cluster’s Master Node and create the two ingress rules.

export EMR_MASTER_SG_ID=$(aws ec2 describe-security-groups | \
    jq -r ".SecurityGroups[] | \
    select(.GroupName==\"ElasticMapReduce-master\").GroupId" | \
    head -n 1)

aws ec2 authorize-security-group-ingress \
    --group-id ${EMR_MASTER_SG_ID} \
    --protocol tcp \
    --port 22 \
    --cidr $(curl ipinfo.io/ip)/32

Superset Script

Once the CloudFormation stack is created and the ports are open, we can install Apache Superset on the EMR Master Node. The bootstrap script,bootstrap_emr/bootstrap_superset.sh, will be used to install Apache Superset onto the EMR cluster’s Master Node as the hadoop user. The script is roughly based on Superset’s Installing from Scratch instructions.

As part of installing Superset, the script will also deploy several common database drivers, including Amazon Athena, Amazon Redshift, Apache Spark SQL, Presto, PostgreSQL, and MySQL. The script will also create a Superset Admin role, and two Superset User roles — Alpha and Gamma.

	#!/bin/bash
	# Purpose: Installs Apache Superset on EMR
	# Author: Gary A. Stafford (December 2020)
	# Usage: sh ./bootstrap_superset.sh 8280
	# Reference: https://superset.apache.org/docs/installation/installing-superset-from-scratch
	# port for superset (default: 8280)
	export SUPERSET_PORT="${1:-8280}"
	# install required packages
	sudo yum -y install gcc gcc-c++ libffi-devel python-devel python-pip python-wheel \
	openssl-devel cyrus-sasl-devel openldap-devel python3-devel.x86_64
	# optionally, update Master Node packages
	sudo yum -y update
	# install required Python package
	python3 -m pip install –user –upgrade setuptools virtualenv
	python3 -m venv venv
	. venv/bin/activate
	python3 -m pip install –upgrade apache-superset \
	PyAthenaJDBC PyAthena sqlalchemy-redshift pyhive mysqlclient psycopg2-binary
	command -v superset
	superset db upgrade
	export FLASK_APP=superset
	echo "export FLASK_APP=superset" >>~/.bashrc
	touch superset_config.py
	echo "ENABLE_TIME_ROTATE = True" >>superset_config.py
	echo "export SUPERSET_CONFIG_PATH=superset_config.py" >>~/.bashrc
	export ADMIN_USERNAME="SupersetAdmin"
	export ADMIN_PASSWORD="Admin1234"
	# create superset admin
	superset fab create-admin \
	–username "${ADMIN_USERNAME}" \
	–firstname Superset \
	–lastname Admin \
	–email superset_admin@example.com \
	–password "${ADMIN_PASSWORD}"
	superset init
	# create two sample superset users
	superset fab create-user \
	–role Alpha \
	–username SupersetUserAlpha \
	–firstname Superset \
	–lastname UserAlpha \
	–email superset_user_alpha@example.com \
	–password UserAlpha1234
	superset fab create-user \
	–role Gamma \
	–username SupersetUserGamma \
	–firstname Superset \
	–lastname UserGamma \
	–email superset_user_gamma@example.com \
	–password UserGamma1234
	# get instance id
	INSTANCE_ID="$(curl –silent http://169.254.169.254/latest/dynamic/instance-identity/document | jq -r .instanceId)"
	export INSTANCE_ID
	echo "INSTANCE_ID: ${INSTANCE_ID}"
	# use instance id to get public dns of master node
	PUBLIC_MASTER_DNS="$(aws ec2 describe-instances –instance-id ${INSTANCE_ID} |
	jq -r '.Reservations[0].Instances[0].PublicDnsName')"
	export PUBLIC_MASTER_DNS
	echo "PUBLIC_MASTER_DNS: ${PUBLIC_MASTER_DNS}"
	# start superset in background
	nohup superset run \
	–host "${PUBLIC_MASTER_DNS}" \
	–port "${SUPERSET_PORT}" \
	–with-threads –reload –debugger \
	>superset_output.log 2>&1 </dev/null &
	# output connection info
	printf %s """
	**********************************************************************
	Superset URL: http://${PUBLIC_MASTER_DNS}:${SUPERSET_PORT}
	Admin Username: ${ADMIN_USERNAME}
	Admin Password: ${ADMIN_PASSWORD}
	**********************************************************************
	"""

view raw bootstrap_superset.sh hosted with ❤ by GitHub

To install Superset using the bootstrap script, we will use another Python script, install_superset.py. The script uses paramiko, a Python implementation of SSHv2. The script also uses scp, a module that uses a paramiko transport to send and receive files via the scp1 protocol.

	#!/bin/bash
	# Purpose: Installs Apache Superset on EMR
	# Author: Gary A. Stafford (December 2020)
	# Usage: sh ./bootstrap_superset.sh 8280
	# Reference: https://superset.apache.org/docs/installation/installing-superset-from-scratch
	# port for superset (default: 8280)
	SUPERSET_PORT="${1:-8280}"
	# install required packages
	sudo yum -y install gcc gcc-c++ libffi-devel python-devel python-pip python-wheel \
	openssl-devel cyrus-sasl-devel openldap-devel python3-devel.x86_64
	# optionally, update master node packages
	sudo yum -y update
	# set up a python virtual environment
	python3 -m pip install –user –upgrade setuptools virtualenv
	python3 -m venv venv
	. venv/bin/activate
	python3 -m pip install –upgrade apache-superset \
	PyAthenaJDBC PyAthena sqlalchemy-redshift pyhive mysqlclient psycopg2-binary
	command -v superset
	superset db upgrade
	FLASK_APP=superset
	export "FLASK_APP=${FLASK_APP}"
	echo "export FLASK_APP=superset" >>~/.bashrc
	touch superset_config.py
	echo "ENABLE_TIME_ROTATE = True" >>superset_config.py
	echo "export SUPERSET_CONFIG_PATH=superset_config.py" >>~/.bashrc
	ADMIN_USERNAME="SupersetAdmin"
	ADMIN_PASSWORD="Admin1234"
	# create superset admin
	superset fab create-admin \
	–username "${ADMIN_USERNAME}" \
	–firstname Superset \
	–lastname Admin \
	–email superset_admin@example.com \
	–password "${ADMIN_PASSWORD}"
	superset init
	# create two sample superset users
	superset fab create-user \
	–role Alpha \
	–username SupersetUserAlpha \
	–firstname Superset \
	–lastname UserAlpha \
	–email superset_user_alpha@example.com \
	–password UserAlpha1234
	superset fab create-user \
	–role Gamma \
	–username SupersetUserGamma \
	–firstname Superset \
	–lastname UserGamma \
	–email superset_user_gamma@example.com \
	–password UserGamma1234
	# get ec2 instance id
	INSTANCE_ID="$(curl –silent http://169.254.169.254/latest/dynamic/instance-identity/document | jq -r .instanceId)"
	# use ec2 instance id to get public dns of master node
	PUBLIC_MASTER_DNS="$(aws ec2 describe-instances –instance-id ${INSTANCE_ID} |
	jq -r '.Reservations[0].Instances[0].PublicDnsName')"
	# start superset in background
	nohup superset run \
	–host "${PUBLIC_MASTER_DNS}" \
	–port "${SUPERSET_PORT}" \
	–with-threads –reload –debugger \
	>superset_output.log 2>&1 </dev/null &
	# output superset connection info
	printf %s """
	**********************************************************************
	Superset URL: http://${PUBLIC_MASTER_DNS}:${SUPERSET_PORT}
	Admin Username: ${ADMIN_USERNAME}
	Admin Password: ${ADMIN_PASSWORD}
	**********************************************************************
	"""

view raw install_superset.py hosted with ❤ by GitHub

The script requires a single input parameter, ec2-key-path, which is the full path to your EC2 key pair (e.g., ~/.ssh/my-key-pair.pem). Optionally, you can change the default Superset port of 8280, using the superset-port parameter.

python3 ./install_superset.py \
    --ec2-key-path </path/to/my-key-pair.pem> \
    --superset-port 8280

The script uses SSH and SCP to deploy and execute the bootstrap script,bootstrap_superset.sh. The output from the script includes the URL of Apache Superset running on the EMR cluster. The output also contains the username and password of the Superset Admin.

********************************************************************
Superset URL: http://ec2-111-22-333-44.compute-1.amazonaws.com:8280
Admin Username: SupersetAdmin
Admin Password: Admin1234
********************************************************************

SSH Tunnel

According to AWS, EMR applications publish user interfaces as websites hosted on the master node. For security reasons, these websites are only available on the master node’s local web server. To reach any of the web interfaces, you must establish an SSH tunnel with the master node using either dynamic or local port forwarding. If you are using dynamic port forwarding, you must also configure a proxy server to view the web interfaces.

Running the command in your terminal will start the SSH tunnel on port 8157. Once the tunnel is enabled, you can access Apache Superset in a web browser, using the script output’s URL shown in the script output above. Use the Admin credentials or either of the two User credentials to sign in to Superset.

Once signed in, you will have the ability to connect to your data sources and explore and visualize data. Below, we see an example of a SQL query executed against an Amazon RDS for PostgreSQL database, running in a separate VPC from EMR.

Conclusion

In this post, we learned how to install Apache Superset onto the Master Node of an Amazon EMR Cluster. If you want to install an application on all the nodes of an EMR cluster, you can add the commands to the bootstrap script, which runs when CloudFormation creates the cluster.

---

This blog represents my own viewpoints and not of my employer, Amazon Web Services. All product names, logos, and brands are the property of their respective owners.