ก้าวแรก HPC #03: การสร้าง Cluster ส่วนตัวราคาถูกและดี

เกริ่นนำ

ในบทความก่อนหน้า ผมคุยถึงเรื่องภาษาที่เลือกใช้ไปแล้วได้แก่ภาษา Python และ C++ ตอนแรกคิดว่าบทความนี้จะเข้าเรื่องโจทย์ตัวอย่างเลย แต่มาคิดอีกทียังขาดพื้นฐานที่สำคัญอีกเรื่องหนึ่ง ผมว่าเราควรมาคุยกันก่อนเพื่อจะได้ไม่เสียเวลาย้อนมาคุยกันอีก เรื่องที่ผมจะคุยในบทนี้ก็คือเรื่องเครื่องคอมพิวเตอร์ที่ผมใช้ครับ เนื่องจากเนื้อหาในเว็ปนี้เป็นการประมวลผลแบบขนาน ซึ่งไม่ได้จำกัดว่าจะขนานกับบนเครื่องคอมพิวเตอร์เพียงเครื่องเดียว ผมมีคอมพิวเตอร์หลายเครื่องครับ แต่การเปิดเครื่องคอมพิวเตอร์หลายเครื่องทำงานพร้อมๆ กัน ทั้งกินพื้นที่และกินไฟ ดูยุ่งยากครับ ผมก็เลยจะใช้วิธีเอาเครื่องคอมพิวเตอร์ถูกๆ ถูกจริงๆ ครับ กินพื้นที่น้อยมาก จอภาพแต่ละเครื่องก็ไม่ต้องใช้ ผมใช้ notebook ตัวเดียวเพื่อเข้าไปควบคุมทั้งหมด เป็น Single-board Computer หน้าตาจะเป็นอย่างไร เราไปดูรายละเอียดกันครับ

ประวัติ Single-board Computer

คอมพิวเตอร์ราคาถูกที่ผมจะใช้นั้น เป็นคอมพิวเตอร์ที่เรียกว่า Single-board Computer ตามธรรมเนียมเช่นเดิมครับ ก่อนเรียนรู้อะไร มาคุยกันเรื่องประวัติกันก่อ ผมขอถอยไปในยุคที่เครื่องคอมพิวเตอร์เริ่มมีใช้ตามบ้าน ก็ยุคปลาย 70 ต่อ 80 นั่นเอง ก่อนหน้านั้นเล็กน้อยก็เป็นยุคที่มีการออกแบบเครื่องคอมพิวเตอร์เองโดยการสร้างแผงวงจรขึ้นเอง ยุคนั้นเป็นยุคแสวงหา Apple เองก็กำเนิดในยุคนั้น เพิ่งดูข่าวเมื่อวานว่า มีคนประมูลเครื่อง Apple I ไปถึงราคาหนึ่งล้านดอลล่าร์ เป็น “rare item” ในตำนานจริงๆ ยุคนั้นเป็นยุคกำเนิดเครื่องคอมพิวเตอร์ยี่ห้อต่างๆ เช่น Apple, Sinclair, Commodore เป็นต้น แต่ก็มีคนอีกกลุ่มหนึ่งครับสร้างแผงวงจรเหมือนกัน แต่จุดหมายปลายทางไม่ได้ประกอบขึ้นมาเป็นเครื่องคอมพิวเตอร์ แต่หากคาเป็นแผงวงจรเปลือยๆ ซึ่งแผงวงจรนี้เขียนโปรแกรมได้เหมือนกันครับ เพราะเอา CPU คอมพิวเตอร์ไปใส่ ในยุคนั้นจะเป็น Z80 หรือ 6502 ก็แล้วแต่ครับ การใช้งานเน้นไปทางการเชื่อมต่อกับอุปกรณ์ภายนอกต่างๆ ผลลัพธ์จึงกลายเป็นสิ่งที่เรียกว่า Single-board Computer เริ่มแรกภายในจะมีโปรแกรมที่ฝังตัวอยู่ใน IC เรียกว่าโปรแกรม monitor มีหน้าที่รับคำสั่งการป้อนโปรแกรมผู้เขียนโปรแกรมผ่าน Key Pad (0-F เลขฐาน 16) โดยที่ผู้เขียนจะเขียนเป็น ภาษา Assembly ในกระดาษ จากนั้นก็เปิดตารางแปลเป็นภาษาเครื่องเลขฐาน 16  จากนั้นก็นำเอาเลขที่ได้ป้อนผ่านโปรแกรม Monitor เป็นการป้อนโปรแกรมสดเลยครับ แล้วค่อยสั่งให้เริ่มทำงาน ดังรูปนี้ครับเป็น Single-board computer แบบหนึ่ง ลองเทียบกับขนาดของบัตรที่ขนาดเดียวกับบัตรเครดิตดูครับ

ET-Board

Single-board Computer ชื่อก็บอกแล้วว่าชิ้นเดียวจบ ทุกอย่างอยู่บนแผ่นวงจรแผงเดียว เครื่องคอมพิวเตอร์แบบนี้โด่งดังอยู่ในช่วงเวลาหนึ่ง สุดท้ายก็เงียบๆ ไปครับ เพราะในเชิงการเขียนโปรแกรมและการใช้งานก็แพ้เครื่องคอมพิวเตอร์ ในแง่การควบคุมอุปกรณ์ก็แพ้บอร์ดไมโครคอนโทรลเลอร์ ซึ่งบอร์ดไมโครคอนโทรลเลอร์พวกนี้อาศัยการเขียนโปรแกรมบนเครื่องคอมพิวเตอร์ และเอาผลลัพธ์ไปใช้กับบอร์ดตามหลักการทำงานของ Cross-Compiler ครับ Single-board Computer ก็พอจะกลับมามีชื่อเสียงก็พวกบอร์ดสำหรับ Windows CE และ Android ซึ่งบอร์ดพวกนี้ก็ใช้งานกันในวงการเฉพาะครับ

จุดเปลี่ยนสำคัญที่เกิดขึ้นก็คือ ในต้นปี 2012 คณะจากห้องทดลองคอมพิวเตอร์ของมหาวิทยาลัยแคมบริตจ์ นำเสนออุปกรณ์ Single-board Computer ตัวหนึ่ง มีขนาดเล็กมากแผงวงจรมีขนาดพอๆ กับบัตรเครดิตหรือบัตรเอทีเอ็มเท่านั้น แต่ที่สุดยอดมากก็คือ เราสามารถลง Linux เต็มรูปได้เลย ไม่ใช่รุ่นลดความสามารถสำหรับเครื่องเล็กๆ แต่หากเป็นรุ่นใหญ่ รุ่นเดียวกับที่ใช้ในเครื่องคอมพิวเตอร์เลยครับ ซึ่ง OS ทั้งตัวและแฟ้มข้อมูลต่างๆ ของเราจะอยู่ใน SDCard ไม่ต้องมีอะไรอีกให้เสียค่าใช้จ่าย แค่ต่อจอ ต่อ mouse ต่อ keyboard เหมือนเครื่องคอมพิวเตอร์ก็ทำงานได้แล้ว ที่น่าสนใจมากก็คือราคาครับ เปิดตัวมาที่ $25 หรือ 800 บาท ราคาเท่ากับไปกินอาหารบุฟเฟ่ต์อาหารญี่ปุ่นระดับกลางๆ แค่มื้อเดียว อะไรมันจะถูกขนาดนั้น แล้วความเร็วก็ไม่ได้แย่นะครับ ความเร็วถึง 700 MHz นับได้ว่าไม่ธรรมดา เป็าหมายของเขาคือการกระจายโอกาสทางการศึกษาครับ ให้เด็กด้อยโอกาสในประเทศโลกที่สามมีโอกาสเข้าถึงคอมพิวเตอร์ได้มากขึ้น

