JS `Monorepo` `Remote Caching` (`Turborepo`, `Nx`) 的分布式原理

Alright, 各位观众老爷，咱们今天唠唠 JS Monorepo 里的 Remote Caching 这事儿。保证让各位听完之后，下次面试被问到，能直接把面试官怼到墙上抠都抠不下来！

咱们今天主要聊聊 Turborepo 和 Nx 这俩明星选手，看看它们是怎么玩转 Remote Caching 的，以及这背后的分布式原理。

一、 Monorepo 的痛点：重复劳动

首先，咱们得明白 Monorepo 这玩意儿，好处是代码共享方便，依赖管理清晰，但坏处也很明显：

构建时间长： 每次构建都要重新编译所有模块，即使只有一小部分代码改动。
CI/CD 压力大： 每次提交都要跑一遍完整的 CI/CD 流程，浪费资源。

举个例子，咱们有个 Monorepo，里面有 A、B、C 三个模块。

monorepo/
├── packages/
│   ├── A/
│   │   ├── src/
│   │   │   └── index.js
│   │   ├── package.json
│   ├── B/
│   │   ├── src/
│   │   │   └── index.js
│   │   ├── package.json
│   ├── C/
│   │   ├── src/
│   │   │   └── index.js
│   │   ├── package.json
├── package.json

如果咱们只改了 A 模块的代码，但每次 CI/CD 都要重新构建 A、B、C 三个模块，这就很浪费时间。

二、 Remote Caching 的核心思想：记住结果，下次直接用

Remote Caching 就是为了解决这个问题而生的。它的核心思想很简单：

计算任务的指纹（Hash）： 根据任务的输入（代码、配置、依赖等）计算出一个唯一的指纹。
检查缓存： 在远程缓存服务器上查找是否存在相同指纹的缓存结果。
命中缓存： 如果找到缓存，直接使用缓存结果，跳过实际的构建/测试过程。
未命中缓存： 如果没有找到缓存，执行实际的构建/测试过程，并将结果存储到远程缓存服务器上。

这样，下次如果任务的输入没有变化，就可以直接从缓存中获取结果，大大节省时间和资源。

三、 Turborepo 的 Remote Caching：基于内容哈希的管道

Turborepo 的 Remote Caching 机制是基于内容哈希的管道。简单来说，它会根据每个任务的输入内容（包括代码、配置文件、依赖项等）计算出一个唯一的哈希值，然后将这个哈希值作为缓存的键。

Turborepo 使用 turbo.json 文件来定义任务和依赖关系。

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

pipeline： 定义任务管道。
build： 定义 build 任务。
- dependsOn： 依赖其他任务，^build 表示依赖当前 package 下的所有 build 任务。
- outputs： 指定 build 任务的输出目录，Turborepo 会根据这些目录的内容计算哈希值。
test： 定义 test 任务。
- dependsOn： 依赖 build 任务。
- inputs： 指定 test 任务的输入文件，Turborepo 会根据这些文件的内容计算哈希值.

Turborepo Remote Caching 的工作流程：

任务执行： Turborepo 根据 turbo.json 文件中的配置，确定需要执行的任务。
哈希计算： 对于每个任务，Turborepo 会根据任务的 inputs 和 outputs 计算出一个唯一的哈希值。
缓存查找： Turborepo 会根据计算出的哈希值，在远程缓存服务器上查找是否存在对应的缓存结果。
缓存命中： 如果找到缓存，Turborepo 会直接从缓存服务器下载缓存结果，并跳过实际的任务执行过程。
缓存未命中： 如果没有找到缓存，Turborepo 会执行实际的任务，并将任务的输出结果上传到远程缓存服务器，以便下次使用。

Turborepo 的 Remote Caching 配置：

Turborepo 支持多种远程缓存存储方式，包括：

Turborepo Cloud： 官方提供的云服务，简单易用。
Self-hosted： 可以使用 AWS S3、Google Cloud Storage 等云存储服务，或者使用 Docker 镜像自己搭建缓存服务器。

以 Turborepo Cloud 为例，只需要在 turbo.json 文件中配置 remoteOnly 选项即可启用 Remote Caching：

// turbo.json
{
  "pipeline": {
    "build": {
      "dependsOn": ["^build"],
      "outputs": [".next/**", "dist/**"]
    },
    "test": {
      "dependsOn": ["build"],
      "inputs": ["src/**/*.js", "src/**/*.ts", "test/**/*.js", "test/**/*.ts"]
    },
    "lint": {}
  },
  "remoteOnly": true // 启用 Remote Caching
}

然后，使用 turbo login 命令登录 Turborepo Cloud，就可以开始使用 Remote Caching 了。

四、 Nx 的 Remote Caching：更精细的控制

Nx 的 Remote Caching 机制更加灵活，提供了更多的配置选项，可以更精细地控制缓存行为。

Nx 使用 nx.json 文件来配置项目和任务。

