Les outils de Rust : installation et configuration

Quand on débute en Rust, on entend beaucoup de nouveaux noms d’un coup : rustup, rustc, cargo, clippy, rustfmt, rust-analyzer. On a l’impression qu’il faut dix outils avant de pouvoir écrire une seule ligne. Bonne nouvelle : un seul installateur vous les donne presque tous, et chaque outil a un rôle bien précis.

Imaginez une cuisine. rustup est le magasin qui livre et remplace votre matériel. cargo est le chef qui fait tourner toute la cuisine. clippy est le professeur bienveillant qui regarde par-dessus votre épaule, et rustfmt garde le plan de travail bien rangé. Cette page présente chaque outil, ce qu’il vous faut selon votre système d’exploitation, et la façon dont un développeur Rust s’en sert au quotidien.

Si vous n’avez pas encore installé Rust, l’installation pas à pas et votre premier projet sont sur la page Débuter avec Rust. Les bases de cargo (cargo new, cargo add, Cargo.toml) sont sur Cargo et les crates. Cette page s’appuie sur les deux.

Vue d’ensemble

Voici toute la boîte à outils dans un seul tableau :

Outil	À quoi il sert	Fourni avec rustup ?
rustup	Installe Rust, le met à jour et passe d’une version à l’autre	C’est lui, l’installateur
rustc	Le compilateur : il transforme vos fichiers .rs en programme	Oui
cargo	Compile, exécute, teste et ajoute des crates. Vous l’utilisez pour presque tout	Oui
rustup doc	Ouvre la documentation de la bibliothèque standard et le Rust Book hors ligne dans votre navigateur	Oui (profil par défaut)
clippy	Un linter : il repère des bugs et des façons plus simples d’écrire votre code	Oui (profil par défaut)
rustfmt	Un formateur : il réécrit votre code dans le style standard	Oui (profil par défaut)
rust-analyzer	Le « cerveau » de l’éditeur : autocomplétion, erreurs dans le code, types affichés, aller à la définition	Pas par défaut. L’extension VS Code apporte sa propre copie
Un débogueur	Mettre votre programme en pause sur une ligne et regarder ses variables	Non. Vous installez LLDB ou GDB (ou une extension d’éditeur qui en inclut un)

Un profil est un groupe de composants que rustup installe. L’installation normale utilise le profil default, qui ajoute la documentation, clippy et rustfmt en plus du compilateur et de cargo. Si quelqu’un a configuré votre machine avec le profil minimal, cargo clippy vous dira qu’il n’est pas installé. Une seule commande règle ça : rustup component add clippy rustfmt.

Essayez rustup doc --std au moins une fois. Cette commande ouvre toute la documentation de la bibliothèque standard depuis votre propre disque : elle marche donc dans un avion ou avec une connexion lente. Pour la documentation de votre propre projet et de toutes les crates qu’il utilise, lancez cargo doc --open (plus de détails dans Documentation).

Avant d’installer : ce qu’il faut sur chaque système

Rust compile votre code, mais tout à la fin il a besoin d’un éditeur de liens (linker) : un programme qui assemble les morceaux compilés en un seul fichier exécutable. Rust utilise l’éditeur de liens fourni par les outils C de votre système. C’est pour ça que chaque système demande une petite étape en plus.

Système	Quoi installer	Comment
Windows (recommandé)	Les outils C++ de Visual Studio : l’éditeur de liens MSVC et le SDK Windows	Cochez la charge de travail Développement Desktop en C++ (« Desktop development with C++ ») dans l’installateur de Visual Studio
Windows (alternative)	La toolchain GNU (MinGW)	rustup toolchain install stable-gnu
Windows (autre option)	WSL, un vrai Linux à l’intérieur de Windows	wsl --install, puis suivez les étapes pour Linux
macOS	Les outils en ligne de commande d’Apple (avec un compilateur C et un éditeur de liens)	xcode-select --install
Debian / Ubuntu	Un compilateur C et un éditeur de liens	sudo apt install build-essential
Fedora	Un compilateur C et un éditeur de liens	sudo dnf install gcc

Quelques remarques honnêtes :

