Lær Rust-programmering · leksjon

Middleware

Tower-lag

Leksjon 4 av 413 trinn

Middleware er en gratis leksjon i Lær Rust-programmering på CoddyKit. Dette er leksjon 4 av 4. Du kan lese valgfritt 3 leksjoner fra denne læringsstien gratis i sin helhet – deretter låser CoddyKit PRO opp alle leksjoner, samt praktisk øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Lær Rust-programmering, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Lær Rust-programmering inneholder totalt 4 leksjoner.

Hva er middleware?

Middleware kjører kode før og etter en handler og omslutter forespørsels-/svarsyklusen. Bruk det til logging, autentisering, komprimering og tidsavbrudd.

Axum bygger på tower-økosystemet
Middleware legges til som lag

Service-traitet

Tower definerer en Service: noe som tar imot en forespørsel og produserer et svar asynkront. Lag omslutter én tjeneste med en annen.

Legge til et lag

Fest middleware med .layer(). Her legger vi til sporing av forespørsler fra 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())
}

Rekkefølge på lag

Lag omslutter nedenfra og opp: det siste laget som legges til, er det ytterste. Forespørsler går fra ytre til indre lag, og svar går fra indre til ytre lag.

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())
}

Egendefinert middleware med from_fn

middleware::from_fn gjør en async-funksjon om til middleware. Den mottar forespørselen og en Next som kan kalle resten av kjeden.

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
}

Koble til egendefinert middleware

Omslutt funksjonen med from_fn og legg den til som et lag.

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

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

Kortslutte forespørsler

Middleware kan returnere tidlig uten å kalle next, noe som er nyttig for autentisering. Når et svar returneres, stopper kjeden.

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)
    }
}

Modellere en middleware-kjede

En kjede består ganske enkelt av funksjoner som kaller den neste funksjonen. Dette kjørbare eksempelet modellerer innpakking før og etter.

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 per rute

Bruk et lag på én enkelt rute ved å kalle .layer() på metode-ruteren i stedet for på hele appen.

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

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

Vanlige tower_http-lag

tower_http-craten leveres med ferdige middleware-komponenter:

TraceLayer for logging
CompressionLayer for gzip
CorsLayer for CORS
TimeoutLayer for å begrense forespørselstiden

use tower_http::cors::CorsLayer;

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

Stable lag med ServiceBuilder

Gruppér flere lag på en ryddig måte med ServiceBuilder, som bruker dem ovenfra og ned for å sikre en forutsigbar rekkefølge.

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())
}

Hurtigsjekk

Test forståelsen din av middleware.

Besvar den i den interaktive leksjonen

Oppsummering

Du har lært om middleware med tower-lag:

Legg til middleware via .layer(); det sist tilføyde laget er ytterst
from_fn bygger egendefinert middleware ved hjelp av Next
Returner tidlig for å kortslutte kjeden, for eksempel ved autentisering
tower_http tilbyr lag for sporing, komprimering, CORS og tidsavbrudd

Dette fullfører Axum-kurset.

Gratis å komme i gang

Lær deg Rust med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 39
Leksjoner: 144

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Middleware» gratis?

Ja – du kan lese valgfritt 3 av leksjonene i læringsstien Lær Rust-programmering, inkludert «Middleware», gratis i sin helhet her på nettet. Deretter låser CoddyKit PRO opp alle leksjoner, samt interaktiv øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Kurset i Lær Rust-programmering inneholder totalt 4 leksjoner.

Hva lærer jeg i «Middleware»?

Tower-lag Du øver på Lær Rust-programmering med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Lær Rust-programmering?

Ingen tidligere erfaring er nødvendig. Lær Rust-programmering på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 4 av 4.

Hvor lang tid tar leksjonen «Middleware»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Lær Rust-programmering-leksjonen?

Ja. Alle Lær Rust-programmering-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

← Tilbake til Lær Rust-programmering