Learn Rust Coding · Leçon

Intergiciel

Couches Tower

Intergiciel est une leçon Learn Rust Coding gratuite sur CoddyKit. Ceci est la leçon 4 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’un middleware ?

Le middleware exécute du code avant et après un gestionnaire, en enveloppant le cycle requête/réponse. Utilisez-le pour la journalisation, l’authentification, la compression et les délais d’attente.

Axum s’appuie sur l’écosystème tower
Le middleware est ajouté sous forme de couches

Le trait Service

Tower définit un Service : un élément qui reçoit une requête et produit une réponse de manière asynchrone. Les couches enveloppent un service dans un autre.

Ajouter une couche

Associez un middleware avec .layer(). Ici, nous ajoutons le traçage des requêtes fourni par tower_http.

use axum::{Router, routing::get};
use tower_http::trace::TraceLayer;

fn app() -> Router {
    Router::new()
        .route("/", get(|| async { "ok" }))
        .layer(TraceLayer::new_for_http())
}

Ordre des couches

Les couches s’enveloppent de bas en haut : la dernière couche ajoutée est la plus externe. Les requêtes circulent de l’extérieur vers l’intérieur, et les réponses de l’intérieur vers l’extérieur.

use axum::{Router, routing::get};
use tower_http::{trace::TraceLayer, compression::CompressionLayer};

fn app() -> Router {
    Router::new()
        .route("/", get(|| async { "ok" }))
        .layer(CompressionLayer::new())
        .layer(TraceLayer::new_for_http())
}

Middleware personnalisé avec from_fn

middleware::from_fn transforme une fonction asynchrone en middleware. Il reçoit la requête et un Next qui permet d’appeler le reste de la chaîne.

use axum::{middleware::Next, response::Response, extract::Request};

async fn log_mw(req: Request, next: Next) -> Response {
    println!("{} {}", req.method(), req.uri());
    next.run(req).await
}

Intégrer un middleware personnalisé

Enveloppez votre fonction avec from_fn, puis ajoutez-la comme couche.

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

fn app() -> Router {
    Router::new()
        .route("/", get(|| async { "ok" }))
        .layer(middleware::from_fn(log_mw))
}

Interrompre prématurément les requêtes

Un middleware peut renvoyer une réponse immédiatement sans appeler next, ce qui est utile pour l’authentification. Renvoyer une réponse arrête la chaîne.

use axum::{middleware::Next, response::Response, extract::Request, http::StatusCode};

async fn auth(req: Request, next: Next) -> Result<Response, StatusCode> {
    if req.headers().contains_key("authorization") {
        Ok(next.run(req).await)
    } else {
        Err(StatusCode::UNAUTHORIZED)
    }
}

Modéliser une chaîne de middleware

Une chaîne n’est qu’un ensemble de fonctions qui appellent la suivante. Cet exemple exécutable modélise l’enveloppement avant/après.

fn handler() -> String {
    "response".to_string()
}

fn logging<F: Fn() -> String>(next: F) -> String {
    println!("-> request in");
    let res = next();
    println!("<- response out");
    res
}

fn main() {
    let out = logging(handler);
    println!("body: {}", out);
}

Middleware par route

Appliquez une couche à une seule route en appelant .layer() sur le routeur de méthodes plutôt que sur l’ensemble de l’application.

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

fn app() -> Router {
    Router::new().route(
        "/admin",
        get(|| async { "admin" }).layer(middleware::from_fn(auth)),
    )
}

Couches courantes de tower_http

La caisse tower_http fournit des middlewares prêts à l’emploi :

TraceLayer pour la journalisation
CompressionLayer pour gzip
CorsLayer pour CORS
TimeoutLayer pour limiter la durée des requêtes

use tower_http::cors::CorsLayer;

fn cors() -> CorsLayer {
    CorsLayer::permissive()
}

Empiler avec ServiceBuilder

Regroupez proprement plusieurs couches avec ServiceBuilder, qui les applique de haut en bas pour garantir un ordre prévisible.

use tower::ServiceBuilder;
use tower_http::{trace::TraceLayer, compression::CompressionLayer};

fn stack() -> ServiceBuilder<impl Sized> {
    ServiceBuilder::new()
        .layer(TraceLayer::new_for_http())
        .layer(CompressionLayer::new())
}

Vérification rapide

Vérifiez votre compréhension du middleware.

Récapitulatif

Vous avez appris à utiliser le middleware avec les couches tower :

Ajoutez un middleware via .layer() : le dernier ajouté est le plus externe
from_fn crée un middleware personnalisé à l’aide de Next
Renvoyez une réponse immédiatement pour interrompre la chaîne, par exemple pour l’authentification
tower_http fournit des couches de traçage, de compression, de CORS et de délai d’attente

Vous avez terminé le cours sur Axum.

Questions Fréquemment Posées

La leçon « Intergiciel » est-elle gratuite ?

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

Couches Tower 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 4 sur 4.

Combien de temps prend la leçon « Intergiciel » ?

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