Category: Cluster & Load Balancing

เรียนรู้เกี่ยวกับ GlusterFS และวิธีติดตั้ง GlusterFS บน Ubuntu 16.04
อยากเอา Storage จากหลาย ๆ เครื่องมารวมกัน เครื่องพังไฟล์ไม่หาย แถมเข้าจากที่ไหนก็ได้ต้องทำอย่างไร

GlusterFS^[1] คือ filesystem รูปแบบหนึ่งสามารถรวม Storage จากหลาย ๆ เครื่อง และทำการกระจายข้อมูลเก็บโดยมีระบบคล้าย ๆ RAID ที่ช่วยป้องกันเวลาเครื่องใดเครื่องหนึ่งพัง โดย Access ได้หลาย Protocol แล้วแต่ว่าการทำไปใช้งานกับอะไร
Gluster FS มีโครงสร้างระบบไฟล์ 2 ส่วน^[2]คือ
- Brick คือ Directory ที่อยู่บนแต่ละเครื่อง โดยจะสร้าง Partition เพิ่มจาก Partition ปกติ (จะ Disk ใหม่ Disk เดิมก็ได้) หรือจะใช้เป็น Directory ที่อยู่บน Partition เดิมก็ได้ โดย recommend เวลาสร้าง partition ให้เป็น xfs (รองรับ inode หรือจำนวนไฟล์ได้สูงกว่า ext4 ถ้าใช้ ext4 อาจจะเจอว่าเนื้อที่ยังไม่หมดแต่สร้างไฟล์ไม่ได้แล้วเนื่องจาก inode หมด)
- Volume คือชุดของข้อมูลที่ให้บริการ กล่าวง่าย ๆ คือ การเอา Brick จากแต่ละเครื่องมาให้บริการภายใต้ Volume นั้น ๆ (อาจจะเทียบได้ประมาณ เอา HDD หลาย ๆ ก้อนมารวมกันแล้วทำ RAID 5 ตั้งชื่อ Volume แล้วผู้ใช้ก็มีหน้าที่ใช้งานอย่างเดียว)
ประเภทของ Volume^[3]
1. Distributed Glusterfs Volume : เป็น default volume ของ glusterfs คือการเมื่อสร้างไฟล์ลงใน volume นั้น ๆ ก็จะกระจายไปเก็บยัง Brick ต่าง ๆ ถ้าเครื่องไหน Brick พังไฟล์ในเครื่องนั้นก็จะพังไปด้วยเพราะไม่มีสำรอง ข้อดีที่คือประหยัดที่ ข้อเสียคือการป้องกันไฟล์เสียหายขึ้นอยู่กับ Hardware RAID เครื่องอย่างเดียว
2. Replicated Glusterfs Volume : รูปแบบนี้จะมีการทำสำเนาข้อมูลไฟล์นั้น ๆ ไปยังอีกเครื่อง ซึ่งจะตั้งให้เก็บกี่สำเนาก็ได้แล้วแต่จะกำหนด ถ้า Brick ใดเสียก็สามารถ Access ไฟล์นั้นจากอีก Brick แทน
3. Distributed Replicated Glusterfs Volume : รูปแบบนี้จะซับซ้อนขึ้นแต่ก็ประมาณ ไฟล์หนึ่งจะกำหนดให้เก็บกี่สำเนา ส่วนจะไปอยู่เครื่องใดบ้าง ระบบจัดการให้เอง แต่จำนวนสำเนาต้องสอดคล้องกับจำนวน Brick นั่นเอง (ผมไม่อธิบายมากนะครับ เพราะยังไม่ค่อยเข้าใจมากนั้น เพราะไม่ได้ลอง)
4. Striped Glusterfs Volume : คือการใช้หลักการในข้อ 1 เพิ่มเติมคือหั่นไฟล์ย่อย ๆ และเก็บกระจาย
5. Distributed Striped Glusterfs Volume : คือการใช้หลักการในข้อ 2 เพิ่มเติมคือหั่นไฟล์ย่อย ๆ และเก็บกระจายเช่นเดียวกัน
6. Distributed Replicated and Striped Glusterfs Volume : เป็นรูปแบบทีทั้งหั่นไฟล์ และสำเนาไฟล์ ซึ่งจะดีที่สุด แต่จะเปลืองเนื้อที่ที่สุด (ไม่มีรูปตัวอย่าง)
  ถ้าสรุปง่าย ๆ Strip เพื่อให้ได้เนื้อที่เยอะ ๆ โดยเอามาจากหลาย ๆ node ในส่วนของ Replicate เพื่อป้องกันข้อมูลหาย ตัวอย่างวิธีการคิดขนาดในแต่ละ Volume Type^[3]
ตัวอย่างการออกแบบผังการเชื่อมต่อเครือข่าย^[4]

ซึ่งที่แนะนำปกติจะให้มี Storage Network เพื่อใช้ในการคุยกันระหว่าง Block(ชื่อ Node) และมี Data Network สำหรับใช้ในการดึงข้อมูล และมี Management Network ไว้เผื่อในกรณีฉุกเฉิน Data Network ข้อมูลเต็ม จะได้เข้าไป Config อะไรได้

วิธีการติดตั้ง GlusterFS บน Ubuntu 16.04^[5]
1. ติดตั้ง ubuntu 16.04 ให้เรียบร้อย
2. เพิ่ม ppa เข้าไปใน apt ดังนี้
```
sudo apt install software-properties-common
sudo add-apt-repository ppa:gluster/glusterfs-3.8
```
3. จากนั้นทำการ Update และ ติดตั้ง Glusterfs Server
```
sudo apt update
sudo apt install glusterfs-server
```
4. Start Glusterfs Server
```
sudo service glusterfs-server start
```
5. สุดท้ายต้องทำการเปิด Firewall ให้เครื่องที่จะให้ใช้งานเข้าถึงดังนี้ (ถ้าจะระบุ Port ให้ระบุ TCP 24007-24008 และ TCP 49152-49156)
```
sudo ufw allow from 10.x.x.x
sudo ufw allow from 192.x.x.x
sudo ufw allow ssh
sudo ufw default deny incoming
sudo ufw default alllow outgoing
sudo ufw enable
```
วิธีการสร้าง xfs partition บน Ubuntu 16.04^[6]
1. ทำการจัดการ Partition ด้วย fdisk (ในกรณีขนาดเกิน 2TB ต้องใช้ parted ซึ่งไม่ขออธิบายครับ) ในตัวอย่างเป็น sdb
```
sudo fdisk /dev/sdb
```
2. กด n (New Partition) ตามด้วย p (Primary Partition) จากนั้นกด Enter ไป 3 ครั้ง จบด้วยกด w (Write Partition)
3. จากนั้นทำการสร้าง Partition ด้วย mk.xfs
```
sudo mkfs.xfs /dev/sdb1
```
4. จากนั้นทำการสร้าง path ที่ต้องการ mount ยกตัวอย่างดังนี้
```
sudo mkdir /cluster
```
5. ทำการแก้ fstab เพื่อให้ automount ทุกครั้งที่ boot ดังนี้
```
sudo vim /etc/fstab
```
6. เพิ่มข้อความท้ายไฟล์ประมาณนี้
```
/dev/sdb1      /cluster      xfs     defaults     0      0
```
7. สั่ง mount (ในกรณีที่ไม่ได้รีเครื่อง)
```
sudo mount -a
```
8. สามารถใช้งาน path ที่ mount ได้แล้ว
วิธี config glusterfs cluster node บน ubuntu 16.04