บอร์ดนี้ไม่ได้ใช้ในการสร้างโอกาสให้เด็กแต่อย่างเดียวนะครับ มีการประยุกต์ใช้การใช้งานหลากหลายทั่วโลกครับ โดยเฉพาะอย่างยิ่งกลุ่มคนที่ใช้งานไมโครคอนโทรลเลอร์บางส่วนก็ย้ายค่ายมาไม่น้อยเครับ เพราะบอร์ดนี้มี interface สำหรับอุปกรณ์ต่อพ่วงต่างๆ เหมือนกับบอร์ดไมโครคอนโทรลเลอร์ ซึ่งการเขียนโปรแกรมบน Linux ก็ทำได้ง่ายและทำให้ซับซ้อนได้มากกว่าเขียนโปรแกรมต่อกับไมโครคอนโทรลเลอร์โดยตรงครับ ทำให้เกิดการระเบิดของเทคโนโลยีครั้งใหญ่ ยังมีงานประยุกต์อีกมากมายหลายสาขา รวมถึง HPC ที่ผมจะกล่าวต่อไป และแน่นอนครับ เมื่อบอร์ดนี้รุ่ง ใครๆ ก็อยากจะมีส่วนแบ่งด้วย ทำให้บอร์ดลักษณะ Raspberry Pi เลียนแบบเกิดขึ้นมาหลายบอร์ดครับ

รู้จัก Banana Pi

ในเว็ปนี้ผมไม่ใช้ Raspberry Pi แต่หากใช้ Banana Pi แทนครับ Banana Pi นี้เป็นบอร์ดที่ลอก Raspberry Pi มาอีกที ต่างกันตรงที่เขาเป็นราสเบอรี แกก็เป็นกล้วย ไม่แน่นะครับต่อไปอาจจะมีของไทยเข้าไปแข่งชื่อ Lamhud Pi ก็เป็นได้ ปัจจุบัน Raspberry Pi Model B+ ราคาขายอยู่ที่ $35 ส่วน Banana Pi  เปิดตัวเมื่อตอนต้นปี 2014 ราคาอยู่ที่ $50 ทำไมผมถึงเลือก Banana Pi ที่แพงกว่าความนิยมก็ด้อยกว่า เชื่อว่าท่านก็คงไม่สงสัย เพราะคำตอบมันกำปั้นทุบดินอยู่แล้ว Spec มันสูงกว่าครับ แต่ก่อนที่ผมคุยเรื่อง Spec เรามาทำความรู้จัก Banana Pi ให้มากกว่านี้สักหน่อยก่อนครับ

Banana Pi ชื่อก็บอกชัดเจนแล้วครับว่าเป็นของเลียนแบบ ท่านเดาได้ไหมครับว่ามาจากประเทศอะไร เชื่อมั่นในตัวท่านเลยครับว่าท่านเดาไม่ผิดแน่ อารมณ์การตั้งชื่อออกไปแนวจีนแน่นอนครับ  แต่ดีหน่อยครับไม่ได้ก๊อปปี้ทั้งดุ้น แต่หากเอาของเขามาปรับปรุงให้ดีขึ้นครับ ดีขึ้นอย่างน่าสนใจเลยทีเดียวครับ บริษัทผู้ผลิตบอร์ดนี้ชื่อว่า  Lemaker อยู่ใน เซินเจิ้นครับ หน้าตาของบอร์ด Banana Pi เป็นแบบนี้ครับ

Banana Front Banana_Back

ผมถ่ายรูปเทียบกับบัตรขนาดเท่ากับบัตรเครดิตให้ดูครับ ว่ามันใหญ่พอๆ กับบัตรเครดิตจริงๆ ลองดูด้านหลังเห็นตัวคำว่า A20 รึเปล่าครับ นั่นคือ CPU นั่นเอง แต่ถ้าจะเรียกให้ถูกต้องขึ้นก็ต้องเรียกว่า SoC ครับ เพราะมันได้มีแค่ CPU เท่านั้น แต่หากมี GPU อยู่ในนั้นด้วย ถ้ามีของแถมพ่วงนอกเหนือ CPU แบบนี้เราเรียกมันว่า SoC หรื System On Chip หมายถึงทั้งระบบอยู่ใน IC ตัวเดียว ตระกูล Intel Core i ก็เป็น SoC ครับ เพราะมี GPU ของ Intel HD Graphics อยู่ข้างในตัวถังด้วย SoC A20 ผู้ผลิตคือ Allwinner Tech ของจีนแท้ๆ อีกครับ ภายในมี CPU ตระกูล ARM Cortex-A7 ซึ่งเป็น CPU ยอดนิยมรุ่นหนึ่งที่ใช้ใน Smartphone ตั้งแต่ราคาถูกไปจนแพง ถูกแพงดูจากจำนวน Cores ครับ ที่ให้มาใน A20 นี้มี 2 cores ทำงานที่ความเร็ว 1GHZ ครับ ท่านอาจสงสัยว่าตกลง Allwinner หรือ ARM กันแน่ที่ผลิต CPU ก็ขอไขข้อข้องใจดังนี้ครับ ARM นั้นเป็นบริษัทที่ออกแบบ CPU ครับออกแบบอย่างเดียวครับ และขายลิขสิทธิ์อีกต่อครับ ดังนั้นจะไปหา CPU ที่ ARM ผลิตในท้องตลาด ไม่มีครับ มีแต่ของยี่ห้ออื่นในกรณีนี้ Allwinner Tech ก็ซื้อลิขสิทธิ์เอาไป สร้างเป็น A20 โดยซื้อ Spec ของ ARM Cortex-A7 ไปผนวกกับ GPU Mali-400MP2 ซึ่งก็เป็นการออกแบบของ ARM เช่นเดียวกันครับ แต่น่าเศร้าครับ Mali-400 เป็นรุ่นเล็กเกินไปไม่สามารถรองรับ OpenCL ทำให้เราไม่สามารถใช้งาน HPC กับ GPU ตัวนี้ครับ ถ้าจะให้ใช้ OpenCL ต้อง Mali-600 ขึ้นไปครับ  ว่าแต่เรื่องของ ARM น่าสนใจ สักวันผมจะเล่าเรื่องตำนานของ ARM สนุกมาก เขียนเป็นบทความได้บทความหนึ่งเลยครับ

เรามาดูส่วนอื่นกันต่อไปครับ SDRAM ที่ใส่เข้ามามีขนาดถึง 1GB DDR3 เสียด้วย ถ้าเป็น Ubuntu มีแรมขนาด 128MB ก็สามารถทำงานแบบไม่มี GUI ได้แล้วครับ แต่ถ้าเป็น GUI ก็ 512MB ขึ้นไป ดังนั้นการให้มาถึง 1GB นั้นเรียกว่าเหลือเฟือ เทียบกับ Raspberry Pi B+ มีให้เพียง 512MB เท่านั้น ส่วนอุปกรณ์ต่อพ่วงที่ให้มานับได้ว่าแพรวพราวครับ ทั้ง IR Reciever, USB 2.0, Audio in/out, AV Video, HDMI และที่เด่นมากสองอย่างเมื่อเทียบกับ Raspberry Pi B+ คือ 1Gb Ethernet Port (100Mb ใน raspberry Pi B+) และที่สำคัญคือสามารถต่อเชื่อมโดยใช้ SATA ได้ ทำให้สามารถเชื่อมกับ Harddisk ด้วยความเร็วสูงได้

