Middleware
Capas de Tower
Middleware es una lección gratuita de Learn Rust Coding en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Learn Rust Coding, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Learn Rust Coding incluye 4 lecciones en total.
¿Qué es el middleware?
El middleware ejecuta código antes y después de un handler, envolviendo el ciclo de solicitud y respuesta. Úselo para registro, autenticación, compresión y tiempos de espera.
- Axum se basa en el ecosistema de
tower - El middleware se añade como capas
El trait Service
Tower define un Service: algo que recibe una solicitud y produce una respuesta de forma asíncrona. Las capas envuelven un servicio dentro de otro.
Añadir una capa
Asocie middleware con .layer(). Aquí añadimos trazas de solicitudes desde 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())
}Orden de las capas
Las capas se envuelven de abajo arriba: la última capa añadida es la exterior. Las solicitudes fluyen de fuera hacia dentro y las respuestas, de dentro hacia fuera.
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 personalizado con from_fn
middleware::from_fn convierte una función asíncrona en middleware. Recibe la solicitud y un Next para llamar al resto de la cadena.
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
}Configurar middleware personalizado
Envuelva su función con from_fn y añádala como capa.
use axum::{Router, routing::get, middleware};
fn app() -> Router {
Router::new()
.route("/", get(|| async { "ok" }))
.layer(middleware::from_fn(log_mw))
}Interrumpir solicitudes
El middleware puede devolver una respuesta anticipadamente sin llamar a next, lo que resulta útil para la autenticación. Devolver una respuesta detiene la cadena.
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)
}
}Modelar una cadena de middleware
Una cadena consiste simplemente en funciones que llaman a la siguiente. Este ejemplo ejecutable modela el envoltorio anterior y posterior.
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 por ruta
Aplique una capa a una sola ruta llamando a .layer() en el router del método, en lugar de hacerlo en toda la aplicación.
use axum::{Router, routing::get, middleware};
fn app() -> Router {
Router::new().route(
"/admin",
get(|| async { "admin" }).layer(middleware::from_fn(auth)),
)
}Capas habituales de tower_http
El crate tower_http incluye middleware listo para usar:
TraceLayerpara el registroCompressionLayerpara gzipCorsLayerpara CORSTimeoutLayerpara limitar el tiempo de las solicitudes
use tower_http::cors::CorsLayer;
fn cors() -> CorsLayer {
CorsLayer::permissive()
}Apilar con ServiceBuilder
Agrupe varias capas de forma ordenada con ServiceBuilder, que las aplica de arriba abajo para mantener un orden predecible.
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())
}Comprobación rápida
Compruebe su comprensión del middleware.
Resumen
Ha aprendido sobre el middleware con capas de tower:
- Añada middleware mediante
.layer(); la última capa añadida es la exterior from_fncrea middleware personalizado medianteNext- Devuelva una respuesta anticipadamente para interrumpir la cadena, por ejemplo, en la autenticación
tower_httpofrece capas de trazas, compresión, CORS y tiempo de espera
Con esto termina el curso de Axum.
Preguntas frecuentes
¿La lección «Middleware» es gratis?
Sí — el texto completo de «Middleware» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Learn Rust Coding, actualiza a CoddyKit PRO. El curso de Learn Rust Coding incluye 4 lecciones en total.
¿Qué aprenderé en «Middleware»?
Capas de Tower Practicas Learn Rust Coding con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar Learn Rust Coding?
No se requiere experiencia previa. Learn Rust Coding en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.
¿Cuánto tiempo toma la lección «Middleware»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de Learn Rust Coding?
Sí. Cada lección de Learn Rust Coding incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.