Installation et Configuration d'un Environnement Rust sur Windows

🎯 Introduction

Rust est un langage de programmation système moderne qui allie performance, sécurité mémoire et productivité. Dans cet article, nous allons voir comment installer et configurer un environnement Rust complet sur Windows SANS droits administrateur en utilisant Scoop comme gestionnaire de paquets.

🎉 Bonne nouvelle : Cette approche permet d’installer Rust et toutes ses dépendances sans jamais avoir besoin des droits admin ! Parfait pour les environnements d’entreprise restrictifs ou les postes personnels.

Pourquoi cette méthode ? Parce que l’installation traditionnelle de Rust nécessite souvent des droits admin pour les dépendances MSVC. Nous allons contourner cela élégamment avec la toolchain GNU.

📋 Prérequis

Avant de commencer, assurez-vous d’avoir :

Windows 10/11 (versions récentes recommandées)
Scoop installé (si ce n’est pas fait, consultez notre article sur Scoop)
Un terminal (PowerShell, Windows Terminal, ou Git Bash)
❌ AUCUNS droits administrateur requis ! Tout s’installe dans votre répertoire utilisateur

🔑 Pourquoi cette méthode fonctionne sans droits admin ?

La magie de Scoop :

Installation utilisateur : Scoop installe tout dans ~/scoop/ (votre répertoire personnel)
Pas de modifications système : Aucun changement dans C:\Program Files\ ou le registre Windows
PATH local : Les exécutables sont ajoutés à votre PATH utilisateur uniquement

Avantages pour les environnements restrictifs :

✅ Parfait pour les entreprises avec politiques de sécurité strictes
✅ Idéal pour les postes partagés ou les machines virtuelles
✅ Installation réversible : scoop uninstall supprime tout proprement
✅ Pas de conflit avec d’autres installations système

Comparaison avec l’installation traditionnelle :

Méthode	Droits admin	Installation système	Réversible
Scoop + GNU	❌ Non requis	❌ Non	✅ Oui
Installation standard	✅ Requis	✅ Oui	❌ Non

Passons maintenant à l’installation !

🚀 Installation de Rust via Scoop

Étape 1 : Installation de rustup-gnu

1
scoop install rustup-gnu

Que fait cette commande ?

Installe rustup configuré pour utiliser la toolchain GNU par défaut
Configure automatiquement le PATH système
Évite d’avoir à changer la toolchain comme avec rustup classique
Inclut la toolchain GCC prête à l’emploi

⚠️ Important: Redémarrage de votre terminal/VS Code après l’installation pour que les changements de PATH soient pris en compte.

Étape 2 : Installation de MinGW-w64

La toolchain GNU nécessite MinGW-w64 pour la compilation :

1
scoop install mingw

Que fait cette commande ?

Installe MinGW-w64 (GNU pour Windows)
Fournit les outils de compilation nécessaires (gcc, g++, dlltool, etc.)
Configure automatiquement le PATH

⚠️ Important : Redémarrage du terminal requis après l’installation de MinGW.

Étape 3 : Vérification de l’installation

1
2
3
4
5
# Vérifier Rust
rustc --version

# Vérifier Cargo (gestionnaire de paquets)
cargo --version

Résultat attendu :

1
2
rustc 1.90.0 (1159e78c4 2025-09-14)
cargo 1.90.0 (840b83a10 2025-07-30)

🔧 Résolution des problèmes courants

Problème 1 : Dépendances MSVC manquantes

Si vous obtenez cette erreur :

1
note: you may need to install Visual Studio build tools with the "C++ build tools" workload

Solution : Cette erreur ne devrait plus apparaître avec rustup-gnu, mais si elle survient, utilisez la toolchain GNU explicitement.

Problème 2 : dlltool manquant

Si vous obtenez cette erreur malgré l’installation de MinGW :

1
Error calling dlltool 'dlltool.exe': program not found

Solutions possibles :

Redémarrage du terminal (PATH pas mis à jour)
Réinstallation de MinGW :

1
2
scoop uninstall mingw
scoop install mingw

Vérification de l’installation :

1
dlltool --version

🏗️ Configuration d’un projet web avec Axum

Pour un projet web moderne, voici une configuration de base :

Initialisation du projet

1
2
cargo init mon-projet-web
cd mon-projet-web

Configuration Cargo.toml

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
[package]
name = "mon-projet-web"
version = "0.1.0"
edition = "2021"

[dependencies]
axum = "0.7"
tokio = { version = "1.0", features = ["full"] }
tower = "0.4"
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"

Exemple de serveur basique

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
use axum::{
    routing::get,
    response::Json,
    Router,
};
use serde::Serialize;
use std::net::SocketAddr;

#[derive(Serialize)]
struct HealthCheck {
    status: String,
    message: String,
}

async fn health_check() -> Json<HealthCheck> {
    Json(HealthCheck {
        status: "ok".to_string(),
        message: "Server is running!".to_string(),
    })
}

#[tokio::main]
async fn main() {
    // Créer le routeur
    let app = Router::new()
        .route("/health", get(health_check));

    // Lancer le serveur
    let addr = SocketAddr::from(([127, 0, 0, 1], 3000));
    println!("🚀 Server running on http://{}", addr);

    axum::Server::bind(&addr)
        .serve(app.into_make_service())
        .await
        .unwrap();
}

