Learn Rust Coding · Aula

Middleware

Camadas do Tower

Middleware é uma aula grátis de Learn Rust Coding no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Learn Rust Coding, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Learn Rust Coding inclui 4 aulas no total.

O que é middleware?

Middleware executa código antes e depois de um handler, envolvendo o ciclo de requisição e resposta. Use-o para logging, autenticação, compactação e timeouts.

O Axum se baseia no ecossistema tower
O middleware é adicionado como camadas

O trait Service

Tower define um Service: algo que recebe uma requisição e produz uma resposta de forma assíncrona. As camadas envolvem um serviço em outro.

Adicionando uma camada

Anexe middleware com .layer(). Aqui, adicionamos rastreamento de requisições de 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())
}

Ordem das camadas

As camadas são envolvidas de baixo para cima: a última camada adicionada é a mais externa. As requisições fluem de fora para dentro, e as respostas, de dentro para fora.

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 com from_fn

middleware::from_fn transforma uma função assíncrona em middleware. Ela recebe a requisição e um Next para chamar o restante da cadeia.

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
}

Integrando middleware personalizado

Envolva sua função com from_fn e adicione-a como uma camada.

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

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

Interrompendo requisições antecipadamente

O middleware pode retornar imediatamente sem chamar next, o que é útil para autenticação. Retornar uma resposta interrompe a cadeia.

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

Representando uma cadeia de middleware

Uma cadeia consiste simplesmente em funções que chamam a próxima. Este exemplo executável representa o envolvimento antes e depois.

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 rota

Aplique uma camada a uma única rota chamando .layer() no roteador do método, em vez de aplicá-la ao aplicativo inteiro.

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

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

Camadas comuns de tower_http

O crate tower_http fornece middleware prontos:

TraceLayer para logging
CompressionLayer para gzip
CorsLayer para CORS
TimeoutLayer para limitar o tempo das requisições

use tower_http::cors::CorsLayer;

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

Empilhando com ServiceBuilder

Agrupe várias camadas de forma organizada com ServiceBuilder, que as aplica de cima para baixo, garantindo uma ordem previsível.

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

Verificação rápida

Teste sua compreensão sobre middleware.

Recapitulação

Você aprendeu sobre middleware com camadas do tower:

Adicione middleware por meio de .layer(); a última camada adicionada é a mais externa
from_fn cria middleware personalizado usando Next
Retorne imediatamente para interromper a cadeia, por exemplo, na autenticação
tower_http oferece camadas de rastreamento, compactação, CORS e limite de tempo

Isso conclui o curso de Axum.

Perguntas Frequentes

A aula “Middleware” é grátis?

Sim — o texto completo de “Middleware” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Learn Rust Coding, atualize para CoddyKit PRO. O curso de Learn Rust Coding inclui 4 aulas no total.

O que vou aprender em “Middleware”?

Camadas do Tower Você pratica Learn Rust Coding com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Learn Rust Coding?

Nenhuma experiência prévia é necessária. Learn Rust Coding no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Middleware”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Learn Rust Coding?

Sim. Cada aula de Learn Rust Coding inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Learn Rust Coding