• Windows et Visual Studio. Vous n’avez pas besoin de le chercher vous-même : si Visual Studio manque, rustup-init.exe propose de l’installer pour vous. Il installe Visual Studio Community, gratuit pour les particuliers, les étudiants et l’open source, mais pas pour toutes les entreprises. Si vous l’installez au travail, demandez quelle édition votre entreprise utilise. La charge de travail « Développement Desktop en C++ » contient tout ce dont Rust a besoin.
• Windows et GNU. La toolchain MSVC est celle par défaut, et c’est elle qui s’entend le mieux avec les autres logiciels Windows. La toolchain GNU n’a pas besoin de Visual Studio pour des programmes simples, mais beaucoup de crates qui contiennent du code C ne compileront pas tant que vous n’aurez pas aussi installé MSYS2 avec MinGW. La plupart des gens devraient rester sur MSVC.
• WSL est un excellent choix si vous voulez un environnement Linux sous Windows (par exemple parce que votre serveur tourne sous Linux). Dans WSL, vous installez Rust avec la commande Linux habituelle, indépendamment de toute installation Windows.
• Les extras sous Linux. Certaines crates populaires utilisent des bibliothèques du système. Si une compilation échoue avec un message qui parle de pkg-config ou d’OpenSSL, installez aussi pkg-config et libssl-dev sur Ubuntu.

Ensuite, suivez les étapes d’installation de Débuter avec Rust.

rustup en pratique

Une fois Rust installé, c’est avec rustup que vous l’entretenez. Une nouvelle version stable de Rust sort toutes les six semaines, donc mettre à jour est une habitude normale :

rustup update     # met à jour toutes les toolchains installées (et rustup lui-même)
rustup show       # ce qui est installé, et quelle toolchain est active ici

rustup show affiche quelque chose comme ceci (raccourci) :

Default host: x86_64-unknown-linux-gnu

installed toolchains
--------------------
stable-x86_64-unknown-linux-gnu (active, default)

active toolchain
----------------
name: stable-x86_64-unknown-linux-gnu
active because: it's the default toolchain

Stable, beta et nightly

Une toolchain (chaîne d’outils) est un ensemble complet de rustc, cargo et compagnie. Rust a trois canaux de publication :

Canal	Ce que c’est	À utiliser quand
stable	La version officielle, toutes les six semaines	Presque toujours. C’est celle qu’il vous faut
beta	La prochaine version stable, en cours de test	Vous voulez vérifier votre projet avant la prochaine version
nightly	Compilée chaque nuit, avec des fonctionnalités expérimentales	Un outil ou une crate l’exige, ou vous voulez essayer une nouveauté

Vous pouvez installer plusieurs toolchains côte à côte :

rustup toolchain install nightly   # installe nightly à côté de stable
cargo +nightly build               # utilise nightly pour cette seule commande
rustup default stable              # choisit la toolchain utilisée partout

Fixer une toolchain par projet

Parfois, un projet a besoin d’une version précise de Rust. Placez un fichier rust-toolchain.toml dans le dossier du projet, et rustup changera de version automatiquement chaque fois que vous travaillez dans ce dossier :

[toolchain]
channel = "1.97.0"
components = ["clippy", "rustfmt"]
targets = ["wasm32-unknown-unknown"]

Ajoutez ce fichier à git. Toute votre équipe (et votre CI) utilisera alors exactement le même compilateur, et rustup l’installera pour eux s’il manque. La plupart des petits projets n’ont pas du tout besoin de ce fichier : ils utilisent simplement la dernière version stable.

Composants et cibles

Les composants sont des éléments supplémentaires d’une toolchain. Les cibles (targets) permettent de compiler pour un autre type de machine :

rustup component add clippy rustfmt rust-src   # rust-src : le code source de std, utilisé par rust-analyzer
rustup component list --installed              # voir ce que vous avez
rustup target add wasm32-unknown-unknown       # compiler du Rust pour le navigateur

La cible wasm32-unknown-unknown est celle qu’il vous faut pour WebAssembly.

Éditeurs et IDE

