Cómo escribir una API REST en Rust en 30 minutos: guía práctica

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

Rust es un lenguaje de programación de sistemas moderno que combina el rendimiento de C/C++ con la seguridad de memoria sin un recolector de basura. Para crear API REST, Rust ofrece varios frameworks potentes, y Actix-web es uno de los más populares. En esta guía, crearemos paso a paso una API REST completa en Rust en 30 minutos. Verá lo rápido que puede empezar, incluso si es principiante en Rust.

Preparación del entorno

Antes de escribir código, asegúrese de tener Rust instalado. Si no es así, ejecute el comando:

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

Después de la instalación, verifique la versión:

rustc --version

Ahora cree un nuevo proyecto:

cargo new rust_rest_api\ncd rust_rest_api

Abra el archivo Cargo.toml y agregue las dependencias:

[dependencies]\nactix-web = "4"\nserde = { version = "1.0", features = ["derive"] }\nserde_json = "1.0"\ntokio = { version = "1", features = ["full"] }

Ejecute cargo build para instalar todos los paquetes. Esto tomará de 1 a 2 minutos.

Creación de una API REST básica en Rust

Empecemos con un endpoint simple que devuelve un saludo. Abra src/main.rs y escriba:

use actix_web::{web, App, HttpServer, Responder};\n\nasync fn hello() -> impl Responder {\n    "¡Hola, mundo! ¡Esta es una API REST en Rust!"\n}\n\n#[actix_web::main]\nasync fn main() -> std::io::Result<()> {\n    println!("Servidor iniciado en http://127.0.0.1:8080");\n    HttpServer::new(|| {\n        App::new()\n            .route("/", web::get().to(hello))\n    })\n    .bind("127.0.0.1:8080")?\n    .run()\n    .await\n}

Ejecute el servidor con el comando cargo run y abra http://127.0.0.1:8080 en su navegador. Verá nuestro saludo. Esta es la base de cualquier API REST en Rust.

Adición de estructura de datos y JSON

Una API REST real trabaja con JSON. Creemos un modelo de usuario y un endpoint para obtenerlo:

use serde::{Deserialize, Serialize};\n\n#[derive(Serialize, Deserialize)]\nstruct User {\n    id: u32,\n    name: String,\n    email: String,\n}\n\nasync fn get_user() -> impl Responder {\n    let user = User {\n        id: 1,\n        name: "Iván Petrov".to_string(),\n        email: "ivan@example.com".to_string(),\n    };\n    web::Json(user)\n}\n\n// En main() agregue la nueva ruta:\n// .route("/user", web::get().to(get_user))

Ahora, en la dirección /user obtendrá un objeto JSON. Este es un punto clave: Rust serializa automáticamente la estructura en JSON gracias a serde.

Trabajo con parámetros de consulta y solicitudes POST

Una API real debe manejar diferentes métodos HTTP y parámetros. Agreguemos un endpoint para crear un usuario mediante POST:

use actix_web::web::Json;\n\nasync fn create_user(user: Json<User>) -> impl Responder {\n    let new_user = user.into_inner();\n    println!("Usuario creado: {} ({})", new_user.name, new_user.email);\n    web::Json(new_user)\n}\n\n// En main():\n// .route("/user", web::post().to(create_user))

Ahora puede enviar una solicitud POST con un cuerpo JSON, por ejemplo, mediante curl:

curl -X POST http://127.0.0.1:8080/user \\\n  -H "Content-Type: application/json" \\\n  -d '{"id":2,"name":"María Smirnova","email":"maria@example.com"}'

El servidor devolverá el mismo objeto, confirmando la creación. Esta es la base para las operaciones CRUD.

Manejo de parámetros de ruta y cadena de consulta

Agreguemos un endpoint para obtener un usuario por ID mediante un parámetro de ruta:

use actix_web::web::Path;\n\nasync fn get_user_by_id(path: Path<u32>) -> impl Responder {\n    let user_id = path.into_inner();\n    // En una aplicación real, aquí habría una consulta a la base de datos\n