Apache Hadoop 1.1

• Before 2004 “Google have implemented
hundreds of special-purpose computations
that process large amounts of raw data, such
as crawled documents, web request logs, etc.,
to compute various kinds of derived data, such
as inverted indices etc.”
• Nutch search system at 2004 was effectively
limited to 100M web pages
Use Cases

• 2002: Doug Cutting started Nutch: crawler & search
system
• 2003: GoogleFS paper
• 2004: Start of NDFS project (Nutch Distributed FS)
• 2004: Google MapReduce paper
• 2005: MapReduce implementation in Nutch
• 2006: HDFS and MapReduce to Hadoop subproject
• 2008: Yahoo! Production search index by a 10000-core
Hadoop cluster
• 2008: Hadoop – top-level Apache project
Hadoop History

• Need to process Multi Petabyte Datasets
• Need to provide framework for reliable application
execution
• Need to encapsulate nodes failures from application
developer.
– 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
Hadoop Objectives

• Hadoop Distributed File System (HDFS)
• Hadoop MapReduce
• Hadoop Common
Hadoop

• Very Large Distributed File System
– 10K nodes, 100 million files, 10 PB
• Assumes Commodity Hardware
– Files are replicated to handle hardware failure
– Detect failures and recovers from them
• Optimized for Batch Processing
– Data locations exposed so that computations can move to
where data resides
– Provides very high aggregate bandwidth
Goals of GFS/HDFS

• Data Coherency
– Write-once-read-many access model
– Client can only append to existing files
• Files are broken up into blocks
– Typically 128 MB block size
– Each block replicated on multiple DataNodes
• Intelligent Client
– Client can find location of blocks
– Client accesses data directly from DataNode
HFDS Details

• Java API
• Command Line
– hadoop dfs -mkdir /foodir
– hadoop dfs -cat /foodir/myfile.txt
– hadoop dfs -rm /foodir myfile.txt
– hadoop dfsadmin –report
– hadoop dfsadmin -decommission datanodename
• Web Interface
– http://host:port/dfshealth.jsp
HDFS User Interface

Map function
Reduce function
Run this program as a
MapReduce job
Lifecycle of a MapReduce Job

• 190+ parameters in
Hadoop
• Set manually or defaults
are used
Hadoop Configuration

Pro:
• Cheap components
• Replication
• Fault tolerance
• Parallel processing
• Free license
• Linear scalability
• Amazon support
Con:
• No realtime
• Difficult to add MR tasks
• File edit is not supported
• High support cost
Summary

• Distributed Grep
• Count of URL Access Frequency
• Reverse Web-Link Graph
• Inverted Index
Examples

• Streaming
• Hive
• Pig
• HBase
Hadoop

API to MapReduce that uses Unix standard streams
as the interface between Hadoop and your program
MAP: map.rb
#!/usr/bin/env ruby
STDIN.each_line do |line|
val = line
year, temp, q = val[15,4], val[87,5], val[92,1]
puts "#{year}t#{temp}" if (temp != "+9999" && q =~ /[01459]/)
end
% cat input/ncdc/sample.txt | map.rb
1950 +0000
1950 +0022
1950 -0011
1949 +0111
1949 +0078
LOCAL EXECUTION
Hadoop Streaming (1)

REDUCE: reduce.rb
#!/usr/bin/env ruby
last_key, max_val = nil, 0
STDIN.each_line do |line|
key, val = line.split("t")
if last_key && last_key != key
puts "#{last_key}t#{max_val}"
last_key, max_val = key, val.to_i
else
last_key, max_val = key, [max_val, val.to_i].max
end
end
puts "#{last_key}t#{max_val}" if last_key
% cat input/ncdc/sample.txt | map.rb | sort | reduce.rb
1949 111
1950 22
LOCAL EXECUTION

HADOOP EXECUTION
% hadoop jar
$HADOOP_INSTALL/contrib/streaming/hadoop-*-streaming.jar
-input input/ncdc/sample.txt
-output output
-mapper map.rb
-reducer reduce.rb

 Intuitive
 Make the unstructured data looks like tables regardless how
