Learn Rust Coding · Lección

API REST con Actix-web/Rocket

Desarrolle API RESTful utilizando un framework web moderno de Rust, como Actix-web o Rocket, y gestione rutas, solicitudes y respuestas.

API REST con Actix-web/Rocket es una lección gratuita de Learn Rust Coding en CoddyKit. Esta es la lección 1 de 3. 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 3 lecciones en total.

¿Qué son las API REST?

REST, o REpresentational State Transfer, es un estilo arquitectónico para aplicaciones conectadas en red. Define un conjunto de principios sobre cómo deben comunicarse los servicios web.

Considérelo un conjunto de pautas para crear servicios web sin estado, almacenables en caché y que utilicen métodos HTTP estándar para interactuar con recursos.

Recursos: Cualquier elemento al que se pueda asignar un nombre, como un usuario, un producto o un pedido.
URI: Identificadores únicos de los recursos, por ejemplo, /users/123.
Métodos HTTP: Acciones estándar realizadas sobre los recursos (GET, POST, PUT, DELETE).

¿Por qué Rust para servicios web?

Rust aporta ventajas únicas al desarrollo de servicios web, por lo que es una opción sólida para API de alto rendimiento y fiables:

Rendimiento: Las abstracciones de coste cero de Rust permiten crear código muy eficiente, a menudo comparable al de C/C++.
Seguridad de memoria: El sistema de ownership evita errores comunes, como la desreferenciación de punteros nulos y las condiciones de carrera de datos, lo que produce servicios más robustos.
Concurrencia: El modelo async/await de Rust, combinado con sus garantías de seguridad, facilita la creación de servicios web concurrentes de forma «sin miedo».
Fiabilidad: El sistema de tipos sólido y las comprobaciones en tiempo de compilación detectan muchos errores pronto.

Conozca Actix-web

Para crear servicios web en Rust, solemos usar frameworks. Actix-web es un framework web potente, pragmático y extremadamente rápido para Rust.

Está construido sobre Actix, un framework de actores, pero no necesita comprender los actores para usar Actix-web eficazmente. Está diseñado para operaciones asíncronas, por lo que es ideal para tareas limitadas por E/S, como gestionar muchas solicitudes de API simultáneas.

Actix-web proporciona herramientas para el enrutamiento, la gestión de solicitudes y respuestas, el middleware y mucho más, lo que simplifica la creación de API complejas.

Configuración del proyecto y dependencias

Para empezar, crearemos un nuevo proyecto de Rust y añadiremos las dependencias necesarias. Usaremos actix-web para el framework y serde para serializar y deserializar datos JSON.

Primero, cree un proyecto nuevo:

cargo new my_rest_api --bin

Después, añada estas líneas al archivo Cargo.toml, dentro de la sección [dependencies]:

[dependencies]
actix-web = "4"
serde = { version = "1.0", features = ["derive"] }

Su primer servidor Actix-web

Vamos a escribir un servidor Actix-web mínimo. Este código configura la estructura básica para escuchar solicitudes HTTP entrantes en el puerto 8080. Todavía no gestiona ninguna ruta específica, pero constituye la base.

La macro #[actix_web::main] hace que nuestro async fn main sea compatible con el runtime de Actix-web.

use actix_web::{App, HttpServer};

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    println!("Server running at http://127.0.0.1:8080");
    HttpServer::new(|| {
        // Our application instance, where we'll add routes
        App::new()
    })
    .bind(("127.0.0.1", 8080))? // Bind to an IP address and port
    .run() // Start the server
    .await // Await its completion
}

Definir una ruta GET

Ahora vamos a añadir una ruta sencilla a nuestro servidor. Una ruta asigna la ruta y el método de una solicitud HTTP entrante, como GET /hello, a una función controladora específica.

Nuestra función controladora hello_world simplemente devolverá una cadena. web::get().to() registra esta función para las solicitudes GET dirigidas a la ruta /hello.

use actix_web::{web, App, HttpServer, Responder};

// A handler function that returns a simple string response
async fn hello_world() -> impl Responder {
    "Hello, Actix-web!"
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    println!("Server running at http://127.0.0.1:8080");
    HttpServer::new(|| {
        App::new()
            // Register our route: GET /hello maps to hello_world()
            .route("/hello", web::get().to(hello_world))
    })
    .bind(("127.0.0.1", 8080))?
    .run()
    .await
}

Parámetros de ruta para rutas dinámicas

Las API a menudo deben gestionar partes dinámicas de la URL, como un ID o un nombre. Actix-web utiliza parámetros de ruta para capturar estos valores.

Definimos un marcador de posición en la ruta (por ejemplo, /{name}). En el controlador, usamos web::Path<String> (o cualquier otro tipo que se pueda deserializar) para extraer el valor.

use actix_web::{web, App, HttpServer, Responder};

// Handler function with a path parameter 'name'
async fn greet_name(name: web::Path<String>) -> impl Responder {
    format!("Hello, {}!", name.into_inner())
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    println!("Server running at http://127.0.0.1:8080");
    HttpServer::new(|| {
        App::new()
            // Route with a dynamic path segment for a name
            .route("/greet/{name}", web::get().to(greet_name))
    })
    .bind(("127.0.0.1", 8080))?
    .run()
    .await
}

