Author: kanakorn.h

วิธีติดตั้งระบบ Cyrus IMAP Cluster (Cyrus Murder)
ต่อจาก
Mail Clustering with Cyrus Murder และ How Cyrus Murder (Mail Clustering) work?

คราวนี้ มาลง รายละเอียดทีละขั้นตอน

ระบบ Cyrus IMAP Cluster หรือ Cyrus Murder นี้ ประกอบด้วยเครื่องคอมพิวเตอร์ ขั้นต่ำ 3 เครื่อง คือ frontend, backend, mupdate ต่อไปนี้ จะเป็นวิธีการทำ แต่ละเครื่อง

Prerequisite

ทั้งหมดเป็น Ubuntu 16.04 Server, ทำการ update และ upgrade แล้ว และ เข้า SSH ด้วย user ที่สามารถ sudo ได้ และรุ่นของ cyrus-imapd, cyrus-murder ที่ใช้เป็น 2.4.18
ทุกเครื่อง มี user ชื่อ ‘cyrus’ และ ทำการตั้งรหัสผ่านไว้เรียบร้อย
เฉพาะเครื่องที่เป็น Backend จะต้องมี uesr ชื่อ ‘mailproxy’ และทำการตั้งรหัสผ่านไว้เรียบร้อย ด้วยอีก 1 คน
ในที่นี้ จะใช้ pam-ldap ติดตั้งใน Backend ทุกเครื่อง

MUPDATE ( mupdate1.example.com )
1. ติดตั้ง cyrus-murder ด้วยคำสั่ง
```
sudo apt install cyrus-murder cyrus-common sasl2-bin
```
  ระบบจะติดตั้งตั้งโปรแกรมที่เกี่ยวข้อง รวมถึง postfix ด้วย ให้เลือกเป็น No configuration ไป
2. แก้ไขไฟล์ /etc/cyrus.conf ใน Section “SERVICES” ประมาณบรรทัดที่ 62 ให้ uncomment เพื่อได้บรรทัดนี้
```
mupdate       cmd="mupdate -m" listen=3905 prefork=1
```
  จุดสำคัญคือ mupdate -m คือ ตัวที่จะบอกว่า ทำหน้าที่เป็น MUPDATE Master
3. แก้ไขไฟล์ /etc/imapd.conf เพื่อกำหนด admins ในที่นี้ให้ใช้ชื่อ cyrus โดยการ uncomment ประมาณบรรทัดที่ 55
  และแก้ sasl_pwcheck_method เป็น saslauthd
```
sasl_pwcheck_method: saslauthd
sasl_mech_list: PLAIN
admins: cyrus
```
4. จากนั้น start ระบบขึ้นมา จะพบว่ามีการเปิด port 3905 รออยู่
```
sudo /etc/init.d/cyrus-imapd start
netstat -nl | grep 3905
```
5. แก้ไขไฟล์ /etc/default/saslauthd บรรทัดที่ 7
```
START=yes
```
  แล้ว start saslauthd
```
sudo /etc/init.d/saslauthd start
```
BACKEND ( backend01.example.com)
1. ติดตั้ง
```
sudo apt install cyrus-imapd cyrus-common cyrus-clients sasl2-bin
```
2. แก้ไขไฟล์ /etc/imapd.conf โดยเพิ่มบรรทัดต่อไปนี้ไว้ท้ายไฟล์
```
#SASL
sasl_pwcheck_method: saslauthd
sasl_mech_list: PLAIN

# MUPDATE
servername: backend01.example.com
admins: cyrus   
proxyservers:   mailproxy
lmtp_admins: mailproxy
mupdate_server: mupdate.example.com
mupdate_port: 3905
mupdate_username: cyrus
mupdate_authname: cyrus
mupdate_password: <secret>
```
3. แก้ไข /etc/cyrus.conf
  ใน START section ให้ uncomment