โดยขั้นต้นในการสื่อสารระหว่าง node ต้องมีชื่อ node ซึ่งเครื่องแต่ละเครื่องจะจด domain ก็ได้ แต่ในที่นี้ใช้วิธีกำหนดไปใน host ไฟล์ (ป้องกัน dns หรือ data network มีปัญหา server ก็จะยังคุยกันได้ แต่ถ้าต้องการให้ client ใช้งานได้ต้องจดชื่อจริงทั้งหมด เพราะเมื่อ client ต่อก็จะมีการไล่ check ไปตาม node อื่น ๆ ด้วย ถ้าไม่จดชื่อจะ mount ไม่สำเร็จ) ทำได้ดังนี้
- ทำการแก้ไขไฟล์ /etc/hosts
```
sudo vim /etc/hosts
```
- เพิ่มข้อความในส่วนของ ipv4 ประมาณนี้ครับ
```
10.x.x.10 gluster-cluster1.x.y.z gluster-cluster1
10.x.x.11 gluster-cluster2.x.y.z gluster-cluster2
10.x.x.12 gluster-cluster3.x.y.z gluster-cluster3
10.x.x.13 gluster-cluster4.x.y.z gluster-cluster4
```
- ทำการค้นหา node อื่น ๆ ให้เข้ามาอยู่ใน cluster เดียวกันดังนี้ (เข้าทีหลังเครื่อง และค้นหาเฉพาะที่ไม่ใช่ node ตัวเอง) ยกตัวอย่างคำสั่งที่ใช้ใน gluster-cluster1 (ทำแค่ node เดียว)
```
sudo gluster peer probe gluster-cluster2.x.y.z
sudo gluster peer probe gluster-cluster3.x.y.z
sudo gluster peer probe gluster-cluster4.x.y.z
```
- คำสั่งที่ใช้ในการดูสถานะของ node ใน cluster ซึ่งเมื่อดูจาก node ที่ไม่ได้เพิ่มก็จะขึ้นสถานะเหมือนกัน
```
sudo gluster peer status
```
- คำสั่งสำหรับดู pool list (อีกมุมมอง) ใช้คำสั่งดังนี้
```
sudo gluster pool list
```
- ในกรณีที่ต้องการเอาเครื่องออก สั่งดังนี้
```
sudo gluster peer detach <node> force
```
วิธีการสร้าง glusterfs volume บน ubuntu 16.04^[2]

ยกตัวอย่างจากหัวข้อก่อนหน้า กำหนดให้ใช้ Volume Type แบบ Distributed Replicated and Striped Glusterfs Volume มี 4 node (4 brick) โดย Stripe ข้อมูล 2 node และกำหนดให้ Replicate จำนวน 2 ชุดข้อมูล (พังได้ 1 node ที่เป็นคู่กัน)
- ทำการสร้าง Volume ตามเงื่อนไขข้างต้น
```
sudo gluster volume create cluster1_volume replica 2 strip 2 \
transport tcp \
gluster-cluster1.x.y.z:/cluster \
gluster-cluster2.x.y.z:/cluster \
gluster-cluster3.x.y.z:/cluster \
gluster-cluster4.x.y.z:/cluster \
force
```
- จากนั้นทำการ Start volume
```
sudo gluster volume start cluster1_volume
```
- ทำการตรวจสอบ volume ดังนี้
```
sudo gluster volume list
```
- อีกคำสั่งในการตรวจสอบทำได้ดังนี้
```
sudo gluster volume status
```
- ในกรณีที่ต้องการ Stop volume ใช้คำสั่งดังนี้
```
sudo gluster volume stop cluster1_volume
```
- คำสั่งในการลบ volume ดังนี้
```
sudo gluster volume delete cluster1_volume
```
วิธีการ mount glusterfs จาก client บน ubuntu 16.04^[7]
- ให้สร้างเครื่อง client ubuntu 16.04 เพื่อเชื่อมต่อ glusterfs
- ทำการติดตั้ง glusterfs-client
```
sudo apt install glusterfs-client attr
```
- ทำการทดสอบ mount ไปยัง glusterfs-server ตามที่ตั้งไว้ในหัวข้อข้างต้น (ต้องจดชื่อที่แล้ว ถ้าไม่ได้จดต้องบันทึก list server ทั้งหมดใน /etc/hosts เช่นเดียวกัน)
```
sudo mkdir /glusterfs
sudo mount -t glusterfs gluster-cluster1.x.y.z:/cluster1_volume /glusterfs
```
- หลังจากนั้นจะได้ mount volume ซึ่งสามารถใช้งานได้เลยดังรูป
- ในกรณีที่ต้องการสร้างเป็น fstab สามารถทำได้โดยแก้ไข /etc/fstab ดังนี้
```
sudo vim /etc/fstab
```
- ทำการเพิ่มท้ายไฟล์ประมาณนี้ครับ
```
gluster-cluster1.x.y.z:/cluster1_volume /glusterfs glusterfs defaults,_netdev 0 0
```
ทดสอบใช้งาน GlusterFS
- ทดสอบให้ gluster volume เป็นแบบ 2 stripe และ 2 replica และให้ client ต่อไปยัง cluster1 ด้วยการ mount
- จากนั้นทำการทดสอบสร้าง image ขนาด 5.2 GB ด้วยคำสั่ง dd ที่ client ดังนี้
```
sudo dd if=/dev/zero of=test.img bs=512K count=10000
```
  ผลลัพธ์ได้ดังรูป
จะเห็นได้ว่า ระบบจะแบ่งไฟล์ออกเป็น 2.5G และทำการ replicate กระจายไปยังอีกคู่ node (1:2->3:4)
- จากนั้นทดสอบปิด glusterfs server node 1 ที่ client กำลังต่ออยู่ดูว่ายังเข้าถึงไฟล์จาก node อื่นได้ไหม
จากการทดสอบพบว่ายังสามารถเข้าถึงไฟล์ได้อยู่ ซึ่งเมื่อสั่ง netstat ดูจะพบว่าเครื่องยังต่อไปยัง cluster ที่เหลืออยู่
- การทดสอบสุดท้าย ทดสอบสร้างไฟล์ขณะที่ glusterfs server node 1 ปิดอยู่ แล้วลองเปิด node 1 กลับเข้ามา active ดูว่าไฟล์จะมาไหม ผลที่ได้คือไฟล์ถูก sync หลังจาก เปิด node 1 ขึ้นมา
ซี่งปกติแล้ว Port TCP 24007-24008 ใช้สำหรับตรวจสอบข้อมูลของ GlusterFS Server node ต่าง ๆ (เดาว่าถ้าเราปิด node 1 ถ้ามีการเพิ่ม node อาจจะไม่เห็น node ใหม่ ใครว่างลองทดสอบดูครับ) และ TCP 49152-49156 ใช้สำหรับโอนถ่ายข้อมูล
- จากการทดสอบสร้างไฟล์บน server พบว่าไม่มีการกระจายไฟล์ (เนื่องจากสร้างโดยไม่ผ่าน glusterfs-client) เพราะฉนั้นควรสร้างผ่านการ mount เป็น glusterfs เท่านั้น
หวังว่าไม่ยาวไปนะครับ ไม่อยากแยกหลายบทความเดี๋ยวจะงง เอาเป็นบทความเดียวจบเลยนะครับ ตอนหน้าน่าจะพูดถึง docker management tools อย่าง kubernetes หรือไม่ก็ rancher ครับ……

