Tag: hadoop

การใช้งาน Google Datalab Notebook บน Dataproc เพื่อสร้าง Machine Learning Model เบื้องต้น
ต่อจาก สร้าง Hadoop และ Spark Cluster เพื่องานด้าน Data Science ด้วย Google Cloud Dataproc + Datalab
1. จาก Google Cloud Datalab คลิก Notebookแล้ว ตั้งชื่อ Demo01
  
  เลือได้ว่า จะใช้ Python2 หรือ Python3 ในที่นี้จะเลือก Python3
2. ตรวจสอบรุ่นของ Spark ที่ใช้งานด้วยคำสั่ง
```
spark.version
```
  แล้วกดปุ่ม Shift+Enter เพื่อ Run
3. สามารถใช้คำสั่งไปย้ง Shell ซึ่งเป็น Linux ได้ โดยใช้เครื่องหมาย ! นำหน้า
  ในที่นี้ จะ Download iris dataset จาก https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data มาไว้ในเครื่อง mycluster-m ด้วย คำสั่ง
```
! wget https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data
```
  แล้ว เอาไปใส่ใน HDFS ด้วยคำสั่ง
```
! hdfs dfs -put iris.data /
```
  จะได้ผลประมาณนี้
4. จาก Machine Learning #01 – Python with iris dataset ซึ่งเดิมใช้ sklearn จะเปลี่ยนเป็น Spark MLlib เพื่อใช้ความสามารถของ Spark Cluster ได้ เริ่มต้นจาก Import Library ที่จำเป็นดังนี้
```
# Import Libaries
from pyspark.ml import Pipeline
from pyspark.ml.evaluation import MulticlassClassificationEvaluator
from pyspark.ml.classification import LogisticRegression
from pyspark.ml.tuning import ParamGridBuilder, CrossValidator
from pyspark.ml.feature import VectorAssembler
from pyspark.sql.types import *
```
5. จากนั้น สร้าง Spark Dataframe (Concept จะคล้ายกับ Pandas แต่มีรายละเอียดที่มากกว่า)
```
# get into DataFrame
csvFile = spark.read.csv('/iris.data', inferSchema=True)
diz = {"Iris-setosa":"1", "Iris-versicolor":"2", "Iris-virginica":"3" }
df = csvFile.na.replace(diz,1,"_c4")
df2 = df.withColumn("label",df["_c4"].cast(IntegerType())) \
.withColumnRenamed("_c0","sepal_length") \
.withColumnRenamed("_c1","sepal_width") \
.withColumnRenamed("_c2","petal_length") \
.withColumnRenamed("_c3","petal_width") 
train,test = df2.randomSplit([0.75,0.25])
```
  เริ่มจาก ให้ spark session (spark) อ่านไฟล์ CSV จาก HDFS /iris.data โดยระบุว่า ให้กำหนด Data Type อัตโนมัติ (inforSchema=True) และไฟล์นี้ไม่มี Header
  
  Dataset นี้ ประกอบด้วย 5 columns เมื่อ Spark อ่านข้อมูลเข้ามา จะตั้งชื่อ column เป็น _c0, _c1, _c2, _c3, _c4 โดย _c4 จะเป็น label ของชนิดของดอก iris ซึ่งกำหนดเป็น String => Iris-setosa, Iris-vesicolor, Iris-virginica ในการใช้งาน Logistic Regression ขั้นตอนต่อไป ไม่สามารถนำเข้าข้อมูลชนิด String เพื่อไปใช้งานได้ จึงต้องทำการเปลี่ยน จาก “Iris-setosa” เป็น “1” แล้วทำการเปลี่ยน “1” ซึ่งเป็น String ให้เป็น Integer ด้วย ฟังก์ชั่น cast และตั้งชื่อว่า column ว่า “label”
  
  จากนั้น ทำการเปลี่ยนชื่อ column _c0, _c1, _c2, _c3 เป็นชื่อตามต้องการ
  
  สุดท้าย ใช้ randomSplit([0.75, 0.25]) เพื่อแบ่งข้อมูลสำหรับ train 75% และ test 25%
6. ลอง แสดง Schema ดู
```
df2.printSchema()
```
  ได้ผลดังนี้
  
  และใช้คำสั่งนี้ เพื่อดูข้อมูล
```
df2.show()
```
  ได้ผลประมาณนี้
7. ใน Spark 2.x จะมี Concept ของการใช้ Pipeline เพื่อให้สามารถออกแบบการทดลอง ปรับค่า Meta Parameter ต่าง ๆ ของโมเดล และทำงานอย่างเป็นระบบยิ่งขึ้น (ในขั้นตอนนี้ ขอไม่ปรับค่าใด ๆ ก่อน)
```
# Model
assembler = VectorAssembler(
inputCols=["sepal_length","sepal_width","petal_length","petal_width"],
outputCol="features")
lr = LogisticRegression()
paramGrid = ParamGridBuilder().build()

#Pipeline
pipeline = Pipeline(stages=[assembler, lr])
```
  ในการใช้งาน Logistic Regression ต้องกำหนดค่า field คือ features โดยกำหนดให้มาจาก Column sepal_length, sepal_width, petal_length, petal_width ส่วน label ได้กำหนดในขั้นก่อนหน้าแล้ว
  
  จากนั้นสร้าง lr เป็น instant ของ LogisticRegression
  
  ในการปรับค่า Parameter จะมาใส่ใน ParamGridBuilder ซึ่งจะไม่กล่าวถึงในขั้นนี้
  
  สุดท้าย นำ assembler และ lr มาเข้าสู่ stage วิธีการนี้ทำให้การทำซ้ำขั้นตอนต่าง ๆ ใน Pipeline สะดวกยิ่งขึ้น (ต้องเห็นกระบวนการที่ซับซ้อนกว่านี้ จึงจะเห็นประโยชน์)
