Capas de middleware en Rust

Una capa envuelve cada ruta debajo de ella: logging, timeouts, compresión.

use std::time::Instant;

use axum::extract::Request;
use axum::middleware::{self, Next};
use axum::response::Response;
use axum::{routing::get, Router};

async fn timing(request: Request, next: Next) -> Response {
    let method = request.method().clone();
    let path = request.uri().path().to_string();
    let started = Instant::now();

    let response = next.run(request).await;

    println!("{method} {path} -> {} in {:?}", response.status(),
             started.elapsed());
    response
}

#[tokio::main]
async fn main() {
    let app = Router::new()
        .route("/", get(|| async { "ok" }))
        .layer(middleware::from_fn(timing));

    let listener = tokio::net::TcpListener::bind("127.0.0.1:8080")
        .await
        .unwrap();
    axum::serve(listener, app).await.unwrap();
}

Cómo funciona

1. layer aplica un servicio de tower al router entero.
2. middleware::from_fn convierte una async fn en una capa.
3. Las capas corren de afuera hacia adentro, al revés del orden en que se agregan.

Palabras clave y builtins usados aquí

• async
• await
• fn
• let
• self
• use

El intento, en números

Líneas

30

Caracteres a escribir

719

Tokens

217

Ritmo de tres estrellas

110 tpm

Al ritmo de tres estrellas de 110 tokens por minuto, este intento toma unos 118 segundos.

Escribe este fragmento

Paso 3 de 3 en Respuestas y middleware; paso 8 de 9 en Servicios web con axum.

← Anterior Siguiente →