the hadoop ecosystem for developers

The Hadoop Ecosystem

Zohar Elkayam & Ronen Fidel

Brillix

Agenda

• Big Data – The Challenge

• Introduction to Hadoop

– Deep dive into HDFS

– MapReduce and YARN

• Improving Hadoop: tools and extensions

• NoSQL and RDBMS

About Brillix

• Brillix is a leading company that specialized in Data Management

• We provide professional services and consulting for Databases, Security and Big Data solutions

Who am I?

• Zohar Elkayam, CTO at Brillix

• DBA, team leader, instructor and a senior consultant for over 17 years

• Oracle ACE Associate

• Involved with Big Data projects since 2011

• Blogger – www.realdbamagic.com

Big Data

"Big Data"??

Different definitions

“Big data exceeds the reach of commonly used hardware environments

and software tools to capture, manage, and process it with in a tolerable

elapsed time for its user population.” - Teradata Magazine article, 2011

“Big data refers to data sets whose size is beyond the ability of typical

database software tools to capture, store, manage and analyze.”

- The McKinsey Global Institute, 2012

“Big data is a collection of data sets so large and complex that it

becomes difficult to process using on-hand database management

tools.” - Wikipedia, 2014

A Success Story

MORE stories..

• Crime Prevention in Los Angeles

• Diagnosis and treatment of genetic diseases

• Investments in the financial sector

• Generation of personalized advertising

• Astronomical discoveries

Examples of Big Data Use Cases Today

MEDIA/ENTERTAINMENT

Viewers / advertising effectiveness

COMMUNICATIONS

Location-based advertising

EDUCATION &RESEARCH

Experiment sensor analysis

CONSUMER PACKAGED GOODS

Sentiment analysis of what’s hot, problems

HEALTH CARE

Patient sensors, monitoring, EHRs

Quality of care

LIFE SCIENCES

Clinical trials

Genomics

HIGH TECHNOLOGY / INDUSTRIAL MFG.

Mfg quality

Warranty analysis

OIL & GAS

Drilling exploration sensor analysis

FINANCIALSERVICES

Risk & portfolio analysis

New products

AUTOMOTIVE

Auto sensors reporting location, problems

RETAIL

Consumer sentiment

Optimized marketing

LAW ENFORCEMENT & DEFENSE

Threat analysis -social media monitoring, photo analysis

TRAVEL &TRANSPORTATION

Sensor analysis for optimal traffic flows

Customer sentiment

UTILITIES

Smart Meter analysis for network capacity,

ON-LINE SERVICES / SOCIAL MEDIA

People & career matching

Web-site

optimization

Most Requested Uses of Big Data

• Log Analytics & Storage

• Smart Grid / Smarter Utilities

• RFID Tracking & Analytics

• Fraud / Risk Management & Modeling

• 360° View of the Customer

• Warehouse Extension

• Email / Call Center Transcript Analysis

• Call Detail Record Analysis

The Challenge

Big Data Big Problems

• Unstructured• Unprocessed• Un-aggregated• Un-filtered• Repetitive• Low quality• And generally messy

Oh, and there is a lot of it

The Big Data Challenge

Big Data: Challenge to Value

Business

High Variety

High Volume

High Velocity

Deep Analytics

High Agility

Massive Scalability

Real TimeTomorrow

Challenges

Volume

• Big data come in one size: Big.

• Size is measured in Terabyte(1012), Petabyte(1015), Exabyte(1018), Zettabyte (1021)

• The storing and handling of the data becomes an issue

• Producing value out of the data in a reasonable time is an issue

Some Numbers

• How much data in the world?– 800 Terabytes, 2000– 160 Exabytes, 2006 (1EB = 1018B)– 4.5 Zettabytes, 2012 (1ZB = 1021B)– 44 Zettabytes by 2020

• How much is a zettabyte?– 1,000,000,000,000,000,000,000 bytes– A stack of 1TB hard disks that is 25,400 km high

Data grows fast!

Growth Rate

How much data generated in a day?

– 7 TB, Twitter

– 10 TB, Facebook

Variety

• Big Data extends beyond structured data: including semi-structured and unstructured information: logs, text, audio and videos

• Wide variety of rapidly evolving data types requires highly flexible stores and handling

Structured & Un-Structured

Un-Structured Structured

Objects Tables

Flexible Columns and Rows

Structure Unknown Predefined Structure

Textual and Binary Mostly Textual

Big Data is ANY data:

Unstructured, Semi-Structure and Structured

• Some has fixed structure

• Some is “bring own structure”

• We want to find value in all of it

Data Types by Industry

Velocity

• The speed in which the data is being generated and collected

• Streaming data and large volume data movement

• High velocity of data capture – requires rapid ingestion

• Might cause the backlog problem

Global Internet Device Forecast

Internet of Things

Veracity

• Quality of the data can vary greatly

• Data sources might be messy or corrupted

So, What Defines Big Data?

• When we think that we can produce value from that data and want to handle it

• When the data is too big or moves too fast to handle in a sensible amount of time

• When the data doesn’t fit conventional database structure

• When the solution becomes part of the problem

Handling Big Data

Big Data in Practice

• Big data is big: technological infrastructure solutions needed

• Big data is messy: data sources must be cleaned before use

• Big data is complicated: need developers and system admins to manage intake of data

Big Data in Practice (cont.)

• Data must be broken out of silos in order to be mined, analyzed and transformed into value

• The organization must learn how to communicate and interpret the results of analysis

Infrastructure Challenges

• Infrastructure that is built for:

– Large-scale

– Distributed

– Data-intensive jobs that spread the problem across clusters of server nodes

Infrastructure Challenges (cont.)

• Storage:– Efficient and cost-effective enough to capture and

store terabytes, if not petabytes, of data

– With intelligent capabilities to reduce your data footprint such as:

• Data compression

• Automatic data tiering

• Data deduplication

Infrastructure Challenges (cont.)

• Network infrastructure that can quickly import large data sets and then replicate it to various nodes for processing

• Security capabilities that protect highly-distributed infrastructure and data

Introduction To Hadoop

Apache Hadoop

• Open source project run by Apache (2006)

• Hadoop brings the ability to cheaply process large amounts of data, regardless of its structure

• It Is has been the driving force behind the growth of the big data Industry

• Get the public release from:http://hadoop.apache.org/core/

Hadoop Creation History

Key points

• An open-source framework that uses a simple programming model to enable distributed processing of large data sets on clusters of computers.