8. ขั้นตอนสำคัญ pipeline มาแล้ว ก็ต้องนำมาสร้าง model โดยการ Train ด้วยชุดข้อมูล “train”
```
model = pipeline.fit(train)
predictions = model.transform(train)
```
  แล้ว นำ model ที่ได้ มาทดลอง predictions ด้วย transform() บนข้อมูล train ผลที่ได้ คือ ผลการ Predict จาก Model
9. ต่อไป คือ การตรวจสอบว่า Model ที่สร้างขึ้น มีความแม่นยำแค่ไหน ในที่นี้ จะใช้ MulticlassClassificationEvaluator เพราะ label มีมากว่า 2 ชนิด
```
evaluator=MulticlassClassificationEvaluator(predictionCol="prediction", labelCol="label")
```
  แล้วนำ เปรียบเทียบว่า สิ่งที่ predict ได้จาก model
```
evaluator.evaluate(predictions)
```
  ถูกต้องมากน้อยขนาดไหน กับข้อมูล test
```
evaluator.evaluate(model.transform(test))
```
10. ผลที่ได้ ประมาณนี้
  โดยจะเห็นได้ว่า มีความถูกต้อง 0.9521 … หรือ 95.21% นั่นเอง
July 16, 2018
สร้าง Hadoop และ Spark Cluster เพื่องานด้าน Data Science ด้วย Google Cloud Dataproc + Datalab
จาก Ambari #01: ติดตั้ง Ambari Server , Ambari #02 ติดตั้ง Ambari Agent , Ambari #04 การสร้าง Hadoop ด้วย Ambari บน AWS และ GCP #01 วิธีการสร้าง Virtual Machine บน Google Cloud Platform จะเห็นได้ว่า ก็ยังมีความยุ่งยากอยู่ อีกทั้ง หากต้องการใช้ PySpark ก็ต้องตามติดตั้ง Python Packages ต้องปรับค่ามากมาย และหากต้องการขยายระบบ ก็มีงานต้องทำอีกเยอะ

ในบทความนี้ จะแนะนำอีกวิธีหนึ่ง คือ การใช้งาน Google Cloud Dataproc ซึ่งจะทำให้เราได้ใช้ Hadoop + Spark Cluster ซึ่งได้รับการทดสอบเป็นอย่างดี อีกทั้งยังสามารถเลือกใช้ Spark รุ่นต่างๆได้อย่างง่ายได้ ทำให้สามารถโฟกัสไปยัง Data และ กระบวนทำ Machine Learning ได้เต็มที่
1. ไปที่ Google Cloud Console เพื่อเลือก Project ที่จะทำงานด้วย และเปิดช้งาน Cloud Dataproc และ Compute Engine APIs และ ในที่นี้ จะมี project-id คือ kx-dataproc-01 (สามารถสร้างในชื่อที่ต้องการเองได้)
  https://console.cloud.google.com/
2. เปิดใช้งาน Google Cloud Dataproc
  https://console.cloud.google.com/dataproc/
3. เปิด GCLOUD COMMAND
4. ในที่นี้ จะสร้าง Cluster ชื่อ mycluster ใน project-id ชื่อ kx-dataproc-01 แล้วให้ copy คำสั่งต่อไปนี้ลงไปใน gcloud command แล้วกดปุ่ม Enter
```
gcloud dataproc clusters create mycluster --project kx-dataproc-01 --initialization-actions gs://dataproc-initialization-actions/datalab/datalab.sh
```
5. ใช้เวลาประมาณ 5 นาที ก็จะได้ Hadoop + Spark Cluster ที่มี 1 Master และ 2 Workers
  ซึ่ง Master จะชื่อว่า mycluster-m
  และ Workers จะชื่อ mycluster-w-0 และ mycluster-w-1
6. ต่อไป ทำ SSH Tunnel จาก Master คือ mycluster-m Port 8080 ออกมา โดยพิมพ์คำสั่งต่อไปนี้
```
gcloud compute ssh mycluster-m --project kx-dataproc-01 --zone=asia-southeast1-a -- -4 -N -L 8080:mycluster-m:8080
```
  โดย
  –project ไว้สำหรับระบุชื่อ project-id
  –zone ไว้ระบุ Zone ที่ Cluster อยู่
  — ไว้เป็นตัวคั่น (separator) ว่าหลังจากนี้เป็นคำสั่งของ ssh
  -4 บอกว่า ติดต่อด้วย IPv4
  -N บอกว่า ไม่ต้องเปิด Shell ของเครื่อง Master
  -L บอกว่า จะ Forward Port 8080 ไปยังเครื่อง mycluster-m ที่ port 8080
