โครงการ Yocto คืออะไร: คู่มือฝังตัวฉบับสมบูรณ์

หากคุณสนใจระบบฝังตัวหรือ IoT เร็ว ๆ นี้คุณจะได้พบกับ Yocto Project เป็นพื้นฐานที่ทีมงานนับพันสร้างการแจกจ่าย Linux "ของตัวเอง"ปรับแต่งให้เหมาะกับฮาร์ดแวร์และความต้องการของคุณ ไม่ใช่แค่ดิสโทรธรรมดา แต่เป็นชุดเครื่องมือ เมตาดาต้า และกระบวนการที่ยกระดับการปรับแต่งและความสามารถในการทำซ้ำไปอีกขั้น

ในคู่มือนี้ คุณจะเข้าใจโดยไม่ต้องเสียเวลาต่อไปว่า Yocto คืออะไรและไม่ใช่สิ่งใด เหตุใดจึงแพร่หลายมาก มีองค์ประกอบอย่างไร (OpenEmbedded, BitBake และ Poky) Layer Model ประกอบด้วยอะไร และมีเครื่องมือใดบ้างที่โคจรอยู่รอบๆ (Toaster, CROPS, eSDK...) รูปภาพถูกสร้างขึ้นมาอย่างไร มีตัวเลือกการอัปเดตอะไรบ้าง มีข้อเสนออะไรบ้างในแง่ของการรักษาความปลอดภัย และโครงการได้รับการกำกับดูแลและกำหนดเวอร์ชันอย่างไรนอกจากนี้คุณจะได้เห็นแนวคิดและตัวอย่างเชิงปฏิบัติ (reTerminal/Raspberry Pi) ที่จะช่วยให้คุณนำไปใช้ในชีวิตประจำวันได้

Yocto Project คืออะไร?

Yocto Project เป็นโครงการร่วมมือที่ได้รับการสนับสนุนจาก Linux Foundation ซึ่งจัดเตรียมองค์ประกอบพื้นฐานสำหรับการสร้างการแจกจ่าย Linux แบบกำหนดเองสำหรับอุปกรณ์ฝังตัวและ IoT ไม่ว่าสถาปัตยกรรมฮาร์ดแวร์จะเป็นอย่างไรก่อตั้งขึ้นในปี 2010 และเปิดตัวเวอร์ชันแรกในปี 2011 โดยได้รับการสนับสนุนจากองค์กรประมาณสองโหลและร่วมมืออย่างใกล้ชิดกับ OpenEmbedded

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

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

Yocto จะไม่ล็อคคุณไว้ เพราะไม่ขึ้นอยู่กับผู้จำหน่ายและไม่ขึ้นอยู่กับรูปแบบแพ็คเกจ ดังนั้นคุณจึงเลือกได้ระหว่าง deb, rpm หรือ ipk และปฏิบัติตามโมเดลการสร้างแบบกำหนดค่าได้ นอกเหนือจากภาพอุปกรณ์แล้ว คุณยังสามารถสร้างเครื่องมือและ SDK ที่กำหนดเองได้ สำหรับการพัฒนาและแก้ไขแอพพลิเคชัน

เหตุใดจึงต้องใช้ Yocto ในระบบฝังตัว

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

เหตุผลสำคัญอีกประการหนึ่งคือความสามารถในการทำซ้ำได้ ทุกอย่าง (เลเยอร์ สูตร การกำหนดค่า) สามารถกำหนดเวอร์ชันในคลังข้อมูลได้ ซึ่งช่วยให้สามารถสร้างภาพเดียวกันในสภาพแวดล้อมและเวลาที่ต่างกันได้สิ่งนี้สอดคล้องกับ CI/CD และให้การตรวจสอบย้อนกลับสำหรับ QA และการปฏิบัติตามข้อกำหนด

นอกจากนี้ยังโดดเด่นในเรื่องความยืดหยุ่น: รองรับสถาปัตยกรรมเช่น Arm, x86/x86-64, MIPS หรือ PowerPC และ ทำให้การรีไซเคิลการจัดจำหน่ายระหว่างกลุ่มผลิตภัณฑ์เป็นเรื่องง่ายยิ่งขึ้น หรือหมุนเมื่อเปลี่ยนบอร์ดหรือ SoC

