发布于 由admin

JS `Monorepo` `Bazel` / `Pants`：构建系统中的远程执行与缓存

咳咳，大家好！今天咱们来聊聊 Monorepo、Bazel/Pants 这几个家伙，以及它们在构建系统里如何玩转远程执行和缓存。这可是提升大型项目构建效率的秘密武器，能让你告别“编译一时爽，等待火葬场”的痛苦。

Monorepo：把鸡蛋放一个篮子里？

首先，啥是 Monorepo？简单来说，就是把所有项目（前端、后端、移动端等等）的代码都放在一个大的代码仓库里。这和传统的 Multi-repo 模式（每个项目一个仓库）正好相反。

  • 优点：

    • 代码共享更容易： 模块之间可以无缝引用，避免重复造轮子。
    • 依赖管理更简单： 所有项目都使用统一的版本，减少依赖冲突。
    • 原子性变更： 可以一次性修改多个项目，保证一致性。
    • 代码可见性好： 所有代码都在一个地方，方便搜索和浏览。
    • 重构更容易：全局重构更方便快捷。

  • 缺点：

    • 代码库庞大： 可能会导致仓库体积过大，影响 clone 和 checkout 速度。
    • 权限管理复杂： 需要更精细的权限控制，避免误操作。
    • 构建速度慢： 如果构建系统不给力，全量构建会非常耗时。

Bazel 和 Pants：构建界的扛把子

既然 Monorepo 带来了构建速度的挑战，就需要更强大的构建系统来解决。Bazel 和 Pants 就是其中的佼佼者。它们都具有以下特点：

  • 声明式构建： 使用 BUILD 文件描述构建规则，而不是编写复杂的脚本。
  • 可复现构建： 保证在任何环境下构建结果都一致。
  • 增量构建： 只重新构建修改过的部分，大幅提升构建速度。
  • 远程缓存： 将构建结果缓存起来，供其他开发者或 CI 系统使用。
  • 远程执行： 将构建任务分发到远程服务器上执行，充分利用计算资源。

Bazel vs. Pants：谁更胜一筹？

这两个工具都是优秀的构建系统，选择哪个取决于你的具体需求和偏好。

特性 Bazel Pants
社区活跃度 非常活跃，Google 支持 活跃，但社区规模相对较小
语言支持 广泛，原生支持 Java, C++, Python, Go 等 广泛，特别是 Python 和 JVM 系语言
配置复杂性 较高，需要学习 BUILD 文件的语法和概念 较低，配置更简洁，学习曲线更平缓
插件生态 丰富，有很多第三方插件 较少，但可以自定义插件
适用场景 大型项目，对性能要求高的项目 中小型项目，对易用性要求高的项目
学习曲线 陡峭 相对平缓
默认远程缓存 不支持，需要配置外部缓存服务 支持，配置简单

远程执行与缓存：加速 Monorepo 构建的法宝

现在，我们来重点聊聊远程执行和缓存。这可是 Monorepo 构建提速的关键。

1. 远程缓存 (Remote Caching)

  • 原理： 构建系统会将构建结果（例如编译后的代码、打包后的文件等）存储在一个远程缓存服务器上。当其他开发者或 CI 系统需要构建相同的目标时，可以直接从缓存中获取结果，而无需重新构建。
  • 优点：
    • 节省时间： 避免重复构建，大幅缩短构建时间。
    • 节省资源： 减少本地 CPU 和内存的使用。
    • 提高一致性： 保证所有开发者和 CI 系统使用相同的构建结果。
  • 配置：
    • Bazel： 需要配置一个外部的缓存服务，例如 Google Cloud Storage, AWS S3, Artifactory 等。
    • Pants： 内置了对远程缓存的支持，可以轻松配置。

Bazel 远程缓存配置示例：

# .bazelrc
build --remote_cache=grpc://your-cache-server:9090

Pants 远程缓存配置示例：

# pants.toml
[GLOBAL]
remote_cache_read = true
remote_cache_write = true
remote_cache_service = "your-cache-server:9090"

2. 远程执行 (Remote Execution)

  • 原理： 将构建任务分发到远程服务器上执行。远程服务器拥有更强大的计算资源，可以并行执行多个构建任务，从而加速构建过程。
  • 优点：
    • 加速构建： 充分利用计算资源，缩短构建时间。
    • 减轻本地负担： 将构建任务转移到远程服务器，减轻本地 CPU 和内存的压力。
    • 提高可扩展性： 可以根据需要增加远程服务器的数量，提高构建能力。
  • 配置：
    • Bazel： 需要配置一个远程执行服务，例如 Google Cloud Build, Buildbarn 等。
    • Pants： 也支持远程执行，但配置相对复杂。

Bazel 远程执行配置示例：

# .bazelrc
build --remote_execution_properties=exec_properties:{...}
build --remote_executor=grpc://your-execution-server:9090

