Prochain Live découverte TSSR et AIS : jeudi 10 octobre à 12h (je m’inscris)

🦀Comment installer Rust sur Windows, MacOS & Linux ?

2024-06-17

Chez O’clock, nous mettons un point d’honneur à toujours être au courant de ce qui se fait de mieux dans la tech, mais surtout de ce qui sera l’avenir dans les métiers de la tech. Nous pensons que Rust, entre autres, est l’un des futurs piliers de la programmation. C’est pour cela que nous avons lancé notre toute première formation Rust et qu’on vous partage notre tuto pour installer Rust sur Windows, MacOS ou Linux.

Mais c’est quoi Rust ?

Rust est un langage de programmation dit de “bas niveau” avec un typage fort. Comme l’indique Rust-lang.org, Rust est “un langage qui offre à tous le pouvoir de construire des logiciels fiables et efficaces”.

Il est également connu pour être un langage de programmation très productif, grâce à ses différents outils qu’il met à disposition pour être le plus efficace possible et ça, même pendant son apprentissage.
Nous abordons ici, l’installation de Rust, mais également de ces fameux outils satellites.

Rustup, une installation pour les unir tous

Rustup est tout simplement un logiciel qui vous permet non seulement d’installer Rust, mais également de le maintenir à jour, d’ailleurs, il est utile pour Rust, mais aussi pour d’autres outils. On en reparlera plus tard.

Que vous soyez sur Linux, MacOS ou Windows, vous serez tous logé à la même enseigne pour installer Rust et ses outils : Rustup ! Rendez-vous sur la page et vous trouverez la méthode pour l’installer.

Si vous êtes sur Linux ou MacOS, ce sera une ligne de commande dans votre terminal :

				
					$ curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Si vous êtes sur Windows (quelle drôle d’idée ;-)), vous trouverez un exécutable « .exe » qui fera la même chose que cette ligne de commande – c’est-à-dire télécharger et installer Rustup, Rust et d’autres outils dont Cargo, ce dernier est un outil multi-fonctions, c’est un gestionnaire de paquet, au travers de sa CLI, il lance le compilateur, les tests unitaires, la documentation locale, etc. Et il permet aussi de créer de nouveaux projets.

Et nous allons donc commencer par ça.

Mon premier projet Rust

Je précise ici, peu importe votre OS, à partir de maintenant, c’est pareil pour tout le monde. Il est temps de s’y mettre, dans votre terminal, vous allez donc écrire ceci :

				
					$ cargo new first_project

Cargo va créer votre projet dans un nouveau dossier “first_project”, déjà versionné en plus. Vous allez pouvoir entrer dedans et constater l’architecture.

				
					first_project/