Gestionar solicitudes POST y JSON

Para crear o actualizar recursos, usamos solicitudes POST o PUT, que a menudo envían los datos en el cuerpo de la solicitud como JSON.

Actix-web facilita la gestión de JSON mediante web::Json<T>. Definimos un struct de Rust que coincida con la estructura JSON esperada, derivamos Deserialize de serde y Actix-web analiza automáticamente el JSON entrante y lo convierte en nuestro struct.

use actix_web::{web, App, HttpServer, Responder};
use serde::{Deserialize, Serialize};

// Define a struct to represent our incoming JSON data
#[derive(Deserialize, Serialize)]
struct User {
    username: String,
    email: String,
}

// Handler for POST requests that accepts a JSON User object
async fn create_user(user: web::Json<User>) -> impl Responder {
    // In a real app, you'd save this user to a database
    format!("User created: {} ({})", user.username, user.email)
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    println!("Server running at http://127.0.0.1:8080");
    HttpServer::new(|| {
        App::new()
            // POST /users expects a JSON body and maps to create_user()
            .route("/users", web::post().to(create_user))
    })
    .bind(("127.0.0.1", 8080))?
    .run()
    .await
}

Crear una API sencilla con estado

Combinemos lo aprendido para crear una API pequeña que gestione una lista de usuarios en memoria. Usaremos web::Data para compartir el estado específico de la aplicación (nuestra lista de usuarios) entre los controladores.

std::sync::Mutex se utiliza para permitir de forma segura el acceso mutable a nuestro Vec<User> desde varias solicitudes simultáneas. Tendremos endpoints para GET /users y POST /users.

use actix_web::{web, App, HttpServer, Responder, HttpResponse};
use serde::{Deserialize, Serialize};
use std::sync::Mutex; // For shared mutable state

// Define a User struct that can be serialized/deserialized and cloned
#[derive(Deserialize, Serialize, Clone)]
struct User {
    id: u32,
    username: String,
    email: String,
}

// Application state to hold our users and track next ID
struct AppState {
    users: Mutex<Vec<User>>,
    next_id: Mutex<u32>,
}

// Handler to get all users
async fn get_users(data: web::Data<AppState>) -> impl Responder {
    let users = data.users.lock().unwrap(); // Acquire a lock
    web::Json(users.clone()) // Return users as JSON
}

// Handler to create a new user
async fn create_user(
    data: web::Data<AppState>,
    new_user: web::Json<User>,
) -> impl Responder {
    let mut users = data.users.lock().unwrap();
    let mut next_id = data.next_id.lock().unwrap();

    let user = User {
        id: *next_id,
        username: new_user.username.clone(),
        email: new_user.email.clone(),
    };
    users.push(user.clone());
    *next_id += 1; // Increment for the next user
    HttpResponse::Created().json(user) // Return 201 Created status and user
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    println!("Server running at http://127.0.0.1:8080");
    // Create shared application state
    let app_state = web::Data::new(AppState {
        users: Mutex::new(vec![]), // Initialize with an empty user list
        next_id: Mutex::new(1),    // Start IDs from 1
    });

    HttpServer::new(move || { // 'move' closure to capture app_state
        App::new()
            .app_data(app_state.clone()) // Register shared state with the app
            .route("/users", web::get().to(get_users))
            .route("/users", web::post().to(create_user))
    })
    .bind(("127.0.0.1", 8080))?
    .run()
    .await
}

Comprobación rápida de conceptos de API

Ha aprendido a configurar un servidor básico con Actix-web y a gestionar diferentes solicitudes HTTP. ¡Pongamos a prueba sus conocimientos!

Repaso y próximos pasos

¡Buen trabajo! Ha dado sus primeros pasos en la creación de API RESTful con Rust y Actix-web.

Hemos explorado los fundamentos de las API REST y por qué Rust es una excelente opción.
Ha aprendido a configurar un proyecto básico de Actix-web.
Hemos visto cómo definir rutas GET y POST.
Ha aprendido a extraer parámetros de ruta y a gestionar cargas útiles JSON.
Por último, ha creado una API sencilla que gestiona el estado en memoria mediante web::Data.

A continuación, profundizará en la integración de bases de datos y en una gestión sólida de errores para crear servicios web aún más potentes y listos para producción.

Preguntas frecuentes

¿La lección «API REST con Actix-web/Rocket» es gratis?

Sí — el texto completo de «API REST con Actix-web/Rocket» 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 3 lecciones en total.

¿Qué aprenderé en «API REST con Actix-web/Rocket»?

Desarrolle API RESTful utilizando un framework web moderno de Rust, como Actix-web o Rocket, y gestione rutas, solicitudes y respuestas. 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 3.

¿Cuánto tiempo toma la lección «API REST con Actix-web/Rocket»?

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

API REST con Actix-web/Rocket
Integración con bases de datos (SQLx/Diesel)
Autenticación y autorización

← Volver a Learn Rust Coding