555 คำ
3 นาที
เมื่อผมอยากทำซอฟต์แวร์ใช้เอง ตอนที่ 6: ยุค DevOps ปล่อยของทุกวัน
สารบัญ

ทุกบทความในซีรีส์นี้มาจากการที่ผมคุยกับ AI แล้วค้นข้อมูลเพิ่มเติม ผมเป็นคนกำหนดทิศทาง ให้ AI ช่วยสรุป วิเคราะห์ และเรียบเรียงออกมาเป็นบทความครับ

ในตอนที่ 5 ทีมฝนเขียนตะกร้าสินค้าใหม่เสร็จในสองสัปดาห์

แต่ลูกค้าได้ใช้จริงอีกหกสัปดาห์ต่อมา

เวลาไม่ได้หายไปกับการเขียนโค้ด

หายไปกับการรอ

รอส่งต่อทีม รอเครื่องทดสอบ รออนุมัติ รอคนติดตั้งด้วยมือ

ตอนนี้ขยับมาปี 2008

ทีมฝนจะค่อยๆ เปลี่ยนการรอแต่ละด่าน ให้กลายเป็นงานของเครื่องแทน

วิธีคิดแบบนี้ ต่อมาได้ชื่อว่า DevOps (ให้คนเขียนโค้ดกับคนดูแลเครื่องทำงานเป็นทีมเดียว แล้วให้เครื่องทำงานซ้ำๆ แทนคน)

ฝน ร้าน และทุกคนในร้านยังเป็นตัวละครสมมติเหมือนเดิม แต่เครื่องมือและเหตุการณ์จริงที่เล่าถึง มีอยู่จริง

แผนภาพ: ปี 2008 ทีมโตจาก 4 เป็น 20 คน ลูกค้าเยอะขึ้นหลายเท่า แต่ยังปล่อยของใหม่เดือนละคืน ตีสอง เว็บล่มบ่อย

ปี 2008 คืนที่ทุกคนกลัว#

ร้านขายอุปกรณ์เดินป่าจากตอนที่ 5 โตขึ้นมาก

ลูกค้าเยอะขึ้นหลายเท่า ทีมเขียนโค้ดจาก 4 คน กลายเป็น 20 คน

ฝนอายุ 38 แล้ว ตอนนี้เป็นหัวหน้าทีม

แต่วิธีปล่อยของใหม่ขึ้นเว็บ ยังเหมือนปี 1999 ทุกอย่าง

เดือนละครั้ง ตีสอง

คืนนั้นทุกคนต้องอยู่ รอดูว่าเว็บจะล่มมั้ย

ล่มบ่อยด้วยครับ

ทีมเขียนโค้ดบอกว่า “บนเครื่องผมใช้ได้นะ”

ทีมดูแลเครื่องบอกว่า “โค้ดพวกคุณนั่นแหละพัง”

เถียงกันจนเช้า 555+

DevOps คืออะไร?#

DevOps คือ Dev (คนเขียนโค้ด) กับ Ops (คนดูแลเครื่องที่รันระบบจริง) มาทำงานเป็นทีมเดียว มีเป้าหมายเดียวกัน แล้วให้เครื่องทำงานซ้ำๆ แทนคน

ทีมฝนไม่ได้เปลี่ยนทีเดียวทั้งหมด

ค่อยๆ รื้อทีละด่าน จากสี่ด่านในตอนที่ 5

ด่านที่ 1 สองทีม กลายเป็นทีมเดียว#

เมื่อก่อน ทีมเขียนโค้ดมีเป้าหมายว่า “ส่งของใหม่ให้เร็ว”

ทีมดูแลเครื่องมีเป้าหมายว่า “อย่าให้เว็บล่ม”

สองเป้าหมายนี้ดึงกันไปคนละทาง เลยทะเลาะกันตลอด

ฝนกับหัวหน้าทีม Ops ตกลงกันใหม่

ให้ทั้งสองทีมมีเป้าหมายเดียว คือ “ลูกค้าได้ของใหม่เร็ว และเว็บไม่ล่ม”