การสนับสนุนจากชุมชนและอุตสาหกรรมช่วยให้มั่นใจได้ว่าจะมีการอัปเดตและแพตช์ด้านความปลอดภัยอย่างต่อเนื่อง มีสาขาที่มีการสนับสนุนเพิ่มเติม (LTS) เพื่อลดความซับซ้อนของอายุการใช้งานผลิตภัณฑ์ และการบำรุงรักษาภาคสนาม

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

ส่วนประกอบหลัก: OpenEmbedded, BitBake และ Poky

หัวใจของการสร้างคือ BitBake: เอนจิ้นที่ตีความสูตรและตัวแปรการกำหนดค่า แก้ไขการอ้างอิง และดำเนินการงานตามลำดับ (ดาวน์โหลด แกะ กำหนดค่า คอมไพล์ ติดตั้ง แพ็กเกจ ประกอบรูปภาพ) ลองนึกถึง BitBake เป็นเครื่องมือประสานงานแบบ "สร้าง" แต่ได้รับการออกแบบมาสำหรับโลกฝังตัว.

OpenEmbedded (OE) จัดเตรียมข้อมูลเมตาและฐานคลาส (OpenEmbedded-Core หรือ oe-core) ชุดสูตรอาหารและยูทิลิตี้ที่คัดสรรมาอย่างดีซึ่งได้รับการทดสอบอย่างต่อเนื่อง ซึ่งทำหน้าที่เป็นรากฐานให้กับเลเยอร์และโครงการนับร้อย

Poky คือการแจกจ่ายข้อมูลอ้างอิงของ Yocto ซึ่งรวมระบบการสร้าง OE ชุดสูตรที่หลากหลาย และการกำหนดค่า "ตามหนังสือ" ที่ถูกต้องเพื่อเริ่มต้นใช้งาน ไม่ใช่การจัดจำหน่ายผลิตภัณฑ์ แต่เป็นจุดเริ่มต้นที่เป็นเชิงสั่งสอนและเชิงฟังก์ชัน ที่ตรวจสอบระบบนิเวศ

โมเดลเลเยอร์: การทำงานร่วมกันและการปรับแต่งในเวลาเดียวกัน

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

แนวทางนี้ส่งเสริมการแยกตรรกะของสิ่งที่คุณทำ: เลเยอร์ BSP จากผู้ผลิต เลเยอร์ GUI เลเยอร์มิดเดิลแวร์ เลเยอร์สำหรับแอปพลิเคชันของคุณ เลเยอร์สำหรับการแจกจ่าย… การหลีกเลี่ยง "การวางทุกอย่างไว้ในชั้นเดียว" จะทำให้ชีวิตของคุณง่ายขึ้นเมื่อต้องอัปเดต บำรุงรักษา และนำกลับมาใช้ใหม่ ส่วนประกอบระหว่างโครงการ

เลเยอร์ BSP มีความสำคัญอย่างยิ่ง เนื่องจากมีโครงสร้างอุปกรณ์ การกำหนดค่าเคอร์เนล ไดรเวอร์ และการตั้งค่าเครื่องสำหรับเป้าหมายเฉพาะ (เช่น กลุ่มผลิตภัณฑ์ Raspberry Pi) การต้องขอบคุณพวกเขา การเพิ่มหรือเปลี่ยนฮาร์ดแวร์ไม่ได้หมายความว่าจะต้องเขียนใหม่ทั้งหมดเพียงเพิ่มหรือปรับเปลี่ยนเลเยอร์ที่เหมาะสม

ขั้นตอนการทำงานก่อสร้าง

กระบวนการทั่วไปนั้นชัดเจนมาก แม้ว่าจะเข้มข้นก็ตาม ขั้นแรก คุณต้องกำหนดสถาปัตยกรรม นโยบาย แพตช์ และพารามิเตอร์ (เช่น ใน local.conf y bblayers.conf). BitBake ดึงข้อมูลแหล่งที่มา (tarballs, git…), แพตช์, กำหนดค่า และคอมไพล์ ขึ้นอยู่กับคลาส (autotools, cmake ฯลฯ)

