ปัญหาอย่างหนึ่งที่มักพบเจอกับทีมพัฒนาคือ
เครื่องผมเครื่องหนูมันทำงานได้นะ
แต่บนเครื่องจริง ๆ กลับทำงานไม่ถูกต้องหรือทำงานต่างกันไป
ไม่ว่าจะเหตุผลใดก็ตาม มันก็คือไม่ถูก
ดังนั้นเราจะทำอย่างไรดีละ ?
หนึ่งแนวทางคือ ถ้าทำให้เครื่องนักพัฒนา
มีขั้นตอนการทำงาน มี environment ต่าง ๆ เหมือนหรือคล้ายกับเครื่องจริง ๆ
มันน่าจะดีไม่น้อยนะ
แต่การติดตั้งมันก็ไม่ง่ายนะ
ติดปัญหามากมายทั้ง software ทั้ง CPU/RAM/Network รวมไปถึง configuration
ชีวิตดูลำบากน่าดู
จะติดตั้งระบบ Contunous Integration ก็แลดูจะนานไปหน่อย
ดังนั้นมาติดตั้งระบบ Continuous Integration บนเครื่องกันไปเลย
แน่นอนว่านำ Docker มาใช้งานด้วย
มาดูกันว่าใช้อย่างไร ?
ปัญหาที่ทำให้พบเจอเรื่อง Work on my machine
ประกอบไปด้วย
- ในแต่ละ environment แตกต่างกัน
- มีชุดการทดสอบนะ แต่ว่าเราคนจริงต้อง skip หรือบางคนลบทิ้งไป !!
- มีหลาย ๆ ไฟล์ และ folder ที่มีเฉพาะในเครื่องของนักพัฒนา ขึ้นไปที่อื่นจะรอดได้ไง
- ความผิดพลาดที่เกิดจาก code
ดังนั้นสิ่งที่ทีมพัฒนามักจะสร้างเพื่อแก้ไขหรือลดปัญหาเหล่านี้คือ
การสร้างระบบ Continuous Integration ขึ้นมา
เพื่อช่วยทำให้ทีมพัฒนารู้ตัวได้อย่างรวดเร็ว
ว่ามีข้อผิดพลาดอะไรตรงไหน
จะได้แก้ไขได้อย่างรวดเร็ว
ที่สำคัญระบบนี้ตองทำงานได้อย่างรวดเร็ว
แต่เมื่อระบบเริ่มใหญ่ขึ้น
code เยอะขึ้น
ทีมใหญ่ขึ้น
เวลาในการทำงานของระบบ Continuous Integration ก็จะเริ่มช้าลง
นั่นคือ เรารู้ปัญหาได้ช้าลง
ซึ่งจำเป็นต้องแก้ไขเพื่อให้ทีมและนักพัฒนารู้ได้อย่างรวดเร็ว
แน่นอนว่ามีวิธีการมากมาย
เช่นการเปลี่ยนขั้นตอนการทำงาน
เช่นการเพิ่ม RAM/CPU ให้เยอะและเร็วขึ้น
แต่มีอีกวิธีการหนึ่งที่น่าสนใจคือ
ทำ Local Continuous Integration Server บนเครื่องนักพัฒนาแต่ละคนไปเลย
เพื่อทำให้นักพัฒนามั่นใจว่า
สิ่งที่สร้าง แก้ไข หรือเปลี่ยนแปลงมันผ่านจริง ๆ นะ
ก่อนนะทำการ push/checkin code มายังส่วนกลาง
โดยการติดตั้งเราจะนำ Docker มาใช้ มันง่ายมากนะ
โดยขั้นตอนของนักพัฒนาจะเปลี่ยนไป คือ
- เมื่อทำการแก้ไข code บนเครื่องตาม requirement หนึ่ง ๆ แล้ว
- เมื่อมั่นใจ ตรวจสอบสิ่งต่าง ๆ แล้ว ทำการ run Continuous Integration Server ที่เครื่อง
- เพื่อทำการตรวจสอบสิ่งต่าง ๆ ทั้งการ compile, test
- การทำงานต่าง ๆ อยู่ในโลกของ container
- เมื่อทุกอย่างผ่านแล้ว ก็ทำการ commit/push/checkin code ไปยังส่วนกลางต่อไป
ซึ่งวิธีการนี้จะช่วยเพิ่มความมั่นใจให้กับนักพัฒนาขึ้นอย่างมาก
ลดการ build ที่แดงหรือ fail ในระบบ Continuous Integration ที่อยู่ตรงกลางอีกด้วย
แน่นอนว่า ส่งผลดีต่อทีมอย่างแน่นอน
ขี้โม้มากแล้ว มาลงมือทำกันบ้าง
ถ้าพูดเรื่องของระบบ Continuous Integration กันแล้ว
มักจะพูดถึงแต่ Jenkins
เนื่องจากเป้นเครื่องมือที่ได้รับความนิยม มี community ขนาดใหญ่ เอกสารเพียบ
แต่จะติดตั้งและ configuration มันไม่ง่ายเลย
ดังนั้นขอแนะนำของง่าย ๆ เล็กลงมาหน่อยคือ Buildpal
โดยที่ Buildpal คือ Continuous Integration Server
ที่สร้างมาในโลกของ container เลย
ดังนั้นมันจึงต้องเล็กและเร็วเป็นธรรมชาติ
สนับสนุนเรื่องของ Pipeline as a Code
โดยที่ pipeline นั้นทำการเขียนด้วยภาษา JavaScript !!
สามารถกำหนดให้ทำการแบบ sequence หรือ parallel ได้อีกด้วย
แต่โชคไม่ค่อยดีว่า มันพัฒนาด้วยภาษา Java 8 นะ
รออะไรติดตั้งกันดีกว่า
ติดตั้งง่าย ๆ ผ่าน Docker ไปเลย
โดยตัวอย่างทำการสร้าง Volume container ก่อน
จากนั้นจึงทำการสร้าง container ของ Local Continuous Integration Server กัน
ดังนี้
ทดสอบด้วยการเปิด url http://localhost:8080/ ใน browser
username=admin
password=admin123
ต่อมาเริ่มสร้าง pipeline หรือขั้นตอนการทำงานกัน
สิ่งที่ต้องการเป็นดังนี้
1. Source code ของ project อยู่ที่ Git repository
2. สร้าง Pipeline สำหรับการ compile + test ด้วย Apache Maven
สามารถสร้างใน Buildpal ได้ดังนี้
1. กำหนด Repository ก่อน
สนับสนุน Git, File system และ Perforce
ให้ทำการกำหนดค่าต่าง ๆ แสดงดังรูป
2. ทำการสร้าง Pipeline
สิ่งที่กำหนดคือ เลือก Repository ที่ต้องการ
เลือกใช้ image ที่ต้องการสำหรับสร้าง container
จากนั้นก็เข้าไป execute คำสั่งต่าง ๆใน container กันแบบสบาย ๆ
มาดูตัวอย่างของการใช้งาน Apache Maven เพื่อ compile + test ระบบแบบง่าย ๆ
แสดงดังรูป
3. ผลการทำงานเป็นดังรูป
โดยรวม ๆ แล้วก็ใช้งานง่ายดีนะ
ทุกอย่างอยู่ในโลกของ container ด้วย Docker กันไปเลย
ลองใช้กันดูนะครับ
ไม่พอใจก็ลบ container ทิ้งไปซะ ง่ายสุด ๆ
ดังนั้นเครื่องใครก็สามารถทำได้นะครับ
ที่สำคัญถ้าทำ Image และไฟล์ต่าง ๆ ให้เหมือนกัน
ก็จะไม่เกิดปัญหาเครื่องผมทำงานได้นะ !!
ขอให้สนุกกับการ coding ครับ