// nx.json
{
  "tasksRunnerOptions": {
    "default": {
      "runner": "nx-cloud",
      "options": {
        "cacheableOperations": ["build", "test", "lint"],
        "accessToken": "YOUR_NX_CLOUD_ACCESS_TOKEN"
      }
    }
  },
  "affected": {
    "defaultBase": "main"
  },
  "targetDefaults": {
    "build": {
      "dependsOn": ["^build"],
      "outputs": ["{projectRoot}/dist"]
    },
    "test": {
      "inputs": ["{projectRoot}/src/**/*.ts", "{projectRoot}/src/**/*.js", "{projectRoot}/test/**/*.ts", "{projectRoot}/test/**/*.js", "{projectRoot}/tsconfig.json"],
      "dependsOn": ["build"]
    },
    "lint": {}
  }
}

tasksRunnerOptions： 配置任务运行器。
- default： 默认的任务运行器配置。
  - runner： 指定任务运行器，这里使用 nx-cloud。
  - options： 任务运行器的配置选项。
    - cacheableOperations： 指定可以缓存的任务类型，例如 build、test、lint。
    - accessToken： Nx Cloud 的 Access Token。
affected： 配置受影响的项目检测。
- defaultBase： 默认的基准分支，用于检测受影响的项目。
targetDefaults： 配置任务的默认选项。
- build： build 任务的默认选项。
  - dependsOn： 依赖其他任务，^build 表示依赖当前 workspace 下的所有 build 任务。
  - outputs： 指定 build 任务的输出目录，Nx 会根据这些目录的内容计算哈希值。
- test： test 任务的默认选项。
  - inputs： 指定 test 任务的输入文件，Nx 会根据这些文件的内容计算哈希值.
  - dependsOn： 依赖 build 任务。
- lint： lint 任务的默认选项。

Nx Remote Caching 的工作流程：

任务执行： Nx 根据 nx.json 文件中的配置，确定需要执行的任务。
哈希计算： 对于每个任务，Nx 会根据任务的 inputs 和 outputs 计算出一个唯一的哈希值。Nx 提供了多种哈希计算方式，可以根据不同的需求选择。
缓存查找： Nx 会根据计算出的哈希值，在远程缓存服务器上查找是否存在对应的缓存结果。
缓存命中： 如果找到缓存，Nx 会直接从缓存服务器下载缓存结果，并跳过实际的任务执行过程。
缓存未命中： 如果没有找到缓存，Nx 会执行实际的任务，并将任务的输出结果上传到远程缓存服务器，以便下次使用。

Nx 的 Remote Caching 配置：

Nx 支持多种远程缓存存储方式，包括：

Nx Cloud： 官方提供的云服务，功能强大，集成度高。
Self-hosted： 可以使用 AWS S3、Google Cloud Storage 等云存储服务，或者使用 Docker 镜像自己搭建缓存服务器。

以 Nx Cloud 为例，需要在 nx.json 文件中配置 tasksRunnerOptions 选项，并设置 runner 为 nx-cloud：

// nx.json
{
  "tasksRunnerOptions": {
    "default": {
      "runner": "nx-cloud",
      "options": {
        "cacheableOperations": ["build", "test", "lint"],
        "accessToken": "YOUR_NX_CLOUD_ACCESS_TOKEN"
      }
    }
  },
  "affected": {
    "defaultBase": "main"
  },
  "targetDefaults": {
    "build": {
      "dependsOn": ["^build"],
      "outputs": ["{projectRoot}/dist"]
    },
    "test": {
      "inputs": ["{projectRoot}/src/**/*.ts", "{projectRoot}/src/**/*.js", "{projectRoot}/test/**/*.ts", "{projectRoot}/test/**/*.js", "{projectRoot}/tsconfig.json"],
      "dependsOn": ["build"]
    },
    "lint": {}
  }
}

然后，使用 nx cloud login 命令登录 Nx Cloud，就可以开始使用 Remote Caching 了。

五、分布式原理：如何实现高效的缓存共享？

Remote Caching 的核心是分布式缓存。为了实现高效的缓存共享，需要考虑以下几个方面：

缓存存储： 选择合适的缓存存储介质，例如：
- 本地磁盘： 速度快，但容量有限，不适合跨机器共享。
- 网络文件系统（NFS）： 可以在多台机器之间共享，但性能可能受到网络带宽的限制。
- 云存储服务（AWS S3、Google Cloud Storage）： 容量无限，可靠性高，适合大规模分布式缓存。
缓存索引： 建立高效的缓存索引，以便快速查找缓存结果。通常使用哈希表来实现缓存索引。
缓存同步： 确保缓存服务器之间的数据一致性。可以使用主从复制、分布式一致性算法等技术来实现缓存同步。
缓存清理： 定期清理过期的缓存数据，释放存储空间。可以使用 LRU（Least Recently Used）、LFU（Least Frequently Used）等算法来选择要清理的缓存数据.

