Learn Rust Coding · Aula

Roteamento com Axum

Manipuladores e rotas

Roteamento com Axum é uma aula grátis de Learn Rust Coding no CoddyKit. Esta é a aula 1 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 é Axum?

Axum é um framework web assíncrono e ergonômico da equipe do Tokio. Ele se baseia em tower e hyper.

Os handlers são funções assíncronas comuns
O roteamento é orientado por tipos e combinável
É executado no ambiente de execução do Tokio

Um handler é uma função

Um handler do Axum é uma função assíncrona que retorna algo conversível em uma resposta, como &str ou String.

async fn hello() -> &'static str {
    "Hello, world!"
}

Criando um Router

O Router associa caminhos a handlers. Use route com um filtro de método HTTP, como get.

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

async fn hello() -> &'static str { "Hello" }

fn app() -> Router {
    Router::new().route("/", get(hello))
}

Iniciando o servidor

Associe um listener TCP e sirva o roteador. A macro #[tokio::main] configura o ambiente de execução assíncrono.

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

#[tokio::main]
async fn main() {
    let app = Router::new().route("/", get(|| async { "Hi" }));
    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();
    axum::serve(listener, app).await.unwrap();
}

Várias rotas

Encadeie chamadas de route para registrar vários endpoints em um único roteador.

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

fn app() -> Router {
    Router::new()
        .route("/", get(|| async { "home" }))
        .route("/about", get(|| async { "about" }))
}

Métodos HTTP diferentes

Combine handlers de métodos em um único caminho com get(...).post(...). Cada método é encaminhado para seu próprio handler.

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

fn app() -> Router {
    Router::new().route(
        "/items",
        get(|| async { "list" }).post(|| async { "create" }),
    )
}

Parâmetros de caminho

Capture partes da URL com um segmento {name} e leia-as por meio do extrator Path.

use axum::extract::Path;

async fn show(Path(id): Path<u32>) -> String {
    format!("item {}", id)
}

Representando o roteamento em Rust puro

Em sua essência, o roteamento associa um caminho a uma resposta. Este modelo executável representa essa ideia sem o framework.

fn route(path: &str) -> &str {
    match path {
        "/" => "home",
        "/about" => "about page",
        _ => "404 not found",
    }
}

fn main() {
    println!("{}", route("/"));
    println!("{}", route("/about"));
    println!("{}", route("/missing"));
}

Aninhando roteadores

Componha aplicativos maiores montando um sub-roteador sob um prefixo com nest.

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

fn api() -> Router {
    Router::new().route("/users", get(|| async { "users" }))
}

fn app() -> Router {
    Router::new().nest("/api", api())
}

Handler de fallback

Defina o que acontece com rotas não correspondentes usando fallback. É perfeito para páginas 404 personalizadas.

use axum::{Router, http::StatusCode};

async fn not_found() -> (StatusCode, &'static str) {
    (StatusCode::NOT_FOUND, "nothing here")
}

fn app() -> Router {
    Router::new().fallback(not_found)
}

Retornando códigos de status

Um handler pode retornar uma tupla de (StatusCode, body) para controlar o status da resposta com precisão.

use axum::http::StatusCode;

async fn create() -> (StatusCode, &'static str) {
    (StatusCode::CREATED, "created")
}

Verificação rápida

Teste sua compreensão sobre o roteamento do Axum.

Recapitulação

Você aprendeu os fundamentos do roteamento no Axum:

Handlers são funções assíncronas que retornam uma resposta
Router::new().route(path, get(handler)) registra endpoints
Path captura segmentos da URL
nest, fallback e tuplas de status estruturam o aplicativo

A seguir: extratores que analisam requisições recebidas.

Perguntas Frequentes

A aula “Roteamento com Axum” é grátis?

Sim — o texto completo de “Roteamento com Axum” é 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 “Roteamento com Axum”?

Manipuladores e rotas 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 1 de 4.

Quanto tempo leva a aula “Roteamento com Axum”?

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

Roteamento com Axum
Extratores
JSON e estado
Middleware

← Voltar para Learn Rust Coding