Lerna

基于 Nx 驱动的现代化 JavaScript/TypeScript Monorepo 构建与发布系统，支持高效任务编排、远程缓存和多包版本管理。

精选工具MonorepoNx多包发布版本管理

Lerna 是 JavaScript 生态中最具历史的 Monorepo 管理工具，由 Nx 团队全面重构后，底层替换为 Nx 执行引擎，引入远程缓存和并行执行。聚焦于任务编排、多包版本管理与 npm 发布，支持 OIDC 可信发布。

Lerna

基于 Nx 驱动的现代化 JavaScript/TypeScript Monorepo 构建与发布系统，支持高效任务编排、远程缓存和多包版本管理。

技术简介说明

Lerna 是 JavaScript/TypeScript 生态中最具历史的 Monorepo 管理工具之一，最初由 Babel 团队于 2015 年开发，用于在同一个 Git 仓库中管理多个 npm 包的版本控制、依赖链接和发布流程。在其早期版本中，Lerna 几乎是 Monorepo 方案的代名词，被 Babel、Angular、Babel 等大量知名开源项目采用。

2022 年，由于社区维护力量不足，Lerna 面临停止维护的风险。Nx 团队（由前 Google 工程师创建的开源构建系统）正式接管了 Lerna 的维护权，开启了 Lerna 的"重生"之路。Nx 团队对 Lerna 进行了全面重构，将其底层执行引擎替换为 Nx 的任务运行器，引入了远程缓存、并行执行、依赖图分析等现代特性，使 Lerna 从一个传统的包管理发布工具进化为高性能的构建系统。

截至 2026 年，Lerna v9 已发展为一个成熟、现代化的 Monorepo 构建平台。它不再自行处理依赖安装（bootstrap、add、link 等遗留命令已在 v9 中彻底移除），转而依赖原生包管理器（npm/yarn/pnpm）的 Workspace 能力。Lerna 的核心价值聚焦于三个方面：任务编排与缓存、多包版本管理与发布、以及项目依赖图可视化。

基本信息

官网：https://lerna.js.org（注：lerna.io 域名已停放）
GitHub：https://github.com/lerna/lerna
License：MIT
最新版本：v9.0.7（2026 年 3 月 13 日发布）
主要维护者：Nx 团队（Nrwl）；核心贡献者包括 Victor Savkin、James Henry、Austin Fahsl、Benjamin Cabanes、Juri Strumpflohner
npm 周下载量：约 190 万（2026 年数据）
GitHub Stars：36.1k+
总提交数：2,900+

快速上手

安装

1. 全局安装 Lerna

# 使用 npm 全局安装
npm install -g lerna
 
# 或使用 npx 免安装直接运行（推荐）
npx lerna init

2. 初始化 Monorepo 项目

# 创建项目目录
mkdir my-monorepo && cd my-monorepo
 
# 初始化 Git 仓库
git init
 
# 使用 npx 运行 Lerna 初始化（推荐方式）
npx lerna init
 
# 或全局安装后使用
lerna init

lerna init 命令会生成以下文件结构：

my-monorepo/
├── lerna.json          # Lerna 配置文件
├── package.json        # 根 package.json
└── packages/           # 默认包目录
    └── (子包目录)

3. 配置原生 Workspace

Lerna v9 要求使用原生包管理器 Workspace，需在根 package.json 中声明：

// npm 7+ / yarn / pnpm 原生 workspace
{
  "name": "my-monorepo",
  "private": true,
  "workspaces": [
    "packages/*"
  ]
}

基础配置

lerna.json 配置文件

{
  "$schema": "node_modules/lerna/schemas/lerna-schema.json",
  "version": "1.0.0",
  "packages": [
    "packages/*"
  ],
  "npmClient": "pnpm",
  "command": {
    "version": {
      "allowBranch": "main",
      "conventionalCommits": true,
      "message": "chore(release): publish"
    },
    "publish": {
      "registry": "https://registry.npmjs.org"
    }
  }
}

核心配置项说明：

