Bermain dengan Lerna untuk membantu anda membina Monorepo dengan mudah

Apakah itu Monorepo?

Monorepo ialah repositori tunggal dengan pelbagai perkhidmatan, projek dan komponen yang berkaitan, yang boleh digunakan oleh pasukan yang berbeza untuk menyimpan kod bagi projek yang berkaitan atau tidak berkaitan. Perkataan monorepo berasal daripada mono, yang bermaksud tunggal, dan repo, yang merupakan singkatan dari repositori. Manfaat Monorepo

Berikut adalah beberapa faedah utama menggunakan monorepo:

• Perkongsian Kod: Projek berkongsi kod standard, perpustakaan atau utiliti.
• Kebolehgunaan semula: Komponen perlu digunakan semula dalam projek yang berbeza.
• Semakan Kod Lebih Mudah: Semakan kod lebih cekap dalam monorepo kerana penyemak boleh melihat dengan mudah konteks perubahan antara projek berkaitan, yang boleh meningkatkan kualiti kod dan mengenal pasti isu yang berpotensi lebih awal.
• Proses CI/CD yang dipermudahkan: Menerbit berbilang projek serentak menggunakan satu repositori menjadi lebih mudah.
• Pengurusan Kebergantungan Konsisten: Projek berkongsi kebergantungan yang serupa atau bertindih dan anda mahu mengurus kebergantungan secara berpusat.
• Kolaborasi Pasukan: Pasukan yang bekerja pada projek berkaitan boleh bekerjasama dengan lebih berkesan dalam satu repositori, berkongsi pengetahuan, cerapan dan sumber.
• Seni Bina Perkhidmatan Mikro: Apabila berurusan dengan set perkhidmatan mikro yang berkait rapat, satu repositori boleh memudahkan perkongsian kod, pengurusan pergantungan dan ujian merentas perkhidmatan.
• Ketekalan Versi: Semua projek boleh berkongsi seni bina kawalan versi standard, memudahkan komunikasi dan pemahaman.

Perpustakaan dan alatan yang direka khusus untuk mengurus Monorepos menggunakan Node.js

• Lerna: Alat yang digunakan secara meluas untuk mengurus projek JavaScript dengan berbilang pakej.
• Nx: Tertumpu pada Sudut tetapi boleh digunakan pada rangka kerja lain, Nx menyediakan alatan pembangunan yang berkuasa untuk monorepos dengan penekanan pada aliran kerja yang cekap, penggunaan semula kod dan ujian.
• Ruang Kerja Benang: Kefungsian monorepo terbina dalam Benang membolehkan mengurus berbilang pakej dalam satu repositori.
• Rush: Pengurus monorepo boleh skala yang dibangunkan oleh Microsoft untuk pangkalan kod yang besar.
• Bolt: Alat pengurusan repositori tunggal memfokuskan pada prestasi yang boleh lebih pantas daripada Lerna untuk beberapa operasi.
• Pengurus Monorepo: Alat ini memudahkan penciptaan dan penyelenggaraan monorepo, menyediakan antara muka mesra pengguna untuk mengurus pakej, kebergantungan dan skrip.
• pnpm: Seperti Benang, pnpm juga menyokong persediaan monorepo melalui ciri ruang kerjanya, mengurangkan pertindihan dan menambah baik penggunaan ruang cakera melalui kebergantungan dikongsi.

Setiap alat menawarkan faedah dan ciri khusus, jadi pilihan bergantung pada keperluan dan keutamaan projek anda.

Kenapa Lerna?

Lerna ialah alat yang direka untuk mengurus repositori yang mengandungi berbilang pakej npm. Ia memudahkan proses pengendalian kebergantungan, penerbitan dan pelepasan pakej merentasi berbilang repositori pakej dalam satu git repositori. Lerna amat berguna untuk monorepo kerana ia membolehkan perkongsian kod dan kerjasama yang cekap antara pembangun yang bekerja pada pakej npm yang berbeza dalam repositori yang sama. Ia membolehkan pembangun merawat projek dengan berbilang pakej sebagai satu entiti, meningkatkan pengurusan kitaran hayat pembangunan.