ที่กล่าวมาทั้งหมด Single-board Computer ที่ลอกแบบมาจาก Raspberry Pi ส่วนมากจ่ายไฟเลี้ยงบอร์ดผ่าน USB  ซึ่ง Banana Pi ก็ใช้วิธีเดียวกันครับ (ฺBanana Pi มีช่องจ่ายไฟเลี้ยงเฉพาะให้มาด้วย) เป็นที่ทราบดีอยู่แล้วว่า USB ปกตินั้นจ่ายไฟระดับแรงดันที่ 5V  ไม่น่าเชื่อนะครับด้วแรงดันไฟฟ้าเพียงแค่นี้ทำให้บอร์ดนี้ทำงานเป็นเครื่องคอมพิวเตอร์เครื่องหนึ่งได้แล้ว มีคนวัดกระแสไฟฟ้าเฉพาะตัวบอร์ดตอนทำงานต่อทั้งจอภาพและ Ethernet ก็ทำงาน กินกระแสไฟฟ้าเพียง 230mA เมื่อคูณกับ 5V กลายเป็นกำลังไฟฟ้าจะได้ 1.15W หรือเปิดทิ้งไว้ไม่ปิดเลยประมาณ 1 เดือน กินไฟเพียง 1 หน่วยไฟฟ้าเท่านั้น แต่ตัวเลข 1.15W อาจเป็นแค่ตัวแลขเริ่มต้นครับ ถ้าทำงานคำนวณเยอะๆ อาจจะกินมากกว่านี้ แต่อย่างไรเสียก็กินไฟน้อยกว่า Raspberry Pi Model B+ ซึ่งกินกระแสไฟต่ำสุดอยู่ที่ 600mA หรือ 3W ไปจนถึง 1.8A หรือ 9W ทั้งนี้การออกแบบบอร์ดมีผลมากครับ Raspberry Pi เอาอุปกรณ์ทุกอย่างไปใส่ไว้ในด้านเดียวทำให้เกิดความร้อนสะสมมาก ส่วน Banana pi ก็อย่างที่เห็นกระจายออกทั้งสองด้านจึงระบายความร้อนได้ดีกว่า และปั่น Clock เพิ่ม Cores ได้มากกว่า Rasberry Pi ครับ

ตัวที่จะเป็นคอขวดของระบบจริงๆ น่าจะอยู่ที่ SD Card ครับ เพราะใน SD Card นั้นเก็บ File System ทั้งหมด ดังนั้น SD Card จึงถูกใช้งานอย่างหนัก ถ้างบถึงอยากให้พิจารณาหา SD Card ที่เร็วที่สุดในท้องตลาดมาใช้ครับ หรือจะใช้ SATA ต่อกับ SSD แบบนี้ติดจรวด แต่ก็คงเทอะทะน่าดู

ในเวลาที่ผมเขียนบทความนี้ Lemaker ประกาศตัวBanana Pro ผมก็กำลังเล็งอยู่ ถ้าได้มาจะมาเล่าสู่กันฟังอีกทีครับ

Single-board สำหรับงาน Big Compute

เป็นที่ทราบกันครับว่า ลำพังการนำเอาความเร็วของ clock มาเปรียบเทียบเป็นความเร็วของ CPU โดยตรงไม่ได้ เพราะหนึ่ง clock ของแต่ละ CPU ได้งานไม่เท่ากัน ผมเองก็อยากรู้ว่า Allwinner A20 ตัวนี้เร็วแค่ไหน งานนี้คงต้องใช้ Benchmark ดู ผมไปที่ http://www.7-cpu.com เขาทดสอบจับเวลาการใช้โปรแกรมย่อและขยายข้อมูล พบว่า

Intel Pentium II  350MHz     Compress = 410 MIPS, Decompress=600 MIPS
Intel Pentium III  1400MHz  Compress = 980 MIPS, Decompress = 1250 MIPS
Intel Pentium IV 3000MHz   Compress = 2000 MIPS, Decompress = 2330MIPS

Allwinner A20  2 Cores  Compress = 750MIPS,   Decompress=1560 MIPS

ตัวเลขยิ่งมากยิ่งเร็วนะครับ ในส่วน SoC ของ Raspberry Pi Model B+ ที่ใช้ของ Broadcome 2835 ในเว็ปด้งกล่าวไม่ได้เปรียบเทียบไว้ แต่ว่ากันว่าความเร็วสูสีกับ Intel Pentium II ส่วน Allwinner A20 ความเร็วจะอยู่ระหว่าง Pentium III และ Pentium IV ซึ่ง Pentium IV เริ่มสายการผลิตตั้งแต่ปี 2000 มานี่เองครับ สิ่งที่น่าสังเกตก็คือ Allwinner A20 ใช้ Clock ที่ความถี่ต่ำกว่า ทำให้ร้อนน้อยกว่า แถมยังกินไฟทั้งบอร์ดเพียง 1.15W ยิ่งร้อนน้อยไปอีก ทำให้สามารถใช้งานได้โดยไม่ต้องใช้ระบบจัดการความร้อนอย่าง Heatsink พัดลม หรือระบบหล่อเย็นใดๆ ซึ่งเมื่อเทียบกับ Pentium IV แล้วว่ากันเฉพาะ CPU ยังไม่รวมส่วนอื่นถึง 86W ต่างกันเยอะมากครับ อย่าลืมนะครับ ใน A20 ยังมี GPU อยู่ด้วยอีกต่างหาก

ด้วยอัตราการกินกำลังไฟต่ำมากเมื่อเทียบกับคอมพิวเตอร์และราคาที่ถูกจนน่าตกใจ ทำให้หลายคนคิดจะนำเอา Single-board Computer หลายๆ บอร์ดมาต่อร่วมกันเป็น cluster แลกเปลี่ยนข้อมูลผ่านสาย Lan ตามปกติ ซึ่งในต่างประเทศทำกันอย่างกว้างขวางครับ ที่เห็นเยอะๆ ก็จะมีประมาณ 40-node ต่อเข้าด้วยกัน หลายร้อยบอร์ดก็มีคนทำ เชื่อไหมครับฝรั่งเขาคำนวณแล้วว่า การสร้าง cluster ขนาด 40-node โดยใช้ Raspberry Pi นั้น ต้นทุนรวมทั้งหมดพอๆ กับ Macbook Air ของ Apple เพียงเครื่องเดียว เชื่อว่าในปัจจุบัน ในมหาวิทยาลัยทางเทคโนโลยีชั้นนำทั่วโลกคงมี cluster ลักษณะนี้เกือบทุกที่แล้วครับ เมืองไทยก็มีแล้วเหมือนกันครับ ผมเองก็จะทำบ้างเอาแบบเล็กๆ พอขำๆ ผมมี Banana Pi อยู่ 3 บอร์ด เอามาต่อกันเป็น cluster ดังนี้ครับ

Banana Cluster

ขอคุยกันเรื่องความเร็วหน่อยครับ Raspberry Pi ที่มีความเร็วพอๆ กับ Pentium II กับ Banana Pi มีความเร็วพอๆ กับ Pentium III จะบอร์ดไหนก็ไม่ต่างกันครับสำหรับเว็ปนี้ เพราะในเว็ปนี้เน้นที่การศึกษาครับ ผมเทียบเป็นอัตราส่วน หลาย Core ต่อ หนึ่ง Core ไม่ว่าความเร็วจะเป็นเท่าไหร่ก็ไม่สำคัญนักครับ ที่สำคัญคือมี Cores เยอะๆ หลายๆ บอร์ดก็ยิ่งสนุกครับ แต่ถ้างบน้อยอย่างผม ซัก 3 บอร์ดอย่างผมก็เพียงพอที่ใช้ทดลองให้เห็นภาพอย่างชัดเจน ใครมีมากกว่าก็ยิ่งดีครับ แต่ถ้าใครไม่มี แต่มีเครื่องคอมพิวเตอร์หลายเครื่อง ซัก 3 เครื่องขึ้นไปก็ใช้ได้ครับ แต่การใช้งานกับเครื่องคอมพิวเตอร์มีจุดอ่อนครับ เพราะเครื่องคอมพิวเตอร์แต่ละเครื่องลงโปรแกรมมากมาย มี Background processes เยอะ ดังนั้นการจับเวลาที่ได้ค่าอาจจะแกว่งหน่อยครับ อาศัยรันหลายๆ รอบแล้วเฉลี่ยค่าเอา ก็น่าจะพอได้ ถ้าใช้ Virtual Machine อย่าง VMware, Hyper-V หรือ Virtual Box ก็แค่ทดสอบการทำงานว่าทำงานได้ครับ แต่เรื่องเวลาที่จับก็จะแกว่งมากครับ