配置项	类型	说明
`version`	`string` / `"independent"`	版本号模式。设为固定版本号（如 `"1.0.0"`）使用统一版本；设为 `"independent"` 允许每个包独立版本管理
`packages`	`string[]`	包路径 glob 模式数组，定义 Lerna 扫描子包的位置
`npmClient`	`"npm"` / `"yarn"` / `"pnpm"`	指定使用的包管理器，默认 `"npm"`
`command.version`	`object`	`lerna version` 命令的专属配置
`command.publish`	`object`	`lerna publish` 命令的专属配置
`useWorkspaces`	`boolean`	是否从 `package.json` 的 `workspaces` 字段读取包路径（v9 中默认行为）

nx.json 缓存与任务配置

Lerna v9 使用 Nx 作为底层执行引擎，因此需要 nx.json 配置文件来定义任务缓存和管道：

# 如果初始化时未自动生成，可通过以下命令添加
npx lerna add-caching

// nx.json
{
  "targetDefaults": {
    "build": {
      "cache": true,
      "dependsOn": ["^build"]
    },
    "test": {
      "cache": true,
      "inputs": ["default", "^default"]
    },
    "lint": {
      "cache": true
    }
  }
}

最小示例

以下是一个从零开始的最小化 Lerna Monorepo 示例：

# 1. 初始化项目
mkdir lerna-demo && cd lerna-demo
git init
npx lerna init
 
# 2. 创建两个示例包
mkdir -p packages/utils packages/cli

packages/utils/package.json

{
  "name": "@my-org/utils",
  "version": "1.0.0",
  "main": "index.js",
  "scripts": {
    "build": "echo 'Building utils...'",
    "test": "echo 'Testing utils...'"
  }
}

packages/utils/index.js

module.exports.greet = (name) => `Hello, ${name}!`;

packages/cli/package.json

{
  "name": "@my-org/cli",
  "version": "1.0.0",
  "dependencies": {
    "@my-org/utils": "workspace:*"
  },
  "scripts": {
    "build": "echo 'Building cli...'",
    "test": "echo 'Testing cli...'"
  }
}

运行命令：

# 安装所有依赖（使用包管理器原生 workspace）
pnpm install
 
# 并行运行所有包的 build
npx lerna run build
 
# 并行运行所有包的 test
npx lerna run test
 
# 查看项目依赖图
npx lerna graph
 
# 版本号递增（统一模式）
npx lerna version
 
# 发布到 npm
npx lerna publish

核心概念与架构

核心概念

1. Workspace（工作区）

Lerna v9 完全依赖原生包管理器的 Workspace 机制管理包依赖链接。npm、Yarn 和 pnpm 各自实现了 Workspace 协议，Lerna 会自动读取 package.json 中的 workspaces 字段来识别仓库内的所有子包。

2. Task（任务）与 Target（目标）

Lerna 区分了三个关键概念：

Target（目标）：package.json 中定义的 npm script 名称（如 build、test）
Task（任务）：特定 Target 在某一个包中的具体执行实例
Command（命令）：用户在终端输入的完整命令

例如 lerna run build 中，build 是 Target，而在 @my-org/utils 和 @my-org/cli 中各执行一次就产生两个 Task。

3. Project Graph（项目依赖图）

Lerna 自动分析仓库中所有包之间的依赖关系，构建一张有向无环图（DAG）。这张图决定了任务执行的拓扑顺序——被依赖的包优先构建，确保正确的构建链。

4. Computation Cache（计算缓存）

Lerna 会记录每次任务的输入（源文件、依赖、环境变量、命令参数）和输出（生成的文件、终端日志）。当下次运行时输入未发生变化，Lerna 直接从缓存恢复输出，跳过实际执行。缓存可跨本地环境和 CI 共享。

5. Versioning Mode（版本模式）

Fixed/Locked（固定模式）：所有包共享同一版本号，默认模式。任何包变更时，所有包同步升级到新版本。
Independent（独立模式）：每个包维护自己的版本号，lerna version 时会分别提示为每个变更的包选择版本升级策略。

架构设计