==================================
Reference :

[1] Gluster : https://www.gluster.org/

[2] How to install and use GlusterFS : https://www.rmuti.ac.th/user/prakai/w/images/9/9c/How-to-install-and-use-GlusterFS-ARIT-Net-3.pdf

[3] GlusterFS Storage Cluster on CentOS 7 : https://wiki.centos.org/HowTos/GlusterFSonCentOS

[4] Gluster Docs – Architecture : http://gluster.readthedocs.io/en/latest/Quick-Start-Guide/Architecture/

[5] Gluster Docs – Install Gluster : https://gluster.readthedocs.io/en/latest/Install-Guide/Install/

[6] Format a Volume as XFS in Debian and Ubuntu : https://linhost.info/2012/08/format-a-volume-as-xfs-in-debian-and-ubuntu/

[7] Install and Configure GlusterFS on Ubuntu 16.04 / Debian 8 : http://www.itzgeek.com/how-tos/linux/ubuntu-how-tos/install-and-configure-glusterfs-on-ubuntu-16-04-debian-8.html
May 5, 2017
วิธีสร้าง CoreOS Cluster
จะสร้าง CoreOS ให้กลายเป็น Cluster Docker Container ได้อย่างไร

จากบทความที่แล้วที่แนะนำเกี่ยวกับ CoreOS และการติดตั้งบน Vmware^[1] ไปแล้วนั้น เราก็สามารถสร้างให้เป็นในรูปแบบ Cluster ได้ โดยมองว่าเครื่องแต่ละเครื่องที่สร้างนั้นเป็น Node หนึ่ง ๆ ใน Cluster โดยใช้ etcd เป็นตัวเก็บข้อมูลของ Node และ Fleet เป็นตัว Deploy docker ให้กระจายไปยัง Node ต่าง ๆ อย่างเหมาะสม โดยที่จะสามารถย้ายตัวเองได้เมื่อมีเครื่องใดเครื่องหนึ่งมีปัญหา (Recommend จำนวนเลขคี่ และอย่างต่ำต้อง 3 node ขึ้นไป ยิ่งเยอะ โอกาสล่มก็ยิ่งต่ำ)

etcd ในปัจจุบันเป็น Version 3 ซึ่งจะมีประสิทธิภาพเพิ่มขึ้นจาก Version 2 (แต่ใน document web ยังเป็น etcd2 เป็นส่วนมาก) โดยใช้สำหรับเก็บข้อมูลแต่ละ Node ทำให้รู้ว่าในแต่ละ Cluster มีเครื่องใด IP อะไรบ้าง มีทั้งหมด 3 วิธีคือ
1. Static เป็นวิธีที่ระบุลงไปเลยในแต่ละเครื่องว่ามีเครื่องไหนบ้างที่อยู่ใน Cluster วิธีการนี้ข้อเสียคือถ้าเพิ่มต้องเพิ่มทุกเครื่อง
2. etcd Discovery เป็นวิธีที่จะให้ Discovery Service เป็นคนทำหน้าที่เก็บข้อมูล (เหมือน tracker torrent) เมื่อเพิ่มเครื่องใหม่ ก็แค่ชี้ไป Discovery URL ก็เสร็จ
3. DNS Discovery เป็นวิธีการใช้วิธีการจด DNS ในรูปแบบ SRV record เพื่อบอกว่า บริการนี้มีเครื่องอะไรอยู่บ้าง ซึ่งจะมีการอ้างอิงอยู่กับ Domain Name โดยวิธีนี้จำเป็นต้องจดชื่อ Domain ทุกเครื่อง
ในบทความนี้จะอธิบายวิธีที่ 1 ซึ่งแม้ยุ่งยาก แต่เหมาะกับระบบที่ Internet Public ไม่ค่อยเสถียร และ ถ้าใครต้องการลองวิธีอื่นสามารถตามอ่านได้ใน Web CoreOS^[2] ครับ

วิธีการตั้งค่า etcd2
- ทำการสร้าง service etcd2 service ด้วย systemd ดังนี้
```
sudo vim /etc/systemd/system/etcd2.service
```
- ข้อความในไฟล์มีดังนี้ (ถ้าต้องการความปลอดภัยสามารถใช้ https ได้ครับ แต่ต้องมีการทำ certificate เพิ่มเติม ซึ่งไม่ขออธิบายครับ)
```
[Unit]
Description=etcd2
Conflicts=etcd.service

[Service]
User=etcd
Type=notify
Environment=ETCD_DATA_DIR=/var/lib/etcd
ExecStart=/usr/bin/etcd2 --name node01 --initial-advertise-peer-urls http://[IP]:2380 \
 --listen-peer-urls http://[IP]:2380 \
 --listen-client-urls http://[IP]:2379,http://127.0.0.1:2379 \
 --advertise-client-urls http://[IP]:2379 \
 --initial-cluster-token etcd-cluster-1 \
 --initial-cluster node01=http://[IP_node01]:2380,node02=http://[IP_node02]:2380,node03=http://[IP_node03]:2380 \
 --initial-cluster-state new

Restart=always
RestartSec=10s
LimitNOFILE=40000
TimeoutStartSec=0

[Install]
WantedBy=multi-user.target
```
- Enable etcd2 service เพื่อให้รันทุกครั้งที่เปิดเครื่อง
```
sudo systemctl enable etcd2
```
- Start etcd2 service
```
sudo systemctl start etcd2
```
- ตรวจดูสถานะการทำงานของ etcd2 service
```
sudo systemctl status etcd2
```
- เราสามารถดูข้อมูลสมาชิกได้ดังนี้
```
etcdctl member list
```
วิธีการตั้งค่า Fleet
- ทำการสร้าง service fleet โดยการตั้งค่าใน systemd ดังนี้
```
sudo vim /etc/systemd/system/fleet.service
```
- ข้อความในไฟล์มีดังนี้ (จะเห็นว่า config ตั้งค่าให้ Start หลัง etcd2)
```
[Unit]
Description=fleet daemon

After=etcd2.service

Wants=fleet.socket
After=fleet.socket

[Service]
User=fleet
Environment=GOMAXPROCS=1
Environment="FLEET_PUBLIC_IP=[IP]"
ExecStart=/usr/bin/fleetd
Restart=always
RestartSec=10s

[Install]
WantedBy=multi-user.target
```
- Enable fleet service เพื่อให้รันทุกครั้งที่เปิดเครื่อง
```
sudo systemctl enable fleet
```
- Start fleet service
```
sudo systemctl start fleet
```
- ตรวจดูสถานะการทำงานของ fleet service
```
sudo systemctl status fleet
```
- วิธีตรวจดูสถานะแต่ละ Node ทำได้ดังนี้
```
fleetctl list-machines
```
- จะได้ผลลัพธ์หน้าตาประมาณนี้ครับ
ให้ทำการติดตั้งไปเรื่อย ๆ ทั้ง CoreOS->Etcd2->Fleet จนครบ 3 เครื่อง หรือ 5,7,9 เครื่องแล้วแต่จะต้องการว่าจะสร้างกี่ Node ครับ ยกตัวอย่างถ้าครบ 3 เครื่องก็จะได้ประมาณนี้ครับ

