BÁO CÁO

NGHIÊN CỨU GIẢI PHÁP XỬ LÝ DỮ LIỆU LỚN THEO LÔ

NHIỆM VỤ: XÂY DỰNG HỆ THỐNG CƠ SỞ DỮ LIỆU VÀ THÔNG TIN

PHỤC VỤ CÔNG TÁC NGHIÊN CỨU KHOA HỌC CỦA LỰC LƯỢNG
CÔNG AN

Hà Nội, năm 2020

 BÁO CÁO
NGHIÊN CỨU GIẢI PHÁP XỬ LÝ DỮ LIỆU LỚN THEO LÔ

NHIỆM VỤ: XÂY DỰNG HỆ THỐNG CƠ SỞ DỮ LIỆU VÀ THÔNG TIN

PHỤC VỤ CÔNG TÁC NGHIÊN CỨU KHOA HỌC CỦA LỰC LƯỢNG
CÔNG AN

Hà Nội, năm 2020

2
 MỤC LỤC
I. TỔNG QUÁT..............................................................................................4
1.1. THUẬT NGỮ...........................................................................................4
1.2. PHẠM VI THỰC HIỆN..............................................................................4
1.3. TÀI LIỆU THAM KHẢO...........................................................................4
II. NỘI DUNG CHUYÊN ĐỀ.........................................................................5
2.1. CÁC CÔNG CỤ PHÂN TÍCH MAPREDUCE VÀ HADOOP...........................5
2.1.1. HDFS............................................................................................5
2.1.2. MapReduce...................................................................................6
2.1.3. Phương pháp sử dụng MapReduce và Hadoop............................7
2.2. MAPREDUCE2.....................................................................................13
2.2.1. Tổng quan...................................................................................13
2.2.2. Nền tảng YARN...........................................................................14
2.3. APACHE SPARK...................................................................................16
2.3.1. Tổng quan về Apache Spark.......................................................16
2.3.2. Thành phần của Apache Spark...................................................16
2.3.3. Tại sao nên sử dụng Apache Spark............................................17
2.3.4. Sự đa dạng của Spark.................................................................19
III. KẾT LUẬN...........................................................................................20

iii
 I. TỔNG QUÁT
I.1. Thuật ngữ
I.2. Phạm vi thực hiện
I.3. Tài liệu tham khảo
Các tiêu chuẩn của ISO liên quan đến kỹ thuật thống kê
1. http://eprints.utm.my/id/eprint/80688/1/SaifulAdliIsmail2017_DataAnaly
sisUsingMapReduceinHadoop.pdf
2. http://www.informit.com/articles/article.aspx?p=2008905
3. http://www.informit.com/articles/article.aspx?p=2017060
4. http://www.informit.com/articles/article.aspx?p=2017061
5. https://docs.microsoft.com/en-us/azure/architecture/solution-
ideas/articles/advanced-analytics-on-big-data#pricing-calculator
6. https://dzone.com/articles/hadoop-ecosystem-hadoop-tools-for-
crunching-big-data
7. https://www.softwaretestinghelp.com/big-data-tools/
8. https://www.datamation.com/big-data/top-big-data-analytics-tools.html
9. https://isb.edu.vn/10-cong-cu-phan-tich-big-data-toi-uu/

4
 II. NỘI DUNG CHUYÊN ĐỀ