┌─────────────────────────────────────────────────┐
│                    用户命令层                      │
│  lerna run  │  lerna version  │  lerna publish   │
└──────────────────────┬──────────────────────────┘
                       │
┌──────────────────────▼──────────────────────────┐
│                 Lerna 核心引擎                    │
│  命令解析 · 包过滤 · 版本管理 · 发布编排            │
└──────────────────────┬──────────────────────────┘
                       │
┌──────────────────────▼──────────────────────────┐
│               Nx 执行引擎（底层）                  │
│  任务调度 · 依赖图分析 · 并行执行 · 缓存管理        │
└──────────┬───────────────┬──────────────────────┘
           │               │
    ┌──────▼──────┐  ┌─────▼──────┐
    │  本地缓存    │  │ Nx Cloud   │
    │ (7天自动清理) │  │ 远程缓存/CI │
    └─────────────┘  └────────────┘
           │
    ┌──────▼──────────────────────────────────────┐
    │           原生包管理器 Workspace              │
    │     npm workspaces / yarn workspaces /      │
    │     pnpm workspaces                          │
    └─────────────────────────────────────────────┘

核心特性

1. 智能任务编排

支持通过 lerna run 并发执行任意 npm script，底层由 Nx 引擎驱动，自动分析依赖图并按正确的拓扑顺序执行，同时最大化并行度。

# 运行所有包的 build，自动处理依赖顺序
npx lerna run build
 
# 同时运行多个 target
npx lerna run build,test,lint
 
# 指定作用域，只构建特定包
npx lerna run build --scope=@my-org/cli
 
# 只构建自某个分支以来有变更的包
npx lerna run build --since=origin/main

2. 计算缓存

Lerna 会缓存每个任务的输入和输出，下次输入相同时直接从缓存恢复，跳过实际执行。本地缓存默认保留 7 天，可手动执行 npx nx reset 清除。

// nx.json 中配置缓存
{
  "targetDefaults": {
    "build": {
      "cache": true,
      "dependsOn": ["^build"],
      "outputs": ["{projectRoot}/dist"]
    }
  }
}

3. 远程缓存与分布式执行

通过接入 Nx Cloud，团队的本地缓存和 CI 缓存可共享，开发者无需重复构建其他同事已经计算过的任务。在大型 Monorepo 中，分布式执行可将任务分散到多台 CI 机器并行处理。

4. 多包版本管理

lerna version 自动扫描自上次标签以来有变更的包，执行语义化版本递增、Git commit 和 tag 操作，并支持 Conventional Commits 规范自动生成 Changelog。

# 自动分析变更并提示版本升级
npx lerna version
 
# 预发布版本
npx lerna version prerelease
 
# 使用 Conventional Commits 自动确定版本
npx lerna version --conventional-commits
 
# 排除私有包
npx lerna version --no-private

5. 多包发布到 npm

lerna publish 在 lerna version 的基础上，将变更的包发布到 npm registry。支持固定模式和独立模式两种版本策略。

# 正常发布（先 version 再 publish）
npx lerna publish
 
# 从当前包状态发布（不依赖本地 version 步骤）
npx lerna publish from-package
 
# 发布到特定 tag
npx lerna publish --dist-tag=beta

6. OIDC 可信发布（v9 新特性）

v9 引入了 npm OIDC Trusted Publishing 支持，使用短生命周期的凭据替代静态 npm token，大幅提升发布安全性，且无需额外配置。

7. 项目依赖图可视化

Lerna 提供交互式的依赖图可视化界面，帮助开发者直观理解项目架构、包依赖关系和任务执行链路。

# 生成并打开交互式项目依赖图
npx lerna graph

8. 动态 CLI 与自动补全

Lerna v9 提供动态 CLI，支持命令自动补全、参数提示和上下文感知帮助信息，降低学习门槛。

9. Conventional Commits 集成

内置支持 Conventional Commits 规范，可根据 commit 信息自动推断版本升级类型（major/minor/patch）、自动生成 Changelog，并与 GitHub/GitLab Release 集成。

10. 环境变量加载

Lerna 启动时自动读取 .env 文件中的环境变量，确保任务执行环境的一致性。可通过 --load-env-files 参数控制此行为。