ทดสอบการสร้าง WordPress ผ่าน Fleet^[3]
- วิธีการทำแน่นอนครับ หนีไม่พ้นไฟล์รูปแบบ systemd (อีกแล้ว) แต่ไม่ต้องรันด้วย systemctl นะครับ ทำที่เครื่องใดเครื่องหนึ่ง สร้างที่ /home/core ก็ได้ดังนี้
- ก่อนอื่นต้องติดตั้ง docker mysql โดยสร้างไฟล์ mysql.service ดังนี้
```
vim mysql.service
```
- ข้อความในไฟล์ประมาณนี้ครับ
```
[Unit]
Description=MySQL DataBase
After=etcd.service
After=docker.service

[Service]
TimeoutStartSec=0
ExecStartPre=-/usr/bin/docker kill mysql
ExecStartPre=-/usr/bin/docker rm mysql
ExecStartPre=/usr/bin/docker pull mysql:5.7
ExecStart=/usr/bin/docker run --name mysql -e MYSQL_ROOT_PASSWORD="wordpress" -e MYSQL_DATABASE="wordpress" -e MYSQL_USER="wordpress" -e MYSQL_PASSWORD="wordpress" mysql:5.7
ExecStop=/usr/bin/docker stop mysql
```
- สร้างไฟล์ wordpress.service ดังนี้
```
vim wordpress.service
```
- ข้อความในไฟล์ประมาณนี้ครับ
```
[Unit]
Description=WordPress
After=mysql.service

[Service]
TimeoutStartSec=0
ExecStartPre=-/usr/bin/docker kill wordpress
ExecStartPre=-/usr/bin/docker rm wordpress
ExecStartPre=/usr/bin/docker pull wordpress
ExecStart=/usr/bin/docker run --name wordpress --link mysql -p 8880:80 -e WORDPRESS_DB_PASSWORD=wordpress -e WORDPRESS_DB_NAME=wordpress -e WORDPRESS_DB_USER=wordpress wordpress
ExecStop=/usr/bin/docker stop wordpress

[X-Fleet]
X-ConditionMachineOf=mysql.service
```
- สั่ง Start mysql service ด้วย fleetctl ดังนี้
```
fleetctl start mysql.service
```
- สั่ง Start wordpress service ด้วย fleetctl ดังนี้
```
fleetctl start wordpress.service
```
- สั่งคำสั่งเพื่อตรวจสอบสถานะดังนี้ (ซึ่งจะบอกว่าติดตั้งที่ Node ใด และสถานะการใช้งาน หรือการติดตั้งเป็นอย่างไร)
```
fleetctl list-units
```
- เสร็จแล้วลองสั่ง fleetctl list-units ที่ Node อื่น ๆ ดูครับก็จะได้ผลลัพธ์เหมือน ๆ กัน
- ก็จะได้ web wordpress เอาไว้ใช้งานแล้ว
- จากนั้นทดสอบลองปิด Node ดูครับ สำหรับระบบที่มี 3 Node พังได้แค่ Node เดียวครับ ถ้าอยากได้มากกว่านั้นต้องเพิ่มจำนวน Node ขึ้นไป
- จะพบว่าเครื่องจะย้ายไป Start อีก Node ทันที (มันจะสั่ง start ใหม่นะครับ ไม่ได้ย้ายไปแบบ vmware) เท่าที่ทดสอบข้อมูลไม่ได้มาด้วยครับ อีกทั้งยังได้ ip ที่เครื่องใหม่ เพราะฉะนั้นต้องหาวิธีทำ map volume และ proxy web เอาเองครับ
(Optional) วิธีการ Fix IP แทน DHCP
- ในกรณีที่ต้องการ Fix IP แทน DHCP ให้เข้าไปสร้าง systemd network config โดยสร้างไฟล์ดังนี้
```
sudo vim /etc/systemd/network/static.network
```
- ข้อความในไฟล์ประมาณนี้ครับ
```
[Match]
Name=[Interface Name]

[Network]
Address=[IP/Mask]
Gateway=[IP Gateway]
DNS=[DNS IP มีหลาย IP ให้เว้นวรรค เช่น 10.0.0.1 10.0.0.2]
```
- จากนั้นให้ทำการ Restart เครื่อง (จริง ๆ restart service ก็น่าจะได้ แต่ลองแล้วไม่ได้ครับ)
สำหรับ CoreOS Cluster ก็มีเท่านี้ครับ แต่จะเห็นว่ายังขาด Docker Management ที่เป็น GUI รวมถึง Docker Gateway และระบบ Storage ติดตามในตอนต่อ ๆ ไปแล้วกันครับ

==================================

Reference :

[1] มารู้จักกับ CoreOS Linux และวิธีติดตั้ง CoreOS Linux บน Vmware : https://sysadmin.psu.ac.th/2017/05/03/coreos-linux-install-vmware/

[2] CoreOS Clustering Guide : https://coreos.com/etcd/docs/latest/op-guide/clustering.html#etcd-discovery

[3] Deploy WordPress in CoreOS Cluster using Fleet : https://wenfeng-gao.github.io/2016/06/03/deploy-wordpress-in-coreos-cluster-using-fleet.html
May 4, 2017
Kafka #01 Basic Installtion
Apache Kafka เป็น distributed streaming platform [1] กล่าวคือ สามารถ Publish และ Subscribe ข้อมูลแบบ Streaming ได้ คล้ายๆกับ Message Queue หรือ Enterprise Messaging System ระบบนี้ใช้ได้ทั้งเป็น Real-time Streaming Data Pipeline และ สร้าง Streaming Application ได้ Apache Kafka ออกแบบมาให้สามารถทำงานเป็นแบบ Cluster โดยเก็บข้อมูลเป็น Stream of Record ซึ่งจัดหมวดหมู่ในรูปของ Topics ข้อมูลแต่ละ Record ประกอบด้วบ Key, Value และ timestamp

