JS `Monorepo` `Turborepo` / `Nx` 的远程缓存与分布式构建加速

各位观众老爷们，大家好！今天咱们来聊聊Monorepo这玩意儿，以及它的小伙伴们：Turborepo和Nx，特别是它们在远程缓存和分布式构建加速方面的骚操作。

说起Monorepo，有些人可能觉得是“大而全”，有些人觉得是“臃肿不堪”，但不得不承认，它确实能解决一些实际问题，尤其是在大型项目中。想象一下，你手头有十几个甚至几十个项目，它们之间互相依赖，每次修改都要跑一遍所有的构建和测试，那酸爽……简直就像便秘一样。

这时候，Monorepo搭配Turborepo或者Nx就成了救星。它们的核心思想就是“只构建需要构建的，只测试需要测试的”。这听起来很美好，但具体怎么实现呢？这就是咱们今天要重点讨论的：远程缓存和分布式构建。

一、Monorepo、Turborepo、Nx：铁三角的爱恨情仇

首先，咱们简单捋一下这三者的关系：

Monorepo: 是一种代码管理方式，把多个项目放在同一个代码仓库里。
Turborepo: 是一个专门为Monorepo设计的构建工具，特点是速度快，支持远程缓存。
Nx: 也是一个Monorepo构建工具，功能更丰富，除了构建，还包括代码生成、依赖分析等等，也支持远程缓存。

你可以把Monorepo想象成一个大家庭，Turborepo和Nx就是这个家庭里的管家，负责管理家务，让大家生活更舒适。

那么，为什么我们需要远程缓存和分布式构建呢？

远程缓存: 避免重复构建。如果某个模块的代码没有改变，那么它的构建结果就可以直接从缓存中拿来用，省时省力。
分布式构建: 把构建任务分配到多台机器上并行执行，大幅缩短构建时间。

举个例子，你家有十个房间，每个房间都需要打扫。如果没有缓存，每次打扫都要把所有房间都扫一遍。有了缓存，如果某个房间昨天刚打扫过，今天就可以直接跳过。如果只有你一个人打扫，速度肯定慢。如果找来十个保姆一起打扫，速度就快多了。这就是远程缓存和分布式构建的威力。

二、远程缓存：让构建“偷懒”的魔法

远程缓存的核心思想是：“如果代码没变，构建结果就没必要重新生成。” 这就像你做饭一样，如果食材没变，菜谱没变，做出来的菜肯定还是一样的，没必要每次都从头开始做。

Turborepo和Nx都支持远程缓存，但实现方式略有不同。

1. Turborepo的远程缓存

Turborepo的远程缓存默认使用.turbo/目录作为本地缓存。要使用远程缓存，你需要配置一个远程存储后端，比如：

Turborepo Cloud: Turborepo官方提供的云服务，需要付费。
AWS S3: 亚马逊的云存储服务。
Google Cloud Storage (GCS): 谷歌的云存储服务。
Azure Blob Storage: 微软的云存储服务。
Self-hosted Redis: 自己搭建的Redis服务器。

以配置AWS S3为例，你需要设置以下环境变量：

TURBO_REMOTE_ONLY=1 # 只使用远程缓存
TURBO_TEAM=your-team-id # 你的Turborepo团队ID
AWS_ACCESS_KEY_ID=your-access-key-id
AWS_SECRET_ACCESS_KEY=your-secret-access-key
AWS_REGION=your-aws-region
TURBO_STORAGE=s3
TURBO_STORAGE_BUCKET=your-s3-bucket-name
TURBO_STORAGE_PATH=turbo # 可选，用于指定S3 bucket中的路径

然后在turbo.json文件中配置：

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

dependsOn: 指定任务的依赖关系。例如，build任务依赖于^build，表示依赖于所有依赖项目的build任务。
outputs: 指定任务的输出文件或目录。Turborepo会根据这些输出文件生成缓存Key。
inputs: 指定任务的输入文件或目录。Turborepo会监控这些文件的变化，如果发生变化，就会重新构建。