生态图

核心依赖关系

Lerna
├── Nx（底层执行引擎）
│   ├── Nx Cloud（远程缓存与分布式执行）
│   └── Nx Console（VS Code / JetBrains IDE 插件）
├── 原生 Workspace 支持
│   ├── npm workspaces（npm 7+）
│   ├── Yarn workspaces（Yarn 1.x / Berry）
│   └── pnpm workspaces（pnpm 所有版本）
└── npm registry（发布目标）

常用配套工具

工具	用途	关系说明
Nx Cloud	远程缓存 / CI 分布式执行	Lerna 内置集成，免费使用
Changesets	版本管理与 Changelog	与 Lerna 互补，专注版本变更管理
Conventional Commits	Commit 规范	Lerna 原生支持，自动推断版本号
commitlint	Commit 格式校验	配合 Conventional Commits 使用
Turborepo	任务编排（可选替代）	Lerna 可与 Turborepo 共存
semantic-release	自动化发布	可作为 Lerna publish 的替代方案
Nx Console	IDE 可视化	VS Code / JetBrains 中的 Lerna 任务面板

社区生态

Discord 社区：Lerna 官方 Discord 频道，与 Nx 社区共享
Twitter：@lernajs
GitHub Discussions：github.com/lerna/lerna/discussions
中文文档：lerna.node.org.cn（社区维护的中文翻译版）
Lerna-Lite：社区维护的轻量版本，提供额外的发布工作流选项

适用场景

1. 多包 npm 库的统一管理与发布

最经典的 Lerna 使用场景。当你维护多个相互依赖的 npm 包（如 UI 组件库 + 工具库 + CLI 工具）时，Lerna 能自动处理包间依赖链接、统一版本递增和批量发布。

2. 共享组件库的企业 Monorepo

企业级前端项目中，多个应用共享 UI 组件库、业务组件库、工具函数库时，Lerna 提供版本管理、构建缓存和任务编排能力，确保包间版本一致性。

3. 需要自动化发布的 SDK 生态

维护一组 SDK 包（如云服务 SDK、插件系统）时，Lerna 的 version + publish 工作流可以一键完成所有变更包的版本递增和发布。

4. 与 CI/CD 深度集成的构建流水线

Lerna 的 --since 参数结合缓存机制，可以在 CI 中只构建和测试受影响的包，显著缩短流水线时间。结合 Nx Cloud 远程缓存，跨 CI 运行也能复用结果。

5. 渐进式迁移中的 Monorepo

从多仓库合并到 Monorepo 的过程中，Lerna 帮助管理迁移阶段的依赖关系和版本协调，提供清晰的依赖图辅助决策。

6. 小型到中型团队的标准 Monorepo 方案

相比 Nx 的完整企业级功能，Lerna 提供"刚好够用"的任务编排和发布能力，配置简单，学习曲线平缓，适合不需要复杂治理规则的团队。

7. 开源项目的多包管理

开源项目（如 Babel、Angular 历史版本）常采用 Lerna 管理多个发布包，独立版本号模式特别适合各自迭代节奏不同的子项目。

开发与工程化

开发流程

# 1. 初始化开发环境
npx lerna init
pnpm install
 
# 2. 添加缓存配置
npx lerna add-caching
 
# 3. 开发子包（利用原生 workspace 链接）
# 包间直接引用，无需手动 link
cd packages/my-lib
 
# 4. 运行任务
npx lerna run dev           # 启动所有包的开发模式
npx lerna run build         # 构建所有包
npx lerna run test          # 测试所有包
 
# 5. 版本与发布
npx lerna version           # 递增版本、生成 Changelog、打 tag
npx lerna publish           # 发布到 npm

构建部署最佳实践

任务管道配置