```
mupdatepush cmd="/usr/sbin/cyrus ctl_mboxlist -m"
```
4. เพิ่มส่วนนี้ ท้ายไฟล์ /etc/services ด้วย
```
#MUPDATE
mupdate 3905/tcp # MUPDATE
mupdate 3905/udp # MUPDATE
```
5. *** ติดตั้ง PAM LDAP
```
sudo apt-get install ldap-auth-client nscd
```
  ตั้งค่าต่อไปนี้
```
LDAP server Uniform Resource Identifier: ldap://ldap.your.domain/
Distinguished name of the search base: dc=example,dc=com
LDAP version to use: 3
Make local root Database admin: No
Does the LDAP database require login? No
```
  ต่อไป สั่งให้ระบบแก้ไขเงื่อนไขการ authen เป็น LDAP
```
sudo auth-client-config -t nss -p lac_ldap
```
  จากนั้นใช้คำสั่งต่อไปนี้ เพื่อเริ่มใช้งาน PAM LDAP
```
sudo pam-auth-update
```
  จะมีคำถามว่า
  PAM profiles to enable:
  ให้เลือกทั้ง
  Unix authentication และ
  LDAP Authentication
  
  สุดท้าย
```
sudo /etc/init.d/nscd restart
```
6. แก้ไขไฟล์ /etc/default/saslauthd บรรทัดที่ 7
```
START=yes
```
  แล้ว start saslauthd
```
sudo /etc/init.d/saslauthd start
```
FRONTEND ( frontend01.example.com )
1. ติดตั้ง
```
sudo apt install cyrus-imapd cyrus-common cyrus-clients sasl2-bin
```
2. แก้ไขไฟล์ /etc/imapd.conf โดยเพิ่มบรรทัดต่อไปนี้ไว้ท้ายไฟล์
```
#SASL
sasl_pwcheck_method: saslauthd
sasl_mech_list: PLAIN

# MUPDATE
mupdate_server: mupdate.example.com
mupdate_port: 3905
mupdate_username: cyrus
mupdate_authname: cyrus
mupdate_password: <secret>

#PROXY
serverlist: backend01.example.com
backend01_password: mailproxy
proxy_authname: mailproxy
```
3. แก้ไข /etc/cyrus.conf
  ใน SERVICE section ให้ uncomment
```
mupdate cmd="mupdate" listen=3905 prefork=1
```
4. เพิ่มส่วนนี้ ท้ายไฟล์ /etc/services ด้วย
```
#MUPDATE
mupdate 3905/tcp # MUPDATE
mupdate 3905/udp # MUPDATE
```
5. แก้ไขไฟล์ /etc/default/saslauthd บรรทัดที่ 7
```
START=yes
```
  แล้ว start saslauthd
```
sudo /etc/init.d/saslauthd start
```
และ เมื่อทุกอย่างพร้อม ทุกเครื่องก็
```
sudo /etc/init.d/cyrus-imapd restart
```
เมื่อจะเพิ่มเครื่อง Backend ก็ทำตามขั้นตอน แล้ว เพิ่มใน /etc/imapd.conf ของเครื่อง Frontend ในส่วนของ serverlist และ password เช่น
จะเพิ่มเครื่อง backend02.example.com ก็ต้องเพิ่มดังนี้
```
#PROXY
serverlist: backend01.example.com backend02.example.com
backend01_password: <secret>
backend02_password: <secret>
proxy_authname: mailproxy
```
เมื่อต้องการเพิ่ม Frontend ก็ให้ Sync ตัวไฟล์ /etc/imapd.conf ไปให้เหมือนกันทุกเครื่อง

หวังว่าจะเป็นประโยชน์
December 14, 2017
วิธีการใช้ Google Drive เป็น Private Git Repository
git คือ distributed revision control system

เรามักใช้ github.com สำหรับเก็บ source code แต่มัน public ซึ่ง บางทีเราก็ต้องการอะไรที่ private

ต่อไปนี้ คือวิธีการใช้งาน Google Drive เพื่อสร้าง Private Git Repository
1. ติดตั้ง Google Drive File Stream, git ให้เรียบร้อย
2. ใน Google Drive สร้าง Directory ชื่อ git ขึ้นมาที่ My Drive
  กรณี Google Drive File Stream ก็จะเห็นที่
  G:\My Drive\git