7. จากนั้น เปิด Web Preview on port 8080
8. ก็จะได้ Google Cloud Datalab ซึ่งติดต่อกับ Hadoop+Spark ที่อยู่บน Google Cloud Dataproc ได้แล้ว
Reference:

https://cloud.google.com/dataproc/docs/tutorials/dataproc-datalab
July 10, 2018
Ambari #04 การสร้าง Hadoop ด้วย Ambari บน AWS
การจัดการข้อมูลขนาดใหญ่ (Big Data) มีเครื่องมือที่ได้รับความนิยมหลายตัว หนึ่งในนั้นคือ Apache Hadoop ซึ่งสามารถติดตั้งได้โดยตรง ตาม บทความที่เล่าให้ฟังก่อนหน้านี้

ขั้นตอนการติดตั้ง Hadoop Cluster อย่างง่าย

แต่ Hadoop เอง ไม่ได้มีแค่ HDFS และ MapReduce เท่านั้น ยังประกอบด้วย Modules ต่างๆ รวมกันเป็น Ecosystem ซึ่งจะต้องติดตั้งไปทีละตัวๆ และก็ไม่ง่ายนัก

จึงมีโปรเจคชื่อ Apache Ambari ทำหน้าที่ Deploy Hadoop และส่วนประกอบต่างๆได้ง่ายขึ้น ดังที่เคยเล่าให้ฟังมาแล้วใน (ใช้ Ambari ที่อยู่ในบริการของ Hortonwors)

Ambari #01: ติดตั้ง Ambari Server

Ambari #02 ติดตั้ง Ambari Agent

คราวนี้ ถ้าจะลองทำกับระบบขนาดใหญ่ขึ้น ทางเลือกหนึ่ง ที่ประหยัด และรวดเร็วคือ ไปใช้บริการ Cloud ซึ่งในที่นี้ จะขอเล่าให้ฟังในกรณีการติดตั้งบน Amazon Web Service (AWS)

Prerequisite

เปิดบัญชี AWS ก่อนนะ AWS Getting Start

ขั้นตอนการใช้งาน
1. สิ่งที่เรากำลังจะทำคือ สร้าง Ubuntu 14.04 LTS จำนวน 4 เครื่อง แต่ละเครื่อง ใช้เป็น t2.medium ซึ่งมี CPU Intel Xeon 2.5 GHz 2 ตัว, มี RAM 4 GB และมี SSD HD 30 GB
2. Login เข้าไปยัง AWS Console (ผมเลือกใช้ Singapore นะครับ) แล้วคลิก Launch Instance
3. เลือก Ubuntu Server 14.04 LTS 64bit คลิก Select
4. เลือก Instance Type เป็น t2.medium แล้วคลิก Next: …
5. ต่อไป เลือกขนาด Storage ในที่นี้ ใส่ size เป็น 30 GB แล้วคลิก Next …
6. Add Tags ในกรณีต้องการใส่ Tag เพือให้ง่ายต่อการจัดกลุ่มสามารถทำได้ แต่ไม่ขอทำในตอนนี้ คลิก Next
7. ต่อไป สร้าง Security Group กล่าวคือ เปิด Port ให้มีการเข้าถึงได้จากที่ใด ไปยัง port ใดบ้าง ให้เลือก Create a new security group และ คลิก Add Rule เพิ่ม Port 8080 เพื่อให้สามารถเรียกใช้ Ambari Web UI ได้ และ เปิด All TCP จากเครือข่ายภายใน ในที่นี้คือ 172.31.0.0/16 จากนั้น คลิก Review and Launch
8. มีเตือนเรื่องความปลอดภัย … ใช่ … แต่ผ่านไปก่อน คลิก Launch
9. สร้าง Key pair เพื่อให้สามารถ SSH เข้าไปใน Instance ได้โดยไม่ต้องใส่รหัสผ่าน ในที่นี้จะเลือก Create a new key pair ตั้งชื่อว่า ambari (จะได้ไฟล์ ambari.pem) แล้วคลิก Launch Instances
  ระวัง! ต้องเก็บไฟล์ .pem นี้ให้ดี หายไปแล้วไม่สามารถขอใหม่ได้
10. คลิก View Instances
11. จะพบว่า ระบบสร้างเครื่อง 4 เครื่องให้เราแล้ว ต่อไป ให้คลิกใน Column “name” เลือกเครื่องแรกให้เป็น Ambari Web UI และเครื่องอื่นตั้งชื่อเป็น node1, node2, node3
12. ในการใช้งาน AWS จะเรียกผ่าน Name และ IP Address
  ในตอนนี้ ขอให้คลิกแต่ละ Instance แล้วจดค่า
  – Public DNS IPv4
  – Private DNS
  – Private IPs
  ซึ่ง หากมีการ Restart Instance ค่าของ Public DNS IPv4 จะเปลี่ยนไปเรื่อยๆ
  
  ประมาณนี้