// nx.json - 推荐的任务管道配置
{
  "targetDefaults": {
    "build": {
      "cache": true,
      "dependsOn": ["^build"],
      "outputs": ["{projectRoot}/dist", "{projectRoot}/build"]
    },
    "test": {
      "cache": true,
      "inputs": [
        "default",
        "^default",
        "{workspaceRoot}/jest.config.ts"
      ]
    },
    "lint": {
      "cache": true,
      "inputs": ["default", "{workspaceRoot}/.eslintrc.json"]
    },
    "dev": {
      "cache": false,
      "dependsOn": ["^build"]
    }
  }
}

包过滤与作用域控制

# 只构建指定包
npx lerna run build --scope=@my-org/core
 
# 构建指定包及其依赖
npx lerna run build --scope=@my-org/core --include-dependencies
 
# 排除特定包
npx lerna run build --ignore=@my-org/deprecated
 
# 只处理自某分支以来的变更包
npx lerna run build --since=origin/main

CI/CD 集成

GitHub Actions 示例

# .github/workflows/ci.yml
name: CI
 
on:
  push:
    branches: [main]
  pull_request:
    branches: [main]
 
jobs:
  build-test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0  # Lerna 需要完整 git 历史
 
      - uses: actions/setup-node@v4
        with:
          node-version: 22
 
      - uses: pnpm/action-setup@v4
        with:
          version: 9
 
      - name: Install dependencies
        run: pnpm install --frozen-lockfile
 
      - name: Build affected packages
        run: npx lerna run build --since=origin/${{ github.base_ref || 'main' }}
 
      - name: Test affected packages
        run: npx lerna run test --since=origin/${{ github.base_ref || 'main' }}
 
  publish:
    needs: build-test
    if: github.ref == 'refs/heads/main'
    runs-on: ubuntu-latest
    permissions:
      id-token: write  # OIDC 可信发布所需
      contents: write
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
 
      - uses: actions/setup-node@v4
        with:
          node-version: 22
          registry-url: 'https://registry.npmjs.org'
 
      - run: pnpm install --frozen-lockfile
      - run: npx lerna publish --yes

接入 Nx Cloud 远程缓存

# 初始化 Nx Cloud 连接
npx nx connect-to-nx-cloud
 
# 或在 CI 中设置环境变量
# NX_CLOUD_ACCESS_TOKEN=your-token

性能与安全

性能特点

优势

计算缓存：避免重复执行相同任务，输入未变则直接从缓存恢复，本地缓存 7 天有效
并行执行：基于依赖图的拓扑排序，无依赖关系的任务完全并行执行
受影响分析：--since 参数精准定位变更影响的包，避免全量构建
远程缓存：Nx Cloud 提供跨机器、跨 CI 运行的缓存共享
分布式执行：大型 Monorepo 可将任务分散到多台机器并行处理

性能优化建议

# 1. 合理配置缓存输入，避免缓存失效过频
# nx.json 中精确声明 inputs
 
# 2. 使用 --since 限制 CI 构建范围
npx lerna run build --since=origin/main
 
# 3. 定期清理本地缓存
npx nx reset
 
# 4. 为不同任务配置正确的 outputs，避免缓存遗漏
"outputs": ["{projectRoot}/dist"]
 
# 5. 使用 Nx Cloud 共享缓存，减少团队重复计算

安全注意事项

OIDC 可信发布（推荐）

v9 引入的 OIDC Trusted Publishing 是当前最安全的发布方式，无需存储长期 npm token：

# GitHub Actions 中启用 OIDC
permissions:
  id-token: write  # 允许 GitHub 生成 OIDC token
  contents: read

传统 Token 安全

若使用 npm token，注意：

不要将 token 硬编码到代码库或 CI 配置中
使用 GitHub Secrets 或环境变量管理
定期轮换 token
限制 token 权限范围（只赋予发布权限，不赋予读取/管理权限）

依赖安全

定期运行 npm audit 或 pnpm audit 检查依赖漏洞
使用 lockfile 锁定依赖版本，确保可重现构建
关注 Lerna 自身的版本更新，及时修复已知漏洞

已知性能瓶颈

超大 Monorepo（1000+ 包）：项目图的构建和遍历可能成为瓶颈，需配合 Nx Cloud 和精细的 --since 过滤
缓存命中率低：若 nx.json 中 inputs 配置不当（如包含经常变化的文件），缓存失效频繁，失去加速效果
冷启动：首次运行或缓存清除后需要完整执行所有任务，可通过远程缓存缓解