คนทีม Ops ย้ายมานั่งโต๊ะติดกับทีมเขียนโค้ด เข้าประชุมวางแผนด้วยกันตั้งแต่ต้นรอบ

เว็บล่มเมื่อไหร่ ทุกคนช่วยกันแก้ ไม่มีใครชี้นิ้วหาคนผิด

แผนภาพก่อน-หลัง: Dev อยากส่งของเร็ว Ops อยากให้เว็บไม่ล่ม ดึงกันคนละทาง พอรวมเป็นทีมเดียวก็มีเป้าเดียว ลูกค้าได้ของใหม่เร็วและเว็บไม่ล่ม

ด่านที่ 2 เขียนการตั้งเครื่องเป็นสูตร#

ปัญหาเดิมจากตอนที่ 5 คือเครื่องทดสอบกับเครื่องจริงตั้งค่าไม่เหมือนกัน

เพราะคนตั้งเครื่องด้วยมือ ทีละเครื่อง

คนละวัน คนละคน ก็ออกมาไม่เหมือนกัน

ทีมฝนเลยเลิกตั้งเครื่องด้วยมือ

เขียนวิธีตั้งเครื่องทั้งหมดลงไฟล์ เหมือนสูตรทำอาหาร ลงโปรแกรมอะไร รุ่นไหน ตั้งค่ายังไง

แล้วให้โปรแกรมอ่านสูตรนั้นไปตั้งเครื่องให้

ทำสูตรเดียวกันกี่ครั้ง ก็ได้เครื่องหน้าตาเหมือนกันทุกครั้ง ทั้งเครื่องของฝน เครื่องทดสอบ และเครื่องจริง

แล้วจะเอาเครื่องมาจากไหนเพิ่ม?

เมื่อก่อนต้องสั่งซื้อ รอส่งของ ยกเข้าห้อง server เป็นสัปดาห์

ปี 2006 Amazon เปิดบริการ EC2 ให้คนเช่าเครื่องบนอินเทอร์เน็ต จ่ายเป็นรายชั่วโมง

ทีมฝนกดขอเครื่องใหม่ ไม่กี่นาทีก็ได้ แล้วให้สูตรตั้งเครื่องให้เสร็จ

ใช้เสร็จก็คืน เลิกจ่าย

ด่านที่ 3 test ทันทีที่แก้ ไม่ต้องรอประชุมอนุมัติ#

ตอนที่ 5 ทีมฝนมี test อัตโนมัติแล้ว แต่ต้องมีคนสั่งรัน

และของจะขึ้นเว็บได้ ต้องรอประชุมอนุมัติเดือนละครั้ง

ตอนนี้ทีมตั้งเครื่องไว้หนึ่งเครื่อง คอยดูที่เก็บโค้ดตลอดเวลา

ใครส่งโค้ดเข้ามา เครื่องนี้ดึงไปรัน test ครบทุกข้อทันที

แล้วมี bot ส่งผลเข้าห้อง chat ของทีม

ผ่านหมด ขึ้นสีเขียว พร้อมปล่อย

พังข้อไหน ขึ้นสีแดง บอกชื่อ test ที่พัง คนที่เพิ่งแก้รู้ภายในไม่กี่นาที

วิธีนี้เรียกว่า CI (Continuous Integration) รวมโค้ดของทุกคนแล้ว test ทุกครั้งที่มีคนแก้

คนที่เคยนั่งประชุมอนุมัติ ตอนนี้ดูแค่สีในห้อง chat ก็พอ

สายพานจากโค้ดเสร็จ ไปถึงเว็บจริง#

CI ดูแลแค่ช่วงแรก คือรวมโค้ดแล้ว test

ทีมฝนอยากให้ทุกช่วงหลังจากนั้นต่อกันเป็นเส้นเดียว

นึกถึงสายพานในโรงงานขนมปังครับ

แป้งวางลงต้นสาย แล้วไหลผ่านเครื่องนวด เครื่องอบ เครื่องตรวจ เครื่องห่อ ไปจนถึงรถส่งของ