|-- Cargo.toml
`-- src/
    |-- main.rs

Expliquons chaque élément en détail :

- first_project/ : ce répertoire contient tous les fichiers et sous-répertoires associés à votre projet, qui s’appelle « first_project« .
  - - Cargo.toml : ce fichier est le manifeste du projet. Il décrit les métadonnées du projet (nom, version, auteur) ainsi que ses dépendances. Le manifeste permet également à Cargo de construire, tester, et gérer les dépendances de votre projet Rust. Le manifeste permet également à Cargo de construire, tester, et gérer les dépendances de votre projet Rust, et est une base essentielle pour bien structurer un projet Rust.
  - - src/ : ce répertoire contient le code source de votre application. Par convention, les fichiers source sont stockés dans ce répertoire.
      - main.rs : ce fichier est l’entrée principale de votre programme. Il doit contenir une fonction fn main(). Cette fonction sera exécutée lorsqu’on lancera votre application via la commande cargo run.

Ainsi, lorsque vous créez un nouveau projet avec cargo new, il inclura ces trois composants principaux par défaut. Vous pouvez commencer à écrire du code Rust dans le fichier src/main.rs, puis utiliser des commandes comme cargo build ou cargo run pour compiler et exécuter votre application.

Jetons rapidement un œil dans le fichier main.rs :

				
					fn main() {
    println!("Hello, world!");
}

Dans cet exemple simple, la fonction main ne fait qu’afficher un message sur la sortie standard grâce à la macro println!. Lorsque vous exécuterez votre application, vous verrez apparaître le texte « Hello, world! » dans votre terminal.

Build & Run

Nous allons tout de suite compiler notre projet. Dans le terminal, placez-vous dans le dossier “first_project” et lancez la commande cargo build. Voici à quoi ressemble votre terminal à l’issue de cette commande :

				
					Compiling first_project v0.1.0 (/home/andre/oclock/rust/first_project)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.11s

Aucun problème constaté sur notre projet, nous pouvons donc lancer notre nouveau programme à l’aide de la commande cargo run. Et voir notre fameux “Hello, world!”.

				
					Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.00s
     Running `target/debug/first_project`
Hello, world!

Voilà, vous avez les bases de la création et l’exécution d’un nouveau projet en Rust.

Pourquoi est-ce un compilateur “Bienveillant” ?

Avant de parler des outils, je voulais vous montrer pourquoi on dit que le compilateur de Rust est bienveillant. Jusqu’ici, vous n’avez vu qu’un projet fonctionnel qui ne nécessite pas d’optimisation.

Amusons-nous un peu en créant une faute dans notre script main.rs nous allons ajouter après le println!() ceci :

				
					let test = “test”

On sauvegarde et on lance dans notre terminal cargo build :

				
					Compiling first_project v0.1.0 (/home/user/oclock/rust/first_project)
error: expected `;`, found `}`
 --> src/main.rs:7:22
  |
7 |     let test = "test"
  |                      ^ help: add `;` here
8 | }
  | - unexpected token

Ici, on constate à quel point l’erreur est très “verbeuse”, tout est expliqué clairement, non seulement le message d’erreur “classique” error: expected ;, found } avec la ligne, mais aussi un aperçu du code en lui-même avec une phrase explicite.

Si on corrige son erreur en ajoutant le point-virgule à la fin de notre ligne et que l’on relance cargo build, voici ce qu’il nous retourne :

				
					warning: unused variable: `test`
 --> src/main.rs:7:9
  |
7 |     let test = "test"
  |         ^^^^ help: if this is intentional, prefix it with an underscore: `_test`
  |
  = note: `#[warn(unused_variables)]` on by default

Dans ce cas, ce n’est plus une erreur, mais bien un “warning”, il nous indique que la variable “test” n’est pas utilisé, et que si c’est intentionnel de notre part, il est de bon usage de préfixé par un tiret bas “_”.

Nous pouvons donc suivre le conseil du compilateur et relancer un cargo build.

				
					Compiling first_project v0.1.0 (/home/andre/oclock/rust/first_project)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.10s

Et on constate que tout fonctionne parfaitement. Vous pouvez voir à quel point ce compilateur est très bien structuré pour vous permettre de tout de suite comprendre votre erreur et surtout d’écrire du code déjà très propre.

Vous êtes maintenant prêt à vous lancer dans Rust ! Théoriquement, rien ne vous empêche de commencer tout de suite à apprendre les concepts de ce langage. Mais je vais vous parler d’une dernière chose, que j’aurais aimé connaître avant de démarrer et qui va vous faire gagner beaucoup de temps.

Pourquoi choisir Rust Analyzer quand on choisit d’installer Rust sur Windows, macOS ou Linux ?

Vous l’avez vu dans la précédente section, le compilateur est très bienveillant, mais c’est le passage entre le code et le terminal pour tester ce que l’on écrit qui est un peu “lourd” et je le comprends très bien.

C’est pour cela que nous allons installer “Rust Analyzer”, un outil qui va faire les mêmes vérifications qu’un cargo build, mais en direct dans votre IDE et aussi faire de l’auto-complétion, vous proposer des améliorations de code, etc.

Vous pouvez consulter une nouvelle fois rust-lang.org vous rendre sur la page afin de trouver comment installer Rust Analyzer sur votre IDE préféré. Dans notre cas, nous allons l’installer sur VSCode à l’aide d’une extension officielle.

Une fois installé si on refait les mêmes erreurs dans notre code :

				
					fn main() {
    println!("Hello, world!");
    let test = “test”
}

Voici à quoi va ressembler notre IDE :

On peut voir l’erreur soulignée en rouge et le warning en jaune. Et si on passe la souris dessus voici un exemple de ce qui apparaît :