3. จากนั้น ก็สร้าง Working Directory เช่น ที่ Documents
  ในภาพ สร้างไว้ใน Documents\firebase\fmsworkshop
  จากนั้น คลิก Git Bash Here
4. ใช้คำสั่ง
```
git init
```
  เพื่อสร้าง .git ใน Directory นี้ก่อน
  จากนั้นใช้คำสั่งนี้ ที่มี –bare เพื่อสร้าง Remore Repository บน Google Drive
```
git init --bare "G:\My Drive\git\fmsworkshop.git"
```
5. บน Google Drive File Stream ก็จะมี fmsworkshop.git ปรากฏขึ้น
  ซึ่งต่อไปก็สามารถ git push ขึ้นไปเก็บไว้ได้แล้ว
6. ต่อไป ก็พัฒนาโปรแกรมไป
7. แล้ว ก็ git push ตามปรกติครับ
```
git add .
git commit -m "some text"
git push "G:\My Drive\git\fmsworkshop.git"
```
หวังว่าจะเป็นประโยชน์ครับ
November 23, 2017
GCP #01 วิธีการสร้าง Virtual Machine บน Google Cloud Platform
ขั้นตอน
1. มี Google Account
2. ไปที่ https://console.cloud.google.com/start
3. สำหรับคนที่ใช้ครั้งแรก ควรจะใช้สิทธิ์ Free Trial 300 USD / 12 Month
4. ในการใช้งาน จะต้องมี Billing Account โดยต้องกรอกข้อมูล บัตร Credit/Debit ซึ่งต้องเป็น VISA/MasterCard เท่านั้น และต้องไม่ใช่ Prepaid ด้วย
  https://cloud.google.com/billing/docs/how-to/payment-methods#add_a_payment_method
5. เมื่อเสร็จแล้วจะได้ Credit อย่างนี้
6. ต่อไป สร้าง Virtual Machine กัน
  ไปที่ เมนู > Cloud Launcher
  
  จะเห็นได้ว่า ตอนนี้ระบบจะสร้าง “My First Project” ไว้ให้ ซึ่งเราสามารถ สร้าง Project ใหม่ก็ได้ แต่ตอนนี้ใช้อย่างนี้ไปก่อน
7. ต่อไป จะลองสร้าง Ubuntu Server ขึ้นมาใช้งาน ในที่นี้จะสร้าง Ubuntu 14.04
  พิมพ์ Ubuntu ในช่องค้นหา แล้ว เลือก Ubuntu 14.04
8. จากนั้น คลิก Launch on Compute Engine
9. ตั้งชื่อตามต้องการ (ถ้าต้องการ)
10. สามารถเลือก Zone และ Machine Type ได้ตามความเหมาะสม ซึ่งจะมีราคาแตกต่างกัน
11. ค่าเริ่มต้น Machine Type: n1-standard-1 จะให้ 1 vCPU, 3.75 GB RAM และ 10 GB standard persistent disk หากต้องการ Disk เพิ่ม สามารถคลิก Change เพื่อเพิ่มได้ (standard persistent disk จะราคาถูกกว่า ssd มาก)
12. ต่อไป กำหนดเรื่องเของ Firewall ถ้าให้บริการ HTTP/HTTPS ก็คลิกเลือกได้เลย
  ในกรณีที่ต้องการกำหนดค่าอื่นๆ เช่น Disk, Network, SSH Key ให้คลิก “Management, disks, networking, SSH keys”
  เสร็จแล้วกดปุ่ม Create
