HTTP utilise une architecture client-serveur pour le transfert d'informations et de données. L'une des caractéristiques des langages de programmation côté serveur comme Rust est le développement de serveurs et d'applications clientes pour interagir avec des services basés sur HTTP.

Rust convient à la construction de serveurs HTTP en raison de ses caractéristiques de sécurité, de performances et de fiabilité. Les caisses tierces de Rust comme Actix et Rocket sont populaires pour la construction de serveurs Web sophistiqués capables de gérer un trafic élevé.

Pourquoi devriez-vous utiliser Rust pour le développement de serveurs Web HTTP?

Rust a gagné en popularité pour le développement de serveurs Web car certaines des fonctionnalités du langage sont exactement les exigences pour la construction de la plupart des serveurs Web.

L'utilisation de Rust garantit que votre application évolue efficacement, ce qui rend le langage idéal pour créer des applications hautes performances. Voici des raisons spécifiques d'envisager d'utiliser Rust pour votre serveur Web et d'autres applications côté serveur.

La haute performance de Rust

Les hautes performances sont l'une des raisons pour lesquelles Rust est un excellent choix pour la construction de serveurs Web HTTP. Rust fournit un accès de bas niveau aux ressources système, y compris la mémoire et le processeur, vous permettant d'écrire du code qui s'exécute plus rapidement avec moins de ressources que les autres langages côté serveur.

De plus, le système de propriété de Rust élimine le besoin de récupération de place au moment de la compilation, ce qui est l'une des raisons pour lesquelles certains langages côté serveur sont lents.

Sûreté et sécurité

Le système propriétaire de gestion de la mémoire de Rust rend le langage sécurisé pour le développement de serveurs Web. Vous ne rencontrez pas de références de pointeur nulles ou pendantes qui peuvent entraîner des fuites de mémoire et d'autres vulnérabilités de sécurité.

Le système de propriété de Rust empêche ces erreurs courantes pour assurer la sécurité de votre serveur et de vos applications. Rust se concentre également sur la prévention des débordements de mémoire tampon et d'autres erreurs liées à la mémoire.

Concurrence

La simultanéité est la capacité d'exécuter plusieurs unités d'un programme dans le désordre sans affecter la sortie. La sortie d'un programme concurrent doit être la même que la sortie d'un programme asynchrone.

La simultanéité peut affecter considérablement les performances de votre application, car les serveurs doivent gérer plusieurs requêtes simultanément. Rust prend en charge la coexistence avec un modèle de threading léger.

La sauce de la programmation concurrente dans Rust est que le système de propriété vous permet d'écrire du code thread-safe sans avoir besoin de verrous et d'autres primitives de synchronisation.

La bibliothèque Rust Standard et packages tiers dans l'écosystème Rust fournir des outils modernes pour une efficacité développement de serveur web.

Cargo, le gestionnaire de packages de Rust, simplifie la gestion des dépendances et construit des processus. De plus, Rust dispose d'un excellent support IDE avec des outils tels que Rust Analyzer qui fournissent une complétion de code transparente, une mise en évidence des erreurs et d'autres fonctionnalités.

Présentation des bibliothèques Actix et Rocket

La bibliothèque standard de Rust contient la plupart des utilitaires dont vous aurez besoin pour créer des serveurs Web. Des bibliothèques tierces comme Fusée et Actix simplifiez la création d'applications côté serveur avec Rust.

Actix et Fusée sont des frameworks Web Rust populaires, mais les bibliothèques diffèrent par leur conception et leurs fonctionnalités.

Rocket est un framework Web de haut niveau donnant la priorité à la productivité et à la facilité d'utilisation. Rocket fournit de nombreuses abstractions et du sucre de syntaxe pour créer des applications Web dans Rust. Rocket est également populaire pour son typage fort et sa conception d'API intuitive.

Vous pouvez ajouter Rocket en tant que dépendance de projet dans votre Cargaison.toml fichier pour commencer à créer des applications Web dans Rust :

[dépendances]
fusée = "0.4.11"

D'autre part, Actix-web est un framework de bas niveau privilégiant la performance et l'évolutivité. Actix exploite un modèle de concurrence basé sur les acteurs et fournit des E/S non bloquantes qui rendent le package idéal pour créer des applications Web performantes.

Ajouter Actix comme dépendance de projet dans le dépendances rubrique de votre Cargaison.toml déposer:

[dépendances]
actix-web = "4.3.1"

Le choix d'une bibliothèque pour votre projet dépendra des spécifications de votre projet, des fonctionnalités de la bibliothèque et de votre expérience avec Rust et HTTP.

Construire un serveur Web simple en Rust

Après avoir créé un projet Rust et ajouté l'un des frameworks Rocket ou Actix aux dépendances de votre projet dans le Cargaison.toml fichier, vous êtes prêt à commencer à créer un serveur Web dans Rust.

Construire un serveur Web simple avec Actix

Vous pouvez utiliser un sérialiseur pour les requêtes lors de la création de services Web dans Rust.

Serde est une bibliothèque Rust populaire pour la sérialisation et la désérialisation des données entre les types Rust et les formats de données tels que JSON, YAML et TOML. Serde fournit un cadre pour définir la conversion de données entre les structures de données Rust et les représentations correspondantes dans d'autres formats de données.