13. วิธีการ SSH ไปยังเครื่องต่างๆ คลิกที่ Connect ก็จะแสดงรายละเอียด
14. ต่อไป เพื่อให้ง่ายต่อการจัดการ เราจะ Key Pair “ambari.pem” ที่ AWS สร้างให้ เอาไปใส่ในเครื่องที่เราตั้งเป็น Ambari Web UI
  ซึ่งทุก Instance ที่สร้างขึ้นทั้ง 4 ตัวนี้ จะมี Public Key อยู่ใน /home/ubuntu/.ssh/authorized_hosts แล้ว ทำให้สามารถ SSH เข้าไปโดยใช้ ambari.pem ซึ่งไม่ต้องใส่รหัสผ่าน (จริงๆแล้วสามารถทำตามขั้นตอน วิธีทำ Password-less SSH บน Ubuntu เพื่อสร้าง Key Pair อีกชุดได้) ให้ทำการ scp ambari.pem ไปไว้ใน hom directory ของ ubuntu ด้วยคำสั่ง
```
scp -i ambari.pem ambari.pem ubuntu@ec2-xx-xx-xx-xx.ap-southeast-1.compute.amazonaws.com:
```
15. จากนั้น SSH เข้าไปยังเครื่อง Ambari Web UI
```
ssh -i ambari.pem ubuntu@ec2-xx-xx-xx-xx.ap-southeast-1.compute.amazonaws.com
```
16. ตอนนี้ เราก็จะเข้ามาอยู่ใน home directory ของ ec2-user บนเครื่อง Ambari Web UI
  ต่อไป ทำการสร้าง .ssh/id_rsa ด้วยคำสั่งนี้
```
mv ambari.pem .ssh/id_rsa
```
17. ต่อไป ให้ sudo su เพื่อเป็น root แล้วติดตั้ง Ambari Server ตามคำสั่งต่อไปนี้
  (ในขั้นตอนของ ambari-server setup ให้เคาะ Enter ใช้ค่า Default ไปทั้งหมด)
```
sudo su

wget -O /etc/apt/sources.list.d/ambari.list http://public-repo-1.hortonworks.com/ambari/ubuntu14/2.x/updates/2.5.2.0/ambari.list

apt-key adv --recv-keys --keyserver keyserver.ubuntu.com B9733A7A07513CAD

apt-get update -y

apt-get install -y ambari-server

ambari-server setup
```
18. ซึ่งจะ Error น่ะ 555 เพราะ Postgresql รุ่นนี้ต้องสร้าง cluster ก่อนจึงจะทำงานได้
  ให้ใช้คำสั่งต่อไปนี้
```
export LC_ALL=en_US.UTF-8

pg_createcluster 9.3 main --start

/etc/init.d/postgresql restart
```
  แล้วจึง setup อีกครั้ง
```
ambari-server setup
ambari-server start
```
19. เสร็จแล้ว ไปทำต่อบน Ambari Web UI ที่
  http://ec2-xx-xx-xx-xx.ap-southeast-1.compute.amazonaws.com:8080
  Default user/password คือ admin/admin
20. คลิก launch Install Wizard
21. ตั้งค่า Cluster แล้วคลิก Next
22. เลือก Version ล่าสุด HDP-2.6.2.0
  
  แล้วคลิก Next
23. ต่อไป ให้เอา Private DNS ของทุกเครื่องที่ต้องการจะติดตั้ง Ambari Agent มาใส่ (ในที่นี้ ใส่ทั้งตัว Ambari Web UI และ node1 – node3) แล้ว เลือก Provide your SSH Private Key “ambari.pem” และ กำหนด SSH User Account เป็น ubuntu ใช้ Port 22
24. ระบบจะทำการติดต่อไปยัง nodes ต่างๆแล้วติดตั้ง Ambari Agent เมื่อเสร็จแล้ว คลิก Next
25. จากนั้น เลือก Services ที่ต้องการใช้งาน
  ในที่นี้ จะใช้ HDFS, Yarn, Tez, Hive, Sqoop, Spark2, Zeppelin
  หากมี Service ใดที่ต้องใช้งานร่วมด้วย ระบบจะแจ้งเตือนอีกครั้ง
  
  แล้วคลิก Next
26. เลือก Master ว่าจะอยู่บนเครื่องใดบ้าง
  หาก Deploy ระบบขนาดใหญ่ๆ ก็ควรจะจัดกลุ่ม Server ไว้เลย แล้วพวก Slave เป็นอีกกลุ่มหนึ่ง
27. เลือกว่า Slaves and Clients จะติดตั้งไว้ในเครื่องใดบ้าง
28. ต่อไป จะเป็นการปรับแต่งระบบ ในที่นี้ ซึ่งถ้ามี ตัวแดง ปรากฏที่ใด ก็ให้ตามไปใส่ค่าที่ระบบแนะนำให้ปรับแต่ง
  ในที่นี้ จะเป็น Hive, Ambari Matrics และ SmartSense ซึ่งจะเป็นเรื่องการกำหนด Password
29. เมื่อปรับแต่งเรียบร้อย ก็ Review
30. ระบบจะติดตั้ง Service/Clients ต่างๆ เมื่อเสร็จแล้วจะได้ผลดังภาพ แล้วคลิก Next
31. แสดง Summary
  คลิก Next