ผลลัพธ์ระดับกลางจะถูกติดตั้งในการจัดเตรียมชั่วคราวและบรรจุในรูปแบบที่เลือก (deb, rpm, ipk) ด้วยแพ็กเกจเหล่านี้ rootfs จะถูกสร้างขึ้นและสร้างอิมเมจขั้นสุดท้าย ที่คุณจะแฟลชหรือปรับใช้กับอุปกรณ์

การตรวจสอบความสมบูรณ์ การถดถอย และการทดสอบ QA จะดำเนินการตลอดกระบวนการสร้าง นอกจากนี้ คุณยังสามารถบูตและตรวจสอบภาพใน QEMU ได้อีกด้วย ซึ่งจะช่วยลดวงจรการลองผิดลองถูกบนฮาร์ดแวร์จริงโดยเฉพาะในระยะเริ่มแรก

เครื่องมือและโครงการย่อยรอบ Yocto

ระบบนิเวศน์นี้มอบยูทิลิตี้ที่ทำให้ชีวิตของคุณง่ายขึ้น CROPS คือเฟรมเวิร์กคอนเทนเนอร์ที่มอบสภาพแวดล้อมการสร้างที่สอดคล้องกันบน Linux, Windows และ macOS เหมาะสำหรับทีมผสมหรือสำหรับการสรุปความสัมพันธ์Toaster เป็นอินเทอร์เฟซเว็บสำหรับการกำหนดค่าและการเปิดตัวการสร้างและการดูเมตริกและสิ่งประดิษฐ์

eSDK (Extensible SDK) ช่วยให้นักพัฒนาแอปพลิเคชัน เพิ่มไลบรารีและการเปลี่ยนแปลงและป้อนกลับเข้าไปในรูปภาพ สะดวกมาก นอกจากนี้ยังมีการรองรับ Multi-Config สำหรับการสร้างสถาปัตยกรรมหลายแบบด้วยคำสั่งเดียว และ "การสร้างแบบไบนารี" สำหรับการรวมไฟล์ไบนารีเมื่อไม่มีแหล่งที่มา

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

โครงการอื่นๆ ภายใต้ร่มนี้ ได้แก่ ยูทิลิตี้ต่างๆ เช่น pseudo, cross-prelink, ชุด Matchbox สำหรับสภาพแวดล้อมกราฟิกน้ำหนักเบา และอื่นๆ อีกมากมาย ก่อนหน้านี้มีการบูรณาการกับ Eclipse ที่ถูกลบออกตั้งแต่เวอร์ชัน 2.7 กลายเป็นสิ่งล้าสมัยเมื่อมีเครื่องมือใหม่ๆ เข้ามา

การจัดการแพ็คเกจและกลยุทธ์การอัปเดต

การอัปเดตอุปกรณ์ภาคสนามเป็นสิ่งสำคัญ และ Yocto มีตัวเลือกมากมาย คุณสามารถเลือกอัปเดตอิมเมจทั้งหมด (ความสอดคล้องของระบบทั้งหมด) กระจายการเปลี่ยนแปลงที่ระดับแพ็กเก็ตเพื่อประหยัดแบนด์วิดท์ใช้โมเดลอะตอมที่มีการกลับด้าน (เช่น OSTree) หรือใช้เดลต้าเพื่อลดการถ่ายโอน

ไม่มีวิธีแก้ปัญหาแบบตายตัว: ภาพรวมทั้งหมดนั้นดีสำหรับ "การกระโดดครั้งใหญ่" แพ็กเก็ตสำหรับการเปลี่ยนแปลงแบบละเอียด อะตอมมิกสำหรับสภาพแวดล้อมที่สำคัญที่มีการย้อนกลับ และเดลต้าสำหรับเครือข่ายที่แคบ ข้อดีคือคุณเลือกกลยุทธ์ที่เหมาะกับผลิตภัณฑ์ของคุณ และการดำเนินงานของคุณ

การทดสอบ การจำลอง และการจัดทำเอกสาร

Yocto ใส่ใจในคุณภาพ ซึ่งรวมถึงการทดสอบความสมเหตุสมผลและการถดถอย รองรับการบูตและการทดสอบใน QEMU และความสามารถในการผสานรวมชุดทดสอบ วิธีนี้จะทำให้รอบการตรวจสอบแคบลงและลดความประหลาดใจของฮาร์ดแวร์.

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