代码示例：使用 Bazel 构建一个简单的 JavaScript 项目

  1. 项目结构：

    my-js-project/
├── BUILD
├── index.html
└── src
    ├── index.js
    └── utils.js

  2. BUILD 文件：

    # my-js-project/BUILD
load("@build_bazel_rules_nodejs//:index.bzl", "nodejs_binary", "npm_install")

npm_install(
    name = "npm",
    package_json = "package.json",
    package_lock_json = "package-lock.json",
)

nodejs_binary(
    name = "my-app",
    entry_point = "src/index.js",
    data = [
        "index.html",
        "src/utils.js",
        "@npm//:browserify", # 假设使用了 browserify 打包
    ],
    node_modules = "@npm//:node_modules",
    output_name = "bundle.js",
)

  3. index.html：

    <!DOCTYPE html>
<html>
<head>
    <title>My JS App</title>
</head>
<body>
    <script src="bundle.js"></script>
</body>
</html>

  4. src/index.js：

    import { greet } from './utils.js';

console.log(greet('World'));

  5. src/utils.js：

    export function greet(name) {
    return `Hello, ${name}!`;
}

  6. 构建命令：

    bazel build //:my-app

代码示例：使用 Pants 构建一个简单的 Python 项目

  1. 项目结构：

    my-python-project/
├── BUILD
├── my_module
│   ├── __init__.py
│   └── greet.py
└── main.py

  2. BUILD 文件 (my-python-project/BUILD):

    # my-python-project/BUILD
python_sources(
    name="my_module_sources",
    sources=["my_module/*.py"],
)

python_library(
    name="my_module",
    sources=[":my_module_sources"],
)

python_source(
    name="main",
    source="main.py",
    dependencies=[":my_module"],
)

pex_binary(
    name="my_app",
    entry_point="main.py",
    dependencies=[":main"],
)

  3. my_module/__init__.py：

    # my-python-project/my_module/__init__.py
from .greet import greet

  4. my_module/greet.py：

    # my-python-project/my_module/greet.py
def greet(name):
    return f"Hello, {name}!"

  5. main.py：

    # my-python-project/main.py
from my_module import greet

if __name__ == "__main__":
    print(greet("World"))

  6. 构建命令：

    ./pants package my_app

JS Monorepo 的特殊性：

JavaScript Monorepo 和其他语言的 Monorepo 有一些特殊之处，主要体现在依赖管理和构建工具上。

  • 依赖管理： JavaScript 项目通常使用 npm 或 yarn 进行依赖管理。在 Monorepo 中，可以使用 workspaces 来管理多个 package 的依赖。
  • 构建工具： 除了 Bazel 和 Pants，还有一些专门为 JavaScript Monorepo 设计的构建工具，例如 Lerna, Turborepo, Nx 等。这些工具通常集成了依赖管理、版本控制、构建优化等功能。

JavaScript Monorepo 示例 (使用 Turborepo):

  1. 项目结构：

    my-js-monorepo/
├── apps
│   ├── web
│   │   ├── package.json
│   │   └── src
│   │       └── index.js
│   └── mobile
│       ├── package.json
│       └── src
│           └── index.js
├── packages
│   └── ui
│       ├── package.json
│       └── src
│           └── button.js
├── package.json
└── turbo.json

  2. turbo.json：

    {
  "pipeline": {
    "build": {
      "dependsOn": ["^build"],
      "outputs": ["dist/**", ".next/**"]
    },
    "test": {
      "dependsOn": ["build"]
    },
    "lint": {}
  }
}

  3. package.json (根目录)：

    {
  "name": "my-js-monorepo",
  "private": true,
  "workspaces": [
    "apps/*",
    "packages/*"
  ],
  "scripts": {
    "build": "turbo run build",
    "test": "turbo run test",
    "lint": "turbo run lint"
  },
  "devDependencies": {
    "turbo": "^1.10.16"
  }
}

在这个例子中，turbo.json 定义了构建流程，package.json 使用 workspaces 管理多个 package，Turborepo 会根据依赖关系并行构建和测试项目。

总结：

Monorepo 是一种强大的代码管理方式，但需要强大的构建系统来支撑。Bazel 和 Pants 都是优秀的构建系统，它们通过远程执行和缓存等技术，可以大幅提升 Monorepo 的构建效率。对于 JavaScript Monorepo，还可以选择 Lerna, Turborepo, Nx 等专门的工具。

选择合适的构建系统取决于你的具体需求和偏好。如果你需要高度定制化的构建流程和强大的性能，可以选择 Bazel。如果你更注重易用性和快速上手，可以选择 Pants 或 Turborepo。

希望今天的分享能帮助大家更好地理解 Monorepo 和构建系统，并在实际项目中应用这些技术，提升开发效率。 下课！

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注