32. แล้วก็จะได้ระบบพร้อมใช้งาน
33. คราวนี้ เรื่องค่าใช้จ่าย ก็ประมาณนี้
  
  ประมาณ 22 บาทต่อชั่ว่โมง จะใช้งาน ค่อย Start ใช้งานเสร็จก็ Stop ไม่คิดตังค์ (เว้นแต่ EBS Storage ที่คิดเป็นรายเดือน)
Addtional
- หากต้องการใช้ Hive2 View จะต้องสร้าง /user/admin directory ก่อน ด้วยคำสั่ง
```
sudo su hdfs

hdfs dfs -mkdir /user/admin

hdfs dfs -chown admin.hdfs
```
  แล้วไปแก้ไขใน Ambari Web UI
  http://AmbariWebUI:8080/#/main/services/HDFS/configs
  แก้
```
hadoop.proxyuser.root.groups=*

hadoop.proxyuser.root.hosts=*
```
- หากต้องการติดต่อ mysql จาก Spark ให้ Download จาก https://dev.mysql.com/downloads/connector/j/
  จากนั้นให้ Unzip จะได้ไฟล์ mysql-connector-java-5.1.44-bin.jar (Version อาจจะแตกต่างกัน)
  แล้วนำไปไว้ใน /usr/hdp/current/spark2-client/jars *** ของทุก Nodes ***
October 16, 2017
Ambari #02 ติดตั้ง Ambari Agent
ต่อจาก Ambari #01: ติดตั้ง Ambari Server

ในบทความนี้ จะขอนำเสนอการติดตั้ง Ambari version 2.5.1 จาก HortonWorks ซึ่งจะทำงานกับ Hortonworks Data Platform (HDP) 2.6 โดยติดตั้งบน Ubuntu 16.04 ในส่วนของ “Ambari Agent” [2]
1. ติดตั้ง Ubuntu 16.04 Server 64bit
2. สิ่งที่สำคัญมากคือ FQDN หรือการอ้างชื่อเต็มของ host ดังนั้น ในไฟล์ /etc/hosts บรรทัดแรกต้องเป็น Fully Qualified Domain Name เช่น (ห้ามเป็น localhost เด็ดขาด) และถ้าจะให้ดี ควรมี DNS Record บน Name Server ด้วย
```
127.0.0.1       ambari02.example.com ambari02
192.168.1.122   ambari02.example.com ambari02
```
  ต้องทดสอบใช้คำสั่ง
```
hostname -f
```
  แล้วได้ชื่อ FQDN ถึงจะใช้งานได้
3. ตั้งค่า Ambari Public Repository
```
sudo su
wget -O /etc/apt/sources.list.d/ambari.list http://public-repo-1.hortonworks.com/ambari/ubuntu16/2.x/updates/2.5.1.0/ambari.list
apt-key adv --recv-keys --keyserver keyserver.ubuntu.com B9733A7A07513CAD
apt-get update -y
sudo dpkg --configure -a
echo never > /sys/kernel/mm/transparent_hugepage/enabled
apt-cache showpkg ambari-server
```
4. ติดตั้ง Ambari Agent
```
apt-get install -y ambari-agent
```
5. แก้ไขไฟล์
```
/etc/ambari-agent/conf/ambari-agent.ini
```
  ให้ระบบ hostname ไปยัง ambari server ในที่นี้คือ ambari01.example.com
```
hostname=ambari01.example.com
...
run_as_user=ambari
```
6. เนื่องจากเป็นการติดตั้งแบบ non-root จึงต้องทำการแก้ไข visudo ด้วย
  โดยเพิ่มบรรทัดต่อไปนี้เข้าไป
```
# Ambari Customizable Users
ambari ALL=(ALL) NOPASSWD:SETENV: /bin/su hdfs *,/bin/su ambari-qa *,/bin/su ranger *,/bin/su zookeeper *,/bin/su knox *,/bin/su falcon *,/bin/su ams *, /bin/su flume *,/bin/su hbase *,/bin/su spark *,/bin/su accumulo *,/bin/su hive *,/bin/su hcat *,/bin/su kafka *,/bin/su mapred *,/bin/su oozie *,/bin/su sqoop *,/bin/su storm *,/bin/su tez *,/bin/su atlas *,/bin/su yarn *,/bin/su kms *,/bin/su activity_analyzer *,/bin/su livy *,/bin/su zeppelin *,/bin/su infra-solr *,/bin/su logsearch *
```
7. Start Ambari Agent
```
ambari-agent start
```
July 31, 2017
Ambari #01: ติดตั้ง Ambari Server
Apache Ambari เป็นเครื่องมือที่ทำให้การจัดการ Hadoop ง่ายขึ้น [1] แต่การติดตั้ง Apache Ambari เองนั้น (จาก Apache Project) ก็มีความยุ่งยากเล็กน้อย เพราะต้อง Build Source เอง จึงมีบริษัท HortonWorks เค้าไปทำตัว Binary มาให้ download และติดตั้งได้ง่ายกว่า

Ambari ประกอบด้วย Ambari Server และ Ambari Agent ซึ่ง Server จะเป็นตัวสั่งการให้ติดตั้ง Hadoop Component ต่างๆลงไปบน Agent

