Créer une API REST en Rust avec Claude Code : guide 2026

Créer une API REST en Rust avec Claude Code

Le langage Rust s'est imposé comme le choix de référence pour bâtir des logiciels rapides, sûrs et fiables : performances proches du C, sécurité mémoire garantie à la compilation, absence de ramasse-miettes et concurrence sans *data races*. Pour une API REST qui doit tenir la charge sans surprises, difficile de trouver mieux. Son seul obstacle, c'est sa réputation de langage difficile — le fameux *borrow checker* et sa gestion stricte de la propriété découragent bien des débutants. C'est exactement là que Claude Code renverse la donne.

Plutôt que de vous battre avec les durées de vie et les emprunts, vous décrivez votre besoin en français — « une API REST pour gérer des tâches, avec CRUD complet et connexion PostgreSQL » — et l'agent écrit le code Rust, le compile, lit les diagnostics du compilateur et se corrige jusqu'à obtenir un service qui tourne. Ce guide vous montre comment créer une API REST en Rust avec Claude Code de A à Z : installation, première route avec Axum, structuration du projet, base de données, tests, gestion d'erreurs, conteneurisation et bonnes pratiques. Si vous débutez avec l'agent, gardez à portée notre guide complet de Claude Code.

Sommaire

Pourquoi Rust et Claude Code forment un duo idéal<a id="pourquoi"></a>

Rust a été pensé pour offrir des garanties fortes sans sacrifier la performance. Son compilateur refuse de produire un binaire tant qu'il subsiste un accès mémoire dangereux, une variable non initialisée ou une race condition potentielle. Cette intransigeance, source de frustration pour l'humain, est une aubaine pour un agent de code : chaque erreur est un signal précis, documenté, souvent accompagné de la correction suggérée.

Contrairement à un simple autocomplete, Claude Code est un agent : il lit vos fichiers, exécute des commandes dans le terminal, interprète les résultats et itère. Appliqué à Rust, cela donne une boucle d'auto-correction remarquablement efficace. Le compilateur rustc produit des messages d'erreur parmi les meilleurs de l'industrie — il pointe la ligne exacte, explique le problème d'*ownership* ou de *lifetime*, et propose fréquemment le correctif. Là où ce niveau de détail intimide le débutant, il devient le meilleur allié de l'IA : l'agent lit le diagnostic, comprend, corrige et relance cargo check. Le typage fort et le système de traits ferment la boucle de vérification.

Cette philosophie prolonge naturellement d'autres usages backend de l'agent. Si vous avez déjà lu notre tutoriel pour créer une API REST en Go avec Claude Code, vous retrouverez ici la même logique « décrire, générer, compiler, corriger » — appliquée à un langage encore plus strict, où les garanties du compilateur sont poussées à l'extrême.

Prérequis avant de commencer<a id="prerequis"></a>

Avant de générer votre première API Rust avec l'agent, réunissez quatre éléments :

