Modernize for Bzlmod / Bazel 8.0 / modern kubebuilder

- Make compatible with Bzlmod - WORKSPACE is unsupported in Bazel 9.
- Add support for arm64.

Author: telotortium

BUILD.bazel

@@ -1,21 +1,15 @@
-load("@rules_pkg//:pkg.bzl", "pkg_tar")
 load("@rules_kubebuilder//kubebuilder:def.bzl", "kubebuilder")
+load("@rules_pkg//:pkg.bzl", "pkg_tar")
 
 pkg_tar(
     name = "release",
     srcs = glob([
         "*.bazel",
-        "*.bzl",
     ]) + [
         "WORKSPACE",
     ],
     extension = "tar.gz",
     package_dir = "rules_kubebuilder",
-    deps = [
-        "//controller-gen:release",
-        "//kubebuilder:release",
-        "//kustomize:release",
-    ],
 )
 
 # This is just an example of how to run kubebuilder via bazel

MODULE.bazel

@@ -0,0 +1,50 @@
+###############################################################################
+# Bazel now uses Bzlmod by default to manage external dependencies.
+# Please consider migrating your external dependencies from WORKSPACE to MODULE.bazel.
+#
+# For more details, please check https://github.com/bazelbuild/bazel/issues/18958
+###############################################################################
+
+module(
+    name = "rules_kubebuilder",
+    version = "0.1.0",
+)
+
+# Keep consistent with https://github.com/openai/openai/blob/master/MODULE.bazel
+bazel_dep(name = "platforms", version = "1.0.0")
+bazel_dep(name = "rules_go", version = "0.55.1")
+bazel_dep(name = "rules_pkg", version = "1.0.1")
+
+# Create controller-gen and kustomize repos via local extensions so that
+# this module can reference them from its packages (toolchains).
+cg = use_extension("@rules_kubebuilder//controller-gen:extensions.bzl", "cg_ext")
+cg.controller_gen(
+    arches = [
+        "amd64",
+        "arm64",
+    ],
+    version = "0.17.1",
+)  # create controller_gen_<os>_<arch>
+use_repo(
+    cg,
+    "controller_gen_darwin_amd64",
+    "controller_gen_darwin_arm64",
+    "controller_gen_linux_amd64",
+    "controller_gen_linux_arm64",
+)
+
+kz = use_extension("@rules_kubebuilder//kustomize:extensions.bzl", "kz_ext")
+kz.kustomize(
+    arches = [
+        "amd64",
+        "arm64",
+    ],
+    version = "5.7.1",
+)  # create kustomize_<os>_<arch>
+use_repo(
+    kz,
+    "kustomize_darwin_amd64",
+    "kustomize_darwin_arm64",
+    "kustomize_linux_amd64",
+    "kustomize_linux_arm64",
+)

MODULE.bazel.lock

@@ -18,14 +18,72 @@ load("@rules_kubebuilder//kubebuilder:sdk.bzl", "kubebuilder_register_sdk")
 kubebuilder_register_sdk(version = "2.3.1")
 
 load("@rules_kubebuilder//controller-gen:deps.bzl", "controller_gen_register_toolchain")
+load("@rules_kubebuilder//kustomize:deps.bzl", "kustomize_register_toolchain")
 
