Installer Rust et Cargo : votre premier programme

📍 Guide principal de la série : Apprendre Rust de zéro : le guide complet pour débuter. Ce tutoriel fait partie de la série « Rust de zéro ». Pour la vue d’ensemble du langage et le parcours d’apprentissage, commencez par le guide principal.

Pourquoi commencer par l’outillage, pas par la syntaxe

Beaucoup de débutants en Rust ouvrent un éditeur, copient un fn main() trouvé en ligne, et se retrouvent bloqués dès qu’il faut compiler ou ajouter une dépendance. Le problème n’est pas le langage : c’est que personne ne leur a montré Cargo, le chef d’orchestre qui gère la compilation, les dépendances, les tests et la publication. En Rust, on ne lance presque jamais le compilateur rustc à la main. On parle à Cargo, et Cargo parle au compilateur.

Dans ce tutoriel, vous installez la chaîne d’outils complète avec rustup, vous créez votre premier projet, et vous posez la première pierre de stock-cli — l’outil en ligne de commande que toute la série va construire : un gestionnaire d’inventaire pour l’atelier de réparation de téléphones d’Ousmane, à Pikine. À la fin, vous aurez un binaire qui compile et s’exécute, et vous saurez exactement ce que fait chaque commande Cargo.

🎯 Ce que vous allez apprendre

• Installer Rust et Cargo proprement avec rustup, sur Linux, macOS ou Windows.
• Créer, compiler et exécuter un projet avec cargo new, cargo run et cargo build.
• Lire l’anatomie d’un projet Cargo : Cargo.toml, src/main.rs, le dossier target/.
• Mettre à jour la toolchain et vérifier votre version avec rustup update et rustc --version.

🛠️ Ce que vous allez construire

Une première version minimale de stock-cli : un programme qui affiche le nom de l’atelier et un message de démarrage. Rien de spectaculaire visuellement, mais c’est un projet Cargo réel, versionné avec Git, qui compile en mode debug et en mode release. C’est le socle sur lequel les tutoriels suivants ajouteront les variables, les structures, la gestion d’erreurs et la logique d’inventaire.

Prérequis

• Un terminal (Bash sous Linux/macOS, PowerShell ou le terminal de Windows).
• Une connexion Internet pour le téléchargement initial (~200 à 400 Mo selon la plateforme).
• Test express : si vous savez ouvrir un terminal et taper une commande, vous êtes prêt. Aucune connaissance préalable de Rust n’est requise.
• ⏱️ Temps estimé : ~30 minutes, dont l’essentiel en téléchargement.

Étape 1 — Installer la toolchain avec rustup

Rust ne s’installe pas comme un paquet figé. On installe rustup, un gestionnaire de versions qui télécharge et met à jour les toolchains (compilateur rustc, gestionnaire cargo, formateur, documentation). C’est l’équivalent de nvm pour Node ou pyenv pour Python : un seul outil pour installer, mettre à jour et basculer entre versions. Sur les distributions Linux, n’installez surtout pas le paquet rust du système : il est souvent figé sur une version ancienne et entre en conflit avec rustup.

Sur Linux et macOS, la commande officielle est la suivante. Elle télécharge le script d’installation depuis le site de Rust et le lance :

# Lance l'installeur rustup officiel (Linux / macOS)
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Le drapeau --proto '=https' impose le HTTPS, --tlsv1.2 force une version de TLS sûre, et -sSf rend curl silencieux tout en affichant les vraies erreurs. L’installeur vous propose trois choix ; tapez 1 (installation par défaut). À la fin, il vous demande de recharger votre terminal ou de sourcer l’environnement :

# Recharge les variables d'environnement sans rouvrir le terminal
source "$HOME/.cargo/env"

Sous Windows, le chemin propre n’est pas curl mais l’installeur graphique : téléchargez rustup-init.exe depuis win.rustup.rs (ou la page officielle rust-lang.org/tools/install) et exécutez-le. Windows vous demandera peut-être d’installer les Visual Studio C++ Build Tools : acceptez, Rust en a besoin pour lier les binaires. Une fois l’installation terminée, fermez puis rouvrez votre terminal pour que le PATH soit pris en compte.

✅ Point d’étape — Tapez rustc --version puis cargo --version. Vous devez voir s’afficher des numéros de version (par exemple rustc 1.96.0). Si le terminal répond « commande introuvable », c’est que le PATH n’a pas été rechargé : fermez et rouvrez le terminal, ou ressourcez ~/.cargo/env.

Étape 2 — Vérifier l’installation et comprendre les composants

