Cómo escribir una API REST en Rust en 30 minutos: guía paso a paso

Introducción: ¿Por qué Rust para REST API?

Rust es un lenguaje de programación de sistemas moderno que combina el rendimiento de C/C++ con la seguridad de memoria. En los últimos años, se ha utilizado activamente para crear servicios web de alta carga y REST API. Gracias al framework Actix-web, se puede escribir un REST API completo en Rust en solo 30 minutos, incluso si estás empezando a aprender el lenguaje.

En este artículo crearemos un REST API simple pero funcional para gestionar una lista de tareas (Todo List). Aprenderás:

• Configurar un proyecto en Rust con Actix-web
• Implementar operaciones CRUD (Create, Read, Update, Delete)
• Trabajar con solicitudes y respuestas JSON
• Usar enrutamiento y manejadores

¿Listo? ¡Vamos allá!

Paso 1: Configuración del proyecto e instalación de dependencias

Para empezar, asegúrate de tener Rust instalado. Si no es así, ejecuta el comando:

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Crea un nuevo proyecto:

cargo new rust_todo_apicd rust_todo_api

Abre Cargo.toml y añade las siguientes dependencias:

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

Aquí:

• actix-web — un potente framework web asíncrono
• serde — para serialización/deserialización JSON
• tokio — runtime asíncrono (Actix-web lo usa internamente)

Ejecuta cargo build para descargar y compilar las dependencias. Esto tomará 2-3 minutos.

Paso 2: Creación del modelo de datos y almacenamiento

En este proyecto no conectaremos una base de datos — para simplificar, usaremos un vector en memoria. Crearemos una estructura para la tarea.

Abre src/main.rs y escribe el siguiente código:

use actix_web::{web, App, HttpServer, HttpResponse, middleware};use serde::{Deserialize, Serialize};use std::sync::Mutex;

// Modelo de tarea#[derive(Serialize, Deserialize, Clone)]struct Task {    id: u32,    title: String,    completed: bool,}

// Almacenamiento de tareas (seguro para hilos)struct AppState {    tasks: Mutex<Vec<Task>>,}

Explicaciones:

• #[derive(Serialize, Deserialize)] — genera automáticamente métodos para trabajar con JSON
• Mutex — garantiza acceso seguro a los datos desde múltiples hilos
• AppState — se almacenará en el estado de la aplicación

Paso 3: Implementación de los manejadores CRUD

Ahora añadiremos las funciones manejadoras para cada método HTTP. Inserta el siguiente código después de la declaración de las estructuras:

// Obtener todas las tareasasync fn get_tasks(data: web::Data<AppState>) -> HttpResponse {    let tasks = data.tasks.lock().unwrap();    HttpResponse::Ok().json(tasks.clone())}

// Crear una nueva tareaasync fn create_task(data: web::Data<AppState>, body: web::Json<Task>) -> HttpResponse {    let mut tasks = data.tasks.lock().unwrap();    let new_id = tasks.len() as u32 + 1;    let task = Task {        id: new_id,        title: body.title.clone(),        completed: body.completed,    };    tasks.push(task.clone());    HttpResponse::Created().json(task)}

// Actualizar una tareaasync fn update_task(    data: web::Data<AppState>,    path: web::Path<u32>,    body: web::Json<Task>,) -> HttpResponse {    let mut tasks = data.tasks.lock().unwrap();    let id = path.into_inner();    if let Some(task) = tasks.iter_mut().find(|t| t.id == id) {        task.title = body.title.clone();        task.completed = body.completed;        HttpRespons