ช่วงที่กำลังเขียนบทความนี้ ก็มีการเปิดตัว Single-board Computer ใหม่หลายตัว ที่มีความพิเศษคือใช้ SoC ของ Intel Atom ทำให้สามารถลง Windows 8 ได้ ซึ่ง Board เหล่านี้ราคายังสูงอยู่ หนึ่งบอร์ด Intel Atom ซื้อ Banana Pi ได้ 3 บอร์ด ผมไม่ได้เน้นความเร็ว ผมเน้นถูกเข้าว่า จำนวน Core ยิ่งเยอะยิ่งดี ตอนนี้ก็เลยขอมองข้ามบอร์ดเหล่านี้ไปครับ

การติดตั้ง Software สำหรับ Single-board Computer

ในหัวข้อนี้ผมจะพูดถึงเรื่องการติดตั้ง Software โดยที่เน้นไปที่ Banana Pi ซึ่งถ้าใครใช้ Single-board Computer ตัวอื่นก็บอกได้เลยครับว่าอารมณ์เดียวกัน ต่างกันแค่จุดเล็กๆ น้อยเท่านั้น ใครใช้เครื่องคอมพิวเตอร์ก็สามารถประยุกต์ได้เช่นกันครับ ผมจะใช้ Lubuntu เพื่อเป็น OS ของบอร์ด  ใครจะใช้ ubuntu, kubuntu อะไร buntu ก็ตาม มันไม่ต่างกันครับ ที่ต่างกันเฉพาะ GUI ซึ่งผมไม่ได้สนใจ เวลาลงทุกอย่างเสร็จ ผมจะตัด GUI ทิ้งไปด้วยซ้ำ เพื่อเพิ่มกำลัง CPU ให้แก่งาน HPC ดังนั้น *buntu ตัวไหนก็เหมือนกันหมดครับ

แนวทางที่ผมใช้ในการติดตั้ง OS นี้มองว่าอุปกรณ์ Single-board Computer นี้เป็น headless แปลเป็นภาษาเข้าใจง่ายคือไม่มีจอภาพนั่นเอง บางท่านอาจมีจอภาพที่มี connector ไม่ตรงกับบอร์ดเลยไม่สามารถใช้งานจอภาพได้ หรือ Single-board Computer บางตัวอาจมีรุ่นราคาประหยัดตัดการเชื่อมต่อจอภาพทิ้ง ไม่ว่าจะเป็นกรณีใดก็ตาม ผมถือว่าไม่มีจอภาพก็แล้วกัน ถ้าท่านมีจอภาพก็ใช้งานได้ครับ ก็จะยิ่งง่ายเข้าไปอีก ส่วนผมจะติดต่อทาง Lan เอา ใช้ Notebook เป็นจอภาพนั่นเอง

เมื่องานเป็นแบบ cluster มีบอร์ดหลายๆ บอร์ด การที่มาติดตั้งในแต่ละบอร์ด เผื่อว่าใครทำ cluster สัก 100 บอร์ดคงแย่แน่นอน เหมือนการ format เครื่อง 100 เครื่อง เหนื่อยน่าดู และที่สำคัญ ถ้าลงโปรแกรมต่างกันอาจเกิดปัญหาได้ ผมจึงใช้วิธีสร้างต้นแบบใน SD Card จะลงโปรแกรมอะไรก็เอาให้เสร็จ จากนั้นก็ดูดกลับมาเป็น .img อีกที เพื่อใช้ในการคัดลอกไปลงอีก 99 แผ่นที่เหลือ  (ว่าไปนั่น ของผมจริงๆ มีแค่ 3 บอร์ด) ดังนั้นกรรมวิธีที่ท่านจะได้เห็นจะกระทำเพียงแค่แผ่นเดียวที่เป็นต้นฉบับครับ เริ่มกันดีกว่าครับ

 ขั้นตอนที่ 1 : download OS

สำหรับ Banana Pi ให้ไปที่  http://www.lemaker.org เลือกเมนู Resources แล้วเลือก Downloads เราจะเห็น Images Files มองหา Lubuntu รุ่นล่าสุดแล้ว Download ครับ สำหรับ Single-board Computer ตัวอื่นหรือคอมพิวเตอร์ก็เช่นกันครับลง *buntu รุ่นล่าสุดครับ ไม่น่าจะหายาก ถ้าท่านได้ *buntu  14.04 ท่านจะได้ GCC 4.8 ซึ่งเป็นรุ่นต่ำสุดที่จะมาใช้กับเว็ปนี้ เพราะ GCC 4.8 เป็นรุ่นแรกที่รองรับ C++11 ได้เต็มรูปครับ ดังนั้นต่ำกว่า 14.04 ไม่ได้นะครับ ส่วน 14.10 ขึ้นไป จะได้ GCC 4.9 ขึ้นไป ซึ่งยิ่งดีครับ ซึ่งจะรองรับ OpenMP 4.0 และ Clik Plus ซึ่งเราจะใช้งานต่อไป ผมได้มาเป็น Lubuntu 14.04 ครับ ล่าสุดเท่าที่มีแล้วครับ

ขั้นตอนที่ 2: ติดตั้ง OS

ขั้นตอนนี้ถ้าท่านคิดจะลง Lubuntu บนเครื่อง PC ก็เลือกได้ครับว่าจะติดตั้งโดยใช้ Virtual Machine หรือจะลง Partition ของ Harddisk เลย วิธีลงผมคงไม่กล่าวถึงนะครับ หาข้อมูลใน Internet ไม่ยาก มีมากมาย แม้ว่าท่านจะใช้งาน Single-board Computer อยู่แล้ว ผมก็ยังแนะนำว่าลง *buntu ไว้บนเครื่อง PC ที่ท่านใช้ด้วยครับ ถ้าท่านใช้งาน Windows อยู่แนะนำให้แบ่ง Partition ใหม่ มีโปรแกรมฟรีหลายตัวครับที่สามารถลดขนาด NTFS ได้ โดยที่เอาขนาดที่ลดได้นั้นไปสร้างเป็น Partition ใหม่เพื่อลง *buntu แล้วทำ Dual boot เอาครับ หรือถ้าจนใจจริงๆ ลงใน Virtual Machine ก็ยังดีกว่า Windows ครับ เพราะทำงานระบบเดียวกันหมดไม่วุ่นวายครับ

