Category: Cluster & Load Balancing

  • 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 ได้แล้ว
  • 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

     

  • 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 ที่น่าสนใจได้
  • 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 ชั่วโมงก็ได้

  • 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 ***
  • วิธีทำ 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 ไปเป็นเครื่องต่างๆได้เลย

  • Spark #04 – Pyspark connect to MySQL

    ในบทความนี้ จะกล่าวถึง การดึงข้อมูลจาก MySQL ผ่าน JDBC เพื่อนำมาใช้งานใน Spark ด้วยภาษา Python ซึ่งจะใช้ Library Pyspark

    ในขั้นตอนนี้ขอกล่าวเฉพาะวิธีการก่อน (รายละเอียดจะตามมาทีหลัง)

    1. สร้าง SparkSession ตั้งชื่อว่า myspark
      from pyspark.sql import SparkSession
      myspark = SparkSession \
       .builder \
       .appName("Python Spark SQL basic example") \
       .config("spark.some.config.option", "some-value") \
       .getOrCreate()
    2. ติดต่อ MySQL และสร้าง View ชื่อ myuser
      myuser=myspark.read.jdbc(url="jdbc:mysql://mysql/mysql",table="user", properties={
       'user': 'user1', 'password': '123456'}
       )
      myuser.createOrReplaceTempView(name="myuser")
    3. จากนั้นก็จะสามารถ Query ข้อมูลที่เก็บไว้มาใช้งานใน Spark ได้
      myspark.sql(sqlQuery="select user,host from myuser where user='user1'").show()

    ซึ่งต่อจากนี้ จะสามารถใช้ความสามารถของ Spark ซึ่งทำงานด้าน Distributed Computing ได้ดี มาปรับปรุงความเร็วในการ Query ที่ซับซ้อน เช่นการ JOIN ได้ โดยจะกล่าวในบทความต่อๆไป

  • ELK #6 วิธีการติดตั้ง ELK และ Geoserver แบบ Docker ให้ทำงานร่วมกัน

    จาก ELK #5 การประยุกต์ใช้ ELK ในงานด้าน GIS และ การสร้าง Web Map Service (WMS) บน Geoserver ก็จะเห็นถึงการนำไปใช้เบื้องต้น

    >> ขอบคุณ คุณนพัส กังวานตระกูล สถานวิจัยสารสนเทศภูมิศาสตร์ทรัพยากรธรรมชาติและสิ่งแวดล้อม ศูนย์ภูมิภาคเทคโนโลยีอวกาศและภูมิสารสนเทศ (ภาคใต้) สำหรับความรู้มากมายครับ <<

     

    ต่อไปนี้ จะเป็นขั้นตอนการติดตั้ง ELK และ Geoserver แบบ Docker โดยผมได้สร้าง Github Repository เอาไว้ ซึ่งได้แก้ไขให้ระบบสามารถเก็บข้อมูลไว้ภายนอก

    Prerequisite

    1. ถ้าเป็น Windows ก็ต้องติดตั้ง Docker Toolbox หรือ Docker for Windows ให้เรียบร้อย
    2. ถ้าเป็น Linux ก็ติดตั้ง docker-ce ให้เรียบร้อย (เรียนรู้เกี่ยวกับ Docker ได้จาก ติดตั้ง docker 17.06.0 CE บน Ubuntu)

    ขั้นตอนการติดตั้ง

    1. สร้าง Folder ชื่อ Docker เอาไว้ในเครื่อง เช่นใน Documents หรือ จะเป็น D:\ หรืออะไรก็แล้วแต่
    2. เปิด Terminal หรือ Docker Quickstart Terminal จากนั้นให้ cd เข้าไปมา Folder “Docker” ที่สร้างไว้
    3. ดึง ELK ลงมา ด้วยคำสั่ง
      git clone https://github.com/deviantony/docker-elk.git
    4. ดึง Geoserver ลงมา ด้วยคำสั่ง (อันนี้ผมทำต่อยอดเค้าอีกทีหนึ่ง ต้นฉบับคือ https://hub.docker.com/r/fiware/gisdataprovider/)
      git clone https://github.com/nagarindkx/geoserver.git
    5. เนื่องจาก ไม่อยากจะไปแก้ไข Git ของต้นฉบับ เราจึงต้องปรับแต่งนิดหน่อยเอง
      ให้แก้ไขไฟล์ docker-elk/docker-compose.yml
      โดยจะเพิ่ม Volume  “data” เพื่อไป mount ส่วนของ data directory ของ Elasticsearch ออกมาจาก Containerแก้ไขจาก

      elasticsearch:
       build: elasticsearch/
       volumes:
       - ./elasticsearch/config/elasticsearch.yml:/usr/share/elasticsearch/config/elasticsearch.yml

      เป็น

      elasticsearch:
       build: elasticsearch/
       volumes:
       - ./elasticsearch/config/elasticsearch.yml:/usr/share/elasticsearch/config/elasticsearch.yml
       - ./elasticsearch/data:/usr/share/elasticsearch/data
    6. สร้าง docker-elk/elasticsearch/data
      mkdir docker-elk/elasticsearch/data
    7. แก้ไขไฟล์ docker-elk/logstash/pipeline/logstash.conf ตามต้องการ เช่น ใส่ filter
      filter {
       csv {
         separator => ","
         columns => [
      	"cid","name","lname","pid","house","road","diagcode","latitude","longitude","village","tambon","ampur","changwat"
         ]
       }
       if [cid] == "CID" {
         drop { }
       } else {
         # continue processing data
         mutate {
           remove_field => [ "message" ]
         }
         mutate {
           convert => { "longitude" => "float" }
           convert => { "latitude" => "float" }
         }
         mutate {
           rename => {
             "longitude" => "[geoip][location][lon]"
             "latitude" => "[geoip][location][lat]"
           }
         }
       }
      }
    8. จาก Terminal ให้เข้าไปใน docker-elk แล้ว start ด้วยคำสั่ง
      cd docker-elk
      docker-compose up -d
    9. จาก Terminal ให้เข้าไปใน geoserver แล้ว start ด้วยคำสั่ง
      cd ../geoserver
      docker-compose up -d

    ถึงขั้นตอนนี้ ก็จะได้ ELK และ Geoserver ทำงานขึ้นแล้ว

    ELK: http://localhost:5601

    Geoserver: http://localhost:9090/geoserver/web

     

    ขั้นตอนต่อไป จะเป็นการ นำข้อมูลเข้า และ เชื่อ Kibana กับ Geoserver

    วิธีการนำข้อมูลเข้า Elasticsearch

    เนื่องจาก pipeline ของ Logstash กำหนดว่า จะรับข้อมูลทาง TCP Port 5000 จึงใช้วิธี netcat ไฟล์เข้าไป ด้วยคำสั่ง (ตัวอย่างนี้ ใช้ข้อมูลจากไฟล์ sample.csv)

    cat sample.csv | nc localhost 5000

    วิธีการดึง Map จาก Geoserver มาใช้งานใน Kibana

    ทำตามขั้นตอนที่กล่าวไว้ใน การสร้าง Web Map Service (WMS) บน Geoserver ซึ่งจะได้ URL ของ Layer Preview มา ประมาณนี้
    http://localhost:9090/geoserver/test/wms?service=WMS&version=1.1.0&request=GetMap&layers=test:hadyai_vil&styles=&bbox=631866.963048935,748605.6609660918,677997.0295239205,791055.6681053439&width=768&height=706&srs=EPSG:32647&format=application/openlayers

    ทำตามขั้นตอนที่กล่าวไว้ใน ELK #5 การประยุกต์ใช้ ELK ในงานด้าน GIS ในส่วนของ วิธีใส่ Map Server อื่น แล้วเอา URL นี้ไปใส่ และรายละเอียดเกี่ยวกับ Layer, version, format ตามที่กำหนดไว้ ก็จะสามารถเอา Map ที่เราต้องการ พร้อม Shape File มาใช้งานได้

    หวังว่าจะเป็นประโยชน์ครับ

  • ELK #5 การประยุกต์ใช้ ELK ในงานด้าน GIS

    คราวนี้ มาดูการประยุกต์ใช้ ELK ในงานด้าน GIS

    ต่อจาก ELK #01 > ELK #02 > ELK #03 > ELK #04 ซึ่งเป็นการติดตั้งทั้งหมด คราวนี้มาดูการประยุกต์ใช้งานกันบ้าง

    โจทย์มีอยู่ว่า มีการไปเก็บข้อมูลในภาคสนาม แล้วมีการบันทึก พิกัดด้วย GPS เป็น Latitude กับ Longitude พร้อมกับค่าบางอย่าง ทั้งหมดถูกเก็บไว้ในฐานข้อมูล MySQL

    การนำข้อมูลเข้า ELK ก็เลย Export ข้อมูลจาก MySQL มาเป็น CSV File ประกอบด้วย

    id,LATITUDE,LONGITUDE,something

    ตัวอย่างข้อมูล มีดังนี้

    id,LATITUDE,LONGITUDE,something
    1,6.97585,100.448963,100
    2,6.975627,100.450841,19
    3,6.973472,100.449196,65
    4,6.973468,100.449104,53
    5,6.973455,100.449135,33
    6,6.973252,100.44888,13
    7,6.985862,100.45292,85
    8,6.993386,100.416214,90
    9,7.005465,100.447984,1

    นำข้อมูลเข้า ELK ผ่านทาง Logstash

    ใน  ELK #2 ได้อธิบายขั้นตอนการติดตั้ง Logstash ไว้แล้วนั้น ต่อไปเป็นการนำข้อมูลชนิด CSV เข้าไปใส่ใน Elasticsearch

    Logstash จะอ่าน “กระบวนการทำงาน” หรือเรียกว่า Pipeline จากไฟล์ Configuration ซึ่งประกอบด้วย 3 ส่วนหลักๆ คือ Input, Filter และ Output

    input {
       stdin { }
    }

    ในส่วน input นี้ จะเป็นการอ่าน STDIN หรือ ทาง Terminal

    filter {
     csv {
       separator => ","
       columns => [
         "id","latitude","longitude","something"
       ]
     }
     if [id] == "id" {
       drop { }
     } else {
       # continue processing data
       mutate {
         remove_field => [ "message" ]
       }
       mutate {
         convert => { "something" => "integer" }
         convert => { "longitude" => "float" }
         convert => { "latitude" => "float" }
       }
       mutate {
         rename => {
           "longitude" => "[geoip][location][lon]"
           "latitude" => "[geoip][location][lat]"
         }
       }
     }
    }

    ในส่วนของ filter นี้ เริ่มจาก เลือกใช้ Filter Plugin ชื่อ “csv” เพื่อจัดการไฟล์ CSV โดยกำหนด “separator” เป็น “,” แล้วกำหนดว่ามีชื่อ Column เป็น “id”,”latitude”,”longitude”,”something”

    จากนั้น ก็ตรวจสอบว่า ถ้าข้อมูลที่อ่านเข้ามา ใน Column “id” มีค่าเป็น “id” (ซึ่งก็คือบรรทัดหัวตารางของไฟล์ csv นั่นเอง) ก้ให้ “drop” ไป

    แต่หากไม่ใช่ ก็ให้ทำดังนี้ (mutate คือการแก้ไข)

    • remove field ชื่อ message (ซึ่งจะปรากฏเป็น Default อยู่ ก็เลยเอาออกเพราะไม่จำเป็น)
    • convert หรือ เปลี่ยน “ชนิด”  ของแต่ละ field เป็นไปตามที่ต้องการ ได้แก่ ให้ something เป็น Integer, latitude และ longitude เป็น float
    • rename จาก latitude เป็น [geoip][location][lat] และ longitude เป็น [geoip][location][lon] ซึ่งตรงนี้สำคัญ เพราะ geoip.location Field ข้อมูลชนิก “geo_point” ซึ่งจำเป็นต่อการนำไปใช้งานเกำหนดตำแหน่งพิกัดบนแผนที่ (เป็น Field ที่สร้างจาก Template พื้นฐานของ Logstash ซึ่งจะไม่กล่าวถึงในบทความนี้)
    output {
     stdout { codec => rubydebug }
     elasticsearch {
       hosts => ["http://your.elastic.host:9200"]
     }
    }

    ในส่วนของ Output จะกำหนดว่า ข้อมูลที่อ่านจาก csv และผ่าน filter ตามที่กล่าวมาข้างต้น จะส่งไปที่ใน จากการกำหนดนี้ บอกว่า จะส่งออกไป

    • stdout คือ การแสดงผลออกมาทาง terminal โดยมีรูปแบบเป็น rubydebug (รูปแบบหนึ่ง)
    • Elasticsearch ซึ่งอยู่ที่ http://your.elastic.host:9200

    จากนั้น Save ไฟล์นี้ แล้วตั้งชื่อว่า gis.conf

    แล้วใช้คำสั่ง

    cat sample1.csv | /usr/share/logstash/bin/logstash -f gis.conf

    การแสดงผลข้อมูลใน Elasticsearch ผ่าน Kibana

    จากบทความก่อนหน้า ได้แสดงวิธีการติดตั้ง Kibana และเชื่อมต่อกับ Elasticsearch แล้ว โดยจะเข้าถึง Kibana ได้ทางเว็บไซต์ http://your.kibana.host:5601

    ในกระบวนการของ Logstash ข้างต้น จะไปสร้าง Elasticsearch Index ชื่อ “logstash-YYYY-MM-DD”, ใน Kibana ก็จะต้องไป คลิกที่ Setting (รูปเฟือง) จากนั้นคลิกที่ Index Pattern โดยให้ไปอ่าน index ซึ่งมีชื่อเป็น Pattern คือ “logstash-*” จากนั้น คลิกปุ่ม Create

    จะได้ผลประมาณนี้

    ต่อไป คลิกที่ Discover ก็จะเห็นข้อมูลเข้ามา

    แสดงข้อมูลในรูปแบบของ Tile Map

    คลิกที่ Visualization > Create a visualization

    เลือก Tile Map

    เลือก Index ที่ต้องการ ในที่นี้คือ logstash-*

    คลิก Geo Coordinates

    จากนั้น คลิก Apply แล้วคลิก Fit Data Bound

    ก็จะได้เฉพาะ พื้นที่ทีมีข้อมุล

    วิธีใส่ Map Server อื่น

    ปัญหาของ Defaul Map Service ที่มากับ Kibana คือ Elastic Map Service นั้น จะจำกัดระดับในการ Zoom จึงต้องหา WMS (Web Map Service) อื่นมาใช้แทน ต้องขอบคุณ คุณนพัส กังวานตระกูล สถานวิจัยสารสนเทศภูมิศาสตร์ทรัพยากรธรรมชาติและสิ่งแวดล้อม ศูนย์ภูมิภาคเทคโนโลยีอวกาศและภูมิสารสนเทศ (ภาคใต้)  สำหรับคำแนะนำในการใช้งาน WMS และระบบ GIS ตลอดมาครับ 🙂

    โดย เราจะใช้ WMS ของ Longdo Map API : http://api.longdo.com/map/doc/
    ข้อมูลการใช้งาน เอามาจาก http://api.longdo.com/map/doc/demo/advance/02-layer.php

    วิธีการตั้งค่าใน Kibana

    คลิกที่ Option > WMS compliant map server
    แล้วกรอกข้อมูล

    URL : https://ms.longdo.com/mapproxy/service
    Layer: bluemarble_terrain
    Version: 1.3.0
    Format: image/png
    Attribute: Longdo API

    จากนั้นคลิก Apply

    จากนั้นให้ Save พร้อมตั้งชื่อ

    ซึ่ง Longdo Map API สามารถ Zoom ได้ละเอียดพอสมควร

    สามารถนำเสนอระบบ GIS ได้บน Website ทันที

    หวังว่าจะเป็นประโยชน์ครับ