Monorepo avec Rust : organisation du code pour débutants

Formateur Python en ligne pour débutants

Apprenez Python facilement sans surcharge théorique. Résolvez des tâches pratiques avec vérification automatique et écrivez du code directement dans le navigateur.

Start Course

Introduction : Pourquoi un monorepo en Rust ?

Lorsque vous commencez à apprendre Rust, la première chose que vous rencontrez est un projet unique créé avec cargo new. Mais que faire lorsque votre projet s'agrandit : des bibliothèques communes apparaissent, plusieurs exécutables (par exemple, un serveur et un client) ou vous souhaitez extraire du code répétitif dans un package séparé ?

C'est là qu'intervient le monorepo (monorepository) — une approche où le code de plusieurs projets interdépendants (bibliothèques et exécutables) est stocké dans un seul dépôt. Rust fournit une solution intégrée pour cela : Cargo Workspaces (espaces de travail).

Dans cet article, nous allons voir comment organiser un monorepo en Rust à partir de zéro : de la structure des dossiers aux exemples pratiques. Vous apprendrez à diviser correctement le code en modules, à connecter des dépendances locales et à gérer la compilation.

1. Qu'est-ce qu'un Cargo Workspace et comment le créer ?

Un espace de travail (workspace) est un ensemble de crates qui utilisent le même fichier Cargo.lock et un répertoire target commun. Cela permet d'éviter les conflits de versions de dépendances et accélère la compilation.

Création de la structure du monorepo

Créons un monorepo simple avec deux crates : une bibliothèque utils et un exécutable app.

mkdir my_monorepocd my_monorepocargo new utils --libcargo new app

Créons maintenant le fichier racine Cargo.toml qui déclarera le workspace :

[workspace]members = [    "utils",    "app",]

Important : Assurez-vous que dans les fichiers utils/Cargo.toml et app/Cargo.toml, il n'y a pas de section [package] avec le champ workspace — elle n'est pas nécessaire. Cargo comprendra automatiquement qu'ils font partie du workspace.

Structure du projet

Après la création, vous obtiendrez la structure suivante :

my_monorepo/├── Cargo.toml          # workspace racine├── utils/│   ├── Cargo.toml│   └── src/│       └── lib.rs└── app/    ├── Cargo.toml    └── src/        └── main.rs

2. Organisation du code : bibliothèques et modules

Ajoutons maintenant du code à la bibliothèque utils. Supposons que nous voulions créer des fonctions communes pour travailler avec les nombres et les chaînes de caractères.

Code de la bibliothèque (utils/src/lib.rs)

pub mod math;pub mod strings;

Créons les fichiers des modules :

// utils/src/math.rspub fn add(a: i32, b: i32) -> i32 {    a + b}

pub fn multiply(a: i32, b: i32) -> i32 {    a * b}

// utils/src/strings.rspub fn greet(name: &str) -> String {    format!("Bonjour, {} !", name)}

pub fn to_uppercase(text: &str) -> String {    text.to_uppercase()}

Connexion de la bibliothèque dans l'exécutable

Dans le fichier app/Cargo.toml, indiquons la dépendance au crate local :

[package]name = "app"version = "0.1.0"edition = "2021"

[dependencies]utils = { path = "../utils" }

Maintenant, dans app/src/main.rs, nous pouvons utiliser les fonctions de utils :

use utils::math;use utils::strings;

fn main() {    let sum = math::add(5, 10);    println!("5 + 10 = {}", sum);

    let greeting = strings::greet("Monde");    println!("{}", greeting);

    let upper = strings::to_uppercase("rust rocks");    println!("{}", upper);}

Lancez le projet depuis la racine du monorepo avec la commande :