Abstract:

This video serves as a beginner-friendly guide to Bazel, an open-source build tool by Google, from the perspective of someone new to programming. It aims to demystify Bazel's core concepts by walking through the creation of a simple project. The tutorial covers setting up a Bazel workspace and build file, defining custom build rules, managing inputs and outputs to leverage Bazel's efficient change detection, and integrating external tools for hermetic and cross-platform builds. The video culminates in demonstrating how to replace platform-specific commands with a custom Python script, highlighting Bazel's power in creating reproducible and portable build environments.

Summarizing Bazel Basics: Building Custom Rules and Hermetic Environments

• 0:00 Introduction to Bazel: The speaker introduces Bazel, an open-source build tool by Google, and shares his experience learning it without a strong programming background.
• 0:44 Video Goals: The tutorial will cover creating a simple Bazel project, defining basic build actions with inputs and outputs, leveraging Bazel's change detection, and integrating external tools for cross-platform builds.
• 1:41 Project Setup: To begin, the bazel.exe executable is placed directly in the project. A WORKSPACE file (project root) and a BUILD file (defines build actions) are created.
• 2:57 Running Basic Bazel Command: The command bazel build //:all is used to build all targets in the root package, which initially analyzes zero targets. This action creates Bazel's output folders (bazel-bin, bazel-out).
• 4:29 Creating a Custom Rule: A new file, my_custom_rule.bzl, is created to define a custom rule named write_new_file and its _impl function. Rules describe how a build is performed and what files to watch.
• 7:19 Loading and Using the Custom Rule: The BUILD file uses load("//:my_custom_rule.bzl", "write_new_file") to import the rule, then creates a build action named write_my_custom_message_into_file using it.
• 10:40 Defining Rule Attributes (Inputs/Outputs): The write_new_file rule is enhanced with attributes to accept my_input_file (a label for a single file) and out_file_name (a string for the output file's name).
• 13:00 Declaring Output File: Inside the rule's implementation, ctx.actions.declare_file() is used to define the output file based on out_file_name.
• 18:13 Running an Action: ctx.actions.run() is added to perform the actual build task. It specifies the output_file, uses cmd.exe as the executable, and constructs arguments to copy the input_file content to the output_file.
• 22:22 Essential Rule Return Value: For Bazel to correctly process the output, the rule's _impl function must return DefaultInfo(files=depset([output_file])).
• 25:15 Enabling Change Detection: To leverage Bazel's caching and only rebuild when necessary, inputs=[ctx.file.my_input_file] must be explicitly added to ctx.actions.run(). This tells Bazel to monitor the input file for changes.
• 29:03 Rule Reusability: The video demonstrates creating multiple build actions from the same custom rule, each producing a different output, showcasing the rule's reusability.
• 31:00 Achieving Hermetic Builds: To eliminate platform-specific dependencies (like cmd.exe), rules_python is integrated into the WORKSPACE file, providing a portable Python interpreter.
• 35:10 Custom Python Build Tool: A my_build_tool.py script is created (which converts input text to uppercase) and defined as a py_binary target in BUILD.
• 41:43 Integrating Python Tool into Rule: A new rule, write_new_file_with_custom_tool, is created. It takes the py_binary target (my_build_tool) as an executable attribute, making the build hermetic.
• 45:10 Dynamic Executable and Arguments: The ctx.actions.run() in the new rule uses ctx.executable.my_custom_build_tool as the executable and passes the input and output file paths as arguments to the Python script.
• 46:00 Key Takeaway: Hermeticity: The build now uses a self-contained Python environment, ensuring it's reproducible and portable across different operating systems.
• 47:50 Debugging with bazel action query: The bazel action query command is introduced as a powerful debugging tool to inspect the exact command line Bazel executes for a given action.