Optimización Simple de una Api con el marco Actix de Rust

Si estás interesado en desarrollar un servicio backend con el lenguaje Rust, hay muchos frameworks y fuentes abiertas que son bien conocidos y populares, como Warp, Rocket y Actix. 

¿Por qué concentrarnos en Actix? 

Rendimiento: este framework está diseñado para un rendimiento y concurrencia elevados, lo que significa que puede manejar solicitudes masivas al mismo tiempo y puede construir un servicio web escalable. 

Ergonomía: muchas fuentes abiertas del lenguaje Rust pueden ofrecer un rendimiento excelente, pero ninguna de ellas logra que el desarrollador y el mantenedor se sientan ergonómicos. Actix es el único framework que puede proporcionar una estructura limpia y una API que los desarrolladores pueden utilizar fácilmente. 

Ecosistema y Comunidad: Actix cuenta con una comunidad activa donde las personas pueden discutir y plantear cualquier problema. La documentación de Actix es útil y legible tanto para principiantes como para personas con experiencia. 

¡Comencemos con Cargo!

Cargo lo es todo para los programadores Rust.  

Existen muchas características que Cargo proporciona para su uso, tales como Gestión de Dependencias, Sistema de Construcción, Pruebas, Documentación y Publicación.  

Para empezar, primero debse instalar Rust en su ordenador, lo que puede hacerse siguiendo las instrucciones de instalación proporcionadas en https://www.rust-lang.org/tools/install. 

Ejemplo para Cargo.toml se está incluyendo Actix 

# create a project by using cargo command 
cargo new simple-api 
cd simple-api 

# default folder structure 
simple-api/ 
├── Cargo.toml 
└── src/ 
    └── main.rs 

[package] 
name = "simple-api" 
version = "0.1.0" 
edition = "2021" 
 
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 
 
[dependencies] 
actix-web = "4" 
serde = { version = "1.0", features = ["derive"] } 
serde_json = {version = "1.0"} 

Mi intención es demostrar cómo crear un controlador para obtener respuestas de un servicio en Actix.

# default folder structure that contains controller 
simple-api/ 
├── Cargo.toml 
└── src/ 
    ├── controller/ 
        └── user/ 
            └── user_controller.rs 
            └── user_struct.rs 
    └── main.rs 

En user_struct.rs, encontrarás estructuras convenientemente organizadas que se utilizan dentro del controlador para facilitar la gestión. 

use serde::Serialize; 
 
#[derive(Serialize)] 
pub struct User { 
    pub first_name: String, 
    pub last_name: String, 
    pub age: i16 
} 
 
#[derive(Serialize)] 
pub struct UsersResponse { 
    pub status: String, 
    pub data: Vec<User> 
} 

Pasando a user_controller.rs, Este archivo contiene la lógica de control para determinar las respuestas, e incluye un método para establecer el protocolo en cualquier solicitud entrante. 

pub mod user_controller { 
    use actix_web::{get, web, Responder, Result}; 
    use crate::controller::user::user_struct::{User, UsersResponse}; 
 
    #[get("/users")] 
    async fn get_users() -> Result<impl Responder> { 
        let mut users: Vec<User> = Vec::new(); 
        for index in 1..10 { 
            let first_name:String = "John ".to_string().to_owned() + &index.to_string().to_owned(); 
            let user = User { 
                first_name, 
                last_name: "Doe".to_string(), 
                age: 20 + index 
            }; 
 
            users.push(user); 
        } 
 
        let response = UsersResponse { 
            status: "ok".to_string(), 
            data: users 
        }; 
         
        Ok(web::Json(response)) 
    } 
} 

Finalmente en main.rs, registraremos una función del controlador y configuraremos la aplicación para servirla. 

// register user_controller and user_struct  
mod controller { 
    pub mod user { 
        pub mod user_controller; 
        pub mod user_struct; 
    } 
} 
 
// define for using get_users api 
use crate::controller::user::user_controller::user_controller::get_users; 
 
#[actix_web::main] 
async fn main() -> std::io::Result<()> { 
    use actix_web::{App, HttpServer}; 
 
    HttpServer::new(|| App::new().service(get_users) 
                    ) 
        .bind(("127.0.0.1", 8080))? 
        .run() 
        .await 
} 

Veamos cómo instalar las dependencias necesarias y empezar a servir nuestra aplicación. 

# install dependencies 
cargo build 
# serve our application 
cargo run 

Consulta la respuesta de Actix. puedes obtener esta respuesta llamando al API a localhost:8080/users. 

{ 
    "status": "ok", 
    "data": [ 
        { 
            "first_name": "John 1", 
            "last_name": "Doe", 
            "age": 21 
        }, 
        { 
            "first_name": "John 2", 
            "last_name": "Doe", 
            "age": 22 
        }, 
        { 
            "first_name": "John 3", 
            "last_name": "Doe", 
            "age": 23 
        }, 
        { 
            "first_name": "John 4", 
            "last_name": "Doe", 
            "age": 24 
        }, 
        { 
            "first_name": "John 5", 
            "last_name": "Doe", 
            "age": 25 
        }, 
        { 
            "first_name": "John 6", 
            "last_name": "Doe", 
            "age": 26 
        }, 
        { 
            "first_name": "John 7", 
            "last_name": "Doe", 
            "age": 27 
        }, 
        { 
            "first_name": "John 8", 
            "last_name": "Doe", 
            "age": 28 
        }, 
        { 
            "first_name": "John 9", 
            "last_name": "Doe", 
            "age": 29 
        } 
    ] 
} 

Conclusión 

Descubre lo fácil que es implementar una API con Actix y el confiable compilador de Rust que detecta errores. Su estructura limpia y características amigables lo convierten en una elección de desarrollo ideal. ¿Listo para optimizar tus proyectos? ¡Contáctanos para explorar nuestros servicios de consultoría de TI personalizados hoy mismo!