-controller_gen_register_toolchain()
+# Downloads binaries from GitHub for linux/darwin and amd64/arm64 by default,
+# and registers the matching toolchains.
+controller_gen_register_toolchain(version = "0.17.1", arches = ["amd64", "arm64"])  # controller-gen
+kustomize_register_toolchain(version = "5.7.1", arches = ["amd64", "arm64"])       # kustomize
+```
 
-load("@rules_kubebuilder//kustomize:deps.bzl", "kustomize_register_toolchain")
+## Using with Bzlmod (MODULE.bazel)
+
+With Bzlmod, repository creation and toolchain registration must be separated:
+
+- Module extensions may create external repositories but may not call `register_toolchains()`.
+- Toolchains must be registered in the root `MODULE.bazel` via the `register_toolchains(...)` directive.
+
+This repo provides module extensions to download the Kubebuilder SDK, controller-gen, and kustomize. Register the toolchains directly using labels from this repo.
+
+Example `MODULE.bazel` snippet:
+
+```starlark
+module(name = "your_module")
+
+bazel_dep(name = "rules_kubebuilder", version = "0.1.0")
+
+# Create the SDK repo(s) via the module extension
+kb = use_extension("@rules_kubebuilder//kubebuilder:extensions.bzl", "kb_ext")
+kb.kubebuilder_sdk(name = "kubebuilder_sdk_4_7_1", version = "4.7.1")
+use_repo(kb, "kubebuilder_sdk_4_7_1")
+
+# Download controller-gen binaries for both arches
+cg = use_extension("@rules_kubebuilder//controller-gen:extensions.bzl", "cg_ext")
+cg.controller_gen(version = "0.17.1", arches = ["amd64", "arm64"])  # creates repos named controller_gen_<os>_<arch>
+use_repo(cg,
+  "controller_gen_linux_amd64",
+  "controller_gen_linux_arm64",
+  "controller_gen_darwin_amd64",
+  "controller_gen_darwin_arm64",
+)
+
+# Download kustomize binaries for both arches
+kz = use_extension("@rules_kubebuilder//kustomize:extensions.bzl", "kz_ext")
+kz.kustomize(version = "5.7.1", arches = ["amd64", "arm64"])  # creates repos named kustomize_<os>_<arch>
+use_repo(kz,
+  "kustomize_linux_amd64",
+  "kustomize_linux_arm64",
+  "kustomize_darwin_amd64",
+  "kustomize_darwin_arm64",
+)
 
-kustomize_register_toolchain()
+# Register toolchains at the root (don’t do this from an extension)
+register_toolchains(
+    # controller-gen
+    "@rules_kubebuilder//controller-gen:controller_gen_linux_amd64_toolchain",
+    "@rules_kubebuilder//controller-gen:controller_gen_linux_arm64_toolchain",
+    "@rules_kubebuilder//controller-gen:controller_gen_darwin_amd64_toolchain",
+    "@rules_kubebuilder//controller-gen:controller_gen_darwin_arm64_toolchain",
+    # kustomize
+    "@rules_kubebuilder//kustomize:kustomize_linux_amd64_toolchain",
+    "@rules_kubebuilder//kustomize:kustomize_linux_arm64_toolchain",
+    "@rules_kubebuilder//kustomize:kustomize_darwin_amd64_toolchain",
+    "@rules_kubebuilder//kustomize:kustomize_darwin_arm64_toolchain",
+)
 ```
 
+Note: The macros in `controller-gen/deps.bzl` and `kustomize/deps.bzl` call `native.register_toolchains(...)` and are intended for WORKSPACE-based setups. Do not call these macros from a module extension.
+
 And in your `go_test()` files, add `etcd` as a data dependency like this:
 
 ```starlark
