Jouez avec Lerna pour vous aider à créer facilement Monorepo

Qu'est-ce que Monorepo ?

Un monorepo est un référentiel unique avec plusieurs services, projets et composants associés, qui peuvent être utilisés par différentes équipes pour stocker le code de projets liés ou non. Le mot monorepo est dérivé de mono, qui signifie unique, et de repo, qui est l'abréviation de référentiel. Avantages du Monorepo

Voici quelques-uns des principaux avantages de l'utilisation du monorepo :

• Partage de code : Les projets partagent du code standard, des bibliothèques ou des utilitaires.
• Réutilisabilité : Les composants doivent être réutilisés dans différents projets.
• Révisions de code plus faciles : Les révisions de code sont plus efficaces dans un monorepo car les réviseurs peuvent facilement voir le contexte des changements entre des projets liés, ce qui peut améliorer la qualité du code et identifier les problèmes potentiels plus tôt.
• Processus CI/CD simplifié : Publier plusieurs projets simultanément à l'aide d'un seul référentiel est devenu plus facile.
• Gestion cohérente des dépendances : Les projets partagent des dépendances similaires ou qui se chevauchent, et vous souhaitez gérer les dépendances de manière centralisée.
• Collaboration en équipe : Les équipes travaillant sur des projets connexes peuvent collaborer plus efficacement dans un référentiel unique, en partageant leurs connaissances, leurs idées et leurs ressources.
• Architecture des microservices : Lorsqu'il s'agit d'un ensemble de microservices étroitement liés, un référentiel unique peut simplifier le partage de code, la gestion des dépendances et les tests entre les services.
• Cohérence des versions : Tous les projets peuvent partager une architecture de contrôle de version standard, simplifiant ainsi la communication et la compréhension.

Bibliothèques et outils spécialement conçus pour gérer Monorepos à l'aide de Node.js

• Lerna : Un outil largement utilisé pour gérer des projets JavaScript avec plusieurs packages.
• Nx : Axé sur Angular mais applicable à d'autres frameworks, Nx fournit de puissants outils de développement pour les monorepos en mettant l'accent sur des flux de travail efficaces, la réutilisation de code et les tests.
• Yarn Workspace : la fonctionnalité monorepo intégrée de Yarn permet de gérer plusieurs packages dans un seul référentiel.
• Rush : Un gestionnaire monorepo évolutif développé par Microsoft pour les grandes bases de code.
• Bolt : Un outil de gestion de référentiel unique axé sur les performances qui peut être plus rapide que Lerna pour certaines opérations.
• Monorepo Manager : Cet outil simplifie la création et la maintenance de monorepo, en fournissant une interface conviviale pour gérer les packages, les dépendances et les scripts.
• pnpm : Comme Yarn, pnpm prend également en charge les configurations monorepo via sa fonctionnalité d'espace de travail, réduisant la duplication et améliorant l'utilisation de l'espace disque grâce à des dépendances partagées.

Chaque outil offre des avantages et des fonctionnalités spécifiques, le choix dépend donc des exigences et des préférences de votre projet.

Pourquoi Lerna ?

Lerna est un outil conçu pour gérer des référentiels contenant plusieurs packages npm. Il simplifie le processus de gestion des dépendances, de publication et de publication des packages sur plusieurs référentiels de packages dans un seul référentiel git . Lerna est particulièrement utile pour monorepo car il permet un partage de code efficace et une collaboration entre les développeurs travaillant sur différents packages npm dans le même référentiel. Il permet aux développeurs de traiter les projets comportant plusieurs packages comme une seule entité, améliorant ainsi la gestion du cycle de vie du développement.

Prérequis avant d'installer Lerna

• Git : Téléchargez et installez Git
• Git Bash (Terminal)  : Si vous utilisez Windows, Git Bash est inclus avec l'installation de Git ; Pour macOS et Linux, veuillez utiliser le terminal de votre système.
• Node.js : Téléchargez et installez Node.js
• npm : npm est inclus avec Node.js, donc une fois Node.js installé, npm est disponible dans votre utilisation de terminal. Vérifiez en ouvrant un terminal et en tapant. npm -v.