ในบทความนี้ จะขอนำเสนอการติดตั้ง Ambari version 2.5.1 จาก HortonWorks ซึ่งจะทำงานกับ Hortonworks Data Platform (HDP) 2.6 โดยติดตั้งบน Ubuntu 16.04 ในส่วนของ “Ambari Server” [2]
1. ติดตั้ง Ubuntu 16.04 Server 64bit
2. สิ่งที่สำคัญมากคือ FQDN หรือการอ้างชื่อเต็มของ host ดังนั้น ในไฟล์ /etc/hosts บรรทัดแรกต้องเป็น Fully Qualified Domain Name เช่น (ห้ามเป็น localhost เด็ดขาด) และถ้าจะให้ดี ควรมี DNS Record บน Name Server ด้วย
```
192.168.1.121   ambari01.example.com ambari01
```
  ต้องทดสอบใช้คำสั่ง
```
hostname -f
```
  แล้วได้ชื่อ FQDN ถึงจะใช้งานได้
  UPDATE: ในการระบบทดสอบ ซึ่งประกอบด้วยเครื่องไม่เกิน 5 เครื่อง อาจจะใช้ /etc/hosts บันทึก IP Address และ FQDN ของทุกเครื่องใน Cluster และต้องสร้าง /etc/hosts ให้เหมือนกันทุกเครื่องด้วยเช่นกัน แต่หากต้องทำระบบขนาดใหญ่ แนะนำให้ใช้ DNS ซึ่งต้องทำ Reverse DNS ด้วย กล่าวคือ ต้อง nslookup 192.168.1.2 แล้วกลับมาเป็น ambari01.example.com ได้
  แต่หากไม่สามารถจัดการ DNS หลักขององค์กรได้ ก็พอจะใช้งาน dnsmasq ช่วยได้ โดยวิธีการติดตั้งและใช้งานมีดังนี้
```
 apt install dnsmasq
```
  แก้ไขไฟล์ /etc/dnsmasq.conf
  เพิ่มบรรทัดต่อไปนี้
```
interface=eth0
address=/ambari01.example.com/192.168.1.121
ptr-record=121.1.168.192.in-addr.arpa,ambari01.example.com
address=/ambari02.example.com/192.168.1.122
ptr-record=122.1.168.192.in-addr.arpa,ambari02.example.com
....
address=/ambari99.example.com/192.168.1.219
ptr-record=219.1.168.192.in-addr.arpa,ambari99.example.com
```
  จากนั้น ให้แก้ไขไฟล์ /etc/network/interfaces ของทุกเครื่อง ให้ชี้มาที่ IP ของ Ambari Server ในที่นี้คือ 192.168.1.121
  ก็จะใช้งานได้อย่างราบรื่น
3. ตั้งค่า Ambari Public Repository
```
sudo su
wget -O /etc/apt/sources.list.d/ambari.list http://public-repo-1.hortonworks.com/ambari/ubuntu16/2.x/updates/2.5.1.0/ambari.list
apt-key adv --recv-keys --keyserver keyserver.ubuntu.com B9733A7A07513CAD
apt-get update -y
sudo dpkg --configure -a
echo never > /sys/kernel/mm/transparent_hugepage/enabled
apt install -y ntp
apt-cache showpkg ambari-server
```
4. ติดตั้ง Ambari Server
```
apt-get install -y ambari-server
```
5. จากนั้นเป็นการ Setup
```
ambari-server setup

Customize user account for ambari-server daemon [y/n] (n)? n

Checking JDK...
[1] Oracle JDK 1.8 + Java Cryptography Extension (JCE) Policy Files 8
[2] Oracle JDK 1.7 + Java Cryptography Extension (JCE) Policy Files 7
[3] Custom JDK
==============================================================================
Enter choice (1): 1

Do you accept the Oracle Binary Code License Agreement [y/n] (y)? y

Enter advanced database configuration [y/n] (n)? n
# Default PostgreSQL Database: ambari
# Default Username/Password:   ambari/bigdata
```
6. Start Ambari
```
ambari-server start
```
ต่อไป สามารถเปิดการทำงานของ Ambari Server จาก

http://ambari01.example.com:8080
Default Username/Password = admin/admin

Reference:

[1] http://ambari.apache.org/

[2] https://docs.hortonworks.com/HDPDocuments/Ambari/Ambari-2.5.1.0/index.html
July 31, 2017
Spark #03: Query Apache Access Log with Spark SQL
ต่อจาก
- Spark #02: Cluster Installation ซึ่งทำให้เรามี Spark Cluster ที่พร้อมจะทำงานแบบ Distributed Computing แล้ว
- ขั้นตอนการติดตั้ง Hadoop Cluster อย่างง่าย ทำให้มี Hadoop HDFS เป็นพื้นที่จัดกับ
- Zeppelin #01 Installation ทำให้สามารถใช้งาน Spark ได้ง่ายขึ้น
บทความนี้ จะกล่าวถึงการนำเข้าไฟล์ Apache Access Log เข้าไปเก็บไว้ใน Hadoop HDFS แล้ว ให้ Apache Spark Cluster เข้าไปค้นหาข้อมูล โดยใช้ภาษา SQL ผ่าน Spark SQL API