การกำกับดูแลและการเปิดตัว

ทิศทางทางเทคนิคตกอยู่กับสถาปนิกโครงการ (Richard Purdie) และลำดับชั้นของผู้ดูแลระบบต่อส่วนประกอบ ในแบบจำลองที่คล้ายกับเคอร์เนล Linuxในด้านการบริหาร มีคณะกรรมการที่ปรึกษาซึ่งประกอบด้วยตัวแทนจากสมาชิก (ผู้ผลิตซิลิกอน ผู้จำหน่ายเชิงพาณิชย์ใน Yocto ผู้ใช้องค์กร และที่ปรึกษา) เช่นเดียวกับกลุ่มทำงานด้านการเงิน โครงสร้างพื้นฐาน การส่งเสริมการขาย และชุมชน

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

เวอร์ชันและชื่อรหัส

ในอดีต Yocto ได้เผยแพร่รุ่นต่างๆ ที่ระบุด้วยหมายเลขและชื่อเล่น ด้านล่างนี้เป็นตัวอย่างของเวอร์ชันและวันที่ที่เป็นตัวแทน:

รุ่น	รหัสชื่อ	วันที่
3.3	ฮาร์ดน็อต	04/2021
3.2	เกตส์การ์ธ	11/2020
3.1	ดันเฟลล์	04/2020
3.0	Zeus	10/2019
2.7	เกร์เรโร	04/2019
2.6	เสียงตกดังโครมหรือเปรี้ยง	11/2018
2.5	ซูโม่	04/2018
2.4	ร็อคโค	10/2017
2.3	Pyro	04/2017
2.2	Morty	10/2016
2.1	โครกอธ	04/2016
2.0	เจ	10/2015
1.8	Fido	04/2015
1.7	วิงเวียน	10/2014
1.6	ดอกเดซี	04/2014
1.5	ดอร่า	10/2013
1.4	ดีแลน	04/2013
1.3	ดีแลน	10/2012
1.2	เดนซิล	04/2012
1.1	เอดิสัน	10/2011
1.0	เบอร์นาร์ด	2011
0.9	เวอร์น	2010

นอกเหนือจากรูปภาพทั่วไปแล้ว โปรเจ็กต์ยังรักษาการใช้งานอ้างอิงที่เรียกว่า Poky ซึ่งรวมระบบสร้าง OE และชุดสูตรที่ครอบคลุมซึ่งจัดเป็นเลเยอร์ มีประโยชน์เป็นเทมเพลตฟังก์ชันสำหรับระบบฝังตัว.

โปรแกรมแบรนด์: ผู้เข้าร่วมและความเข้ากันได้

โปรแกรมแบรนด์ Yocto ช่วยให้องค์กรและผลิตภัณฑ์เชื่อมโยงงานของตนกับโครงการด้วยตราสองดวง: “ผู้เข้าร่วมโครงการ Yocto” สำหรับหน่วยงานที่ใช้และสนับสนุน Yocto ต่อสาธารณะและ “Yocto Project Compatible” สำหรับผลิตภัณฑ์ที่เข้ากันได้กับ OE, BSP และเลเยอร์จากองค์กรสมาชิก

คำศัพท์ที่จำเป็น