เอาเป็นว่า ระบบนี้เอาไว้สำหรับรองรับการส่งข้อมูลแนวๆ Streaming มาเพื่อทำการวิเคราะห์แบบ Real-Time แทนที่จะต้องบริหารเองก็แล้วกัน แถมด้วยความสามารถในการ Subscribe ข้อมูล สามารถย้อนไปดูข้อมูลก่อนหน้าได้ (ตามขอบเขตเวลาที่กำหนด) มาติดตั้งกัน

บทความนี้ ทดสอบบน Ubuntu 16.04
1. ไป Download และ ติดตั้ง
  จาก https://www.apache.org/dyn/closer.cgi?path=/kafka/0.10.2.0/kafka_2.11-0.10.2.0.tgz
  ด้วยคำสั่ง
```
wget http://www-eu.apache.org/dist/kafka/0.10.2.0/kafka_2.11-0.10.2.0.tgz
tar -zxvf kafka_2.11-0.10.2.0.tgz
cd kafka_2.11-0.10.2.0
```
2. Kafka ทำงานบน Zookeeper ดังนั้นให้เริ่มทำงานด้วยคำสั่ง
```
bin/zookeeper-server-start.sh config/zookeeper.properties &
```
  แล้วจึง สั่ง Start Kafka
```
bin/kafka-server-start.sh config/server.properties &
```
3. ต่อไป Producer กับ Consumer จะติดต่อกันผ่าน Topic จึงต้องสร้าง topic ด้วยคำสั่งต่อไปนี้
```
bin/kafka-topics.sh --create --zookeeper localhost:2181 --replication-factor 1 --partitions 1 --topic test
```
  ซึ่งในที่นี้ จะได้ Topic ชื่อ test ทำงานบน Zookeeper บน Localhost ที่ Port 2181
  ลองใช้คำสั่งต่อไปนี้เพื่อดู Topic ทั้งหมด
```
bin/kafka-topics.sh --list --zookeeper localhost:2181
```
4. ทดลองส่งข้อมูลเข้าไปให้ Kafka ซึ่งจะทำงานที่ Localhost ที่ Port 9092
```
bin/kafka-console-producer.sh --broker-list localhost:9092 --topic test
```
  แล้วลองพิมพ์ข้อความอะไรลงไปดู เช่น
```
Hello World
This is a book
Blah Blah
```
5. ลองเปิดอีก Terminal ขึ้นมา แล้วใช้คำสั่งต่อไปนี้
```
bin/kafka-console-consumer.sh --bootstrap-server localhost:9092 --topic test --from-beginning
```
  ก็จะเห็นได้ว่า สามารถเรียกดูสิ่งที่ส่งเข้าไปใน Topic “test” ตั้งแต่เริ่มต้นได้
ตรงนี้ยังไม่แปลกอะไร และไม่น่าตื่นเต้นอะไร บทความต่อไปจะกล่าวถึงการสร้างเป็น Cluster แล้วก็ทำงานกับ หลายๆ Producer และ หลายๆ Consumer พร้อมๆกัน

Reference
1. https://kafka.apache.org/intro
April 16, 2017
Oracle MySQL Cluster :- The shared-nothing architecture (Manual Installation)
1. สิ่งที่ต้องเตรียม ได้แก่ Ubuntu Server 16.04 (รุ่น x86_64 architecture) จำนวนอย่างน้อย 4 เครื่อง (แต่ควรอย่างน้อย 6 เครื่อง), IP Address 4 IP, Software MySQL Cluster โหลดที่ https://edelivery.oracle.com/ (ต้องสมัครสมาชิกให้เรียบร้อยก่อน) ใช้คำค้นว่า MySQL Cluster (จะมีรุ่น 7.5.5 ให้โหลด) โดยไฟล์ที่ใช้งานชื่อว่า V840854-01.zip MySQL Cluster 7.5.5 TAR for Generic Linux (glibc2.5) x86 (64bit)
2. 4 เครื่องประกอบด้วยอะไรบ้าง
  2 x data nodes เปลี่ยน IP ให้ตรงกับที่ใช้งาน
  192.168.106.32 Data-node1
  192.168.106.33 Data-node2
  1 x SQL/NoSQL Application Node
  192.168.106.42 SQL-Node
  1 x Management Node
  192.168.106.40 Management-node
3. เริ่มที่ Management Node
  1. ssh 192.168.106.40 -l sudo_user (user ที่เรียกใช้คำสั่ง sudo ได้)
  2. คลายแฟ้ม V840854-01.zip ด้วยคำสั่ง
    unzip V840854-01.zip (อาจต้องติดตั้งเพิ่มเติมด้วยคำสั่ง sudo apt install unzip)
  3. จะได้แฟ้ม mysql-cluster-advanced-7.5.5-linux-glibc2.5-x86_64.tar.gz คลายแฟ้ม mysql-cluster-advanced-7.5.5-linux-glibc2.5-x86_64.tar.gz ด้วยคำสั่ง
    tar zxvf mysql-cluster-advanced-7.5.5-linux-glibc2.5-x86_64.tar.gz
  4. เปลี่่ยนชื่อ mysql-cluster-advanced-7.5.5-linux-glibc2.5-x86_64 เป็น mysql
    mv mysql-cluster-advanced-7.5.5-linux-glibc2.5-x86_64 mysql
  5. คัดลอกแฟ้ม mysql/bin/ndb_mgmd และ mysql/bin/ndb_mgm ไปไว้ที่ /usr/local/bin
    cp mysql/bin/ndb_mgm* /usr/local/bin/
  6. สร้างโฟลเดอร์ /var/lib/mysql-cluster และสร้างแฟ้ม /var/lib/mysql-cluster/config.ini
    sudo mkdir -p /var/lib/mysql-cluster/
  7. เพื่อเป็นการบอก Management node ว่า Data Node และ SQL Node มีใครบ้าง ให้สร้าง config.ini ไว้ที่ /var/lib/mysql-cluster ด้วยคำสั่ง
    cat<< EOF | sudo tee /var/lib/mysql-cluster/config.ini
    เพิ่มข้อความต่อไปนี้ลงไป
    [ndbd default] NoOfReplicas=2 DataMemory=80M IndexMemory=18M [mysqld default] [ndb_mgmd default] [tcp default]# Cluster Control / Management node
    [ndb_mgmd]
    hostname=192.168.106.40# Data Node 1
    [ndbd]
    hostname=192.168.106.32
    DataDir= /var/lib/mysql-cluster# Data Node 2
    [ndbd]
    HostName=192.168.106.33
    DataDir=/var/lib/mysql-cluster# SQL Node
    [mysqld]
    hostname=192.168.106.42
    
    # If you to add new SQL Node
    [mysqld]
    
    EOF
  8. เพิ่มข้อความต่อไปนี้ในแฟ้ม /etc/rc.local
    /var/lib/mysql-cluster/config.ini --configdir=/var/lib/mysql-cluster/
    โดยเพิ่มให้อยู่บรรทัดก่อนคำว่า exit 0 ตัวอย่าง /etc/rc.local
    #!/bin/sh -e
    #
    # rc.local
    #
    # This script is executed at the end of each multiuser runlevel.
    # Make sure that the script will "exit 0" on success or any other
    # value on error.
    #
    # In order to enable or disable this script just change the execution
    # bits.
    #
    # By default this script does nothing.ndb_mgmd -f /var/lib/mysql-cluster/config.ini --configdir=/var/lib/mysql-cluster/
    exit 0
  9. สั่งคำสั่ง
    sudo ndb_mgmd -f /var/lib/mysql-cluster/config.ini --configdir=/var/lib/mysql-cluster/ต้องเห็นข้อความว่า MySQL Cluster Management Server mysql-5.7.17 ndb-7.5.5 แปลว่า management node ทำงานแล้ว
  10. สามารถตรวจสอบด้วยคำสั่งอื่นๆ
    netstat -plntuได้ผลดังภาพ สังเกตุบรรทัดที่เขียนว่า tcp 0 0 0.0.0.0:1186 แปลว่า management node ทำงานแล้ว
  11. สามารถทำซ้ำได้อีกเครื่อง (ไม่จำกัด) แต่ในตัวอย่างนี้มีเพียงเครื่องเดียว
  12. ส่งแฟ้ม mysql-cluster-advanced-7.5.5-linux-glibc2.5-x86_64.tar.gz ให้ SQL node
    cd scp mysql-cluster-advanced-7.5.5-linux-glibc2.5-x86_64.tar.gz sudo_user@192.168.106.42
