Introducción
En este tutorial, aprenderá a crear un servidor web con Rust y el framework Actix-web en un Droplet de DigitalOcean. Configurará un servidor principal y creará rutas para gestionar una lista simple de tareas pendientes que admite operaciones RESTful comunes, como la recuperación y la creación de tareas pendientes.
Requisitos previos
Antes de comenzar, asegúrese de tener lo siguiente:
- Uno Cuenta en la nube de DigitalOcean Para rotar una gota.
- Ya está funcionando un droplet de Ubuntu.
- Rust está instalado en Droplet.
- Familiaridad con los principios de Rust, incluidas variables, funciones y atributos.
Paso 1: Configuración del droplet de Ubuntu
Acceda por SSH a su Droplet de DigitalOcean: Abra su terminal y use el siguiente comando para acceder por SSH a su Droplet. Reemplace your_username con su nombre de usuario y your_droplet_ip con la dirección IP de su Droplet:
ssh your_username@your_droplet_ip
Actualizar la lista de paquetes: después de iniciar sesión, actualice la lista de paquetes para asegurarse de tener la información más reciente sobre los paquetes disponibles:
sudo apt update
Instalar Rust: para instalar Rust, utilice el siguiente comando, que descargará y ejecutará el script de instalación de Rust:
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
Siga las instrucciones en pantalla para completar la instalación. Tras la instalación, es posible que deba reiniciar su terminal o ejecutar:
source $HOME/.cargo/env
Instalar bibliotecas esenciales: Instala las bibliotecas necesarias para compilar aplicaciones Rust. Puedes instalar build-essential y libssl-dev usando:
sudo apt install build-essential libssl-dev
Verificar la instalación de Rust: Para verificar que Rust esté instalado correctamente, verifique la versión:
rustc --version
Instalar Cargo (Administrador de paquetes de Rust): Cargo se instala automáticamente con Rust. Puedes verificar su instalación comprobando la versión:
cargo --version
Paso 2 – Lanzar el proyecto
Creemos un nuevo proyecto rust sammy_todos usando la carga útil
cargo new sammy_todos
Luego, busca el archivo Cargo.toml. Ve al directorio raíz de tu proyecto de Rust. El archivo Cargo.toml se encuentra en el mismo directorio donde creaste tu proyecto (por ejemplo, sammy_todos). Puedes usar el siguiente comando para cambiar al directorio de tu proyecto:
cd sammy_todos/
lsA continuación se muestran los archivos del proyecto Rust que se generan automáticamente:
Output
Cargo.toml srcAgregue actix-web y serde como dependencias en Cargo.toml. Aquí, serde es necesario para la serialización y la deserialización.
vi Cargo.toml
Y agregue las siguientes líneas bajo dependencias.
[dependencies]
actix-web = "4.0"
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"Ahora use el siguiente comando para descargar y compilar las dependencias:
cargo build
Paso 3 – Crear un servidor básico
En main.rs, agrega las siguientes líneas de código para iniciar un servidor principal. Debes acceder al directorio src dentro de tu proyecto.
use actix_web::{get, App, HttpServer, HttpResponse, Responder,web};
#[get("/")]
async fn index() -> impl Responder {
HttpResponse::Ok().body("Welcome to the Sammy Todo API!")
}
#[actix_web::main]
async fn main() -> std::io::Result<()> {
HttpServer::new(|| {
App::new()
.service(index)
})
.bind("127.0.0.1:8080")?
.run()
.await
}Ejecutar el servidor:
cargo run
Para probar el servidor, abra una nueva sesión de terminal y ejecute el siguiente comando:
curl http://127.0.0.1:8080
Debería recibir la siguiente respuesta:
Output
Welcome to the Sammy Todo API!Paso 4 – Agregar un modelo de tarea pendiente
El modelo Todo es necesario para serializar la solicitud y la respuesta. Agregue las siguientes líneas de código al archivo main.rs.
use serde::{Serialize, Deserialize};
#[derive(Serialize, Deserialize)]
struct Todo {
id: i32,
title: String,
completed: bool,
}Paso 5 – Implementar Crear todo
Esta API crea la tarea pendiente y es una API ficticia que solo devuelve tu tarea pendiente, pero puedes implementarla con bases de datos para hacerla persistente.
#[get("/todos")]
async fn create_todo(todo: web::Json<Todo>) -> impl Responder {
HttpResponse::Ok().body(serde_json::to_string(&todo).unwrap())
}
Paso 6 – Ejecutar Get todo
Esta API devuelve la tarea con el id:
#[get("/todos/{id}")]
async fn get_todo(id: web::Path<i32>) -> impl Responder {
let todo = Todo {
id: id.into_inner(),
title: "Learn Actix-Web".to_string(),
completed: false,
};
HttpResponse::Ok().body(serde_json::to_string(&todo).unwrap())
}Conecte el servicio con su servidor
El servidor rust main.rs se ve así:
use actix_web::{get, App, HttpServer, HttpResponse, Responder, web};
#[get("/")]
async fn index() -> impl Responder {
HttpResponse::Ok().body("Welcome to the Sammy Todo API!")
}
#[actix_web::main]
async fn main() -> std::io::Result<()> {
HttpServer::new(|| {
App::new()
.service(index)
.service(get_todo)
.service(create_todo)
})
.bind("127.0.0.1:8080")?
.run()
.await
}
use serde::{Serialize, Deserialize}; // Added Deserialize to imports
#[derive(Serialize, Deserialize)] // Ensure Deserialize is imported
struct Todo {
id: i32,
title: String,
completed: bool,
}
#[get("/todos")]
async fn create_todo(todo: web::Json<Todo>) -> impl Responder {
HttpResponse::Ok().body(serde_json::to_string(&todo).unwrap())
}
#[get("/todos/{id}")]
async fn get_todo(id: web::Path<i32>) -> impl Responder {
let todo = Todo {
id: id.into_inner(),
title: "Learn Actix-Web".to_string(),
completed: false,
};
HttpResponse::Ok().body(serde_json::to_string(&todo).unwrap())
}Ahora, puedes probarlo enviando una solicitud POST con curl:
curl -X POST -H "Content-Type: application/json" -d '{"title": "Buy groceries"}' http://127.0.0.1:8080/todos
Resultado
¡Felicitaciones! Has configurado correctamente un servidor web básico con Rust y Actix. Este tutorial te enseñará a crear puntos finales para recuperar y crear tareas pendientes, lo que te proporcionará una base sólida para crear aplicaciones más complejas. Para optimizar aún más tu aplicación, integra una solución de base de datos para la persistencia de datos, lo que te permitirá almacenar y gestionar tus tareas pendientes de forma eficiente.
