Learn Rust Coding · Lección

Enrutamiento con Axum

Handlers y rutas

Enrutamiento con Axum es una lección gratuita de Learn Rust Coding en CoddyKit. Esta es la lección 1 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 Axum?

Axum es un framework web asíncrono y ergonómico del equipo de Tokio. Se basa en tower y hyper.

Los handlers son funciones asíncronas normales
El enrutamiento se basa en tipos y es componible
Se ejecuta sobre el runtime de Tokio

Un handler es una función

Un handler de Axum es una función asíncrona que devuelve algo convertible en una respuesta, como &str o String.

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

Construir un Router

El Router asigna rutas a handlers. Use route con un 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))
}

Iniciar el servidor

Vincule un listener TCP y sirva el router. La macro #[tokio::main] configura el runtime así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();
}

Varias rutas

Encadene llamadas a route para registrar varios endpoints en un mismo router.

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

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

Diferentes métodos HTTP

Combine handlers de distintos métodos en una misma ruta con get(...).post(...). Cada método se dirige a su propio handler.

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

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

Parámetros de ruta

Capture partes de la URL con un segmento {name} y léalas mediante el extractor Path.

use axum::extract::Path;

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

Modelar el enrutamiento en Rust puro

En esencia, el enrutamiento asigna una ruta a una respuesta. Este modelo ejecutable representa esa idea sin usar el 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"));
}

Anidar routers

Componga aplicaciones más grandes montando un subrouter bajo un prefijo con 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 respaldo

Defina qué ocurre con las rutas no coincidentes mediante fallback. Es perfecto 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)
}

Devolver códigos de estado

Un handler puede devolver una tupla de (StatusCode, body) para controlar con precisión el estado de la respuesta.

use axum::http::StatusCode;

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

Comprobación rápida

Compruebe su comprensión del enrutamiento de Axum.

Resumen

Ha aprendido los fundamentos del enrutamiento de Axum:

Los handlers son funciones asíncronas que devuelven una respuesta
Router::new().route(path, get(handler)) registra endpoints
Path captura segmentos de la URL
nest, fallback y las tuplas de estado dan forma a la aplicación

A continuación: los extractores analizan las solicitudes entrantes.

Preguntas frecuentes

¿La lección «Enrutamiento con Axum» es gratis?

Sí — el texto completo de «Enrutamiento con Axum» 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 «Enrutamiento con Axum»?

Handlers y rutas 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 1 de 4.

¿Cuánto tiempo toma la lección «Enrutamiento con Axum»?

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.

Todas las lecciones de este curso

Enrutamiento con Axum
Extractores
JSON y estado
Middleware

← Volver a Learn Rust Coding