4. ติดตั้ง SQL Node
  1. ssh 192.168.106.42 -l sudo_user (User ที่สามารถเรียกใช้คำสั่ง sudo ได้)
  2. ติดตั้ง Package ที่จำเป็น
    sudo apt install libaio1
  3. สร้าง user และ group
    sudo groupadd mysql
    sudo useradd -g mysql mysql
  4. คลายแฟ้ม mysql-cluster-advanced-7.5.5-linux-glibc2.5-x86_64.tar.gz ด้วยคำสั่ง
    tar zxvf mysql-cluster-advanced-7.5.5-เพิ่มข้อความต่อไปนี้ในแฟ้ม /etc/rc.local /var/lib/mysql-cluster/config.ini --configdir=/var/lib/mysql-cluster/ โดยเพิ่มให้อยู่บรรทัดก่อนคำว่า exit 0 ตัวอย่าง /etc/rc.locallinux-glibc2.5-x86_64.tar.gz
  5. เปลี่่ยนชื่อ mysql-cluster-advanced-7.5.5-linux-glibc2.5-x86_64 เป็น mysql
    mv mysql-cluster-advanced-7.5.5-linux-glibc2.5-x86_64 mysql
  6. ย้าย mysql ไปที่ /usr/local/ ด้วยคำสั่ง
    sudo mv mysql /usr/local
  7. สร้างโฟลเดอร์และสั่งคำสั่งต่อไปนี้
    sudo mkdir /usr/local/mysql/data
    sudo mkdir /var/lib/mysql-files
    sudo chown mysql:mysql /var/lib/mysql-files
    sudo chown mysql:mysql /usr/local/mysql/data
  8. สร้างแฟ้ม /etc/my.cnf ด้วยคำสั่ง
    cat << EOF | sudo tee /etc/my.cnf
    เพิ่มข้อความต่อไปนี้ลงไป
    # MySQL Config
    [mysqld]
    datadir=/usr/local/mysql/data
    socket=/tmp/mysql.sock
    user=mysql# Run ndb storage engine
    ndbcluster
    # IP address management node
    ndb-connectstring=192.168.106.40[mysql_cluster]
    # IP address management node
    ndb-connectstring=192.168.106.40# MySQL Pid and Log
    [mysqld_safe]
    log-error=/var/log/mysqld.log
    pid-file=/var/run/mysqld/mysqld.pid
    EOF
  9. สั่งคำสั่งต่อไปนี้เพื่อเตรียมฐานข้อมูล ในขั้นตอนนี้จะมีการสร้าง passwd ของ root ให้ด้วยโดยอัตโนมัติ *จดไว้ด้วย*
    sudo /usr/local/mysql/bin/mysqld --initialize --user=mysql --datadir=/usr/local/mysql/data
  10. เพื่อให้ตัวควบคุมฐานข้อมูลทำงานอัตโนมัติสั่งคำสั่งต่อไปนี้
    sudo cp /usr/local/mysql/support-files/mysql.server /etc/init.d/mysqld
    sudo systemctl enable mysqld.service
    sudo systemctl start mysqld
  11. สามารถทำซ้ำได้อีกเครื่อง (ไม่จำกัด) แต่ในตัวอย่างนี้มี SQL Node เพียงเครื่องเดียว
  12. ส่งแฟ้ม mysql-cluster-advanced-7.5.5-linux-glibc2.5-x86_64.tar.gz ให้ SQL node
    cd scp mysql-cluster-advanced-7.5.5-linux-glibc2.5-x86_64.tar.gz sudo_user@192.168.106.32
5. ติดตั้ง Data Node
  1. ssh sudo_user@192.168.106.32 (sudo_user คือ user ที่เรียกใช้คำสั่ง sudo ได้)
  2. สร้างแฟ้ม /etc/my.cnf ด้วยคำสั่ง
    cat << EOF | sudo tee /etc/my.cnf
    เพิ่มข้อความต่อไปนี้เข้าไป
    # MySQL Config
    [mysqld]
    datadir=/usr/local/mysql/data
    socket=/tmp/mysql.sock
    user=mysql# Run ndb storage engine
    ndbcluster
    # IP address management node
    ndb-connectstring=192.168.106.40[mysql_cluster]
    # IP address management node
    ndb-connectstring=192.168.106.40# MySQL Pid and Log
    [mysqld_safe]
    log-error=/var/log/mysqld.log
    pid-file=/var/run/mysqld/mysqld.pid
    EOF
  3. ติดตั้ง Package ที่จำเป็น
    sudo apt install libaio1
  4. สร้าง user และ group
    sudo groupadd mysql
    sudo useradd -g mysql mysql
  5. คลายแฟ้ม mysql-cluster-advanced-7.5.5-linux-glibc2.5-x86_64.tar.gz ด้วยคำสั่ง
    tar zxvf mysql-cluster-advanced-7.5.5-linux-glibc2.5-x86_64.tar.gz
  6. เปลี่่ยนชื่อ mysql-cluster-advanced-7.5.5-linux-glibc2.5-x86_64 เป็น mysql
    mv mysql-cluster-advanced-7.5.5-linux-glibc2.5-x86_64 mysql
  7. ย้าย mysql ไปที่ /usr/local/ ด้วยคำสั่ง
    sudo mv mysql /usr/local
  8. สร้างโฟลเดอร์และสั่งคำสั่งต่อไปนี้
    sudo mkdir /usr/local/mysql/data sudo mkdir /var/lib/mysql-files sudo mkdir /var/lib/mysql-cluster sudo chown mysql:mysql /var/lib/mysql-files sudo chown mysql:mysql /usr/local/mysql/data
  9. สั่ง start service ด้วยคำสั่ง
    sudo /usr/local/mysql/bin/ndbd
  10. เพิ่มข้อความต่อไปนี้ในแฟ้ม /etc/rc.local
    /usr/local/mysql/bin/ndbd โดยเพิ่มให้อยู่บรรทัดก่อนคำว่า exit 0
    ตัวอย่าง /etc/rc.local
    #!/bin/sh -e
    #
    # rc.local
    #
    # This script is executed at the end of each multiuser runlevel.
    # Make sure that the script will "exit 0" on success or any other
    # value on error.
    #
    # In order to enable or disable this script just change the execution
    # bits.
    #
    # By default this script does nothing.
    /usr/local/mysql/bin/ndbd
    exit 0
  11. ทำซ้ำสำหรับ Data Node2 (ไม่จำกัด)
