การจัดการการพึ่งพา

เมื่อดูหน้าก่อนๆ จะเห็นธีมหนึ่งซ้ำไปซ้ำมา นั่นคือ การจัดการโค้ดของคุณเองนั้นค่อนข้างตรงไปตรงมา แต่การจัดการทรัพยากร Dependency ของโค้ดนั้นยากกว่ามาก ทรัพยากร Dependency มีหลายประเภท บางครั้งก็เป็นทรัพยากร Dependency ของงาน (เช่น "เผยแพร่เอกสารก่อนที่ฉันจะทำเครื่องหมายว่าการเผยแพร่เสร็จสมบูรณ์") และบางครั้งก็เป็นทรัพยากร Dependency ของอาร์ติแฟกต์ (เช่น "ฉันต้องมีไลบรารี Computer Vision เวอร์ชันล่าสุดเพื่อสร้างโค้ด") บางครั้งคุณก็มีทรัพยากร Dependency ภายในในโค้ดเบสส่วนอื่น และบางครั้งก็มีทรัพยากร Dependency ภายนอกในโค้ดหรือข้อมูลที่เป็นของทีมอื่น (ไม่ว่าจะเป็นในองค์กรของคุณหรือบุคคลที่สาม) แต่ไม่ว่าในกรณีใด แนวคิดที่ว่า "ฉันต้องมีสิ่งนั้นก่อนจึงจะมีสิ่งนี้ได้" เป็นแนวคิดที่เกิดขึ้นซ้ำๆ ในการออกแบบระบบบิลด์ และการจัดการทรัพยากร Dependency อาจเป็นงานพื้นฐานที่สุดของระบบบิลด์

การจัดการโมดูลและทรัพยากร Dependency

โปรเจ็กต์ที่ใช้ระบบบิลด์แบบอิงตามอาร์ติแฟกต์ เช่น Bazel จะแบ่งออกเป็นชุดโมดูล โดยโมดูลจะแสดงทรัพยากร Dependency ต่อกันผ่านไฟล์ BUILD การจัดระเบียบโมดูลและทรัพยากร Dependency เหล่านี้อย่างเหมาะสมอาจส่งผลอย่างมากต่อทั้งประสิทธิภาพของระบบบิลด์และปริมาณงานที่ต้องใช้ในการดูแลรักษา

การใช้โมดูลแบบละเอียดและกฎ 1:1:1

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

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

แม้ว่าความละเอียดที่แน่นอนจะแตกต่างกันไปตามภาษา (และมักจะแตกต่างกันไปในแต่ละภาษาด้วย) แต่ Google มักจะชอบโมดูลที่มีขนาดเล็กกว่ามากเมื่อเทียบกับโมดูลที่โดยทั่วไปแล้วอาจเขียนในระบบบิลด์แบบอิงตามงาน ไบนารีการใช้งานจริงทั่วไปที่ Google มักจะขึ้นอยู่กับเป้าหมายหลายหมื่นรายการ และแม้แต่ทีมขนาดกลางก็อาจเป็นเจ้าของเป้าหมายหลายร้อยรายการภายในโค้ดเบส สำหรับภาษาต่างๆ เช่น Java ที่มีแนวคิดเรื่องการแพ็กเกจในตัวที่ชัดเจน ไดเรกทอรีแต่ละรายการมักจะมีแพ็กเกจ เป้าหมาย และไฟล์ BUILD เพียงรายการเดียว (Pants ซึ่งเป็นระบบบิลด์อีกระบบหนึ่งที่อิงตาม Bazel เรียกสิ่งนี้ว่ากฎ 1:1:1) ภาษาที่มีกฎการแพ็กเกจที่อ่อนแอกว่ามักจะกำหนดเป้าหมายหลายรายการต่อไฟล์ BUILD

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

เครื่องมือบางอย่าง เช่น buildifier และ buildozer พร้อมใช้งานกับ Bazel ในไดเรกทอรีbuildtools

การลดการมองเห็นโมดูลให้เหลือน้อยที่สุด

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

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

การจัดการทรัพยากร Dependency

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

ทรัพยากร Dependency ภายใน

ในโปรเจ็กต์ขนาดใหญ่ที่แบ่งออกเป็นโมดูลแบบละเอียด ทรัพยากร Dependency ส่วนใหญ่มีแนวโน้มที่จะเป็นทรัพยากร Dependency ภายใน นั่นคือ ทรัพยากร Dependency ในเป้าหมายอื่นที่กำหนดและสร้างขึ้นในที่เก็บซอร์สเดียวกัน ทรัพยากร Dependency ภายในแตกต่างจากทรัพยากร Dependency ภายนอกตรงที่สร้างขึ้นจากซอร์ส ไม่ได้ดาวน์โหลดเป็นอาร์ติแฟกต์ที่สร้างไว้ล่วงหน้าขณะเรียกใช้บิลด์ ซึ่งหมายความว่าไม่มีแนวคิดเรื่อง "เวอร์ชัน" สำหรับทรัพยากร Dependency ภายใน เป้าหมายและทรัพยากร Dependency ภายในทั้งหมดจะสร้างขึ้นที่คอมมิต/การแก้ไขเดียวกันในที่เก็บเสมอ ปัญหาหนึ่งที่ควรจัดการอย่างระมัดระวังเกี่ยวกับทรัพยากร Dependency ภายในคือวิธีจัดการทรัพยากร Dependency แบบถ่ายทอด (รูปที่ 1) สมมติว่าเป้าหมาย A ขึ้นอยู่กับเป้าหมาย B ซึ่งขึ้นอยู่กับเป้าหมายไลบรารีทั่วไป C เป้าหมาย A ควรใช้คลาสที่กำหนดไว้ในเป้าหมาย C ได้หรือไม่