II.1. Các công cụ phân tích MapReduce và Hadoop
Hadoop (Apache Hadoop) là nên tảng mã nguồn mở được phát triển trên ngôn
ngữ Java. Đây là một dự án được tài trợ bởi Quỹ phần mềm Apache. Hadoop có
thể xử lý hàng nghìn Terabyte dữ liệu, cho phép các ứng dụng chạy trên các hệ
thống có hàng ngàn node phần cứng hạ tầng phổ thông. Một trong những lợi thế
của Hadoop là không dựa vào phần cứng để cung cấp tính sẵn sàng cao, Hadoop
cung cấp thư viện có thể phát hiện và xử lý các lỗi ở các lớp ứng dụng, được
thực thi trên mỗi cụm máy tính. Thành phần cốt lõi của Hadoop là HDFS và
MapReduce.
Hệ thống tệp phân tán HDFS hoặc Hadoop là một hệ thống được thiết kế nhằm
lưu trữ và xử lý cho một lượng rất lớn dữ liệu phi cấu trúc, phân tán. HDFS
ngoài chức năng lưu trữ dữ liệu, khả năng truy cập dữ liệu nhanh còn cho phép
tạo nhân bản, mở rộng dữ liệu theo chiều ngang một cách linh hoạt, ổn định.
MapReduce là một nền tảng phục vụ việc xử lý song song các bộ dữ liệu lớn,
trên nhiều máy tính (node) (hay được gọi chung là một cụm) 1 hoặc lưới2.
MapReduce có thể tối ưu việc xử lý dữ liệu, bằng cách xử lý những dữ liệu
được lưu trữ gần nơi triển khai hệ thống, dịch vụ trung tâm, nhằm tránh giảm
thiểu việc truyền, xử lý dữ liệu được lưu trữ ở xa. Theo Czajkowski trong bài
viết “Sorting Petabytes with MapReduce - The Next Episode”, MapReduce có
thể xử lý đồng thời nhiều tiến trình ngay cả ở quy mô dữ liệu hàng PetaByte.
II.1.1.HDFS
Một cụm HDFS bao gồm NameNode để quản lý siêu dữ liệu của cụm và
DataNodes để lưu trữ dữ liệu. Các tệp và thư mục được quản lý trên NameNode
gọi là Inode. Inode ghi các thuộc tính như các quyền, thời gian sửa đổi và truy
cập, không gian tên (Namespace) và hạn ngạch dung lượng lưu trữ. Nội dung
tệp được chia thành các khối lớn (thường là 128 megabyte) và mỗi khối của tệp
được sao chép độc lập tại nhiều DataNodes.

1
Các node cùng nằm trên cùng một mạng cục bộ (LAN) và sử dụng phần cứng
tương đồng nhau.
2
Các node được chia sẻ trên các hệ thống phân tán và sử dụng phần cứng không
đồng nhất
5
Các thành phần của Hadoop đều là các phần mềm hoạt động trên hệ điều hành
Linux, hỗ trợ triển khai đến 2000 node, từ phiên bản 2.2 trở lên, Hadoop hỗ trợ
triển khai bản gốc cho hệ điều hành Windows.
II.1.2.MapReduce
MapReduce với kiến trúc JobTracker và TaskTracker là kiến trúc ban đầu được
sử dụng để tính toán xử lý theo lô. Công cụ lập trình MapReduce được sử dụng
phổ biến do việc sử dụng đơn giản, cung cấp khả năng chịu lỗi cao khi thực thi,
hoạt động trên hệ thống quy mô lớn.
MapReduce phân chia tập dữ liệu đầu vào thành các phần độc lập được xử lý
theo cách hoàn toàn song song. Hệ thống tệp phân tán (DFS) sẽ phân vùng dữ
liệu trong nhiều máy và dữ liệu được biểu diễn dưới dạng cặp (khóa, giá trị).
MapReduce thực hiện các chức năng, đúng như tên gọi là Map (ánh xạ) và
Reduce (rút gọn), cụ thể:
- Map: Chức năng ánh xạ (được triển khai trên máy chủ chính (Master)) thực
hiện việc lấy một tập dữ liệu và chuyển đổi thành một tập dữ liệu khác và ánh
xạ các tập dữ liệu này.
- Reduce: Chức năng rút gọn kết quả ánh xạ và tổng hợp các tập dữ liệu đó
thành một tập hợp bộ dữ liệu nhỏ hơn.
Chức năng Map và Reduce có thể được thực thi một lần hoặc nhiều lần phụ
thuộc vào đặc điểm, yêu cầu của ứng dụng.

6
II.1.3.Phương pháp sử dụng MapReduce và Hadoop
Ví dụ về bài toán đếm số từ trong một quyển sách điện tử (có dạng text).
Ứng dụng MapReduce sẽ xuất ra mỗi từ dưới dạng một khóa và giá trị là số lần
từ đó xuất hiện. Cụ thể hơn, quyển sách có thể được chia thành các câu hoặc
đoạn văn, chức năng Map sẽ trả về mỗi từ được ánh xạ theo số lần xuất hiện
trong câu, chức năng Reduce sẽ kết hợp các khóa bằng cách thêm các giá trị của
chúng lại với nhau và trả ra kết quả.