Et tout ceci apparaît sur notre IDE dès que l’on sauvegarde, donc beaucoup plus rapide.
Vous aurez peut-être constaté autre chose, entre le nom de notre variable test et le signe égale il y a un : &str qui s’affiche en gris, je n’ai absolument rien ajouté, c’est bien une suggestion de typage de la part de Rust Analyzer. Un simple double-clic permet de l’appliquer.

Voici donc à quoi ressemble notre ligne une fois que tout est corrigé.

Cas pratique et dépendances

Amusons-nous un petit peu, avec un cas pratique et l’installation d’une dépendance. Vous allez vous rendre sur le site https://crates.io . C’est un site qui répertorie toutes les dépendances de Rust. Nous allons installer rand ( https://crates.io/crates/rand ) à l’aide de la commande cargo add rand.

Une fois installé, rendez-vous dans votre fichier main.rs afin d’ajouter du code, je ne rentre pas dans les détails ici, mais en écrivant le code n’hésitez pas à sauvegarder votre code afin de voir les différents messages de Rust Analyzer.

				
					 use rand::prelude::*;

fn main() {
    let x = random();
    println!(“Hello, world!”);
    println!(“Random number : {x}”);
}

Si vous avez recopié le code ci-dessus, vous allez voir apparaître une erreur sur let x.

Si vous cliquez sur la ligne “Click for full compiler diagnostic” voici ce que vous affichera Rust Analyzer :

				
					error[E0283]: type annotations needed
   --> src/main.rs:4:9
    |
4   |     let x = random();
    |         ^   -------- type must be known at this point
    |
    = note: cannot satisfy `Standard: Distribution<_>`
note: required by a bound in `rand::random`
   --> /home/user/.cargo/registry/src/index.crates.io-6f17d22bba15001f/rand-0.8.5/src/lib.rs:184:17
    |
183 | pub fn random<T>() -> T
    |        ------ required by a bound in this function
184 | where Standard: Distribution<T> {
    |                 ^^^^^^^^^^^^^^^ required by this bound in `random`
help: consider giving `x` an explicit type
    |
4   |     let x: /* Type */ = random();
    |          ++++++++++++

Une version plus complète du message d’erreur avec même un exemple de comment résoudre le problème :

				
					help: consider giving `x` an explicit type
    |
4   |     let x: /* Type */ = random();
    |          ++++++++++++

Le but ici n’est pas de « debug » cette erreur, donc simplement si on lit la documentation de rand on va trouver quel type est attendu et il suffit de corriger notre ligne comme ceci :

				
					let x: u8 = random();

Et voilà, vous pouvez maintenant faire un cargo run pour voir le résultat :

				
					Compiling libc v0.2.155
   Compiling cfg-if v1.0.0
   Compiling ppv-lite86 v0.2.17
   Compiling getrandom v0.2.15
   Compiling rand_core v0.6.4
   Compiling rand_chacha v0.3.1
   Compiling rand v0.8.5
   Compiling first_project v0.1.0 (/home/andre/oclock/rust/first_project)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.83s
     Running `target/debug/first_project`
Hello, world!
Random number : -49

On remarque que la nouvelle dépendance rand ainsi que ses propres dépendances sont compilées avec notre programme. Si vous relancez cargo run, il n’aura pas besoin de les recompiler vu qu’elles sont déjà compilées, et il vous affichera directement le résultat :

				
					    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.00s
     Running `target/debug/first_project`
Hello, world!
Random number : -21

Et voilà !

Au-delà des premiers pas : optimisez votre parcours d’apprentissage Rust

Rust a cette mauvaise réputation d’être difficile et long à apprendre, et même si elle n’est pas vraiment juste (c’est un long débat), elle est sans doute impactée par un mauvais départ pour de nombreux développeurs. Utiliser au mieux Cargo & Rust Analyzer n’est qu’un premier pas vers des conditions optimales pour découvrir et travailler sur Rust. Il reste encore plein de choses dont je n’ai pas encore parlé comme par exemple RustFMT ou Clippy. Mais ce sera pour un autre jour. N’oubliez pas de jeter un œil à notre formation Rust.