Avant d’écrire la moindre ligne de code, prenez trente secondes pour voir ce que rustup a réellement installé. Cela vous évitera de chercher pendant des heures un outil qui était déjà là. La commande rustup show affiche la toolchain active :

rustc --version    # le compilateur Rust
cargo --version    # le gestionnaire de projet et de paquets
rustup show        # la toolchain installée et active

Trois outils nous intéressent dès maintenant. rustc est le compilateur ; vous ne l’appellerez quasiment jamais directement. cargo est votre interface quotidienne : il appelle rustc pour vous, télécharge les dépendances et lance les tests. rustup gère les versions de tout ça. Plus tard, deux compagnons vous serviront sans installation supplémentaire : cargo fmt (formatage automatique) et cargo clippy (un linter qui repère les maladresses). Ils sont fournis par défaut avec la toolchain stable.

Pour maintenir Rust à jour — une nouvelle version stable sort toutes les six semaines —, une seule commande suffit. Prenez l’habitude de la lancer une fois par mois :

rustup update    # met à jour toutes les toolchains installées

Étape 3 — Créer le projet stock-cli avec Cargo

On ne crée pas un projet Rust en faisant un dossier et un fichier à la main : on laisse Cargo poser la structure standard, attendue par tout l’écosystème. Placez-vous dans votre dossier de travail (par exemple ~/projets) et lancez :

cargo new stock-cli
cd stock-cli

Cargo crée un dossier stock-cli contenant un fichier Cargo.toml (le manifeste du projet), un dossier src/ avec un main.rs de démonstration, et il initialise même un dépôt Git avec un .gitignore adapté. Cette convention « manifeste + src » est universelle en Rust : quand vous récupérerez le projet d’un collègue, vous saurez immédiatement où regarder.

Ouvrez Cargo.toml. Vous y trouverez le manifeste minimal généré automatiquement :

[package]
name = "stock-cli"
version = "0.1.0"
edition = "2024"

[dependencies]

Le champ edition = "2024" est important : les éditions de Rust (2015, 2018, 2021, 2024) permettent au langage d’évoluer sans casser le code existant. L’édition 2024 est celle générée par défaut depuis Rust 1.85. La section [dependencies], vide pour l’instant, accueillera les crates (bibliothèques) que vous ajouterez plus tard.

✅ Point d’étape — Votre dossier doit contenir Cargo.toml et src/main.rs. Vérifiez avec ls (ou dir sous Windows). Si cargo new a échoué avec une erreur Git, ce n’est pas bloquant : ajoutez --vcs none pour créer le projet sans dépôt Git.

Étape 4 — Compiler et exécuter votre premier binaire

Le main.rs généré affiche « Hello, world! ». Personnalisons-le pour stock-cli. Ouvrez src/main.rs dans votre éditeur et remplacez son contenu par :

fn main() {
    let atelier = "Atelier Réparation Pikine";
    println!("=== stock-cli ===");
    println!("Inventaire de : {atelier}");
    println!("Démarrage du programme...");
}

La fonction main est le point d’entrée de tout programme exécutable Rust. La macro println! (le ! indique une macro, pas une fonction ordinaire) écrit une ligne sur la sortie standard. La syntaxe {atelier} insère directement la valeur de la variable dans le texte : c’est l’interpolation moderne, disponible depuis Rust 1.58, plus lisible que l’ancien println!("{}", atelier).

Lancez maintenant le programme. cargo run compile puis exécute en une seule commande :

cargo run

Vous devriez voir Cargo compiler le projet (Compiling stock-cli v0.1.0), puis la sortie de votre programme :

=== stock-cli ===
Inventaire de : Atelier Réparation Pikine
Démarrage du programme...

Si le compilateur refuse votre code, ne paniquez pas : les messages d’erreur de Rust sont parmi les plus pédagogiques qui existent. Ils pointent la ligne exacte, expliquent le problème et proposent souvent le correctif. Lisez-les, ils vous font gagner du temps.

Étape 5 — Comprendre debug, release et le dossier target

Par défaut, cargo run et cargo build compilent en mode debug : compilation rapide, binaire non optimisé, idéal pendant le développement. Quand vous voudrez distribuer votre outil, vous passerez en mode release, plus lent à compiler mais qui produit un binaire optimisé et bien plus rapide à l’exécution. Comparez les deux :

cargo build               # compile en mode debug -> target/debug/stock-cli
cargo build --release     # compile optimisé    -> target/release/stock-cli

Le binaire compilé se trouve dans target/debug/stock-cli (ou target/release/). Vous pouvez l’exécuter directement, sans Cargo : ./target/debug/stock-cli. Le dossier target/ peut grossir vite (des centaines de Mo) ; c’est pourquoi le .gitignore généré l’exclut du dépôt Git — ne le versionnez jamais.