7
Cấu trúc thành phần, lớp chức năng MapReduce
- FileInputFormat: Định nghĩa FileInputFormat để đọc tất cả các tệp trong
một thư mục được chỉ định (truyền đối số đầu tiên cho ứng dụng
MapReduce) và truyền đối số cho TextInputFormat.
- TextInputFormat: Mặc định InputFormat cho Hadoop là
TextInputFormat, đọc một dòng tại một thời điểm và trả về khóa dưới
dạng byte (LongWritable) và dòng văn bản làm giá trị (Text).
- Word Count Mapper: Tách dòng văn bản truyền cho InputFormat thành
các từ và đếm các từ đó mỗi lần xuất hiện (mỗi lần 01 từ xuất hiện, sẽ
đánh dấu là “1”).
- Combiner: là một phần thực hiện của Reduce.
- Word Count Reducer: Nhận ánh xạ (Map) của tất cả các từ, số lượng các
từ xuất hiện.
- TextOutputFormat: Sử dụng lớp TextOutputFormat để khai báo các khóa
là Text và các giá trị là IntWritable.
- FileOutputFormat: TextOutputFormat truyền số liệu và định dạng để
FileOutputFormat ghi kết quả vào một thư mục được chỉ định.

Viết dòng mã lệnh (code) cho ứng dụng MapReduce

Đoạn mã lệnh đặt tên là WordCount.java
package com.geekcap.hadoopexamples;

import org.apache.hadoop.conf.Configured;
import org.apache.hadoop.util.Tool;
import org.apache.hadoop.util.ToolRunner;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapred.Mapper;
import org.apache.hadoop.mapred.Reducer;
import org.apache.hadoop.mapred.JobConf;
import org.apache.hadoop.mapred.MapReduceBase;
import org.apache.hadoop.mapred.OutputCollector;
import org.apache.hadoop.mapred.Reporter;
import org.apache.hadoop.mapred.KeyValueTextInputFormat;
import org.apache.hadoop.mapred.TextOutputFormat;
import org.apache.hadoop.mapred.JobClient;
import org.apache.hadoop.mapred.FileInputFormat;
import org.apache.hadoop.mapred.FileOutputFormat;

import java.io.IOException;
import java.util.Iterator;
import java.util.StringTokenizer;

public class WordCount extends Configured implements Tool {

public static class MapClass extends MapReduceBase

implements Mapper<LongWritable, Text, Text, IntWritable>
{
private Text word = new Text();

8
 private final static IntWritable one = new IntWritable( 1 );

public void map( LongWritable key, // Offset into the file

Text value,
OutputCollector<Text, IntWritable> output,
Reporter reporter) throws IOException
{
// Get the value as a String
String text = value.toString().toLowerCase();

// Replace all non-characters

text = text.replaceAll( "'", "" );
text = text.replaceAll( "[^a-zA-Z]", " " );

// Iterate over all of the words in the string

StringTokenizer st = new StringTokenizer( text );
while( st.hasMoreTokens() )
{
// Get the next token and set it as the text for our "word"
variable
word.set( st.nextToken() );

// Output this word as the key and 1 as the value

output.collect( word, one );
}
}
}

public static class Reduce extends MapReduceBase

implements Reducer<Text, IntWritable, Text, IntWritable>
{
public void reduce( Text key, Iterator<IntWritable> values,
OutputCollector<Text, IntWritable> output,
Reporter reporter) throws IOException
{
// Iterate over all of the values (counts of occurrences of
this word)
int count = 0;
while( values.hasNext() )
{
// Add the value to our count
count += values.next().get();
}

// Output the word with its count (wrapped in an IntWritable)

output.collect( key, new IntWritable( count ) );
}
}

public int run(String[] args) throws Exception

{
// Create a configuration
Configuration conf = getConf();

// Create a job from the default configuration that will use the
WordCount class
JobConf job = new JobConf( conf, WordCount.class );

// Define our input path as the first command line argument and our
output path as the second
Path in = new Path( args[0] );

9
 Path out = new Path( args[1] );

// Create File Input/Output formats for these paths (in the job)
FileInputFormat.setInputPaths( job, in );
FileOutputFormat.setOutputPath( job, out );

// Configure the job: name, mapper, reducer, and combiner

job.setJobName( "WordCount" );
job.setMapperClass( MapClass.class );
job.setReducerClass( Reduce.class );
job.setCombinerClass( Reduce.class );

// Configure the output

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

// Run the job

JobClient.runJob(job);
return 0;
}

public static void main(String[] args) throws Exception

{
// Start the WordCount MapReduce application
int res = ToolRunner.run( new Configuration(),
new WordCount(),
args );
System.exit( res );
}
}

Đóng gói mã lệnh bằng Maven POM

Cấu hình file pom.xml
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>

<groupId>com.geekcap</groupId>
<artifactId>hadoop-examples</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>jar</packaging>

<name>hadoop-examples</name>
<url>http://maven.apache.org</url>

<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>

<dependencies>
<dependency>
<groupId>org.apache.hadoop</groupId>
<artifactId>hadoop-core</artifactId>
<version>0.20.205.0</version>
</dependency>