技术对比

Lerna vs Nx vs Turborepo

特性维度	Lerna (v9)	Nx	Turborepo
定位	Monorepo 构建与发布系统	完整 Monorepo 智能平台	轻量级 Monorepo 构建系统
底层语言	TypeScript	TypeScript + Rust（迁移中）	Rust（2023年底从 Go 迁移）
底层引擎	Nx 执行引擎	自有引擎	自有引擎
任务缓存	✅ 本地 + 远程（Nx Cloud）	✅ 本地 + 远程（Nx Cloud）	✅ 本地 + 远程（Vercel）
依赖图分析	✅ 自动分析	✅ 自动分析 + 持久守护进程	✅ 自动分析
版本管理	✅ 核心强项（version/publish）	✅ 有（@nx/js:release）	❌ 无内置，需搭配 Changesets
发布到 npm	✅ 核心强项	✅ 支持	❌ 无内置
Conventional Commits	✅ 原生支持	✅ 原生支持	❌ 需额外配置
OIDC 可信发布	✅ v9 原生支持	✅ 支持	❌ 不支持
AI 辅助调试	❌	✅ MCP Server 集成	❌
受影响分析	✅ `--since`	✅ 精细的 affected 算法	✅ `--affected`
分布式执行	✅ 通过 Nx Cloud	✅ 通过 Nx Cloud	✅ Vercel Remote Cache
IDE 支持	Nx Console 插件	Nx Console 插件	Vercel 扩展
多语言支持	仅 JavaScript/TypeScript	任意语言（通过插件）	主要 JS/TS，支持有限多语言
学习曲线	低	中高	低
配置复杂度	低	高（功能全面）	极低
License	MIT	MIT	MIT
维护方	Nx 团队 (Nrwl)	Nrwl	Vercel
适用规模	小/中/大型	中/大型/企业级	小/中型

选型建议

选 Lerna：多包 npm 发布是核心需求，需要开箱即用的版本管理 + 发布工作流，团队偏好"刚好够用"的方案
选 Nx：需要企业级治理、多语言支持、AI 集成、深度 CI 优化，愿意投入更多学习成本
选 Turborepo：追求零配置体验、深度集成 Vercel 部署，不需要内置发布功能
组合使用：Lerna 专注于版本和发布，Turborepo 负责任务编排和缓存，两者可互补

最佳实践

生产环境建议

1. 始终使用原生 Workspace

// package.json - 根目录
{
  "workspaces": ["packages/*"]
}

不要再依赖 lerna bootstrap，Lerna v9 已移除该命令。使用包管理器原生 Workspace 性能更好、兼容性更强。

2. 精确配置缓存边界

// nx.json - 为每个 target 明确声明输入和输出
{
  "targetDefaults": {
    "build": {
      "cache": true,
      "dependsOn": ["^build"],
      "inputs": ["{projectRoot}/src/**/*", "{projectRoot}/tsconfig.json"],
      "outputs": ["{projectRoot}/dist"]
    }
  }
}

3. 使用 Conventional Commits 自动化版本管理

# 根据 Conventional Commits 自动确定版本号和生成 Changelog
npx lerna version --conventional-commits
 
# 推荐 commit 规范：
# feat: 新功能 → minor 版本升级
# fix: 修复 bug → patch 版本升级
# feat!: 破坏性变更 → major 版本升级

4. CI 中使用 OIDC 发布

# GitHub Actions 中无需配置 npm token
permissions:
  id-token: write
  contents: write

5. 使用 `--since` 优化 CI 速度

# PR 中只构建受影响包
npx lerna run build --since=origin/main

6. 合理选择版本模式

统一版本（默认）：适合包间强耦合、同步发布的场景（如 React 生态）
独立版本（"independent"）：适合包间松耦合、各自迭代节奏不同的场景

常见陷阱

