HTTP utiliza una arquitectura cliente-servidor para la transferencia de información y datos. Una de las características de los lenguajes de programación del lado del servidor como Rust es desarrollar servidores y aplicaciones de cliente para interactuar con servicios basados ​​en HTTP.

Rust es adecuado para construir servidores HTTP debido a sus características de seguridad, rendimiento y confiabilidad. Las cajas de terceros de Rust como Actix y Rocket son populares para construir servidores web sofisticados que pueden manejar un alto tráfico.

¿Por qué debería usar Rust para el desarrollo de servidores web HTTP?

Rust ha ganado popularidad para el desarrollo de servidores web ya que algunas de las características del lenguaje son exactamente los requisitos para construir la mayoría de los servidores web.

El uso de Rust garantiza que su aplicación se escale de manera eficiente, lo que hace que el lenguaje sea ideal para crear aplicaciones de alto rendimiento. Aquí hay razones específicas para considerar usar Rust para su servidor web y otras aplicaciones del lado del servidor.

Alto rendimiento de Rust

El alto rendimiento es una de las razones por las que Rust es una excelente opción para crear servidores web HTTP. Rust proporciona acceso de bajo nivel a los recursos del sistema, incluida la memoria y la CPU, lo que le permite escribir código que se ejecuta más rápido con menos recursos que otros lenguajes del lado del servidor.

Además, el sistema de propiedad de Rust elimina la necesidad de recolección de elementos no utilizados en el momento de la compilación, que es una de las razones por las que algunos lenguajes del lado del servidor son lentos.

Seguridad y proteccion

El sistema de gestión de memoria de propiedad de Rust hace que el lenguaje sea seguro para el desarrollo de servidores web. No experimenta referencias de puntero nulas o colgantes que pueden provocar fugas de memoria y otras vulnerabilidades de seguridad.

El sistema de propiedad de Rust previene estos errores comunes para mantener seguros su servidor y sus aplicaciones. Rust también se enfoca en prevenir desbordamientos de búfer y otros errores relacionados con la memoria.

concurrencia

La simultaneidad es la capacidad de ejecutar múltiples unidades de un programa de manera desordenada sin afectar la salida. La salida de un programa concurrente debe ser la misma que la salida de un programa asíncrono.

La simultaneidad puede afectar significativamente el rendimiento de su aplicación, ya que los servidores necesitan manejar múltiples solicitudes simultáneamente. Rust proporciona compatibilidad con la coexistencia con un modelo de subprocesos ligero.

La ventaja de la programación concurrente en Rust es que el sistema de propiedad le permite escribir código seguro para subprocesos sin la necesidad de bloqueos y otras primitivas de sincronización.

La biblioteca estándar de Rust y paquetes de terceros en el ecosistema Rust proporcionar herramientas modernas para desarrollo de servidor web.

Cargo, el administrador de paquetes de Rust, simplifica la administración de dependencias y crea procesos. Además, Rust tiene una excelente compatibilidad con IDE con herramientas como Rust Analyzer que brinda finalización de código sin problemas, resaltado de errores y otras características.

Descripción general de las bibliotecas Actix y Rocket

La biblioteca estándar de Rust tiene la mayor parte de la utilidad que necesitará para construir servidores web. Bibliotecas de terceros como Cohete y Actix Simplifique la creación de aplicaciones del lado del servidor con Rust.

Actix y Cohete son marcos web populares de Rust, pero las bibliotecas difieren en diseño y características.

Rocket es un marco web de alto nivel que prioriza la productividad y la facilidad de uso. Rocket proporciona muchas abstracciones y azúcar de sintaxis para crear aplicaciones web en Rust. Rocket también es popular por su escritura fuerte y su diseño intuitivo de API.

Puede agregar Rocket como una dependencia del proyecto en su Cargo.toml para comenzar a crear aplicaciones web en Rust:

[dependencias]
cohete = "0.4.11"

Por otro lado, Actix-web es un marco de trabajo de bajo nivel que prioriza el rendimiento y la escalabilidad. Actix aprovecha un modelo de concurrencia basado en actores y proporciona E/S sin bloqueo que hace que el paquete sea ideal para crear aplicaciones web de alto rendimiento.

Agregue Actix como una dependencia del proyecto en el dependencias sección de su Cargo.toml archivo:

[dependencias]
actix-web = "4.3.1"

La elección de una biblioteca para su proyecto dependerá de las especificaciones de su proyecto, las características de la biblioteca y su experiencia con Rust y HTTP.

Construyendo un servidor web simple en Rust

Después de crear un proyecto Rust y agregar cualquiera de los marcos Rocket o Actix a las dependencias de su proyecto en el Cargo.toml archivo, está listo para comenzar a construir un servidor web en Rust.

Creación de un servidor web sencillo con Actix

Puede usar un serializador para solicitudes al crear servicios web en Rust.