<dependency>

10
 <groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>3.8.1</version>
<scope>test</scope>
</dependency>
</dependencies>

</project>

Thực thi file POM

Thực thi file POM bằng lệnh sau: mvn clean install

Thực thi MapReduce

Thực thi MapReduce thông qua sử dụng lệnh trên môi trường Hadoop, kèm
theo tham số về đường dẫn của thư mục chứa quyển sách điện tử, cụ thể:
hadoop jar hadoop-examples-1.0-SNAPSHOT.jar
com.geekcap.hadoopexamples.WordCount ~/apps/hadoop-0.23.5/test-data output
Việc thực thi sẽ hiển thị như sau:
4:1203] Unable to load realm info from SCDynamicStore
2012-12-11 22:27:09.023 java[37044:1203] Unable to load realm info from
SCDynamicStore
12/12/11 22:27:09 WARN conf.Configuration: session.id is deprecated.
Instead, use dfs.metrics.session-id
12/12/11 22:27:09 INFO jvm.JvmMetrics: Initializing JVM Metrics with
processName=JobTracker, sessionId=
12/12/11 22:27:09 INFO jvm.JvmMetrics: Cannot initialize JVM Metrics with
processName=JobTracker, sessionId= - already initialized
12/12/11 22:27:09 WARN util.NativeCodeLoader: Unable to load native-hadoop
library for your platform... using builtin-java classes where applicable
12/12/11 22:27:09 WARN snappy.LoadSnappy: Snappy native library not loaded
12/12/11 22:27:09 INFO mapred.FileInputFormat: Total input paths to process
: 1
12/12/11 22:27:10 INFO mapreduce.JobSubmitter: number of splits:1
12/12/11 22:27:10 WARN conf.Configuration: mapred.jar is deprecated.
Instead, use mapreduce.job.jar
12/12/11 22:27:10 WARN conf.Configuration: mapred.output.value.class is
deprecated. Instead, use mapreduce.job.output.value.class
12/12/11 22:27:10 WARN conf.Configuration: mapred.job.name is deprecated.
Instead, use mapreduce.job.name
12/12/11 22:27:10 WARN conf.Configuration: mapred.input.dir is deprecated.
Instead, use mapreduce.input.fileinputformat.inputdir
12/12/11 22:27:10 WARN conf.Configuration: mapred.output.dir is deprecated.
Instead, use mapreduce.output.fileoutputformat.outputdir
12/12/11 22:27:10 WARN conf.Configuration: mapred.map.tasks is deprecated.
Instead, use mapreduce.job.maps
12/12/11 22:27:10 WARN conf.Configuration: mapred.output.key.class is
deprecated. Instead, use mapreduce.job.output.key.class
12/12/11 22:27:10 WARN conf.Configuration: mapred.working.dir is
deprecated. Instead, use mapreduce.job.working.dir
12/12/11 22:27:10 INFO mapreduce.JobSubmitter: Submitting tokens for job:
job_local_0001
12/12/11 22:27:10 INFO mapreduce.Job: The url to track the job:
http://localhost:8080/
12/12/11 22:27:10 INFO mapred.LocalJobRunner: OutputCommitter set in config
null
12/12/11 22:27:10 INFO mapreduce.Job: Running job: job_local_0001
12/12/11 22:27:10 INFO mapred.LocalJobRunner: OutputCommitter is
org.apache.hadoop.mapred.FileOutputCommitter

