วิธีแก้ปัญหา Docker Crash Loop สำหรับมือใหม่หัดเขียนโปรแกรม

ทำความรู้จักกับอาการ Docker Crash Loop

เวลาที่เราเริ่มเขียนโปรแกรมและหัดใช้ Docker (เครื่องมือสำหรับจำลองสภาพแวดล้อมการทำงานของโปรแกรม) เรามักจะเจอสถานการณ์ที่คอนเทนเนอร์ (Container - สภาพแวดล้อมเสมือนที่บรรจุโปรแกรมของเราไว้) เปิดขึ้นมาแล้วดับไปเองซ้ำๆ จนดูเหมือนมันติดอยู่ในวงจรไม่รู้จบ นี่แหละคือสิ่งที่เรียกว่า Docker Crash Loop (อาการที่คอนเทนเนอร์พยายามเริ่มทำงานใหม่ซ้ำไปซ้ำมาเพราะเกิดข้อผิดพลาด)

ลองนึกภาพว่าคุณกำลังพยายามต้มมาม่า แต่พอใส่เส้นลงไปในน้ำเดือดปุ๊บ หม้อก็ระเบิดตูมทันที แล้วคุณก็หยิบหม้อใบใหม่มาต้มซ้ำแบบเดิมเป๊ะๆ วนไปเรื่อยๆ นี่คือสิ่งที่ Docker ทำเมื่อโปรแกรมหลักภายในคอนเทนเนอร์ทำงานผิดพลาดจน Exit Code (รหัสสถานะที่โปรแกรมแจ้งเมื่อจบการทำงาน) ไม่เป็นศูนย์ Docker จะมองว่าโปรแกรมพังและพยายามรีสตาร์ทให้เราอัตโนมัติ

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

ทำไม Docker ถึงพยายามรีสตาร์ทโปรแกรมของเรา

หัวใจสำคัญของ Docker คือการที่มันยึดติดกับ Process (กระบวนการทำงานของโปรแกรม) หลักที่เรียกว่า PID 1 ถ้าโปรแกรมนี้ตาย Docker จะถือว่าหน้าที่ของคอนเทนเนอร์นั้นจบสิ้นลงแล้ว หากเราตั้งค่า Restart Policy (กฎที่กำหนดว่าเมื่อไหร่ควรเปิดโปรแกรมใหม่) เป็นแบบ always (เปิดใหม่เสมอ) Docker ก็จะทำหน้าที่เป็นพนักงานคอยกดปุ่ม Reset ให้เราทันที

สาเหตุส่วนใหญ่ที่ทำให้เกิดการวนลูปแบบนี้มักมาจากข้อผิดพลาดพื้นฐาน เช่น การลืมกำหนดค่า Environment Variable (ตัวแปรสภาพแวดล้อมที่ใช้เก็บค่าคอนฟิกต่างๆ) ที่จำเป็น หรือการเชื่อมต่อฐานข้อมูลไม่สำเร็จ ถ้าโปรแกรมหาค่าเหล่านี้ไม่เจอ มันจะหยุดทำงานทันทีเพื่อป้องกันความเสียหายที่อาจเกิดขึ้นกับข้อมูล หรือเพราะมันไม่รู้จะทำงานต่ออย่างไร

เพื่อให้เห็นภาพชัดขึ้น ลองดูตัวอย่างการเขียนไฟล์ docker-compose.yml (ไฟล์กำหนดค่าการรันคอนเทนเนอร์หลายตัว) ที่อาจทำให้เกิดลูปนี้ได้ หากเราตั้งค่าให้รันโปรแกรมที่ไม่มีอยู่จริง หรือเขียนโค้ดที่ทำให้โปรแกรมปิดตัวลงทันทีหลังจากรัน คอนเทนเนอร์ก็จะวนลูปแจ้งเตือนว่ามันกำลังพยายามรีสตาร์ทอยู่ตลอดเวลา

version: '3'
services:
  app:
    image: node:18
    # สั่งให้รันคำสั่งที่ผิดพลาดจนโปรแกรมปิดตัวลง
    command: ["node", "-e", "process.exit(1)"]
    restart: always

ในโค้ดชุดนี้ บรรทัด command คือการสั่งให้ Node.js รันโค้ดที่สั่งปิดโปรแกรมด้วยรหัส 1 ทันที ส่วน restart: always คือตัวกำหนดให้ Docker พยายามเปิดใหม่ทุกครั้งที่มันเห็นคอนเทนเนอร์ดับลง ผลลัพธ์ที่ได้คือคอนเทนเนอร์จะวนลูปสถานะ Restarting ไปเรื่อยๆ และเราจะไม่เห็นหน้าจอการทำงานปกติเลย

การเก็บข้อมูลให้รอดพ้นจากการรีสตาร์ท

ปัญหาใหญ่สุดของมือใหม่คือ พอคอนเทนเนอร์รีสตาร์ท ไฟล์ Log (บันทึกการทำงานของโปรแกรม) ที่อยู่ในตัวคอนเทนเนอร์จะหายไปหมดเหมือนการลบกระดานทิ้ง ทำให้เราไม่รู้เลยว่าก่อนมันจะตาย มันบ่นว่าอะไรไว้บ้าง เราจึงต้องใช้ Volume Mount (การเชื่อมต่อโฟลเดอร์จากเครื่องเราเข้าไปในคอนเทนเนอร์) เพื่อเก็บข้อมูลไว้ที่เครื่องเราแทน

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