陷阱	说明	解决方案
忘记 `fetch-depth: 0`	CI checkout 时默认浅克隆，`--since` 和版本号推断失败	在 checkout action 中设置 `fetch-depth: 0`
缺少 `nx.json`	Lerna v9 依赖 Nx 引擎，缺少 `nx.json` 缓存和任务编排不工作	运行 `npx lerna add-caching` 生成
遗留命令仍在使用	`lerna bootstrap`、`lerna add`、`lerna link` 在 v9 已移除	改用原生包管理器 Workspace
缓存配置不当	`outputs` 未声明导致缓存恢复不完整	为每个 target 明确声明 `outputs`
混用版本模式	中途从固定模式切换到独立模式，导致版本号混乱	初始化时确定版本模式，谨慎切换

技术局限与边界

已知限制

仅支持 JavaScript/TypeScript：Lerna 专为 npm 生态设计，不支持 Python、Go、Rust 等其他语言的 Monorepo 管理。多语言场景需考虑 Nx 或 Bazel。
发布只支持 npm registry：lerna publish 只能发布到 npm（或兼容的 registry），不支持直接发布到 GitHub Packages 私有 registry 或私有 CDN。
无内置守护进程：与 Nx 不同，Lerna 没有持久化后台进程来维护项目图的内存快照，大型仓库每次启动可能有冷启动开销。
不处理依赖安装：v9 移除了所有包管理命令（bootstrap、add、link），完全依赖原生 Workspace。若包管理器版本较旧或不支持 Workspace，则无法使用。
对 Nx Cloud 的依赖：远程缓存和分布式执行完全依赖 Nx Cloud 服务。若团队因合规原因无法使用外部云服务，需自行搭建 Nx Enterprise 或使用其他方案。
v9 迁移破坏性：从 v8 或更早版本升级到 v9 时，遗留命令被移除，需要迁移到原生 Workspace 工作流，可能涉及较大改动。

不适用场景

纯多语言 Monorepo（Java + Go + JS）→ 考虑 Bazel 或 Nx
需要内置 CI 编排（类似 Drone / GitHub Actions）→ Lerna 是构建工具，不是 CI 系统
超大规模仓库（10000+ 包）且需要亚秒级响应 → 考虑 Bazel 或 Nx Enterprise 专属方案
不需要发布功能，只需任务编排 → 考虑 Turborepo，更轻量直接

迁移注意事项

从旧版 Lerna 迁移到 v9

# 1. 升级到最新版本
npm install lerna@latest --save-dev
 
# 2. 确保 package.json 配置了 workspaces
# 3. 运行初始化缓存配置
npx lerna add-caching
 
# 4. 替换遗留命令
# lerna bootstrap → pnpm install / yarn install / npm install
# lerna add xxx  → pnpm add xxx --filter <package>
# lerna link     → pnpm install（workspace 自动链接）
 
# 5. 检查 lerna.json 中的废弃配置

从 Lerna 迁移到 Nx

# Nx 提供官方迁移工具
npx nx@latest init
 
# 自动检测 Lerna 配置并迁移
# lerna.json 中的配置会迁移到 nx.json

学习资源

官方文档

Lerna 官方文档 - 完整的入门指南和功能文档
Lerna 与 Nx 集成说明 - 理解 Lerna 与 Nx 的关系
版本与发布功能 - 详细版本管理文档
OIDC 可信发布指南 - v9 新特性使用指南
Lerna GitHub 仓库 - 源码、Issues 和 Release Notes
Lerna CHANGELOG - 详细版本变更记录

教程

Nx 官方博客：Lerna reborn — What's new in v6? - Lerna 重生历程
Semaphore：JavaScript Monorepos with Lerna - CI 集成实战
Medium：Mastering Monorepos - 实用 Monorepo 指南

社区资源

Lerna 中文文档（社区翻译） - 中文版文档
Dev.to：Turborepo, Nx, and Lerna — The Truth about Monorepo Tooling in 2026 - 2026 年 Monorepo 工具现状分析
Aviator：Top 5 Monorepo Tools for 2026 - Monorepo 工具排行与对比
Bejamas：Lerna vs Nx vs Turborepo - 三方对比详解
YouTube：Best Monorepo Tool in 2026: Nx vs Turborepo vs Lerna - 视频对比评测
Lerna Discord - 官方社区交流