13. รอสักครู่ ก็จะได้ VM มาใช้งานแล้ว
14. ในที่นี้ จะได้ External IP ซึ่งใช้ในการติดต่อจาก Internet มา แต่หากมีการ Restart/Stop IP address นี้ก็จะเปลี่ยนไป (การ Fix มีค่าใช้จ่ายนิดหน่อย) และ การติดต่อไปยัง VM ก็สามารถทำได้ โดยการคลิก SSH ซึ่งสามารถเข้าถึงได้จาก Console นี้ หากต้องการใช้งานจาก Client อื่นก็ทำได้ แต่ต้องกำหนด SSH Key กันนิดหน่อย ซึ่งจะกล่าวในภายหลัง
15. เพิ่มเติม ในกรณีต้องการเปิด Port เพิ่มที่ไม่ใช่ HTTP/HTTPS ให้คลิกที่ Menu > Network Services > Firewall Rules
  
  แล้วกำหนดค่าตามต้องการ โดยการ Create Firewall Rule
หวังว่าจะเป็นประโยชน์ครับ
November 14, 2017
Ambari #08 ปรับแต่ง pyspark ให้สามารถใช้งาน spark.ml ได้ ด้วย conda package management
เราสามารถใช้งาน Spark ในด้าน Machine Learning ด้วย pyspark แต่ปัญหาอยู่ที่ว่า python ที่ติดตั้งบน Ubuntu 14.04 นั้น ไม่มี package ที่จำเป็นต้องใช้ ได้แก่ numpy, scipy, scikit-learn, matplotlib ซึ่งขั้นตอนการติดตั้ง ก็จะยุ่งยาก เพราะต้อง compile code เองด้วย

แต่ปัจจุบัน มีเครื่องมือที่เรียกว่า “conda” ทำหน้าที่ติดตั้ง package ที่ต้องการได้สะดวก ในที่นี้ จะเลือกใช้ python 2.7 และ จะติดตั้งลงไปใน /opt/conda

ขั้นตอนการติดตั้ง conda
1. ไปเลือก setup script จาก https://conda.io/miniconda.html
2. ในการนี้ ขอให้ทำในสิทธิ์ของ root
```
sudo su
cd
```
3. Download script
  wget https://repo.continuum.io/miniconda/Miniconda2-latest-Linux-x86_64.sh
4. จากนั้น ใช้คำสั่งต่อไปนี้ เพื่อติดตั้ง conda ลงไปใน /opt/conda และ เลือกใช้ค่า default
  bash Miniconda2-latest-Linux-x86_64.sh -p /opt/conda -b
5. ติดตั้ง scikit-learn package ซึ่งจะติดตั้ง package อื่นๆที่จำเป็นสำหรับ spark.ml เข้ามาด้วย
  /opt/conda/bin/conda install scikit-learn -y
6. ทำขั้นตอน 3-6 กับ “ทุกๆ node” ใน Hadoop Cluster
ต่อไปตั้งค่า Zeppelin ให้สามารถใช้งาน conda แทน python เดิม
1. เปิด Zeppelin ขึ้นมา
2. คลิก Interpreter > ค้นหา spark
  
  แล้วคลิก edit
3. จากนั้น หาเลื่อนหาค่า pyspark.python แล้วแก้ไขเป็น /opt/conda/bin/python แล้วคลิก save
4. จากนั้นก็จะสามารถใช้งาน spark.ml ได้แล้ว
October 27, 2017
Ambari #07 เปรียบเทียบความเร็วของการ Query ระหว่าง MySQL กับ Hive
จากบทความก่อนหน้า

Ambari #05 การดึงข้อมูลเข้าจาก MySQL เข้าสู่ Hive ด้วย Sqoop ได้นำเข้าข้อมูล Mail Log จาก MySQL ซึ่งมีขนาด 27 GB มีข้อมูลประมาณ 12 ล้าน Record

ต่อไปจะเปรียบเทียบ การ Query ข้อมูลจาก Hive ซึ่งทำงานอยู่บน Hadoop Cluster กับ MySQL Server

Spec

MySQL Server: 1 Node x CPU 40 Core x RAM 8 GB

Hive: 7 Data Node x CPU 4 Core x RAM 4 GB

Query:
```
use mailscanner;
select from_domain,count(*) from maillog group by from_domain having from_domain like '%.com';
```
ซึ่ง from_domain เป็น Field ที่ไม่มีการทำ index

ผลการทดสอบ