11
12/12/11 22:27:10 INFO mapred.LocalJobRunner: Waiting for map tasks
12/12/11 22:27:10 INFO mapred.LocalJobRunner: Starting task:
attempt_local_0001_m_000000_0
12/12/11 22:27:10 INFO mapred.Task: Using ResourceCalculatorPlugin : null
12/12/11 22:27:10 INFO mapred.MapTask: numReduceTasks: 1
12/12/11 22:27:10 INFO mapred.MapTask: (EQUATOR) 0 kvi 26214396(104857584)
12/12/11 22:27:10 INFO mapred.MapTask: mapreduce.task.io.sort.mb: 100
12/12/11 22:27:10 INFO mapred.MapTask: soft limit at 83886080
12/12/11 22:27:10 INFO mapred.MapTask: bufstart = 0; bufvoid = 104857600
12/12/11 22:27:10 INFO mapred.MapTask: kvstart = 26214396; length = 6553600
12/12/11 22:27:11 INFO mapred.LocalJobRunner:
12/12/11 22:27:11 INFO mapred.MapTask: Starting flush of map output
12/12/11 22:27:11 INFO mapred.MapTask: Spilling map output
12/12/11 22:27:11 INFO mapred.MapTask: bufstart = 0; bufend = 2027118;
bufvoid = 104857600
12/12/11 22:27:11 INFO mapred.MapTask: kvstart = 26214396(104857584); kvend
= 25353164(101412656); length = 861233/6553600
12/12/11 22:27:11 INFO mapreduce.Job: Job job_local_0001 running in uber
mode : false
12/12/11 22:27:11 INFO mapreduce.Job: map 0% reduce 0%
12/12/11 22:27:12 INFO mapred.MapTask: Finished spill 0
12/12/11 22:27:12 INFO mapred.Task: Task:attempt_local_0001_m_000000_0 is
done. And is in the process of committing
12/12/11 22:27:12 INFO mapred.LocalJobRunner:
file:/Users/shaines/apps/hadoop-0.23.5/test-data/mobydick.txt:0+1212132
12/12/11 22:27:12 INFO mapred.Task: Task 'attempt_local_0001_m_000000_0'
done.
12/12/11 22:27:12 INFO mapred.LocalJobRunner: Finishing task:
attempt_local_0001_m_000000_0
12/12/11 22:27:12 INFO mapred.LocalJobRunner: Map task executor complete.
12/12/11 22:27:12 INFO mapred.Task: Using ResourceCalculatorPlugin : null
12/12/11 22:27:12 INFO mapred.Merger: Merging 1 sorted segments
12/12/11 22:27:12 INFO mapred.Merger: Down to the last merge-pass, with 1
segments left of total size: 247166 bytes
12/12/11 22:27:12 INFO mapred.LocalJobRunner:
12/12/11 22:27:12 INFO mapreduce.Job: map 100% reduce 0%
12/12/11 22:27:12 INFO mapred.Task: Task:attempt_local_0001_r_000000_0 is
done. And is in the process of committing
12/12/11 22:27:12 INFO mapred.LocalJobRunner:
12/12/11 22:27:12 INFO mapred.Task: Task attempt_local_0001_r_000000_0 is
allowed to commit now
12/12/11 22:27:12 INFO output.FileOutputCommitter: Saved output of task
'attempt_local_0001_r_000000_0' to
file:/Users/shaines/Documents/Workspace/hadoop-
examples/target/output/_temporary/0/task_local_0001_r_000000
12/12/11 22:27:12 INFO mapred.LocalJobRunner: reduce > reduce
12/12/11 22:27:12 INFO mapred.Task: Task 'attempt_local_0001_r_000000_0'
done.
12/12/11 22:27:13 INFO mapreduce.Job: map 100% reduce 100%
12/12/11 22:27:13 INFO mapreduce.Job: Job job_local_0001 completed
successfully
12/12/11 22:27:13 INFO mapreduce.Job: Counters: 24
File System Counters
FILE: Number of bytes read=2683488
FILE: Number of bytes written=974132
FILE: Number of read operations=0
FILE: Number of large read operations=0
FILE: Number of write operations=0
Map-Reduce Framework
Map input records=21573
Map output records=215309

12
 Map output bytes=2027118
Map output materialized bytes=247174
Input split bytes=113
Combine input records=215309
Combine output records=17107
Reduce input groups=17107
Reduce shuffle bytes=0
Reduce input records=17107
Reduce output records=17107
Spilled Records=34214
Shuffled Maps =0
Failed Shuffles=0
Merged Map outputs=0
GC time elapsed (ms)=32
Total committed heap usage (bytes)=264110080
File Input Format Counters
Bytes Read=1212132
File Output Format Counters
Bytes Written=182624

Kết quả cuối cùng sẽ được lưu dưới tên part-00000 trong thư mục đã khai báo
kết quả đầu ra.
a 4687
aback 2
abaft 2
abandon 3
abandoned 7
abandonedly 1
abandonment 2
...
your 251
youre 6
youve 1
zephyr 1
zeuglodon 1
zones 3
zoology 2
zoroaster 1

Kết quả thể hiện số từ và số lần từ đó xuất hiện, chẳng hạn chữ “a” (độc lập
thành 1 từ) xuất hiện 4687 lần hay từ “your” xuất hiện 251 lần.

II.2. MapReduce2

II.2.1.Tổng quan
Kiến trúc mới chia 2 chức năng chính của JobTracker - quản lý tài nguyên và
quản lý job thành 2 thành phần riêng biệt:
 Resource Manager (RM): quản lý toàn bộ tài nguyên tính toán của
cluster.
 Application Master (AM): đơn vị là trên 1 ứng dụng và quản lý vòng đời
