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

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 garantie à la compilation. Ces dernières années, Rust est activement utilisé pour créer des services web et des microservices à forte charge. Dans cet article, nous allons montrer comment écrire une API REST complète en Rust en 30 minutes à l'aide du framework Actix-web et de la bibliothèque Serde.

Pourquoi choisir Rust pour votre API ?

• Performances : Rust fonctionne au niveau du C/C++, ce qui est crucial pour les systèmes à forte charge.
• Sécurité : Le système de possession (ownership) et d'emprunt (borrowing) élimine des classes entières d'erreurs liées à la mémoire.
• Asynchronisme : La prise en charge intégrée d'async/await permet de gérer efficacement des milliers de connexions.
• Écosystème : Cargo (gestionnaire de paquets) et crates.io rendent la gestion des dépendances simple et pratique.

Nous allons créer une API simple pour gérer une liste de tâches (Todo list), qui prendra en charge les opérations CRUD. Vous apprendrez à configurer des routes, à traiter du JSON et à travailler avec l'état de l'application.

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

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

cargo new rust_todo_apicd rust_todo_api

Modifions maintenant le fichier Cargo.toml en ajoutant les dépendances nécessaires :

[package]name = "rust_todo_api"version = "0.1.0"edition = "2021"

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

Voyons à quoi sert chaque bibliothèque :

• actix-web — un framework web asynchrone performant.
• serde — une bibliothèque pour la sérialisation et la désérialisation des données (JSON).
• serde_json — le support du format JSON pour serde.
• tokio — le runtime asynchrone pour Rust (actix-web l'utilise par défaut).
• uuid — la génération d'identifiants uniques pour nos tâches.

Après avoir ajouté les dépendances, exécutez cargo build pour télécharger et compiler tous les paquets. Cela peut prendre quelques minutes lors de la première exécution.

Étape 2 : Création du modèle de données et de la structure de l'application

Créons le fichier src/main.rs et définissons le modèle de notre tâche. Nous allons utiliser la structure TodoItem avec les champs id, title et completed :

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

#[derive(Debug, Serialize, Deserialize, Clone)]struct TodoItem {    id: String,    title: String,    completed: bool,}

#[derive(Debug, Deserialize)]struct CreateTodoRequest {    title: String,}

#[derive(Debug, Deserialize)]struct UpdateTodoRequest {    title: Option<String>,    completed: Option<bool>,}

struct AppState {    todos: Mutex<Vec<TodoItem>>,}

Notez les détails importants :

• Serialize et Deserialize — des traits de serde qui génèrent automatiquement le code pour travailler avec JSON.
• Mutex — utilisé pour un accès sécurisé à l'état partagé depuis plusieurs threads.
• Uuid — génère des identifiants uniques pour chaque tâche.

Ajoutons maintenant la fonction main qui démarrera le serveur et initialisera l'état :

#[actix_web::main]async fn main() -> std::io::R