MySQL: ใช้เวลา 5 นาที 23.90 วินาที = 329.90 วินาที

Hive: ใช้เวลา 92.754 วินาที

อนึ่ง : Hive ที่ใช้งานนั้น ทำงานบน Execution Engine ชื่อ Tez ซึ่งทำงานทั้งหมดบน Memory หากใช้งาน Hive ที่มากับ Apache โดยตรง จะใช้งาน MapReduce ซึ่งจะใช้เวลานานกว่ามาก (ยังไม่ได้ปรับแต่งให้ดีนัก)

แต่อย่างไรก็ดี Hive ไม่ได้ออกแบบมาใช้ทดแทน RDBMS เช่น MySQL/Oracle แต่เหมาะสำหรับการทำงานแบบ Data Warehouse มากกว่า ส่วนเหตุที่ MySQL แม้จะมีจำนวน Core มาก แต่ด้วยข้อจำกัด (โดย Default) ให้การ Group By นั้น จะใช้งานได้แค่ 1 Core เท่านั้น ! [1]

แต่เมื่อมองในมุมของ Hive สามารถนำเครื่องคอมพิวเตอร์ทั่วไป (Commodity Hardware) มารวมๆกันได้ ก็ทำให้สามารถขยายระบบได้แบบ Scale Out ก็น่าจะเป็นทางเลือกที่น่าสนใจ

Reference

[1] https://dev.mysql.com/doc/refman/5.5/en/innodb-performance-thread_concurrency.html
October 27, 2017
Ambari #06 การใช้งาน Zeppelin เพื่อเรียกข้อมูลจาก MySQL
ขั้นตอนการปรับแต่งให้ Zeppelin เชื่อมต่อกับ MySQL
ในที่นี้ จะเชื่อมต่อไปยัง MySQL Server: ที่ your.mysql.server โดยมี Username/Password เป็น root/123456 และจะใช้ Database ชื่อ employees
1. 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 ***
2. จาก Ambari Web UI เลือก Zeppelin Notebook > Quick Links > Zeppelin UI
3. ที่ Zeppelin UI ให้ Login ด้วย admin/admin
  แล้วคลิก Admin > Interpreter
4. คลิก Create
  กรอกข้อมูลต่อไปนี้
  Interpreter Name: employees
  Interpreter Group: jdbcแล้วเพิ่ม
  default.driver: com.mysql.jdbc.Driver
  default.url: jdbc:mysql://your.mysql.server:3306/employees
  default.user: root
  default.password: 123456ในส่วนของ Dependency ให้กำหนด
  artifact: mysql:mysql-connector-java:5.1.44
  
  แล้วกดปุ่ม Save
5. สร้าง Notebook ใหม่ ชื่อ mydatabase
  แล้วเลือก Default Interpreter เป็น employees
  แล้วคลิก Create Note
6. จากนั้น ก็จะสามารถส่ง Query ต่างได้
7. รวมถึง แสดง Graph ที่น่าสนใจได้
October 24, 2017
Ambari #05 การดึงข้อมูลเข้าจาก MySQL เข้าสู่ Hive ด้วย Sqoop
Apache Hive เป็นระบบ Data Warehouse ซึ่งสร้างอยู่บน Hadoop ใช้สำหรับการวิเคราะห์ข้อมูล โดยจุดเด่นคือการใช้คำสั่งภาษา SQL ในการเรียกข้อมูล ทั้งที่อยู่ในรูปแบบของ Database และไฟล์บน Hadoop ได้ เหมาะสำหรับการเก็บข้อมูลขนาดใหญ่มากๆ เช่น การเก็บข้อมูลที่ Rotate ออกจากฐานข้อมูลหลักอย่าง MySQL ก็นำมาเก็บไว้ใน MySQL เพื่อใช้วิเคราะห์ต่อไป