Nous créons un référentiel unique qui inclut les services de paiement utilisés par le serveur backend. De plus, le serveur backend et le service de paiement partageront le service de journalisation.

• Service de journalisation : Conçu pour une journalisation efficace dans divers services.
• Service de paiement : Responsable du traitement des fonctions liées au paiement.
• Serveur backend : Effectue le traitement des paiements et intègre les services de journalisation pour un fonctionnement transparent.

Plongeons-nous maintenant dans la mise en œuvre de Monorepo à l'aide de Lerna.

Étape 1 : Créer un répertoire et initialiser Lerna

Accédez au répertoire racine de votre projet et initialisez Lerna :

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

Ci-dessus 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}

这里，目录是默认的：packagesLa commande créera un nouveau référentiel géré par Lerna.

🎜 : Le fichier racine package.json pour l'ensemble du référentiel. 🎜🎜<p style="text-align:center"><img src="https://img.php.cn/upload/image/495/551/637/1694397153311761.png" title="1694397153311761.png" alt="Jouez avec Lerna pour vous aider à créer facilement Monorepo">🎜<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;">Étape 2 : Générer le package backend</strong>🎜🎜🎜Assurez-vous d'être dans le dossier racine de votre milieu du projet. 🎜🎜🎜🎜Commande Lerna pour créer des packages : 🎜<code style="box-sizing: border-box; font-family: Menlo, Monaco, Consolas, " courier new monospace font-size: padding: couleur d rgb le r est celui par padding :>paquets🎜

npx lerna create back-end 
//or
//this will skip the questionnaire related to package
npx lerna create back-end -y

上面的命令，不带-y  会提示你各种问题，比如覆盖包名、添加描述等等。但是，这些详细信息对于本示例来说并不重要，因此请按“Enter”键。

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

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

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

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

在根级别的主package.json文件中，您必须告知 Lerna services/ 目录中的软件包。修改工作区配置package.json并包含"services/*" fichier, vous devez également indiquer à Lerna le package dans le répertoire services/. Edit

package.json

Configuration de l'espace de travail et ajout"services/*" dedans. La configuration devrait ressembler à ceci :

🎜🎜Maître au niveau racine 🎜🎜🎜 fichier, vous devez informer Lerna des packages présents dans le répertoire services/. 🎜🎜Modifier la configuration de l'espace de travail🎜🎜<code style="box-sizing: border-box; font-family: Menlo, Monaco, Consolas, " courier new monospace taille de police: remplissage: couleur : rgb background-color: border-radius:>package.json🎜et contient 🎜"services/*"🎜🎜. La configuration devrait ressembler à ceci : 🎜🎜🎜🎜🎜🎜🎜🎜🎜🎜🎜🎜

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"

npx lerna run test --scope="logging"

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

第5步：设置支付服务

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

在services/payment

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

第5步：设置支付服务

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

🎜在🎜services/paiement🎜目录内，并通过简单的功能设置支付服务。🎜🎜

• 将现有脚本替换为 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/。您将观察到输出“后端服务器：正在运行！” 显示在浏览器中。
• 检查终端中的日志，您将遇到类似于图中所示的Jouez avec Lerna pour vous aider à créer facilement Monorepo。

• Executelerna run testlerna run test，这将运行所有微服务中的所有测试，因为所有微服务test, cela exécutera tous les tests dans tous les microservices car Tous les microservices testIl y a des commandes dans le script.

Conclusion

La création d'un monorepo avec un serveur backend, un service de paiement et un service de journalisation met en évidence les avantages d'une approche de développement unifiée. Cette configuration favorise une gestion et un partage efficaces du code en consolidant les composants associés dans un référentiel unique.

L'intégration des services de journalisation dans les services de paiement et les serveurs backend démontre la puissance de la réutilisabilité du code et des pratiques de journalisation cohérentes entre les services.

L'adoption d'une architecture monorepo apportera un environnement de développement organisé et collaboratif. La modularisation simplifie le développement, améliore l'efficacité et la maintenance à long terme. Il fournit une base solide pour des applications complexes avec une communication transparente, une réutilisabilité du code et des tests efficaces.

🎜

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!