Learn Rust Coding · Leçon

API REST avec Actix-web/Rocket

Développez des API RESTful à l’aide d’un framework web Rust moderne comme Actix-web ou Rocket, en gérant les routes, les requêtes et les réponses.

API REST avec Actix-web/Rocket est une leçon Learn Rust Coding gratuite sur CoddyKit. Ceci est la leçon 1 sur 3. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Learn Rust Coding, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Learn Rust Coding comprend 3 leçons au total.

Que sont les API REST ?

REST, ou REpresentational State Transfer, est un style architectural destiné aux applications en réseau. Il définit un ensemble de principes régissant la communication des services web.

Considérez-le comme un ensemble de recommandations pour créer des services web sans état, pouvant utiliser la mise en cache et s’appuyant sur les méthodes HTTP standard pour interagir avec des ressources.

Ressources : tout ce qui peut être nommé, comme un utilisateur, un produit ou une commande.
URI : identifiants uniques des ressources, par exemple /users/123.
Méthodes HTTP : actions standard effectuées sur les ressources (GET, POST, PUT, DELETE).

Pourquoi choisir Rust pour les services web ?

Rust apporte des avantages uniques au développement de services web, ce qui en fait un choix solide pour des API hautement performantes et fiables :

Performances : les abstractions sans coût à l’exécution de Rust permettent d’obtenir un code très efficace, souvent comparable à celui de C/C++.
Sécurité de la mémoire : le système de propriété évite les bogues courants comme le déréférencement de pointeurs nuls et les courses de données, pour des services plus robustes.
Concurrence : le modèle async/await de Rust, associé à ses garanties de sécurité, permet de créer sereinement des services web concurrents.
Fiabilité : le système de types strict et les vérifications à la compilation détectent de nombreuses erreurs en amont.

Découvrez Actix-web

Pour créer des services web en Rust, nous utilisons souvent des cadriciels. Actix-web est un cadriciel web Rust puissant, pragmatique et extrêmement rapide.

Il est construit au-dessus d’Actix, un cadriciel fondé sur les acteurs, mais vous n’avez pas besoin de comprendre les acteurs pour utiliser Actix-web efficacement. Il est conçu pour les opérations asynchrones, ce qui le rend idéal pour les tâches limitées par les entrées-sorties, comme la gestion de nombreuses requêtes API simultanées.

Actix-web fournit des outils pour le routage, la gestion des requêtes et des réponses, les intergiciels et bien plus encore, ce qui simplifie la création d’API complexes.

Configuration du projet et dépendances

Pour commencer, vous allez créer un nouveau projet Rust et ajouter les dépendances nécessaires. Vous utiliserez actix-web pour le framework et serde pour sérialiser et désérialiser les données JSON.

Commencez par créer un nouveau projet :

cargo new my_rest_api --bin

Ajoutez ensuite ces lignes à votre fichier Cargo.toml, dans la section [dependencies] :

[dependencies]
actix-web = "4"
serde = { version = "1.0", features = ["derive"] }

Votre premier serveur Actix-web

Écrivons un serveur Actix-web minimal. Ce code met en place la structure de base pour écouter les requêtes HTTP entrantes sur le port 8080. Il ne gère encore aucune route particulière, mais constitue le socle de notre application.

La macro #[actix_web::main] rend notre async fn main compatible avec l’environnement d’exécution d’Actix-web.

use actix_web::{App, HttpServer};

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    println!("Server running at http://127.0.0.1:8080");
    HttpServer::new(|| {
        // Our application instance, where we'll add routes
        App::new()
    })
    .bind(("127.0.0.1", 8080))? // Bind to an IP address and port
    .run() // Start the server
    .await // Await its completion
}

Définir une route GET

Ajoutons maintenant une route simple à notre serveur. Une route associe le chemin et la méthode d’une requête HTTP entrante (comme GET /hello) à une fonction de traitement particulière.

Notre fonction de traitement hello_world renverra simplement une chaîne de caractères. web::get().to() enregistre cette fonction pour les requêtes GET vers le chemin /hello.

use actix_web::{web, App, HttpServer, Responder};

// A handler function that returns a simple string response
async fn hello_world() -> impl Responder {
    "Hello, Actix-web!"
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    println!("Server running at http://127.0.0.1:8080");
    HttpServer::new(|| {
        App::new()
            // Register our route: GET /hello maps to hello_world()
            .route("/hello", web::get().to(hello_world))
    })
    .bind(("127.0.0.1", 8080))?
    .run()
    .await
}

Paramètres de chemin pour les routes dynamiques

Les API doivent souvent gérer des éléments dynamiques dans l’URL, comme un identifiant ou un nom. Actix-web utilise des paramètres de chemin pour capturer ces valeurs.

Vous définissez un espace réservé dans la route (par exemple, /{name}). Dans la fonction de traitement, vous utilisez web::Path<String> (ou tout autre type pouvant être désérialisé) pour extraire la valeur.

use actix_web::{web, App, HttpServer, Responder};

// Handler function with a path parameter 'name'
async fn greet_name(name: web::Path<String>) -> impl Responder {
    format!("Hello, {}!", name.into_inner())
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    println!("Server running at http://127.0.0.1:8080");
    HttpServer::new(|| {
        App::new()
            // Route with a dynamic path segment for a name
            .route("/greet/{name}", web::get().to(greet_name))
    })
    .bind(("127.0.0.1", 8080))?
    .run()
    .await
}