ก้อนไหนตรวจไม่ผ่าน ก็ถูกคัดออกตรงนั้น ไม่ไปถึงร้าน

โค้ดของทีมฝนก็เดินแบบนั้น ส่งโค้ดเข้ามา test ติดตั้งลงเครื่องทดสอบ test อีกรอบ แล้วพร้อมขึ้นเว็บจริง

สายพานเส้นนี้เรียกว่า pipeline

ส่วนการทำให้โค้ดพร้อมขึ้นเว็บจริงได้ตลอดเวลาแบบนี้ เรียกว่า CD (Continuous Delivery)

ชื่อนี้มาจากหนังสือ Continuous Delivery ของ Jez Humble กับ David Farley ที่ออกในปี 2010

ในตอนที่ 1 ผมเรียกช่วงนี้ว่ายุค Continuous Delivery กับ DevOps ก็มาจากตรงนี้แหละครับ

คนมักเรียกคู่กันว่า CI/CD

ด่านที่ 4 คู่มือหลายสิบหน้า กลายเป็นปุ่มเดียว#

คู่มือติดตั้งเล่มหนาจากตอนที่ 5 ทีมฝนเอามาเขียนเป็นโปรแกรมทีละขั้น

ย้ายไฟล์ แก้ค่า เปิดโปรแกรมใหม่ เช็กว่าเว็บขึ้น

ทุกขั้นที่คนเคยทำด้วยมือ เครื่องทำให้หมด

เหลือแค่กดปุ่มเดียว

เครื่องทำตามขั้นตอนเดิมเป๊ะทุกครั้ง ไม่ง่วง ไม่ข้ามขั้น ไม่ต้องรอตีสอง

แผนภาพ: ขั้นตอนในคู่มือที่คนทำมือกลางดึกและข้ามได้ กลายเป็นปุ่มเดียวที่เครื่องทำขั้นตอนเดิมเป๊ะทุกครั้ง

ทีมปี 2008 ใช้เครื่องมืออะไร?#

เก็บโค้ดด้วย git ฝากโค้ดไว้บนเว็บกลางที่ช่วยกันตรวจงานได้อย่าง GitHub และเช่า server บนอินเทอร์เน็ตแทนการซื้อเอง

จาก CVS มาเป็น git#

ตอนที่ 5 ทีมใช้ CVS ทุกคนต้องต่อเข้าที่เก็บกลางเครื่องเดียว

ปี 2005 Linus Torvalds คนเดียวกับที่เริ่ม Linux เขียน git ขึ้นมาใช้กับโค้ดของ Linux

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

เว็บกลางสำหรับเก็บโค้ดและตรวจงานกัน#

เดือนเมษายนปี 2008 GitHub เปิดตัว

เป็นเว็บที่ฝากโค้ด git ไว้ตรงกลาง

ใครแก้อะไร ก็ส่งเป็นคำขอรวมโค้ด ให้เพื่อนในทีมเปิดดู เขียนความเห็นทีละบรรทัด แล้วค่อยกดรวม

ทุกบรรทัดที่ขึ้นเว็บจริง มีอย่างน้อยสองคนเคยเห็นมาแล้ว

server เป็นของเช่า#

ร้านของฝนเลิกซื้อ server เองทีละเครื่อง

ช่วงลดราคาใหญ่ คนเข้าเว็บเยอะ ก็เช่าเพิ่มอีกหลายเครื่อง

ผ่านช่วงนั้นไป ก็คืน

แบบนี้ต่อมาคนเรียกรวมๆ ว่า cloud

เรื่องจริง ปี 2009#

เรื่องของฝนเป็นเรื่องสมมติ แต่ช่วงนั้นมีบริษัทจริงทำแบบนี้อยู่แล้ว

มิถุนายนปี 2009 ที่งานประชุม Velocity ในแคลิฟอร์เนีย John Allspaw กับ Paul Hammond จาก Flickr เว็บฝากรูปชื่อดังยุคนั้น ขึ้นพูดหัวข้อ “10+ Deploys Per Day”

คือ Flickr ปล่อยของใหม่ขึ้นเว็บจริง มากกว่าวันละ 10 ครั้ง