ที่ผมจะกล่าวถึงก็คือการลงบน Single-board Computer เนื่องจากบอร์ดเหล่านี้ไม่ได้ติดตั้ง Harddisk มาด้วย (ถ้าติดตั้งมาด้วยทุกบอร์ดคงเกะกะน่าดู) ทางเลือกหนึ่งก็คือใช้ SD Card หรือ Micro SD Card แทน Harddisk แล้วแต่ว่าบอร์ดใดรองรับอะไร เราเอา OS ทั้งตัว และ file systems ทั้งหมดเข้าไปเก็บไว้ในนั้น ผมขอเรียกรวมว่า SD Card นะครับ หมายความรวมไปถึง Micro SD Card ด้วย ซึ่ง image ของ OS ก็คือสิ่งที่เราเพิ่ง download มาในขั้นตอนที่ 1 นั่นเอง ขอแนะนำว่าใช้ SD Card ขนาด 8GB ขึ้นไป จะได้มืเนื้อที่ในการเก็บแฟ้มอื่นๆ อย่างพอเพียงครับ

ขั้นตอนต่อไปเราจะเอา OS ที่ได้ในขั้นตอนที่ 1 บรรจุลงไปใน SD Card ครับ เริ่มจากการ extract แฟ้มในขึ้นตอนแรกออกมาด้วยวิธีการใดก็ตาม ถ้าติดปัญหาให้ใช้ 7-zip ซึ่ง download ได้จาก http://www.7-zip.org จะได้ผลลัพธ์ออกมา เป็น .img ซึ่งสังเกตดูขนาดของแฟ้มครับ ว่ามีขนาดกี่ GB ถ้าตรงกับขนาดของ SD Card ก็จบไม่มีปัญหา แต่ถ้าขนาดของแฟ้มน้อยกว่า เช่นมี 4GB ไม่ว่าเราจะใช้ SD Card ใหญ่แค่ไหนก็ตามเมื่อทำเสร็จขั้นตอนก็จะกลายเป็นว่า SDCard มองเห็นแค่ 4GB เท่านั้น ซึ่งต้องมีขั้นตอนยุ่งยากเล็กน้อยในการขยายขนาด แต่ตอนนี้เรา .img ใส่เข้าไปใน SD Card ก่อน

ถ้าท่านใช้ OS Windows ต้องหา Software ตัวช่วยคือ win32diskimager ไป download ได้จาก http://sourceforge.net/projects/win32diskimager download แล้ว install โปรแกรมครับ เสียบ SD Card เข้าไปในเครื่อง จากนั้นก็รันโปรแกรม Image Writer\Win32 Disk Imager เวลารันให้กดขวา Run as Administrator จากนั้น เลือกแฟ้ม .img และ เลือก Drive ที่เป็น SD Card แล้วกด Write  ตามรูป

win32 Disk Imageจะมีคำเตือนใดๆ ก็ช่างกด Ok ข้ามไป Progress จะวิ่งจนเสร็จ

แต่ถ้าเราใช้ Ubuntu ก็เช่นเดียวกัน แกะแฟ้มจนได้ .img ก่อน เช่นต้นฉบับเป็น .tgz เราก็สามารถใช้ tar zxvf Lubuntu_For_BananaPi_v3.1.1.img เพื่อแกะให้ได้ .img เมื่อแกะได้แล้ว ก็ใช้คำสั่ง

มันก็จะเท่ากับขั้นตอนของ Windows ที่ใช้ Win32 Disk Imager ครับ

ขั้นตอนที่ 3: การ login เข้าสู่บอร์ดและการ boot เข้าสู่ text mode และการ Time Zone

ในขั้นตอนนี้ให้ท่านนำเอา SD Card ที่มี *buntu อยู่ภายในเอาไปเสียบที่บอร์ด ต่อสาย Lan จากนั้นจ่ายไฟครับ รอสักพักประมาณไม่น่าเกิน 2 นาที ถ้าเป็นบอร์ด Banana Pi ให้สังเกตไฟหลอด LED สีน้ำเงินถ้ากระพริบต่อเนื่องเมื่อใด แสดงว่าระบบพร้อมทำงานแล้วครับ เมื่อระบบพร้อมใช้งานเราจะได้ Linux ตัวหนึ่ง เราต้อง Login เข้าไปใช้งานครับ ถ้าจากเครื่อง Linux ท่านก็ใช้ ssh ip_address  ip_address ท่านน่าจะพอเดาได้นะครับ เพราะมันได้รับแจกมาจาก DHCP Server ของท่านอยู่แล้ว ของผมเป็น ASDL Router ซึ่งผม config เอง ก็เลยรู้ว่า IP ที่มันแจกอยู่ย่านไหน ลอง ping ดูก่อนครับ

แต่ถ้าท่านใช้ Windows ก็ต้องไปหาโปรแกรมเสริมครับ ชื่อ putty download ได้จาก http://www.putty.org/  install เสร็จแล้วก็เรียกใช้โปรแกรม putty ใส่ ip ก็เข้าไปได้ครับ  user/password ก็น่าจะหาได้จากหน้าเว็ปเดียวกับที่ท่าน download image ของ OS มานั่นเอง ในกรณีของผมนี้  bananapi/bananapi ครับ ถ้ามีการถามถึง security ก่อนหน้าให้กด Yes ไว้

จากนั้นควรสร้าง User ใหม่ครับ ตามแต่ใจท่าน ของผมก็ตั้งชื่อว่า supojc พิมพ์คำสั่งตามนี้ครับ

ถ้าท่าน sudo ไม่ได้เพราะ user ที่ระบบเตรียมมาไว้ให้ไม่ยอมให้ sudo ก็ไม่ต้อง sudo ครับ ใช้ su – แล้วกด enter เพื่อแปลงกายเป็น root คราวนี้ทำได้ทุกอย่าง แต่เราจะใช้วิธีนี้น้อยที่สุดครับ มันอันตราย ใช้ user ธรรมดาดีกว่า user ที่เพิ่มมาใหม่นี้จะสามารถใช้ sudo ได้ครับ ซึ่งเป็นการขอใช้สิทธิ root ชั่วคราว ก่อนที่ทำอะไรต่อ เราดูกันครับว่าระบบถึงจุดนี้มันกินหน่วยความจำ RAM  มันกินเท่าใดกันแน่ ใช้คำสั่ง free -h ครับ

free_gui

 

จากคำสั่ง free -h เราจะเห็นว่า ระบบกินหน่วยความจำ 148M แม้ว่าจะเหลืออีกถึง 725M ก็ตาม ทางที่ดีเราควรดึงหน่วยความให้เหลือมากกว่านี้ ตัวที่กินหน่วยความจำมากก็คือ GUI ซึ่งระบบเราเป็นแบบ headless ไม่ได้มีการต่อจอภาพใดๆ อยู่แล้ว ไม่ได้ใช้ GUI อยู่แล้ว จึงเป็นการสิ้นเปลืองโดยใช้เหตุ ทำให้ boot และทำงานช้าลงอีกต่างหาก เราจะตัด GUI ทิ้ง (แต่สำหรับเครื่อง PC ยังใช้ GUI อยู่นะครับ) โดยที่ท่านใช้ editor  nano หรือ vi ก็ได้ไปแก้แฟ้ม /etc/init/lightdm.conf โดยแก้จาก

เป็น

ใส่เลข 2 เพิ่มเข้าไปตัวเดียวครับจากนั้นเมื่อ boot เครื่องใหม่จะ boot ได้เร็วขึ้นมากครับเพราะไม่มี GUI แล้ว (สังเกตไฟกระพริบต่อเนื่องสีน้ำเงิน) เมื่อ boot เสร็จแล้ว เข้า putty เพื่อ login เป็น user ใหม่ครับ จากนั้นลอง free -h ดูครับ ของผมจะได้

free_text

กินหน่วยความจำลดลงอย่างเห็นได้ชัดครับ ต่อมาเราต้องปรับ Time Zone ให้ตรงกับประเทศไทยครับ เพราะที่ให้มาก็จะเป็น TimeZone ของบริษัทผู้ผลิต ใช้คำสั่งนี้ครับ