Prasyarat sebelum memasang Lerna

• Git: Muat turun dan pasang Git
• Git Bash (Terminal) : Jika anda menggunakan Git, Git Bash disertakan dengan Windows; macOS dan Linux, sila gunakan terminal sistem anda.
• Node.js: Muat turun dan pasang Node.js
• npm: npm disertakan dengan Node.js, jadi sebaik sahaja Node.js tersedia dalam terminal anda, npm digunakan Sahkan dengan membuka terminal dan menaip. npm -v.

Kami sedang mencipta satu repositori yang merangkumi perkhidmatan pembayaran yang digunakan oleh pelayan bahagian belakang. Selain itu, pelayan bahagian belakang dan perkhidmatan pembayaran akan berkongsi perkhidmatan log.

• Perkhidmatan Pembalakan: Direka untuk pembalakan yang cekap merentas pelbagai perkhidmatan.
• Perkhidmatan Pembayaran: Bertanggungjawab memproses fungsi berkaitan pembayaran.
• Backend Server: Melaksanakan pemprosesan pembayaran dan menyepadukan perkhidmatan pembalakan untuk operasi yang lancar.

Sekarang mari kita mendalami pelaksanaan Monorepo menggunakan Lerna.

Langkah 1: Cipta Direktori dan Mulakan Lerna

Navigasi ke direktori akar projek anda dan mulakan Lerna:

mkdir monorepo # create a repo directory of the monorepo 
cd monorepo
npx lerna@latest init # initalize the repo

Atas npxnpx命令将创建一个新的 Lerna 管理的存储库。
lerna.json：配置文件包含Lerna行为的设置，例如版本控制模式、包位置等

package.json：整个存储库的根 package.json 文件。

git config user.name ${username}
git config user.email ${email}

第2步：生成后端包

确保您位于项目的根文件夹中。 

用于创建包的 Lerna 命令：npx lerna create #{packageName} #{directory}

这里，目录是默认的：packagesArahan akan mencipta repositori yang diuruskan Lerna baharu.

🎜: Fail root package.json untuk keseluruhan repositori. 🎜🎜<p style="text-align:center"><img src="https://img.php.cn/upload/image/495/551/637/1694397153311761.png" title="1694397153311761.png" alt="Bermain dengan Lerna untuk membantu anda membina Monorepo dengan mudah">🎜<pre class="brush:php;toolbar:false">npx lerna create back-end //or //this will skip the questionnaire related to package npx lerna create back-end -y</pre>🎜<strong style="box-sizing: border-box;">Langkah 2: Jana pakej hujung belakang</strong>🎜🎜🎜Pastikan anda berada dalam folder akar anda tengah projek. 🎜🎜🎜🎜Arahan Lerna untuk mencipta pakej: 🎜<code style="box-sizing: border-box; font-family: Menlo, Monaco, Consolas, " courier new monospace font-size: padding: warna: rgb sini direktori ialah lalai: padding :><span style="box-sizing: border-box; color: rgb(34, 38, 53); font-family: Cambria, serif; font-size: 19px; text-wrap: wrap; background-color: rgb(255, 255, 255); vertical-align: inherit;"><span style="box-sizing: border-box; vertical-align: inherit;">上面的命令，不带</span></span><code style="box-sizing: border-box; font-family: Menlo, Monaco, Consolas, " courier new monospace font-size: padding: color: rgb background-color: border-radius: text-wrap: wrap>-y  会提示你各种问题，比如覆盖包名、添加描述等等。但是，这些详细信息对于本示例来说并不重要，因此请按“Enter”键。

运行后，包后端将如下所示：

步骤3：生成支付和日志服务包

再次执行相同的过程，但指定要创建的服务的目录，因为我们希望包位于该"services/"目录中。

At the rootpackage.json文件中，您还必须告知 Lerna 目录中的包services/。编辑package.json工作区配置并添加"services/*"到其中。配置应类似于以下内容：