หากคุณกำลังหัดทำโปรเจกต์ อย่าลืมกำหนด Volume ให้กับโฟลเดอร์ที่โปรแกรมของคุณใช้เขียนไฟล์ Log หรือไฟล์เก็บสถานะเสมอ วิธีนี้จะช่วยให้คุณเปลี่ยนจากสถานะ "งมเข็มในมหาสมุทร" มาเป็นการ "เปิดอ่านสมุดบันทึก" เพื่อหาจุดผิดพลาดในโค้ดได้ทันที นี่คือทักษะสำคัญที่มืออาชีพทุกคนใช้ในการ Debug (การตรวจหาและแก้ไขข้อผิดพลาดในโค้ด)

วิธีตรวจสอบว่าเกิดอะไรขึ้นในคอนเทนเนอร์

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

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

ขั้นตอนการตรวจสอบสถานะคอนเทนเนอร์ที่พัง:

1. รันคำสั่ง docker ps -a เพื่อดูสถานะคอนเทนเนอร์ทั้งหมดในเครื่อง
2. ใช้คำสั่ง docker logs [ชื่อคอนเทนเนอร์] เพื่อดูข้อความแจ้งเตือนข้อผิดพลาดล่าสุด
3. ถ้าดูไม่ทัน ให้ใช้ docker run -it --entrypoint sh [ชื่ออิมเมจ] เพื่อเข้าไปในระบบแบบโต้ตอบ

ผลลัพธ์ที่คุณควรเห็นคือหน้าจอ Terminal ที่พร้อมให้เราพิมพ์คำสั่งเข้าไปสำรวจไฟล์ภายในคอนเทนเนอร์ได้โดยตรง แทนที่จะปล่อยให้มันวนลูปอัตโนมัติจนอ่านอะไรไม่ทัน

แยกแยะ Exit Code เพื่อหาทางแก้

ในโลกของ Docker รหัส 0 คือสัญญาณว่า "งานเสร็จสมบูรณ์" แต่ถ้าเห็นรหัสอื่น เช่น 1 หรือ 137 นั่นคือสัญญาณอันตราย Exit Code 1 มักหมายถึงความผิดพลาดทั่วไปในโค้ด ส่วน 137 มักหมายถึงการที่คอนเทนเนอร์ถูกระบบสั่งหยุดเพราะใช้หน่วยความจำเกิน (Out of Memory)

การฝึกอ่านรหัสพวกนี้จะช่วยให้คุณเดาทางได้ว่าควรแก้ที่ไหน ถ้าเป็น 1 ให้ไปดูที่โค้ดส่วนที่จัดการ Exception (เหตุการณ์ผิดปกติที่เกิดขึ้นระหว่างรัน) แต่ถ้าเป็น 137 ให้ไปดูที่การตั้งค่าทรัพยากรของเครื่องหรือการเขียนโค้ดที่กินแรมมากเกินความจำเป็น การรู้รหัสพวกนี้จะช่วยลดเวลาในการเดาสาเหตุได้มหาศาล

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

บทสรุป: จบวงจร Crash Loop ด้วยการแก้ที่ต้นเหตุ

การจะหยุดวงจร Crash Loop ได้ เราต้องเลิกมองว่ามันคือศัตรูที่น่ารำคาญ แต่ให้มองว่ามันคือ "เพื่อนที่พยายามเตือนเรา" ว่าโค้ดหรือการตั้งค่าของเรายังไม่สมบูรณ์ เมื่อเราพบสาเหตุและแก้ไขจนโปรแกรมสามารถทำงานได้จนจบด้วย Exit Code 0 วงจรการรีสตาร์ทก็จะหยุดลงเองโดยอัตโนมัติ

ตัวอย่างเช่น หากคุณพบว่าโปรแกรมพังเพราะลืมตั้งค่า Database URL (ที่อยู่ของฐานข้อมูล) ให้คุณทำการแก้ไขไฟล์ docker-compose.yml เพิ่มตัวแปรให้ครบถ้วน เมื่อรันใหม่แล้วโปรแกรมสามารถเชื่อมต่อฐานข้อมูลได้สำเร็จ มันก็จะรันค้างไว้และพร้อมใช้งาน นี่คือความสำเร็จเล็กๆ ที่จะสร้างความมั่นใจให้คุณในการจัดการระบบที่ใหญ่ขึ้นในอนาคต

จงฝึกใช้คำสั่ง Docker อย่างใจเย็นเสมอ อย่ารีบแก้โค้ดโดยไม่ได้ดู Log เพราะนั่นคือวิธีที่ดีที่สุดในการเรียนรู้ว่าระบบทำงานอย่างไร การเป็นโปรแกรมเมอร์ที่เก่งไม่ได้วัดกันที่ว่าใครทำบั๊กน้อยกว่ากัน แต่วัดกันที่ว่าใครสามารถแก้บั๊กและทำความเข้าใจปัญหานั้นได้รวดเร็วและแม่นยำกว่ากัน ขอให้สนุกกับการจัดการคอนเทนเนอร์และก้าวสู่การเป็นนักพัฒนาที่มั่นใจครับ

ที่มา: Debugging Docker Crash Loops: A Practical Guide — DEV Community