💡 Exemple concret

Pour voir ces concepts en action, consultez le repository de démonstration qui implémente un serveur web Rust complet avec Axum :

🔗 Repository GitHub - Rust Web Server Demo

📁 Structure recommandée d’un projet Rust

Voici la structure d’un projet web Rust moderne (basée sur notre exemple concret) :

1
2
3
4
5
6
7
mon-projet-web/
├── Cargo.toml          # Configuration du projet Rust
├── src/
│   ├── main.rs         # Point d'entrée de l'application
│   └── templates/      # Templates HTML
│       └── home.html   # Template de la page d'accueil
└── README.md

Éléments clés :

src/main.rs : Point d’entrée avec la logique serveur
src/templates/ : Templates HTML pour les vues
Cargo.toml : Dépendances et configuration

🛠️ Commandes essentielles

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
# Développement
cargo build          # Compilation en mode debug
cargo run            # Compilation + exécution
cargo check          # Vérification sans compilation

# Production
cargo build --release  # Compilation optimisée

# Maintenance
cargo clean          # Nettoyage des artefacts
cargo update         # Mise à jour des dépendances
cargo doc --open     # Génération de la documentation

# Tests
cargo test           # Exécution des tests
cargo test --doc     # Tests de documentation

🔍 Dépannage avancé

Gestion des toolchains multiples

1
2
3
4
5
6
7
8
# Lister les toolchains installées
rustup toolchain list

# Changer de toolchain temporairement
rustup run stable-x86_64-pc-windows-gnu cargo build

# Installer une version spécifique
rustup install 1.89.0

Problèmes de PATH persistants

Si les commandes ne sont toujours pas trouvées :

Vérifier le PATH :

1
echo $env:PATH

Réinstaller rustup :

1
2
scoop uninstall rustup
scoop install rustup

Redémarrage complet de Windows si nécessaire

Conflits avec d’autres installations Rust

Si vous avez déjà installé Rust via d’autres méthodes :

1
2
3
# Désinstaller les autres versions
# Puis réinstaller proprement avec Scoop
scoop install rustup

🎯 Bonnes pratiques

1. Utiliser un gestionnaire de versions

1
2
3
4
# Pour les projets, spécifier la version de Rust
# Dans Cargo.toml
[package]
rust-version = "1.70"

2. Configuration VS Code optimale

Créez un fichier .vscode/settings.json :

1
2
3
4
5
6
7
8
{
    "rust-analyzer.checkOnSave.command": "clippy",
    "rust-analyzer.server.path": "~/.cargo/bin/rust-analyzer",
    "editor.formatOnSave": true,
    "[rust]": {
        "editor.defaultFormatter": "rust-lang.rust-analyzer"
    }
}

3. Gestion des dépendances

Utilisez cargo add pour ajouter des crates
Auditez régulièrement avec cargo audit
Gardez les dépendances à jour avec cargo update

🚀 Prochaines étapes

Maintenant que votre environnement est configuré, vous pouvez :

Explorer la documentation officielle : doc.rust-lang.org
Suivre le livre Rust : doc.rust-lang.org/book
Rejoindre la communauté : users.rust-lang.org
Contribuer à des projets open source

📚 Ressources recommandées

📖 The Rust Programming Language - Le livre officiel
🛠️ Rustup Documentation - Gestion des toolchains
📦 Crates.io - Registre des packages Rust
💬 Rust Discord - Communauté active

🎉 Conclusion

Félicitations ! Vous avez maintenant un environnement Rust complet et fonctionnel sur Windows. L’approche avec Scoop et la toolchain GNU vous évite les complications des dépendances MSVC tout en maintenant d’excellentes performances.

Rust est un langage exigeant mais extrêmement puissant. Prenez le temps d’explorer ses concepts uniques comme la propriété (ownership), l’emprunt (borrowing), et les lifetimes.

Votre premier projet vous attend ! 🚀

Vous débutez avec Rust ? Partagez vos premières impressions ou difficultés rencontrées !

🎯 Introduction#

📋 Prérequis#

🔑 Pourquoi cette méthode fonctionne sans droits admin ?#

🚀 Installation de Rust via Scoop#

Étape 1 : Installation de rustup-gnu#

Étape 2 : Installation de MinGW-w64#

Étape 3 : Vérification de l’installation#

🔧 Résolution des problèmes courants#

Problème 1 : Dépendances MSVC manquantes#

Problème 2 : dlltool manquant#

🏗️ Configuration d’un projet web avec Axum#

Initialisation du projet#

Configuration Cargo.toml#

Exemple de serveur basique#

💡 Exemple concret#

📁 Structure recommandée d’un projet Rust#

🛠️ Commandes essentielles#

🔍 Dépannage avancé#

Gestion des toolchains multiples#

Problèmes de PATH persistants#

Conflits avec d’autres installations Rust#

🎯 Bonnes pratiques#

1. Utiliser un gestionnaire de versions#

2. Configuration VS Code optimale#

3. Gestion des dépendances#

🚀 Prochaines étapes#

📚 Ressources recommandées#

🎉 Conclusion#