Vous pouvez écrire du Rust dans n’importe quel éditeur de texte, mais un éditeur avec rust-analyzer (ou un moteur équivalent) change tout. Vous voyez les erreurs pendant que vous tapez, le type de vos variables s’affiche à côté d’elles, et vous pouvez sauter à la définition de n’importe quelle fonction. Pour un débutant, c’est comme avoir un professeur particulier très patient.

Éditeur	Prix	Support de Rust	Idéal pour
VS Code + rust-analyzer	Gratuit	Extension rust-analyzer officielle	La plupart des gens. C’est le choix le plus populaire, et la plupart des guides partent du principe que vous l’utilisez
RustRover (JetBrains)	Gratuit pour un usage non commercial (apprentissage, projets perso, open source non rémunéré). Le travail commercial demande un abonnement payant	Intégré, avec le propre moteur Rust de JetBrains et un débogueur intégré	Les personnes qui aiment un IDE complet où tout est inclus
Zed	Gratuit, open source	Intégré (utilise rust-analyzer, et CodeLLDB pour le débogage)	Un éditeur moderne et très rapide
Neovim / Helix	Gratuits, open source	Via rust-analyzer. Helix marche presque tout de suite ; Neovim demande un peu de configuration	Les amoureux du terminal
Visual Studio	Éditions payantes, plus Community gratuite	Pas de support officiel de Rust	Pas adapté à Rust. Vous n’avez besoin que de ses outils de build C++ pour l’éditeur de liens

Les conditions de licence de RustRover peuvent changer : vérifiez les règles actuelles sur la page de RustRover (en anglais) avant de l’utiliser au travail.

Pour Neovim, Helix et les autres éditeurs, installez le programme rust-analyzer lui-même avec rustup component add rust-analyzer.

Extensions VS Code recommandées

Si vous utilisez VS Code, ces quatre extensions couvrent presque tout :

• rust-analyzer : l’indispensable. Complétion, erreurs, indications, refactorisation.
• CodeLLDB : un débogueur pour poser des points d’arrêt et avancer dans le code pas à pas. Il inclut sa propre copie de LLDB.
• Even Better TOML : colore et vérifie votre Cargo.toml.
• Error Lens (facultatif) : affiche les messages d’erreur directement sur la ligne, pas seulement au survol. Certains adorent, d’autres trouvent ça envahissant.

Déboguer

Des points d’arrêt avec CodeLLDB

Avec rust-analyzer et CodeLLDB installés dans VS Code, vous verrez de petits liens Run | Debug au-dessus de fn main et de chaque test. Cliquez dans la marge à gauche d’un numéro de ligne pour poser un point d’arrêt (un point rouge), puis cliquez sur Debug. Le programme s’arrête sur votre point d’arrêt, et vous pouvez examiner chaque variable et avancer dans le code ligne par ligne.

Si vous voulez une configuration réutilisable (par exemple pour passer des arguments en ligne de commande), créez .vscode/launch.json :

{
  "version": "0.2.0",
  "configurations": [
    {
      "type": "lldb",
      "request": "launch",
      "name": "Debug task_queue",
      "cargo": {
        "args": ["build", "--bin=task_queue"]
      },
      "args": [],
      "cwd": "${workspaceFolder}"
    }
  ]
}

La partie cargo demande à CodeLLDB de compiler d’abord votre programme avec cargo, puis de le lancer dans le débogueur. Remplacez task_queue par le nom de votre package, et mettez les éventuels arguments du programme dans "args". Appuyez sur F5 pour démarrer.

Des vérifications rapides avec dbg!

Vous n’avez pas toujours besoin d’un vrai débogueur. La macro dbg! affiche une expression, sa valeur, ainsi que le fichier et la ligne où vous l’avez écrite. En plus, elle renvoie la valeur, donc vous pouvez en entourer presque n’importe quoi sans changer ce que fait votre code :

fn apply_discount(price: u32, percent: u32) -> u32 {
    price - price * percent / 100
}

fn main() {
    let prices = [120, 45, 80];

    let total: u32 = dbg!(prices.iter().sum());
    let final_price = dbg!(apply_discount(total, 10));

    println!("Total après une remise de 10 % : {final_price}");
}

Sortie :

Total après une remise de 10 % : 221

▶ Essayez par vous-même