ในการดึงข้อมูลจาก MySQL จะแบ่งเป็น 2 ส่วน คือ
1. Full Backup คือการนำข้อมูลทั้งหมดจาก MySQL มาเก็บไว้ใน Apache Hive
2. Incremental Backup คือการดึงเฉพาะข้อมูลที่เพิ่มขึ้นมาเก็บไว้ใน Apache Hive
แต่ในบทความนี้ จะแนะนำการทำแบบ Incremental Backup ซึ่งในครั้งแรกจะทำ Full Backup และครั้งต่อๆไป จะทำ Incremental Backup เลย

Incremental Backup

sqoop ออกแบบมาให้สามารถ Run คำสั่งให้ทำงานทันทีก็ได้ หรือ จะสร้างเป็น Job เอาไว้ เพื่อใช้งานภายหลังก็ได้ ในที่นี้จะสร้างแบบ Job เพราะให้สะดวกในการทำ Incremental Backup
การสร้าง Sqoop Job ใช้คำสั่ง
```
 sqoop job --create JobName -- import ...
```
ในส่วนที่จะบอก sqoop ให้ทำงานแบบ incremental backup ต้องตามด้วย Options
```
--incremental append 
--check-column your_primary_key
```
ในตัวอย่างต่อไปนี้ จะสร้าง sqoop job ชื่อ maillog-incremental
ใช้คำสั่งต่อไปนี้ เพื่อดึงข้อมูลทั้งหมดจาก your.mysql.server ใน Database: mailscanner จาก Table: maillog โดยสมมุติใช้ username/password เป็น root/123456
แล้วนำมาใส่ใน Hive Database: mailscanner
เพิ่มเติมคือ ให้เก็บไว้ในรูปแบบ Paquet File
และ กำหนดให้ใช้ Field: timestamp เป็น Key เพื่อแบ่งงานเพื่อดึงข้อมูลแบบ Parallel ในที่นี้กำหนดให้แบ่งออกเป็น 10 ส่วนพร้อมๆกัน

UPDATE: sqoop job จะไม่ยอมให้ใส่ password ตรงๆ แต่จะต้องสร้างไฟล์ password เก็บไว้ใน hdfs และต้องเป็น mode 400 ให้ทำคำสั่งต่อไปนี้ก่อน
```
echo -n "123456" > mysqlpassword.txt
hdfs dfs -put mysqlpassword.txt mysqlpassword.txt
hdfs dfs -chmod 400 mysqlpassword.txt
```
แล้วจึงสร้าง sqoop job ด้วยคำสั่งต่อไปนี้
```
sqoop job --create maillog-incremental 
-- 
import 
--connect jdbc:mysql://your.mysql.server:3306/mailscanner 
--username root 
--password-file /user/hdfs/mysqlpassword.txt 
--table maillog 
--hive-database mailscanner 
--as-parquetfile 
--hive-import 
--split-by timestamp 
-m 10 
--incremental append 
--check-column timestamp
```
เมื่อสร้าง sqoop job เสร็จแล้ว สามารถเรียกดูได้ด้วยคำสั่ง
```
sqoop job --list
```
ดูรายละเอียดการทำงานได้ด้วย คำสั่ง
```
sqoop job --show maillog-incremental
```
และ สั่งให้ sqoop job ทำงานด้วยคำสั่ง
```
sqoop job --exec maillog-incremental
```
เมื่อทำการ Run ระบบก็จะแบ่งงานออกเป็น 10 ส่วนให้เครื่องใน Cluster ช่วยกัน Import เข้า Hive

ในการสั่งานครั้งแรก ระบบจะดึงข้อมูลทั้งหมดมาก่อน เช่น ในตัวอย่างนี้ ดึงมา 12 ล้าน record

แต่เมื่อสั่งอีกครั้ง ด้วยคำสั่ง
```
sqoop job --exec maillog-incremental
```
จะดึงเฉพาะส่วนที่เพิ่งเพิ่มเข้าม (233 records ตามภาพ)