• The complete technology stack includes

– common utilities

– a distributed file system

– analytics and data storage platforms

– an application layer that manages distributed processing, parallel computation, workflow, and configuration management

• Cost-effective for handling large unstructured data sets than conventional approaches, and it offers massive scalability and speed

Why use Hadoop?

Cost Flexibility

Near linear

performance up

to 1000s of nodes

Leverages

commodity HW &

open source SW

Versatility with

data, analytics &

operation

Scalability

No, really, why use Hadoop?

• Need to process Multi Petabyte Datasets• Expensive to build reliability in each application• Nodes fail every day

– Failure is expected, rather than exceptional– The number of nodes in a cluster is not constant

• Need common infrastructure– Efficient, reliable, Open Source Apache License

• The above goals are same as Condor, but– Workloads are IO bound and not CPU bound

Hadoop Benefits

• Reliable solution based on unreliable hardware• Designed for large files• Load data first, structure later• Designed to maximize throughput of large scans• Designed to leverage parallelism• Designed to scale• Flexible development platform• Solution Ecosystem

Hadoop Limitations

• Hadoop is scalable but it’s not fast

• Some assembly required

• Batteries not included

• Instrumentation not included either

• DIY mindset

Hadoop Components

Hadoop Main Components

• HDFS: Hadoop Distributed File System –distributed file system that runs in a clustered environment.

• MapReduce – programming paradigm for running processes over a clustered environments.

HDFS is...

• A distributed file system

• Redundant storage

• Designed to reliably store data using commodity hardware

• Designed to expect hardware failures

• Intended for large files

• Designed for batch inserts

• The Hadoop Distributed File System

HDFS Node Types

HDFS has three types of Nodes

• Namenode (MasterNode)– Distribute files in the cluster– Responsible for the replication between

the datanodes and for file blocks location

• Datanodes– Responsible for actual file store– Serving data from files(data) to client

• BackupNode (version 0.23 and up)• It’s a backup of the NameNode

Typical implementation

• Nodes are commodity PCs

• 30-40 nodes per rack

• Uplink from racks is 3-4 gigabit

• Rack-internal is 1 gigabit

MapReduce is...

• A programming model for expressing distributed computations at a massive scale

• An execution framework for organizing and performing such computations

• An open-source implementation called Hadoop

MapReduce paradigm

• Implement two functions:• MAP - Takes a large problem and divides into sub problems

and performs the same function on all subsystemsMap(k1, v1) -> list(k2, v2)

• REDUCE - Combine the output from all sub-problemsReduce(k2, list(v2)) -> list(v3)

• Framework handles everything else (almost)

• Value with same key must go to the same reducer

Typical large-data problem

• Iterate over a large number of records

• Extract something of interest from each

• Shuffle and sort intermediate results

• Aggregate intermediate results

• Generate final output

Reduce

Divide and Conquer

MapReduce - word count example

function map(String name, String document):

for each word w in document:

emit(w, 1)

function reduce(String word, Iterator

partialCounts):

totalCount = 0

for each count in partialCounts:

totalCount += count

emit(word, totalCount)

MapReduce Word Count Process

MapReduce Advantages

Example: $HADOOP_HOME/bin/hadoop jar @HADOOP_HOME/hadoop-

streaming.jar \

- input myInputDirs \

- output myOutputDir \

- mapper /bin/cat \

- reducer /bin/wc

• Runs programs (jobs) across many computers

• Protects against single server failure by re-run failed steps

• MR jobs can be written in Java, C, Phyton, Ruby and

others

• Users only write Map and Reduce functions

MapReduce is good for...

• Embarrassingly parallel algorithms

• Summing, grouping, filtering, joining

• Off-line batch jobs on massive data sets

• Analyzing an entire large dataset

MapReduce is OK for...

• Iterative jobs (i.e., graph algorithms)

• Each iteration must read/write data to disk

• IO and latency cost of an iteration is high

MapReduce is NOT good for...

• Jobs that need shared state/coordination

• Tasks are shared-nothing

• Shared-state requires scalable state store

• Low-latency jobs

• Jobs on small datasets

• Finding individual records

Deep Dive into HDFS

• Appears as a single disk• Runs on top of a native filesystem

– Ext3,Ext4,XFS

• Based on Google's Filesystem GFS• Fault Tolerant

– Can handle disk crashes, machine crashes, etc...

• Based on Google's Filesystem (GFS or GoogleFS)– gfs-sosp2003.pdf

• http://static.googleusercontent.com/external_content/untrusted_dlcp/research.google.com/en/us/archive/gfs-sosp2003.pdf

– http://en.wikipedia.org/wiki/Google_File_System

HDFS is Good for...

• Storing large files– Terabytes, Petabytes, etc...– Millions rather than billions of files– 100MB or more per file

• Streaming data– Write once and read-many times patterns– Optimized for streaming reads rather than random reads– Append operation added to Hadoop 0.21

• “Cheap” Commodity Hardware– No need for super-computers, use less reliable commodity hardware

HDFS is not so good for...

• Low-latency reads– High-throughput rather than low latency for small chunks of

data– HBase addresses this issue

• Large amount of small files– Better for millions of large files instead of billions of small files

• For example each file can be 100MB or more

• Multiple Writers– Single writer per file– Writes only at the end of file, no-support for arbitrary offset

HDFS: Hadoop Distributed File System

• A given file is broken down into blocks (default=64MB), then blocks are replicated across cluster (default=3)

• Optimized for:– Throughput– Put/Get/Delete– Appends

• Block Replication for:– Durability– Availability– Throughput

• Block Replicas are distributed across servers and racks

HDFS Architecture

• Name Node : Maps a file to a file-id and list of Map Nodes

• Data Node : Maps a block-id to a physical location on disk

• Secondary Name Node: Periodic merge of Transaction log

HDFS Daemons

• Filesystem cluster is manager by three types of processes– Namenode

• manages the File System's namespace/meta-data/file blocks• Runs on 1 machine to several machines

– Datanode• Stores and retrieves data blocks• Reports to Namenode• Runs on many machines

– Secondary Namenode• Performs house keeping work so Namenode doesn’t have to• Requires similar hardware as Namenode machine• Not used for high-availability – not a backup for Namenode

Files and Blocks

• Files are split into blocks (single unit of storage)

– Managed by Namenode, stored by Datanode

– Transparent to user

• Replicated across machines at load time