Où sont passées les lignes de dbg! ? dbg! écrit sur stderr (le flux d’erreurs), pas sur stdout comme println!. Vos notes de débogage restent ainsi séparées de la vraie sortie du programme. Dans votre terminal, ou dans la section « Standard Error » du Playground, vous verrez aussi :

[src/main.rs:8:22] prices.iter().sum() = 245
[src/main.rs:9:23] apply_discount(total, 10) = 221

Supprimez vos appels à dbg! quand vous avez fini. Ils sont là pour vous, pas pour vos utilisateurs.

La qualité du code au quotidien

Trois commandes gardent votre code en bonne santé. Elles sont rapides, alors lancez-les souvent.

cargo check : un retour rapide

cargo check trouve les erreurs de compilation sans produire de programme exécutable, ce qui le rend beaucoup plus rapide que cargo build. Beaucoup de développeurs le lancent toutes les quelques minutes. (Le rust-analyzer de votre éditeur fait une vérification de ce genre pour vous à chaque enregistrement.)

cargo fmt : fini les débats sur le style

cargo fmt réécrit chaque fichier de votre projet dans le style Rust standard. Plus personne dans votre équipe n’aura à réfléchir aux espaces ou aux retours à la ligne. Il transforme ceci :

struct Player{name:String,score:u32}
fn top(players:&[Player])->Option<&Player>{players.iter().max_by_key(|p|p.score)}

en ceci :

struct Player {
    name: String,
    score: u32,
}
fn top(players: &[Player]) -> Option<&Player> {
    players.iter().max_by_key(|p| p.score)
}

La plupart des éditeurs peuvent le lancer à chaque enregistrement. Dans VS Code, activez le réglage « Format On Save ».

cargo clippy : une revue de code bienveillante

Clippy connaît des centaines de schémas de code qui sont faux, lents, ou simplement plus difficiles à lire que nécessaire. Voici un petit programme qui fonctionne très bien :

fn main() {
    let tasks: Vec<&str> = vec!["écrire la doc", "corriger un bug"];

    if tasks.len() == 0 {
        println!("Rien à faire !");
    } else {
        println!("{} tâches en attente", tasks.len());
    }
}

Mais cargo clippy a une suggestion :

warning: length comparison to zero
 --> src/main.rs:4:8
  |
