การดำเนินการ
คำสั่งที่จะเรียกใช้ระหว่างบิลด์ เช่น การเรียกใช้คอมไพเลอร์ซึ่งจะนำอาร์ติแฟกต์เป็นอินพุตและสร้างอาร์ติแฟกต์อื่นๆ เป็นเอาต์พุต รวมข้อมูลเมตา เช่น อาร์กิวเมนต์บรรทัดคำสั่ง คีย์การดำเนินการ ตัวแปรสภาพแวดล้อม และอาร์ติแฟกต์อินพุต/เอาต์พุตที่ประกาศ
โปรดดูเพิ่มเติมที่ เอกสารประกอบเกี่ยวกับกฎ
แคชการทำงาน
แคชบนดิสก์ที่จัดเก็บการแมปการดำเนินการที่ดำเนินการแล้วกับเอาต์พุตที่สร้างขึ้น คีย์แคชเรียกว่าคีย์การดำเนินการ คอมโพเนนต์หลักสำหรับโมเดลส่วนเพิ่มของ Bazel แคชจะจัดเก็บไว้ในไดเรกทอรีฐานของเอาต์พุต ดังนั้นจึงรอดจากการรีสตาร์ทเซิร์ฟเวอร์ Bazel
กราฟการดำเนินการ
กราฟในหน่วยความจำของการดำเนินการและอาร์ติแฟกต์ที่การดำเนินการเหล่านี้อ่านและสร้าง กราฟนี้อาจมีอาร์ติแฟกต์ที่มีอยู่เป็นไฟล์ต้นฉบับ (เช่น ในระบบไฟล์) รวมถึงอาร์ติแฟกต์ระหว่างกลาง/สุดท้ายที่สร้างขึ้นซึ่งไม่ได้ระบุไว้ในไฟล์ BUILD สร้างในระหว่างขั้นตอนการวิเคราะห์และใช้ในระหว่างระยะการดำเนินการ
การค้นหากราฟการดำเนินการ (Aquery)
เครื่องมือสืบค้นข้อมูลที่ค้นหาผ่านการดำเนินการของบิลด์ได้ ฟีเจอร์นี้ช่วยให้คุณวิเคราะห์ว่ากฎการสร้างกฎจะแปลเป็นงานสร้างจริงได้อย่างไร
แป้นการทำงาน
คีย์แคชของการดำเนินการ คำนวณตามข้อมูลเมตาของการดำเนินการ ซึ่งอาจรวมถึงคำสั่งที่จะดำเนินการกับการทำงาน, แฟล็กคอมไพเลอร์, ตำแหน่งไลบรารี หรือส่วนหัวของระบบ ทั้งนี้ขึ้นอยู่กับการดำเนินการ ทำให้ Bazel สามารถแคชหรือทำให้การทำงานแต่ละรายการไม่ถูกต้องตามที่กำหนดไว้
ขั้นการวิเคราะห์
เฟสที่ 2 ของบิลด์ ประมวลผลกราฟเป้าหมายที่ระบุในไฟล์ BUILD เพื่อสร้างกราฟการดำเนินการในหน่วยความจำ ซึ่งจะกำหนดลำดับของการดำเนินการที่จะเรียกใช้ระหว่างระยะการดำเนินการ นี่เป็นระยะที่มีการประเมิน
การใช้งานกฎ
อาร์ติแฟกต์
ไฟล์ต้นฉบับหรือไฟล์ที่สร้างขึ้น หรืออาจเป็นไดเรกทอรีของไฟล์ หรือที่เรียกว่าอาร์ติแฟกต์ต้นไม้ได้
อาร์ติแฟกต์อาจเป็นอินพุตสำหรับการดำเนินการหลายรายการ แต่ต้องสร้างจากการดำเนินการไม่เกิน 1 รายการเท่านั้น
อาร์ติแฟกต์ที่สอดคล้องกับเป้าหมายไฟล์จะแก้ไขได้โดยป้ายกำกับ
อัตราส่วน
กลไกสำหรับกฎในการสร้างการดำเนินการเพิ่มเติมในทรัพยากร Dependency เช่น หากเป้าหมาย A ขึ้นอยู่กับ B คุณก็อาจใช้ลักษณะ A ซึ่งข้ามผ่านขึ้นขอบทรัพยากร Dependency ไปยัง B และเรียกใช้การดําเนินการเพิ่มเติมใน B เพื่อสร้างและรวบรวมไฟล์เอาต์พุตเพิ่มเติม การดำเนินการเพิ่มเติมเหล่านี้จะมีการแคชและนำมาใช้ซ้ำระหว่างเป้าหมายที่ต้องการลักษณะเดียวกัน สร้างด้วยฟังก์ชัน aspect() Starlark Build API เช่น สามารถใช้สร้างข้อมูลเมตาสำหรับ IDE และสร้างการดำเนินการสำหรับ Linting
โปรดดูข้อมูลเพิ่มเติมที่ เอกสารประกอบเกี่ยวกับแง่มุม
มุมมองตามอัตราส่วน
กลไกการจัดองค์ประกอบที่สามารถใช้กับผลลัพธ์ของแง่มุมอื่นๆ ได้ เช่น สามารถใช้ด้านที่สร้างข้อมูลสำหรับใช้โดย IDE เพิ่มเติมจากลักษณะหนึ่งที่สร้างไฟล์ .java จากโปรโตคอลได้
หากต้องการให้ด้าน A มีผลกับแง่มุม B ผู้ให้บริการที่ B โฆษณาในแอตทริบิวต์ provides ต้องตรงกับสิ่งที่ A ประกาศต้องการในแอตทริบิวต์ required_aspect_providers
แอตทริบิวต์
พารามิเตอร์ของกฎ ซึ่งใช้เพื่อแสดงข้อมูลบิลด์ต่อเป้าหมาย
ตัวอย่างได้แก่ srcs, deps และ copts ซึ่งจะประกาศไฟล์ต้นทาง การอ้างอิง และตัวเลือกคอมไพเลอร์ที่กำหนดเองตามลำดับ แอตทริบิวต์เฉพาะที่ใช้ได้กับเป้าหมายหนึ่งๆ จะขึ้นอยู่กับประเภทของกฎ
.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() ได้
สร้างกราฟ
กราฟการอ้างอิงที่ 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 และอื่นๆ ได้ แฟล็กมักใช้เพื่อวัตถุประสงค์ในการกำหนดค่า การเปลี่ยนแปลงค่าแฟล็กจึงอาจทำให้ Bazel ทำงานในกราฟในหน่วยความจำไม่ได้และเริ่มขั้นตอนการวิเคราะห์ใหม่
การกำหนดค่า
ข้อมูลที่อยู่นอกคำจำกัดความของกฎซึ่งส่งผลต่อวิธีที่กฎสร้างการดำเนินการ ทุกบิลด์มีการกำหนดค่าอย่างน้อย 1 รายการที่ระบุแพลตฟอร์มเป้าหมาย ตัวแปรสภาพแวดล้อมการดำเนินการ และ build flags ในบรรทัดคำสั่ง การเปลี่ยนอาจมีการกำหนดค่าเพิ่มเติม เช่น สำหรับเครื่องมือโฮสต์หรือการคอมไพล์ข้าม
โปรดดู การกำหนดค่า
การตัดการกำหนดค่า
กระบวนการจะรวมเฉพาะส่วนของการกำหนดค่าที่เป้าหมายต้องการใช้จริงๆ เท่านั้น ตัวอย่างเช่น หากคุณสร้างไบนารีของ Java //:j โดยใช้การขึ้นต่อกันของ C++ //:c การใส่ค่า --javacopt ลงในการกำหนดค่า //:c ก็จะเป็นการเสียเปล่า เนื่องจากการเปลี่ยนแปลง --javacopt จะทำให้การสร้างแคชของการสร้าง C++ เสียหายโดยไม่จำเป็น
คำค้นหาที่กำหนดค่าไว้ (cquery)
เครื่องมือการสืบค้นข้อมูลที่สืบค้นข้อมูลบนเป้าหมายที่กําหนดค่าไว้ (หลังจากขั้นตอนการวิเคราะห์เสร็จสมบูรณ์แล้ว) ซึ่งหมายความว่า select() และ build Flag (เช่น --platforms) จะแสดงในผลลัพธ์อย่างถูกต้อง
โปรดดู เอกสารประกอบเกี่ยวกับการค้นหา
เป้าหมายที่กำหนดค่าแล้ว
ผลลัพธ์ของการประเมิน target ด้วยการกำหนดค่า ซึ่งขั้นตอนการวิเคราะห์จะทําให้เกิดกรณีนี้ขึ้นโดยการรวมตัวเลือกของบิลด์กับเป้าหมายที่ต้องการสร้าง
ตัวอย่างเช่น หาก //:foo สร้างสำหรับสถาปัตยกรรม 2 แบบที่แตกต่างกันในการสร้างเดียวกัน จะมีเป้าหมายที่กำหนดค่า 2 รายการ ได้แก่ <//:foo, x86> และ <//:foo, arm>
ความถูกต้อง
บิลด์จะถูกต้องเมื่อเอาต์พุตสะท้อนให้เห็นสถานะของอินพุตสกรรมกริยาได้อย่างตรงไปตรงมา ในการสร้างบิลด์ที่ถูกต้อง Bazel มุ่งมั่นที่จะสร้างบรรยากาศที่เป็นธรรมชาติ ทำซ้ำได้ และกำหนดการวิเคราะห์บิลด์และการดำเนินการเพื่อการดำเนินการ
การขึ้นต่อกัน
ขอบที่นำทางระหว่างเป้าหมาย 2 รายการ //:foo เป้าหมายมีการขึ้นต่อกันของเป้าหมายในเป้าหมาย //:bar หากค่าแอตทริบิวต์ของ //:foo มีการอ้างอิงไปยัง //:bar //:foo มีทรัพยากร Dependency ของการดำเนินการใน //:bar หากการดำเนินการใน //:foo ขึ้นอยู่กับอาร์ติแฟกต์อินพุตที่สร้างโดยการดำเนินการใน //:bar
ในบางบริบท อาจหมายถึงทรัพยากร Dependency ภายนอก โปรดดูโมดูล
ลดความเร็ว
โครงสร้างข้อมูลสำหรับรวบรวมข้อมูลเกี่ยวกับทรัพยากร Dependency แบบสกรรม เพิ่มประสิทธิภาพเพื่อให้การผสานการทำงานลดลงและเวลาและพื้นที่อย่างมีประสิทธิภาพ เพราะเป็นเรื่องปกติที่จะมีไฟล์ขนาดใหญ่มาก (ไฟล์หลายแสนไฟล์) ใช้เพื่ออ้างอิงถึงตัวปรับเวลาอื่นๆ ซ้ำๆ เพื่อเหตุผลด้านการประหยัดพื้นที่ การใช้งานกฎไม่ควรลด "คงที่" โดยแปลงเป็นรายการ เว้นแต่ว่ากฎจะอยู่ที่ระดับบนสุดของกราฟบิลด์ การแยกส่วนขนาดใหญ่ลงทำให้ ใช้หน่วยความจำมาก มีชื่อเรียกอีกอย่างว่าชุดที่ซ้อนกันในการใช้งานภายในของ Bazel
โปรดดู เอกสารประกอบเกี่ยวกับการลด
ดิสก์แคช
ร้าน BLOB ในดิสก์ในพื้นที่สำหรับฟีเจอร์การแคชจากระยะไกล ซึ่งสามารถใช้ร่วมกับ Blob Store ระยะไกลจริง
กระจาย
ไดเรกทอรีแบบอ่านอย่างเดียวที่มีไฟล์ที่ Bazel จะดึงข้อมูลจากอินเทอร์เน็ตโดยใช้กฎที่เก็บ เปิดใช้บิลด์เพื่อเรียกใช้แบบออฟไลน์โดยสมบูรณ์
การดำเนินการแบบไดนามิก
กลยุทธ์การดำเนินการที่เลือกระหว่างการดำเนินการภายในและระยะไกลตามการเรียนรู้ทางเลือกต่างๆ และใช้ผลลัพธ์การดำเนินการของวิธีที่ประสบความสำเร็จเร็วกว่า การดำเนินการบางอย่างจะดำเนินการเร็วขึ้นภายในเครื่อง (เช่น การลิงก์) และการทำงานอื่นๆ จะดำเนินการได้เร็วขึ้นจากระยะไกล (เช่น การคอมไพล์แบบพร้อมกันสูง) กลยุทธ์การดำเนินการแบบไดนามิกช่วยให้มีเวลาบิลด์เพิ่มขึ้นและสะอาดตาที่สุด
ระยะดำเนินการ
ขั้นที่ 3 ของการสร้าง เรียกใช้การดำเนินการในกราฟการดำเนินการที่สร้างขึ้นระหว่างระยะการวิเคราะห์ การดำเนินการเหล่านี้จะเรียกใช้ไฟล์ปฏิบัติการ (คอมไพเลอร์, สคริปต์) เพื่ออ่านและเขียนอาร์ติแฟกต์ กลยุทธ์การเกิดจะควบคุมวิธีการปฏิบัติการเหล่านี้ เช่น การทำงานในเครื่อง จากระยะไกล แบบไดนามิก แซนด์บ็อกซ์ Docker และอื่นๆ
รูทการดำเนินการ
ไดเรกทอรีในไดเรกทอรีฐานเอาต์พุตของพื้นที่ทำงานที่มีการดำเนินการการดำเนินการในเครื่องในบิลด์ที่ไม่ใช่แซนด์บ็อกซ์ เนื้อหาไดเรกทอรีส่วนใหญ่เป็นลิงก์สัญลักษณ์ของอาร์ติแฟกต์อินพุตจากพื้นที่ทำงาน รูทการดำเนินการยังมีลิงก์สัญลักษณ์ไปยังที่เก็บภายนอกเป็นอินพุตอื่นๆ และไดเรกทอรี bazel-out เพื่อจัดเก็บเอาต์พุต จัดเตรียมในระหว่างระยะการโหลดโดยสร้างฟอเรสต์ลิงก์สัญลักษณ์ของไดเรกทอรีที่แสดงถึงการปิดชั่วคราวของแพ็กเกจที่บิลด์ขึ้นอยู่กับ เข้าถึงได้ผ่าน bazel info
execution_root ในบรรทัดคำสั่ง
ไฟล์
ระยะห่างระหว่างกัน
บิลด์จะมีลักษณะที่แนบเนียนหากไม่มีอิทธิพลภายนอกต่อการดำเนินการสร้างและการทดสอบ ซึ่งช่วยให้มั่นใจได้ว่าผลลัพธ์จะเป็นแบบกำหนดเองและถูกต้อง ตัวอย่างเช่น โดยปกติบิลด์ Hermetic จะไม่อนุญาตให้เข้าถึงการดำเนินการของเครือข่าย จำกัดการเข้าถึงอินพุตที่ประกาศ ใช้การประทับเวลาและเขตเวลาคงที่ จำกัดการเข้าถึงตัวแปรสภาพแวดล้อม และใช้ Seed แบบคงที่สำหรับโปรแกรมสร้างตัวเลขสุ่ม
บิลด์ที่เพิ่มขึ้น
บิลด์ที่เพิ่มขึ้นจะใช้ผลลัพธ์ของบิลด์ก่อนหน้านี้ซ้ำเพื่อลดเวลาของบิลด์และการใช้ทรัพยากร การตรวจสอบการขึ้นต่อกันและการแคชมีเป้าหมายเพื่อสร้างผลลัพธ์ที่ถูกต้องสำหรับบิลด์ประเภทนี้ บิลด์ส่วนเพิ่มตรงข้ามกับบิลด์ที่ปลอดภัย
ป้ายกำกับ
ตัวระบุสำหรับเป้าหมาย โดยทั่วไปจะมีรูปแบบ @repo//path/to/package:target โดยที่ repo เป็นชื่อ (ชัดเจน) ของที่เก็บที่มีเป้าหมาย path/to/package คือเส้นทางไปยังไดเรกทอรีที่มีไฟล์ BUILD ที่ประกาศเป้าหมาย (ไดเรกทอรีนี้เรียกอีกอย่างว่า แพ็กเกจ) และ target คือชื่อของตัวเป้าหมาย ระบบอาจละเว้นบางส่วนของไวยากรณ์นี้ ทั้งนี้ขึ้นอยู่กับสถานการณ์
โปรดดู: ป้ายกำกับ
ระยะการโหลด
เฟสแรกของบิลด์ที่ Bazel เรียกใช้ไฟล์ BUILD เพื่อสร้างแพ็กเกจ มาโครและฟังก์ชันบางอย่าง เช่น
glob() จะได้รับการประเมินในระยะนี้ แทรกสลับกับเฟสที่ 2 ของบิลด์ ซึ่งเป็นระยะการวิเคราะห์เพื่อสร้างกราฟเป้าหมาย
Macro
กลไกในการเขียนการประกาศเป้าหมายกฎหลายรายการร่วมกันภายใต้ฟังก์ชัน Starlark เดียว เปิดใช้รูปแบบการประกาศกฎทั่วไปซ้ำในไฟล์ BUILD ขยายเป็นการประกาศเป้าหมายกฎที่เกี่ยวข้องในระหว่างระยะการโหลด
โปรดดู เอกสารประกอบเกี่ยวกับมาโคร
ช่วยจำ
สตริงสั้นๆ ที่มนุษย์อ่านได้ซึ่งผู้เขียนกฎเลือกมาเพื่อช่วยให้เข้าใจการดำเนินการในกฎได้อย่างรวดเร็ว ความจำสามารถใช้เป็นตัวระบุสำหรับการเลือกกลยุทธ์ที่สร้างขึ้น ตัวอย่างบางส่วนของการบันทึกการดำเนินการ ได้แก่ Javac จากกฎ Java, CppCompile จากกฎ C++ และ
AndroidManifestMerger จากกฎ Android
โมดูล
โปรเจ็กต์ Bazel ที่มีได้หลายเวอร์ชัน โดยแต่ละเวอร์ชันอาจขึ้นอยู่กับโมดูลอื่นๆ ซึ่งเทียบได้กับแนวคิดที่คุ้นเคยในระบบการจัดการการอ้างอิงอื่นๆ เช่น อาร์ติแฟกต์ ของ Maven, แพ็กเกจ NPM, โมดูล Go หรือ Crate ของสินค้า โมดูลต่างๆ เป็นหัวใจสำคัญของระบบการจัดการการพึ่งพาภายนอก ของ Bazel
ระบบจะสนับสนุนแต่ละโมดูลด้วยที่เก็บที่มีไฟล์ MODULE.bazel อยู่ที่รูท ไฟล์นี้มีข้อมูลเมตาเกี่ยวกับโมดูล (เช่น ชื่อและเวอร์ชัน) ทรัพยากร Dependency โดยตรง และข้อมูลอื่นๆ อีกมากมาย เช่น การลงทะเบียน Toolchain และอินพุตส่วนขยายโมดูล
ข้อมูลเมตาของโมดูลจะโฮสต์ในรีจิสทรีของ Bazel
โปรดดู: โมดูล Bazel
ส่วนขยายโมดูล
ตรรกะชิ้นหนึ่งที่เรียกใช้เพื่อสร้างที่เก็บได้โดยการอ่านอินพุตจากกราฟทรัพยากร Dependency ของโมดูลและเรียกใช้กฎที่เก็บได้ ส่วนขยายโมดูลมีความสามารถที่คล้ายกับกฎ ที่เก็บ ซึ่งสามารถเข้าถึงอินเทอร์เน็ต ดำเนินการ I/O ไฟล์ และอื่นๆ
ดูเพิ่มเติม: ส่วนขยายโมดูล
กฎเนทีฟ
กฎที่สร้างขึ้นใน 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 ที่สัมพันธ์กับรูท repo แพ็กเกจอาจมีแพ็กเกจย่อยหรือไดเรกทอรีย่อยที่มีไฟล์ BUILD ซึ่งสร้างลำดับชั้นของแพ็กเกจ
กลุ่มแพ็กเกจ
เป้าหมายที่แสดงถึงชุดแพ็กเกจ มักใช้ในค่าแอตทริบิวต์ visibility
แพลตฟอร์ม
"ประเภทเครื่อง" ที่เกี่ยวข้องในบิลด์ ซึ่งรวมถึงเครื่อง Bazel ที่ทำงานบน (แพลตฟอร์ม "โฮสต์") เครื่องที่สร้างเครื่องมือทำงานบน (แพลตฟอร์ม "exec") และเป้าหมายเครื่องนั้นสร้างขึ้นสำหรับ ("แพลตฟอร์มเป้าหมาย")
ผู้ให้บริการ
สคีมาที่อธิบายหน่วยข้อมูลที่จะส่งผ่านระหว่างเป้าหมายกฎพร้อมกับความสัมพันธ์ของทรัพยากร Dependency โดยปกติจะประกอบด้วยข้อมูล เช่น ตัวเลือกคอมไพเลอร์ ไฟล์ต้นทางหรือไฟล์เอาต์พุตแบบสกรรม และข้อมูลเมตาบิลด์ บ่อยครั้งที่ใช้ร่วมกับ depsets เพื่อจัดเก็บข้อมูลทางอ้อมสะสมอย่างมีประสิทธิภาพ ตัวอย่างผู้ให้บริการในตัวคือ DefaultInfo
โปรดดู เอกสารประกอบจากผู้ให้บริการ
ข้อความค้นหา (แนวคิด)
ขั้นตอนการวิเคราะห์กราฟบิลด์เพื่อทำความเข้าใจพร็อพเพอร์ตี้เป้าหมายและโครงสร้างการพึ่งพา Bazel รองรับการค้นหา 3 รูปแบบ ได้แก่ query, cquery และ aquery
คำค้นหา (คำสั่ง)
เครื่องมือคำค้นหาที่ทำงานในกราฟเป้าหมายหลังระยะการโหลดของบิลด์ วิธีนี้ค่อนข้างเร็ว แต่วิเคราะห์ผลกระทบของ select(), สร้างแฟล็ก, อาร์ติแฟกต์ หรือการดำเนินการไม่ได้
โปรดดู วิธีการค้นหาข้อมูล, ข้อมูลอ้างอิงการค้นหา
ที่เก็บ
แผนผังไดเรกทอรีที่มีไฟล์ตัวทำเครื่องหมายขอบเขตอยู่ที่ราก โดยมีไฟล์ต้นฉบับที่สามารถใช้ในบิวด์ Bazel บ่อยครั้งจะย่อไว้เพียงที่เก็บ
ไฟล์ตัวทำเครื่องหมายขอบเขตที่เก็บอาจเป็น MODULE.bazel (บ่งบอกว่าที่เก็บนี้แสดงถึงโมดูล Bazel) REPO.bazel หรือในบริบทเดิม WORKSPACEหรือ
WORKSPACE.bazel ไฟล์ตัวทำเครื่องหมายขอบเขตที่เก็บจะแสดงขอบเขตของที่เก็บ ซึ่งไฟล์เหล่านี้สามารถอยู่ร่วมกันในไดเรกทอรีได้
ที่เก็บหลักคือที่เก็บที่มีการเรียกใช้คำสั่ง Bazel ปัจจุบัน
ที่เก็บภายนอกจะกำหนดโดยการระบุโมดูลในไฟล์ MODULE.bazel หรือเรียกใช้กฎที่เก็บในส่วนขยายโมดูล อุปกรณ์จะสามารถดึงข้อมูลแบบออนดีมานด์ไปยังตำแหน่ง "เวทมนตร์" ที่กำหนดไว้ล่วงหน้าบนดิสก์
ที่เก็บแต่ละรายการจะมีชื่อ Canonical ที่ไม่ซ้ำกันและไม่ซ้ำกัน และอาจต่างกัน ชื่อ ที่ชัดเจนเมื่อดูจากแหล่งข้อมูลอื่น
โปรดดู: ภาพรวมของทรัพยากร Dependency ภายนอก
แคชที่เก็บ
แคชที่ใช้ร่วมกันซึ่งสามารถระบุเนื้อหาได้ของไฟล์ซึ่ง Bazel ดาวน์โหลดสำหรับบิลด์
ซึ่งแชร์ได้ทั่วทั้งพื้นที่ทำงาน เปิดใช้บิลด์แบบออฟไลน์หลังจากการดาวน์โหลดครั้งแรก มักใช้เพื่อแคชไฟล์ที่ดาวน์โหลดผ่านกฎที่เก็บ เช่น http_archive และ API ของกฎที่เก็บ เช่น repository_ctx.download ระบบจะแคชไฟล์เฉพาะในกรณีที่ระบุ checksum ของ SHA-256 สำหรับการดาวน์โหลด
กฎที่เก็บ
สคีมาสำหรับคำจำกัดความของที่เก็บซึ่งบอก Bazel เกี่ยวกับวิธีทำให้ที่เก็บเป็นรูปธรรม (หรือ "ดึงข้อมูล") มักจะย่อให้เหลือเพียงกฎที่เก็บ
Bazel จะเรียกใช้กฎที่เก็บเป็นการภายในเพื่อกำหนดที่เก็บที่โมดูลรองรับ หรืออาจเรียกใช้โดยส่วนขยายโมดูลก็ได้
กฎที่เก็บจะเข้าถึงอินเทอร์เน็ตหรือใช้ I/O ไฟล์ได้ กฎที่เก็บที่พบบ่อยที่สุดคือ http_archive เพื่อดาวน์โหลดที่เก็บถาวรที่มีไฟล์แหล่งที่มาจากอินเทอร์เน็ต
โปรดดู เอกสารประกอบของกฎที่เก็บ
ความสามารถในการทำซ้ำ
พร็อพเพอร์ตี้ของบิลด์หรือการทดสอบที่ชุดอินพุตไปยังบิลด์หรือการทดสอบจะสร้างชุดเอาต์พุตเดียวกันทุกครั้ง โดยไม่คำนึงถึงเวลา เมธอด หรือสภาพแวดล้อม โปรดทราบว่านี่ไม่ได้หมายความว่าเอาต์พุตนั้นถูกต้องหรือเป็นเอาต์พุตที่ต้องการ
กฎ
สคีมาสำหรับกำหนดเป้าหมายกฎในไฟล์ BUILD เช่น cc_library จากมุมมองของผู้เขียนไฟล์ BUILD กฎจะประกอบด้วยชุดแอตทริบิวต์และตรรกะกล่องดำ ตรรกะจะบอกเป้าหมายของกฎเกี่ยวกับวิธีสร้างอาร์ติแฟกต์เอาต์พุตและส่งข้อมูลไปยังเป้าหมายกฎอื่นๆ จากมุมมองของผู้เขียน .bzl กฎเป็นวิธีหลักในการเผยแพร่ Bazel ให้รองรับภาษาและสภาพแวดล้อมใหม่ๆ ในการเขียนโปรแกรม
ระบบจะสร้างอินสแตนซ์กฎเพื่อสร้างเป้าหมายกฎในระยะการโหลด ในกฎระยะการวิเคราะห์ จะกำหนดเป้าหมายไปที่ทรัพยากร Dependency ของปลายทางในรูปแบบของผู้ให้บริการ และลงทะเบียนการดำเนินการที่อธิบายวิธีสร้างอาร์ติแฟกต์เอาต์พุต การดำเนินการเหล่านี้จะทำงานในระยะการดำเนินการ
โปรดดูเพิ่มเติมที่ เอกสารประกอบเกี่ยวกับกฎ
เป้าหมายกฎ
เป้าหมายที่เป็นอินสแตนซ์ของกฎ แตกต่างจากเป้าหมายไฟล์ และกลุ่มแพ็กเกจ อย่าสับสนกับกฎ
Runfiles
ทรัพยากร Dependency ของรันไทม์ของ target ที่ดำเนินการได้ โดยปกติ ไฟล์ปฏิบัติการคือเอาต์พุตสั่งการของกฎทดสอบ และ Runfiles เป็นทรัพยากร Dependency ของข้อมูลรันไทม์ของการทดสอบ ก่อนเรียกใช้ไฟล์ปฏิบัติการ (ระหว่างการทดสอบแบบเบเซล) Bazel จะเตรียมโครงสร้างของ Runfile คู่กับไฟล์ปฏิบัติการทดสอบ ตามโครงสร้างไดเรกทอรีต้นทาง
โปรดดู เอกสารประกอบเกี่ยวกับ Runfiles
แซนด์บ็อกซ์
เทคนิคในการแยกการดำเนินการที่ทำงานอยู่ภายในรูทการดำเนินการที่ถูกจำกัดและชั่วคราว ซึ่งช่วยตรวจสอบว่าจะไม่มีการอ่านอินพุตที่ไม่ได้ประกาศหรือเขียนเอาต์พุตที่ไม่ได้ประกาศ แซนด์บ็อกซ์ช่วยปรับปรุงความแปรปรวนได้อย่างมาก แต่โดยทั่วไปจะมีค่าใช้จ่ายในการปฏิบัติงานและต้องใช้การสนับสนุนจากระบบปฏิบัติการ ส่วนต้นทุนด้านประสิทธิภาพจะขึ้นอยู่กับแพลตฟอร์ม ส่วนใน Linux นั้นไม่สำคัญ แต่ใน macOS อาจทำให้แซนด์บ็อกซ์ใช้งานไม่ได้
สกายเฟรม
Skyframe เป็นเฟรมเวิร์กการประเมินพร้อมกันหลัก ฟังก์ชันการทำงาน และส่วนเพิ่มของ Bazel
การปั๊มวัสดุ
ฟีเจอร์สำหรับฝังข้อมูลเพิ่มเติมลงในอาร์ติแฟกต์ที่ Bazel สร้างขึ้น ตัวอย่างเช่น ข้อมูลนี้อาจใช้สำหรับการควบคุมแหล่งที่มา เวลาในการสร้าง และพื้นที่ทำงานอื่นๆ หรือข้อมูลอื่นๆ ที่เกี่ยวข้องกับสภาพแวดล้อมสำหรับบิลด์ของรุ่น
เปิดใช้ผ่านแฟล็ก --workspace_status_command และกฎที่รองรับแอตทริบิวต์สแตมป์
สตาร์ลาร์ก
ภาษาส่วนขยายสำหรับการเขียนกฎและมาโคร ชุดย่อยของ Python แบบจำกัด (ตามหลักไวยากรณ์และไวยากรณ์) ที่มีจุดประสงค์เพื่อการกำหนดค่าและเพิ่มประสิทธิภาพ ใช้ส่วนขยายไฟล์ .bzl ไฟล์ BUILD รายการใช้ Starlark เวอร์ชันที่จำกัดมากขึ้น (เช่น ไม่มีคำจำกัดความฟังก์ชัน def) ซึ่งก่อนหน้านี้เรียกว่า Skylark
โปรดดู เอกสารประกอบภาษา Starlark
ธงเริ่มต้น
ชุดแฟล็กที่ระบุระหว่าง bazel กับคำสั่ง เช่น บิลด์ Bazel --host_jvm_debug แฟล็กเหล่านี้จะปรับเปลี่ยนการกำหนดค่าของเซิร์ฟเวอร์ Bazel ดังนั้นการแก้ไขแฟล็กเริ่มต้นจะทำให้มีการรีสตาร์ทเซิร์ฟเวอร์ แฟล็กเริ่มต้นไม่ได้ขึ้นอยู่กับ
คำสั่งใดๆ โดยเฉพาะ
เป้าหมาย
ออบเจ็กต์ที่กำหนดไว้ในไฟล์ BUILD และมีการระบุโดยป้ายกำกับ เป้าหมายเป็นหน่วยของพื้นที่ทำงานที่สร้างได้
จากมุมมองของผู้ใช้ปลายทาง
เป้าหมายที่ประกาศโดยการสร้างอินสแตนซ์กฎจะเรียกว่าเป้าหมายกฎ กฎเหล่านี้สามารถทำงานได้ (เช่น cc_binary) หรือทดสอบได้ (เช่น cc_test) โดยทั่วไป เป้าหมายของกฎจะขึ้นอยู่กับเป้าหมายอื่นๆ ผ่านแอตทริบิวต์ (เช่น deps) การขึ้นต่อกันเหล่านี้เป็นพื้นฐานของกราฟเป้าหมาย
นอกเหนือจากเป้าหมายกฎแล้ว ยังมีเป้าหมายไฟล์และเป้าหมายกลุ่มแพ็กเกจด้วย เป้าหมายของไฟล์สอดคล้องกับอาร์ติแฟกต์ที่อ้างอิงภายในไฟล์ BUILD ในกรณีพิเศษ ระบบจะถือว่าไฟล์ BUILD ของแพ็กเกจใดก็ตามเป็นเป้าหมายของไฟล์ต้นทางในแพ็กเกจนั้นเสมอ
ระบบจะค้นพบเป้าหมายในระหว่างระยะการโหลด ในระหว่างระยะการวิเคราะห์ เป้าหมายจะเชื่อมโยงกับการกำหนดค่าบิลด์เพื่อสร้างเป้าหมายที่กําหนดค่าไว้
กราฟเป้าหมาย
กราฟในหน่วยความจำของเป้าหมายและการพึ่งพากัน ซึ่งสร้างในระหว่างระยะการโหลดและใช้เป็นอินพุตสำหรับระยะการวิเคราะห์
รูปแบบเป้าหมาย
วิธีระบุกลุ่มของเป้าหมายในบรรทัดคำสั่ง รูปแบบที่ใช้กันโดยทั่วไปคือ :all (เป้าหมายกฎทั้งหมด), :* (กฎทั้งหมด + เป้าหมายไฟล์),
... (แพ็กเกจปัจจุบันและแพ็กเกจย่อยทั้งหมดซ้ำๆ) ใช้ร่วมกันได้ เช่น //...:* หมายถึงกฎและเป้าหมายไฟล์ทั้งหมดในทุกแพ็กเกจและรากของพื้นที่ทำงาน
การทดสอบ
กฎเป้าหมายที่สร้างอินสแตนซ์จากกฎการทดสอบจึงประกอบด้วยไฟล์ดำเนินการทดสอบ โค้ดที่แสดงผลเป็น 0 เมื่อไฟล์ปฏิบัติการเสร็จสมบูรณ์จะบ่งบอกถึงความสำเร็จในการทดสอบ สัญญาที่แน่นอนระหว่าง Bazel กับการทดสอบ (เช่น ตัวแปรสภาพแวดล้อมการทดสอบ วิธีรวบรวมผลการทดสอบ) ระบุไว้ในสารานุกรมทดสอบ
เครือเครื่องมือ
ชุดเครื่องมือสำหรับสร้างเอาต์พุตสำหรับภาษาหนึ่งๆ โดยทั่วไปแล้ว Toolchain จะมีคอมไพเลอร์, ตัวลิงก์, ล่าม หรือ/และลินเตอร์ Toolchain อาจแตกต่างกันไปตามแพลตฟอร์ม กล่าวคือ คอมโพเนนต์ของ Toolchain ของ Unix อาจแตกต่างกันสำหรับตัวแปร Windows แม้ว่า Toolchain จะใช้ภาษาเดียวกันก็ตาม การเลือกห่วงโซ่เครื่องมือที่เหมาะสมสำหรับแพลตฟอร์มเรียกว่าการแก้ปัญหาห่วงโซ่เครื่องมือ
เป้าหมายระดับบนสุด
เป้าหมายบิลด์คือระดับบนสุดหากมีการขอในบรรทัดคำสั่ง Bazel เช่น หาก //:foo อาศัย //:bar และเรียกใช้ bazel build //:foo สําหรับบิลด์นี้ //:foo จะเป็นระดับบนสุด และ //:bar ไม่ใช่ระดับบนสุด แต่จะต้องสร้างทั้ง 2 เป้าหมาย ความแตกต่างที่สำคัญระหว่างเป้าหมายระดับบนสุดและไม่ใช่ระดับบนสุดคือคำสั่งที่ตั้งค่าไว้ในบรรทัดคำสั่ง Bazel (หรือผ่าน .bazelrc) จะตั้งค่าการกำหนดค่าสำหรับเป้าหมายระดับบนสุด แต่อาจมีการแก้ไขโดยการเปลี่ยนสำหรับเป้าหมายที่ไม่ใช่ระดับบนสุด
ช่วงการเปลี่ยน
การจับคู่สถานะการกำหนดค่าจากค่าหนึ่งไปยังค่าอื่น เปิดใช้เป้าหมายในกราฟบิลด์เพื่อให้มีการกำหนดค่าต่างกัน แม้ว่าเป้าหมายเหล่านั้นจะมีการสร้างอินสแตนซ์จากกฎเดียวกันก็ตาม การใช้งานทั่วไปของการเปลี่ยนคือการเปลี่ยนหน้าแบบแยก โดยที่บางส่วนของกราฟเป้าหมายจะมีการแยกกันด้วยการกำหนดค่าที่แตกต่างกันสำหรับแต่ละส้อม เช่น อาจสร้าง Android APK ที่มีไบนารีเนทีฟที่คอมไพล์สำหรับ ARM และ x86 โดยใช้การเปลี่ยนแบบ 2 แบบในบิลด์เดียว
โปรดดูข้อมูลเพิ่มเติมที่ การเปลี่ยนรุ่นที่ผู้ใช้กำหนด
สิ่งประดิษฐ์ของต้นไม้
อาร์ติแฟกต์ที่แสดงถึงคอลเล็กชันไฟล์ เนื่องจากไฟล์เหล่านี้ไม่ใช่อาร์ติแฟกต์ของตัวเอง การดำเนินการในไฟล์จึงต้องบันทึกอาร์ติแฟกต์ต้นไม้เป็นอินพุตหรือเอาต์พุตแทน
ระดับการแชร์
กลไกหนึ่งใน 2 กลไกสำหรับป้องกันการพึ่งพิงที่ไม่ต้องการในระบบบิลด์ ได้แก่ ระดับการเข้าถึงเป้าหมายสำหรับควบคุมว่าจะให้เป้าหมายอื่นอ้างอิงเป้าหมายได้หรือไม่ และการเปิดเผยการโหลดสำหรับการควบคุมว่าจะให้ไฟล์ BUILD หรือ .bzl โหลดไฟล์ .bzl หนึ่งๆ หรือไม่ หากไม่มีบริบท โดยทั่วไปแล้ว
"ระดับการเข้าถึง" หมายถึงระดับการมองเห็นเป้าหมาย
โปรดดู เอกสารเกี่ยวกับระดับการเข้าถึง
Workspace
สภาพแวดล้อมที่คำสั่ง Bazel ทั้งหมดแชร์จะทำงานจากที่เก็บหลักเดียวกัน
โปรดทราบว่าก่อนหน้านี้แนวคิดของ "ที่เก็บ" และ "พื้นที่ทำงาน" นั้นขัดแย้งกัน คำว่า "พื้นที่ทำงาน" มักหมายถึงที่เก็บหลัก และบางครั้งอาจหมายถึง "ที่เก็บ" ด้วยซ้ำ ควรหลีกเลี่ยงการใช้งานดังกล่าวเพื่อความชัดเจน