在根级别的主package.json文件中，您必须告知 Lerna services/ 目录中的软件包。修改工作区配置package.json并包含"services/*" <span style="box-sizing: border-box; vertical-align: inherit;">Edit</span><span style="box-sizing: border-box; vertical-align: inherit;"><code style="box-sizing: border-box; font-family: Menlo, Monaco, Consolas, " courier new monospace font-size: padding: color: rgb latar belakang-warna: : border-box font-family: menlo monaco consolas saiz fon: jejari sempadan:>"perkhidmatan/*" ke dalamnya.

Konfigurasi hendaklah kelihatan seperti berikut: Kuasa pada peringkat akar

fail, anda mesti memberitahu Lerna tentang pakej dalam perkhidmatan/ direktori. 🎜🎜Ubah suai konfigurasi ruang kerja🎜🎜"perkhidmatan/*"🎜🎜. Konfigurasi sepatutnya kelihatan seperti ini: 🎜🎜🎜🎜🎜🎜🎜🎜🎜🎜🎜🎜

npx lerna create payment services -y
npx lerna create logging services -y

第 4 步：设置日志服务

在该目录中，通过简单的配置使用 Bunyan 库services/logging设置日志记录服务。

• 在日志服务中安装 Buyan 库，并将 Mocha 作为开发依赖项安装在根目录中，以测试所有服务。

// root folder install test dependencies
npm install mocha --save-dev 
//inside logging
cd services/logging
npm install bunyan

• 替换日志功能文件的内容services/logging/lib/logging.js

const bunyan = require('bunyan');
const logger = bunyan.createLogger({
  name: 'my-logging-service',
  level: 'info',
});
module.exports = logger;

• 日志记录测试用例（测试记录器）：
• 替换测试文件的内容services/logging/__tests__/logging.test.js

const loggingService = require('../lib/logging'); // Import the logging service
describe('Logging Service', () => {
  it('should log messages', () => {
    loggingService.info('Test log message');
  });
});

• 更新 services/logging 的 package.json 中的测试脚本。

"test": "mocha ./__tests__/logging.test.js"

• package.json 应如所附图像所示。

• 是时候使用 lerna 运行测试了

npx lerna run test --scope="logging"

• 日志服务实现现已就位，让我们开发支付服务。

第5步：设置支付服务

付款服务具有一个名为 的函数makePayment，它接受单个参数作为金额并利用记录器服务来记录活动。

在services/payment

日志服务实现现已就位，让我们开发支付服务。🎜 style border-:;>

第5步：设置支付服务

🎜付款服务具有一个名为 的函数🎜makePayment🎜，它接受单个参数作为金额并利用记录器服务来记录活数作为金额并利用记录器服务来记录活动。🎀box="style-boxing" jidar atas: 5px; jidar bawah: 15px; padding-top: 0px; warna: rgb(34, 38, 53); font-family: Cambria, serif; saiz fon: 19px; text-wrap: bungkus; background-color: rgb(255, 255, 255);">🎜在🎜perkhidmatan/pembayaran🎜目录内，并通过简单的功能设置支付服务。🎜🎜

• 将现有脚本替换为 mocha，提供用于测试目的的代码片段。
• 要在支付服务中使用日志记录服务，请将其依赖项添加到支付服务的 package.json 中，如下所述。然后，npm i在services/payment目录中运行进行安装。

"scripts": {
    "test": "mocha ./__tests__/payment.test.js"
  },
  "dependencies": {
    "logging": "file:../logging"
  }

• package.json应该如图片所示
  
• 替换支付文件的内容。services/payment/lib/payment.js

const loggingService = require('logging');
const paymentService = {
  makePayment: (amount) => {
    loggingService.info('Payment processing initiated');
    // Implement payment logic here
    loggingService.info('Payment processed successfully');
    return `Payment of ${amount} processed successfully`;
  },
};
module.exports = paymentService;

• makePayment支付服务功能测试用例。
• 替换测试文件的内容services/payment/__tests__/payment.test.js

const chai = require('chai');
const paymentService = require('../lib/payment'); // Import the payment service
const expect = chai.expect;
describe('Payment Service', () => {
  it('should make a payment successfully', () => {
    const paymentResult = paymentService.makePayment(100);
    expect(paymentResult).to.equal('Payment of 100 processed successfully');
  });
});

