Apache Spark alone, by default, generates a lot of information in its logs. Spark Streaming creates a metric ton more (in fairness, there’s a lot going on). So, how do we lower that gargantuan wall of text to something more manageable?
One way is to lower the log level for the Spark Context, which is retrieved from the Streaming Context. Simply:
I’ve been working with Hadoop, Map-Reduce and other “scalable” frameworks for a little over 3 years now. One of the latest and greatest innovations in our open source space has been Apache Spark, a parallel processing framework that’s built on the paradigm Map-Reduce introduced, but packed with enhancements, improvements, optimizations and features. You probably know about Spark, so I don’t need to give you the whole pitch.
You’re likely also aware of its main components:
Spark Core: the parallel processing engine written in the Scala programming language
Spark SQL: allows you to programmatically use SQL in a Spark pipeline for data manipulation
Spark MLlib: machine learning algorithms ported to Spark for easy use by devs
Spark GraphX: a graphing library built on the Spark Core engine
Spark Streaming: a framework for handling data that is live-streaming at high speed
Spark Streaming is what I’ve been working on lately. Specifically, building apps in Scala that utilize Spark Streaming to stream data from Kafka topics, do some on-the-fly manipulations and joins in memory, and write newly augmented data in “near real time” to HDFS.
One of the key benefits of Hadoop is its capacity for storing large quantities of data. With HDFS (the Hadoop Distributed File System), Hadoop clusters are capable of reliably storing petabytes of your data.
A popular usage of that immense storage capability is storing and building history for your datasets. You can not only utilize it to store years of data you might currently be deleting, but you can also build on that history! And, you can structure the data within a Hadoop-native tool like Hive and give analysts SQL-querying ability to that mountain of data! And it’s pretty cheap!
…And the Pitch!
In this tutorial, we’ll walk through why this is beneficial, and how we can implement it on a technical level in Hadoop. Something for the business guy, something for the developer tasked with making the dream come true.
The point of Hadoopsters is to teach concepts related to big data, Hadoop, and analytics. To some, this article will be too simple — low hanging fruit for the accomplished dev. This article is not necessarily for you, captain know-it-all — it’s for someone looking for a reasonably worded, thoughtfully explained how-to on building data history in native Hadoop. We hope to accomplish that here.
This tutorial will accomplish a few key feats that make ingesting data to Hive far less painless. In this writeup, you will learn not only how to Sqoop a source table directly to a Hive table, but also how to Sqoop a source table in any desired format (ORC, for example) instead of just plain old text.
The rapid pace of the big data community can quickly leave Hadoop environments obsolete and out-of-date. Many great tools provide ways to simply upgrade your software without too much hassle. Unfortunately, earlier versions of the Hortonworks Data Platform (HDP) are a bit clunky to upgrade. A recent project of mine involved upgrading an older (<HDP2.1) version of HDP to v2.4. Upgrading the whole stack would have been very time consuming process (more than two weeks), so we decided to just transplant the edge node into a brand new cluster. Continue reading →
Apache NiFi is changing the way people move huge amounts of data. It’s never been easier (or cheaper) to move and transform raw data into meaningful insight.
With that being said, the release notes for Apache NiFi 1.0.0-BETA were released a couple days ago! These are very exciting times as this project becomes more mature.
Here’s the biggest updates:
A brand new UI (!!!)
Cleaner lines, better toolbars, more modern look. Things will be easier to find.
Zero master clustering
This means that NiFi’s become much more resilient to failure while staying lightweight. Individual clients “elect” a leader to handle coordination between clients. This is similar to how YARN High-Availability works.
Actual multi-user tenancy
There’s a drop-down for admins to create users, set permissions, visibility, etc for actual users. Before, there were really two types of users: Admins and Managers. Admins ruled the whole workflow, Managers could make changes to workflows. Now, individual components can be controlled for individual users.
Version control for templates
This is really huge. The upload/implement template function of NiFi was fairly well hidden and obscure before. With version control, I’d hope that a user would be able to check in/out various branches of the template XML files easily.
Beyond that, there’s a few more processors built-in now and a ton of bug fixes.
Please note, I’m not a contributor/committer of Apache NiFi, but I do follow and use the tool fairly regularly. It’s exciting to see the community making these changes. If you see something in the release notes that excites you, let us know below!
There are many functions in Hive that can help analyze your data. But there are times when you need more functionality, sometimes custom. Or at least functionality that is possible without paragraphs of ugly, layered-sub-queried SQL.