Gérer les requêtes POST et le JSON

Pour créer ou mettre à jour des ressources, vous utilisez des requêtes POST ou PUT, qui envoient souvent les données au format JSON dans le corps de la requête.

Actix-web simplifie la gestion du JSON grâce à web::Json<T>. Vous définissez une struct Rust correspondant à la structure JSON attendue, vous dérivez Deserialize depuis serde, puis Actix-web analyse automatiquement le JSON entrant pour le convertir en votre structure.

use actix_web::{web, App, HttpServer, Responder};
use serde::{Deserialize, Serialize};

// Define a struct to represent our incoming JSON data
#[derive(Deserialize, Serialize)]
struct User {
    username: String,
    email: String,
}

// Handler for POST requests that accepts a JSON User object
async fn create_user(user: web::Json<User>) -> impl Responder {
    // In a real app, you'd save this user to a database
    format!("User created: {} ({})", user.username, user.email)
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    println!("Server running at http://127.0.0.1:8080");
    HttpServer::new(|| {
        App::new()
            // POST /users expects a JSON body and maps to create_user()
            .route("/users", web::post().to(create_user))
    })
    .bind(("127.0.0.1", 8080))?
    .run()
    .await
}

Créer une API simple avec un état

Mettons en pratique ce que vous avez appris pour créer une petite API qui gère une liste d’utilisateurs en mémoire. Vous utiliserez web::Data pour partager l’état propre à l’application (notre liste d’utilisateurs) entre les fonctions de traitement.

std::sync::Mutex permet d’autoriser en toute sécurité un accès mutable à notre Vec<User> depuis plusieurs requêtes simultanées. Vous disposerez de points d’accès pour GET /users et POST /users.

use actix_web::{web, App, HttpServer, Responder, HttpResponse};
use serde::{Deserialize, Serialize};
use std::sync::Mutex; // For shared mutable state

// Define a User struct that can be serialized/deserialized and cloned
#[derive(Deserialize, Serialize, Clone)]
struct User {
    id: u32,
    username: String,
    email: String,
}

// Application state to hold our users and track next ID
struct AppState {
    users: Mutex<Vec<User>>,
    next_id: Mutex<u32>,
}

// Handler to get all users
async fn get_users(data: web::Data<AppState>) -> impl Responder {
    let users = data.users.lock().unwrap(); // Acquire a lock
    web::Json(users.clone()) // Return users as JSON
}

// Handler to create a new user
async fn create_user(
    data: web::Data<AppState>,
    new_user: web::Json<User>,
) -> impl Responder {
    let mut users = data.users.lock().unwrap();
    let mut next_id = data.next_id.lock().unwrap();

    let user = User {
        id: *next_id,
        username: new_user.username.clone(),
        email: new_user.email.clone(),
    };
    users.push(user.clone());
    *next_id += 1; // Increment for the next user
    HttpResponse::Created().json(user) // Return 201 Created status and user
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    println!("Server running at http://127.0.0.1:8080");
    // Create shared application state
    let app_state = web::Data::new(AppState {
        users: Mutex::new(vec![]), // Initialize with an empty user list
        next_id: Mutex::new(1),    // Start IDs from 1
    });

    HttpServer::new(move || { // 'move' closure to capture app_state
        App::new()
            .app_data(app_state.clone()) // Register shared state with the app
            .route("/users", web::get().to(get_users))
            .route("/users", web::post().to(create_user))
    })
    .bind(("127.0.0.1", 8080))?
    .run()
    .await
}

Vérification rapide des concepts d’API

Vous avez appris à configurer un serveur Actix-web de base et à gérer différentes requêtes HTTP. Vérifions votre compréhension !

Récapitulatif et prochaines étapes

Bravo ! Vous avez fait vos premiers pas dans la création d’API REST avec Rust et Actix-web.

Nous avons étudié les principes fondamentaux des API REST et les raisons pour lesquelles Rust convient parfaitement à cet usage.
Vous avez appris à configurer un projet Actix-web de base.
Nous avons vu comment définir des routes GET et POST.
Vous avez découvert comment extraire des paramètres de chemin et gérer des données JSON.
Enfin, vous avez créé une API simple qui gère un état en mémoire avec web::Data.

Vous allez maintenant approfondir l’intégration d’une base de données et la gestion robuste des erreurs afin de créer des services web encore plus puissants et prêts pour la production !

Questions Fréquemment Posées

La leçon « API REST avec Actix-web/Rocket » est-elle gratuite ?

Oui — le texte complet de « API REST avec Actix-web/Rocket » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Learn Rust Coding, passe à CoddyKit PRO. Le cours Learn Rust Coding comprend 3 leçons au total.

Qu'est-ce que j'apprendrai dans « API REST avec Actix-web/Rocket » ?

Développez des API RESTful à l’aide d’un framework web Rust moderne comme Actix-web ou Rocket, en gérant les routes, les requêtes et les réponses. Tu pratiques Learn Rust Coding avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Learn Rust Coding ?

Aucune expérience préalable n'est requise. Learn Rust Coding sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 3.

Combien de temps prend la leçon « API REST avec Actix-web/Rocket » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Learn Rust Coding ?

Oui. Chaque leçon Learn Rust Coding inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

API REST avec Actix-web/Rocket
Intégration de bases de données (SQLx/Diesel)
Authentification et autorisation

← Retour à Learn Rust Coding