Rust-ohjelmoinnin perusteet · Oppitunti

Middleware

Tower-kerrokset.

Oppitunti 4/413 vaihetta

Middleware on ilmainen Rust-ohjelmoinnin perusteet-oppitunti CoddyKitissä. Tämä on oppitunti 4/4. Voit lukea tästä oppimispolusta kokonaan mitkä tahansa 3 oppituntia ilmaiseksi — sen jälkeen CoddyKit PRO avaa kaikki oppitunnit sekä käytännön harjoittelun sisäänrakennetulla koodieditorilla ja ympäri vuorokauden toimivalla tekoälytuutorilla. Oppitunti kuuluu Rust-ohjelmoinnin perusteet-oppimispolkuun, ja edistymisesi synkronoituu verkon ja CoddyKit-sovelluksen välillä. Rust-ohjelmoinnin perusteet-kurssilla on yhteensä 4 oppituntia.

Mitä väliohjelmisto on?

Middleware suorittaa koodia käsittelijän edellä ja jäljessä ja ympäröi pyyntö–vastauskierron. Käyttäkää sitä lokitukseen, todentamiseen, pakkaukseen ja aikakatkaisuihin.

Axum rakentuu tower-ekosysteemin varaan
Middleware lisätään layer-kerroksina

Service-trait

Tower määrittelee Service-palvelun: se vastaanottaa pyynnön ja tuottaa vastauksen asynkronisesti. Layerit käärivät yhden palvelun toisen ympärille.

Layerin lisääminen

Liittäkää middleware käyttämällä .layer()-metodia. Tässä lisäämme pyyntöjen jäljityksen paketista 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())
}

Layerien järjestys

Layerit käärivät alhaalta ylöspäin: viimeksi lisätty layer on ulommaisin. Pyynnöt kulkevat ulkoa sisäänpäin ja vastaukset sisältä ulospäin.

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

Mukautettu middleware from_fn-funktiolla

middleware::from_fn muuntaa asynkronisen funktion middlewareksi. Se vastaanottaa pyynnön ja Next-arvon, jolla kutsutaan ketjun loppuosaa.

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
}

Mukautetun middlewaren kytkeminen

Ympäröikää funktionne from_fn-funktiolla ja lisätkää se layeriksi.

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

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

Pyyntöjen ketjun katkaiseminen

Middleware voi palauttaa vastauksen aikaisin kutsumatta next-arvoa, mikä on hyödyllistä esimerkiksi todentamisessa. Vastauksen palauttaminen pysäyttää ketjun.

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

Middleware-ketjun mallintaminen

Ketju koostuu yksinkertaisesti funktioista, jotka kutsuvat seuraavaa funktiota. Tämä suoritettava esimerkki mallintaa ennen- ja jälkeen-käsittelyn ympäröivän rakenteen.

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

Reittikohtainen middleware

Voitte liittää layerin yhdelle reitille kutsumalla .layer()-metodia metodi-reitittimelle koko sovelluksen sijaan.

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

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

Yleisiä tower_http-layereita

tower_http-crate sisältää valmiita middleware-komponentteja:

TraceLayer lokitukseen
CompressionLayer gzip-pakkaukseen
CorsLayer CORS-toiminnallisuuteen
TimeoutLayer pyyntöjen keston rajoittamiseen

use tower_http::cors::CorsLayer;

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

Pinoaminen ServiceBuilderilla

Ryhmitelkää useita layereita siististi ServiceBuilder-rakenteella, joka ottaa ne käyttöön ylhäältä alaspäin ennakoitavan järjestyksen takaamiseksi.

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

Pikatarkistus

Testatkaa, kuinka hyvin ymmärrätte middlewaren.

Vastaa interaktiivisessa oppitunnissa

Kertaus

Opitte käyttämään middlewarea tower-layereiden kanssa:

Lisätkää middleware .layer()-metodilla; viimeksi lisätty layer on uloin
from_fn rakentaa mukautetun middlewaren käyttäen Next-arvoa
Palauttakaa vastaus aikaisin ketjun katkaisemiseksi, esimerkiksi todentamista varten
tower_http tarjoaa jäljitys-, pakkaus-, CORS- ja aikakatkaisulayereita

Tähän päättyy Axum-kurssi.

Aloita maksutta

Opi Rust tekoälytuutorin avulla — ilmaiseksi

Kirjoita ja suorita oikeaa koodia selaimessa, saa välitöntä apua tekoälytuutorilta ympäri vuorokauden ja jatka siitä, mihin jäit, verkossa tai sovelluksessa.

Kurssit: 39
Oppitunnit: 144

Aloita opiskelu maksutta Näytä koko kurssi

Usein kysytyt kysymykset

Onko oppitunti ”Middleware” ilmainen?

Kyllä — voit lukea täällä verkossa kokonaan ilmaiseksi mitkä tahansa Rust-ohjelmoinnin perusteet-oppimispolun 3 oppituntia, myös oppitunnin “Middleware”. Sen jälkeen CoddyKit PRO avaa kaikki oppitunnit sekä interaktiiviset harjoitukset sisäänrakennetulla koodieditorilla ja ympäri vuorokauden toimivalla tekoälytuutorilla. Rust-ohjelmoinnin perusteet-kurssilla on yhteensä 4 oppituntia.

Mitä opin oppitunnilla ”Middleware”?

Tower-kerrokset. Harjoittelet Rust-ohjelmoinnin perusteet-aihetta koodilla, jonka suoritat suoraan selaimessa. Ympäri vuorokauden käytettävissä oleva tekoälytuutori vastaa kysymyksiisi oppitunnin aikana.

Tarvitsenko kokemusta aloittaakseni Rust-ohjelmoinnin perusteet-opiskelun?

Aiempi kokemus ei ole tarpeen. CoddyKitin Rust-ohjelmoinnin perusteet-oppimispolku sopii vasta-alkajista edistyneisiin, joten voit aloittaa tästä tai alusta ja edetä omaan tahtiisi. Tämä on oppitunti 4/4.

Kuinka kauan ”Middleware”-oppitunnin suorittaminen kestää?

Useimmat CoddyKitin oppitunnit kestävät noin 5–10 minuuttia. Jokainen oppitunti on lyhyt ja interaktiivinen, joten edistyt tasaisesti ja voit jatkaa siitä, mihin jäit – sekä verkossa että sovelluksessa.

Voinko kirjoittaa ja suorittaa koodia tällä Rust-ohjelmoinnin perusteet-oppitunnilla?

Kyllä. Jokainen Rust-ohjelmoinnin perusteet-oppitunti sisältää sisäänrakennetun koodieditorin, joten voit kirjoittaa ja suorittaa oikeaa koodia suoraan selaimessa ja saada välitöntä palautetta tekoälyltä – paikallista asennusta ei tarvita.

Kaikki tämän kurssin oppitunnit

← Takaisin: Rust-ohjelmoinnin perusteet