Enfin, une commande précieuse pendant le développement : cargo check. Elle vérifie que votre code compile sans produire de binaire, donc bien plus vite que cargo build. Quand vous corrigez des erreurs en boucle, cargo check est votre meilleur allié.

cargo check    # valide la compilation sans générer d'exécutable

✅ Point d’étape — Lancez cargo build --release puis exécutez ./target/release/stock-cli. Le programme doit afficher les trois lignes de démarrage. Vous tenez votre premier binaire Rust optimisé.

🐞 Pièges fréquents

🌍 Adaptation au contexte ouest-africain

Le premier téléchargement de la toolchain pèse plusieurs centaines de méga-octets, et chaque cargo build récupère les dépendances depuis crates.io. Avec une connexion mobile facturée au volume, cela compte. Trois réflexes utiles : faites l’installation initiale sur une connexion Wi-Fi (espace de coworking, fibre d’un ami, campus) ; une fois les crates téléchargées, elles sont mises en cache dans ~/.cargo/registry et réutilisées hors ligne pour les compilations suivantes ; et lancez cargo build une première fois avec du réseau pour « remplir » ce cache avant de coder dans le train ou en cas de coupure.

Côté machine, Rust compile confortablement sur un ordinateur modeste (4 Go de RAM suffisent pour des projets d’apprentissage), mais le mode release sollicite le processeur. Sur une machine d’entrée de gamme, restez en mode debug pendant l’apprentissage et ne lancez le --release que pour la version finale. En cas de coupure de courant fréquente, sauvegardez souvent : Cargo, lui, reprend la compilation là où elle s’était arrêtée grâce au cache de target/.

✅ Récapitulatif

Vous êtes parti d’un terminal vide et vous avez maintenant une toolchain Rust complète, un projet stock-cli versionné, et un binaire qui compile en debug comme en release. Vous savez créer un projet (cargo new), le compiler (cargo build), l’exécuter (cargo run), le vérifier vite (cargo check) et tenir la toolchain à jour (rustup update). Surtout, vous avez compris que Cargo, pas rustc, est votre interface de travail. C’est exactement le réflexe que tous les tutoriels suivants supposeront acquis.

🧾 Aide-mémoire

💪 À vous de jouer

Ajoutez à stock-cli une quatrième ligne qui affiche le nombre de produits suivis (mettez 0 pour l’instant) et la ville de l’atelier, sur une seule ligne, en utilisant l’interpolation. Le résultat attendu : Produits suivis : 0 — Ville : Pikine.

fn main() {
    let atelier = "Atelier Réparation Pikine";
    let ville = "Pikine";
    let nb_produits = 0;
    println!("=== stock-cli ===");
    println!("Inventaire de : {atelier}");
    println!("Produits suivis : {nb_produits} — Ville : {ville}");
}

Tutoriels frères

• Variables, types et fonctions en Rust — la suite logique : déclarer des données et structurer la logique.
• Comprendre l’ownership et le borrowing — le concept central qui rend Rust unique.

Pour aller plus loin

• 🔝 Retour au guide principal : Apprendre Rust de zéro : le guide complet
• Documentation officielle d’installation : rust-lang.org/tools/install
• Le livre officiel « The Rust Programming Language » : doc.rust-lang.org/book
• Tutoriel suivant suggéré : Variables, types et fonctions

FAQ

Q : Dois-je installer un éditeur particulier pour coder en Rust ?
R : Non, n’importe quel éditeur de texte fonctionne. Pour une expérience confortable, installez l’extension rust-analyzer dans VS Code : elle apporte l’autocomplétion et l’affichage des erreurs en temps réel, sans configuration.

Q : Quelle est la différence entre rustc et cargo ?
R : rustc est le compilateur brut. cargo est l’outil de plus haut niveau qui appelle rustc, gère les dépendances, les tests et la structure du projet. En pratique, vous utilisez cargo.

Q : Faut-il une connexion Internet permanente pour développer en Rust ?
R : Non. Seuls le premier téléchargement de la toolchain et l’ajout de nouvelles dépendances nécessitent du réseau. Une fois les crates en cache, vous compilez et exécutez hors ligne.

Q : Pourquoi mon dossier target/ est-il si volumineux ?
R : Il contient tous les artefacts de compilation et les dépendances compilées. C’est normal. Il est exclu de Git par le .gitignore ; vous pouvez le supprimer à tout moment avec cargo clean, Cargo le régénérera.