Un réflexe utile dès le départ : ne mettez jamais de secrets (URL de base, clés d'API) en dur dans le code. Demandez à l'agent de les lire depuis des variables d'environnement, par exemple via la bibliothèque dotenvy.

Générer sa première route avec Axum<a id="premiere-route"></a>

Lancez Claude Code dans votre dossier et formulez une demande précise :

« Initialise un projet Cargo nommé tasks-api. Ajoute les dépendances Axum, Tokio et Serde. Crée un serveur HTTP qui écoute sur le port 8080 et expose une route GET /ping renvoyant un JSON {"message":"pong"}. Lance cargo run pour vérifier que le serveur démarre. »

L'agent édite le Cargo.toml, écrit le code, puis compile. Le résultat ressemble à ceci :

use axum::{routing::get, Json, Router};
use serde::Serialize;

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

async fn ping() -> Json<Message> {
    Json(Message {
        message: "pong".to_string(),
    })
}

#[tokio::main]
async fn main() {
    let app = Router::new().route("/ping", get(ping));
    let listener = tokio::net::TcpListener::bind("0.0.0.0:8080")
        .await
        .unwrap();
    println!("Serveur démarré sur http://localhost:8080");
    axum::serve(listener, app).await.unwrap();
}

En quelques secondes, vous disposez d'un serveur asynchrone bâti sur Tokio, le runtime de référence de l'écosystème Rust. L'agent a géré la sérialisation JSON avec Serde, le routage avec Axum et la boucle d'événements. Testez avec curl http://localhost:8080/ping : vous obtenez votre {"message":"pong"}.

Structurer le projet proprement<a id="structure"></a>

Une route unique dans main.rs suffit pour un test, mais une vraie API se structure en modules. Demandez à l'agent : « Réorganise le projet en modules séparés : routes, handlers, modèles et logique métier. Utilise un module par responsabilité. » Claude Code découpe alors le code en une arborescence claire :

src/
├── main.rs          // point d'entrée, configuration du routeur
├── routes.rs        // définition des routes
├── handlers.rs      // logique des endpoints
├── models.rs        // structs Serde (Task, CreateTask…)
└── db.rs            // accès à la base de données

Cette séparation en couches est essentielle en Rust, où le système de modules et la visibilité (pub) structurent fortement le code. L'agent gère les déclarations mod, les imports use et l'exposition des types. Le compilateur, lui, garantit qu'aucune référence ne pointe vers du vide : si un module oublie d'exposer une structure, cargo build échoue immédiatement et l'agent corrige.

Cette rigueur de structuration rappelle celle que nous appliquions dans notre guide pour écrire des tests unitaires en TDD avec Claude Code : un code bien découpé est un code que l'agent — comme l'humain — fait évoluer sans tout casser.

Brancher une base de données avec SQLx<a id="base-de-donnees"></a>

Passons à la persistance. Demandez : « Connecte l'API à PostgreSQL avec SQLx. Crée une table tasks (id, title, done) et implémente le CRUD complet : lister, créer, modifier, supprimer. Utilise un pool de connexions et lis l'URL depuis la variable d'environnement DATABASE_URL. »

L'agent ajoute sqlx au Cargo.toml, configure le pool, écrit les migrations et les requêtes. Voici à quoi ressemble un handler de création :

async fn create_task(
    State(pool): State<PgPool>,
    Json(payload): Json<CreateTask>,
) -> Result<Json<Task>, AppError> {
    let task = sqlx::query_as!(
        Task,
        "INSERT INTO tasks (title, done) VALUES ($1, $2) RETURNING id, title, done",
        payload.title,
        false
    )
    .fetch_one(&pool)
    .await?;

    Ok(Json(task))
}

Le point fort de SQLx ici est décisif : la macro query_as! vérifie la requête SQL à la compilation en la confrontant au schéma réel de votre base. Une colonne mal orthographiée, un type qui ne correspond pas ? cargo build échoue avant même la moindre exécution. Claude Code exploite ce filet de sécurité : il lit l'erreur, ajuste la requête ou la structure, et recompile. Vous obtenez une couche d'accès aux données validée statiquement — un luxe que peu de langages offrent. Pensez à vérifier la gestion des transactions et l'échappement (assuré ici par les requêtes paramétrées $1, $2).

Faire écrire les tests par l'agent<a id="tests"></a>

Rust intègre les tests dans le langage lui-même : pas besoin de framework externe pour commencer. Demandez à l'agent : « Écris des tests d'intégration pour les endpoints de l'API, avec une base de test isolée. » Claude Code génère un module de tests et lance cargo test :

#[cfg(test)]
mod tests {
    use super::*;

    #[tokio::test]
    async fn test_ping_renvoie_pong() {
        let app = build_router();
        let response = app
            .oneshot(Request::builder().uri("/ping").body(Body::empty()).unwrap())
            .await
            .unwrap();
        assert_eq!(response.status(), StatusCode::OK);
    }
}

L'agent exécute la suite, lit les échecs éventuels et corrige jusqu'au vert. Cette boucle « test → correction » est le cœur d'un développement fiable : elle transforme l'IA en un partenaire qui prouve que son code fonctionne au lieu de vous demander de le croire sur parole. Pour approfondir cette méthode, notre guide dédié au développement piloté par les tests détaille comment cadrer l'agent pour qu'il écrive les tests avant le code.

La gestion d'erreurs, terrain de jeu de Rust<a id="erreurs"></a>

Rust n'a pas d'exceptions : les erreurs sont des valeurs typées, gérées explicitement via les types Result et Option. C'est déroutant au début, mais redoutablement robuste — impossible d'oublier de traiter un cas d'échec, le compilateur vous y oblige.

Claude Code excelle sur ce terrain. Demandez-lui « ajoute une gestion d'erreurs propre qui convertit les erreurs internes en réponses HTTP adaptées (404, 400, 500) », et il crée un type d'erreur centralisé implémentant le trait IntoResponse d'Axum :

enum AppError {
    NotFound,
    Database(sqlx::Error),
}

impl IntoResponse for AppError {
    fn into_response(self) -> Response {
        let (status, message) = match self {
            AppError::NotFound => (StatusCode::NOT_FOUND, "Ressource introuvable"),
            AppError::Database(_) => (StatusCode::INTERNAL_SERVER_ERROR, "Erreur serveur"),
        };
        (status, Json(json!({ "error": message }))).into_response()
    }
}

Grâce à l'opérateur ?, chaque handler propage proprement ses erreurs sans code répétitif. Le résultat est une API qui ne « plante » jamais silencieusement : chaque cas d'échec est une réponse HTTP maîtrisée. Cette approche « données API » proche du contrat rejoint les préoccupations que l'on retrouve chez les spécialistes de l'exposition de données, comme le projet ImmoAPI, dédié aux API et à l'exploitation de données métier.

Conteneuriser et déployer<a id="docker"></a>

Un binaire Rust compilé est un exécutable statique autonome, idéal pour Docker. Demandez : « Génère un Dockerfile multi-stage qui compile en mode release et produit une image minimale. » L'agent produit un Dockerfile en deux étapes :

FROM rust:1.79 AS build
WORKDIR /app
COPY . .
RUN cargo build --release

FROM debian:bookworm-slim
COPY --from=build /app/target/release/tasks-api /usr/local/bin/tasks-api
EXPOSE 8080
CMD ["tasks-api"]

Le premier étage compile en mode optimisé, le second ne contient que le binaire sur une image slim légère — l'image finale reste compacte et réduit la surface d'attaque. Pour approfondir cette étape, notre guide Claude Code et Docker applique la même logique à d'autres stacks. L'agent peut ensuite générer un pipeline CI/CD pour compiler, tester et déployer à chaque commit.

Un CLAUDE.md taillé pour Rust<a id="claude-md"></a>

Le meilleur investissement pour rendre l'agent fiable et cohérent sur la durée tient dans un fichier : CLAUDE.md, placé à la racine et lu à chaque session. Il transmet vos conventions sans que vous ayez à les répéter :

## Conventions Rust pour ce projet
- Rust 1.79, édition 2021, framework web : Axum + Tokio
- Base de données : PostgreSQL via SQLx, requêtes vérifiées à la compilation
- Erreurs : type AppError centralisé, jamais de .unwrap() dans les handlers
- Config lue depuis variables d'environnement (dotenvy), jamais de secret en dur
- Avant tout commit : cargo fmt, cargo clippy, cargo test

Avec ces quelques lignes, l'agent respecte votre découpage, importe les bonnes dépendances et lance les contrôles adéquats — notamment cargo clippy, le linter qui traque les tournures non idiomatiques. Pour aller plus loin sur ce fichier central, consultez notre guide complet du fichier CLAUDE.md. Vous pouvez même créer des sous-agents spécialisés — un pour les handlers, un pour la revue de sécurité. Cette logique d'agents spécialisés et d'automatisation avancée est explorée en profondeur sur formation-openclaw.com, dédié aux agents IA open-source et à leur auto-hébergement en entreprise.

Vidéo : Claude Code en action

Pour visualiser la méthode de travail avec l'agent avant de vous lancer sur votre propre API Rust, cette vidéo montre le workflow de bout en bout — décrire, générer, corriger — qui s'applique directement à ce tutoriel :

Limites et pièges à connaître<a id="limites"></a>

Coupler une IA à votre développement Rust appelle quelques précautions lucides :

Gardées en tête, ces limites ne remettent pas en cause l'intérêt de l'approche : elles définissent le cadre d'un usage professionnel et sûr.

Passez à la vitesse supérieure

Vous savez désormais créer une API REST en Rust avec Claude Code : de la première route Axum à la structuration en modules, en passant par la base de données SQLx vérifiée à la compilation, les tests intégrés, une gestion d'erreurs typée et un Dockerfile multi-stage. Rust et Claude Code forment un duo redoutable — l'intransigeance du compilateur nourrit la boucle d'auto-correction de l'agent, et vous obtenez un backend parmi les plus sûrs et performants qui soient, en une fraction du temps habituel.

Reste l'étape suivante : transformer cette productivité en un véritable levier pour déléguer à l'IA une part croissante de votre travail.

👉 Découvrez comment déléguer une grande partie de votre travail à l'IA et vous concentrer sur l'essentiel : se faire remplacer par l'IA.

---

*Cet article fait partie de notre série de guides pratiques sur Claude Code. Pour aller plus loin, explorez le guide complet de Claude Code et notre tutoriel créer une API REST en Go.*