นำ Apache Access Log เข้า HDFS
1. ให้ Copy Apache Access Log ที่มีอยู่มาเก็บไว้ในเครื่องที่สามารถติดต่อ Hadoop HDFS ได้ (ในที่นี้ ชื่อไฟล์เป็น apache.access.log)
2. ใช้คำสั่งต่อไป
  (แทน /test/ ด้วย Path ที่สร้างไว้ใน HDFS)
```
hdfs dfs -copyFromLocal apache.access.log /test/
```
3. เมื่อไปดูผ่าน Web UI ของ Hadoop HDFS ก็จะเห็นไฟล์อยู่ดังนี้
วิธี Query ข้อมูลจาก Zeppelin ไปยัง Spark Cluster
1. เปิด Zeppelin Web UI แล้วสร้าง Note ใหม่ โดยคลิกที่ Create new node
  แล้วใส่ชื่อ Note เช่น Query Apache Access Log
  ตั้ง Default Interpreter เป็น Spark
  แล้วคลิก Create Note
2. ใส่ Code ต่อไปนี้ลงไป
3. ด้านขวามือบน จะมีรูปเฟือง ให้คลิก แล้วเลือก Insert New
4. แล้วใส่ข้อความนี้ลงไป
5. จากนั้นคลิก Run all paragraphs
6. ผลที่ได้
ตอนต่อไปจะมาอธิบายวิธีการเขียนคำสั่งครับ
March 31, 2017
ขั้นตอนการติดตั้ง HBase บน Hadoop อย่างง่าย
HBase เป็น Database บน Hadoop [1]

จากบทความ ขั้นตอนการติดตั้ง Hadoop Cluster อย่างง่าย จะได้ HDFS อยู่ที่ hdfs://192.168.1.101:9000 แล้ว ก็จะสามารถใช้ HBase บน Hadoop HDFS ได้

ขั้นตอนการติดตั้ง
1. โคลนเครื่องต้นฉบับ แล้วตั้ง ip address ให้เรียบร้อย เช่น 192.168.1.121
2. ติดตั้ง HBase (mama shell)
```
(mama shell)
cd ~
wget http://www-us.apache.org/dist/hbase/stable/hbase-1.2.3-bin.tar.gz
tar -zxvf hbase-1.2.3-bin.tar.gz
sudo mv hbase-1.2.3 /usr/local/hbase
sudo chown -R hduser.hadoop /usr/local/hbase
sudo mkdir /usr/local/zookeeper
sudo chown -R hduser.hadoop /usr/local/zookeeper
```
3. แก้ไขไฟล์ /usr/local/hbase/conf/hbase-site.xml (hduser shell)
```
<configuration>
<property>
 <name>hbase.cluster.distributed</name>
 <value>true</value>
</property>
<property>
 <name>hbase.rootdir</name>
 <value>hdfs://192.168.1.101:9000/hbase</value>
</property>
 <property>
 <name>hbase.zookeeper.property.dataDir</name>
 <value>/usr/local/zookeeper</value>
 </property>
</configuration>
```
4. ขั้นตอนการ Start HBase (hduser shell)
```
 /usr/local/hbase/bin/start-hbase.sh
```
5. ดูผลการทำงาน จาก Hadoop HDFS ว่าสร้าง /hbase แล้ว
```
 http://192.168.1.101:50070/explorer.html#/hbase
```
6. ใช้งานผ่าน Shell ได้จากคำสั่ง (hduser shell)
```
 /usr/local/hbase/bin/hbase shell
```
7. ขั้นตอนการ Stop HBase (hduser shell)
```
 /usr/local/hbase/bin/stop-hbase.sh
```
References:

[1] https://hbase.apache.org/
September 14, 2016
ขั้นตอนการติดตั้ง Hadoop Cluster อย่างง่าย
Hadoop เป็น Framework สำหรับสร้างการประมวลผลแบบกระจาย (Distributed Processing) กับข้อมูลขนาดใหญ่ (Large Data Sets) สามารถเริ่มต้นจากทดสอบบนเครื่องคอมพิวเตอร์เครื่องเดียว ไปจนเป็นระบบ Cluster ได้[1]

อธิบายง่ายๆได้ว่า Hadoop ประกอบด้วย ส่วนประมวลผลแบบกระจายเรียกว่า YARN (หรือ MapReduce) และ ส่วนเก็บข้อมูลแบบกระจายเรียกว่า HDFS (Hadoop Distributed File System) สำหรับการสร้าง Hadoop Cluster ในบทความนี้ใช้ Hadoop version 2.7.2 บน Ubuntu 16.04 โดย Cluster จะประกอบด้วย 1 Master และ N Slaves โดยจะใช้วิธีการสร้างเครื่องต้นฉบับ แล้ว Clone ไปเป็น Master/Slave ต่อไป