Voici la directive pour ajouter Serde en tant que package tiers pour votre projet.

[dépendances]
serde = { version = "1.0.159", caractéristiques = ["dériver"] }

Une fois que vous avez ajouté Serde et Actix en tant que dépendances du projet, vous pouvez générer un serveur Web de base avec Rust. Voici comment configurer un simple Bonjour le monde! serveur web qui écrit une chaîne au client avec Actix :

Tout d'abord, importez les modules et types nécessaires à partir du actix_web et serde caisses :

utiliser actix_web ::{get, web, App, HttpResponse, HttpServer, Responder} ;
utiliser serde ::{Désérialiser, Sérialiser} ;

Vous utiliserez serde pour sérialiser un message au client avec une structure. Serde convertira la structure en JSON pour le client. Voici la structure du message :

#[dériver (déboguer, sérialiser, désérialiser)]
structureMessage {
 message: Chaîne,
}

Vous pouvez maintenant définir la fonction de gestionnaire pour le point de terminaison. En haut de votre fonction de gestionnaire, vous pouvez ajouter des décorateurs pour les comportements personnalisés :

#[obtenir("/")]
asynchronefnBonjour() -> mettre en œuvre Répondant {
 HttpResponse ::D'accord().json (Message {
 message: "Bonjour le monde!".to_owned(),
 })
}

Le Bonjour La fonction de gestionnaire gère les requêtes GET. La fonction renvoie un type qui implémente le Répondant trait de la Actix emballer.

Le json méthode de la HttpResponse:: Ok() type prend dans une instance de structure qui Serde gère sous le capot et renvoie la réponse au client.

Après avoir défini le point de terminaison, vous pouvez démarrer une instance de serveur et monter le point de terminaison sur une route.

#[actix_web:: principal]
asynchronefnprincipal() -> std:: io ::Résultat {
 HttpServer:: new(|| App:: new().service (bonjour))
 .lier("127.0.0.1:8080")?
 .courir()
 .attendre
}

Le HttpServer:: nouveau La fonction est une nouvelle instance de serveur. Le principal la fonction démarre et le serveur monte le Bonjour fonction de gestionnaire avec la nouvelle instance d'application. Le lier lie le serveur à l'URL spécifiée, et la méthode courir La fonction exécute le serveur.

Construire un serveur Web simple avec Rocket

Rocket est minimaliste, vous pouvez donc configurer un serveur Web simple sans aucune dépendance autre que le Fusée Caisse.

Voici comment configurer un serveur simple avec un Bonjour le monde! point de terminaison utilisant Rocket :

Tout d'abord, importez les dépendances nécessaires pour votre serveur.

#![fonctionnalité (proc_macro_hygiene, decl_macro)]
#[macro_use]
externeCaisse fusée;
// importe depuis la caisse Rocket
utiliser fusée:: réponse:: contenu;
utiliser fusée:: État ;

Le #![fonctionnalité (proc_macro_hygiene, decl_macro)] L'attribut active les fonctionnalités expérimentales de Rust pour le framework Rocket. Le #[macro_use] l'attribut importe des macros à partir du fusée module.

Voici une fonction de gestionnaire qui sert HTML sur demande :

#[obtenir("/")]
fnBonjour le monde() -> contenu:: Html'statiquechaîne> {
 contenu:: Html("
Bonjour le monde!
")
}

Le Bonjour le monde La fonction renvoie une chaîne HTML statique avec la contenu:: Html fonction.

Voici une déclaration de structure de configuration pour le serveur (convention du framework Rocket):

structureConfiguration {
 port: u16,
}
#[obtenir("/port")]
fnport(config: État) -> Chaîne {
format!("Serveur en cours d'exécution sur le port {}", config.port)
}

Lorsque vous exécutez le serveur, vous pouvez adresser des requêtes au /port point de terminaison pour l'état du port.

Enfin, vous allez créer une instance de serveur avec le enflammer fonction. Ajoutez les configurations, montez les routes et lancez le serveur :

fnprincipal() {
laisser config = Config { port: 8000 };
 fusée:: enflammer()
 .manage (configuration)
 .monter("/", routes ![hello_world, port])
 .lancement();
}

Le configuration variable est une instance de Configuration structure. Le enflammer la fonction démarre une instance de serveur, la gérer ajoute la configuration au serveur, et la méthode monter La méthode monte la fonction de gestionnaire sur les routes de base. Finalement, le lancement La méthode lance le serveur pour écouter sur le port spécifié.

Vous pouvez créer de puissantes applications Web dans Rust avec WASM

WebAssembly (WASM) est un format d'instruction binaire conçu pour être exécuté sur des navigateurs et d'autres appareils. WASM fournit un format de bytecode de bas niveau que les langages de programmation de niveau supérieur comme Rust peuvent utiliser comme cible de compilation.

Avec WASM, vous pouvez compiler votre code Rust dans un format binaire que la plupart des navigateurs populaires peuvent exécuter. WASM ouvre un monde de possibilités pour créer des applications Web robustes dans Rust, y compris des applications Web complètes.