รูปที่ 1 ทรัพยากร Dependency แบบถ่ายทอด

เครื่องมือพื้นฐานไม่มีปัญหาในเรื่องนี้ ทั้ง B และ C จะลิงก์กับเป้าหมาย A เมื่อสร้างขึ้น ดังนั้น A จะรู้จักสัญลักษณ์ทั้งหมดที่กำหนดไว้ใน C Bazel อนุญาตให้ทำเช่นนี้มาหลายปี แต่เมื่อ Google เติบโตขึ้น เราก็เริ่มเห็นปัญหา สมมติว่ามีการปรับโครงสร้าง B ใหม่เพื่อให้ไม่ต้องขึ้นอยู่กับ C อีกต่อไป หากนำทรัพยากร Dependency ของ B ใน C ออกแล้ว A และเป้าหมายอื่นๆ ที่ใช้ C ผ่านทรัพยากร Dependency ใน B จะหยุดทำงาน ทรัพยากร Dependency ของเป้าหมายกลายเป็นส่วนหนึ่งของสัญญาแบบสาธารณะและไม่สามารถเปลี่ยนแปลงได้อย่างปลอดภัย ซึ่งหมายความว่าทรัพยากร Dependency สะสมเมื่อเวลาผ่านไป และบิลด์ที่ Google เริ่มช้าลง

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

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

ทรัพยากร Dependency ภายนอก

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

การจัดการทรัพยากร Dependency แบบอัตโนมัติเทียบกับการจัดการด้วยตนเอง

ระบบบิลด์สามารถอนุญาตให้จัดการเวอร์ชันของทรัพยากร Dependency ภายนอกด้วยตนเองหรือโดยอัตโนมัติ เมื่อจัดการด้วยตนเอง ไฟล์บิลด์ จะแสดงรายการเวอร์ชันที่ต้องการดาวน์โหลดจากที่เก็บอาร์ติแฟกต์อย่างชัดเจน โดยมักจะใช้ สตริงเวอร์ชันเชิงความหมาย เช่น 1.1.4 เมื่อจัดการโดยอัตโนมัติ ไฟล์ซอร์สจะระบุช่วงเวอร์ชันที่ยอมรับได้ และระบบบิลด์จะดาวน์โหลดเวอร์ชันล่าสุดเสมอ ตัวอย่างเช่น Gradle อนุญาตให้ประกาศเวอร์ชันทรัพยากร Dependency เป็น "1.+" เพื่อระบุว่าเวอร์ชันย่อยหรือเวอร์ชันแพตช์ของทรัพยากร Dependency ใดก็ได้ที่ยอมรับได้ ตราบใดที่เวอร์ชันหลักเป็น 1

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

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

กฎเวอร์ชันเดียว

โดยปกติแล้วไลบรารีเวอร์ชันต่างๆ จะแสดงด้วยอาร์ติแฟกต์ที่ต่างกัน ดังนั้นในทางทฤษฎีแล้วจึงไม่มีเหตุผลใดที่ทรัพยากร Dependency ภายนอกเวอร์ชันต่างๆ จะประกาศในระบบบิลด์ภายใต้ชื่อต่างๆ ไม่ได้ ด้วยวิธีนี้ เป้าหมายแต่ละรายการจะเลือกเวอร์ชันของทรัพยากร Dependency ที่ต้องการใช้ได้ แต่ในทางปฏิบัติแล้ววิธีนี้ทำให้เกิดปัญหามากมาย ดังนั้น Google จึงบังคับใช้กฎ เวอร์ชันเดียวที่เข้มงวดสำหรับ ทรัพยากร Dependency ทั้งหมดของบุคคลที่สามในโค้ดเบสของเรา

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

ทรัพยากร Dependency ภายนอกแบบถ่ายทอด

การจัดการทรัพยากร Dependency แบบถ่ายทอดของทรัพยากร Dependency ภายนอกอาจเป็นเรื่องยากเป็นพิเศษ ที่เก็บอาร์ติแฟกต์หลายแห่ง เช่น Maven Central อนุญาตให้อาร์ติแฟกต์ระบุทรัพยากร Dependency ในอาร์ติแฟกต์อื่นๆ เวอร์ชันที่เฉพาะเจาะจงในที่เก็บ เครื่องมือบิลด์ เช่น Maven หรือ Gradle มักจะดาวน์โหลดทรัพยากร Dependency แบบถ่ายทอดแต่ละรายการแบบเรียกซ้ำโดยค่าเริ่มต้น ซึ่งหมายความว่าการเพิ่มทรัพยากร Dependency เพียงรายการเดียวในโปรเจ็กต์อาจทำให้มีการดาวน์โหลดอาร์ติแฟกต์หลายสิบรายการโดยรวม

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