4 |     if tasks.len() == 0 {
  |        ^^^^^^^^^^^^^^^^ help: using `is_empty` is clearer and more explicit: `tasks.is_empty()`
  |
  = note: `#[warn(clippy::len_zero)]` on by default

Clippy vous dit, en anglais, que comparer une longueur à zéro se lit mieux sous la forme tasks.is_empty(). Chaque avertissement a un nom (ici len_zero) que vous pouvez chercher dans la liste des lints de Clippy (en anglais) pour une explication plus détaillée. Voici la version corrigée :

fn main() {
    let tasks: Vec<&str> = vec!["écrire la doc", "corriger un bug"];

    if tasks.is_empty() {
        println!("Rien à faire !");
    } else {
        println!("{} tâches en attente", tasks.len());
    }
}

Sortie :

2 tâches en attente

▶ Essayez par vous-même

cargo clippy --fix peut appliquer beaucoup de suggestions à votre place. Clippy n’a pas toujours raison dans votre situation, mais il a raison assez souvent pour que lire chaque avertissement soit une façon rapide d’apprendre le Rust idiomatique.

Une bonne habitude

Avant chaque commit, lancez cargo fmt, cargo clippy et cargo test. En CI, utilisez cargo fmt --check et cargo clippy -- -D warnings, qui font échouer le build au lieu de modifier les fichiers. Pour écrire les tests, voyez Les tests.

Des outils cargo supplémentaires bien utiles

N’importe qui peut ajouter de nouvelles sous-commandes à cargo. On les installe avec cargo install, qui télécharge le code source, le compile et place le programme dans ~/.cargo/bin (sous Windows, %USERPROFILE%\.cargo\bin). Vous n’en avez besoin d’aucun le premier jour, mais ils valent la peine d’être connus :

Outil	À quoi il sert	Installation	Utilisation
bacon	Relance check, clippy ou les tests à chaque enregistrement, dans un terminal à côté	cargo install --locked bacon	bacon, bacon clippy, bacon test
cargo-watch	Lance n’importe quelle commande cargo à chaque enregistrement. Fonctionne toujours, mais n’est plus mis à jour ; son auteur recommande bacon	cargo install --locked cargo-watch	cargo watch -x check
cargo-nextest	Un lanceur de tests plus rapide, avec une sortie plus claire	cargo install --locked cargo-nextest	cargo nextest run
cargo-audit	Compare votre Cargo.lock aux failles de sécurité connues	cargo install cargo-audit	cargo audit
cargo-outdated	Liste les dépendances qui ont des versions plus récentes	cargo install --locked cargo-outdated	cargo outdated
cargo-edit	Ajoute cargo upgrade, qui monte les versions dans Cargo.toml (cargo add est déjà intégré)	cargo install cargo-edit	cargo upgrade
cargo-expand	Montre le code que deviennent vos macros et vos #[derive]	cargo install cargo-expand	cargo expand
cargo-binstall	Télécharge des binaires tout prêts au lieu de compiler, donc l’installation prend quelques secondes	cargo install cargo-binstall	cargo binstall bacon

cargo install compile depuis le code source : la première installation d’un gros outil peut donc prendre quelques minutes. C’est normal. Pour mettre un outil à jour plus tard, relancez la même commande d’installation. Pour voir ce que vous avez installé, lancez cargo install --list. Pour les outils centrés sur la vitesse, comme les profileurs et les benchmarks, voyez Performance.

Sans rien installer : le Rust Playground

Le Rust Playground exécute du Rust dans votre navigateur. Chaque bouton « Essayez par vous-même » de ce site l’ouvre. Il est parfait pour des expériences rapides, pour partager un bout de code quand vous demandez de l’aide, ou pour apprendre sur un ordinateur où vous ne pouvez rien installer.

Ce qu’il sait faire :

• Exécuter votre code en stable, beta ou nightly, en build debug ou release.
• Utiliser les 100 crates les plus téléchargées de crates.io (plus les crates utilisées par le Rust Cookbook, et leurs dépendances), comme serde, rand, regex et tokio.
• Lancer rustfmt et Clippy depuis le menu Tools.
• Partager votre code sous forme de lien.

Ce qu’il ne sait pas faire :

• Gérer plus d’un fichier. Il n’y a pas de Cargo.toml, donc vous ne pouvez pas choisir d’autres crates ni d’autres versions.
• Accéder au réseau. Un programme qui télécharge une page web échouera.
• Travailler avec vos propres fichiers, ou tourner longtemps. Le temps et la mémoire sont limités.
• Être agréable pour les programmes interactifs. Pendant l’exécution, une petite zone permet de taper une entrée, mais c’est peu pratique au-delà d’un test rapide. Les exemples de ce site ne lisent jamais d’entrée, ils s’exécutent donc en un clic.

Quand il ne vous suffit plus, un projet local avec cargo new n’est qu’à une minute.

Liste de départ pour une nouvelle machine

Vous configurez un nouvel ordinateur ? Parcourez cette liste une fois :

• Installez les prérequis de votre système : les outils C++ de Visual Studio (Windows), xcode-select --install (macOS), ou build-essential / gcc (Linux).
• Installez Rust depuis rustup.rs, puis ouvrez un nouveau terminal.
• Vérifiez : rustc --version et cargo --version.
• Assurez-vous que les outils du quotidien sont là : rustup component add clippy rustfmt.
• Installez un éditeur avec rust-analyzer. Avec VS Code, ajoutez les extensions rust-analyzer et CodeLLDB.
• Activez le formatage à l’enregistrement dans votre éditeur.
• Créez un projet de test avec cargo new hello et lancez-y cargo run, cargo clippy et cargo fmt.
• Programmez un rappel pour lancer rustup update tous les mois ou tous les deux mois.
• Facultatif : cargo install --locked bacon pour un retour instantané pendant que vous codez.

Exercices

1. Vérifiez votre boîte à outils

Sur votre propre machine, lancez chacune de ces commandes et vérifiez qu’aucune ne répond « not installed » : rustup show, cargo clippy --version, cargo fmt --version. Ensuite, ouvrez la documentation hors ligne de la bibliothèque standard et trouvez la page de Vec. Indice : rustup doc accepte un sujet, comme le chemin complet d’un type.

Voir la solution

rustup show
cargo clippy --version
cargo fmt --version
rustup doc std::vec::Vec

Chaque commande --version affiche un numéro de version. Si l’une d’elles affiche une erreur à la place, installez l’élément manquant avec rustup component add clippy ou rustup component add rustfmt. La dernière commande ouvre la page de Vec dans votre navigateur, directement depuis votre disque. Si elle vous dit que rust-docs n’est pas installé, lancez d’abord rustup component add rust-docs.

2. Laissez Clippy vous apprendre

Dans un nouveau projet, collez dans src/main.rs la première version du programme de tâches de la section sur Clippy. Lancez cargo clippy, lisez l’avertissement, puis laissez Clippy le corriger pour vous. Indice : il existe une option qui applique les suggestions automatiquement.

Voir la solution

cargo new task_queue
cd task_queue
# collez le programme dans src/main.rs, puis :
cargo clippy
cargo clippy --fix --allow-dirty
cargo clippy

Le premier cargo clippy affiche l’avertissement len_zero. cargo clippy --fix réécrit tasks.len() == 0 en tasks.is_empty(). L’option --allow-dirty l’autorise à modifier des fichiers que vous n’avez pas encore commités dans git. Le dernier lancement n’affiche plus aucun avertissement.

Récapitulatif

• rustup installe et met à jour Rust et change de toolchain ; cargo compile, exécute, teste et ajoute des crates ; rustc est le compilateur qui travaille en dessous.
• Chaque système a d’abord besoin d’un éditeur de liens : les outils C++ de Visual Studio sous Windows, xcode-select --install sous macOS, build-essential ou gcc sous Linux.
• Restez sur stable. Utilisez rust-toolchain.toml seulement quand un projet doit fixer une version, et cargo +nightly pour une commande ponctuelle en nightly.
• Utilisez un éditeur avec rust-analyzer. VS Code avec rust-analyzer et CodeLLDB est la configuration la plus courante.
• Lancez cargo check souvent, et cargo fmt plus cargo clippy avant chaque commit. Utilisez dbg! pour un coup d’œil rapide et un débogueur pour les bugs plus coriaces.
• Le Playground est parfait pour expérimenter et partager, mais c’est un seul fichier, sans réseau, et seulement avec les crates les plus populaires.

Petit quiz

Petit quiz

1. Quel outil utiliseriez-vous pour installer la toolchain nightly à côté de stable ?

cargo install nightly rustc --nightly rustup toolchain install nightly

2. Votre compilation sous Windows échoue parce qu'aucun éditeur de liens n'est trouvé. Qu'est-ce qui manque le plus probablement ?

Les outils de build C++ de Visual Studio (la charge de travail « Développement Desktop en C++ ») L'extension rust-analyzer Le composant rust-src Clippy

3. Où dbg! écrit-il sa sortie ?

Sur stdout, comme println! Sur stderr, avec le fichier et la ligne Uniquement dans le débogueur Nulle part en build debug

4. Laquelle de ces choses le Rust Playground NE sait-il PAS faire ?

Lancer Clippy et rustfmt Utiliser des crates populaires comme serde Télécharger une page web depuis Internet Exécuter du code en nightly

Score : 0 / 4

Pour aller plus loin

• Installer Rust — rust-lang.org : l’installateur officiel pour chaque plateforme, avec des notes sur Windows, le PATH et la désinstallation.
• The rustup book (en anglais) : toolchains, canaux, composants, profils, rust-toolchain.toml et cibles de compilation croisée.
• The Cargo Book (en anglais) : tout sur cargo, y compris cargo install et les options de chaque commande.
• Manuel de rust-analyzer (en anglais) : configurer rust-analyzer dans VS Code, Neovim, Helix, Emacs et d’autres, avec tous ses réglages.
• Documentation de Clippy (en anglais) : comment lancer et configurer Clippy, avec un lien vers la liste complète des lints et leur signification.