มีโอกาสได้ไปสอนและแบ่งปันเรื่องของ SOA/Microservice เป็นเวลา 1 เทอม
ที่คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกล้าเจ้าคุณทหารลาดกระบัง
จึงทำการสรุปสิ่งที่สอนและพาทำไว้นิดหน่อย
ซึ่งน่าจะพอเป็นประโยชน์ต่อคนที่สนใจบ้าง

เริ่มต้นด้วย course outline หรือหัวข้อการสอน (ไม่รวมการ present ของแต่ละกลุ่ม)

ประกอบไปด้วย

สัปดาห์ที่ 1

Evolution of software architecture ตั้งแต่ monolith จนถึง Microservice ว่ามีที่มาที่ไปอย่างไร
ข้อดีและข้อเสียของ Microservice

สัปดาห์ที่ 2

การออกแบบ Microservice พื้นฐาน มีขั้นตอนคร่าว ๆ คือ

  • เข้าใจพฤติกรรมของระบบ
  • การแบ่ง service ออกแบบ service ย่อย ๆ
  • รูปแบบการออกแบบ service ซึ่งเป็นจุดเริ่มต้นของ Microservice

สัปดาห์ที่ 3

ทำความรู้จักและเข้าใจกับ RESTful API
มีที่มาที่ไปอย่างไร
เหตุผลในความนิยมของ RESTful API

สัปดาห์ที่ 4

การออกแบบ RESTful API
โดยได้นำเอา Service Design Blueprint เข้ามาช่วยในการออกแบบ
ซึ่งมีขั้นตอนดังนี้

  1. ออกแบบ flow การทำงานของระบบในมุมมองของผู้ใช้งาน
  2. ทำการออกแบบ RESTful API ในแต่ละขั้นตอนการทำงานจากข้อที่ 1 ซึ่งจะได้ชื่อและ endpoint
  3. ทำการกำหนด HTTP method ของ RESTful API
  4. ทำการกำหนดรูปแบบ request และ response
  5. ทำการออกแบบ database สำหรับการจัดการข้อมูลของแต่ละ RESTful API
  6. ทำแบบนี้ไปในทุก ๆ flow การใช้งาน

สัปดาห์ที่ 6 และ 7

ทำการพัฒนา Microservice ด้วย Spring boot
ถ้าเพียงแค่ออกแบบมันไม่สนุกเท่าไร
ดังนั้นจึงให้ทำการพัฒนาสิ่งที่ออกแบบมาให้ใช้งานได้บ้าง

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

คำถามคือทำไมต้องใช้ Spring boot ?
คำตอบภาษา Java นักศึกษาส่วนใหญ่เขียนมาแล้ว
ส่วน Spring boot นั้นผมเลือกให้เอง
ไม่มีเหตุผลอะไรมาก เพราะว่า ถ้าใช้ภาษา Java ก็ต้องตัวนี้
น่าจะเป็นความรู้ใหม่ ๆ ติดตัวนักศึกษาไปไม่มากก็น้อย

ส่วนการทดสอบ RESTful API นั้น
ทำการแนะนำและพาเขียนด้วย Silk ซึ่งง่ายดี
แต่ก็มีบางกลุ่มเขียนการทดสอบด้วย Robotframework
ส่วนการทดสอบแบบ manual ก็ให้ใช้ Postman กัน

สัปดาห์ที่ 8

สรุปรูปแบบในการออกแบบ Microservice ว่ามีรูปแบบใดบ้าง
ซึ่งในส่วนนี้ผมไม่ได้คิดเอง
นำข้อมูลมาจาก web Microservices.io
กับหนังสือ Building Microservice

สัปดาห์ที่ 9

สรุปรูปแบบการติดต่อสื่อสารระหว่าง service
ซึ่งมีทั้งแบบ Synchronous และ Asynchronous
เพื่อให้รู้ว่ามีรูปแบบใดบ้าง
ส่วนสิ่งที่เลือกให้ใช้ในการพัฒนาคือ Synchronous (ง่ายที่สุดสำหรับการเริ่มต้น)

สัปดาห์ที่ 10 และ 11

ทำการแนะนำเกี่ยวกับเรื่องของ Containerization
ซึ่งเป็นอีกแนวคิดหนึ่งที่ได้รับความนิยมในปัจจุบัน
ตั้งแต่การพัฒนาไปจนถึงการ deploy ระบบ
ซึ่งเลือกใช้ Docker มาช่วยจัดการ

