Consulta esta lista de los mejores marcos web para Rust en 2023.

Los mejores frameworks web para Rust en 2023

Los mejores marcos de trabajo web de Rust en 2023 En 2023, ¿qué marco web de Rust será el mejor para desarrollar API y aplicaciones web? Aquí, veremos algunos de los marcos más populares actualmente en uso. También exploraremos las funciones de desarrollo web de rust y ejemplos de código.

Un marco web es una biblioteca de software que proporciona una forma estándar de crear e implementar aplicaciones web. Los marcos web suelen incluir bibliotecas para tareas cotidianas, como enrutamiento (asignación de URL a recursos), creación de plantillas (generación de HTML a partir de datos) y acceso a bases de datos.

Rust es un lenguaje de programación que ofrece un gran potencial para el desarrollo web. Es rápido, seguro y proporciona muchas funciones perfectas para crear aplicaciones web. Estos son algunos de los mejores marcos y sus características.

Los mejores marcos de trabajo web de Rust

Rocket

Rocket es un marco web para Rust que simplifica la creación de aplicaciones web rápidas sin sacrificar la flexibilidad ni la seguridad de escritura. Rocket sigue una filosofía de "convención sobre configuración" y tiene como objetivo ponerlo en funcionamiento con una configuración mínima. Se integra estrechamente con el ecosistema de Rust, lo que facilita el uso de las bibliotecas y herramientas existentes.

Aquí hay un ejemplo básico que no está destinado a la producción:

mod user {

    use super::*;

    pub struct User {

        id: Uuid,

        name: String,

        email: String,

    }


    impl User {

        pub fn new(name: &str, email: &str) -> User {

            User {

                id: Uuid::new_v4(),

                name: name.into(),

                email: email.into(),

            }

        }


        pub fn get_id(&self) -> &Uuid {

        &self.id

        }


        pub fn get_name(&self) -> &str {

            &self.name

        }


        pub fn get_email(&self) -> &str {

            &self.email

        }


        pub fn set_name(&mut self, name: &str) {

            self.name = name.into();

        }


        pub fn set_email(&mut self, email: &str) {

        self.email = email.into();

        }

    }
}

use user::User;

Tide

Tide es un marco web para el lenguaje de programación Rust. Proporciona una API limpia y fácil de usar para crear aplicaciones web. Tide se basa en el marco web rust actix.

Características de la marea:

  • soporte asíncrono/en espera
  • escribir enrutamiento seguro
  • solicitar guardias
  • soporte de plantillas
  • gestión de sesiones
  • soporte websockets

Ejemplo de código: para una aplicación web "Hola, mundo" usando Tide:

use tide::{Request, Response};

async fn hello(_: Request) -> Response {
    Response::new(200).body_string("Hello, world!")
}

fn main() {

    let mut app = tide::new();

    app.at("/").get(hello);

    app.run("127.0.0.1:8080").unwrap();

}

Esto iniciará un servidor web escuchando en http://127.0.0.1:8080 que responde a todas las solicitudes con "¡Hola, mundo!".  

Actix-web

Actix-web se basa en el modelo Actor. Es un framework web de alta velocidad escrito en Rust. Actix-web proporciona un sólido conjunto de características para crear aplicaciones web, que incluyen:

  • Soporta multiplexación
  • E/S asíncrona
  • WebSockets
  • Soporte de software intermedio

Ejemplo de código:

use actix_web::{web, App, Responder};

async fn index() -> impl Responder {

    "Hello, world!"

}

fn main() {

    App::new().route("/", web::get().to(index)).run();

}

Ejecute el ejemplo de código con cargo run

Deformación

Warp es un marco de servidor web rápido y flexible construido sobre tokio. Es fácil de usar y viene con muchas funciones listas para usar, como:

  • TLS automático
  • Compatibilidad con HTTP/2
  • Eventos enviados por el servidor (SSE)
  • Websockets
  • Parámetros de ruta
  • Parámetros de consulta
  • Análisis del cuerpo JSON
  • formularios de varias partes
  • Servicio de archivos estáticos