• ไฟล์กำหนดค่า (conf): กำหนดตัวแปรทั่วโลก ตัวเลือกผู้ใช้ และการตั้งค่าฮาร์ดแวร์ ซึ่งจะเป็นตัวกำหนดว่าอะไรจะถูกคอมไพล์และอะไรอยู่ในอิมเมจสำหรับแพลตฟอร์มเฉพาะ
• สูตรอาหาร (.bb):อธิบายแหล่งที่มาของโค้ด แพตช์ การอ้างอิง และตัวเลือกการสร้างเพื่อสร้างแพ็คเกจ รวมไปถึงรูปภาพสุดท้ายด้วย
• เลเยอร์:คอลเลกชันสูตรอาหารและข้อมูลเมตาที่เกี่ยวข้อง ช่วยให้แยกการปรับแต่งได้และรองรับสถาปัตยกรรมหลาย ๆ แบบ
• เมตาดาต้า:ซึ่งรวมถึงสูตร การกำหนดค่า คลาส และข้อมูลที่ควบคุมสิ่งที่สร้างและวิธีการ รวมถึงเวอร์ชันและการอ้างอิงแพตช์
• บิตเบค:เครื่องมือดำเนินการที่วิเคราะห์สูตรและกำหนดลำดับของงาน คล้ายกับคำว่า “make” แต่เน้นไปที่แพ็คเกจและรูปภาพ.
• แพคเกจ: สิ่งประดิษฐ์ที่สร้างขึ้น (deb, rpm, ipk) ที่ใช้ในการติดตั้ง rootfs และอิมเมจระบบ
• อีเอสดีเค:SDK ที่ขยายได้สำหรับนักพัฒนาแอปพลิเคชันเพื่อรวมการเปลี่ยนแปลงและไลบรารีและทดสอบบนฮาร์ดแวร์เป้าหมาย
• ภาพ:รูปแบบไบนารีของระบบปฏิบัติการ Linux ที่จะแฟลชหรือปรับใช้บนอุปกรณ์เป้าหมาย

กรณีการใช้งาน IoT และการเลือกระบบ

ตลาดฝังตัวกำลังเติบโตอย่างต่อเนื่อง: มีอุปกรณ์ที่ปรับแต่งได้มากขึ้น มีบอร์ดและ SoC ให้เลือกหลากหลายมากขึ้น และด้วยเหตุนี้ ความต้องการระบบปฏิบัติการที่กำหนดเองเพิ่มมากขึ้นLinux ได้สร้างตัวเองให้เป็นมาตรฐานโดยพฤตินัย และ Yocto ถือเป็นตัวเลือกที่ยอดเยี่ยมในการสร้างมันขึ้นมา "ตามแบบของคุณ"

เมื่อเทียบกับการแจกจ่ายไบนารีเอนกประสงค์เช่น Debian/Ubuntu แล้ว Yocto ให้การควบคุมที่สมบูรณ์เหนือสิ่งที่ได้รับการติดตั้ง รวมถึงเวอร์ชันและแพตช์ พร้อมด้วยความสามารถในการทำซ้ำและการติดตาม สำหรับผลิตภัณฑ์ที่ต้องใช้พื้นที่จำกัด ความปลอดภัย และการบำรุงรักษาในระยะยาวเป็นการตัดสินใจที่เป็นรูปธรรม

บริษัทต่างๆ ผสมผสาน Yocto เข้ากับสถาปัตยกรรมการดำเนินการภาคสนามที่ทันสมัย ​​(OTA, พาร์ติชั่นที่ปลอดภัย, การย้อนกลับ) การบูรณาการ CI/CD pipeline การทดสอบอัตโนมัติ และการปรับใช้แบบค่อยเป็นค่อยไปยังมีโซลูชันที่ใช้ประโยชน์จาก Yocto เพื่อขยายความสามารถของขอบ (เช่น แพลตฟอร์มที่เน้นการวิเคราะห์ AI และการเชื่อมต่อคลาวด์ที่รองรับโดย Yocto)

ความปลอดภัยและแนวทางปฏิบัติที่ดี

ความปลอดภัยคือสิ่งสำคัญที่สุด โครงการนี้สอดคล้องกับแนวปฏิบัติที่ดีที่สุดของ CII และส่งเสริมการสร้างแบบทำซ้ำได้ (การทดสอบทำได้สำเร็จ ~99,8% บน core-image-minimal) การควบคุมการอ้างอิง สภาพแวดล้อม และเครื่องมือช่วยลดมลภาวะในการสร้าง.

ในระดับรันไทม์ คุณสามารถเปิดใช้งาน SELinux เพื่อการควบคุมการเข้าถึงแบบละเอียด IMA เพื่อการวัดความสมบูรณ์ของรันไทม์ และเชนการบูตที่ปลอดภัยที่ตรวจสอบบูตโหลดเดอร์ เคอร์เนล และ initramfs การเข้ารหัสระบบไฟล์และการจัดการคีย์ การปกป้องที่สมบูรณ์ในขณะพัก.

จากทฤษฎีสู่การปฏิบัติ: การสร้างภาพลักษณ์