ปัญหาการทำ Lab ก็พอสมควร
แต่ก็พอไปวัดไปวาได้ด้วยการใช้งานที่ Digital Ocean

โดยจะสอนแบบค่อยเป็นค่อยไป
ให้รู้จักการสร้าง container ไว้บ้างเล็กน้อย

จากนั้นแนะนำวิธีการ deploy ระบบที่พัฒนาด้วย Docker
ซึ่งพาเขียน Dockerfile นิดหน่อย แค่ 3 บรรทัดเท่านั้น

โดยที่ project ของแต่ละกลุ่มให้ทำการ deploy ด้วย Docker นี่แหละ
มีบางกลุ่มใช้ Kubernates ด้วย ก็ยิ่งดีไปใหญ่เลย

สัปดาห์ที่ 12

สิ่งที่ขาดไม่ได้เลยสำหรับ Microservice หรือระบบใด ๆ ก็ตาม
คือระบบ Monitoring หรือ Application monitoring หรือ Service monitoring
หรือพูดให้ถูกคือ API monitoring

โดยใน Lab สอนเรื่อง monitoring ของ Spring boot ด้วย Actuator
ซึ่งทำการจัดเก็บข้อมูลลงใน Pometheus ที่เก่งเรื่องข้อมูลแบบ time-serie
จากนั้นนำมาแสดงผลด้วย Grafana ที่เก่งเรื่องการแสดงผลข้อมูลแบบสวยงาม ดูดีมีอะไร
โดยเขียนสรุปไว้ใน blog เรื่องระบบ Monitoring สำหรับ Spring boot

ปล. ในทุก ๆ หัวข้อจะให้นักศึกษาทำ quiz เสมอ !!!

โดยที่รายละเอียดและ slide ต่าง ๆ อยู่ที่ Github::Up1::Course Microservice

สิ่งที่ยังไม่ได้สอนประกอบไปด้วย

  • การแบ่งกลุ่มของ service โดยนำแนวคิด DDD (Domain-Driven Design) มาใช้
  • API Gateway
  • การ Scale service

การทำงานเป็นกลุ่ม ซึ่งเป็นส่วนสำคัญมาก ๆ

แน่นอนว่า ต้องมีการทำงานเป็นกลุ่ม ให้แต่ละกลุ่ม
ออกแบบระบบงานเอง
พัฒนาเอง
ทดสอบเอง
deploy เอง
present เอง โดยจะ present 3 สัปดาห์ครั้ง และมีการ present สรุปครั้งสุดท้ายอีก

Source code และ เอกสารต่าง ๆ เขียนใน Wiki ของ Github

เมื่อทำงานเป็นกลุ่ม จึงให้คะแนนในส่วน

  • จำนวนการ commit ของแต่ละคนในกลุ่ม ต้องใกล้เคียงกัน
  • จำนวนการเขียน wiki ของแต่ละกลุ่ม ต้องใกล้เคียงกัน
  • สอนใช้ Issue
  • สอนใช้ Project

ดังนั้นถ้าในกลุ่มกระจายงานกันไม่ดี คะแนนก็จะต่ำ
โดยเขียน code แบบขำ ๆ เพื่อดึงข้อมูลจาก Github มาแสดงนิดหน่อย ดังรูป

ส่วน source code ก็ทำการวิเคราะห์ด้วย SonarQube นิดหน่อย
เพื่อทำให้นักศึกษาเห็นว่า การวิเคราะห์ code ในเบื้องต้นเป็นอย่างไร

เป้าหมายหลักของ course นี้คือ

ให้รู้และเข้าใจว่า software architecture ในรูปแบบต่าง ๆ นั้น
มีที่มาที่ไปอย่างไร
แก้ไขปัญหาอะไร
มีข้อดีและข้อเสียอย่างไร

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

โดยกลุ่มต่าง ๆ ของนักศึกษาอยู่ที่นี่

 

ปล. มันน่าจะมีประโยชน์บ้างนะครับ

สุดท้ายคะแนนทุกอย่างอยู่ใน Google Docs
ซึ่งถ้ามันลงตัวอาจจะกลายเป็นระบบงานต่อไปได้เลย
ทำไปทำมาซับซ้อนน่าดู !!