it really lay out
 SQL based query can be directly against these tables
 Generate specify execution plan for this query
 What’s Hive
 A data warehousing system to store structured data on
Hadoop file system
 Provide an easy query these data by execution Hadoop
MapReduce plans
Hive: overview

HDFS
Map Reduce
Hive: architecture

hive> SHOW TABLES;
hive> CREATE TABLE shakespeare (freq
INT, word STRING) ROW FORMAT
DELIMITED FIELDS TERMINATED BY ‘t’
STORED AS TEXTFILE;
hive> DESCRIBE shakespeare;
loading data…
hive> SELECT * FROM shakespeare LIMIT 10;
hive> SELECT * FROM shakespeare
WHERE freq > 100 SORT BY freq ASC
LIMIT 10;
Hive: shell

-- max_temp.pig: Finds the maximum temperature by year
records = LOAD 'input/ncdc/micro-tab/sample.txt'
AS (year:chararray, temperature:int, quality:int);
filtered_records = FILTER records
BY temperature != 9999
AND (quality == 0 OR quality == 1 OR quality == 4 OR quality == 5 OR quality == 9);
grouped_records = GROUP filtered_records BY year;
max_temp = FOREACH grouped_records
GENERATE group, MAX(filtered_records.temperature);
DUMP max_temp;
Pig

Initial public launch
Move from local workstation to shared, remote hosted
MySQL instance with a well-defined schema.
Service becomes more popular; too many reads hitting the
database
Add memcached to cache common queries. Reads are
now no longer strictly ACID; cached data must expire.
Service continues to grow in popularity; too many writes
hitting the database
Scale MySQL vertically by buying a beefed up server
with 16 cores, 128 GB of RAM,
and banks of 15 k RPM hard drives. Costly.
RDBMS scaling story (1)

New features increases query complexity; now we have
too many joins
Denormalize your data to reduce joins.
Rising popularity swamps the server; things are too slow
Stop doing any server-side computations.
Some queries are still too slow
Periodically prematerialize the most complex
queries, try to stop joining in most cases.
Reads are OK, but writes are getting slower and slower
Drop secondary indexes and triggers (no indexes?).
RDBMS scaling story (1)

• Tables have one primary index, the row key
• No join operators
• Data is unstructured and untyped
• No accessed or manipulated via SQL
– Programmatic access via Java, REST, or Thrift APIs
• There are three types of lookups:
– Fast lookup using row key and optional timestamp
– Full table scan
– Range scan from region start to end
Hbase: differences from RDBMS

• Automatic partitioning
• Scale linearly and automatically with new
nodes
• Commodity hardware
• Fault tolerance: Apache Zookeeper
• Batch processing: Apache Hadoop
Hbase: benefits over RDBMS

 Tables are sorted by Row
 Table schema only define it’s column families .
 Each family consists of any number of columns
 Each column consists of any number of versions
 Columns only exist when inserted, NULLs are free.
 Columns within a family are sorted and stored together
 Everything except table names are byte[]
 (Row, Family: Column, Timestamp)  Value
Row key
Column Family
valueTimeStamp
Hbase: data model

• Master
– Responsible for monitoring region servers
– Load balancing for regions
– Redirect client to correct region servers
• regionserver slaves
– Serving requests (Write/Read/Scan) of Client
– Send HeartBeat to Master
Hbase: members

$ hbase shell
> create 'test', 'data'
0 row(s) in 4.3066 seconds
> list
test
> put 'test', 'row1', 'data:1', 'value1'
> put 'test', 'row2', 'data:2', 'value2'
> scan 'test'
ROW COLUMN+CELL
row1 column=data:1, timestamp=1240148026198, value=value1
row2 column=data:2, timestamp=1240148040035, value=value2
Hbase: shell

• Amazon
• Facebook
• Google
• IBM
• Joost
• Last.fm
• New York Times
• PowerSet
• Veoh
• Yahoo!
Who uses Hadoop?

Apache Hadoop 1.1

More Related Content

What's hot (20)

Viewers also liked (20)

Similar to Apache Hadoop 1.1 (20)

More from Sperasoft (20)

Recently uploaded (20)

Apache Hadoop 1.1