Uso de Pavex para el desarrollo web con Rust

Hay muchos frameworks web disponibles para que los desarrolladores elijan, incluyendo más de diez frameworks web populares en el ecosistema Rust. Cada framework Rust tiene sus propias opiniones y sigue los principios y prácticas de varios desarrolladores para optimizar y garantizar que sigan métodos de desarrollo web de calidad.

En 2022, Luca Palmieri se propuso desarrollar el framework Pavex Rust con el objetivo de lograr una excelente ergonomía, alto rendimiento, usabilidad y velocidad, además del popular framework Hyper. Actualmente, Pavex se encuentra en fase beta y listo para usar, con todas estas características ya disponibles, además de otras como mejores mensajes de error.

¿Qué es Pavex?

Pavex es un nuevo framework de Rust, de próxima aparición, diseñado para ampliar el horizonte del desarrollo web en Rust. Su objetivo es ofrecer una experiencia de desarrollo más abstracta, ergonómica y de alto rendimiento.

El framework web Pavex para Rust garantiza la seguridad en tiempo de compilación y una mejor comunicación de errores, lo que reduce la curva de aprendizaje asociada a la gestión de errores en tiempo de compilación y la sobrecarga del framework. Su arquitectura se centra en minimizar el contenido de cara al usuario para ofrecer una API limpia y un enfoque intuitivo para el desarrollador.

Introducción a Pavex

Dado que Pavex está basado en Rust, necesitará la cadena de herramientas de Rust; Específicamente, necesitará Rustup para instalar y administrar Rust y Cargo como su sistema de compilación y administrador de paquetes.

También necesitarás un subcomando. Puedes instalarlo con las directivas de su documentación.cargo-pxcargocargo-px

Necesitarás tener todas estas herramientas disponibles en tu [nombre del archivo] PATH, así que asegúrate de hacerlo durante la instalación. Puedes ejecutar este comando para verificar la instalación.

Rustup -- versión  carga -- versión  carga px -- versión

A continuación, debe instalar nightlyla cadena de herramientas de Rust. Puede agregarla con este comando:

Instalación nocturna de la cadena de herramientas RustUp

Después de la instalación nightly, agregue el componente a la compilación:rust-docs-json

Componente RustUp : Agregar cadena de herramientas nocturnas Rust - Documentación - JSON

Finalmente, debe instalar y activar la herramienta CLI de Pavex. Ejecute este comando para instalar Pavex:

curl -- proto '=https' -- tlsv1 . 2 - LsSf https://pavex.dev/releases/download/latest/pavex_cli-installer.sh | sh # powershell irm https://pavex.dev/releases/download/latest/pavex_cli-installer.ps1 | iex   

Puede ejecutar este comando para verificar la instalación:

pavex -- versión

Pavex está en versión beta, por lo que debes activarlo con una clave de activación:

Pavex autoactivable

Puedes recuperar una activación del #activationcanal del servidor Discord de Pavex después de unirte a la versión beta en Pavex.dev.

Ingrese la clave de activación y luego podrá proceder a crear un nuevo proyecto Pavex con este comando:

Pavex nuevo Pavex - tutorial y CD Pavex - tutorial

Abra el nuevo proyecto Pavex en el entorno de código que prefiere. Debería ver una estructura de carpetas similar a esta:

Puede proceder a ejecutar un proyecto de demostración de Pavex con este comando:

carrera de carga px

Al ejecutar el comando, debería obtener esto como resultado, ya que el servidor se ejecuta en el puerto predeterminado 8080:

Puedes enviar una solicitud cURL para hacer ping al servidor de la siguiente manera:

curl - v http : //localhost:8000/api/ping

Este es el resultado que debes esperar:

Necesita comprender cómo funciona un proyecto Pavex para desarrollar con el framework. El núcleo de cada proyecto Pavex es el Blueprinttipo. Lo usará Blueprintpara definir rutas, middleware, controladores de errores y otras funciones.

Revisa el archivo de tu proyecto. Esto es lo que deberías esperar ver:pavex_tutorial/src/blueprint.rsBlueprintpavex_tutorial

pub fn blueprint() - Plano { let mut bp = Blueprint::new(); ApiKit::new().register(mut bp); agregar_telemetría_middleware(mut bp); pb}

