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++ et la sécurité mémoire. Ces dernières années, il est activement utilisé pour créer des services web à forte charge et des API REST. Dans ce guide, nous allons créer en 30 minutes une API REST complète en Rust en utilisant le framework Actix-web.

Pourquoi choisir Rust pour une API REST ?

• Performances : Rust est compilé en code natif et n'utilise pas de ramasse-miettes, ce qui offre une vitesse maximale de traitement des requêtes.
• Sécurité : Le système de possession (ownership) et d'emprunt (borrowing) élimine des classes entières d'erreurs liées à la mémoire.
• Scalabilité : Actix-web est l'un des frameworks web les plus rapides au monde, capable de traiter des millions de requêtes par seconde.

À la fin de cet article, vous aurez un projet prêt avec plusieurs endpoints, une gestion des erreurs et une structure pour une extension future.

Étape 1 : Configuration du projet et installation des dépendances

La première chose à faire est de créer un nouveau projet Cargo. Ouvrez un terminal et exécutez :

cargo new rust_rest_apicd rust_rest_api

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

[dependencies]actix-web = "4"serde = { version = "1.0", features = ["derive"] }serde_json = "1.0"tokio = { version = "1", features = ["full"] }uuid = { version = "1.0", features = ["v4", "serde"] }

Voyons à quoi sert chaque bibliothèque :

• actix-web — le framework web principal pour créer un serveur HTTP.
• serde / serde_json — sérialisation et désérialisation des données au format JSON.
• tokio — le runtime asynchrone nécessaire au fonctionnement d'Actix.
• uuid — génération d'identifiants uniques pour nos entités.

Exécutez cargo build pour télécharger toutes les dépendances. Cela prendra un certain temps lors de la première exécution.

Étape 2 : Création du modèle de données et du stockage

Notre API va gérer une liste de tâches (application TODO). Créons un modèle simple. Ouvrez src/main.rs et ajoutez le code suivant :

use actix_web::{web, App, HttpServer, HttpResponse, middleware::Logger};use serde::{Deserialize, Serialize};use std::sync::Mutex;use uuid::Uuid;

// Modèle de tâche#[derive(Debug, Serialize, Deserialize, Clone)]struct Task {    id: Uuid,    title: String,    completed: bool,}

// Requête de création de tâche#[derive(Debug, Deserialize)]struct CreateTaskRequest {    title: String,}

// Stockage des tâches (en mémoire)struct AppState {    tasks: Mutex>,}

Nous utilisons Mutex pour un accès thread-safe aux données. Dans un projet réel, vous le remplaceriez par une base de données, mais pour la démonstration, cette option convient.

Ajoutons maintenant une fonction pour initialiser l'état de l'application :

fn init_tasks() -> Vec {    vec![        Task {            id: Uuid::new_v4(),            title: "Apprendre Rust".to_string(),            completed: false,        },        Task {            id: Uuid::new_v4(),            title: "Écrire une API REST".to_string(),            completed: true,        },    ]}

Étape 3 : Implémentation des endpoints CRUD

Créons maintenant les gestionnaires principaux pour notre API REST. Ajoutez le code suivant après la déclaration des modèles :

GET /tasks — récupération de la liste de toutes les tâches

async fn get_tasks(data: web::Data<AppState>) -> HttpResponse {    let tasks = data.tasks.lock().unwrap();    HttpResponse::Ok().json(tasks.clone())}

POST /tasks — création d'une nouvelle tâche

async fn create_task(    data: web::Dat