当你运行turbo run build时，Turborepo会：

检查当前任务的输入文件是否发生变化。
如果输入文件没有变化，就从远程缓存中查找对应的构建结果。
如果找到了，就直接使用缓存结果，跳过构建步骤。
如果没有找到，就执行构建步骤，并将构建结果上传到远程缓存。

代码示例 (package.json):

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

2. Nx的远程缓存

Nx的远程缓存机制类似，也支持多种存储后端，包括：

Nx Cloud: Nx官方提供的云服务，也需要付费。
AWS S3: 和Turborepo一样。
Google Cloud Storage (GCS): 和Turborepo一样。
Azure Blob Storage: 和Turborepo一样。
Self-hosted Nx Agent: 自己搭建的Nx Agent服务器。

配置方式也类似，需要在nx.json文件中配置：

{
  "tasksRunnerOptions": {
    "default": {
      "runner": "nx-cloud",
      "options": {
        "cacheableOperations": ["build", "test", "lint"],
        "accessToken": "your-nx-cloud-access-token"
      }
    }
  },
  "affected": {
    "defaultBase": "main"
  }
}

cacheableOperations: 指定哪些任务可以被缓存。
accessToken: Nx Cloud的Access Token。

Nx的缓存Key生成策略更灵活，可以根据任务的输入文件、命令参数、环境变量等生成缓存Key。

代码示例 (nx.json):

{
  "npmScope": "my-org",
  "affected": {
    "defaultBase": "main"
  },
  "implicitDependencies": {
    "package.json": {
      "dependencies": "*",
      "devDependencies": "*"
    },
    ".eslintrc.json": "*"
  },
  "tasksRunnerOptions": {
    "default": {
      "runner": "nx-cloud",
      "options": {
        "cacheableOperations": ["build", "test", "lint"],
        "accessToken": "your-nx-cloud-access-token"
      }
    }
  },
  "targetDependencies": {
    "build": [
      {
        "target": "lint",
        "projects": "dependencies"
      }
    ]
  },
  "namedInputs": {
    "default": ["{projectRoot}/**/*", "sharedGlobals"],
    "production": [
      "default",
      "!{projectRoot}/**/?(*.)+(spec|test).[jt]s?(x)?(.snap)",
      "!{projectRoot}/tsconfig.spec.json",
      "!{projectRoot}/karma.conf.js"
    ],
    "sharedGlobals": []
  },
  "generators": {
    "@nrwl/react": {
      "application": {
        "style": "css",
        "linter": "eslint",
        "bundler": "webpack",
        "strict": true,
        "projectNameAndRootFormat": "as-provided"
      },
      "component": {
        "style": "css"
      },
      "library": {
        "strict": true,
        "projectNameAndRootFormat": "as-provided"
      }
    }
  }
}

总结一下，远程缓存的步骤：

配置远程存储后端 (Turborepo Cloud, AWS S3, GCS, Azure Blob Storage, Redis, Nx Cloud, Nx Agent)。
配置构建工具 (Turborepo, Nx) 的缓存选项。
运行构建命令。
构建工具会自动检查缓存，并上传/下载缓存结果。

三、分布式构建：众人拾柴火焰高

分布式构建的核心思想是：“把构建任务分配到多台机器上并行执行。” 这就像你盖房子一样，如果只有你一个人搬砖，速度肯定慢。如果找来十个工人一起搬砖，速度就快多了。

Turborepo和Nx都支持分布式构建，但实现方式也略有不同。

1. Turborepo的分布式构建

Turborepo的分布式构建主要依赖于Turborepo Cloud。当你使用Turborepo Cloud时，Turborepo会自动将构建任务分配到多个云服务器上并行执行。你不需要手动配置任何东西。

2. Nx的分布式构建

Nx的分布式构建可以通过Nx Cloud或者Nx Agent来实现。

Nx Cloud: Nx Cloud会自动将构建任务分配到多个云服务器上并行执行。
Nx Agent: 你可以自己搭建Nx Agent服务器，然后让Nx将构建任务分配到这些Agent服务器上并行执行。

