การดำเนินการ
คำสั่งที่เรียกใช้ระหว่างบิลด์ เช่น การเรียกคอมไพเลอร์ที่ใช้อาร์ติแฟกต์เป็นอินพุตและสร้างอาร์ติแฟกต์อื่นๆ เป็นเอาต์พุต รวมข้อมูลเมตา เช่น อาร์กิวเมนต์บรรทัดคำสั่ง คีย์การดำเนินการ ตัวแปรสภาพแวดล้อม และอาร์ติแฟกต์อินพุต/เอาต์พุตที่ประกาศแล้ว
ดูข้อมูลเพิ่มเติมได้ที่เอกสารประกอบเกี่ยวกับกฎ
แคชการดำเนินการ
แคชในดิสก์ที่จัดเก็บการแมปการดำเนินการที่ดำเนินการกับเอาต์พุตที่สร้างขึ้น คีย์แคชเรียกว่าคีย์การดำเนินการ คอมโพเนนต์หลักสำหรับรูปแบบการทํางานแบบเพิ่มของ Bazel ระบบจะจัดเก็บแคชไว้ในไดเรกทอรีฐานเอาต์พุต ดังนั้นแคชจะยังคงอยู่แม้ว่าเซิร์ฟเวอร์ Bazel จะรีสตาร์ท
กราฟการกระทํา
กราฟในหน่วยความจำของการดำเนินการและอาร์ติแฟกต์ที่การดำเนินการเหล่านี้อ่านและสร้าง กราฟอาจรวมอาร์ติแฟกต์ที่มีอยู่เป็นไฟล์ต้นฉบับ (เช่น ในระบบไฟล์) รวมถึงอาร์ติแฟกต์ขั้นกลาง/สุดท้ายที่สร้างขึ้นและไม่ได้กล่าวถึงในไฟล์ BUILD สร้างขึ้นระหว่างระยะการวิเคราะห์และใช้ระหว่างระยะการดําเนินการ
การค้นหากราฟการดำเนินการ (aquery)
เครื่องมือQuery ที่ใช้ค้นหาแทนบิลด์ actions ได้ ซึ่งจะช่วยให้คุณวิเคราะห์ได้ว่ากฎการสร้างส่งผลต่อการสร้างงานที่ทำงานจริงอย่างไร
ปุ่มดำเนินการ
คีย์แคชของการดําเนินการ คํานวณตามข้อมูลเมตาของการดำเนินการ ซึ่งอาจรวมถึงคําสั่งที่จะดําเนินการในการดําเนินการ แฟล็กคอมไพเลอร์ ตําแหน่งไลบรารี หรือส่วนหัวของระบบ ทั้งนี้ขึ้นอยู่กับการดำเนินการ เปิดใช้ Bazel เพื่อแคชหรือทำให้การดำเนินการแต่ละรายการเป็นโมฆะอย่างแน่ชัด
ช่วงการวิเคราะห์
เฟสที่ 2 ของบิลด์ ประมวลผลกราฟเป้าหมายที่ระบุใน BUILD ไฟล์เพื่อสร้างกราฟการดำเนินการในหน่วยความจำซึ่งกำหนดลำดับการดำเนินการที่จะเรียกใช้ในระหว่างระยะการดำเนินการ นี่คือระยะที่มีการประเมินการใช้งานกฎ
อาร์ติแฟกต์
ไฟล์ต้นฉบับหรือไฟล์ที่สร้างขึ้น หรืออาจเป็นไดเรกทอรีของไฟล์ที่เรียกว่ารายการในต้นไม้
อาร์ติแฟกต์อาจเป็นอินพุตของการดำเนินการหลายรายการ แต่ต้องสร้างขึ้นจากการดำเนินการไม่เกิน 1 รายการเท่านั้น
อาร์ติแฟกต์ที่สอดคล้องกับเป้าหมายไฟล์จะแก้ไขได้ด้วยป้ายกำกับ
สัดส่วนภาพ
กลไกสําหรับกฎในการสร้างการดําเนินการเพิ่มเติมในข้อกําหนด เช่น หากเป้าหมาย ก ขึ้นอยู่กับ ข ผู้ใช้สามารถใช้แง่มุมใน ก ที่ขึ้นขอบความเกี่ยวข้องไปยัง ข และเรียกใช้การดำเนินการเพิ่มเติมใน ข เพื่อสร้างและรวบรวมไฟล์เอาต์พุตเพิ่มเติม การดำเนินการเพิ่มเติมเหล่านี้จะถูกแคชและนำมาใช้ใหม่ระหว่างเป้าหมายที่ต้องใช้ด้านเดียวกัน สร้างด้วย
aspect() ฟังก์ชัน Starlark Build API สามารถใช้เพื่อดำเนินการต่างๆ เช่น สร้างข้อมูลเมตาสำหรับ IDE และสร้างการดำเนินการสำหรับการจัดรูปแบบ
ดูข้อมูลเพิ่มเติมได้ที่เอกสารประกอบเกี่ยวกับแง่มุม
การแสดงภาพซ้อนภาพ
กลไกการคอมโพสิชันที่สามารถใช้แง่มุมกับผลลัพธ์ของแง่มุมอื่นๆ ได้ ตัวอย่างเช่น คุณสามารถใช้แง่มุมที่สร้างข้อมูลให้ IDE ใช้ร่วมกับแง่มุมที่สร้างไฟล์ .java จาก proto ได้
หากต้องการให้แง่มุม 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
ไฟล์ BUILD คือไฟล์การกําหนดค่าหลักที่บอก Bazel ว่าต้องสร้างเอาต์พุตซอฟต์แวร์ใด รายการใดบ้างที่ต้องใช้ร่วมกัน และวิธีสร้าง Bazel จะรับไฟล์ BUILD เป็นอินพุต และใช้ไฟล์ดังกล่าวเพื่อสร้างกราฟของข้อกําหนด และดึงข้อมูลการดําเนินการที่ต้องทําให้เสร็จสมบูรณ์เพื่อสร้างเอาต์พุตซอฟต์แวร์ระดับกลางและขั้นสุดท้าย ไฟล์ BUILD จะทำเครื่องหมายไดเรกทอรีและไดเรกทอรีย่อยทั้งหมดที่ไม่มีไฟล์ BUILD เป็นแพ็กเกจ และอาจมีเป้าหมายที่สร้างโดยกฎ หรือจะตั้งชื่อไฟล์เป็น
BUILD.bazel ก็ได้
ไฟล์ BUILD.bazel
โปรดดูไฟล์ BUILD มีลำดับความสำคัญเหนือไฟล์ BUILD ในไดเรกทอรีเดียวกัน
ไฟล์ .bzl
ไฟล์ที่กําหนดกฎ มาโคร และค่าคงที่ที่เขียนใน Starlark ซึ่งจะนำเข้าไปยังไฟล์ BUILD ได้โดยใช้ฟังก์ชัน load()
สร้างกราฟ
กราฟทรัพยากร Dependency ที่ Bazel สร้างและเรียกใช้เพื่อทำการบิลด์ ซึ่งรวมถึงโหนดต่างๆ เช่น เป้าหมาย เป้าหมายที่กําหนดค่าแล้ว การดําเนินการ และอาร์ติแฟกต์ เวอร์ชันจะถือว่าเสร็จสมบูรณ์เมื่ออาร์ติแฟกต์ทั้งหมดที่ชุดเป้าหมายที่ขอมีการยืนยันว่าเป็นปัจจุบันแล้ว
การตั้งค่าบิลด์
การกำหนดค่าที่ Starlark กำหนด การเปลี่ยนกำหนดการตั้งค่าบิลด์เพื่อเปลี่ยนการกำหนดค่าของกราฟย่อยได้ หากแสดงต่อผู้ใช้เป็นFlag บรรทัดคำสั่ง หรือที่เรียกว่า Flag การสร้าง
ล้างบิลด์
บิลด์ที่ไม่ได้ใช้ผลลัพธ์ของบิลด์ก่อนหน้านี้ โดยทั่วไปแล้ววิธีนี้จะช้ากว่าบิลด์แบบเพิ่ม แต่มักถือว่าถูกต้องกว่า Bazel รับประกันว่าทั้งบิลด์สะอาดและที่เพิ่มขึ้นจะมีความถูกต้องเสมอ
รูปแบบไคลเอ็นต์-เซิร์ฟเวอร์
ไคลเอ็นต์บรรทัดคำสั่ง bazel จะเริ่มเซิร์ฟเวอร์เบื้องหลังบนเครื่องภายในโดยอัตโนมัติเพื่อเรียกใช้คำสั่งของ Bazel เซิร์ฟเวอร์จะยังคงทำงานอยู่สำหรับคำสั่งต่างๆ แต่จะหยุดโดยอัตโนมัติหลังจากไม่มีการใช้งานเป็นระยะเวลาหนึ่ง (หรือผ่านคำสั่ง "bazel shutdown" อย่างชัดแจ้ง) การแยก Bazel เป็นเซิร์ฟเวอร์และไคลเอ็นต์จะช่วยกระจายเวลาเริ่มต้นของ JVM และรองรับการสร้างแบบเพิ่มได้เร็วขึ้นเนื่องจากกราฟการดำเนินการจะยังคงอยู่ในหน่วยความจำสำหรับคำสั่งต่างๆ
คำสั่ง
ใช้ในบรรทัดคำสั่งเพื่อเรียกฟังก์ชัน Bazel ต่างๆ เช่น bazel
build, bazel test, bazel run และ bazel query
Flag คำสั่ง
ชุด Flag สำหรับคําสั่งหนึ่งๆ โดยเฉพาะ ระบุแฟล็กคำสั่งหลังคำสั่ง (bazel build <command flags>) โดยแฟล็กใช้ได้กับคำสั่งอย่างน้อย 1 รายการ ตัวอย่างเช่น --configure เป็นแฟล็กสำหรับคำสั่ง bazel sync โดยเฉพาะ แต่ --keep_going ใช้ได้กับ sync, build,test และอื่นๆ โดยปกติแล้วระบบจะใช้ Flag เพื่อการกำหนดค่า ดังนั้นการเปลี่ยนแปลงค่า Flag อาจทําให้ Bazel ลบล้างกราฟในหน่วยความจําและเริ่มระยะการวิเคราะห์อีกครั้ง
การกำหนดค่า
ข้อมูลนอกคําจํากัดความของกฎที่ส่งผลต่อวิธีสร้างการดําเนินการของกฎ ทุกบิลด์มีการกำหนดค่าอย่างน้อย 1 รายการที่ระบุแพลตฟอร์มเป้าหมาย ตัวแปรสภาพแวดล้อมการดำเนินการ และแฟล็กบรรทัดคำสั่ง การเปลี่ยนอาจสร้างการกำหนดค่าเพิ่มเติม เช่น สําหรับเครื่องมือโฮสต์หรือการคอมไพล์ข้าม
ดูเพิ่มเติมที่ การกำหนดค่า
การตัดการกำหนดค่า
กระบวนการในการรวมเฉพาะส่วนต่างๆ ของการกำหนดค่าที่เป้าหมายต้องการจริงๆ เช่น หากคุณสร้างไบนารีของ Java //:j ด้วยการอ้างอิง C++ //:c ก็จะเป็นการรวมค่า --javacopt ไว้ในการกำหนดค่าของ //:c ด้วย เนื่องจากการเปลี่ยน --javacopt จะทำให้ C++ เกิดการแคชโดยไม่จำเป็น
คําค้นหาที่กําหนดค่า (cquery)
เครื่องมือค้นหาที่ค้นหาในเป้าหมายที่กำหนดค่า (หลังจากขั้นตอนการวิเคราะห์เสร็จสมบูรณ์แล้ว) ซึ่งหมายความว่า select() และFlag การสร้าง (เช่น
--platforms) จะแสดงในผลการค้นหาอย่างถูกต้อง
ดูข้อมูลเพิ่มเติมได้ที่เอกสารประกอบ cquery
เป้าหมายที่กำหนดค่าแล้ว
ผลลัพธ์ของการประเมินเป้าหมายด้วยการกำหนดค่า ระยะการวิเคราะห์จะสร้างข้อมูลนี้โดยการรวมตัวเลือกของบิลด์เข้ากับเป้าหมายที่ต้องสร้าง
ตัวอย่างเช่น หาก //:foo สร้างให้กับสถาปัตยกรรม 2 รายการที่แตกต่างกันภายในบิลด์เดียวกัน ก็จะมีเป้าหมายที่กำหนดค่าไว้ 2 รายการ ได้แก่ <//:foo, x86> และ <//:foo, arm>
ความถูกต้อง
บิลด์จะถูกต้องเมื่อเอาต์พุตของบิลด์แสดงถึงสถานะของอินพุตแบบสัญจร เพื่อให้ได้งานสร้างที่ถูกต้อง Bazel มุ่งมั่นที่จะเป็นตัวเอง ทำซ้ำได้ และทำให้การวิเคราะห์การสร้างและการดำเนินการเป็นสิ่งกำหนด
การขึ้นต่อกัน
เส้นเชื่อมระหว่างเป้าหมาย 2 รายการ //:foo เป้าหมายมีทรัพยากร Dependency เป้าหมายใน //:bar เป้าหมาย หากค่าแอตทริบิวต์ของ //:foo มีการอ้างอิงไปยัง //:bar //:foo มีทรัพยากร Dependency ใน //:bar หากการดำเนินการใน //:foo ขึ้นอยู่กับอาร์ติแฟกต์อินพุตที่สร้างโดยการดำเนินการใน //:bar
ในบางบริบท อาจหมายถึงทรัพยากร Dependency ภายนอกด้วย โปรดดูโมดูล
Depset
โครงสร้างข้อมูลสำหรับการรวบรวมข้อมูลบนทรัพยากร Dependency แบบทรานซิทีฟ เพิ่มประสิทธิภาพเพื่อให้การผสานชุดข้อมูล Dep ประหยัดเวลาและพื้นที่เก็บข้อมูล เนื่องจากมีชุดข้อมูล Dep ขนาดใหญ่ (ไฟล์หลายแสนไฟล์) อยู่ทั่วไป ติดตั้งใช้งานเพื่ออ้างอิงชุดข้อมูลอื่นๆ แบบซ้ำซ้อนเพื่อเหตุผลด้านประสิทธิภาพพื้นที่เก็บข้อมูล การติดตั้งใช้งานกฎไม่ควร "ยุบ" ชุดข้อมูลโดยแปลงเป็นลิสต์ เว้นแต่ว่ากฎจะอยู่ในระดับบนสุดของกราฟการสร้าง การลดการตั้งค่าขนาดใหญ่จะทำให้ใช้หน่วยความจำอย่างมาก หรือที่เรียกว่าชุดที่ฝังอยู่ในการใช้งานภายในของ Bazel
โปรดดู เอกสารประกอบของ Depset
ดิสก์แคช
Blob บนดิสก์ในเครื่องสำหรับฟีเจอร์การแคชจากระยะไกล ใช้ร่วมกับที่เก็บข้อมูล Blob ระยะไกลจริงได้
การกระจาย
ไดเรกทอรีแบบอ่านอย่างเดียวที่มีไฟล์ที่ Bazel จะดึงข้อมูลจากอินเทอร์เน็ตโดยใช้กฎที่เก็บ ช่วยให้บิลด์ทำงานแบบออฟไลน์ได้อย่างสมบูรณ์
การดำเนินการแบบไดนามิก
กลยุทธ์การดำเนินการที่เลือกระหว่างการดำเนินการภายในและระยะไกลตามการเรียนรู้ที่หลากหลาย และใช้ผลการดำเนินการของวิธีที่ประสบความสำเร็จเร็วกว่า การดำเนินการบางอย่างจะทำงานได้เร็วขึ้นเมื่อดำเนินการในเครื่อง (เช่น การลิงก์) และการดำเนินการอื่นๆ จะทำงานได้เร็วขึ้นเมื่อดำเนินการจากระยะไกล (เช่น การคอมไพล์แบบขนานได้สูง) กลยุทธ์การเรียกใช้แบบไดนามิกจะให้เวลาสร้างที่เพิ่มขึ้นและสะอาดที่สุด
ระยะการดำเนินการ
ระยะที่ 3 ของการสร้าง เรียกใช้การดำเนินการในกราฟการดำเนินการที่สร้างขึ้นในระยะการวิเคราะห์ การดำเนินการเหล่านี้จะเรียกใช้ไฟล์ปฏิบัติการ (คอมไพเลอร์ สคริปต์) เพื่ออ่านและเขียนอาร์ติแฟกต์ กลยุทธ์การสร้างจะควบคุมวิธีดำเนินการเหล่านี้ เช่น การดำเนินการในเครื่อง ระยะไกล ไดนามิก แซนด์บ็อกซ์ โดคเกอร์ และอื่นๆ
รูทการดำเนินการ
ไดเรกทอรีในฐานเอาต์พุตของเวิร์กスペース ซึ่งจะเรียกใช้การดำเนินการในเครื่องในบิลด์ที่ไม่ใช่แซนด์บ็อกซ์ เนื้อหาไดเรกทอรีมักจะเป็นลิงก์สัญลักษณ์ของอาร์ติแฟกต์อินพุตจากพื้นที่ทำงาน รูทการดำเนินการยังมีลิงก์สัญลักษณ์ไปยังที่เก็บภายนอกในฐานะอินพุตอื่นๆ และไดเรกทอรี bazel-out สำหรับจัดเก็บเอาต์พุตด้วย เตรียมไว้ในช่วงระยะการโหลดโดยการสร้างป่าลิงก์สัญลักษณ์ของไดเรกทอรีที่แสดงถึงการนำส่งแบบสื่อกลางของแพ็กเกจที่บิลด์นั้นใช้ เข้าถึงได้โดยใช้ bazel info
execution_root ในบรรทัดคำสั่ง
ไฟล์
Hermeticity
บิลด์จะทำงานโดยไม่มีอิทธิพลภายนอกต่อการดำเนินการสร้างและทดสอบ ซึ่งช่วยให้แน่ใจว่าผลลัพธ์จะตายตัวและถูกต้อง ตัวอย่างเช่น โดยปกติแล้วบิลด์ที่ห่อหุ้มจะไม่อนุญาตให้การเข้าถึงเครือข่ายดำเนินการ จำกัดการเข้าถึงอินพุตที่ประกาศ ใช้การประทับเวลาและเขตเวลาแบบคงที่ จำกัดการเข้าถึงตัวแปรสภาพแวดล้อม และใช้ Seed แบบคงที่สำหรับเครื่องมือสร้างตัวเลขสุ่ม
บิลด์ที่เพิ่มขึ้น
บิลด์แบบเพิ่มจะนําผลลัพธ์ของบิลด์ก่อนหน้ามาใช้ซ้ำเพื่อลดเวลาในการสร้างและการใช้ทรัพยากร การตรวจสอบการขึ้นต่อกันและการแคชมีจุดประสงค์เพื่อสร้างผลลัพธ์ที่ถูกต้องสำหรับบิลด์ประเภทนี้ การสร้างแบบเพิ่มเป็นกระบวนการที่ตรงข้ามกับการสร้างแบบล้าง
ป้ายกำกับ
ตัวระบุเป้าหมาย โดยทั่วไปมีรูปแบบเป็น @repo//path/to/package:target โดยที่ repo คือชื่อ (ที่ปรากฏ) ของที่เก็บที่มีเป้าหมาย path/to/package คือเส้นทางไปยังไดเรกทอรีที่มีไฟล์ BUILD ที่ประกาศเป้าหมาย (ไดเรกทอรีนี้เรียกอีกอย่างว่าแพ็กเกจ) และ target คือชื่อของเป้าหมาย คุณอาจละเว้นบางส่วนของไวยากรณ์นี้ ทั้งนี้ขึ้นอยู่กับสถานการณ์
ดูข้อมูลเพิ่มเติมได้ที่ป้ายกำกับ
ระยะการโหลด
ระยะแรกของบิลด์ที่ Bazel ดำเนินการกับไฟล์ BUILD เพื่อสร้างแพ็กเกจ ระบบจะประเมินมาโครและฟังก์ชันบางอย่าง เช่น glob() ในขั้นตอนนี้ แทรกสลับกับเฟสที่ 2 ของบิลด์หรือระยะการวิเคราะห์เพื่อสร้างกราฟเป้าหมาย
มาโคร
กลไกในการเขียนประกาศเป้าหมายกฎหลายรายการร่วมกันภายใต้ฟังก์ชัน Starlark เดียว เปิดใช้การใช้รูปแบบการประกาศกฎทั่วไปซ้ำในไฟล์ BUILD ขยายไปยังการประกาศเป้าหมายของกฎพื้นฐานในระหว่างระยะการโหลด
ดูเพิ่มเติม: เอกสารประกอบเกี่ยวกับมาโคร
Mnemonic
สตริงสั้นๆ ที่มนุษย์อ่านได้ซึ่งผู้เขียนกฎเลือกให้เข้าใจได้อย่างรวดเร็วว่าการดำเนินการในกฎกำลังทำอะไร คุณสามารถใช้เป็นตัวระบุสำหรับการเลือกกลยุทธ์การสร้าง ตัวอย่างคําช่วยจําสําหรับการดําเนินการ ได้แก่ Javac จากกฎ Java, CppCompile จากกฎ C++ และ AndroidManifestMerger จากกฎ Android
โมดูล
โปรเจ็กต์ Bazel ที่สามารถมีหลายเวอร์ชันได้ โดยแต่ละเวอร์ชันอาจขึ้นอยู่กับโมดูลอื่นๆ ซึ่งคล้ายกับแนวคิดที่คุ้นเคยในระบบการจัดการการอ้างอิงอื่นๆ เช่น อาร์ติแฟกต์ของ Maven, แพ็กเกจ npm, โมดูล Go หรือลังคาร์โก้ โมดูลเป็นโครงสร้างพื้นฐานของระบบการจัดการทรัพยากรภายนอกของ Bazel
แต่ละโมดูลได้รับการสนับสนุนจาก repo ที่มีไฟล์ MODULE.bazel ที่รูท ไฟล์นี้มีข้อมูลเมตาเกี่ยวกับโมดูลเอง (เช่น ชื่อและเวอร์ชัน) โมดูลที่ขึ้นต่อกันโดยตรง และข้อมูลอื่นๆ อีกมากมาย รวมถึงการลงทะเบียนเครื่องมือและอินพุตส่วนขยายโมดูล
ข้อมูลเมตาของโมดูลจะโฮสต์ในรีจิสทรี Bazel
ดูข้อมูลเพิ่มเติมได้ที่โมดูล Bazel
ส่วนขยายโมดูล
ตรรกะชิ้นหนึ่งที่สามารถเรียกใช้เพื่อสร้างที่เก็บโดยการอ่านอินพุตจากกราฟทรัพยากร Dependency ของโมดูลและการเรียกใช้กฎที่เก็บได้ ส่วนขยายโมดูลมีความสามารถคล้ายกับกฎของ repo ซึ่งช่วยให้เข้าถึงอินเทอร์เน็ต ดำเนินการ I/O ของไฟล์ และอื่นๆ ได้
ดูข้อมูลเพิ่มเติมได้ที่ส่วนขยายโมดูล
กฎเนทีฟ
กฎที่สร้างไว้ใน Bazel และใช้งานใน Java กฎดังกล่าวจะปรากฏใน .bzl ไฟล์เป็นฟังก์ชันในโมดูลเนทีฟ (เช่น native.cc_library หรือ native.java_library) กฎที่ผู้ใช้กำหนด (ไม่ใช่เนทีฟ) สร้างขึ้นโดยใช้ Starlark
ฐานเอาต์พุต
ไดเรกทอรีสำหรับ workspace โดยเฉพาะสำหรับจัดเก็บไฟล์เอาต์พุตของ Bazel ใช้เพื่อแยกเอาต์พุตจากแผนผังต้นทางของพื้นที่ทำงาน (พื้นที่เก็บข้อมูลหลัก) อยู่ในรูทของผู้ใช้เอาต์พุต
กลุ่มเอาต์พุต
กลุ่มไฟล์ที่คาดว่าจะสร้างขึ้นเมื่อ Bazel บิลด์เป้าหมายเสร็จแล้ว กฎจะใส่เอาต์พุตปกติไว้ใน "กลุ่มเอาต์พุตเริ่มต้น" (เช่น ไฟล์ .jar ของ java_library, .a และ .so สำหรับเป้าหมาย cc_library) กลุ่มเอาต์พุตเริ่มต้นคือกลุ่มเอาต์พุตที่มีการสร้างอาร์ติแฟกต์เมื่อมีการขอเป้าหมายในบรรทัดคำสั่ง
กฎสามารถกำหนดกลุ่มเอาต์พุตที่มีชื่อเพิ่มเติมซึ่งระบุได้อย่างชัดเจนในไฟล์ BUILD (กฎ filegroup) หรือบรรทัดคำสั่ง (Flag --output_groups)
เอาต์พุตรูทผู้ใช้
ไดเรกทอรีเฉพาะผู้ใช้สำหรับจัดเก็บเอาต์พุตของ Bazel ชื่อไดเรกทอรีจะมาจากชื่อผู้ใช้ของระบบ ป้องกันไม่ให้ไฟล์เอาต์พุตทับซ้อนกันหากผู้ใช้หลายคนสร้างโปรเจ็กต์เดียวกันในระบบในเวลาเดียวกัน มีไดเรกทอรีย่อยที่เกี่ยวข้องกับเอาต์พุตของบิลด์ของพื้นที่ทำงานแต่ละแห่ง หรือที่เรียกว่าฐานเอาต์พุต
แพ็กเกจ
ชุดเป้าหมายที่กําหนดโดยไฟล์ BUILD ชื่อแพ็กเกจคือเส้นทางของไฟล์ BUILD สัมพัทธ์กับรูท repo แพ็กเกจอาจมีแพ็กเกจย่อยหรือไดเรกทอรีย่อยที่มีBUILDไฟล์ ซึ่งจะทำให้เกิดลําดับชั้นของแพ็กเกจ
กลุ่มแพ็กเกจ
เป้าหมายที่แสดงชุดแพ็กเกจ มักใช้ในค่าแอตทริบิวต์ visibility
แพลตฟอร์ม
"ประเภทเครื่อง" ที่เกี่ยวข้องกับบิลด์ ซึ่งรวมถึงเครื่อง Bazel ที่ทำงานบน (แพลตฟอร์ม "โฮสต์") เครื่องสร้างเครื่องมือที่ทำงานบนแพลตฟอร์ม "exec") และเป้าหมายเครื่องที่สร้างขึ้นสำหรับ ("แพลตฟอร์มเป้าหมาย")
ผู้ให้บริการ
สคีมาอธิบายหน่วยข้อมูลที่จะส่งระหว่างเป้าหมายกฎตามความสัมพันธ์แบบมีลําดับชั้น โดยปกติแล้วไฟล์นี้จะมีข้อมูล เช่น ตัวเลือกคอมไพเลอร์ ไฟล์ต้นทางหรือไฟล์เอาต์พุตแบบทรานซิทีฟ และข้อมูลเมตาของบิลด์ มักใช้ร่วมกับ depsets เพื่อจัดเก็บข้อมูลทรานซิชันสะสมอย่างมีประสิทธิภาพ ตัวอย่างผู้ให้บริการในตัวคือ DefaultInfo
ดูเพิ่มเติม: เอกสารของผู้ให้บริการ
การค้นหา (แนวคิด)
กระบวนการวิเคราะห์กราฟการสร้างเพื่อทำความเข้าใจพร็อพเพอร์ตี้เป้าหมายและโครงสร้างการพึ่งพา Bazel รองรับรูปแบบการค้นหา 3 รูปแบบ ได้แก่ query, cquery และ aquery
คำค้นหา (คำสั่ง)
เครื่องมือการค้นหาที่ทำงานกับกราฟเป้าหมายหลังระยะการโหลดของบิลด์ ซึ่งจะดำเนินการได้ค่อนข้างเร็ว แต่ไม่สามารถวิเคราะห์ผลของ select(), Flag การสร้าง, อาร์ติแฟกต์ หรือการดำเนินการ
ดูข้อมูลเพิ่มเติมได้ที่วิธีใช้การค้นหา ข้อมูลอ้างอิงการค้นหา
ที่เก็บ
แผนผังไดเรกทอรีที่มีไฟล์ตัวทำเครื่องหมายขอบเขตอยู่ที่รูท มีไฟล์แหล่งที่มาซึ่งใช้ในการสร้างบิลด์ Bazel ได้ มักย่อเป็น repo
ไฟล์เครื่องหมายขอบเขตของ repo อาจเป็น MODULE.bazel (บ่งบอกว่า repo นี้แสดงโมดูล Bazel), REPO.bazel หรือในบริบทเดิม WORKSPACE หรือ WORKSPACE.bazel ไฟล์ตัวทำเครื่องหมายขอบเขตที่เก็บใดก็ตามจะแสดงขอบเขตของที่เก็บ โดยไฟล์เหล่านี้สามารถอยู่ร่วมกันในไดเรกทอรีได้
ที่เก็บหลักคือที่เก็บที่มีการเรียกใช้คำสั่ง Bazel ปัจจุบัน
ที่เก็บภายนอกจะกำหนดโดยการระบุโมดูลในไฟล์ MODULE.bazel หรือการเรียกใช้กฎที่เก็บในส่วนขยายโมดูล โดยสามารถดึงข้อมูลตำแหน่ง "เวทมนตร์" ที่กำหนดไว้ล่วงหน้าบนดิสก์ได้แบบออนดีมานด์
ที่เก็บแต่ละรายการมีชื่อตามรูปแบบบัญญัติที่คงที่และไม่ซ้ำกัน และอาจมีชื่อที่ปรากฏแตกต่างกันเมื่อดูจากที่เก็บอื่นๆ
ดูเพิ่มเติม: ภาพรวมของทรัพยากร Dependency ภายนอก
แคชที่เก็บ
แคชที่จัดการเนื้อหาซึ่งแชร์ได้ของไฟล์ที่ดาวน์โหลดโดย Bazel สำหรับบิลด์และแชร์ได้ในพื้นที่ทำงาน เปิดใช้บิลด์แบบออฟไลน์หลังจากการดาวน์โหลดครั้งแรก โดยทั่วไปมักใช้เพื่อแคชไฟล์ที่ดาวน์โหลดผ่านกฎที่เก็บ เช่น http_archive และ API ของกฎที่เก็บ เช่น repository_ctx.download ระบบจะแคชไฟล์ก็ต่อเมื่อมีการระบุการตรวจสอบข้อผิดพลาด SHA-256 สำหรับการดาวน์โหลดเท่านั้น
กฎที่เก็บ
สคีมาของคำจำกัดความของที่เก็บซึ่งบอก Bazel ถึงวิธีการแสดง (หรือ "ดึงข้อมูล") ที่เก็บ มักจะย่อให้เหลือเพียงกฎที่เก็บ
Bazel จะเรียกใช้กฎของรีโปภายในเพื่อกำหนดรีโปที่รองรับโดยโมดูล หรือส่วนขยายโมดูลจะเรียกใช้กฎได้
กฎของรีโปสามารถเข้าถึงอินเทอร์เน็ตหรือดำเนินการ I/O ของไฟล์ได้ กฎของรีโปที่ใช้กันมากที่สุดคือ http_archive เพื่อดาวน์โหลดไฟล์เก็บถาวรที่มีไฟล์ต้นฉบับจากอินเทอร์เน็ต
โปรดดูที่: เอกสารประกอบเกี่ยวกับกฎที่เก็บ
ความสามารถในการทำซ้ำ
พร็อพเพอร์ตี้ของบิลด์หรือการทดสอบที่ชุดอินพุตของบิลด์หรือการทดสอบจะสร้างชุดเอาต์พุตเดียวกันทุกครั้ง ไม่ว่าเวลา วิธีการ หรือสภาพแวดล้อมจะเป็นอย่างไร โปรดทราบว่าอาจไม่ได้หมายความว่าเอาต์พุตถูกต้องหรือเป็นเอาต์พุตที่ต้องการ
กฎ
สคีมาสำหรับกำหนดเป้าหมายของกฎในไฟล์ BUILD เช่น cc_library จากมุมมองของผู้เขียนไฟล์ BUILD กฎประกอบด้วยชุดแอตทริบิวต์และตรรกะกล่องดำ ตรรกะนี้จะบอกให้กฎกำหนดเป้าหมายวิธีสร้างอาร์ติแฟกต์เอาต์พุตและส่งข้อมูลไปยังเป้าหมายของกฎอื่นๆ จากมุมมองของผู้เขียน .bzl กฎคือวิธีหลักในการขยาย Bazel ให้รองรับภาษาโปรแกรมและสภาพแวดล้อมใหม่ๆ
ระบบจะสร้างอินสแตนซ์กฎเพื่อสร้างเป้าหมายของกฎในระยะการโหลด ในกฎระยะการวิเคราะห์ เป้าหมายจะสื่อสารข้อมูลไปยังทรัพยากร Dependency แบบดาวน์สตรีมในรูปแบบของผู้ให้บริการ และลงทะเบียนการดำเนินการที่อธิบายวิธีสร้างอาร์ติแฟกต์เอาต์พุต โดยการดำเนินการเหล่านี้จะเรียกใช้ในระยะการดำเนินการ
ดูเพิ่มเติมที่ เอกสารประกอบเกี่ยวกับกฎ
เป้าหมายของกฎ
เป้าหมายที่เป็นอินสแตนซ์ของกฎ แตกต่างจากไฟล์เป้าหมาย และกลุ่มแพ็กเกจ อย่าสับสนกับกฎ
ไฟล์รันไทม์
Dependency รันไทม์ของเป้าหมายที่เรียกใช้งานได้ โดยทั่วไปแล้ว ไฟล์ที่เรียกใช้ได้คือเอาต์พุตที่เรียกใช้ได้ของกฎการทดสอบ และไฟล์เรียกใช้คือทรัพยากร Dependency ของข้อมูลรันไทม์ของการทดสอบ ก่อนเรียกใช้ไฟล์ปฏิบัติการ (ระหว่างการทดสอบ Bazel) Bazel จะเตรียมต้นไม้ของไฟล์เรียกใช้ควบคู่ไปกับไฟล์ปฏิบัติการทดสอบตามโครงสร้างไดเรกทอรีต้นทาง
ดูข้อมูลเพิ่มเติมได้ที่เอกสารประกอบเกี่ยวกับ Runfiles
การทำแซนด์บ็อกซ์
เทคนิคในการแยกการดำเนินการที่ทำงานอยู่ภายในรูทการดำเนินการที่จำกัดและชั่วคราว ซึ่งช่วยให้แน่ใจว่าจะไม่อ่านอินพุตที่ไม่ได้ประกาศหรือเขียนเอาต์พุตที่ไม่ได้ประกาศ การใช้แซนด์บ็อกซ์ช่วยเพิ่มการปิดผนึกได้อย่างมาก แต่มักจะมีต้นทุนด้านประสิทธิภาพและต้องใช้การรองรับจากระบบปฏิบัติการ ค่าใช้จ่ายด้านประสิทธิภาพจะขึ้นอยู่กับแพลตฟอร์ม ระบบปฏิบัติการใน Linux ไม่มีนัยสำคัญ แต่ใน macOS อาจทำให้ไม่สามารถใช้แซนด์บ็อกซ์ได้
Skyframe
Skyframe เป็นเฟรมเวิร์กการประเมินหลักแบบคู่ขนาน ฟังก์ชันการทำงาน และการประเมินที่เพิ่มขึ้นของ Bazel
การปั๊มวัสดุ
ฟีเจอร์สำหรับฝังข้อมูลเพิ่มเติมลงในอาร์ติแฟกต์ที่สร้างด้วย Bazel เช่น สามารถใช้สำหรับการควบคุมแหล่งที่มา เวลาสร้าง และข้อมูลอื่นๆ เกี่ยวกับเวิร์กスペースหรือสภาพแวดล้อมสำหรับบิลด์รุ่น
เปิดใช้ผ่าน--workspace_status_command Flag และกฎที่รองรับแอตทริบิวต์การประทับ
สตาร์ลาร์ก
ภาษาส่วนขยายสําหรับเขียนกฎและมาโคร ชุดย่อยแบบจำกัดของ Python (ตามไวยากรณ์และไวยากรณ์) ซึ่งมีเป้าหมายเป็นการกำหนดค่าและเพื่อให้มีประสิทธิภาพดีขึ้น ใช้นามสกุล .bzl
file ไฟล์ BUILD ใช้ Starlark เวอร์ชันที่จำกัดมากขึ้น (เช่น ไม่มีคําจํากัดความของฟังก์ชัน def) ซึ่งก่อนหน้านี้เรียกว่า Skylark
ดูข้อมูลเพิ่มเติมได้ที่เอกสารประกอบเกี่ยวกับภาษา Starlark
แฟล็กเริ่มต้น
ชุด Flag ที่ระบุระหว่าง bazel กับคำสั่ง เช่น บิลด์ --host_jvm_debug แบบ bazel Flag เหล่านี้จะแก้ไขการกําหนดค่าของเซิร์ฟเวอร์ Bazel ดังนั้นการแก้ไข Flag การเริ่มต้นระบบจะทําให้เซิร์ฟเวอร์รีสตาร์ท แฟล็กสตาร์ทอัพไม่ได้มีไว้เฉพาะสำหรับคำสั่งใดๆ
เป้าหมาย
ออบเจ็กต์ที่กําหนดไว้ในไฟล์ BUILD และระบุด้วยป้ายกํากับ เป้าหมายแสดงถึงหน่วยที่สามารถสร้างได้ของพื้นที่ทํางานจากมุมมองของผู้ใช้ปลายทาง
เป้าหมายที่ประกาศโดยการสร้างอินสแตนซ์กฎเรียกว่าเป้าหมายของกฎ เป้าหมายเหล่านี้อาจเรียกใช้ได้ (เช่น cc_binary) หรือทดสอบได้ (เช่น cc_test) ทั้งนี้ขึ้นอยู่กับกฎ โดยปกติแล้วเป้าหมายของกฎจะขึ้นอยู่กับเป้าหมายอื่นๆ ผ่านแอตทริบิวต์ (เช่น deps) ความสัมพันธ์เหล่านี้เป็นพื้นฐานของกราฟเป้าหมาย
นอกจากเป้าหมายกฎแล้ว ยังมีเป้าหมายไฟล์และเป้าหมายกลุ่มแพ็กเกจด้วย เป้าหมายไฟล์จะสอดคล้องกับอาร์ติแฟกต์ที่อ้างอิงภายในไฟล์ BUILD ทั้งนี้ในกรณีพิเศษ ไฟล์ BUILD ของแพ็กเกจจะถือว่าเป็นเป้าหมายไฟล์ต้นทางในแพ็กเกจนั้นเสมอ
ระบบจะค้นพบเป้าหมายในระหว่างระยะโหลด ในระหว่างระยะการวิเคราะห์ ระบบจะเชื่อมโยงเป้าหมายกับการกำหนดค่าการสร้างเพื่อสร้างเป้าหมายที่กำหนดค่าไว้
กราฟเป้าหมาย
กราฟในหน่วยความจำของเป้าหมายและรายการที่เกี่ยวข้อง สร้างขึ้นในระหว่างระยะการโหลด และใช้เป็นแหล่งข้อมูลในระยะการวิเคราะห์
รูปแบบเป้าหมาย
วิธีระบุกลุ่มเป้าหมายในบรรทัดคำสั่ง รูปแบบที่ใช้บ่อยคือ :all (เป้าหมายของกฎทั้งหมด), :* (กฎทั้งหมด + เป้าหมายไฟล์), ... (แพ็กเกจปัจจุบันและแพ็กเกจย่อยทั้งหมดที่เกิดซ้ำ) ใช้ร่วมกันได้ เช่น //...:* หมายถึงเป้าหมายกฎและไฟล์ทั้งหมดในแพ็กเกจทั้งหมดแบบย้อนกลับจากรูทของ workspace
การทดสอบ
กฎเป้าหมายที่สร้างอินสแตนซ์จากกฎทดสอบ จึงมีไฟล์ปฏิบัติการทดสอบ โค้ดผลลัพธ์ที่มีค่าเป็น 0 หลังจากการรันไฟล์เสร็จสมบูรณ์หมายความว่าการทดสอบสำเร็จ สัญญาที่แน่นอนระหว่าง Bazel กับการทดสอบ (เช่น ตัวแปรสภาพแวดล้อมการทดสอบ วิธีการรวบรวมผลลัพธ์การทดสอบ) จะระบุไว้ในสารานุกรมการทดสอบ
ห่วงโซ่เครื่องมือ
ชุดเครื่องมือในการสร้างเอาต์พุตสำหรับภาษาหนึ่งๆ โดยทั่วไป Toolchain จะประกอบด้วย คอมไพเลอร์ ตัวลิงก์ อินเทอร์พรีเตอร์ หรือ/และโปรแกรมวิเคราะห์โค้ด นอกจากนี้ Toolchain อาจแตกต่างกันไปตามแพลตฟอร์มด้วย กล่าวคือ คอมโพเนนต์ของ Toolchain ของคอมไพเลอร์ Unix อาจแตกต่างกันไปสำหรับเวอร์ชันของ Windows แม้ว่า Toolchain จะมีไว้สำหรับภาษาเดียวกันก็ตาม การเลือก Toolchain ที่เหมาะสมสำหรับแพลตฟอร์มเรียกว่าความละเอียด Toolchain
เป้าหมายระดับบนสุด
เป้าหมายการสร้างจะเป็นระดับบนสุดหากมีการขอในบรรทัดคำสั่ง Bazel ตัวอย่างเช่น หาก //:foo ขึ้นอยู่กับ //:bar และมีการเรียกใช้ bazel build //:foo การสร้างครั้งนี้ //:foo จะเป็นระดับบนสุดและ //:bar จะไม่ได้เป็นระดับบนสุด แม้ว่าจะต้องสร้างทั้ง 2 เป้าหมายก็ตาม ความแตกต่างที่สําคัญระหว่างเป้าหมายระดับบนสุดกับเป้าหมายที่ไม่ใช่ระดับบนสุดคือFlag ของคําสั่งที่ตั้งค่าในบรรทัดคําสั่งของ Bazel (หรือผ่าน .bazelrc) จะตั้งค่าการกําหนดค่าสําหรับเป้าหมายระดับบนสุด แต่อาจแก้ไขโดยการเปลี่ยนสําหรับเป้าหมายที่ไม่ใช่ระดับบนสุด
ทรานซิชัน
การแมปสถานะการกําหนดค่าจากค่าหนึ่งไปยังอีกค่าหนึ่ง เปิดใช้เป้าหมายในกราฟบิลด์เพื่อให้มีการกำหนดค่าที่ต่างกัน แม้ว่าจะสร้างอินสแตนซ์จากกฎเดียวกันก็ตาม การใช้งานโดยทั่วไปของการเปลี่ยนคือกับการเปลี่ยนแบบแยก โดยจะมีการแยกบางส่วนของกราฟเป้าหมายด้วยการกำหนดค่าที่แตกต่างกันสำหรับแยกแต่ละอัน ตัวอย่างเช่น หนึ่งสามารถสร้าง Android APK ที่มีไบนารีดั้งเดิมที่คอมไพล์สำหรับ ARM และ x86 โดยใช้การเปลี่ยนแบบแยกในบิลด์เดียว
ดูเพิ่มเติมที่ การเปลี่ยนที่ผู้ใช้กำหนด
อาร์ติแฟกต์ต้นไม้
อาร์ติแฟกต์ที่แสดงถึงคอลเล็กชันไฟล์ เนื่องจากไฟล์เหล่านี้ไม่ใช่อาร์ติแฟกต์เอง การดำเนินการที่ดำเนินการในไฟล์จึงต้องลงทะเบียนอาร์ติแฟกต์ต้นไม้เป็นอินพุตหรือเอาต์พุตแทน
ระดับการแชร์
กลไก 1 ใน 2 วิธีในการป้องกันทรัพยากร Dependency ที่ไม่ต้องการในระบบบิลด์ ได้แก่ การเปิดเผยเป้าหมายเพื่อควบคุมว่าเป้าหมายอื่นๆ จะพึ่งพาเป้าหมายได้หรือไม่ และการโหลดการเปิดเผยสำหรับควบคุมว่าไฟล์ BUILD หรือ .bzl จะสามารถโหลดไฟล์ .bzl ที่ระบุได้หรือไม่ หากไม่มีบริบท "การแสดงผล" มักจะหมายถึงการแสดงผลเป้าหมาย
โปรดดูข้อมูลเพิ่มเติมที่ เอกสารประกอบระดับการเข้าถึง
Workspace
สภาพแวดล้อมที่คำสั่ง Bazel ทั้งหมดใช้ร่วมกันจะทำงานจากที่เก็บข้อมูลหลักเดียวกัน
โปรดทราบว่าที่ผ่านมาแนวคิดของ "ที่เก็บ" และ "พื้นที่ทำงาน" จะรวมอยู่ด้วยกัน คำว่า "พื้นที่ทำงาน" มักใช้เพื่ออ้างถึงที่เก็บหลัก และบางครั้งยังใช้เป็นคำพ้องความหมายของ "ที่เก็บ" ด้วย คุณควรหลีกเลี่ยงการใช้คำดังกล่าวเพื่อความชัดเจน