0Pricing
Learn Rust Coding · Leçon

Configuration du projet

Structurer l’API

Configuration du projet est une leçon Learn Rust Coding gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. 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 4 leçons au total.

Créer une API REST en Rust

Dans ce cours, vous allez créer une petite API REST en Rust. Nous utilisons le framework web Axum, qui repose sur Tokio (environnement d’exécution asynchrone) et Tower (intergiciel). Il est ergonomique, sûr du point de vue des types et largement utilisé en production.

Cette première leçon met en place la structure du projet afin que les leçons suivantes puissent ajouter des routes, des modèles, une base de données et des tests.

Créer le projet

Commencez avec Cargo. Un projet binaire fournit un point d’entrée src/main.rs :

  • cargo new rest_api crée le dossier.
  • cd rest_api y accède.
  • cargo run compile et exécute.

Il s’agit de commandes du shell et de Cargo, pas d’extraits de code Rust exécutables.

// terminal
// cargo new rest_api
// cd rest_api
// cargo run

Ajouter des dépendances

Une API Axum nécessite quelques paquets dans Cargo.toml :

  • axum pour le routage et les gestionnaires.
  • tokio pour l’environnement d’exécution asynchrone.
  • serde pour la sérialisation JSON.
// Cargo.toml
// [dependencies]
// axum = "0.7"
// tokio = { version = "1", features = ["full"] }
// serde = { version = "1", features = ["derive"] }
// serde_json = "1"

L’environnement d’exécution asynchrone

Les serveurs web gèrent de nombreuses connexions simultanément, c’est pourquoi Axum est asynchrone. L’attribut #[tokio::main] transforme un main asynchrone en véritable point d’entrée en démarrant l’environnement d’exécution Tokio. Chaque gestionnaire peut utiliser .await pour effectuer des entrées-sorties non bloquantes.

// src/main.rs
use tokio;

#[tokio::main]
async fn main() {
    println!("runtime started");
}

Un serveur minimal

La plus petite application Axum crée un Router, associe un écouteur TCP et sert les requêtes. Une seule route associe GET / à un gestionnaire qui renvoie une chaîne. Les gestionnaires sont simplement des fonctions asynchrones qui renvoient quelque chose implémentant IntoResponse.

use axum::{routing::get, Router};

#[tokio::main]
async fn main() {
    let app = Router::new().route("/", get(root));
    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000")
        .await.unwrap();
    axum::serve(listener, app).await.unwrap();
}

async fn root() -> &'static str {
    "Hello, API!"
}

Fonctionnement du routage

Un Router associe un chemin et une méthode HTTP à un gestionnaire. Enchaînez des appels .route(path, method(handler)) pour enregistrer des points de terminaison. Les fonctions utilitaires de méthode comme get, post, put et delete proviennent de axum::routing. Vous pouvez combiner plusieurs méthodes sur un même chemin.

use axum::{routing::{get, post}, Router};

async fn list() -> &'static str { "list" }
async fn create() -> &'static str { "created" }

fn build_router() -> Router {
    Router::new()
        .route("/items", get(list).post(create))
        .route("/health", get(|| async { "ok" }))
}

Organisation recommandée des modules

À mesure que l’API grandit, répartissez le code dans des modules plutôt que de tout mettre dans un seul main.rs :

  • main.rs — démarrage et configuration du serveur.
  • routes.rs — définition du routeur.
  • handlers.rs — gestionnaires des requêtes.
  • models.rs — structures de données.

Cette séparation permet à chaque fichier de rester ciblé et facile à tester.

// src/main.rs
mod routes;
mod handlers;
mod models;

#[tokio::main]
async fn main() {
    let app = routes::build();
    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000")
        .await.unwrap();
    axum::serve(listener, app).await.unwrap();
}

État partagé de l’application

La plupart des API ont besoin d’un état partagé, comme un groupe de connexions à une base de données ou un stockage en mémoire. Axum le conserve avec .with_state(state) sur le routeur. Les gestionnaires le reçoivent via l’extracteur State. L’état doit être Clone ; enveloppez les données mutables dans un Arc et un verrou.

use axum::{routing::get, Router, extract::State};
use std::sync::{Arc, Mutex};

type Db = Arc<Mutex<Vec<String>>>;

async fn count(State(db): State<Db>) -> String {
    let n = db.lock().unwrap().len();
    format!("{} items", n)
}

fn build(db: Db) -> Router {
    Router::new().route("/count", get(count)).with_state(db)
}

Renvoyer du JSON

Pour envoyer du JSON, enveloppez une valeur sérialisable dans axum::Json. Si serde dérive Serialize pour vos structures, Axum définit automatiquement le type de contenu et le corps corrects.

use axum::Json;
use serde::Serialize;

#[derive(Serialize)]
struct Status {
    service: String,
    healthy: bool,
}

async fn health() -> Json<Status> {
    Json(Status { service: "api".into(), healthy: true })
}

Configuration et ports

Coder le port en dur convient pour les démonstrations, mais les vrais services lisent la configuration depuis l’environnement. Utilisez std::env::var avec une valeur par défaut. Vous pourrez ainsi modifier l’adresse d’écoute sans recompiler et mieux fonctionner avec les conteneurs.

use std::env;

async fn main_inner() {
    let port = env::var("PORT").unwrap_or_else(|_| "3000".to_string());
    let addr = format!("0.0.0.0:{}", port);
    println!("binding to {}", addr);
    // bind and serve with addr ...
}

Assembler la configuration

Un démarrage complet relie tous les éléments : construisez le routeur avec les routes et l’état partagé, lisez le port, liez un écouteur, puis lancez le service. Une fois cette structure en place, les prochaines leçons ajouteront de vrais points d’accès, des modèles et la persistance.

use axum::{routing::get, Router};
use std::sync::{Arc, Mutex};

#[tokio::main]
async fn main() {
    let db = Arc::new(Mutex::new(Vec::<String>::new()));
    let app = Router::new()
        .route("/health", get(|| async { "ok" }))
        .with_state(db);
    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000")
        .await.unwrap();
    axum::serve(listener, app).await.unwrap();
}

Vérification rapide

Vérifiez votre compréhension de la configuration du projet.

Récapitulatif

Vous avez configuré un projet d’API REST en Rust :

  • Utilisez cargo new et ajoutez axum, tokio et serde.
  • #[tokio::main] fournit l’environnement d’exécution asynchrone.
  • Un Router associe les chemins et les méthodes à des gestionnaires asynchrones.
  • Partagez les données avec .with_state et l’extracteur State.
  • Répartissez le code entre les modules de routes, de gestionnaires et de modèles ; lisez le port depuis l’environnement.

Questions Fréquemment Posées

La leçon « Configuration du projet » est-elle gratuite ?

Oui — le texte complet de « Configuration du projet » 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 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Configuration du projet » ?

Structurer l’API 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 4.

Combien de temps prend la leçon « Configuration du projet » ?

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

  1. Configuration du projet
  2. Points d’accès et modèles
  3. Intégration de la base de données
  4. Tester l’API
← Retour à Learn Rust Coding