ขั้นตอนที่ 4: ปรับปรุงระบบให้ทันสมัย

ก่อนทำอะไรก็ควรปรับปรุงระบบให้ทันสมัย ท่านต้องเชื่อมต่อกับ Internet ด้วยครับ ให้พิมพ์คำสั่งดังนี้ครับ

กระบวนการนี้กินเวลาค่อนข้างมาก อาจเป็นชั่วโมงก็ได้ครับ

มาถึงขั้นตอนนี้ ถ้าใครคิดว่าจะซื้อบอร์ดมาใช้สำหรับงาน HPC อย่างเดียวไม่ทำอย่างอื่น ก็ควรจะตัด GUI ทิ้งแบบถาวรไปครับ ด้วยการพิมพ์

นอกจากจะได้พื้นที่ SD Card เพิ่มขึ้นแล้ว เวลาที่ใช้ในการ update ระบบก็จะเร็วขึ้นมากครับ เพราะจะเหลือ package ที่ต้องปรับปรุงน้อยลงนั่นเอง ในส่วนต่อไปเป็นการปรับปรุงรุ่นของ *buntu ให้ทันสมัยล่าสุดครับ ตระกูล *buntu นั้นผู้ผลิตเขากำหนดเวลาออกรุ่นใหม่ตายตัวปีละสองครั้ง คือเดือน เมษายนและเดือนตุลาคม ในวันที่ผมเขียนบทความนี้ Lubuntu ที่ลงนั้นรุ่น 14.04 (เมษายน) และ 14.10 เพิ่งออกมา ทางผู้ผลิตบอร์ดยังไม่ได้ทำ Lubuntu รุ่นใหม่มาให้ ผมก็เลยต้องลงเอง ถามว่าจำเป็นไหม ก็ 14.10 นั้นเขาให้ GCC 4.9 มาซึ่งเราจำเป็นต้องใช้ในบทความชุดนี้ครับ ดังนั้นก็ควรลง แต่ก็ขอเตือนไว้นะครับตระกูล *buntu บ่อยครั้งที่ออกรุ่นใหม่มาหมาดๆ ถ้าเอาไปลงแล้วก็เกิดปัญหา รอให้นิ่งซักสองเดือนก่อนก็จะดี และการลงจากแผ่นก็จะมีความเสถียรกว่าการ upgrade ด้วยวิธีนี้ แต่ตอนนี้ผมไม่มีทางเลือกครับ จำเป็นต้องใช้วิธีนี้ ทำตามได้ครับ ถ้าเผื่อใจเอาไว้แล้ว ขั้นตอนนี้กินเวลาประมาณ 2-3 ชั่วโมงครับ เริ่มจากไปแก้แฟ้มนี้ครับ

แก้ให้เป็น Prompt=normal ครับ หมายความว่า จะยินยอมให้มีการ upgrade ได้ถ้ามีรุ่นใหม่มาทุกรุ่น โดยปกติแล้วจะเป็น Prompt=lts ซึ่งยอมให้ upgrade เฉพาะรุ่นเดือนเมษายน รุ่นที่ออกเดือนตุลาคมนั้นไม่ยอมให้ upgrade ทั้งนี้เพราะรุ่นเดือน เมษายน นั้นเป็นรุ่นที่เอาจริงมากกว่าครับ ทรัพยากรบุคคลใช้มากกว่าและหมดอายุนานกว่าด้วยครับ เหมือนว่ารุ่นเดือนตุลาคมเป็นรุ่นลองของครับ จากนั้น

เป็นการเริ่มกระบวนการ รอไปเลยครับ 2-3 ชั่วโมง เมื่อเสร็จแล้วก็ Boot ใหม่ครับ เราจะได้รุ่นใหม่

ขั้นตอนที่ 5: ขยายขนาด Root File System

ผมกำลังจะลง Software ที่ต้องการใช้ลงใน SD Card ครับ แต่เกรงว่าพื้นที่จะเหลือไม่พอ ดังนั้นผมจึงต้องเอาพื้นที่ที่เหลือใน SD Card มาเพิ่มให้แก่ Root file Systemครับ  ตอนนี้ของผม Root File System มีประมาณ 4GB ตามขนาดของ .img ครับ แต่ SD Card ของผมมีขนาด 8GB ผมจึงจะเอา 4GB ที่เหลือมาต่อให้กับ Root File System ขั้นตอนนี้เสี่ยงนะครับ ถ้าทำพลาดข้อมูลหายหมด ต้องไปเริ่มขั้นตอนที่ 1 ใหม่ ผมจึงทำ Backup ไว้ก่อนครับเพื่อความปลอดภัย

เริ่มจากถอด SD Card ไปใส่ในคอมพิวเตอร์ ผมจึงใช้ Win32 Disk Imager อ่านข้อมูลกลับมาเป็นแฟ้มขนาด 4GB เก็บเอาไว้ก่อนครับ โดยการตั้งชื่อแฟ้ม เลือก Drive ที่เก็บ SD Card แล้วกด Read ครับ ถ้าเป็น linux ก็ใช้

จากนั้นดึงแผ่น SD Card ออกไปใส่ไว้ในบอร์ดตามเดิมแล้ว boot ครับ  พิมพ์ df -h ดูครับ จะได้รู้ว่าขนาดที่เหลือมีเท่าใด

df_before_parted

จาก /dev/root จะเห็นได้ว่าใช้ไป 89% แล้ว พื้นที่ลงโปรแกรมเพิ่มไม่พอแน่นอนครับ ต้องขยายโดยการใช้ parted ทำตามทีละขั้นตอนเลยนะครับ

parted_first_print

เมื่อใช้คำสั่ง p จะเห็น 2 partitions ซึ่ง partition แรกเก็บ OS ส่วน partitions ที่ 2 เป็น Root File System มีขนาด 3606MB  ก็คือหย่อนๆ 4GB นั่นเอง ดูที่ใต้บรรทัดคำสั่ง p ลงมา 2 บรรทัดครับ จะเห็นว่า  ทั้ง /dev/mmcblk0 ซึ่งก็คือ SD Card ทั้งแผ่นนั้นมีขนาด 7948MB ซึ่งก็หย่อนๆ 8GB นั่นเอง เป็นไปตามคาดการทุกประการ ขั้นตอนต่อมาเราต้องเปลี่ยนมุมมองก่อนครับ แทนที่จะมองเป็นหน่วยความจำ เราเปลี่ยนไปมองเป็นมิติของ Harddisk ที่ประกอบด้วย cylinder,head,sector แทนซึ่งตัวเลขมิติเหล่านี้เราต้องใช้ในขั้นตอนต่อไป  เราเปลี่ยนมุมมองโดยใช้คำสั่ง  unit chs แล้ว ก็ p อีกครั้งจะเห็น

parted_chs

เราสนใจ Partition ที่ 2 ครับ จุดเริ่มต้นที่   7,197,62   สิ้นสุด 446,47,48  และสิ้นสุดจริงดูใต้ p มา 2 บรรทัดเช่นเดิมคือ 966,80,9 ครับ วิธีการก็คือ ลบ partition 2 ทิ้ง แล้วสร้างใหม่ให้มีขนาด  7,197,62 ถึง 966,80,9 นั่นเอง เราจะให้พื้นที่ทั้งหมดที่เหลือทั้งหมดแก่ partitions ที่ 2 ถามว่าแล้วข้อมูลไม่หายหรือ ก็บอกว่าไม่หายครับ ถ้าหายไม่ต้องกลัวเรามี backup สรุปคำสั่งเป็นตามนี้ครับ

ทั้งสองคำสั่งนี้จะมีการเตือนบางอย่างขึ้นมา ไม่ต้องสนใจครับกด I ข้ามไป เมื่อทำเสร็จแล้วก็