– Same block is stored on multiple machines

– Good for fault-tolerance and access

– Default replication is 3

HDFS Blocks

• Blocks are traditionally either 64MB or 128MB– Default is 128MB

• The motivation is to minimize the cost of seeks as compared to transfer rate– 'Time to transfer' > 'Time to seek'

• For example, lets say– seek time = 10ms– Transfer rate = 100 MB/s

• To achieve seek time of 1% transfer rate– Block size will need to be = 100MB

Block Replication

• Namenode determines replica placement • Replica placements are rack aware

– Balance between reliability and performance• Attempts to reduce bandwidth• Attempts to improve reliability by putting replicas on multiple racks

– Default replication is 3• 1st replica on the local rack• 2nd replica on the local rack but different machine• 3rd replica on the different rack

– This policy may change/improve in the future

Data Correctness

• Use Checksums to validate data– Use CRC32

• File Creation– Client computes checksum per 512 byte

– Data Node stores the checksum

• File access– Client retrieves the data and checksum from Data Node

– If Validation fails, Client tries other replicas

Data Pipelining

• Client retrieves a list of Data Nodes on which to place replicas of a block

• Client writes block to the first Data Node

• The first Data Node forwards the data to the next Data Node in the Pipeline

• When all replicas are written, the Client moves on to write the next block in file

Client, Namenode, and Datanodes

• Namenode does NOT directly write or read data

– One of the reasons for HDFS’s Scalability

• Client interacts with Namenode to update Namenode’s HDFS namespace and retrieve block locations for writing and reading

• Client interacts directly with Datanode to read/write data

Name Node Metadata

• Meta-data in Memory– The entire metadata is in main memory– No demand paging of meta-data

• Types of Metadata– List of files– List of Blocks for each file– List of Data Nodes for each block– File attributes, e.g. creation time, replication factor

• A Transaction Log– Records file creations, file deletions. etc.

Namenode Memory Concerns

• For fast access Namenode keeps all block metadata in-memory– The bigger the cluster - the more RAM required

• Best for millions of large files (100mb or more) rather than billions• Will work well for clusters of 100s machines

• Hadoop 2+– Namenode Federations

• Each namenode will host part of the blocks• Horizontally scale the Namenode

– Support for 1000+ machine clusters

Using HDFS

Reading Data from HDFS

1. Create FileSystem

2. Open InputStream to a Path

3. Copy bytes using IOUtils

4. Close Stream

1: Create FileSystem

• FileSystem fs = FileSystem.get(new Configuration());

– If you run with yarn command, DistributedFileSystem (HDFS) will be created

• Utilizes fs.default.name property from configuration