Aquí hay un ejemplo simple de "Hola, mundo" usando Warp:

use warp::Filter;

fn main() {

    let hello = warp::path!("hello") // Reconoce /hello/...

    .and(warp::path::end()) // ...pero solo al final (no más '/' después de esto)

    .map(|| "Hello, world!"); // Responder con un body simple

    warp::serve(hello).run((["127.0.0.1", "8080"]).into());
}

Axum

Este marco web está diseñado para ser rápido, eficiente y liviano. El lenguaje de programación Erlang lo inspira, brindando a los desarrolladores un alto nivel de concurrencia. Axum es perfecto para crear microservicios, aplicaciones en tiempo real y sistemas de baja latencia.

Sus características incluyen:

  • Modelo de actor inspirado en Erlang para concurrencia
  • Baja latencia y alto rendimiento
  • Soporte para WebSockets y otros protocolos
  • E/S asíncrona

Ejemplo de código:

use actix_web::{web, App, Responder};

fn index() -> impl Responder {

    "Hello, world!"

}

fn main() {

    App::new().route("/", web::get().to(index)).run();

}

Hyper

Este marco se basa en la biblioteca estándar de Rust y brinda soporte para una amplia gama de características. Estos incluyen:

  • E/S asíncrona: esto le permite usar características como async/await para hacer que su código sea más eficiente.
  • Soporte HTTP2: Esto significa que puede aprovechar los últimos estándares en desarrollo web.
  • Rápido y liviano: Hyper está diseñado para ser rápido y liviano, por lo que es perfecto para desarrollar aplicaciones web de alto rendimiento.
  • Fácil de usar: el marco es fácil de usar, por lo que puede comenzar a desarrollar sus aplicaciones web rápidamente.
  • También es fácil de usar y tiene una excelente documentación.

Ejemplo de código:

extern crate hyper;

use hyper::{Body, Response, Server};

use hyper::rt::Future;

use hyper::service::service_fn;

const PHRASE: &str = "Hello, World!";

fn main() {

    // Enlace a la dirección y llame a la función `run`, pasando un cierre.

    // El cierre contiene todo nuestro servicio HTTP.

    let addr = "127.0.0.1:3000".parse().unwrap();

    let server = Server::bind(&addr)

    .serve(|| service_fn(|_| {

        // Devolvemos un `Futuro` que se resuelve en un `Resultado` cuando el HTTP

        // el cuerpo ha sido leído completamente. En este caso, simplemente devuelva un vacío

        // resultado exitoso

        future::ok(Response::new(Body::from(PHRASE)))

    }))

    .map_err(|e| {

        // Si ocurre algún error, regístrelo en STDOUT.

        println!("server error: {}", e);

    });

    // Ejecute este servicio HTTP en el hilo actual.

    hyper::rt::run(server);
}

Cualquier desarrollador que use un marco de API de óxido debe saber acerca de Hyper. Viene con muchas características y es fácil de usar. La documentación también es de primera categoría, lo que la convierte en un excelente recurso de aprendizaje para los nuevos desarrolladores.

Estos son solo algunos de los mejores marcos de programación web de óxido que existen. Todos ellos tienen fortalezas y debilidades, por lo que depende de usted decidir cuál se adapta mejor a sus necesidades. Estos marcos web de Rust ofrecen ventajas sobre otros marcos que incluyen:

  • Excelente actuación
  • Seguridad de memoria superior
  • Una amplia gama de características
  • Fácil de usar

Si está buscando un marco web oxidado que pueda ofrecer estos beneficios, definitivamente debería consultar uno de estos marcos. Son excelentes opciones para desarrollar aplicaciones web.


Conviertete en un programador más sociable

Patrocinadores