สัปดาห์ที่ผ่านมามีโอกาสสอนและแบ่งปัน
เรื่อง Continuous Integration and Delivery with Jenkins ที่ Software Park เป็นเวลา 2 วัน
จึงทำการสรุปสิ่งที่สอนและแบ่งปันไว้นิดหน่อย
อธิบายเกี่ยวกับความสำคัญของ CI และ CD
เกิดมาจากปัญหาในเรื่องของการ integrate ทดสอบ และ deploy ระบบงาน
ทั้งใช้เวลา คน และ ค่าใช้จ่ายที่สูงมาก
แถมได้ข้อผิดพลาดมากมายเป็นสิ่งตอบแทน
ดังนั้นแนวคิดและแนวปฏิบัติเหล่านี้จึงเกิดขึ้นมา
เพื่อช่วยลด !! ไม่ใช่นะ
แต่เป็นการช่วยหาปัญหา เพื่อชี้จุดที่มีปัญหา
จากนั้นจึงทำการแก้ไข ได้อย่างรวดเร็ว
ยิ่งรู้ปัญหาได้เร็วเพียงใด ยิ่งดีมากเท่านั้น
ยกตัวอย่างเช่น
หลังจากที่ developer ทำการพัฒนา feature หนึ่งเสร็จแล้ว
คำถามคือ developer บอกว่าเสร็จ นั่นคืออะไร ?
เขียน code เสร็จ ?
ทดสอบ feature นั้น ๆ แล้ว ?
ทดสอบ feature ทั้งหมดหรือไม่ ?
มั่นใจหรือไม่ว่า feature ที่เพิ่มไปนั้น กระทบการทำงานส่วนอื่น ๆ หรือไม่ ?
เมื่อ deploy แล้วมีปัญหาต่อผู้ใช้งานหรือไม่ ?
อธิบายเกี่ยวกับแนวปฏิบัติของ CI และ CD
หลัก ๆ คือ
1. Integrate ส่วนการทำงานบ่อย ๆ
2. ค่อย ๆ เพิ่ม feature ต่าง ๆ แบบเล็ก ๆ
3. ต้องทำให้ได้ feedback ที่รวดเร็วจากทุก ๆ การเปลี่ยนแปลง
สังเกตได้ว่า แนวปฏิบัติต่าง ๆ จะเกิดจากคนล้วน ๆ
ลองคิดดูว่า
ถ้าคนทำงานไม่ส่งการเปลี่ยนแปลง หรือ บอกให้คนอื่นรู้โดยเร็ว
จะทำการ integrate บ่อยได้อย่างไร
แล้วจะรู้ปัญหาได้เร็วได้อย่างไร
แสดงว่างานที่ทำมันใหญ่เกินไปไหม
ดังนั้นสิ่งต่าง ๆ เหล่านี้
เป็นการปรับปรุงสิ่งที่กำลังทำอยู่ให้ดีขึ้น
นั่นคือ ต้องเริ่มจากคนทำงาน (People)
จากนั้นคนทำงานคิดขั้นตอนการทำงานหรือปรับให้ดีขึ้น (Process)
สุดท้ายคนทำงานจึงหาเครื่องมือที่ดีและเหมาะสม (Tools)
เพื่อช่วยให้ขั้นตอนการทำงานมีประสิทธิภาพที่ดีขึ้นอย่างต่อเนื่อง
ปล. อย่าเริ่มด้วยเครื่องมือเด็ดขาด !!
จากนั้นแนะนำให้ผู้เรียนทำการออกแบบขั้นตอนการทำงาน
หรืออาจจะเรียกว่า build process หรือ build pipeline ขึ้นมา
ซึ่งจะเน้นในส่วนการพัฒนา software
นั่นคือ เริ่มด้วยจาก
- การจัดการ source code ควรอยู่ใน version control system ที่ดี
- ยังไม่พอ ต้องคุยและตกลงเรื่องของ Branch strategy อีกด้วย มิเช่นนั้นเละแน่ ๆ
- ขั้นตอนการ build เป็นอย่างไร เช่น compile, testing, packaging และ deploy
- เน้นเรื่องของการวิเคราะห์ source code
- เน้นเรื่องของการทดสอบในชั้นต่าง ๆ เช่น unit, integration, component, API และ User Interface ซึ่งควรเป็นการทดสอบแบบอัตโนมัติให้ได้มากที่สุด
- เน้นในเรื่องของการจัดเก็บ software package ซึ่งแนะนำให้แยก code กับ configuration ออกจากกัน
- เน้นในเรื่องของการ deploy ระบบงานแบบอัตโนมัติ
สิ่งเหล่านี้คือ ขั้นตอนที่ทีมควรคิดและสรุปกันก่อนเสมอ
จากนั้นทำการสรุปว่า
ในแต่ละขั้นตอนทำอย่างไร ?
ในแต่ละขั้นตอนใช้เครื่องมืออะไรบ้าง ?
โดยใน workshop นั้นจะใช้เครื่องมือต่าง ๆ ดัง
- Git และ Github สำหรับจัดการ source code, configuration และชุดการทดสอบ
- SonarQube, Checkstyle, Lint, PMD, CPD และ FindBugสำหรับการวิเคราะห์ source code
- JUnit สำหรับการเขียนชุดการทดสอบแบบอัตโนมัติ
- Robotframework สำหรับการทดสอบ User Interface แบบอัตโนมัติ
- Postman สำหรับการทดสอบ API แบบอัตโนมัติ
- Frog Artifactory สำหรับการจัดเก็บ software package ต่าง ๆ
สุดท้ายจึงพาแปลงจากขั้นตอนการทำงานที่สรุปด้วยเครื่องมือที่ชื่อว่า Jenkins
ซึ่งเป็นหนึ่งในเครื่องมือที่ได้รับความนิยม
แต่ถามว่า ใช้เครื่องมืออื่นได้ไหม ?
ตอบได้เลยว่า ได้
แต่คุณเอาเครื่องมือ หรือ ขั้นตอนเป็นหลัก
ไว้เจอกันในรอบต่อ ๆ ไป
ขอให้สนุกกับการ coding ครับ