ถ้าโชคดีก็ boot ขึ้นครับ เมื่อ boot ขึ้น เข้าไปใน parted กด p จะเห็นว่า partition ใหญ่ขึ้นแล้ว แต่เมื่อพิมพ์ df -h  ก็ยังเป็น 89% เหมือนว่า Root File System ไม่ได้รับว่า partition ใหญ่ขึ้นครับ เราต้องบอกมันว่ามีพื้นที่เพิ่มโดยการ

จากนั้นลอง df -h ดูครับ

parted_final_df

ได้พื้นที่เพิ่มมาแล้วครับ รอดตัวไป

ขั้นตอนที่ 6: ติดตั้งเครื่องมือการเขียนโปรแกรม

ติดตั้งเครื่องมือหลักในการพัฒนา Software ชุดคอมไพเลอร์ภาษา C/C++ โดยใช้คำสั่ง

ติดตั้ง curl เพื่อให้เราสามารถใช้ URL กับคำสั่งต่างๆ ได้ และ git เพื่อใช้ดึง source code จาก repository ต่างๆ และ vim ซึ่งก็คือ vi ตัวเต็มนั่นเอง

ขั้นตอนต่อไปเป็นการเตรียมการสำหรับใช้งาน Spark ซึ่งรายละเอียดการใช้งานจะกล่าวในบทต่อๆ ไป ซึ่ง Spark นั้นเขียนด้วย Scala และ Scala ทำงานภายใต้ JVM ดังนั้นจึงต้องลงทั้ง scala และ java แม้ว่าเราจะไม่ได้เขียนโปรแกรมด้วยภาษาทั้งสองนี้ก็ตาม จากการทดสอบของผมเองพบว่า openjdk ที่เป็นของฟรีใน *buntu เมื่อใช้งานกับ Spark มีติดๆ ขัดๆ ผมเลยตัดสินใจลง JDK ของ Oracle (Sun เดิม) แทน แต่ปัญหาคือใน repository หลักของ Ubuntu ไม่มี JDK ของ Oracle ก็เลยต้องยุ่งยากเล็กน้อยไปดึงมาจาก repository อื่น ทำตามขั้นตอนนี้ได้เลยครับ

ทดสอบดูว่า java ลงได้สำเร็จหรือไม่ให้ใช้คำสั่งข้างล่าง คับ ถ้าแสดงคำว่า java และรุ่นออกมาก็เป็นอันใช้ได้

Spark รุ่นล่าสุด ณ เวลาที่เขียนบทความนี้คือ Spark 1.1 ซึ่งรองรับ scala 2.10 เป็นหลัก Ubuntu นั้น ใน repository ไม่ใช่รุ่นนี้ ดังนั้นจึงต้องหามาลงเอง และเพราะ scala 2.10 เข้ากันได้ดีกับ Java7 เราจึงลง Java7 ไม่ใช่ Java8 ดังได้ลงสำเร็จไปแล้วข้างบน วิธีการติดตั้ง scala 2.10  ต้องใช้ browser ครับ เราต้อง download browser text mode ที่ชื่อว่า links โดยใช้คำสั่ง

ใช้ links เข้าเวปไซต์ scala โดย

ใช้ลูกศรขึ้นลงเพื่อหา scala 2.10 รุ่นที่ใหม่ที่สุด นามสกุล .deb  วันนี้ผมลองไปดูได้รุ่นใหม่ล่าสุดคือ scala-2.10.4.deb download มาเลยโดยการกด enter ครับ เมื่อเสร็จแล้วกด q เพื่อหยุดโปรแกรม จากนั้นติดตั้งโดย

ทดสอบว่า scala ทำงานได้โดยพิมพ์คำสั่งข้างล่างครับ ถ้าขึ้นคำว่า scala และรุ่น ก็ผ่านครับ

download Spark ให้ใช้ links ไปที่เว็ปไซต์ Spark ที่

ในกรณีที่มีรุ่นใหม่กว่านี้ ก็เปลี่ยนตัวเลขข้างหลัง เมื่อเข้าสู่เว็ปได้แล้วให้เลือก mirror ที่ใกล้ที่สุด ถ้ามีของไทยก็ยิ่งดี กด enter เข้าไป เลือก download ชื่อแฟ้มที่มีคำว่า hadoop รุ่นที่สูงที่สุดครับ ที่ผมได้มาก็คือ spark-1.1.0-bin-hadoop2.4.tgz  เมื่อ download เสร็จแล้วก็ q ออกไปครับ แล้วพิมพ์

ทิ้ง spark ไว้ตรงนี้ ไว้ว่ากันในบทความต่อๆ ไป ตอนนี้เราแวะมาลง Python ใจจริงอยากลง Conda แต่ไม่รองรับ CPU ARM เลยลงไม่ได้ก็ต้องลงปกติเอาครับ ซึ่งขั้นตอนนี้อาจกินเวลานานเป็นชั่วโมง

ท่านอาจสงสัยว่าทำไมผมถึงใช้ python ของ Ubuntu แทนที่จะใช้ Anaconda นั่นหนะสิ ผมก็สงสัย สงสัยว่าทำไม Continuum Analytics ถึงไม่ทำ Anaconda สำหรับ CPU ตระกูล ARM

ขั้นตอนที่ 7: กำหนด IP ให้แก่บอร์ดโดยอัตโนมัติ

เรื่องนี้ไม่ได้ง่ายอย่างที่คิดนะครับ เราอาจใช้ DHCP ในการกำหนด IP อัตโนมัติให้ได้ แต่ IP ก็มีสิทธิเปลี่ยนเป็นเลขอื่น ซึ่งเมื่อเราใช้ในงาน Cluster มันจะเชื่อมกับบอร์ดไม่ได้ถ้า IP เปลี่ยน ดังนั้นมันต้องเป็น IP ที่กำหนดมาเลย ซึ่งนั่นก็นำปัญหาต่อมา ถ้าเรามีเป็น 100 บอร์ด ก็ต้องมานั่งปรับค่าทุกบอร์ด เหนื่อยหนักแน่ ดังนั้นทางออกก็คือใช้ DHCP นั่นแหละครับ แต่ผูก IP กับ Mac Address แบบหนึ่งต่อหนึ่ง ซึ่ง ADSL Router ทำได้เกือบทุกตัวครับ ภาพข้างล่างเป็นตัวอย่าง Router ที่ผมใช้

dhcp_router
IP ที่ผมเลือกใช้ จะไม่ใกล้กับ DHCP ที่แจกปกตินะครับ ใกล้มากอาจชนกัน จากตัวอย่างผมเลือก .101 เลยครับ ท่านอาจสงสัย แล้ว Mac Address หาได้จากไหน  ก็พิมพ์บรรทัดข้างล่างเลยครับ

mac_address

มาถึงขั้นนี้เราจะปิดเครื่องครับโดย

เพื่อปิดเครื่อง จากนั้นถอด SD-CARD เพื่อไปเสียบเครื่องอื่นแล้วจ่ายไฟครับ เป้าหมายคือต้องรู้ให้ได้หมดครับว่าบอร์ดไหนมี Mac Address อะไร เพื่อเอาไปกรอกใน ADSL Router ให้ครบทุกตัวครับ แนะนำว่า เมื่อท่านรู้ Mac Address ของแต่ละเครื่องแล้ว ท่านต้องจำให้ได้ว่าแผ่นไหนเป็นแผ่นไหน จะทำเป็นสติ๊กเกอร์ปิดไปที่บอร์ดเลยก็น่าจะดี

ขั้นตอนที่ 8: ปรับ /etc/hostname