@@ -64,7 +122,7 @@ bazel run //:kubebuilder -- --help
 In order to use `controller-gen` you will need to do something like the following in your `api/v1alpha1` directory (essentially where the `*_type.go` files are):
 
 ```starlark
-load("@io_bazel_rules_go//go:def.bzl", "go_library")
+load("@rules_go//go:def.bzl", "go_library")
 load(
     "@rules_kubebuilder//controller-gen:controller-gen.bzl",
     "controller_gen_crd",
@@ -121,14 +179,7 @@ controller_gen_crd(
 
 ## Developers
 
-The toolchain that describes `controller-gen` needs to be built and the binaries committed so that
-they can be used. Fortunately Go supports cross compiling so in order to build the controller, you'll
-need to get and install Go either from [their download page](https://golang.org/doc/install) or from
-homebrew by running
-
-```shell
-brew install golang
-```
-
-After that you can run the script in `scripts/build-controller-gen.sh` which will compile `controller-gen`
-for both Linux and macOS.
+Previously this repo committed prebuilt binaries for controller-gen and kustomize.
+This has been replaced with repository rules that download the official release
+artifacts from GitHub at fetch time. No binaries are stored in Git, and arm64
+is supported alongside amd64.

README.md

@@ -22,15 +22,15 @@ load("@rules_pkg//:deps.bzl", "rules_pkg_dependencies")
 rules_pkg_dependencies()
 
 http_archive(
-    name = "io_bazel_rules_go",
+    name = "rules_go",
     sha256 = "b4433651f57560237681cb9caa969106aba614f5b1e66fefa5834c42b8013b42",
     urls = [
         "https://mirror.bazel.build/github.com/bazelbuild/rules_go/releases/download/v0.24.6/rules_go-v0.24.6.tar.gz",
         "https://github.com/bazelbuild/rules_go/releases/download/v0.24.6/rules_go-v0.24.6.tar.gz",
     ],
 )
 
-load("@io_bazel_rules_go//go:deps.bzl", "go_register_toolchains", "go_rules_dependencies")
+load("@rules_go//go:deps.bzl", "go_register_toolchains", "go_rules_dependencies")
 
 go_rules_dependencies()
 

WORKSPACE

@@ -1,13 +1,4 @@
 load("@rules_kubebuilder//controller-gen:controller-gen-toolchain.bzl", "controller_gen_toolchain")
-load("@rules_pkg//:pkg.bzl", "pkg_tar")
-
-exports_files(
-    [
-        "bin/controller-gen.linux",
-        "bin/controller-gen.darwin",
-    ],
-    visibility = ["//visibility:public"],
-)
 
 filegroup(
     name = "srcs",
@@ -18,53 +9,75 @@ filegroup(
     visibility = ["//visibility:public"],
 )
 
-pkg_tar(
-    name = "release-bin",
-    srcs = glob(["bin/*"]),
-    package_dir = "/bin",
+toolchain_type(name = "toolchain")
+
+# Toolchains reference externally fetched binaries. See deps.bzl and
+# extensions.bzl for repository creation macros.
+
+# Linux x86_64
+controller_gen_toolchain(
+    name = "controller_gen_linux_amd64",
+    controller_gen_bin = "@controller_gen_linux_amd64//:controller-gen",
 )
 
-pkg_tar(
-    name = "release",
-    srcs = [
-        "BUILD.bazel",
-        ":srcs",
+toolchain(
+    name = "controller_gen_linux_amd64_toolchain",
+    exec_compatible_with = [
+        "@platforms//os:linux",
+        "@platforms//cpu:x86_64",
     ],
-    package_dir = "controller-gen",
+    toolchain = ":controller_gen_linux_amd64",
+    toolchain_type = ":toolchain",
     visibility = ["//visibility:public"],
-    deps = [":release-bin"],
 )
 
-toolchain_type(name = "toolchain")
-
+# Linux arm64
 controller_gen_toolchain(
-    name = "controller_gen_linux",
-    controller_gen_bin = "@rules_kubebuilder//controller-gen:bin/controller-gen.linux",
+    name = "controller_gen_linux_arm64",
+    controller_gen_bin = "@controller_gen_linux_arm64//:controller-gen",
 )
 
+toolchain(
+    name = "controller_gen_linux_arm64_toolchain",
+    exec_compatible_with = [
+        "@platforms//os:linux",
+        "@platforms//cpu:aarch64",
+    ],
+    toolchain = ":controller_gen_linux_arm64",
+    toolchain_type = ":toolchain",
+    visibility = ["//visibility:public"],
+)
+
+# macOS x86_64
 controller_gen_toolchain(
-    name = "controller_gen_darwin",
-    controller_gen_bin = "@rules_kubebuilder//controller-gen:bin/controller-gen.darwin",
+    name = "controller_gen_darwin_amd64",
+    controller_gen_bin = "@controller_gen_darwin_amd64//:controller-gen",
 )
 
 toolchain(
-    name = "controller_gen_linux_toolchain",
+    name = "controller_gen_darwin_amd64_toolchain",
     exec_compatible_with = [
-        "@platforms//os:linux",
+        "@platforms//os:osx",
         "@platforms//cpu:x86_64",
     ],
-    toolchain = ":controller_gen_linux",
+    toolchain = ":controller_gen_darwin_amd64",
     toolchain_type = ":toolchain",
     visibility = ["//visibility:public"],
 )
 
+# macOS arm64
+controller_gen_toolchain(
+    name = "controller_gen_darwin_arm64",
+    controller_gen_bin = "@controller_gen_darwin_arm64//:controller-gen",
+)
+
 toolchain(
-    name = "controller_gen_darwin_toolchain",
+    name = "controller_gen_darwin_arm64_toolchain",
     exec_compatible_with = [
         "@platforms//os:osx",
-        "@platforms//cpu:x86_64",
+        "@platforms//cpu:aarch64",
     ],
-    toolchain = ":controller_gen_darwin",
+    toolchain = ":controller_gen_darwin_arm64",
     toolchain_type = ":toolchain",
     visibility = ["//visibility:public"],
 )