Serde es una biblioteca popular de Rust para serializar y deserializar datos entre tipos de Rust y formatos de datos como JSON, YAML y TOML. Serde proporciona un marco para definir la conversión de datos entre las estructuras de datos de Rust y las representaciones correspondientes en otros formatos de datos.

Aquí está la directiva para agregar Serde como un paquete de terceros para su proyecto.

[dependencias]
serde = { versión = "1.0.159", caracteristicas = ["derivar"] }

Una vez que haya agregado Serde y Actix como dependencias del proyecto, puede generar un servidor web básico con Rust. Así es como puede configurar un simple ¡Hola Mundo! servidor web que escribe una cadena al cliente con Actix:

Primero, importe los módulos y tipos necesarios desde el actix_web y serde cajas:

usar actix_web::{get, web, App, HttpResponse, HttpServer, Responder};
usar serde::{Deserializar, Serializar};

usarás serde para serializar un mensaje al cliente con una estructura. Serde convertirá la estructura a JSON para el cliente. Aquí está la estructura del mensaje:

#[derivar (depurar, serializar, deserializar)]
estructuraMensaje {
 mensaje: Cadena,
}

Ahora puede definir la función de controlador para el punto final. En la parte superior de su función de controlador, puede agregar decoradores para comportamientos personalizados:

#[conseguir("/")]
asíncronofnHola() -> impl. Respondedor {
 HttpRespuesta::De acuerdo().json (Mensaje {
 mensaje: "¡Hola Mundo!".a_propiedad(),
 })
}

El Hola La función de controlador maneja las solicitudes GET. La función devuelve un tipo que implementa el Respondedor rasgo de la Actix paquete.

El json metodo de la HttpRespuesta:: Ok () type toma una instancia de estructura que Serde maneja bajo el capó y devuelve la respuesta al cliente.

Después de definir el punto final, puede iniciar una instancia de servidor y montar el punto final en una ruta.

#[actix_web:: principal]
asíncronofnprincipal() -> estándar:: io::Resultado {
 HttpServer:: nuevo(|| Aplicación:: nuevo().servicio (hola))
 .unir("127.0.0.1:8080")?
 .correr()
 .esperar
}

El Servidor Http:: nuevo función es una nueva instancia de servidor. El principal se inicia la función y el servidor monta el Hola función de controlador con la nueva instancia de la aplicación. El unir El método vincula el servidor a la URL especificada, y el correr La función ejecuta el servidor.

Construyendo un servidor web simple con Rocket

Rocket es minimalista, por lo que puede configurar un servidor web simple sin más dependencias que la Cohete caja.

He aquí cómo configurar un servidor simple con un ¡Hola Mundo! punto final usando Rocket:

Primero, importe las dependencias necesarias para su servidor.

#![función (proc_macro_higiene, decl_macro)]
#[uso_macro]
externocaja cohete;
// importaciones desde la caja Rocket
usar cohete:: respuesta:: contenido;
usar cohete:: Estado;

El #![función (proc_macro_higiene, decl_macro)] El atributo habilita las características experimentales de Rust para el marco Rocket. El #[uso_macro] atributo importa macros desde el cohete módulo.

Aquí hay una función de controlador que sirve HTML a pedido:

#[conseguir("/")]
fnHola Mundo() -> contenido:: Html'estáticocalle> {
 contenido:: HTML("
¡Hola Mundo!
")
}

El Hola Mundo función devuelve una cadena estática HTML con el contenido:: HTML función.

Aquí hay una declaración de estructura de configuración para el servidor (convención del marco de Rocket):

estructuraConfiguración {
 puerto: u16,
}
#[conseguir("/puerto")]
fnpuerto(configuración: Estado) -> Cadena {
¡formato!("Servidor ejecutándose en el puerto {}", config.puerto)
}

Cuando ejecuta el servidor, puede realizar solicitudes al /port punto final para el estado del puerto.

Finalmente, creará una instancia de servidor con el encender función. Agregue las configuraciones, monte las rutas e inicie el servidor:

fnprincipal() {
dejar config = Configuración { puerto: 8000 };
 cohete:: encender()
 .manage (configuración)
 .montar("/", rutas![hola_mundo, puerto])
 .lanzamiento();
}

El configuración variable es una instancia de la Configuración estructura El encender función inicia una instancia de servidor, el administrar agrega la configuración al servidor, y el montar El método monta la función del controlador en las rutas base. Finalmente, el lanzamiento El método inicia el servidor para escuchar en el puerto especificado.

Puede crear aplicaciones web potentes en Rust con WASM

WebAssembly (WASM) es un formato de instrucción binaria diseñado para ejecutarse en navegadores y otros dispositivos. WASM proporciona un formato de código de bytes de bajo nivel que los lenguajes de programación de alto nivel como Rust pueden usar como objetivo de compilación.

Con WASM, puede compilar su código Rust en un formato binario que pueden ejecutar los navegadores más populares. WASM abre un mundo de posibilidades para crear aplicaciones web sólidas en Rust, incluidas aplicaciones web completas.