1.ขั้นตอนการสร้างตันฉบับสำหรับการ Clone
1.1. ติดตั้ง Ubuntu 16.04 ตามปรกติ สร้าง User คนแรกชื่อ mama
1.2. สร้างกลุ่มชื่อ hadoop
```
sudo addgroup hadoop
```
1.3. สร้างผู้ใช้ชื่อ hduser อยู่ในกลุ่ม hadoop
```
sudo adduser hduser --ingroup hadoop
```
1.4. ติดตั้ง Java
```
sudo apt-get install default-jre openjdk-8-jdk-headless
```
1.5. ติดตั้ง hadoop
```
wget http://www-us.apache.org/dist/hadoop/common/hadoop-2.7.2/hadoop-2.7.2.tar.gz
tar -zxvf hadoop-2.7.2.tar.gz
sudo mv hadoop-2.7.2 /usr/local/hadoop
sudo mkdir /usr/local/hadoop/etc/hadoop/tmp
sudo chown -R hduser.hadoop /usr/local/hadoop
```
1.6. เพิ่มตัวแปรใน /etc/environment
```
HADOOP_HOME=/usr/local/hadoop
HADOOP_PREFIX=/usr/local/hadoop
JAVA_HOME=/usr/lib/jvm/java-8-openjdk-amd64
```
1.7. แก้ไขค่าใน .bashrc
```
su hduser; cd ~
```
แล้วแก้ไข .bashrc โดยเพิ่มบรรทัดต่อไปนี้ ท้ายไฟล์
```
export HADOOP_HOME=/usr/local/hadoop
export HADOOP_PREFIX=/usr/local/hadoop
export JAVA_HOME=/usr/lib/jvm/java-8-openjdk-amd64
export PATH=$PATH:$HADOOP_HOME/bin:$HADOOP_HOME/sbin
```
2.ขั้นตอนการสร้าง Master (namenode)
2.1. Clone เครื่องต้นฉบับมา แล้วแก้ไข ip address, /etc/hosts, /etc/hostname ให้เหมาะสม
โดยเครื่องนี้ต้อง Static IP เช่น 192.168.1.101
2.2. แก้ไข /usr/local/hadoop/etc/hadoop/core-site.xml ดังนี้
```
<configuration>
<property>
 <name>hadoop.tmp.dir</name>
 <value>/usr/local/hadoop/tmp</value>
 </property>
 <property>
 <name>fs.defaultFS</name>
 <value>hdfs://192.168.107.116:9000</value>
 </property>
</configuration>
```
2.3. แก้ไข /usr/local/hadoop/etc/hadoop/hdfs-site.xml
```
<configuration>
 <property>
 <name>dfs.replication</name>
 <value>3</value>
 </property>
 <property>
 <name>dfs.namenode.datanode.registration.ip-hostname-check</name>
 <value>false</value>
 </property>
</configuration>
```
2.4. แก้ไข /usr/local/hadoop/etc/hadoop/slaves

โดยใส่ IP ของเครื่องที่จะเป็น Slave หรือ datanode ลงไป เช่น 192.168.1.102 ถึง 192.168.1.111 เป็นต้น
```
192.168.1.102
192.168.1.103
192.168.1.104
192.168.1.105
192.168.1.106
192.168.1.107
192.168.1.108
192.168.1.109
192.168.1.110
192.168.1.111
```
3.ขั้นตอนการสร้าง Slave (datanode)
3.1. Clone เครื่องต้นฉบับมา แล้วแก้ไข ip address, /etc/hosts, /etc/hostname

เช่น ตั้ง IP เป็น 192.168.1.102
3.2. แก้ไข /usr/local/hadoop/etc/hadoop/core-site.xml ดังนี้ (สังเกตว่า 192.168.1.101 เป็น IP Address ของเครื่อง Master)
```
<configuration>
 <property>
 <name>fs.defaultFS</name>
 <value>hdfs://192.168.1.101:9000</value>
 </property>
</configuration>
```
4.ขั้นตอนการตั้งค่า Passwordless SSH

ที่เครื่อง Master ใช้คำสั่งต่อไปนี้ เพื่อให้สามารถ Login ไปเป็น hduser บนเครื่อง slave ได้โดยไม่ต้องใส่รหัสผ่าน
```
(hduser@master shell)
ssh-keygen -t rsa
ssh hduser@192.168.1.102 mkdir -p .ssh
ssh-copy-id -i .ssh/id_rsa.pub hduser@192.168.1.102
```
จากนั้นจะสามารถ ssh hduser@192.168.1.102 โดยไม่ต้องใส่ Password อีก แล้วหลังจากนี้ สามารถใช้เครื่อง Slave นี้เป็นต้นฉบับในการ Clone เป็น datanode ต่างๆได้ตามต้องการ

5.ขั้นตอนการ Start Hadoop Cluster

ในครั้งแรกสุด ที่เครื่อง Master ต้อง format HDFS ก่อน โดยใช้คำสั่ง (จาก hduser shell)
```
hdfs namenode -format
```
จากนั้นใช้คำสั่งต่อไปนี้เพื่อ start ระบบ
```
start-dfs.sh
start-yarn.sh
```
6.ดูผลการทำงาน

http://192.168.1.101:50070

http://192.168.1.101:8088

7.ขั้นตอนการ Stop Hadoop Cluster
```
stop-dfs.sh
stop-yarn.sh
```
References:
[1] http://hadoop.apache.org/
September 14, 2016