2026 年现状

发展趋势

Nx 深度整合：Lerna 正在成为 Nx 生态的"发布专用前端"，核心执行能力完全委托给 Nx，自身聚焦于版本管理和发布工作流
Rust 化浪潮：Nx 正在将核心从 TypeScript 迁移到 Rust，Lerna 也将间接受益于底层的性能提升
安全优先：OIDC 可信发布代表了行业向无长期凭据方向发展的趋势，Lerna 在这方面走在前列
原生 Workspace 标准化：Lerna 放弃自研包管理功能，全面拥抱 npm/yarn/pnpm 的原生 Workspace，降低了工具间的认知负担

社区活跃度

GitHub Stars：36.1k+，在 Monorepo 工具中处于第一梯队
npm 周下载量：约 190 万，说明大量生产项目仍在使用
发布频率：v9 系列保持稳定的 patch 更新节奏（v9.0.0 ~ v9.0.7 约半年内发布 7 个版本）
社区讨论：GitHub Discussions 和 Discord 频道保持活跃，Nx 团队响应及时
注意信号：部分社区声音认为 Lerna 正在"被 Nx 吸收"，建议新项目直接使用 Nx。Lerna 的独立定位是否长期维持，需持续关注

未来路线图

Nx 核心 Rust 迁移完成后，Lerna 的启动和图分析性能预计将大幅提升
更精细的缓存策略和 CI 优化
可能与 Nx 的 AI 辅助能力（MCP Server）深度整合
OIDC 可信发布的跨平台支持扩展（如 GitLab CI、Bitbucket Pipelines）

文档更新日期：2026 年 7 月 7 日 数据来源：Lerna 官方文档、GitHub 仓库、Nx 官方博客、社区评测文章

Lerna

Lerna

技术简介说明

基本信息

快速上手

安装

1. 全局安装 Lerna

2. 初始化 Monorepo 项目

3. 配置原生 Workspace

基础配置

lerna.json 配置文件

nx.json 缓存与任务配置

最小示例

核心概念与架构

核心概念

1. Workspace（工作区）

2. Task（任务）与 Target（目标）

3. Project Graph（项目依赖图）

4. Computation Cache（计算缓存）

5. Versioning Mode（版本模式）

架构设计

核心特性

1. 智能任务编排

2. 计算缓存

3. 远程缓存与分布式执行

4. 多包版本管理

5. 多包发布到 npm

6. OIDC 可信发布（v9 新特性）

7. 项目依赖图可视化

8. 动态 CLI 与自动补全

9. Conventional Commits 集成

10. 环境变量加载

生态图

核心依赖关系

常用配套工具

社区生态

适用场景

1. 多包 npm 库的统一管理与发布

2. 共享组件库的企业 Monorepo

3. 需要自动化发布的 SDK 生态

4. 与 CI/CD 深度集成的构建流水线

5. 渐进式迁移中的 Monorepo

6. 小型到中型团队的标准 Monorepo 方案

7. 开源项目的多包管理

开发与工程化

开发流程

构建部署最佳实践

任务管道配置

包过滤与作用域控制

CI/CD 集成

GitHub Actions 示例

接入 Nx Cloud 远程缓存

性能与安全

性能特点

优势

性能优化建议

安全注意事项

OIDC 可信发布（推荐）

传统 Token 安全

依赖安全

已知性能瓶颈

技术对比

Lerna vs Nx vs Turborepo

选型建议

最佳实践

生产环境建议

1. 始终使用原生 Workspace

2. 精确配置缓存边界

3. 使用 Conventional Commits 自动化版本管理

4. CI 中使用 OIDC 发布

5. 使用 --since 优化 CI 速度

6. 合理选择版本模式

常见陷阱

技术局限与边界

已知限制

不适用场景

迁移注意事项

从旧版 Lerna 迁移到 v9

从 Lerna 迁移到 Nx

学习资源

5. 使用 `--since` 优化 CI 速度