6. ทดสอบ Cluster
  1. พิมพ์คำสั่ง
    sudo /usr/local/mysql/bin/ndb_mgm
    เมื่อได้ prompt พิมพ์คำว่า show ได้ผลดังภาพ
  2. แปลว่าทำงานถูกต้องแล้ว..
7. เชื่อมต่อกับ SQL Node เพื่อเปลี่ยนรหัสผ่าน root
  1. ssh sudo_user@192.168.106.42 (sudo_user คือ user ที่เรียกใช้คำสั่ง sudo ได้)
  2. พิมพ์คำสั่งต่อไปนี้เพื่อสร้าง link ไปยัง mysql client
    sudo ln -s /usr/local/mysql/bin/mysql /usr/bin
  3. เรียกใช้งาน mysql
    mysql -u root -p
    ใส่ passwd ที่จดไว้ในข้อ 4 ข้อย่อย 9 แล้วเปลี่ยนใหม่ด้วยคำสั่ง
    ALTER USER ‘root’@’localhost’ IDENTIFIED BY ‘newPassw0rd’
8. ทุกครั้งที่จะทำอะไรผ่าน mysql client ต้องติดต่อกับ SQL Node เท่านั้นซึ่งตามตัวอย่างนี้มีเพียงเครื่องเดียวจึงไม่มีการทำ replicate data ใดๆ ทั้งสิ้นจำเป็นต้องเพิ่ม SQL Node เข้าไปอีก
9. จบ.. ขอให้สนุกครับ
อ้างอิง

https://www.howtoforge.com/tutorial/how-to-install-a-mysql-cluster-on-ubuntu-16-04/

https://medium.com/@ophasnoname_44358/mysql-cluster-7-5-5-on-ubuntu-16-04-step-by-step-9132cf76d5b8
April 12, 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
Zeppelin #01 Installation
Apache Zeppelin เป็น Web-Base Notebook สำหรับเป็นการเชื่อมต่อกับระบบ Data Analytic [1] สามารถใช้ทำ Data-Driven แบบ Interactive และยังสามารถใช้งานพร้อมๆกันหลายคนได้ รองรับการทำงานผ่านภาษา SQL, Scala และอื่นๆอีกมากมาย

ในบทความนี้ จะแนะนำการติดตั้ง Apache Zeppelin 0.7.0 บน Ubuntu 16.04
1. ไปที่ http://zeppelin.apache.org/download.html เพื่อ Download ชุดติดตั้ง ซึ่งแบ่งออกเป็น แบบรวมทุก Interpreters ขนาด 710 MB หรือ จะเลือกเป็นแบบ ที่รองรับเฉพาะ Spark ขนาด 272 MB ซึ่งหากในอนาคตต้องการใช้ภาษาอื่นอีก ก็จะต้องติดตั้งเพิ่มเติม (แนะนำให้ใช้แบบรวม Interpreters)
2. บน Ubuntu ที่จะใช้เป็น Zeppelin Server ใช้คำสั่งต่อไปนี้เพื่อ Download
```
wget http://www-eu.apache.org/dist/zeppelin/zeppelin-0.7.0/zeppelin-0.7.0-bin-all.tgz
```
3. ติดตั้ง Zeppelin (ต้องใช้ Java) ด้วยคำสั่งต่อไปนี้
```
sudo apt install default-jre
tar -zxvf zeppelin-0.7.0-bin-all.tgz ; ln -s zeppelin-0.7.0-bin-all.tgz zeppelin
```
4. Start Zeppelin
```
cd zeppelin
bin/zeppelin-daemon.sh start
```
5. หากเรียบร้อยก็จะสามารถใช้งานผ่านทาง Web UI ที่ port: 8080 ได้
6. ในกรณีที่ติดตั้ง Zeppelin บนเครื่องเดียวกับ Spark Master ก็จะพบว่า Port ชนกัน (คือใช้ Web UI ที่ port 8080 เหมือนกัน) เราสามารถเปลี่ยน Web UI port ของ Zeppelin ได้โดยใช้คำสั่งต่อไปนี้
```
cp conf/zeppelin-site.xml.template conf/zeppelin-site.xml
```
  แล้วแก้ไขไฟล์ conf/zeppelin-site.xml
  แก้ไขค่า 8080 เป็น ค่าอื่น เช่น 8090 เป็นต้น
```
<property>
 <name>zeppelin.server.port</name>
 <value>8080</value>
 <description>Server port.</description>
</property>
```
  แล้วทำการ Start Zeppelin ใหม่
Reference:
1. http://zeppelin.apache.org/
March 27, 2017
Spark #02: Cluster Installation
ต่อจาก Spark #01: Standalone Installation

Apache Spark ทำงานแบบ Master – Slave โดย Spark Cluster Component ดังภาพ

ภาพจาก http://spark.apache.org/docs/latest/img/cluster-overview.png

การใช้งาน Apache Spark จะใช้ผ่านการเขียนโปรแกรมด้วยภาษา Scala, Java, Python หรือ R แล้วสั่งการผ่าน “Driver” ซึ่งจะทำการส่งการไปยัง “Worker” เพื่อให้ Execute ตามที่ต้องการ การสร้าง Cluster จะมี Cluster Manager เป็น Standalone, Apache Mesos และ Hadoop YARN [1]

ในบทความนี้ จะกล่าวถึงเฉพาะ การติดตั้ง Apache Spark Cluster แบบ Standalone คือใช้ Apache Spark เองเป็น Cluster Manager
1. ติดตั้ง Ubuntu 16.04 อีกเครื่องหนึ่ง แล้วติดตั้งตามขึ้นตอนที่กล่าวใน Spark #01: Standalone Installation ข้อ 1-2 เท่านั้น (ไม่ต้อง Start Master ขึ้นมา)
2. ตอนนี้จะมีเครื่อง Master และ เครื่อง Slave ซึ่งแนะนำให้ทำ Password-less SSH จากเครื่อง Master ไปยัง Slave เพื่อสะดวกต่อการใช้งาน
3. ที่เครื่อง Master ใช้คำสั่งต่อไปนี้ เพื่อสร้างไฟล์ spark-env.sh ซึ่งเป็นตัวกำหนดการทำงานต่างๆของ Spark Cluster โดยในที่นี้ จะ SPARK_MASTER_HOST เป็น IP ของเครื่อง Master (แทนที่ 192.168.XXX.YYY ด้วย IP ของ Master )
```
cp conf/spark-env.sh.template conf/spark-env.sh

echo "SPARK_MASTER_HOST=192.168.XXX.YYY" >> conf/spark-env.sh
```
4. ที่เครื่อง Master ใช้คำสั่งต่อไปนี้ เพื่อสร้างไฟล์ slaves ซึ่งจะกำหนดว่า เครื่องใดบ้างจะเป็น Slave ของ Cluster นี้ (หากมี Slave หลายเครื่อง ก็ใส่ IP ลงไปในไฟล์ conf/slaves ให้หมด)
```
cp conf/slaves.template conf/slaves

echo "192.168.XXX.ZZZ" >> conf/slaves
```
5. ที่เครื่อง Master ใช้คำสั่งต่อไปนี้ เพื่อเชื่อมต่อ Cluster
```
sbin/start-all.sh
```
  หมายเหตุ: หากไม่ได้ทำ Password-less SSH ก็จะต้องใส่ Password ทีละเครื่องจนเสร็จ