วิธีที่พื้นฐานที่สุดคือโคลน Poky เริ่มต้นสภาพแวดล้อม เลือกเครื่อง (เช่น เป้าหมาย QEMU หรือ Raspberry Pi) เพิ่มเลเยอร์ BSP ที่จำเป็นและรัน BitBake กับรูปภาพอ้างอิงการสร้างครั้งแรกอาจต้องใช้เวลาสักพัก แต่หลังจากนั้นการสร้างขั้นต่อๆ ไปก็จะใช้เวลาอย่างรวดเร็ว

สำหรับฮาร์ดแวร์เช่น Raspberry Pi/reTerminalการไหลทั่วไปประกอบด้วยเลเยอร์โคลน เช่น meta-raspberrypi, meta-oe, meta-python หรือเลเยอร์จากผู้จำหน่ายอุปกรณ์ ปรับแต่งเคอร์เนล นำเข้าเลเยอร์และตัวแปร และสร้างภาพเฉพาะ (ตัวอย่างเช่น “rpi-test-image”)

Toaster ช่วยให้คุณทำสิ่งเดียวกันได้ผ่าน GUI: สร้างโครงการ เลือกรุ่น เครื่อง (raspberrypi4-64, raspberrypi5…) นำเข้าเลเยอร์ ปรับเปลี่ยนตัวแปร (เช่น แบ็กเอนด์กราฟิก) และเปิดการสร้างจากเบราว์เซอร์เมื่อเสร็จแล้ว ให้ดาวน์โหลดไฟล์ (เช่น .wic.bz2) และแฟลช

BitBake นำเสนอคำสั่งที่มีประโยชน์ในการแสดงรายการเลเยอร์และสูตรอาหาร สำรวจการอ้างอิง เปิด devshell สำหรับแพ็คเกจ ตรวจสอบงานหรือทำความสะอาดสภาพแวดล้อมเพื่อสร้างใหม่วิธีนี้จะช่วยเร่งการวินิจฉัยเมื่อมีสิ่งผิดปกติเกิดขึ้น

ขั้นตอนการทำงานโดยละเอียด (สรุปการดำเนินงาน)

1. กำหนดสถาปัตยกรรม นโยบาย แพตช์ และการกำหนดค่า
2. ดาวน์โหลดแบบอักษรจากแหล่งที่ประกาศไว้
3. แกะแพ็ก ติดตั้งแพตช์ และรัน configure/compile ตามความเหมาะสม.
4. การจัดฉากและบรรจุภัณฑ์
5. ดำเนินการ QA และตรวจสอบ
6. เผยแพร่ฟีดแพ็กเกจ
7. สร้างภาพสุดท้าย

โครงร่างนี้จะปรับให้เข้ากับคลาสและเลเยอร์ตามส่วนประกอบของคุณ คุณอาจต้องการแบ็กเอนด์กราฟิกเฉพาะ โมดูลเคอร์เนลของคุณเอง หรือ init อื่น ความงดงามของ Yocto ก็คือทั้งหมดนี้แสดงออกมาในรูปแบบข้อมูลเมตาแบบกำหนดเวอร์ชันได้.

เคล็ดลับการรับเลี้ยงทีม

สำหรับโปรไฟล์ที่มาจากสภาพแวดล้อม Windows การลงทุนในพื้นฐานของ Unix/Linux จะช่วยได้มาก ทำงานกับดิสโทร Linux บนเวิร์กสเตชันของคุณ ทำความเข้าใจ Bash และ Python และทำความคุ้นเคยกับครอสทูลเชน เร่งให้เกิดการโค้ง

หากคุณเป็นผู้ใช้ใหม่ต่อโครงการ ให้เริ่มต้นด้วย Poky และ QEMU เพื่อตรวจสอบเวิร์กโฟลว์แบบครบวงจร จากนั้นเพิ่มเลเยอร์ฮาร์ดแวร์ BSP จริงและเลเยอร์แอปพลิเคชันของคุณเองสร้างคอนเทนเนอร์ (CROPS) และ CI/CD โดยอัตโนมัติตั้งแต่เริ่มต้น

ความสามารถในการอัพเกรดภาคสนามและการดำเนินงาน

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

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