của Job.
Do vậy đối với YARN, MapReduce sẽ là 1 ứng dụng chạy trên YARN, sử dụng
tài nguyên do RM cấp phát. Các node tính toán trong cluster bây giờ sẽ chạy
13
NodeManager quản lý các tiến trình chạy trên máy đó. Resource Manager và
Node Manager trở thành xương sống của tính toán phân tán trong YARN. Việc
mỗi ứng dụng được tách ra riêng cho phép các process chạy lâu (long running
process) cũng có thể được khởi động trên YARN.
ApplicationMaster trên 1 ứng dụng là một thư viện cho phép yêu càu tài nguyên
từ Resource Manager và giao tiếp với Node Manager để chạy và thực thi các
tasks. Trong YARN, MapReduce2 thay vì là linh hồn của Hadoop như ở
Hadoop 1 thì chỉ là một ứng dụng. Application Master cho phép xây dựng các
ứng dụng khác MR chạy trên YARN.
Hiện tại có rất nhiều ứng dụng BigData được port chạy trên YARN, trong đó có
một số ứng dụng nổi tiếng như Spark. Cụ thể bạn có thể tham khảo hình dưới
đây:
(hình vẽ copy từ Horton)

14
II.2.2.Nền tảng YARN
II.2.2.1. Chạy ứng dụng trên YARN

Quá trình 1 ứng dụng chạy trên YARN được mô tả bằng sơ đồ trên. Cụ thể các
bước khởi động 1 ứng dụng như sau:
 Client giao 1 task cho Resource Manager
 Resource Manager tính toán tài nguyên cần thiết theo yêu cầu của ứng
dụng và tạo 1 App Master (App Mstr). Application Master được chuyển
đến chạy 1 một node tính toán. Application Master sẽ liên lạc với các
NodeManager ở các node khác để ra yêu cầu công việc cho node này.
 Node Manager nhận yêu cầu và chạy các task trên container
 Các thông tin trạng thái thay vì được gửi đến JobTracker sẽ được gửi đến
App Master.
Các ứng dụng khác nhau sẽ có các AppMstr khác nhau và sẽ được khởi động ở
các máy trạm khác nhau. Điều này làm việc khi một máy trạm bị lỗi phần cứng
và sập, các ứng dụng khác không bị ảnh hưởng, chỉ ứng dụng có AppMstr chạy
trên máy đó bị ảnh hưởng.
II.2.2.2. Lập lịch (schedulers)
Resource Manager dùng một module lập lịch mà có thể tháo lắp tự do. Hiện tại
YARN có 2 schedulers là:
 CapacityScheduler
 FairScheduler
Scheduler mặc định của YARN là FairScheduler ở đó các Job sẽ được cho vào
hàng đợi và cấp phát một cách công bằng.

15
Bạn có thể thiết kế và sử dụng một scheduler của riêng mình bằng cách cấu
hình, thông báo cho Yarn biết bộ scheduler nào được sử dụng.
II.2.2.3. Tài nguyên
Ở YARN, tài nguyên không đơn thuần là CPU cores nữa mà bao gồm cả bộ
nhớ, DiskIO, và GPUs... Một ứng dụng khi khởi động sẽ yêu cầu
 Priority: độ ưu tiên để có được tài nguyên so với các ứng dụng khác, các
ứng dụng với độ ưu tiên cao có thể sẽ được cấp phát tài nguyên sớm hơn.
 Bộ nhớ MB: chương trình ứng dụng dự định sẽ sử dụng bao nhiêu MB bộ
nhớ
 CPU: ứng dụng dự định sử dụng bao nhiêu cores.
 Số lượng containers.
Containers là số lượng tasks có thể được triển khai song song trên 1 node tính
toán. Giới hạn tài nguyên sử dụng bởi 1 containers được thực hiện thông qua
tính năng cgroups của Linux kernels.

16
II.3. Apache Spark
Nổi bật trong hệ sinh thái xung quanh Apache Hadoop là Apache Spark.
Apache Spark hỗ trợ nhà phát triển trong việc thiết kế và triển khai ứng dụng
trên nền tảng MapReduce. Trong phần tiếp theo, Apache Spark sẽ được giới
thiệu.

II.3.1.Tổng quan về Apache Spark