ในยุคที่หลายบริษัทยังปล่อยกันเดือนละครั้ง

สิ่งที่ทั้งสองคนเล่า ก็คล้ายกับที่ทีมฝนทำ ทั้งให้เครื่องตั้งเครื่อง ติดตั้งด้วยขั้นตอนเดียว bot ในห้อง chat และให้ Dev กับ Ops ไว้ใจกัน ไม่โทษกัน

ปลายเดือนตุลาคมปีเดียวกัน Patrick Debois จัดงาน devopsdays ครั้งแรกที่เมือง Ghent ประเทศเบลเยียม ชวนคนเขียนโค้ดกับคนดูแลเครื่องมาคุยกัน

ชื่อ DevOps ก็มาจากชื่องานนี้แหละครับ

แผนภาพจุด: ในหนึ่งเดือน หลายบริษัทปล่อยของขึ้นเว็บครั้งเดียว ส่วน Flickr ปล่อยวันละสิบกว่าครั้ง (จากงาน Velocity 2009; จำนวนวันทำงาน 22 วันเป็นตัวอย่าง)

จากหกสัปดาห์ เหลือไม่กี่ชั่วโมง#

ปลายปี 2009 ทีมฝนลองปล่อยของชิ้นเล็กๆ

ปุ่มเลือกสีเต็นท์ในหน้าสินค้า

เช้าเขียนโค้ด เพื่อนตรวจผ่าน GitHub test ขึ้นสีเขียวในห้อง chat

บ่ายกดปุ่ม

ลูกค้าได้ใช้ก่อนเลิกงาน

ไม่มีคืนตีสอง ไม่มีประชุมอนุมัติ ไม่มีใครเถียงกันจนเช้า

ร้านเปลี่ยนจากเดือนละครั้ง เป็นวันละหลายครั้ง

หกสัปดาห์ในตอนที่ 5 เหลือไม่กี่ชั่วโมง

แผนภาพ: ปี 1999 ไอเดียใช้หกสัปดาห์กว่าถึงลูกค้า ปลายปี 2009 เขียนโค้ดตอนเช้า ตรวจบน GitHub test เขียว กดปุ่ม ลูกค้าใช้ได้ก่อนเลิกงาน

ปล่อยบ่อย ก็พังบ่อยขึ้นได้#

แต่ปล่อยวันละหลายครั้ง ก็แปลว่ามีโอกาสพังวันละหลายครั้ง

บ่ายวันหนึ่ง ปุ่มจ่ายเงินหายไปจากหน้าตะกร้า

test ผ่านหมด เพราะไม่มี test ข้อไหนเช็กเรื่องนี้

ทีมรู้ตัวตอนลูกค้าโทรมาบ่น

แผนภาพ: test ทุกข้อผ่าน แต่ไม่มี test ว่าปุ่มจ่ายเงินยังอยู่ไหม ปุ่มจึงหายจากหน้าตะกร้า ทีมรู้ตอนลูกค้าโทรมาบ่น

ปล่อยของได้เร็วแล้ว

แต่จะรู้ตัวยังไงว่าพัง ก่อนลูกค้าจะโทรมา

แล้วจะกลับมาใช้ได้เร็วแค่ไหน

สิ่งที่ผมได้จากยุคนี้#

ลองทำเอง

ตามฝนมาตอนนี้ ผมว่าเรื่องสำคัญคือ ก่อนจะเร่งอะไร ให้นับก่อนว่าเวลาหายไปตรงไหน

ทีมฝนไม่ได้เขียนโค้ดเร็วขึ้นเลย

แค่เปลี่ยนการรอทีละด่าน ให้เป็นงานของเครื่อง

งานไหนทำซ้ำทุกครั้ง เครื่องทำได้แม่นกว่าคน

เก็บศัพท์