La blueprintfunción contiene todas las rutas, constructores y controladores de errores. Pavex requiere que la blueprintfunción se ejecute.

Creando tu primera ruta Pavex

El enrutamiento con Pavex es sencillo e intuitivo en comparación con muchos otros frameworks web de Rust. Registrarás rutas, middleware, etc., en la registerfunción después de escribir las funciones de controlador de la siguiente manera:

//rutas/mod.rsestado de mod de pub ;pub mod hola ;usar pavex :: blueprint ::{ enrutador :: GET , Blueprint }; usar pavex :: f ; pub fn registro (bp: mut Blueprint) { bp.route (GET, "/api/ping", f! (self:: estado :: ping)); bp.route(GET, "/api/hola/:nombre", f !( self :: hola :: hola ) ); }    

Arriba, registramos la función del controlador de solicitudes GET hellocon la ruta. A continuación, se explica cómo extraer y usar parámetros de ruta con Pavex:/api/hello/:name

// rutas/hola.rsutilizar pavex :: solicitud :: ruta :: PathParams ; utilizar pavex :: respuesta :: Respuesta ;#[PathParams] pub struct HelloParameters { nombre de pub : String , } pub fn hola ( params : PathParams HelloParameters ) - Respuesta { let HelloParameters { nombre } = params.0 ; Respuesta :: ok () . set_typed_body ( formato !( "Hola, { nombre}!" ) ) }                        

Puedes usar una estructura para modelar los objetos que esperas de una solicitud. La HelloParametersestructura es la estructura del nameparámetro de la solicitud. La hellofunción recupera el parámetro de ruta y escribe una cadena con dicho parámetro al cliente como respuesta.

Manejo de datos de solicitud con Pavex

Gestionar todo tipo de datos de solicitud con Pavex también es muy intuitivo. Puedes usar los contenedores serdey serde_jsoncon Pavex para operaciones JSON. Pavex también ofrece una JsonBodyfunción para analizar el cuerpo de una solicitud entrante como JSON.

Aquí está la lista completa de importaciones que necesitarán para manejar los datos de solicitud JSON:

utilizar pavex :: http ::{ StatusCode , HeaderValue }; utilizar pavex :: request :: body :: JsonBody ; utilizar pavex :: respuesta :: Respuesta ; utilizar serde ::{ Serializar , Deserializar }; utilizar serde_json :: to_string ;  

A continuación, se muestra una Userestructura para la operación JSON. La #[derive(Serialize, Deserialize)]macro añade funcionalidad de serialización y deserialización mediante el serdecontenedor:

#[derive(Serializar, Deserializar)] pub struct Usuario { pub id : u32 , pub nombre : String , pub email : String , }    

A continuación, se explica cómo se puede deserializar una carga JSON en la Userestructura:

pub fn create_user (cuerpo: usuario JsonBody) - Respuesta {let usuario = cuerpo.0; // La deserialización ocurre aquí let save_user = Usuario { id : 1 , .. usuario } ; // otras acciones }

Esta create_userfunción es un controlador de solicitudes que gestiona las solicitudes POST para crear un nuevo usuario. Acepta datos codificados en JSON del cuerpo de la solicitud y los deserializa para recuperarlos de forma similar a una estructura. El extractor de Pavex deserializa el JSON del cuerpo de la solicitud.JsonBodyT

A continuación se explica cómo puede registrar la create_userfunción del controlador en la registerfunción:

pub fn register(bp:mut Blueprint) { bp.route(POST, "/api/users", f!(self::json:create_user)); }   

create_userAhora se puede acceder a la funcionalidad de la función a través de la ruta y puedes realizarle solicitudes./api/users

Respondiendo a las solicitudes

Puedes responder a las solicitudes de clientes mediante Responseel objeto de Pavex. Así es como puedes implementar una función de gestión de solicitudes GET:

utilizar pavex :: respuesta :: Respuesta ;pub fn get_user () - Respuesta { let usuario = Usuario { id : 1 , nombre : "Jane Doe" .to_string ( ), correo electrónico : " jane.doe@example.com " .to_string (), } ; // Serializar la estructura del usuario en una cadena JSON match to_string (user) { Ok (json) = json, Err (_) = return Response :: new (StatusCode :: INTERNAL_SERVER_ERROR), }; deje que mut respuesta = Respuesta :: new (CódigoDeEstado :: OK); respuesta.encabezados_mut(). insert ( " Tipo -DeContenido " , ValorDeEncabezado :: from_static ( "aplicación/json" )); respuesta.cuerpo() ; respuesta}

La get_userfunción crea una Userinstancia de estructura, la serializa en una cadena JSON y gestiona los errores asociados. A continuación, establece el tipo de contenido de la respuesta y escribe la estructura serializada como respuesta al cliente.application/json

Uso de middleware con Pavex

El middleware de Pavex simplifica la incorporación de pasos de preprocesamiento y posprocesamiento a las funciones de control. A continuación, se muestra un ejemplo de cómo usar middleware en sus proyectos de Pavex:

// src/middleware.rsusar pavex :: middleware :: Siguiente ; usar pavex :: respuesta :: Respuesta ; usar std :: futuro :: IntoFuture ;pub async fn logging_middlewareC(next: NextC) - Respuesta donde C: IntoFutureOutput=Response,{ println!("Antes de procesar la solicitud"); let response = next.await; println!("Después de procesar la solicitud"); response}

La logging_middlewarefunción utiliza los Nextobjetos para facilitar el flujo de la solicitud. Registra un mensaje antes y después de la ejecución de la siguiente función de controlador en la cadena.

A continuación se muestra un ejemplo de cómo puede registrar el middleware en la registerfunción:

// rutas/mod.rspub mod estado;pub mod hola;pub mod json;pub mod middleware;use pavex::blueprint::{enrutador::GET, Blueprint};use pavex::blueprint::enrutador::POST;use pavex::f;pub fn register(bp: mut Blueprint) { bp.wrap(f!(self::middleware::logging_middleware)); bp.route(GET, "/api/ping", f!(self::status::ping)); bp.route(GET, "/api/hello/:name", f!(self::hello::hello)); bp.route(POST, "/api/users", f!(self::json::create_user)); bp.route(GET, "/api/usuarios/:id", f!(self::json::get_user));}

La wrapfunción registra un middleware de encapsulamiento. logging_middlewareAhora encapsula las funciones de controlador especificadas.

Comparación de Pavex con los frameworks Rust existentes

Aunque es nuevo, hemos visto que Pavex proporciona la mayoría de las características que necesitará en un marco web Rust, incluido soporte async/await, middleware, simultaneidad y mucho más.

Pavex es un framework interesante con mejor documentación, gestión de errores y semántica que otros frameworks web populares para Rust. Está diseñado para crear aplicaciones de nivel pequeño a empresarial sin sacrificar nada.

Así es como Pavex se compara actualmente con los marcos web Actix Web, Rocket, Axum y warp Rust:

La elección de un framework web Rust debe basarse en las especificaciones y necesidades de su proyecto. Puede usar esta tabla comparativa como guía para elegir un framework tras evaluar las especificaciones del proyecto.

Conclusión

Pavex es aún muy nuevo (en beta cerrada), y antes de que el proyecto esté disponible para el público, se espera que se implementen más funciones. Sin embargo, tenga en cuenta que no está diseñado para ser un framework de código abierto; Palmieri planea añadir un precio de uso al proyecto, aunque el plan de precios aún no está finalizado.

En este artículo, aprendimos sobre el framework Pavex y cómo usarlo para el desarrollo web en Rust. Pavex es un proyecto emocionante para muchos desarrolladores de Rust, especialmente porque mejora la funcionalidad de muchos frameworks existentes. Cuenta con una amplia experiencia en desarrollo; deberías probarlo cuando esté disponible.

Depurar aplicaciones Rust puede ser difícil, especialmente cuando los usuarios experimentan problemas difíciles de reproducir. Si te interesa supervisar y monitorizar el rendimiento de tus aplicaciones Rust, detectar errores automáticamente y monitorizar las solicitudes de red lentas y el tiempo de carga, prueba LogRocket.

Modernice su forma de depurar sus aplicaciones Rust: comience a monitorearlas de forma gratuita.

Si quieres conocer otros artículos parecidos a Uso de Pavex para el desarrollo web con Rust puedes visitar la categoría Desarrollo.