使用Nx Agent需要进行一些额外的配置：

安装Nx Agent: 在每台机器上安装Nx Agent。

npm install -g @nrwl/nx-cloud
nx-cloud agent start

配置Nx Cloud连接: 在Nx Cloud中配置Nx Agent连接。
运行构建命令: Nx会自动将构建任务分配到可用的Nx Agent上并行执行。

代码示例 (使用 Nx Cloud):

nx run your-project:build --parallel=10 # 使用10个并行进程

总结一下，分布式构建的步骤：

选择分布式构建方案 (Turborepo Cloud, Nx Cloud, Nx Agent)。
配置分布式构建方案。
运行构建命令，并指定并行进程数。
构建工具会自动将构建任务分配到多台机器上并行执行。

四、实战演练：手把手教你加速构建

说了这么多理论，咱们来点实际的。假设我们有一个简单的Monorepo项目，包含两个packages：package-a和package-b，package-b依赖于package-a。

1. 创建Monorepo项目

mkdir my-monorepo
cd my-monorepo
npm init -y
npm install -D turbo
mkdir packages apps
cd packages
mkdir package-a package-b
cd ../..
touch turbo.json

2. 配置turbo.json

{
  "pipeline": {
    "build": {
      "dependsOn": ["^build"],
      "outputs": ["dist/**"]
    },
    "test": {
      "dependsOn": ["build"],
      "inputs": ["src/**/*.ts", "src/**/*.tsx", "test/**/*.ts", "test/**/*.tsx"]
    },
    "lint": {}
  }
}

3. 初始化package-a和package-b

cd packages/package-a
npm init -y
echo "console.log('Hello from package-a');" > index.js
cd ../package-b
npm init -y
npm install ../package-a
echo "import { hello } from 'package-a'; console.log('Hello from package-b');" > index.js
cd ../..

4. 配置package.json

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

5. 启用远程缓存 (以AWS S3为例)

export TURBO_REMOTE_ONLY=1
export TURBO_TEAM=your-team-id
export AWS_ACCESS_KEY_ID=your-access-key-id
export AWS_SECRET_ACCESS_KEY=your-secret-access-key
export AWS_REGION=your-aws-region
export TURBO_STORAGE=s3
export TURBO_STORAGE_BUCKET=your-s3-bucket-name
export TURBO_STORAGE_PATH=turbo

6. 运行构建命令

npm run build

第一次运行会比较慢，因为需要构建所有模块并上传到远程缓存。第二次运行就会快很多，因为可以直接从远程缓存中获取构建结果。

五、注意事项：坑爹的地方也要小心

虽然远程缓存和分布式构建很美好，但也有一些需要注意的地方：

缓存失效: 如果构建配置发生变化 (例如，升级了依赖包)，缓存可能会失效，需要重新构建。
缓存污染: 如果构建过程中产生了不确定的结果 (例如，使用了随机数)，缓存可能会被污染，导致构建结果不一致。
网络问题: 远程缓存依赖于网络连接，如果网络不稳定，可能会影响构建速度。
成本问题: 使用云服务 (Turborepo Cloud, Nx Cloud, AWS S3, GCS, Azure Blob Storage) 需要付费。

六、总结：工欲善其事，必先利其器

Monorepo是一种强大的代码管理方式，但需要合适的工具才能发挥其优势。Turborepo和Nx是优秀的Monorepo构建工具，它们通过远程缓存和分布式构建加速构建过程，提高开发效率。

当然，选择哪个工具取决于你的具体需求和偏好。Turborepo更轻量级，上手简单，适合小型项目。Nx功能更丰富，适合大型项目。

希望今天的讲座能对你有所帮助。记住，技术是为人类服务的，选择最适合你的工具，让你的开发工作更轻松愉快！

最后，感谢各位观众老爷的耐心观看，下次再见！

发表回复 取消回复

发表回复取消回复