ศัพท์ความหมายแบบภาษาคน
DevOpsคนเขียนโค้ดกับคนดูแลเครื่องทำงานเป็นทีมเดียว และให้เครื่องทำงานซ้ำๆ แทนคน
Devคนเขียนโค้ด
Opsคนดูแลเครื่องที่รันระบบจริง
สูตรตั้งเครื่องไฟล์ที่เขียนวิธีตั้งเครื่องไว้ ให้โปรแกรมทำตาม ได้เครื่องเหมือนกันทุกครั้ง
EC2บริการเช่าเครื่องบนอินเทอร์เน็ตของ Amazon จ่ายรายชั่วโมง เปิดปี 2006
CI (Continuous Integration)รวมโค้ดและรัน test ทุกครั้งที่มีคนแก้
CD (Continuous Delivery)ทำให้โค้ดพร้อมขึ้นระบบจริงได้ตลอดเวลา โดยให้เครื่องช่วย test และติดตั้ง
pipelineสายพานที่พาโค้ดจากเขียนเสร็จ ผ่านการ test และติดตั้ง ไปจนถึงระบบจริง
gitเครื่องมือเก็บประวัติโค้ดที่ทุกคนมีประวัติครบในเครื่องตัวเอง ปี 2005
GitHubเว็บกลางฝากโค้ด git และตรวจงานกัน เปิดปี 2008
deployเอาโค้ดใหม่ขึ้นระบบจริงให้ลูกค้าใช้

จดบันทึก

ถ้าเพิ่งเข้ามาอ่านตอนนี้ ย้อนไปเริ่มที่ตอนที่ 1 ได้ครับ

ตอนที่ 2 สอนว่ายิ่งรู้ว่าผิดช้า ยิ่งเจ็บ

ตอนที่ 3 สอนว่ารอยต่อระหว่างคนคือที่ที่ความผิดซ่อนอยู่

ตอนที่ 4 สอนว่าให้คนใช้ดูเร็ว

ตอนที่ 5 ทำให้โค้ดเสร็จทุกสองสัปดาห์

ตอนนี้ทำให้โค้ดที่เสร็จแล้ว ถึงมือลูกค้าได้ในวันเดียวกัน

แต่ยิ่งเร็ว ก็ยิ่งต้องรู้ให้เร็วว่าพัง

คำถามที่พบบ่อย#

ทีมเล็กควรเริ่ม DevOps จากตรงไหน?

เริ่มทีละด่านแบบทีมฝน ไม่ต้องเปลี่ยนทีเดียวทั้งหมด ด่านแรกคือให้คนเขียนโค้ดกับคนดูแลเครื่องมีเป้าหมายเดียวกัน แล้วค่อยๆ ให้เครื่องทำงานซ้ำๆ แทนคน ทั้ง test ตั้งเครื่อง และติดตั้ง

DevOps ต่างจาก Agile ยังไง?

Agile ทำให้โค้ดเสร็จพร้อมใช้ในรอบสั้นๆ ไม่กี่สัปดาห์ ส่วน DevOps ทำให้โค้ดที่เสร็จแล้วไปถึงมือลูกค้าได้เร็ว โดยรื้อการรอระหว่างทีมและให้เครื่องติดตั้งแทนคน สองอย่างนี้ใช้ร่วมกันได้

คำว่า DevOps มาจากไหน?

มาจากชื่องาน devopsdays ที่ Patrick Debois จัดครั้งแรกที่เมือง Ghent ประเทศเบลเยียม ปลายเดือนตุลาคม 2009

CI/CD คืออะไร?

CI คือให้เครื่องรวมโค้ดและรัน test ทุกครั้งที่มีคนแก้ ส่วน CD คือต่อสายพานจากตรงนั้นไปจนโค้ดพร้อมขึ้นระบบจริงได้ตลอดเวลา สองอย่างนี้เลยมักเรียกรวมกันว่า CI/CD

git ต่างจาก CVS ยังไง?

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

Next → ตอนที่ 7: ยุค DevOps พังแล้วฟื้นไว ตอนหน้ายังเป็นยุค DevOps ปล่อยของวันละหลายครั้งแล้ว จะรู้ได้ยังไงว่าพังก่อนลูกค้าโทรมา และจะแก้กลับให้ใช้ได้เร็วแค่ไหน ผมจะลองดูครับ