Apache Spark là một open source cluster computing framework được phát triển
vào năm 2009 bởi AMPLab tại đại học California. Sau này, Spark đã được phát
triển với sự hỗ trợ của Apache Software Foundation vào năm. Apache Spark tạo
một môi trường thuật lợi cho phép xây dựng các ứng dụng với việc tính toán
được thực hiện trên một nhóm các máy tính, có có thể tính toán cùng lúc trên
toàn bộ tập dữ liệu mà không cần phải trích xuất mẫu tính toán thử nghiệm. Tốc
độ xử lý của Spark có được do việc tính toán được thực hiện cùng lúc trên nhiều
máy khác nhau. Đồng thời việc tính toán được thực hiện ở bộ nhớ trong (in-
memories).

II.3.2.Thành phần của Apache Spark

Matei Zaharia, cha đẻ của Spark, sử dụng Hadoop từ những ngày đầu. Đến năm
2009 ông viết Apache Spark để giải quyết những bài toán học máy ở đại học
UC Berkely vì Hadoop MapReduce hoạt động không hiệu quả cho những bài
toán này. Rất sớm sau đó ông nhận ra rằng Spark không chỉ hữu ích cho học
máy mà còn cho cả việc xử lý luồng dữ liệu hoàn chỉnh.

Thành phần chung của Spark là Spark Core: cung cấp những chức năng cơ bản
17
nhất của Spark như lập lịch cho các tác vụ, quản lý bộ nhớ, fault recovery,
tương tác với các hệ thống lưu trữ… Đặc biệt, Spark Core cung cấp API để định
nghĩa RDD (Resilient Distributed DataSet) là tập hợp của các item được phân
tán trên các node của cluster và có thể được xử lý song song.
Spark có thể chạy trên nhiều loại Cluster Managers như Hadoop YARN,
Apache Mesos hoặc trên chính cluster manager được cung cấp bởi Spark được
gọi là Standalone Scheduler.
 Spark SQL cho phép truy vấn dữ liệu cấu trúc qua các câu lệnh SQL.
Spark SQL có thể thao tác với nhiều nguồn dữ liệu như Hive tables,
Parquet, và JSON.
 Spark Streaming cung cấp API để dễ dàng xử lý dữ liệu stream,
 MLlib Cung cấp rất nhiều thuật toán của học máy như: classification,
regression, clustering, collaborative filtering…
 GraphX là thư viện để xử lý đồ thị.

Trong các thư viện mà Spark cung cấp thì có 69% người dùng Spark SQL, 62%
sử dụng DataFrames, Spark Streaming và MLlib + GraphX là 58%

II.3.3.Tại sao nên sử dụng Apache Spark

II.3.3.1. Những tính năng nổi bật

 “Spark as a Service”: Giao diện REST để quản lí (submit, start, stop, xem
trạng thái) spark job, spark context
 Tăng tốc, giảm độ trễ thực thi job xuống mức chỉ tính bằng giây bằng
cách tạo sẵn spark context cho các job dùng chung.
 Dừng job đang chạy bằng cách ngừng hoạt động của spark context
 Bỏ bước upload gói jar lúc start job làm cho job được start nhanh hơn.
 Cung cấp hai cơ chế chạy job đồng bộ và bất đồng bộ
 Cho phép cache RDD theo tên, tăng tính chia sẻ và sử dụng lại RDD giữa
các job

18
  Hỗ trợ viết spark job bằng cú pháp SQL
 Dễ dàng tích hợp với các công cụ báo cáo như: Business Intelligence,
Analytics, Data Integration Tools
 Xử lý dữ liệu: Spark xử lý dữ liệu theo lô và thời gian thực
 Tính tương thích: Có thể tích hợp với tất cả các nguồn dữ liệu và định
dạng tệp được hỗ trợ bởi cụm Hadoop.
 Hỗ trợ ngôn ngữ: hỗ trợ Java, Scala, Python và R.
 Phân tích thời gian thực:
o Apache Spark có thể xử lý dữ liệu thời gian thực tức là dữ liệu đến
từ các luồng sự kiện thời gian thực với tốc độ hàng triệu sự kiện
mỗi giây. Ví dụ: Data Twitter chẳng hạn hoặc luợt chia sẻ, đăng
bài trên Facebook. Sức mạnh Spark là khả năng xử lý luồng trực
tiếp hiệu quả.
o Apache Spark có thể được sử dụng để xử lý phát hiện gian lận
trong khi thực hiện các giao dịch ngân hàng. Đó là bởi vì, tất cả các
khoản thanh toán trực tuyến được thực hiện trong thời gian thực và
chúng ta cần ngừng giao dịch gian lận trong khi quá trình thanh
toán đang diễn ra.
 Mục tiêu sử dụng:
o Xử lý dữ liệu nhanh và tương tác
o Xử lý đồ thị
o Công việc lặp đi lặp lại
o Xử lý thời gian thực
o joining Dataset
o Machine Learning
o Apache Spark là Framework thực thi dữ liệu dựa trên Hadoop
HDFS. Apache Spark không thay thế cho Hadoop nhưng nó là một
framework ứng dụng. Apache Spark tuy ra đời sau nhưng được
nhiều người biết đến hơn Apache Hadoop vì khả năng xử lý hàng
loạt và thời gian thực.

II.3.3.2. Quản lý bộ nhớ của Apache Spark

Spark giải quyết các vấn đề vấn đề xung quanh định nghĩa Resilient Distributed
Datasets (RDDs). RDDs hỗ trợ hai kiểu thao tác thao tác: transformations và
action. Thao tác chuyển đổi(tranformation) tạo ra dataset từ dữ liệu có sẵn. Thao
tác actions trả về giá trị cho chương trình điều khiển (driver program) sau khi
thực hiện tính toán trên dataset.
Spark thực hiện đưa các thao tác RDD chuyển đổi vào DAG (Directed Acyclic
Graph) và bắt đầu thực hiện. Khi một action được gọi trên RDD, Spark sẽ tạo
DAG và chuyển cho DAG scheduler. DAG scheduler chia các thao tác thành
các nhóm (stage) khác nhau của các task. Mỗi Stage bao gồm các task dựa trên
phân vùng của dữ liệu đầu vào có thể pipline với nhau và có thể thực hiện một

19
cách độc lập trên một máy worker. DAG scheduler sắp xếp các thao tác phù hợp
với quá trình thực hiện theo thời gian sao cho tối ưu nhất. Ví dụ: các thao tác
map sẽ được đưa vào cùng một stage do không xảy ra shuffle dữ liệu giữa các
stage. Kết quả cuối cùng của DAG scheduler là một tập các stage. Các Stages
được chuyển cho Task Scheduler. Task Scheduler sẽ chạy các task thông qua
cluster manager (Spark Standalone/Yarn/Mesos). Task scheduler không biết về
sự phụ thuộc của các stages. Nó chỉ chịu trách nhiệm thực hiện sắp xếp các task
một cách tối ưu nhất.
Mỗi Worker bao gồm một hoặc nhiều Excuter. Các excuter chịu trách nhiệm
thực hiện các task trên các luồng riêng biệt. Việc chia nhỏ các task giúp đem lại
hiệu năng cao hơn, giảm thiểu ảnh hưởng của dữ liệu không đối xứng (kích
thước các file không đồng đều).

Quá trình Spark xây dựng DAG

Có hai kiểu chuyển đổi có thể áp dụng trên các RDDs đó là chuyển đổi hẹp và
chuyển đổi rộng:
- Chuyển đổi hẹp: không yêu cầu xáo trộn dữ liệu vượt qua các phân vùng
(partition).Ví dụ như các thao tác map, filter,..
- Chuyển đổi rộng yêu cầu dữ liệu phải xáo trộn. Ví dụ: reduceByKey,
sortByKey, groupByKey,…

Các thành phần chính trong quản lý bộ nhớ:

Spark truy cập dữ liệu được lưu trữ ở các nguồn khác nhau như: HDFS, Local
Disk, RAM. Cache Manager sử dụng Block Manager để quản lý dữ liệu. Cache
Manager quản lý dữ liệu nào được Cache trên RAM, thông thường là dữ liệu
được sử dụng thường xuyên nhất, nó cũng có thể được xác định thủ công bằng
tay sử dụng phương thức persit hoặc cache. Nếu kích thước RAM không đủ
chứa dữ liệu thì dữ liệu sẽ được lưu trữ sang Tachyon và cuối cùng là lưu trữ
lên đĩa. Khi dữ liệu(RDD) không được lưu trữ trên RAM, khi có nhu cầu sử
dụng đến, chúng sẽ được recompute lại. Nó sử dụng một khái niệm là “storage
level” để quản lý cấp độ của lưu trữ của dữ liệu.

II.3.4.Sự đa dạng của Spark

Lập trình viên có thể viết các ứng dụng Spark bằng nhiều ngôn ngữ khác nhau.
Năm 2014, 84% người dùng sử dụng Scala, trong khi Java và Python cùng là
38% (Người dùng có thể sử dụng nhiều hơn 1 ngôn ngữ trong các ứng dụng của

20
mình). Đến năm 2015, Spark hỗ trợ thêm ngôn ngữ R, rất nhanh chóng có tới
18% người dùng R, Python cũng tăng lên 58%.

III. Kết luận

21