• 是时候使用 lerna 运行测试了npx lerna run test --scope="payment"
• 我们已经完成了支付服务的实施。现在，让我们继续创建后端服务。

第 6 步：设置后端服务器

我们将使用基本的 GET API 配置服务器，该 API 利用记录器和支付服务。此设置将有助于付款和记录相应的活动。

• 安装 Express 服务器并实现使用这两种服务的功能。

//from root
cd packages/back-end
npm install express

• 替换日志功能文件的内容packages/back-end/lib/back-end.js
• 我们想在服务器中使用支付和日志服务，所以让我们在package.jsonof的依赖项中添加以下代码片段packages/back-end 

"logging": "file:../services/logging",
"payment": "file:../services/payment"

• 替换脚本块来运行服务器并进行测试，如下所示：

"scripts": {
    "start": "node ./lib/back-end.js",
    "test": "mocha ./__tests__/back-end.test.js --exit"
}

• package.json应该如所附图片所示

• 现在，通过执行更新依赖项npm update。
• 将 的内容替换packages/back-end/lib/back-end.js为以下代码：
  • 我们将创建一个带有get / API端口的服务器3000，并使用日志记录和支付服务。 

const express = require('express');
const loggingService = require('logging');
const paymentService = require('payment');
const app = express();
app.get('/', (req, res) => {
  // Use of logging service
  loggingService.info('Backend server received a request');
  
  // Use the payment service
  const paymentResult = paymentService.makePayment(100);
  loggingService.info('Payment result:', paymentResult);
  res.send('Backend Server: Running!');
});
app.listen(3000, () => {
  console.log('Backend server is running on port 3000');
});

• 安装chai-http以对目录上的 API 进行单元测试packages/back-end。
  •  npm i chai-http --save-dev 
• 替换测试文件的内容，我们将在其中测试 API 是否按预期工作。

const chai = require('chai');
const chaiHttp = require('chai-http');
const app = require('../lib/back-end'); // Import the Express app
// using request server as chaiHttp;
chai.use(chaiHttp);
const expect = chai.expect;
describe('Backend Server', () => {
  it('should log a request and process payment', (done) => {
    chai.request(app)
      .get('/')
      .end((err, res) => {
        expect(res).to.have.status(200);
        expect(res.text).to.equal('Backend Server: Running!');
        done();
      });
  });
});

• 恭喜！这样就完成了 monorepo 中三个微服务的简洁有效的实现。 

第 7 步：运行应用程序

• 伟大的！现在，让我们启动服务器并观察所有服务如何组合在一起并工作。
• lerna run start在根文件夹中执行。这将在端口 3000 上启动服务器。打开浏览器并导航至localhost:3000/。您将观察到输出“后端服务器：正在运行！” 显示在浏览器中。
• 检查终端中的日志，您将遇到类似于图中所示的Bermain dengan Lerna untuk membantu anda membina Monorepo dengan mudah。

• Laksanakanlerna run test，这将运行所有微服务中的所有测试，因为所有微服务test

Kesimpulan

Mencipta monorepo dengan pelayan bahagian belakang, perkhidmatan pembayaran dan perkhidmatan pembalakan menyerlahkan faedah pendekatan pembangunan bersatu. Persediaan ini menggalakkan pengurusan dan perkongsian kod yang cekap dengan menyatukan komponen yang berkaitan ke dalam satu repositori.

Mengintegrasikan perkhidmatan pengelogan ke dalam perkhidmatan pembayaran dan pelayan bahagian belakang menunjukkan kuasa kebolehgunaan semula kod dan amalan pengelogan yang konsisten merentas perkhidmatan.

Mengguna pakai seni bina monorepo akan membawa persekitaran pembangunan yang teratur dan kolaboratif. Modularisasi memudahkan pembangunan, meningkatkan kecekapan dan penyelenggaraan jangka panjang. Ia menyediakan asas yang kukuh untuk aplikasi yang kompleks dengan komunikasi yang telus, kebolehgunaan semula kod dan ujian yang berkesan.

Atas ialah kandungan terperinci Bermain dengan Lerna untuk membantu anda membina Monorepo dengan mudah. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!