Turborepo 和 Nx 在分布式原理上的差异：

特性	Turborepo	Nx
哈希计算	基于文件内容哈希，自动计算依赖项的哈希值。	可以自定义哈希计算方式，例如根据文件内容、命令行参数、环境变量等计算哈希值。
缓存存储	支持 Turborepo Cloud 和 Self-hosted 两种方式。	支持 Nx Cloud 和 Self-hosted 两种方式。
缓存同步	Turborepo Cloud 会自动处理缓存同步，Self-hosted 方式需要自己配置缓存同步机制。	Nx Cloud 会自动处理缓存同步，Self-hosted 方式需要自己配置缓存同步机制。
缓存清理	Turborepo Cloud 会自动清理过期的缓存数据，Self-hosted 方式需要自己配置缓存清理策略。	Nx Cloud 会自动清理过期的缓存数据，Self-hosted 方式需要自己配置缓存清理策略。
灵活性	相对简单，配置选项较少，适合快速上手。	更加灵活，配置选项更多，可以更精细地控制缓存行为。
社区和生态	Turborepo 相对较新，社区规模较小，生态系统相对不完善。	Nx 历史更长，社区规模更大，生态系统更完善。

六、实战演练：搭建一个简单的 Remote Caching 服务

为了更好地理解 Remote Caching 的原理，咱们来搭建一个简单的 Remote Caching 服务。这里使用 Node.js 和 Redis 来实现。

安装依赖：

npm install redis express body-parser crypto

创建 server.js 文件：

const express = require('express');
const bodyParser = require('body-parser');
const redis = require('redis');
const crypto = require('crypto');

const app = express();
const port = 3000;

app.use(bodyParser.json());

// Redis 配置
const redisClient = redis.createClient({
  host: 'localhost',
  port: 6379,
});

redisClient.on('connect', () => {
  console.log('Connected to Redis');
});

redisClient.on('error', (err) => {
  console.error('Redis connection error:', err);
});

// 计算哈希值
function calculateHash(data) {
  const hash = crypto.createHash('sha256');
  hash.update(JSON.stringify(data));
  return hash.digest('hex');
}

// 获取缓存
app.get('/cache/:hash', (req, res) => {
  const hash = req.params.hash;

  redisClient.get(hash, (err, value) => {
    if (err) {
      console.error('Error getting cache:', err);
      return res.status(500).send('Error getting cache');
    }

    if (value) {
      console.log('Cache hit for hash:', hash);
      res.json(JSON.parse(value));
    } else {
      console.log('Cache miss for hash:', hash);
      res.status(404).send('Cache not found');
    }
  });
});

// 存储缓存
app.post('/cache', (req, res) => {
  const data = req.body;
  const hash = calculateHash(data);

  redisClient.set(hash, JSON.stringify(data), (err) => {
    if (err) {
      console.error('Error setting cache:', err);
      return res.status(500).send('Error setting cache');
    }

    console.log('Cache set for hash:', hash);
    res.status(201).send('Cache set successfully');
  });
});

app.listen(port, () => {
  console.log(`Remote caching server listening on port ${port}`);
});

启动 Redis 服务：

确保你的机器上已经安装了 Redis，并且 Redis 服务正在运行。

启动 Remote Caching 服务：

node server.js

测试 Remote Caching 服务：

使用 curl 命令测试缓存的存储和获取：

# 存储缓存
curl -X POST -H "Content-Type: application/json" -d '{"message": "Hello, world!"}' http://localhost:3000/cache

# 获取缓存
curl http://localhost:3000/cache/a591a6d40bf420404a011733cfb7b190d62c65bf0bcda32b57b277d9ad9f146e

这个简单的例子演示了 Remote Caching 的基本原理：

使用哈希函数计算数据的指纹。
使用 Redis 存储和获取缓存数据。

七、总结：选择合适的 Remote Caching 方案

Remote Caching 是 Monorepo 优化的重要手段。Turborepo 和 Nx 都提供了强大的 Remote Caching 功能，可以大大提高构建速度和 CI/CD 效率。

选择合适的 Remote Caching 方案需要考虑以下因素：

项目规模： 对于小型项目，Turborepo 可能更简单易用。对于大型项目，Nx 提供了更多的灵活性和控制选项。
团队经验： 如果团队对 Nx 比较熟悉，可以选择 Nx。如果团队对 Turborepo 比较熟悉，可以选择 Turborepo。
预算： Turborepo Cloud 和 Nx Cloud 都提供免费和付费版本，可以根据预算选择合适的版本。
安全性： 对于安全性要求较高的项目，可以选择 Self-hosted 方式，自己搭建缓存服务器。

无论选择哪种方案，Remote Caching 都是一个值得投资的技术，可以帮助你更好地管理 Monorepo，提高开发效率。

好了，今天的讲座就到这里。希望各位观众老爷听得开心，下次有机会再来唠嗑！

发表回复 取消回复

发表回复取消回复