เครื่อง node คือ  Banana Pi นั่นเอง ส่วนของผม มีเครื่อง IP ของ master1 ซึ่งก็คือ notebook มีทั้ง Windows/Linux และ master2 นั่นเป็น Linux อยู่ภายใต้ Virtual Machine ของ Windows เครื่องที่เป็น master หรือตัวสั่งงานก็ต้องแก้แฟ้มนี้ด้วยครับ ถ้าเป็น linux ก็อยู่ที่เดิม /etc/hostname แต่ถ้าเป็น Windows ให้แก้ที่แฟ้ม c:\windows\system32\drivers\etc\hosts  edit ที่แก้ต้อง “Run as Administrator” นะครับ มิฉะนั้นเขียนไม่ได้

เราต้องแก้ /etc/hostname ด้วย ซึ่งภายในจะเก็บชื่อเครื่องของตัวเอง เช่น node01 เป็นต้น แต่เก็บ script ข้างล่างนี้ไว้ก่อนครับ ชื่อ sethostname เดี๋ยวในขั้นท้ายที่สุดเราค่อยไปรันมันครับ

ขั้นตอนที่ 9: สร้าง .img จาก SD Card ที่ทำเสร็จ

เราทำ SD Card เสร็จแล้วครับ ขั้นตอนต่อไป ก็ต้องคัดลอกไปยัง SD Card ทุกแผ่นที่เหลือ วิธีการก็ต้องย้อนกลับในขั้นตอนที่ 2 จากการเขียนมาเป็นการอ่าน ใช้คำสั่ง Read ครับ ตั้งชื่อแฟ้ม อะไรก็ได้ครับนามสกุล .img จากนั้นใช้แฟ้มดังกล่าวเขียน SD Card ที่เหลือทั้งหมด เมื่อเสร็จแล้วก็เก็บแฟ้มนี้ให้ดีนะครับ ถ้ามีอะไรปรับปรุงก็จะได้แก้ได้ อาจจะสะดวกกว่าแก้ทีละแผ่นเองครับ

ขั้นตอนที่ 10: ssh login โดยไม่ต้องใส่ password

ขั้นตอนนี้สำหรับเครื่อง PC ที่เป็น Linux ใช้เชื่อมต่อกับ cluster ที่เราสร้างขึ้นครับ เพื่อให้ script ที่เราเขียนทำงานได้อย่างอัตโนมัติ จะให้มาติดขัดตรงรอ password ให้กรอกนั้นไม่ได้ ดังนั้นจึงต้องหาวิธีเราข้ามไม่ต้องกรอก password แต่ไม่ใช่ว่าการไม่กรอก password จะทำให้ security หลุดนะครับ ยังคงมี security อยู่ (ซึ่งในงาน HPC เราไม่ค่อยคำนึถึง security มากนัก) โดยใช้ RSA เป็นระบบจัดการ security นั่นเอง วิธีการนี้เราเรียกว่า password-less ssh  ทำตามเลยครับ ไปที่เครื่อง PC ที่เป็น linux login เป็น user เดียวกันกับใน cluster ในที่นี้ผมใช้ supojc พิมพ์

เมื่อเรา ssh-copy-id จะให้เราใส่ password ของ เครื่องปลายทาง เพื่อยืนยันว่าเรามีสิทธิจริง เมื่อกรอกไปแล้ว โปรแกรมจะคัดลอก key ครึ่งท่อนไปเก็บเอาไว้ที่เครื่องปลายทาง นึกอะไรไม่ออกก็เหมือนในหนังครับ ฉีกแบ๊งเป็นสองส่วน ให้ node ไปส่วนหนึ่งที่ต้นทางอีกส่วนที่เหลือ เมื่อ login ครั้งต่อไป ก็ลองเอาแบ๊งสองส่วนมาประกบ ถ้าสนิทพอดีก็ให้ผ่านได้เลยโดยไม่ต้องใส่ password

ขั้นตอนที่ 11: ติดตั้งเครื่องมือสำหรับช่วยการทำงานแบบ Cluster

ถ้าท่านมี node อยู่หลาย node แน่นอนครับตามทฤษฏีแล้ว node มันคือหน่วยประมวลผล การปรับแต่งทุกอย่างต้องเหมือนกันหมด ถ้ามี 100 เครื่อง ต้องเรียกคำสั่งเดียวกันทั้ง 100 เครื่อง พิมพ์ 100 ที เหนื่อยครับ วิธีที่สะดวกกว่า และปลอดภัยกว่าคือการใช้ clusterssh  ซึ่งมีเฉพาะบน Linux แบบ GUI ครับบน windows ไม่มี

แล้วภายในใส่ชื่อ user@ชื่อเครื่องของ node ลงไปเช่น

จากนั้นเมื่อเราพิมพ์

มันจะเปิดหน้าต่างมา 3 windows เลยครับ แต่ถ้า cssh two ก็จะเปิด node02 และ node03 เท่านั้น และ ssh เข้าไปในแต่ละเครื่องตามที่เราใส่ไว้ จากนี้ไปเราเลือกได้ว่า keyboard ที่เราพิมพ์จะไปออก windows ไหน หรือจะให้ออกทั้งหมด นั่นหมายความว่าตัวอักษรที่พิมพ์สามารถได้รับกันทุก Windows ทำให้เราปรับแต่งทุกบอร์ดได้ภายในการสั่งงานครั้งเดียว โดยที่ถ้าต้องการให้ออก windows เดียว เราก็กดไปที่ Windows นั้น แต่ถ้าต้องการให้ออกทุก Window เราก็เอา mouse ไป active ที่ Windows เล็ก CSSH [3] ดังรูปครับ

cssh

ขั้นตอนที่ 12: ปรับปรุง /etc/hostname อัตโนมัติ

ไม่ยากแล้วครับใช้ clusterssh ส่งคำสั่ง

เมื่อ boot เสร็จชื่อเครื่องของทุกเครื่องจะถูกต้องครับ

ขั้นตอน 13: การส่งแฟ้มจาก Master ไปสู่ node ทุกเครื่อง

ปกติแล้วเราจะใช้ scp ในการส่งแฟ้มข้ามเครื่อง แต่ scp นั้นส่งได้ที่ host เท่านั้น เราไม่สามารถ clusterssh เพื่อดูดแฟ้มจาก master ได้เพราะมันจะกลายเป็น loop ดังนั้นจึงต้องใช้ parallel-scp ลงตามขั้นตอนนี้เลยครับ ลงที่เครื่อง master นะครับ

ไปแก้แฟ้ม ~/.bashrc เพิ่มบรรทัดต่อท้ายด้งนี้ครับ

จากนั้นปิด shell แล้วเข้าใหม่ครับ เราใช้งานได้แล้วครับ เช่นเราต้องการส่งแฟ้ม hello.txt เราก็สามารถเขียน

แฟ้ม hello.txt จะถูกส่งไปยัง node01, node02 และ node03 ครบทั้งสามเครื่อง

ทิ้งท้าย

ทีแรกก่อนเขียนบทความนี้ คิดว่าคงเป็นบทความสั้นๆ อาจจะสั้นที่สุด เพราะเนื้อเรื่องมีไม่มาก แต่พอเขียนจริงๆ จบไม่ลงครับ คิดว่าพรุ่งนี้เสร็จ มันก็มีพรุ่งนี้ของพรุ่งนี้ไปเรื่อยๆ กว่าจะเสร็จเล่นเอาหมดแรงเหมือนกัน แต่ก็สนุกมากระหว่างเขียน หวังว่าท่านคงสนุกในการอ่านเช่นกัน แล้วพบกันใหม่ครับ

[Total: 24    Average: 3.3/5]

You may also like...