6. เมื่อเสร็จเรียบร้อย ก็จะสามารถดูสถานะได้ที่ http://192.168.XXX.YYY:8080 ดังภาพ
ประมาณนี้

บทความต่อไป จะลงรายละเอียดเกี่ยวกับการเขียน Program เพื่อทำงานบน Spark Cluster

Reference:
1. http://spark.apache.org/docs/latest/cluster-overview.html
March 27, 2017
Spark #01: Standalone Installation
Apache Spark : เป็นระบบ Data Processing ในระดับ Large-Scale ซึ่งทำงานได้เร็วกว่า Apache Hadoop MapReduce 100 เท่าบน Memory และ 10 เท่าบน Disk สามารถพัฒนาโปรแกรมเพื่อทำงานบน Spark ได้หลายภาษา ทั้ง Java, Scala, Python และ R อีกทั้งยังมี Library ทำงานกับ SQL, Machine Learning และ Graph Parallel Computation

ในบทความนี้ จะกล่าวถึงเฉพาะวิธีการติดตั้ง Apache Spark เบื้องต้น บน Ubuntu 16.04 จำนวน 1 Machine ก่อน
1. ไปที่ http://spark.apache.org/downloads.html
  เลือก Release, Package ที่ต้องการ แล้วเลือก Copy Link จาก Download Link มาได้เลย
2. ที่ Ubuntu Server ใช้คำสั่งต่อไปนี้ ติดตั้ง Java และ Download Spark มาไว้บนเครื่อง
```
sudo apt-get install default-jre openjdk-8-jdk-headless
cat <<EOF >> .bashrc 
export SPARK_HOME=/home/mama/spark
export PATH=\$PATH:\$SPARK_HOME/bin
EOF
wget http://d3kbcqa49mib13.cloudfront.net/spark-2.1.0-bin-hadoop2.7.tgz
tar -zxvf spark-2.1.0-bin-hadoop2.7.tgz ; ln -s spark-2.1.0-bin-hadoop2.7 spark
cd spark
```
3. แล้วทำการ Start Spark Master Server ด้วยคำสั่ง
```
sbin/start-master.sh
```
4. จากนั้น สามารถเรียกดู Web UI ได้ที่ port 8080 (Default) และต่อไป เครื่อง Worker หรือ เครื่องที่จะมาเข้า Cluster จะติดต่อเครื่องนี้ผ่าน port 7077 (Default)
5. สามารถใช้งาน Spark Shell ซึ่ง จะเป็นภาษา Scala แบบ Interactive ด้วยคำสั่ง
  bin/spark-shell
6. สามารถดู Jobs ที่ทำงานได้ผ่านทาง Web UI ที่ port 4040 (Default)
ประมาณนี้ก่อน ในบทความต่อไปจะเป็นการสร้าง Spark Cluster

Reference:
1. http://spark.apache.org/
March 27, 2017
Cassandra #02 Scale-Out to Multi-nodes
ต่อจาก Cassandra #01 เริ่มต้นใช้งาน

ความสามารถที่สำคัญของ Cassandra คือสามารถทำการ Scale Out หรือขยายความสามารถของระบบได้โดยการเพิ่มเครื่องคอมพิวเตอร์ในระดับ Commodity Hardware [1] เข้าไปใน Cluster

ในบทความนี้ จะแสดงวิธีการสร้าง Cassandra Cluster ที่ประกอบไปด้วย 3 Node ชื่อ cassandra01, cassandra02 และ cassandra03 โดยมีชื่อ Cluster ว่า PSUCluster และกำหนดให้ cassandra01 เป็น Seed Node (ทำหน้าที่เป็นผู้ประสานงานสำหรับ Node ใหม่ๆเข้าร่วม Cluster)

ขั้นตอนการขยายระบบแบบ Scale Out ไปยังหลายๆ Node แต่ละ Node ทำดังนี้
1. ติดตั้ง Cassandra ตามขั้นตอนใน Cassandra #01 เริ่มต้นใช้งาน
2. แก้ไขไฟล์ /etc/cassandra/cassandra.yaml ดังนี้
```
# กำหนดชื่อ Cluster ที่ต้องการ
cluster_name: 'PSUCluster'

# กำหนด Seed Node ซึ่งมีไว้ให้ node ใหม่ประกาศตัวเองเพื่อเข้าร่วม Cluster
# ควรมีไม่เกิน 3 Node ต่อ Data Center
# ในที่นี้ กำหนดไว้เพียงตัวเดียว 
seed_provider:
 parameters:
 - seeds: "192.168.107.111"

# กำหนด listen_address เป็นค่าว่าง
listen_address:

# กำหนด endpoint_snitch เป็น GossipingPropertyFileSnitch
# เพื่อให้สามารถมี Cluster แบบข้าง Data Center ได้
endpoint_snitch: GossipingPropertyFileSnitch
```
3. ในการเริ่มใช้งานครั้งแรก ให้ลบข้อมูลใน /var/lib/cassandra/data/system ออกก่อน
```
sudo rm -rf /var/lib/cassandra/data/system/*
```
4. ในการใช้ Endpoint Snitch แบบ GossipingPropertyFileSnitch ต้องลบไฟล์ cassandra-topology.properties ออกไปก่อน
```
sudo rm /etc/cassandra/cassandra-topology.properties
```
5. จากนั้นก็ Start Cassandra Service
```
sudo service cassandra restart
```
วิธีดูสถานะของระบบ
```
sudo watch nodetool status
```
ในตอนแรกจะเป็นแบบนี้

เมื่อ cassandra02 เข้ามา

และเมื่อครบ 3 Node

วิธี Debug ว่าเกิดอะไรขึ้น
```
sudo tail -f /var/log/cassandra/debug.log
```
Reference

[1] http://docs.datastax.com/en/landing_page/doc/landing_page/planning/planningHardware.html

[2] http://docs.datastax.com/en/cassandra/3.0/cassandra/architecture/archIntro.html

[3] https://docs.datastax.com/en/cassandra/3.0/cassandra/initialize/initSingleDS.html
March 14, 2017