Bazel ไม่ได้ดาวน์โหลดทรัพยากร Dependency แบบถ่ายทอดโดยอัตโนมัติ ระบบเคยใช้ไฟล์ WORKSPACE ที่กำหนดให้แสดงรายการทรัพยากร Dependency แบบถ่ายทอดทั้งหมด ซึ่งทำให้เกิดความยุ่งยากมากมายในการจัดการทรัพยากร Dependency ภายนอก Bazel ได้เพิ่มการรองรับการจัดการทรัพยากร Dependency ภายนอกแบบถ่ายทอดโดยอัตโนมัติในรูปแบบของไฟล์ MODULE.bazel ดูรายละเอียดเพิ่มเติมได้ที่ภาพรวม ทรัพยากร Dependency ภายนอก

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

การแคชผลลัพธ์บิลด์โดยใช้ทรัพยากร Dependency ภายนอก

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

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

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

ความปลอดภัยและความน่าเชื่อถือของทรัพยากร Dependency ภายนอก

การขึ้นอยู่กับอาร์ติแฟกต์จากแหล่งที่มาของบุคคลที่สามมีความเสี่ยงโดยธรรมชาติ มีความเสี่ยงด้านความพร้อมใช้งานหากแหล่งที่มาของบุคคลที่สาม (เช่น ที่เก็บอาร์ติแฟกต์) หยุดทำงาน เนื่องจากบิลด์ทั้งหมดอาจหยุดชะงักหากดาวน์โหลดทรัพยากร Dependency ภายนอกไม่ได้ นอกจากนี้ยังมีความเสี่ยงด้านความปลอดภัยด้วย หากระบบของบุคคลที่สามถูกผู้โจมตีบุกรุก ผู้โจมตีอาจแทนที่อาร์ติแฟกต์ที่อ้างอิงด้วยอาร์ติแฟกต์ที่ออกแบบเอง ซึ่งอนุญาตให้ผู้โจมตีแทรกโค้ดที่กำหนดเองลงในบิลด์ของคุณได้ คุณสามารถลดปัญหาทั้งสองนี้ได้โดยการทำมิเรอร์อาร์ติแฟกต์ที่คุณขึ้นอยู่ด้วยไปยังเซิร์ฟเวอร์ที่คุณควบคุม และบล็อกไม่ให้ระบบบิลด์เข้าถึงที่เก็บอาร์ติแฟกต์ของบุคคลที่สาม เช่น Maven Central การแลกเปลี่ยนคือมิเรอร์เหล่านี้ต้องใช้ความพยายามและทรัพยากรในการดูแลรักษา ดังนั้นการเลือกว่าจะใช้หรือไม่จึงขึ้นอยู่กับขนาดของโปรเจ็กต์ นอกจากนี้ยังสามารถป้องกันปัญหาด้านความปลอดภัยได้อย่างสมบูรณ์โดยมีค่าใช้จ่ายเพียงเล็กน้อยโดยกำหนดให้ระบุแฮชของอาร์ติแฟกต์แต่ละรายการของบุคคลที่สามในที่เก็บซอร์ส ซึ่งจะทำให้บิลด์ล้มเหลวหากมีการแก้ไขอาร์ติแฟกต์ อีกทางเลือกหนึ่งที่หลีกเลี่ยงปัญหาได้อย่างสมบูรณ์คือการจัดหาทรัพยากร Dependency ของโปรเจ็กต์ เมื่อโปรเจ็กต์จัดหาทรัพยากร Dependency โปรเจ็กต์จะเช็กอินทรัพยากร Dependency เหล่านั้นลงในการควบคุมซอร์สพร้อมกับซอร์สโค้ดของโปรเจ็กต์ ไม่ว่าจะเป็นซอร์สหรือไบนารี ซึ่งหมายความว่าทรัพยากร Dependency ภายนอกทั้งหมดของโปรเจ็กต์จะถูกแปลงเป็นทรัพยากร Dependency ภายใน Google ใช้แนวทางนี้ภายใน โดยเช็กอินไลบรารีของบุคคลที่สามทุกรายการที่อ้างอิงทั่วทั้ง Google ลงในไดเรกทอรี third_party ที่รูทของซอร์สทรีของ Google อย่างไรก็ตาม วิธีนี้ใช้ได้ที่ Google เท่านั้น เนื่องจากระบบควบคุมซอร์สของ Google สร้างขึ้นเองเพื่อจัดการกับโมโนรีโปขนาดใหญ่มาก ดังนั้นการจัดหาทรัพยากร Dependency อาจไม่ใช่ตัวเลือกสำหรับทุกองค์กร