Prochain Live dĂ©couverte : Formation DevOps, le jeudi 7 novembre Ă  12h (je m’inscris)

🩀Comment installer Rust sur Windows, MacOS & Linux ?

17/06/2024
Installer_Rust_Windows_MacOS_Linux

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.

Table des matiĂšres

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 : 

AD 4nXfyXWH Hx8tN42PNBiKdQAi7TC0dc OMHCeUgepLOx7qFr7ykYv4 KndyMW8EUhowdFba4GmRJssfhb6rGIKfmFPsh2UH6qGQ2VP547hKbIR7TpxE5j4ZdK9aVJgqDvDVoN9w70PW3aVzOiL5s3XeOGPwqS?key=uaLYjRurcW 1NqduKSSnwA oclock

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 :

AD 4nXcsF8VuvnMSjO9yhxCmueHJgGWMZ3UJHeoPrdcx2T fUXjNqXIvAsdHnJSwkxHSyiMflAzicmKn3PJZwvyb8INT722Zc5 kTbXRMagGPdSsnwuOMYU CWbOtNYDDRP 6aCHGc3s8LtG493Uge0FN5RTsbTt?key=uaLYjRurcW 1NqduKSSnwA oclock

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é.

AD 4nXcF gEQvf2nc5 D9rWf gvE0dyovVvjCECm 6qmMY6aFhc2LqTHrk1DEjg9JOOWfU3iSoMqiFEqRfpNeeW3hqeGQCZ2gjIf88tZfpAXjFf3Bp1OxBvr3ViAADyMoqW8tcyvqwUPQoBPjzeNAYNvqweQKCMC?key=uaLYjRurcW 1NqduKSSnwA oclock

 

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.

AD 4nXfRDFEEbFq1uI0 B3alnWU4Q1JgmNmoybzmzl7e vpTWHJF6nDRcq60eP7lWOCJkeiDK00v040l6s8tv5gQFuRQjvTyRzAOgX lGTGhmJKSduQaPG6087tBq8x8gh9p4JNBonwAys2jU9h5CKR1Y1kULADf?key=uaLYjRurcW 1NqduKSSnwA oclock

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.