• Recall that Hadoop framework loads core-site.xml which sets property to hdfs (hdfs://localhost:8020)

2: Open Input Stream to a Path

...InputStream input = null;try {input = fs.open(fileToRead);...• fs.open returns org.apache.hadoop.fs.FSDataInputStream

– Another FileSystem implementation will return their own custom implementation of InputStream

• Opens stream with a default buffer of 4k• If you want to provide your own buffer size use

– fs.open(Path f, int bufferSize)

3: Copy bytes using IOUtils

IOUtils.copyBytes(inputStream, outputStream, buffer);

• Copy bytes from InputStream to OutputStream

• Hadoop’s IOUtils makes the task simple

– buffer parameter specifies number of bytes to buffer at a time

4: Close Stream

} finally {

IOUtils.closeStream(input);

• Utilize IOUtils to avoid boiler plate code that catches IOException

ReadFile.java Example

public class ReadFile {

public static void main(String[] args) throws IOException {

Path fileToRead = new Path("/user/sample/sonnets.txt");

FileSystem fs = FileSystem.get(new Configuration()); // 1: Open FileSystem

InputStream input = null;

input = fs.open(fileToRead); // 2: Open InputStream

IOUtils.copyBytes(input, System.out, 4096); // 3: Copy from Input to Output

} finally {

IOUtils.closeStream(input); // 4: Close stream

$ yarn jar my-hadoop-examples.jar hdfs.ReadFile

Reading Data - Seek

• FileSystem.open returns FSDataInputStream

– Extension of java.io.DataInputStream

– Supports random access and reading via interfaces:

• PositionedReadable : read chunks of the stream

• Seekable : seek to a particular position in the stream

Seeking to a Position

• FSDataInputStream implements Seekableinterface– void seek(long pos) throws IOException

• Seek to a particular position in the file

• Next read will begin at that position• If you attempt to seek past the file boundary IOException is emitted

• Somewhat expensive operation – strive for streaming and not seeking

– long getPos() throws IOException• Returns the current position/offset from the beginning of the

stream/file

SeekReadFile.java Examplepublic class SeekReadFile {

public static void main(String[] args) throws IOException {

Path fileToRead = new Path("/user/sample/readMe.txt");

FileSystem fs = FileSystem.get(new Configuration());

FSDataInputStream input = null;

input = fs.open(fileToRead);

System.out.print("start postion=" + input.getPos() + ": ");

IOUtils.copyBytes(input, System.out, 4096, false);

input.seek(11);

input.seek(0);

} finally {

IOUtils.closeStream(input);

Run SeekReadFile Example

$ yarn jar my-hadoop-examples.jar hdfs.SeekReadFile

start position=0: Hello from readme.txt

start position=11: readme.txt

start position=0: Hello from readme.txt

Write Data

1. Create FileSystem instance

2. Open OutputStream

– FSDataOutputStream in this case

– Open a stream directly to a Path from FileSystem

– Creates all needed directories on the provided path

3. Copy data using IOUtils

WriteToFile.java Example

public class WriteToFile {public static void main(String[] args) throws IOException {

String textToWrite = "Hello HDFS! Elephants are awesome!\n";InputStream in = new BufferedInputStream(

new ByteArrayInputStream(textToWrite.getBytes()));Path toHdfs = new Path("/user/sample/writeMe.txt");Configuration conf = new Configuration();FileSystem fs = FileSystem.get(conf); // 1: Create FileSystem instanceFSDataOutputStream out = fs.create(toHdfs); // 2: Open OutputStreamIOUtils.copyBytes(in, out, conf); // 3: Copy Data

Run WriteToFile

$ yarn jar my-hadoop-examples.jar hdfs.WriteToFile

$ hdfs dfs -cat /user/sample/writeMe.txt

Hello HDFS! Elephants are awesome!

MapReduce and YARN

Hadoop MapReduce

• Model for processing large amounts of data in parallel– On commodity hardware– Lots of nodes

• Derived from functional programming– Map and reduce functions

• Can be implemented in multiple languages– Java, C++, Ruby, Python (etc...)

The MapReduce Model

• Imposes key-value input/output• Defines map and reduce functions

map: (K1,V1) → list (K2,V2)reduce: (K2,list(V2)) → list (K3,V3)1. Map function is applied to every input key-value pair2. Map function generates intermediate key-value pairs3. Intermediate key-values are sorted and grouped by key4. Reduce is applied to sorted and grouped intermediate key-values5. Reduce emits result key-values

MapReduce Programming Model

MapReduce in Hadoop (1)

MapReduce in Hadoop (2)

MapReduce Framework

• Takes care of distributed processing and coordination

• Scheduling– Jobs are broken down into smaller chunks called tasks.– These tasks are scheduled

• Task Localization with Data– Framework strives to place tasks on the nodes that host

the segment of data to be processed by that specific task– Code is moved to where the data is

MapReduce Framework

• Error Handling

– Failures are an expected behavior so tasks are automatically re-tried on other machines

• Data Synchronization

– Shuffle and Sort barrier re-arranges and moves data between machines

– Input and output are coordinated by the framework

Map Reduce 2.0 on YARN

• Yet Another Resource Negotiator (YARN)• Various applications can run on YARN

– MapReduce is just one choice (the main choice at this point)– http://wiki.apache.org/hadoop/PoweredByYarn

• YARN was designed to address issues with MapReduce1– Scalability issues (max ~4,000 machines)– Inflexible Resource Management

• MapReduce1 had slot based model

MapReduce1 vs. YARN

• MapReduce1 runs on top of JobTracker and TaskTracker daemons– JobTracker schedules tasks, matches task with TaskTrackers– JobTracker manages MapReduce Jobs, monitors progress– JobTracker recovers from errors, restarts failed and slow tasks

• MapReduce1 has inflexible slot-based memory management model– Each TaskTracker is configured at start-up to have N slots– A task is executed in a single slot– Slots are configured with maximum memory on cluster start-up– The model is likely to cause over and under utilization issues

MapReduce1 vs. YARN (cont.)

• YARN addresses shortcomings of MapReduce1– JobTracker is split into 2 daemons

• ResourceManager - administers resources on the cluster• ApplicationMaster - manages applications such as MapReduce

– Fine-Grained memory management model• ApplicationMaster requests resources by asking for

“containers” with a certain memory limit (ex 2G)• YARN administers these containers and enforces memory usage• Each Application/Job has control of how much memory to

request

Daemons

• YARN Daemons– Node Manger

• Manages resources of a single node• There is one instance per node in the cluster

– Resource Manager• Manages Resources for a Cluster• Instructs Node Manager to allocate resources• Application negotiates for resources with Resource Manager• There is only one instance of Resource Manager

• MapReduce Specific Daemon– MapReduce History Server

• Archives Jobs’ metrics and meta-data

Old vs. New Java API

• There are two flavors of MapReduce API which became known as Old and New

• Old API classes reside under– org.apache.hadoop.mapred

• New API classes can be found under– org.apache.hadoop.mapreduce– org.apache.hadoop.mapreduce.lib

• We will use new API exclusively• New API was re-designed for easier evolution• Early Hadoop versions deprecated old API but deprecation was removed• Do not mix new and old API

Developing First MapReduce Job

MapReduce

• Divided in two phases– Map phase

– Reduce phase

• Both phases use key-value pairs as input and output

• The implementer provides map and reduce functions

• MapReduce framework orchestrates splitting, and distributing of Map and Reduce phases– Most of the pieces can be easily overridden

MapReduce

• Job – execution of map and reduce functions to accomplish a task

– Equal to Java’s main

• Task – single Mapper or Reducer

– Performs work on a fragment of data

Map Reduce Flow of Data

First Map Reduce Job

• StartsWithCount Job

– Input is a body of text from HDFS

• In this case hamlet.txt

– Split text into tokens

– For each first letter sum up all occurrences

– Output to HDFS

Word Count Job

Starts With Count Job

1. Configure the Job– Specify Input, Output, Mapper, Reducer and Combiner

2. Implement Mapper– Input is text – a line from hamlet.txt– Tokenize the text and emit first character with a count of

1 - <token, 1>

3. Implement Reducer– Sum up counts for each letter– Write out the result to HDFS

4. Run the job

1: Configure Job

• Job class– Encapsulates information about a job– Controls execution of the job

Job job = Job.getInstance(getConf(), "StartsWithCount");

• A job is packaged within a jar file– Hadoop Framework distributes the jar on your behalf– Needs to know which jar file to distribute– The easiest way to specify the jar that your job resides in is by calling

job.setJarByClassjob.setJarByClass(getClass());

– Hadoop will locate the jar file that contains the provided class

1: Configure Job - Specify Input

TextInputFormat.addInputPath(job, new Path(args[0]));

job.setInputFormatClass(TextInputFormat.class);

• Can be a file, directory or a file pattern– Directory is converted to a list of files as an input

• Input is specified by implementation of InputFormat - in this case TextInputFormat– Responsible for creating splits and a record reader– Controls input types of key-value pairs, in this case LongWritable

and Text– File is broken into lines, mapper will receive 1 line at a time

Side Note – Hadoop IO Classes

• Hadoop uses it’s own serialization mechanism for writing data in and out of network, database or files– Optimized for network serialization– A set of basic types is provided– Easy to implement your own

• org.apache.hadoop.io package– LongWritable for Long– IntWritable for Integer– Text for String– Etc...

1: Configure Job – Specify Output

TextOutputFormat.setOutputPath(job, new Path(args[1]));job.setOutputFormatClass(TextOutputFormat.class);

• OutputFormat defines specification for outputting data from Map/Reduce job

• Count job utilizes an implemenation ofOutputFormat - TextOutputFormat

– Define output path where reducer should place its output• If path already exists then the job will fail

– Each reducer task writes to its own file• By default a job is configured to run with a single reducer

– Writes key-value pair as plain text

1: Configure Job – Specify Output

job.setOutputKeyClass(Text.class);job.setOutputValueClass(IntWritable.class);

• Specify the output key and value types for both mapper and reducer functions– Many times the same type– If types differ then use

• setMapOutputKeyClass()• setMapOutputValueClass()

1: Configure Job

• Specify Mapper, Reducer and Combiner– At a minimum will need to implement these classes

– Mappers and Reducer usually have same output key

job.setMapperClass(StartsWithCountMapper.class);

job.setReducerClass(StartsWithCountReducer.class);

job.setCombinerClass(StartsWithCountReducer.class);

1: Configure Job

• job.waitForCompletion(true)

– Submits and waits for completion

– The boolean parameter flag specifies whether output should be written to console

– If the job completes successfully ‘true’ is returned, otherwise ‘false’ is returned

Our Count Job is configured to

• Chop up text files into lines• Send records to mappers as key-value pairs

– Line number and the actual value

• Mapper class is StartsWithCountMapper– Receives key-value of <IntWritable,Text>– Outputs key-value of <Text, IntWritable>

• Reducer class is StartsWithCountReducer– Receives key-value of <Text, IntWritable>– Outputs key-values of <Text, IntWritable> as text

• Combiner class is StartsWithCountReducer

1: Configure Count Job

public class StartsWithCountJob extends Configured implements Tool{@Overridepublic int run(String[] args) throws Exception {

Job job = Job.getInstance(getConf(), "StartsWithCount");job.setJarByClass(getClass());

// configure output and input sourceTextInputFormat.addInputPath(job, new Path(args[0]));job.setInputFormatClass(TextInputFormat.class);

// configure mapper and reducerjob.setMapperClass(StartsWithCountMapper.class);job.setCombinerClass(StartsWithCountReducer.class);job.setReducerClass(StartsWithCountReducer.class);

StartsWithCountJob.java (cont.)

// configure outputTextOutputFormat.setOutputPath(job, new Path(args[1]));job.setOutputFormatClass(TextOutputFormat.class);job.setOutputKeyClass(Text.class);job.setOutputValueClass(IntWritable.class);

return job.waitForCompletion(true) ? 0 : 1;}public static void main(String[] args) throws Exception {

int exitCode = ToolRunner.run(new StartsWithCountJob(), args);

System.exit(exitCode);}

2: Implement Mapper class

• Class has 4 Java Generics parameters– (1) input key (2) input value (3) output key (4) output value– Input and output utilizes hadoop’s IO framework

• org.apache.hadoop.io

• Your job is to implement map() method– Input key and value– Output key and value– Logic is up to you

• map() method injects Context object, use to:– Write output– Create your own counters

2: Implement Mapper

public class StartsWithCountMapper extends Mapper<LongWritable, Text, Text, IntWritable> {

private final static IntWritable countOne = new IntWritable(1);private final Text reusableText = new Text();

@Overrideprotected void map(LongWritable key, Text value, Context context)

throws IOException, InterruptedException {StringTokenizer tokenizer = new StringTokenizer(value.toString());while (tokenizer.hasMoreTokens()) {

reusableText.set(tokenizer.nextToken().substring(0, 1));context.write(reusableText, countOne);

3: Implement Reducer

• Analogous to Mapper – generic class with four types– (1) input key (2) input value (3) output key (4) output value– The output types of map functions must match the input types of reduce

function• In this case Text and IntWritable

– Map/Reduce framework groups key-value pairs produced by mapper by key

• For each key there is a set of one or more values• Input into a reducer is sorted by key• Known as Shuffle and Sort

– Reduce function accepts key->setOfValues and outputs key-value pairs• Also utilizes Context object (similar to Mapper)

3: Implement Reducer

public class StartsWithCountReducer extendsReducer<Text, IntWritable, Text, IntWritable> {

@Overrideprotected void reduce(Text token,

Iterable<IntWritable> counts,Context context) throws IOException, InterruptedException {int sum = 0;

for (IntWritable count : counts) {sum+= count.get();

}context.write(token, new IntWritable(sum));

3: Reducer as a Combiner

• Combine data per Mapper task to reduce amount of data transferred to reduce phase

• Reducer can very often serve as a combiner– Only works if reducer’s output key-value pair types are the

same as mapper’s output types

• Combiners are not guaranteed to run– Optimization only– Not for critical logic

• More about combiners later

4: Run Count Job

$ yarn jar my-hadoop-examples.jar \mr.wordcount.StartsWithCountJob \/user/sample/readme.txt \/user/sample/wordcount

Output of Count Job

• Output is written to the configured output directory

– /user/sample/wordCount/

• One output file per Reducer

– part-r-xxxxx format

• Output is driven by TextOutputFormat class

$yarn command

• yarn script with a class argument command launches a JVM and executes the provided Job

$ yarn jar HadoopSamples.jar \mr.wordcount.StartsWithCountJob \/user/sample/hamlet.txt \/user/sample/wordcount/

• You could use straight java but yarn script is more convenient– Adds hadoop’s libraries to CLASSPATH– Adds hadoop’s configurations to Configuration object

• Ex: core-site.xml, mapred-site.xml, *.xml

– You can also utilize $HADOOP_CLASSPATH environment variable

Input and Output

MapReduce Theory

• Map and Reduce functions produce input and output– Input and output can range from Text to Complex data

structures– Specified via Job’s configuration– Relatively easy to implement your own

• Generally we can treat the flow asmap: (K1,V1) → list (K2,V2)reduce: (K2,list(V2)) → list (K3,V3)– Reduce input types are the same as map output types

Map Reduce Flow of Data

map: (K1,V1) → list (K2,V2)

reduce: (K2,list(V2)) → list (K3,V3)

Key and Value Types

• Utilizes Hadoop’s serialization mechanism for writing data in and out of network, database or files– Optimized for network serialization– A set of basic types is provided– Easy to implement your own

• Extends Writable interface– Framework’s serialization mechanisms– Defines how to read and write fields– org.apache.hadoop.io package

Key and Value Types

• Keys must implement WritableComparableinterface– Extends Writable and java.lang.Comparable<T>– Required because keys are sorted prior reduce phase

• Hadoop is shipped with many default implementations of WritableComparable<T>– Wrappers for primitives (String, Integer, etc...)– Or you can implement your own

WritableComparable<T>

Implementations

Hadoop’s Class Explanation

BooleanWritable Boolean implementation

BytesWritable Bytes implementation

DoubleWritable Double implementation

FloatWritable Float implementation

IntWritable Int implementation

LongWritable Long implementation

NullWritable Writable with no data

Implement Custom

WritableComparable<T>

• Implement 3 methods– write(DataOutput)

• Serialize your attributes

– readFields(DataInput)• De-Serialize your attributes

– compareTo(T)• Identify how to order your objects• If your custom object is used as the key it will be sorted

prior to reduce phase

BlogWritable – Implemenation

of WritableComparable<T>

public class BlogWritable implements

WritableComparable<BlogWritable> {

private String author;

private String content;

public BlogWritable(){}

public BlogWritable(String author, String content) {

this.author = author;

this.content = content;

public String getAuthor() {

return author;

public String getContent() {

return content;

BlogWritable – Implemenation

of WritableComparable<T>

@Override

public void readFields(DataInput input) throws IOException {

author = input.readUTF();

content = input.readUTF();

@Override

public void write(DataOutput output) throws IOException {

output.writeUTF(author);

output.writeUTF(content);

@Override

public int compareTo(BlogWritable other) {

return author.compareTo(other.author);

Mapper

• Extend Mapper class– Mapper<KeyIn, ValueIn, KeyOut, ValueOut>

• Simple life-cycle1. The framework first calls setup(Context)2. for each key/value pair in the split:

• map(Key, Value, Context)3. Finally cleanup(Context) is called

InputSplit

• Splits are a set of logically arranged records– A set of lines in a file– A set of rows in a database table

• Each instance of mapper will process a single split– Map instance processes one record at a time

• map(k,v) is called for each record

• Splits are implemented by extending InputSplitclass

InputSplit

• Framework provides many options for InputSplit implementations

– Hadoop’s FileSplit

– HBase’s TableSplit

• Don’t usually need to deal with splits directly

– InputFormat’s responsibility

Combiner

• Runs on output of map function• Produces outpu

map: (K1,V1) → list (K2,V2)combine: (K2,list(V2)) → list (K2,V2)reduce: (K2,list(V2)) → list (K3,V3)

• Optimization to reduce bandwidth– NO guarantees on being called– Maybe only applied to a sub-set of map outputs

• Often is the same class as Reducer• Each combine processes output from a single split

Combiner Data Flow

Sample StartsWithCountJob

Run without Combiner

Sample StartsWithCountJob

Run with Combiner

Specify Combiner Function

• To implement Combiner extend Reducer class

• Set combiner on Job class

job.setCombinerClass(StartsWithCountReducer.class);

Reducer

• Extend Reducer class– Reducer<KeyIn, ValueIn, KeyOut, ValueOut>– KeyIn and ValueIn types must match output types of mapper

• Receives input from mappers’ output– Sorted on key– Grouped on key of key-values produced by mappers– Input is directed by Partitioner implementation

• Simple life-cycle – similar to Mapper– The framework first calls setup(Context)– for each key → list(value) calls

• reduce(Key, Values, Context)

– Finally cleanup(Context) is called

Reducer

• Can configure more than 1 reducer– job.setNumReduceTasks(10);– mapreduce.job.reduces property

• job.getConfiguration().setInt("mapreduce.job.reduces", 10)

• Partitioner implementation directs key-value pairs to the proper reducer task– A partition is processed by a reduce task

• # of partitions = # or reduce tasks

– Default strategy is to hash key to determine partition

implemented by HashPartitioner<K, V>

Partitioner Data Flow

HashPartitioner

public class HashPartitioner<K, V> extends Partitioner<K, V> {public int getPartition(K key, V value, int numReduceTasks) {

return (key.hashCode() & Integer.MAX_VALUE) % numReduceTasks;}

• Calculate Index of Partition:– Convert key’s hash into non-negative number

• Logical AND with maximum integer value

– Modulo by number of reduce tasks

• In case of more than 1 reducer– Records distributed evenly across available reduce tasks

• Assuming a good hashCode() function

– Records with same key will make it into the same reduce task– Code is independent from the # of partitions/reducers specified

Custom Partitioner

public class CustomPartitionerextends Partitioner<Text, BlogWritable>{

@Overridepublic int getPartition(Text key, BlogWritable blog,

int numReduceTasks) {int positiveHash =blog.getAuthor().hashCode()& Integer.MAX_VALUE;

//Use author’s hash only, AND with//max integer to get a positive value

return positiveHash % numReduceTasks;}

• All blogs with the same author will end up in the same reduce task

Component Overview

Improving Hadoop

• Core Hadoop is complicated so some tools were added to make things easier

• Hadoop Distributions collect these tools and release them as a whole package

Noticeable Distributions

• Cloudera

• MapR

• HortonWorks

• Amazon EMR

HADOOP Technology Eco System

Improving Programmability

• Pig: Programming language that simplifies Hadoop actions: loading, transforming and sorting data

• Hive: enables Hadoop to operate as data warehouse using SQL-like syntax.

• “is a platform for analyzing large data sets that consists of a high-level language for expressing data analysis programs, coupled with infrastructure for evaluating these programs. “

• Top Level Apache Project– http://pig.apache.org

• Pig is an abstraction on top of Hadoop– Provides high level programming language designed for data processing– Converted into MapReduce and executed on Hadoop Clusters

• Pig is widely accepted and used– Yahoo!, Twitter, Netflix, etc...

Pig and MapReduce

• MapReduce requires programmers– Must think in terms of map and reduce functions– More than likely will require Java programmers

• Pig provides high-level language that can be used by– Analysts– Data Scientists– Statisticians– Etc...

• Originally implemented at Yahoo! to allow analysts to access data

Pig’s Features

• Join Datasets

• Sort Datasets

• Filter

• Data Types

• Group By

• User Defined Functions

Pig’s Use Cases

• Extract Transform Load (ETL)– Ex: Processing large amounts of log data

• clean bad entries, join with other data-sets

• Research of “raw” information– Ex. User Audit Logs

– Schema maybe unknown or inconsistent

– Data Scientists and Analysts may like Pig’s data transformation paradigm

Pig Components

• Pig Latin– Command based language– Designed specifically for data transformation and flow expression

• Execution Environment– The environment in which Pig Latin commands are executed– Currently there is support for Local and Hadoop modes

• Pig compiler converts Pig Latin to MapReduce– Compiler strives to optimize execution– You automatically get optimization improvements with Pig updates

Pig Code Example

• Data Warehousing Solution built on top of Hadoop

• Provides SQL-like query language named HiveQL– Minimal learning curve for people with SQL expertise

– Data analysts are target audience

• Early Hive development work started at Facebook in 2007

• Today Hive is an Apache project under Hadoop– http://hive.apache.org

Hive Provides

• Ability to bring structure to various data formats

• Simple interface for ad hoc querying, analyzing and summarizing large amounts of data

• Access to files on various data stores such as HDFS and HBase

When not to use Hive

• Hive does NOT provide low latency or real time queries

• Even querying small amounts of data may take minutes

• Designed for scalability and ease-of-use rather than low latency responses

• Translates HiveQL statements into a set of MapReduce Jobs which are then executed on a Hadoop Cluster

Hive Metastore

• To support features like schema(s) and data partitioning Hive keeps its metadata in a Relational Database

– Packaged with Derby, a lightweight embedded SQL DB• Default Derby based is good for evaluation an testing

• Schema is not shared between users as each user has their own instance of embedded Derby

• Stored in metastore_db directory which resides in the directory that hive was started from

– Can easily switch another SQL installation such as MySQL

Hive Architecture

1: Create a Table

• Let’s create a table to store data from $PLAY_AREA/data/user-posts.txt

1: Create a Table

2: Load Data Into a Table

3: Query Data

Databases and DB Connectivity

• HBase: column oriented database that runs on HDFS.

• Sqoop: a tool designed to import data from relational databases (HDFS or Hive).

• Distributed column-oriented database built on top of HDFS, providing Big Table-like capabilities for Hadoop

When do we use HBase?

• Huge volumes of randomly accessed data.

• HBase is at its best when it’s accessed in a distributed fashion by many clients.

• Consider HBase when you’re loading data by key, searching data by key (or range), serving data by key, querying data by key or when storing data by row that doesn’t conform well to a schema.

When not to use Hbase

• HBase doesn’t use SQL, don’t have an optimizer, doesn’t support in transactions or joins.

• If you need those things, you probably can’t use Hbase

HBase Example

Example: create ‘blogposts’, ‘post’, ‘image’ ---create table

put ‘blogposts’, ‘id1′, ‘post:title’, ‘Hello World’ ---insert value

put ‘blogposts’, ‘id1′, ‘post:body’, ‘This is a blog post’ ---insert value

put ‘blogposts’, ‘id1′, ‘image:header’, ‘image1.jpg’ ---insert value

get ‘blogposts’, ‘id1′ ---select records

• Sqoop is a command line tool for moving data from RDBMS to Hadoop

• Uses MapReduce program or Hive to load the data

• Can also export data from HBase to RDBMS

• Comes with connectors to MySQL, PostgreSQL, Oracle, SQL Server and DB2.

Example:

$bin/sqoop import --connect 'jdbc:sqlserver://10.80.181.127;username=dbuser;password=dbpasswd;database=tpch' \

--table lineitem --hive-import

$bin/sqoop export --connect 'jdbc:sqlserver://10.80.181.127;username=dbuser;password=dbpasswd;database=tpch' --table lineitem --export-dir /data/lineitemData

Improving Hadoop – More useful tools

• For improving coordination: Zookeeper

• For Improving log collection: Flume

• For improving scheduling/orchestration: Oozie

• For Monitoring: Chukwa

• For Improving UI: Hue

ZooKeeper

• ZooKeeper is a centralized service for maintaining configuration information, naming, providing distributed synchronization, and providing group services

• It allows distributed processes to coordinate with each other through a shared hierarchal namespace which is organized similarly to a standard file system

• ZooKeeper stamps each update with a number that reflects the order of all ZooKeeper transactions

• Flume is a distributed system for collecting log data from many sources, aggregating it, and writing it to HDFS

• Flume maintains a central list of ongoing data flows, stored redundantly in Zookeeper.

• Oozie is a workflow scheduler system to manage Hadoop jobs

• Oozie workflow is a collection of actions arranged in a control dependency DAG specifying a sequence of actions execution

• The Oozie Coordinator system allows the user to define workflow execution bases on intervals or on-demand

Fast and general MapReduce-like engine for large-scale data processing

• Fast

– In memory data storage for very fast interactive queries Up to 100 times faster then Hadoop

• General

– Unified platform that can combine: SQL, Machine Learning , Streaming , Graph & Complex analytics

• Ease of use

– Can be developed in Java, Scala or Python

• Integrated with Hadoop

– Can read from HDFS, HBase, Cassandra, and any Hadoop data source.

Spark is the Most Active Open Source

Project in Big Data

The Spark Community

Key Concepts

Resilient Distributed Datasets

• Collections of objects spread across a cluster, stored in RAM or on Disk

• Built through parallel transformations

• Automatically rebuilt on failure

Operations

• Transformations(e.g. map, filter, groupBy)

• Actions(e.g. count, collect, save)

Write programs in terms of transformations on

distributed datasets

Unified Platform

• Continued innovation bringing new functionality, e.g.:• Java 8 (Closures, LambaExpressions)• Spark SQL (SQL on Spark, not just Hive)• BlinkDB(Approximate Queries)• SparkR(R wrapper for Spark)

Language Support

Data Sources

• Local Files– file:///opt/httpd/logs/access_log

• S3• Hadoop Distributed Filesystem

– Regular files, sequence files, any other Hadoop InputFormat

• Hbase• Can also read from any other Hadoop data source.

Resilient Distributed Datasets (RDD)

• Spark revolves around RDDs

• Fault-tolerant collection of elements that can be operated on in parallel

– Parallelized Collection: Scala collection which is run in parallel

– Hadoop Dataset: records of files supported by Hadoop

Hadoop Tools

Hadoop cluster

Cluster of machine running Hadoop at Yahoo! (credit: Yahoo!)

Big Data and NoSQL

The Challenge

• We want scalable, durable, high volume, high velocity, distributed data storage that can handle non-structured data and that will fit our specific need

• RDBMS is too generic and doesn’t cut it any more –it can do the job but it is not cost effective to our usages

The Solution: NoSQL

• Let’s take some parts of the standard RDBMS out to and design the solution to our specific uses

• NoSQL databases have been around for ages under different names/solutions

Example Comparison: RDBMS vs. Hadoop

Typical Traditional RDBMS Hadoop

Data Size Gigabytes Petabytes

Access Interactive and Batch Batch – NOT Interactive

Updates Read / Write many times Write once, Read many times

Structure Static Schema Dynamic Schema

Scaling Nonlinear Linear

Query Response

Can be near immediate Has latency (due to batch processing)

Best Used For:

Structured or Not (Flexibility)

Scalability of Storage/Compute

Complex Data Processing

Cheaper compared to RDBMS

Relational Database

Best Used For:

Interactive OLAP Analytics

(<1sec)

Multistep Transactions

100% SQL Compliance

Best when used together

Hadoop And Relational Database

The NOSQL Movement

• NOSQL is not a technology – it’s a concept.

• We need high performance, scale out abilities or an agile structure.

• We are now willing to sacrifice our sacred cows: consistency, transactions.

• Over 200 different brands and solutions (http://nosql-database.org/).

NoSQL, NOSQL or NewSQL

• NoSQL is not No to SQL

• NoSQL is not Never SQL

• NOSQL = Not Only SQL

Why NoSQL?

• Some applications need very few database features, but need high scale.

• Desire to avoid data/schema pre-design altogether for simple applications.

• Need for a low-latency, low-overhead API to access data.

• Simplicity -- do not need fancy indexing – just fast lookup by primary key.

Why NoSQL? (cont.)

• Developer friendly, DBAs not needed (?).

• Schema-less.

• Agile: non-structured (or semi-structured).

• In Memory.

• No (or loose) Transactions.

• No joins.

Is NoSQL a RDMS Replacement?

NOWell... Sometimes it does…

RDBMS vs. NoSQL

Rationale for choosing a persistent store:Relational Architecture NoSQL Architecture

High value, high density, complexData

Low value, low density, simple data

Complex data relationships Very simple relationships

Schema-centric Schema-free, unstructured or semistructured Data

Designed to scale up & out Distributed storage and processing

Lots of general purposefeatures/functionality

Stripped down, special purposedata store

High overhead ($ per operation) Low overhead ($ per operation)

Scalability and Consistency

Scalability

• NoSQL is sometimes very easy to scale out

• Most have dynamic data partitioning and easy data distribution

• But distributed system always come with a price: The CAP Theorem and impact on ACID transactions

ACID Transactions

Most DBMS are built with ACID transactions in mind:• Atomicity: All or nothing, performs write operations as a single

transaction• Consistency: Any transaction will take the DB from one

consistent state to another with no broken constraints, ensures replicas are identical on different nodes

• Isolation: Other operations cannot access data that has been modified during a transaction that has not been completed yet

• Durability: Ability to recover the committed transaction updates against any kind of system failure (transaction log)

ACID Transactions (cont.)

• ACID is usually implemented by a locking mechanism/manager

• Distributed systems central locking can be a bottleneck in that system

• Most NoSQL does not use/limit the ACID transactions and replaces it with something else…

• The CAP theorem states that in a distributed/partitioned application, you can only pick two of the following three characteristics:

– Consistency.

– Availability.

– Partition Tolerance.

CAP Theorem

CAP in Practice

NoSQL BASE

• NoSQL usually provide BASE characteristics instead of ACID.

BASE stands for:– Basically Available– Soft State– Eventual Consistency

• It means that when an update is made in one place, the other partitions will see it over time - there might be an inconsistency window

• read and write operations complete more quickly, lowering latency

Eventual Consistency

Types of NoSQL

NoSQL Taxonomy

Type Examples

Key-Value Store

Document Store

Column Store

Graph Store

SQL comfort zone

Complex

Typical

ValueColumn

DATABASE

Document

Database Performance

NoSQL Map

Key Value Store

• Distributed hash tables.• Very fast to get a single value.• Examples:

– Amazon DynamoDB– Berkeley DB– Redis– Riak– Cassandra

Document Store

• Similar to Key/Value, but value is a document

• JSON or something similar, flexible schema

• Agile technology

• Examples:– MongoDB

– CouchDB

– CouchBase

Column Store

• One key, multiple attributes

• Hybrid row/column

• Examples:– Google BigTable

– Hbase

– Amazon’s SimpleDB

– Cassandra

How Records are Organized?

• This is a logical table in RDBMS systems

• Its physical organization is just like the logical one: column by column, row by row

Col 1 Col 2 Col 3 Col 4

Query Data

• When we query data, records are read at the order they are organized in the physical structure

• Even when we query a single column, we still need to read the entire table and extract the column

Col 1 Col 2 Col 3 Col 4

Select Col2 From MyTable

Select *From MyTable

How Does Column Store Keep Data

Organization in row store Organization in column store

Select Col2 From MyTable

Graph Store

• Inspired by Graph Theory• Data model: Nodes, relationships, properties

on both• Relational Database have very hard time to

represent a graph in the Database• Example:

– Neo4j– InfiniteGraph– RDF

• An abstract representation of a set of objects where some pairs are connected by links.

• Object (Vertex, Node) – can have attributes like name and value

• Link (Edge, Arc, Relationship) – can have attributes like type and name or date

What is Graph

NODEEdge

Graph Types

Undirected Graph

Directed Graph

Pseudo Graph

Multi Graph

NODEEdge

NODE NODE

More Graph Types

Weighted Graph

Labeled Graph

Property Graph

NODE10

NODELike

NODE NODEfriend, date 2015

Name:yosi,

Age:40

Name:ami,

Age:30

Relationships

ID:1TYPE:F

NAME:alice

ID:2TYPE:M

NAME:bob

ID:1TYPE:G

NAME:NoSQL

ID:1TYPE:F

NAME:dafna

TYPE: member

Since:2012

Conclusion

• The Challenge of Big Data

• Hadoop Basics: HDFS, MapReduce and YARN

• Improving Hadoop and Tools

• NoSQL and RDBMS

the hadoop ecosystem for developers

big data challenge

volume big data

big data projects

big data solutions

agenda big data

data management

different definitions

examples of big data

Technology

hadoop and their ecosystem ppt

hadoop ecosystem fundamentals - big data€¦ · hadoop...

challenges to error diagnosis in hadoop ecosystemsthe hadoop...

hands-on hadoop: an intro for web developers

hadoop & ecosystem - an overview

hadoop ecosystem nttdata osc15tk

hadoop ecosystem - hadoop 生態系

hadoop architecture and ecosystem - polito

introduction to hadoop ecosystem

hadoop ecosystem overview - inspiring...

hadoop - architectural road map for hadoop ecosystem

intro hadoop ecosystem components, hadoop ecosystem tools

hadoop&bigdata:craingthe...

hadoop and their ecosystem

the hadoop ecosystem & hbase -...

druid at hadoop ecosystem

big data and hadoop ecosystem

hadoop ecosystem framework n hadoop in live environment

spotify: from 1 to 100 hadoop developers

the hadoop ecosystem - york universitymanaging the whole...