Comment écrire une API REST en Rust en 30 minutes : guide pratique

Introduction : pourquoi Rust pour une API REST ?

Rust est un langage de programmation système moderne qui combine les performances du C/C++ et la sécurité mémoire sans ramasse-miettes. Pour créer une API REST, Rust propose plusieurs frameworks puissants, et Actix-web est l'un des plus populaires. Dans ce guide, nous allons créer pas à pas une API REST complète en Rust en 30 minutes. Vous verrez à quel point il est rapide de commencer, même si vous êtes débutant en Rust.

Préparation de l'environnement

Avant d'écrire du code, assurez-vous d'avoir Rust installé. Sinon, exécutez la commande :

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

Après l'installation, vérifiez la version :

rustc --version

Créez maintenant un nouveau projet :

cargo new rust_rest_api\ncd rust_rest_api

Ouvrez le fichier Cargo.toml et ajoutez les dépendances :

[dependencies]\nactix-web = "4"\nserde = { version = "1.0", features = ["derive"] }\nserde_json = "1.0"\ntokio = { version = "1", features = ["full"] }

Exécutez cargo build pour installer tous les paquets. Cela prendra 1 à 2 minutes.

Création d'une API REST de base en Rust

Commençons par un endpoint simple qui renvoie un message de bienvenue. Ouvrez src/main.rs et écrivez :

use actix_web::{web, App, HttpServer, Responder};\n\nasync fn hello() -> impl Responder {\n    "Bonjour le monde ! C'est une API REST en Rust !"\n}\n\n#[actix_web::main]\nasync fn main() -> std::io::Result<()> {\n    println!("Serveur démarré sur http://127.0.0.1:8080");\n    HttpServer::new(|| {\n        App::new()\n            .route("/", web::get().to(hello))\n    })\n    .bind("127.0.0.1:8080")?\n    .run()\n    .await\n}

Lancez le serveur avec la commande cargo run et ouvrez http://127.0.0.1:8080 dans votre navigateur. Vous verrez notre message de bienvenue. C'est la base de toute API REST en Rust.

Ajout d'une structure de données et du JSON

Une véritable API REST fonctionne avec du JSON. Créons un modèle utilisateur et un endpoint pour le récupérer :

use serde::{Deserialize, Serialize};\n\n#[derive(Serialize, Deserialize)]\nstruct User {\n    id: u32,\n    name: String,\n    email: String,\n}\n\nasync fn get_user() -> impl Responder {\n    let user = User {\n        id: 1,\n        name: "Ivan Petrov".to_string(),\n        email: "ivan@example.com".to_string(),\n    };\n    web::Json(user)\n}\n\n// Dans main(), ajoutez une nouvelle route :\n// .route("/user", web::get().to(get_user))

Maintenant, à l'adresse /user, vous obtiendrez un objet JSON. C'est un point clé : Rust sérialise automatiquement la structure en JSON grâce à serde.

Gestion des paramètres de requête et des requêtes POST

Une véritable API doit gérer différentes méthodes HTTP et paramètres. Ajoutons un endpoint pour créer un utilisateur via POST :

use actix_web::web::Json;\n\nasync fn create_user(user: Json<User>) -> impl Responder {\n    let new_user = user.into_inner();\n    println!("Utilisateur créé : {} ({})", new_user.name, new_user.email);\n    web::Json(new_user)\n}\n\n// Dans main() :\n// .route("/user", web::post().to(create_user))

Vous pouvez maintenant envoyer une requête POST avec un corps JSON, par exemple via curl :

curl -X POST http://127.0.0.1:8080/user \\\n  -H "Content-Type: application/json" \\\n  -d '{"id":2,"name":"Maria Smirnova","email":"maria@example.com"}'

Le serveur renverra le même objet, confirmant la création. C'est la base des opérations CRUD.

Gestion des paramètres de chemin et de chaîne de requête

Ajoutons un endpoint pour récupérer un utilisateur par son ID via un paramètre de chemin :

use actix_web::web::Path;\n\nasync fn get_user_by_id(path: Path<u32>) -> impl Responder {\n    let user_id = path.into_inner();\n    // Dans une application réelle, il y aurait ici une requête à la base de données\n