Learn Rust Coding · Leçon

Routage avec Axum

Gestionnaires et routes

Routage avec Axum 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.

Qu’est-ce qu’Axum ?

Axum est un framework web asynchrone et ergonomique créé par l’équipe de Tokio. Il s’appuie sur tower et hyper.

Les gestionnaires sont de simples fonctions asynchrones
Le routage est piloté par les types et composable
Le framework s’exécute sur l’environnement d’exécution Tokio

Un gestionnaire est une fonction

Dans Axum, un gestionnaire est une fonction asynchrone qui renvoie un élément convertible en réponse, comme &str ou String.

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

Construire un routeur

Le Router associe des chemins à des gestionnaires. Utilisez route avec un filtre de méthode HTTP comme get.

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

async fn hello() -> &'static str { "Hello" }

fn app() -> Router {
    Router::new().route("/", get(hello))
}

Démarrer le serveur

Liez un écouteur TCP et servez le routeur. La macro #[tokio::main] configure l’environnement d’exécution asynchrone.

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

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

Plusieurs routes

Enchaînez les appels à route pour enregistrer plusieurs points de terminaison sur un même routeur.

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

fn app() -> Router {
    Router::new()
        .route("/", get(|| async { "home" }))
        .route("/about", get(|| async { "about" }))
}

Différentes méthodes HTTP

Combinez les gestionnaires de méthodes sur un même chemin avec get(...).post(...). Chaque méthode achemine la requête vers son propre gestionnaire.

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

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

Paramètres de chemin

Capturez des parties de l’URL avec un segment {name}, puis lisez-les à l’aide de l’extracteur Path.

use axum::extract::Path;

async fn show(Path(id): Path<u32>) -> String {
    format!("item {}", id)
}

Modéliser le routage en Rust simple

À la base, le routage associe un chemin à une réponse. Ce modèle exécutable illustre cette idée sans framework.

fn route(path: &str) -> &str {
    match path {
        "/" => "home",
        "/about" => "about page",
        _ => "404 not found",
    }
}

fn main() {
    println!("{}", route("/"));
    println!("{}", route("/about"));
    println!("{}", route("/missing"));
}

Imbriquer des routeurs

Composez des applications plus grandes en montant un sous-routeur sous un préfixe avec nest.

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

fn api() -> Router {
    Router::new().route("/users", get(|| async { "users" }))
}

fn app() -> Router {
    Router::new().nest("/api", api())
}

Gestionnaire de repli

Définissez le comportement des routes introuvables avec fallback. C’est idéal pour créer des pages 404 personnalisées.

use axum::{Router, http::StatusCode};

async fn not_found() -> (StatusCode, &'static str) {
    (StatusCode::NOT_FOUND, "nothing here")
}

fn app() -> Router {
    Router::new().fallback(not_found)
}

Renvoyer des codes d’état

Un gestionnaire peut renvoyer un tuple (StatusCode, body) afin de contrôler précisément le statut de la réponse.

use axum::http::StatusCode;

async fn create() -> (StatusCode, &'static str) {
    (StatusCode::CREATED, "created")
}

Vérification rapide

Vérifiez votre compréhension du routage avec Axum.

Récapitulatif

Vous avez appris les bases du routage avec Axum :

Les gestionnaires sont des fonctions asynchrones qui renvoient une réponse
Router::new().route(path, get(handler)) enregistre des points de terminaison
Path capture les segments d’URL
nest, fallback et les tuples de statut structurent l’application

Ensuite : les extracteurs analysent les requêtes entrantes.

Questions Fréquemment Posées

La leçon « Routage avec Axum » est-elle gratuite ?

Oui — le texte complet de « Routage avec Axum » 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 « Routage avec Axum » ?

Gestionnaires et routes 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 « Routage avec Axum » ?

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

← Retour à Learn Rust Coding