การดำเนินการ
คำสั่งที่เรียกใช้ระหว่างบิลด์ เช่น การเรียกคอมไพเลอร์ที่ใช้อาร์ติแฟกต์เป็นอินพุตและสร้างอาร์ติแฟกต์อื่นๆ เป็นเอาต์พุต รวมข้อมูลเมตา เช่น อาร์กิวเมนต์บรรทัดคำสั่ง คีย์การดำเนินการ ตัวแปรสภาพแวดล้อม และอาร์ติแฟกต์อินพุต/เอาต์พุตที่ประกาศแล้ว
ดูเพิ่มเติมที่ เอกสารประกอบเกี่ยวกับกฎ
แคชการดำเนินการ
แคชบนดิสก์ที่จัดเก็บการแมปของการดำเนินการที่ดำเนินการแล้วกับเอาต์พุตที่สร้างขึ้น คีย์แคชนี้เรียกว่าคีย์การดำเนินการ คอมโพเนนต์หลักสำหรับโมเดลส่วนเพิ่มของ Bazel ซึ่งแคชจะเก็บไว้ในไดเรกทอรีฐานเอาต์พุตจึงทำให้เซิร์ฟเวอร์ Bazel รีสตาร์ทได้
กราฟการทำงาน
กราฟในหน่วยความจำของการดำเนินการและอาร์ติแฟกต์ที่การดำเนินการเหล่านี้อ่านและสร้าง กราฟอาจรวมอาร์ติแฟกต์ที่มีอยู่เป็นไฟล์ต้นฉบับ (เช่น ในระบบไฟล์) รวมถึงอาร์ติแฟกต์ขั้นกลาง/สุดท้ายที่สร้างขึ้นและไม่ได้กล่าวถึงในไฟล์ BUILD สร้างขึ้นในระหว่างระยะการวิเคราะห์และใช้ในระหว่างระยะการดำเนินการ
การค้นหากราฟการดำเนินการ (aquery)
เครื่องมือQuery ที่ใช้ค้นหาแทนบิลด์ actions ได้ ซึ่งจะช่วยให้คุณวิเคราะห์ได้ว่าการสร้างกฎจะแปลงออกมาในลักษณะงานที่สร้างจริงได้อย่างไร
ปุ่มดำเนินการ
คีย์แคชของการดำเนินการ คำนวณตามข้อมูลเมตาของการดำเนินการ ซึ่งอาจรวมถึงคำสั่งที่จะดำเนินการในการดำเนินการ แฟล็กคอมไพเลอร์ ตำแหน่งไลบรารี หรือส่วนหัวระบบ ทั้งนี้ขึ้นอยู่กับการดำเนินการ ช่วยให้ Bazel แคชหรือทำให้การดำเนินการแต่ละรายการไม่ถูกต้องตามการตัดสินใจ
ช่วงการวิเคราะห์
เฟสที่ 2 ของบิลด์ ประมวลผลกราฟเป้าหมายที่ระบุใน BUILD ไฟล์เพื่อสร้างกราฟการดำเนินการในหน่วยความจำซึ่งกำหนดลำดับการดำเนินการที่จะเรียกใช้ในระหว่างระยะการดำเนินการ นี่คือระยะที่มีการประเมินการใช้งานกฎ
อาร์ติแฟกต์
ไฟล์ต้นฉบับหรือไฟล์ที่สร้างขึ้น ซึ่งอาจเป็นไดเรกทอรีของไฟล์ หรือที่เรียกว่าอาร์ติแฟกต์ของต้นไม้ได้ด้วย
อาร์ติแฟกต์อาจเป็นอินพุตของการดำเนินการหลายรายการ แต่ต้องสร้างขึ้นจากการดำเนินการไม่เกิน 1 รายการเท่านั้น
อาร์ติแฟกต์ที่สอดคล้องกับเป้าหมายไฟล์จะแก้ไขได้ด้วยป้ายกำกับ
อัตราส่วน
กลไกสำหรับกฎเพื่อสร้างการดำเนินการเพิ่มเติมในทรัพยากร Dependency ตัวอย่างเช่น หากเป้าหมาย A ขึ้นอยู่กับ B เป้าหมาย หนึ่งสามารถใช้ลักษณะใน A ที่ข้ามผ่าน up Dependency ไปยัง B และเรียกใช้การดำเนินการเพิ่มเติมใน B เพื่อสร้างและรวบรวมไฟล์เอาต์พุตเพิ่มเติม การดำเนินการเพิ่มเติมเหล่านี้จะถูกแคชและนำมาใช้ใหม่ระหว่างเป้าหมายที่ต้องใช้ด้านเดียวกัน สร้างด้วยฟังก์ชัน aspect() Starlark Build API เช่น ใช้สำหรับสร้างข้อมูลเมตาสำหรับ IDE และสร้างการดำเนินการสำหรับการวิเคราะห์ซอร์สโค้ด
โปรดดูข้อมูลเพิ่มเติมที่ เอกสารประกอบของ Aspects
อัตราส่วนภาพ
กลไกการเรียบเรียงที่สามารถนำไปใช้กับผลลัพธ์ของแง่มุมอื่นๆ ได้ ตัวอย่างเช่น ลักษณะที่สร้างข้อมูลเพื่อให้ IDE นำไปใช้ควบคู่ไปกับส่วนที่สร้างไฟล์ .java จาก Pro ได้
หากต้องการใช้ลักษณะ A ร่วมกับด้าน B ผู้ให้บริการที่ B โฆษณาในแอตทริบิวต์ provides ของตนต้องตรงกับสิ่งที่ A ประกาศต้องการในแอตทริบิวต์ required_aspect_providers
แอตทริบิวต์
พารามิเตอร์กับกฎ ซึ่งใช้แสดงข้อมูลบิลด์ต่อเป้าหมาย
ตัวอย่างเช่น srcs, deps และ copts ซึ่งจะประกาศไฟล์แหล่งที่มา ทรัพยากร Dependency และตัวเลือกคอมไพเลอร์ที่กำหนดเองตามลำดับ แอตทริบิวต์เฉพาะที่ใช้ได้กับเป้าหมายที่ระบุจะขึ้นอยู่กับประเภทกฎ
.bazelrc
ไฟล์การกำหนดค่าของ Bazel ใช้ในการเปลี่ยนค่าเริ่มต้นสำหรับแฟล็กเริ่มต้นและแฟล็กคำสั่ง รวมทั้งเพื่อกำหนดกลุ่มตัวเลือกทั่วไปที่จะตั้งค่าร่วมกันในบรรทัดคำสั่ง Bazel ได้โดยใช้แฟล็ก --config Bazel รวมการตั้งค่าจากไฟล์ bazelrc หลายไฟล์ได้
(ทั้งระบบ ต่อพื้นที่ทำงาน ต่อผู้ใช้ หรือจากตำแหน่งที่กำหนดเอง) และไฟล์ bazelrc อาจนำเข้าการตั้งค่าจากไฟล์ bazelrc อื่นๆ ได้ด้วย
Blaze
Bazel เวอร์ชันภายในของ Google ระบบบิลด์หลักของ Google สำหรับที่เก็บแบบโมโน
ไฟล์สร้าง
ไฟล์ BUILD คือไฟล์การกำหนดค่าหลักที่จะบอก Bazel ว่าควรสร้างเอาต์พุตซอฟต์แวร์ใด ทรัพยากร Dependency คืออะไร และจะสร้างเอาต์พุตอย่างไร Bazel นำไฟล์ BUILD เป็นอินพุตและใช้ไฟล์ดังกล่าวในการสร้างกราฟทรัพยากร Dependency และรับการทำงานที่ต้องทำให้เสร็จเพื่อสร้างเอาต์พุตของซอฟต์แวร์ระดับกลางและขั้นสุดท้าย ไฟล์ BUILD จะทำเครื่องหมายไดเรกทอรีและไดเรกทอรีย่อยทั้งหมดที่ไม่มีไฟล์ BUILD เป็นแพ็กเกจ และอาจมีเป้าหมายที่สร้างโดยกฎ ไฟล์นี้อาจมีชื่อว่า BUILD.bazel
ไฟล์ BUILD.bazel
โปรดดูไฟล์ BUILD มีลำดับความสำคัญเหนือไฟล์ BUILD ในไดเรกทอรีเดียวกัน
ไฟล์ .bzl
ไฟล์ที่กำหนดกฎ มาโคร และค่าคงที่ที่เขียนใน Starlark ซึ่งจะนำเข้าไปยังไฟล์ BUILD ได้โดยใช้ฟังก์ชัน load()
สร้างกราฟ
กราฟทรัพยากร Dependency ที่ Bazel สร้างขึ้นและข้ามผ่านเพื่อสร้าง รวมโหนด เช่น เป้าหมาย เป้าหมายที่กำหนดค่า การดำเนินการ และอาร์ติแฟกต์ เวอร์ชันจะถือว่าเสร็จสมบูรณ์เมื่ออาร์ติแฟกต์ทั้งหมดที่ชุดเป้าหมายที่ขอมีการยืนยันว่าเป็นปัจจุบันแล้ว
การตั้งค่าบิลด์
การกำหนดค่าที่ Starlark กำหนด การเปลี่ยนกำหนดการตั้งค่าบิลด์เพื่อเปลี่ยนการกำหนดค่าของกราฟย่อยได้ หากแสดงต่อผู้ใช้เป็นแฟล็กบรรทัดคำสั่งหรือที่เรียกว่าแฟล็กบิลด์
ล้างบิลด์
บิลด์ที่ไม่ได้ใช้ผลลัพธ์ของบิลด์ก่อนหน้านี้ โดยปกติมักจะช้ากว่าบิลด์ที่เพิ่มขึ้น แต่โดยทั่วไปแล้วถือว่าถูกต้องกว่า Bazel รับประกันว่าทั้งบิลด์สะอาดและที่เพิ่มขึ้นจะมีความถูกต้องเสมอ
รุ่นไคลเอ็นต์-เซิร์ฟเวอร์
ไคลเอ็นต์บรรทัดคำสั่ง bazel จะเริ่มเซิร์ฟเวอร์เบื้องหลังบนเครื่องภายในโดยอัตโนมัติเพื่อเรียกใช้คำสั่งของ Bazel เซิร์ฟเวอร์จะยังคงอยู่ในทุกคำสั่ง แต่จะหยุดโดยอัตโนมัติหลังจากไม่มีการใช้งานเป็นระยะเวลาหนึ่ง (หรืออย่างชัดเจนผ่านการปิดระบบโดยอัตโนมัติ) การแยก Bazel ออกเป็นเซิร์ฟเวอร์และไคลเอ็นต์ช่วยลดเวลาเริ่มต้นของ JVM และรองรับบิลด์ที่เพิ่มขึ้นที่เร็วขึ้นเนื่องจากกราฟการดำเนินการยังคงอยู่ในหน่วยความจำตามคำสั่งต่างๆ
คำสั่ง
ใช้ในบรรทัดคำสั่งเพื่อเรียกฟังก์ชัน Bazel ต่างๆ เช่น bazel
build, bazel test, bazel run และ bazel query
แฟล็กคำสั่ง
ชุดของแฟล็กสำหรับคำสั่งโดยเฉพาะ ระบุแฟล็กคำสั่งหลังคำสั่ง (bazel build <command flags>) โดยแฟล็กใช้ได้กับคำสั่งอย่างน้อย 1 รายการ ตัวอย่างเช่น --configure เป็นแฟล็กสำหรับคำสั่ง bazel sync โดยเฉพาะ แต่ --keep_going ใช้ได้กับ sync, build,test และอื่นๆ แฟล็กมักจะใช้เพื่อการกำหนดค่า ดังนั้นการเปลี่ยนแปลงค่า Flag อาจทำให้ Bazel ทำให้กราฟในหน่วยความจำใช้งานไม่ได้และเริ่มต้นช่วงการวิเคราะห์ใหม่
การกำหนดค่า
ข้อมูลที่อยู่นอกเหนือคำจำกัดความของกฎที่ส่งผลต่อวิธีสร้างการดำเนินการของกฎ ทุกบิลด์มีการกำหนดค่าอย่างน้อย 1 รายการที่ระบุแพลตฟอร์มเป้าหมาย ตัวแปรสภาพแวดล้อมการดำเนินการ และแฟล็กบรรทัดคำสั่ง การเปลี่ยนอาจสร้างการกำหนดค่าเพิ่มเติม เช่น สำหรับเครื่องมือโฮสต์หรือการคอมไพล์แบบข้ามระบบ
ดูเพิ่มเติมที่ การกำหนดค่า
การตัดการกำหนดค่า
กระบวนการในการรวมเฉพาะส่วนต่างๆ ของการกำหนดค่าที่เป้าหมายต้องการจริงๆ เช่น หากคุณสร้างไบนารีของ Java //:j ด้วยการอ้างอิง C++ //:c ก็จะเป็นการรวมค่า --javacopt ไว้ในการกำหนดค่าของ //:c ด้วย เนื่องจากการเปลี่ยน --javacopt จะทำให้ C++ เกิดการแคชโดยไม่จำเป็น
คำค้นหาที่กำหนดค่าไว้ (cquery)
เครื่องมือค้นหาที่ค้นหาในเป้าหมายที่กำหนดค่า (หลังจากขั้นตอนการวิเคราะห์เสร็จสมบูรณ์แล้ว) ซึ่งหมายความว่า select() และ สร้างแฟล็ก (เช่น --platforms) จะแสดงอย่างถูกต้องในผลลัพธ์
โปรดดู เอกสารประกอบเกี่ยวกับคำค้นหา
เป้าหมายที่กำหนดค่าแล้ว
ผลลัพธ์ของการประเมินเป้าหมายด้วยการกำหนดค่า ขั้นตอนการวิเคราะห์จะสร้างปัญหานี้โดยรวมตัวเลือกของบิลด์กับเป้าหมายที่ต้องสร้าง
ตัวอย่างเช่น หาก //:foo สร้างให้กับสถาปัตยกรรม 2 รายการที่แตกต่างกันภายในบิลด์เดียวกัน ก็จะมีเป้าหมายที่กำหนดค่าไว้ 2 รายการ ได้แก่ <//:foo, x86> และ <//:foo, arm>
ความถูกต้อง
บิลด์จะถูกต้องเมื่อเอาต์พุตของบิลด์แสดงถึงสถานะของอินพุตแบบสัญจร เพื่อให้ได้งานสร้างที่ถูกต้อง Bazel มุ่งมั่นที่จะเป็นตัวเอง ทำซ้ำได้ และทำให้การวิเคราะห์การสร้างและการดำเนินการเป็นสิ่งกำหนด
การขึ้นต่อกัน
เส้นเชื่อมระหว่างเป้าหมาย 2 รายการ //:foo เป้าหมายมีทรัพยากร Dependency เป้าหมายใน //:bar เป้าหมาย หากค่าแอตทริบิวต์ของ //:foo มีการอ้างอิงไปยัง //:bar //:foo มีทรัพยากร Dependency ใน //:bar หากการดำเนินการใน //:foo ขึ้นอยู่กับอาร์ติแฟกต์อินพุตที่สร้างโดยการดำเนินการใน //:bar
Depset
โครงสร้างข้อมูลสำหรับการรวบรวมข้อมูลบนทรัพยากร Dependency แบบทรานซิทีฟ มีการเพิ่มประสิทธิภาพเพื่อให้การรวม Depset มีประสิทธิภาพด้านเวลาและพื้นที่ เนื่องจากเป็นเรื่องปกติที่จะมี Depset ขนาดใหญ่มาก (หลายแสนไฟล์) มีการนำมาใช้เพื่ออ้างถึงด้านอื่นๆ ซ้ำๆ สำหรับเหตุผลของการประหยัดพื้นที่ การใช้งานกฎไม่ควรทำให้การตั้งค่าเป็น "ราบเรียบ" โดยแปลงเป็นรายการ เว้นแต่กฎจะอยู่ที่ระดับบนสุดของกราฟบิลด์ การลดการตั้งค่าขนาดใหญ่จะทำให้ใช้หน่วยความจำอย่างมาก หรือที่เรียกว่าชุดที่ซ้อนกันในการใช้งานภายในของ Bazel
โปรดดู เอกสารประกอบของ Depset
ดิสก์แคช
Blob บนดิสก์ในเครื่องสำหรับฟีเจอร์การแคชจากระยะไกล สามารถใช้ร่วมกันกับ BLOB Store ระยะไกลจริงๆ ได้
การกระจาย
ไดเรกทอรีแบบอ่านอย่างเดียวที่มีไฟล์ที่ Bazel จะดึงข้อมูลจากอินเทอร์เน็ตโดยใช้กฎที่เก็บ ช่วยให้บิลด์ทำงานแบบออฟไลน์ได้อย่างสมบูรณ์
การดำเนินการแบบไดนามิก
กลยุทธ์การดำเนินการที่เลือกระหว่างการดำเนินการภายในและระยะไกลตามการเรียนรู้ที่หลากหลาย และใช้ผลการดำเนินการของวิธีที่ประสบความสำเร็จเร็วกว่า การดำเนินการบางอย่างจะทำงานในเครื่องได้เร็วขึ้น (เช่น การลิงก์) และการทำงานอื่นๆ จะทำงานจากระยะไกลได้เร็วขึ้น (เช่น การคอมไพล์ที่ทำงานพร้อมกันได้อย่างมาก) กลยุทธ์การดำเนินการแบบไดนามิกสามารถให้ เวลาในการสร้างที่ดีขึ้นและเพิ่มขึ้นที่ดีที่สุดเท่าที่จะเป็นไปได้
ระยะการดำเนินการ
เฟสที่ 3 ของบิลด์ เรียกใช้การดำเนินการในกราฟการดำเนินการที่สร้างขึ้นในระหว่างระยะการวิเคราะห์ การดำเนินการเหล่านี้จะเรียกใช้ไฟล์ปฏิบัติการ (คอมไพเลอร์ สคริปต์) เพื่ออ่านและเขียนอาร์ติแฟกต์ กลยุทธ์การเกิดใหม่จะควบคุมวิธีการเรียกใช้การดำเนินการเหล่านี้ เช่น ในเครื่อง จากระยะไกล แบบไดนามิก แซนด์บ็อกซ์ Docker และอื่นๆ
รูทการดำเนินการ
ไดเรกทอรีในไดเรกทอรีฐานเอาต์พุตของ workspace ที่มีการดำเนินการการดำเนินการในเครื่องในบิลด์ที่ไม่ใช่แซนด์บ็อกซ์ เนื้อหาไดเรกทอรีส่วนใหญ่จะเป็นลิงก์สัญลักษณ์ของอาร์ติแฟกต์อินพุตจากพื้นที่ทำงาน รูทการดำเนินการยังมีลิงก์สัญลักษณ์ไปยังที่เก็บภายนอกในฐานะอินพุตอื่นๆ และไดเรกทอรี bazel-out สำหรับจัดเก็บเอาต์พุตด้วย จัดทำขึ้นระหว่างระยะการโหลดโดยการสร้างฟอเรสต์ลิงก์สัญลักษณ์ของไดเรกทอรีซึ่งแสดงถึงการปิดแบบสับเปลี่ยนของแพ็กเกจซึ่งบิลด์จะขึ้นอยู่กับ เข้าถึงได้ด้วย bazel info
execution_root ในบรรทัดคำสั่ง
ไฟล์
การสับเปลี่ยน
บิลด์จะเป็นตัวยึดประสิทธิภาพหากไม่มีอิทธิพลภายนอกต่อการดำเนินการและการทดสอบ ซึ่งช่วยให้ได้ผลลัพธ์ที่ต้องการและถูกต้อง ตัวอย่างเช่น โดยปกติแล้วบิลด์ที่ห่อหุ้มจะไม่อนุญาตให้การเข้าถึงเครือข่ายดำเนินการ จำกัดการเข้าถึงอินพุตที่ประกาศ ใช้การประทับเวลาและเขตเวลาแบบคงที่ จำกัดการเข้าถึงตัวแปรสภาพแวดล้อม และใช้ Seed แบบคงที่สำหรับการสร้างตัวเลขสุ่ม
บิลด์ส่วนเพิ่ม
บิลด์ที่เพิ่มขึ้นจะใช้ผลลัพธ์ของบิลด์ก่อนหน้านี้ซ้ำเพื่อลดเวลาของบิลด์และการใช้ทรัพยากร การตรวจสอบการขึ้นต่อกันและการแคชมีจุดประสงค์เพื่อสร้างผลลัพธ์ที่ถูกต้องสำหรับบิลด์ประเภทนี้ ส่วนบิลด์ที่เพิ่มขึ้นนั้นตรงกันข้ามกับบิลด์ที่สะอาด
ค่ายเพลง
ตัวระบุสำหรับเป้าหมาย ป้ายกำกับที่สมบูรณ์ในตัวเอง เช่น //path/to/package:target ประกอบด้วย // เพื่อทำเครื่องหมายไดเรกทอรีรากของพื้นที่ทำงาน path/to/package เป็นไดเรกทอรีที่มีไฟล์ BUILD ที่ประกาศเป้าหมาย และ :target เป็นชื่อของเป้าหมายที่ประกาศในไฟล์ BUILD ที่กล่าวไว้ข้างต้น อาจมีคำนำหน้า @my_repository//<..> ด้วยเพื่อระบุว่าเป้าหมายถูกประกาศใน ]ที่เก็บภายนอก] ที่ชื่อ my_repository
ระยะการโหลด
ระยะแรกของบิลด์ที่ Bazel แยกวิเคราะห์ไฟล์ WORKSPACE, BUILD และ .bzl เพื่อสร้างแพ็กเกจ การประเมินมาโครและฟังก์ชันบางอย่าง เช่น glob() จะได้รับการประเมินในระยะนี้ แทรกสลับกับเฟสที่ 2 ของบิลด์หรือระยะการวิเคราะห์เพื่อสร้างกราฟเป้าหมาย
Macro
กลไกในการเขียนการประกาศเป้าหมายกฎหลายรายการร่วมกันภายใต้ฟังก์ชัน Starlark เดียว เปิดใช้การใช้รูปแบบการประกาศกฎทั่วไปซ้ำในไฟล์ BUILD ขยายไปยังการประกาศเป้าหมายของกฎพื้นฐานในระหว่างระยะการโหลด
ดูเพิ่มเติมที่ เอกสารเกี่ยวกับมาโคร
ช่วยจำ
สตริงสั้นๆ ที่มนุษย์อ่านได้ซึ่งผู้เขียนกฎเลือกให้เข้าใจได้อย่างรวดเร็วว่าการดำเนินการในกฎกำลังทำอะไร การจำนำมาใช้เป็นตัวระบุสำหรับการเลือกกลยุทธ์การจำเพาะได้ ตัวอย่างบางส่วนของบันทึกการดำเนินการ ได้แก่ Javac จากกฎ Java, CppCompile จากกฎ C++ และ AndroidManifestMerger จากกฎ Android
กฎเนทีฟ
กฎที่สร้างขึ้นใน Bazel และนำไปใช้ใน Java กฎดังกล่าวจะปรากฏใน .bzl ไฟล์เป็นฟังก์ชันในโมดูลเนทีฟ (เช่น native.cc_library หรือ native.java_library) กฎที่ผู้ใช้กำหนด (ไม่ใช่เนทีฟ) สร้างขึ้นโดยใช้ Starlark
ฐานเอาต์พุต
ไดเรกทอรีสำหรับ workspace โดยเฉพาะสำหรับจัดเก็บไฟล์เอาต์พุตของ Bazel ใช้สำหรับแยกเอาต์พุตจากแผนผังต้นทางของพื้นที่ทำงาน อยู่ในรูทของผู้ใช้เอาต์พุต
กลุ่มเอาต์พุต
กลุ่มของไฟล์ที่คาดว่าจะสร้างขึ้นเมื่อ Bazel สร้างเป้าหมายเสร็จแล้ว กฎจะนำเอาต์พุตปกติไปไว้ใน "กลุ่มเอาต์พุตเริ่มต้น" (เช่น ไฟล์ .jar ของ java_library, .a และ .so สำหรับ cc_library เป้าหมาย) กลุ่มเอาต์พุตเริ่มต้นคือกลุ่มเอาต์พุตที่ระบบสร้างอาร์ติแฟกต์เมื่อมีการขอเป้าหมายในบรรทัดคำสั่ง
กฎจะกำหนดกลุ่มเอาต์พุตที่มีชื่อเพิ่มขึ้นได้ ซึ่งสามารถระบุอย่างชัดแจ้งใน BUILD ไฟล์ (กฎ filegroup) หรือบรรทัดคำสั่ง (แฟล็ก --output_groups)
รูทของผู้ใช้เอาต์พุต
ไดเรกทอรีเฉพาะผู้ใช้สำหรับจัดเก็บเอาต์พุตของ Bazel ชื่อไดเรกทอรีจะมาจากชื่อผู้ใช้ของระบบ ป้องกันการชนกันของไฟล์เอาต์พุตหากมีผู้ใช้หลายคนกำลังสร้างโปรเจ็กต์เดียวกันในระบบพร้อมกัน มีไดเรกทอรีย่อยที่เกี่ยวข้องกับเอาต์พุตของบิลด์ของพื้นที่ทำงานแต่ละแห่ง หรือที่เรียกว่าฐานเอาต์พุต
Package
ชุดของเป้าหมายที่กำหนดโดยไฟล์ BUILD ชื่อของแพ็กเกจคือเส้นทางของไฟล์ BUILD ที่สัมพันธ์กับรูทของพื้นที่ทำงาน แพ็กเกจอาจมีแพ็กเกจย่อยหรือไดเรกทอรีย่อยที่มีไฟล์ BUILD ซึ่งกลายเป็นลำดับชั้นของแพ็กเกจ
กลุ่มแพ็กเกจ
เป้าหมายที่แสดงถึงชุดแพ็กเกจ มักใช้ในค่าแอตทริบิวต์ visibility
แพลตฟอร์ม
"ประเภทเครื่อง" ที่เกี่ยวข้องในบิลด์ ซึ่งรวมถึงเครื่อง Bazel ที่ทำงานบน (แพลตฟอร์ม "โฮสต์") เครื่องสร้างเครื่องมือที่ทำงานบนแพลตฟอร์ม "exec") และเป้าหมายเครื่องที่สร้างขึ้นสำหรับ ("แพลตฟอร์มเป้าหมาย")
ผู้ให้บริการ
สคีมาที่อธิบายหน่วยข้อมูลที่จะส่งต่อระหว่างเป้าหมายกฎตามความสัมพันธ์ของทรัพยากร Dependency โดยทั่วไปแล้วจะประกอบด้วยข้อมูล เช่น ตัวเลือกคอมไพเลอร์ ไฟล์ต้นทางหรือเอาต์พุตแบบทรานซิทีฟ และข้อมูลเมตาของบิลด์ มักใช้ร่วมกับ depsets เพื่อจัดเก็บข้อมูลทรานซิชันสะสมอย่างมีประสิทธิภาพ ตัวอย่างของผู้ให้บริการในตัวคือ DefaultInfo
ดูเพิ่มเติม: เอกสารของผู้ให้บริการ
การค้นหา (แนวคิด)
กระบวนการวิเคราะห์กราฟรุ่นเพื่อทำความเข้าใจพร็อพเพอร์ตี้เป้าหมายและโครงสร้างทรัพยากร Dependency Bazel รองรับตัวแปรการค้นหา 3 รูปแบบ ได้แก่ คำค้นหา cquery และคำค้นหา
คำค้นหา (คำสั่ง)
เครื่องมือค้นหาที่ดำเนินการกับกราฟเป้าหมายหลังการโหลดของบิลด์ ขั้นตอนนี้ค่อนข้างเร็วแต่วิเคราะห์ผลกระทบของ select(), สร้างแฟล็ก
อาร์ติแฟกต์ หรือสร้างการดำเนินการไม่ได้
โปรดดู วิธีการค้นหาข้อมูล ข้อมูลอ้างอิงการค้นหา
แคชที่เก็บ
แคชที่จัดการเนื้อหาซึ่งแชร์ได้ของไฟล์ที่ดาวน์โหลดโดย Bazel สำหรับบิลด์และแชร์ได้ในพื้นที่ทำงาน เปิดใช้บิลด์ออฟไลน์หลังจาก
การดาวน์โหลดเริ่มต้น โดยทั่วไปมักใช้เพื่อแคชไฟล์ที่ดาวน์โหลดผ่านกฎที่เก็บ เช่น http_archive และ API ของกฎที่เก็บ เช่น repository_ctx.download ระบบจะแคชไฟล์ก็ต่อเมื่อมีการระบุการตรวจสอบข้อผิดพลาด SHA-256 สำหรับการดาวน์โหลดเท่านั้น
ความสามารถในการทำซ้ำ
พร็อพเพอร์ตี้ของบิลด์หรือการทดสอบที่ชุดอินพุตไปยังบิลด์หรือการทดสอบจะสร้างเอาต์พุตชุดเดียวกันทุกครั้ง โดยไม่คำนึงถึงเวลา วิธีการ หรือสภาพแวดล้อม โปรดทราบว่าอาจไม่ได้หมายความว่าเอาต์พุตถูกต้องหรือเป็นเอาต์พุตที่ต้องการ
กฎ
สคีมาสำหรับกำหนดเป้าหมายของกฎในไฟล์ BUILD เช่น cc_library จากมุมมองของผู้เขียนไฟล์ BUILD กฎประกอบด้วยชุดแอตทริบิวต์และตรรกะกล่องดำ ตรรกะนี้จะบอกให้กฎกำหนดเป้าหมายวิธีสร้างอาร์ติแฟกต์เอาต์พุตและส่งข้อมูลไปยังเป้าหมายของกฎอื่นๆ จากมุมมองของผู้เขียน .bzl กฎคือวิธีหลักในการขยาย Bazel ให้รองรับภาษาโปรแกรมและสภาพแวดล้อมใหม่ๆ
ระบบจะสร้างอินสแตนซ์กฎเพื่อสร้างเป้าหมายของกฎในระยะการโหลด ในกฎระยะการวิเคราะห์ เป้าหมายจะสื่อสารข้อมูลไปยังทรัพยากร Dependency แบบดาวน์สตรีมในรูปแบบของผู้ให้บริการ และลงทะเบียนการดำเนินการที่อธิบายวิธีสร้างอาร์ติแฟกต์เอาต์พุต โดยการดำเนินการเหล่านี้จะเรียกใช้ในระยะการดำเนินการ
ดูเพิ่มเติมที่ เอกสารประกอบเกี่ยวกับกฎ
เป้าหมายกฎ
เป้าหมายที่เป็นอินสแตนซ์ของกฎ แตกต่างจากไฟล์เป้าหมาย และกลุ่มแพ็กเกจ อย่าสับสนกับกฎ
ไฟล์เรียกใช้
ทรัพยากร Dependency รันไทม์ของเป้าหมายที่เรียกใช้ได้ โดยทั่วไปแล้ว ไฟล์ที่เรียกใช้ได้คือเอาต์พุตที่เรียกใช้ได้ของกฎการทดสอบ และไฟล์เรียกใช้คือทรัพยากร Dependency ของข้อมูลรันไทม์ของการทดสอบ ก่อนการเรียกใช้ไฟล์ปฏิบัติการ (ระหว่างการทดสอบ Bazel) Bazel จะเตรียมแผนผังรันไฟล์ไปพร้อมกับไฟล์ปฏิบัติการทดสอบตามโครงสร้างไดเรกทอรีต้นทาง
ดูเพิ่มเติมที่ เอกสารประกอบเกี่ยวกับ Runfiles
แซนด์บ็อกซ์
เทคนิคในการแยกการดำเนินการที่ทำงานอยู่ภายในรูทการดำเนินการที่จำกัดและชั่วคราว ซึ่งช่วยให้แน่ใจว่าจะไม่อ่านอินพุตที่ไม่ได้ประกาศหรือเขียนเอาต์พุตที่ไม่ได้ประกาศ แซนด์บ็อกซ์ช่วยปรับปรุงการทำงานได้อย่างมาก แต่มักจะมีค่าใช้จ่ายด้านประสิทธิภาพและต้องอาศัยการสนับสนุนจากระบบปฏิบัติการ ค่าใช้จ่ายด้านประสิทธิภาพจะขึ้นอยู่กับแพลตฟอร์ม ระบบปฏิบัติการใน Linux ไม่มีนัยสำคัญ แต่ใน macOS อาจทำให้ไม่สามารถใช้แซนด์บ็อกซ์ได้
สกายเฟรม
Skyframe เป็นเฟรมเวิร์กการประเมินหลักแบบคู่ขนาน ฟังก์ชันการทำงาน และการประเมินที่เพิ่มขึ้นของ Bazel
การปั๊มวัสดุ
ฟีเจอร์สำหรับฝังข้อมูลเพิ่มเติมลงในอาร์ติแฟกต์ที่สร้างด้วย Bazel ตัวอย่างเช่น สามารถใช้สำหรับการควบคุมแหล่งที่มา เวลาของบิลด์ และข้อมูลเกี่ยวกับพื้นที่ทำงานหรือสภาพแวดล้อมอื่นๆ สำหรับบิลด์ที่เผยแพร่
เปิดใช้ผ่านแฟล็ก --workspace_status_command และกฎที่รองรับแอตทริบิวต์สแตมป์
สตาร์ลาร์ก
ภาษาของส่วนขยายสำหรับการเขียนกฎและมาโคร ชุดย่อยแบบจำกัดของ Python (ตามไวยากรณ์และไวยากรณ์) ซึ่งมีเป้าหมายเป็นการกำหนดค่าและเพื่อให้มีประสิทธิภาพดีขึ้น ใช้ส่วนขยายไฟล์ .bzl BUILD ไฟล์ใช้ Starlark เวอร์ชันที่มีการจำกัดมากกว่าเดิม (เช่น ไม่มีคำจำกัดความของฟังก์ชัน def) ซึ่งก่อนหน้านี้เรียกว่า Skylark
โปรดดู เอกสารประกอบภาษา Starlark
แฟล็กเริ่มต้น
ชุด Flag ที่ระบุระหว่าง bazel กับคำสั่ง เช่น บิลด์ --host_jvm_debug แบบ bazel แฟล็กเหล่านี้จะแก้ไขการกำหนดค่าของเซิร์ฟเวอร์ Bazel ดังนั้นการแก้ไขแฟล็กเริ่มต้นจะทำให้เซิร์ฟเวอร์รีสตาร์ท แฟล็กสตาร์ทอัพไม่ได้มีไว้เฉพาะสำหรับคำสั่งใดๆ
เป้าหมาย
ออบเจ็กต์ที่กำหนดไว้ในไฟล์ BUILD และระบุโดยป้ายกำกับ เป้าหมายแสดงถึงหน่วยที่สร้างได้ของพื้นที่ทำงานจากมุมมองของผู้ใช้ปลายทาง
เป้าหมายที่ประกาศโดยการสร้างอินสแตนซ์กฎจะเรียกว่าเป้าหมายกฎ พารามิเตอร์เหล่านี้อาจเรียกใช้ได้ (เช่น cc_binary) หรือทดสอบได้ (เช่น cc_test) โดยทั่วไปเป้าหมายกฎจะขึ้นอยู่กับเป้าหมายอื่นๆ ผ่านแอตทริบิวต์ (เช่น deps) ทรัพยากร Dependency เหล่านี้เป็นพื้นฐานของกราฟเป้าหมาย
นอกจากเป้าหมายกฎแล้ว ยังมีเป้าหมายไฟล์และเป้าหมายกลุ่มแพ็กเกจด้วย เป้าหมายไฟล์จะสอดคล้องกับอาร์ติแฟกต์ที่อ้างอิงภายในไฟล์ BUILD ทั้งนี้ในกรณีพิเศษ ไฟล์ BUILD ของแพ็กเกจจะถือว่าเป็นเป้าหมายไฟล์ต้นทางในแพ็กเกจนั้นเสมอ
ระบบจะค้นพบเป้าหมายในระหว่างระยะโหลด ในระหว่างระยะการวิเคราะห์ เป้าหมายจะเชื่อมโยงกับการกำหนดค่าบิลด์เพื่อสร้างเป้าหมายที่กำหนดค่า
กราฟเป้าหมาย
กราฟในหน่วยความจำของเป้าหมายและการขึ้นต่อกันของเป้าหมาย สร้างขึ้นในระหว่างระยะการโหลด และใช้เป็นอินพุตของระยะการวิเคราะห์
รูปแบบเป้าหมาย
วิธีระบุกลุ่มเป้าหมายในบรรทัดคำสั่ง รูปแบบที่ใช้บ่อยคือ :all (เป้าหมายของกฎทั้งหมด), :* (กฎทั้งหมด + เป้าหมายไฟล์), ... (แพ็กเกจปัจจุบันและแพ็กเกจย่อยทั้งหมดที่เกิดซ้ำ) ใช้ร่วมกันได้ เช่น //...:* หมายถึงกฎและเป้าหมายไฟล์ทั้งหมดในแพ็กเกจทั้งหมดที่เกิดซ้ำจากรูทของพื้นที่ทำงาน
การทดสอบ
กฎเป้าหมายที่สร้างอินสแตนซ์จากกฎทดสอบ ดังนั้นจึงมีไฟล์ปฏิบัติการทดสอบ โค้ดผลลัพธ์ที่มีค่าเป็น 0 หลังจากการรันไฟล์เสร็จสมบูรณ์หมายความว่าการทดสอบสำเร็จ สัญญาที่แน่ชัดระหว่าง Bazel กับการทดสอบ (เช่น ตัวแปรสภาพแวดล้อมการทดสอบ วิธีการเก็บผลการทดสอบ) ระบุไว้ในสารานุกรมการทดสอบ
ห่วงโซ่เครื่องมือ
ชุดเครื่องมือในการสร้างเอาต์พุตสำหรับภาษา โดยทั่วไป Toolchain จะประกอบด้วย คอมไพเลอร์ ตัวลิงก์ อินเทอร์พรีเตอร์ หรือ/และโปรแกรมวิเคราะห์โค้ด Toolchain อาจแตกต่างกันไปตามแพลตฟอร์มด้วย กล่าวคือ คอมโพเนนต์ของ Toolchain ของคอมไพเลอร์ Unix อาจแตกต่างกันไปสำหรับเวอร์ชันของ Windows แม้ว่า Toolchain จะมีไว้สำหรับภาษาเดียวกันก็ตาม การเลือก Toolchain ที่เหมาะสมสำหรับแพลตฟอร์มเรียกว่าความละเอียด Toolchain
เป้าหมายระดับบนสุด
เป้าหมายของบิลด์จะเป็นระดับบนสุดหากมีการขอในบรรทัดคำสั่ง Bazel ตัวอย่างเช่น หาก //:foo ขึ้นอยู่กับ //:bar และมีการเรียก bazel build //:foo สำหรับบิลด์นี้ //:foo จะเป็นระดับบนสุด และ //:bar ไม่ใช่ระดับบนสุด แม้ว่าจะต้องสร้างเป้าหมายทั้ง 2 รายการก็ตาม ความแตกต่างที่สำคัญระหว่างเป้าหมายระดับบนสุดและระดับที่ไม่ใช่ระดับบนสุดคือ คำสั่งแฟล็กที่ตั้งค่าไว้ในบรรทัดคำสั่ง Bazel (หรือผ่าน .bazelrc) จะตั้งค่าการกำหนดค่าสำหรับเป้าหมายระดับบนสุด แต่อาจแก้ไขโดยการเปลี่ยนสำหรับเป้าหมายที่ไม่ใช่ระดับบนสุด
ทรานซิชัน
การแมปสถานะ configuration จากค่าหนึ่งไปยังอีกค่าหนึ่ง เปิดใช้เป้าหมายในกราฟบิลด์เพื่อให้มีการกำหนดค่าที่ต่างกัน แม้ว่าจะสร้างอินสแตนซ์จากกฎเดียวกันก็ตาม การใช้งานโดยทั่วไปของการเปลี่ยนคือกับการเปลี่ยนแบบแยก โดยจะมีการแยกบางส่วนของกราฟเป้าหมายด้วยการกำหนดค่าที่แตกต่างกันสำหรับแยกแต่ละอัน ตัวอย่างเช่น หนึ่งสามารถสร้าง Android APK ที่มีไบนารีดั้งเดิมที่คอมไพล์สำหรับ ARM และ x86 โดยใช้การเปลี่ยนแบบแยกในบิลด์เดียว
ดูเพิ่มเติมที่ การเปลี่ยนที่ผู้ใช้กำหนด
อาร์ติแฟกต์ต้นไม้
อาร์ติแฟกต์ที่แสดงถึงคอลเล็กชันไฟล์ เนื่องจากไฟล์เหล่านี้ไม่ใช่อาร์ติแฟกต์เอง การดำเนินการที่ดำเนินการในไฟล์จึงต้องลงทะเบียนอาร์ติแฟกต์ต้นไม้เป็นอินพุตหรือเอาต์พุตแทน
ระดับการแชร์
กลไก 1 ใน 2 วิธีในการป้องกันทรัพยากร Dependency ที่ไม่ต้องการในระบบบิลด์ ได้แก่ การเปิดเผยเป้าหมายเพื่อควบคุมว่าเป้าหมายอื่นๆ จะพึ่งพาเป้าหมายได้หรือไม่ และการโหลดการเปิดเผยสำหรับควบคุมว่าไฟล์ BUILD หรือ .bzl จะสามารถโหลดไฟล์ .bzl ที่ระบุได้หรือไม่ หากไม่มีบริบท โดยปกติแล้ว
"ระดับการเข้าถึง" หมายถึงระดับการเข้าถึงเป้าหมาย
โปรดดูข้อมูลเพิ่มเติมที่ เอกสารประกอบระดับการเข้าถึง
Workspace
ไดเรกทอรีที่มีไฟล์ WORKSPACE และซอร์สโค้ดของซอฟต์แวร์ที่ต้องการสร้าง ป้ายกำกับที่ขึ้นต้นด้วย // จะสัมพันธ์กับไดเรกทอรีของ Workspace
ไฟล์ WORKSPACE
กำหนดไดเรกทอรีเป็นพื้นที่ทำงาน ไฟล์อาจว่างเปล่า แม้ว่าโดยปกติจะมีการประกาศที่เก็บภายนอกเพื่อดึงข้อมูลทรัพยากร Dependency เพิ่มเติมจากเครือข่ายหรือระบบไฟล์ในเครื่อง