ต่อไป ก็ตั้งเป็น cron ไว้เพื่อทำให้ทำงานทุกๆ 1 ชั่วโมงก็ได้
October 24, 2017
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
วิธีทำ Password-less SSH บน Ubuntu
ในการทำงานกับ Server Cluster ขนาดใหญ่ ซึ่งประกอบด้วย Ubuntu Server จำนวนมาก หากต้องแก้ไขระบบทั้งหมด โดยการ Secure Shell หรือ SSH เข้าไปทีละเครื่อง “โดยต้องเป็น root ด้วย” จะเป็นงานที่ใช้เวลาอย่างมาก เค้าจึงมีระบบที่เรียกว่า Password-less SSH โดยการแลกเปลี่ยน Public Key แทนที่จะต้อง Login ด้วย Username/Password

และเนื่องจาก Ubuntu โดย Default ไม่มีการสร้าง root password (มี root แต่ไม่มี password –> ก็เลย Login ไม่ได้ด้วย Password) ซึ่งก็ดีในเรื่องของ Security แต่ทำให้การทำงานยุ่งยากนิดหน่อย

บทความนี้จะกล่าวถึงวิธีการทำ Password-less SSH รวมไปถึง การที่ไม่ต้องถาม Known Host ในครั้งแรกที่เข้าใช้งานด้วย โดยระบบจะประกอบด้วย server01 เป็นเครื่องที่จะสั่งการเครื่อง server02 … serverNN ในสิทธิ์ root และในระบบนี้ ทุกเครื่องมี user ชื่อ mama ซึ่งมีสิทธิ์ sudo

ที่เครื่อง server01
1. ใช้คำสั่งต่อไปนี้ เพื่อสร้าง Public/Private rsa key pair
```
ssh-keygen
```
  จะได้ผลดังนี้
  
  ซึ่งจะได้ไฟล์มา 2 file อยู่ใน directory: ~/.ssh
  – id_rsa
  – id_rsa.pub
2. เพื่อไม่ให้การ SSH ไปยังเครื่องใหม่ๆ มีการถาม Known Host แบบนี้ แล้วก็ต้องคอยตอบ yes ทุกเครื่องไป
  
  ก็ให้สร้างไฟล์ .ssh/config ว่า (วิธีนี้จะมีผลเฉพาะ mama เท่านั้น) หรือสร้างใน /etc/ssh/ssh_config เพื่อให้มีผลทั้งระบบ
```
Host *
 StrictHostKeyChecking no
 UserKnownHostsFile=/dev/null
```
3. จากนั้น ให้เอาไฟล์ Public Key คือ .ssh/id_rsa.pub ไปยังเครื่องปลายทาง ในที่นี้คือ server02 (ใช้วิธี scp ไปยัง mama@server02)
```
scp .ssh/id_rsa.pub mama@server02:~
```
  ในครั้งแรกนี้ ยังต้องใส่ Password ของ mama บนเครื่อง server02 อยู่
  จากนั้น ไปดำเนินการต่อใน server02
ที่เครื่อง server02
1. ใน home directory ของ mama บน server02 จะมีไฟล์ id_rsa.pub อยู่ ลองตรวจสอบโดยใช้คำสั่ง
```
ls -l /home/mama/id_rsa.pub
```
2. เปลี่ยนเป็น root ด้วยคำสั่ง
```
sudo su
```
  แล้ว เข้าไปใน root home directory ด้วยคำสั่ง
```
cd
```
3. สร้าง directory .ssh และ สร้างไฟล์ .ssh/authorized_keys โดยนำข้อมูลในไฟล์ /home/mama/id_rsa.pub มาต่อท้าย
```
mkdir .ssh
cat /home/mama/id_rsa.pub >> .ssh/authorized_keys
```
4. เพื่อความปลอดภัย ตั้งค่า Permission ให้ถูกต้อง
```
chmod 700 .ssh
chmod 600 .ssh/authorized_keys
```
จากนั้น ลองทดสอบ ssh จาก mama บน server01 ไปยัง root บน server02
```
ssh root@server02
```
ก็จะไม่มีการถาม Password และ ไม่ถาม Known Host อีก

หลังจากนี้ สามารถ clone เครื่อง server02 ไปเป็นเครื่องต่างๆได้เลย
October 11, 2017