DEV Community: Thibaut Roche

Notre première route avec Rocket

Thibaut Roche — Tue, 06 Sep 2022 07:16:44 +0000

Ajout de Rocket à notre projet

Bon, il est maintenant temps de se salir les mains et d'ajouter notre framework web à notre projet. Nous utiliserons Rocket car c'est à mon sens la crate la plus facile à appréhender et à mettre en place. Vous pouvez également consulter la crate actix-web qui peut être une très bonne alternative.
Pour les personnes n'étant pas familières avec le concept de crates, il s'agit de librairies (plugins, package...) permettant d'étendre les fonctionnalités du langage sans avoir besoin de réinventer la roue.

Si vous utilisez la crate cargo-edit vous pouvez simplement taper cargo add rocket dans votre terminal. Sinon, ajoutez simplement la version à votre fichier Cargo. Pour cet article, nous utiliserons la version 0.5.0-rc.2. Votre Cargo.toml devrait maintenant ressembler à ça :

[package]
name = "web_server"
version = "0.1.0"
edition = "2021"

[dependencies]
rocket = "0.5.0-rc.2"

On est paré ! Commençons à coder.

Créons notre première route

Mettre en place un serveur web en Rust avec Rocket est vraiment (très) simple. Qui a dit que le Rust était seulement un langage de bas niveau ?

Remplaçons le contenu de notre main.rs et voyons ce que ça donne.

#[macro_use]
extern crate rocket;

#[get("/health")]
fn healthcheck() -> &'static str {
    "OK"
}

#[launch]
fn rocket() -> _ {
    rocket::build().mount("/", routes![healthcheck])
}

Les deux premières lignes nous permettent d'utiliser les macros de Rocket telles que get ou launch. Vous devriez être familier avec ça si vous avez déjà fait du Rust. Vous pouvez aussi décider de retirer ces lignes et n'importer que les macros dont vous avez besoin.

La macro get transforme notre simple fonction en un endpoint pour notre API. Elle prend en paramèter une string qui correspond au chemin de notre endpoint (à noter que cette route peut être préfixée comme nous le verrons ci-après). Ce n'est évidemment pas la seule macro de ce type et il en existe d'autres correspondant à tous les verbes HTTP.

Notez qu'une route peut retourner n'importe quel type implémentant le trait Responder. Il est déjà implémenté pour certains types tels que &str, String, ou encore Json mais vous pouvez aussi l'implémenter pour vos propres types. Je vous encourage à aller consulter cette page si vous souhaitez en savoir plus sur le trait Responder et les réponses en général.

Finalement, la macro launch génère une fonction main qui appelle la fonction launch de la structure retournée par la fonction à laquelle la macro est appliquée. En l'occurrence, le code généré serait le suivant :

#[rocket::main]
async fn main() {
    let _ = rocket().launch().await;
}

Enfin, en ce qui concerne la fonction rocket() elle-même, elle se contente de monter les routes transmises en paramètre, préfixées du chemin indiqué. Notez qu'il est tout à fait possible d'appeler plusieurs fois la fonction mount si l'on souhaite monter différentes routes avec différents préfixes (nous aurons l'occasion d'y revenir plus tard dans cette série d'articles).

Nous pouvons maintenant lancer le serveur en tapant la commande cargo run dans notre terminal et voir les lignes suivantes nous indiquant que le serveur a démarré avec succès.

Configured for debug.
   >> address: 127.0.0.1
   >> port: 1234
   >> workers: 8
   >> ident: Rocket
   >> limits: bytes = 8KiB, data-form = 2MiB, file = 1MiB, form = 32KiB, json = 1MiB, msgpack = 1MiB, string = 8KiB
   >> temp dir: C:\Users\Thibaut\AppData\Local\Temp\
   >> http/2: true
   >> keep-alive: 5s
   >> tls: disabled
   >> shutdown: ctrlc = true, force = true, grace = 2s, mercy = 3s
   >> log level: debug
   >> cli colors: true
Routes:
   >> (healthcheck) GET /health
Fairings:
   >> Shield (liftoff, response, singleton)
registering event source with poller: token=Token(0), interests=READABLE | WRITABLE
Shield:
   >> X-Frame-Options: SAMEORIGIN
   >> Permissions-Policy: interest-cohort=()
   >> X-Content-Type-Options: nosniff
Rocket has launched from http://127.0.0.1:1234

Rendez-vous dans votre navigateur à l'adresse indiquée (en n'oubliant pas d'y ajouter le chemin de notre endpoint) et vous devriez voir le contenu souhaité à savoir "OK".

Changer la configuration avec le ficher Rocket.toml

Vous souhaitez peut-être configurer votre serveur Rocket pour qu'il se lance sur un port différent, avec un niveau de log plus ou moins élevé ou encore changer le nombre de workers ? Peut-être souhaitez vous aussi avoir des configurations différentes dépendamment des environnements dans lesquels sont déployés l'application ? Bonne nouvelle, le fichier Rocket.toml est là pour ça.

Dans ce fichier, vous pouvez spécifier comment lancer votre serveur et configurer celui-ci par profil. Vous pouvez aussi avoir des configurations par défaut ou au contraire des configurations écrasant toutes les autres valeurs.

Voici une exemple de configuration. Vous pouvez trouver tous les champs disponibles dans la documentation.

[debug]
address = "127.0.0.1"
port = 1234
log_level = "debug"

Dans le prochain article, nous irons un peu plus loin en ajoutant un système d'authentification à notre serveur !

Rust : Comment avoir un backend performant et résilient?

Thibaut Roche — Tue, 30 Aug 2022 10:31:00 +0000

Les serveurs web

Les serveurs web sont partout de nos jours. Légion sont les sites ne reposant plus simplement sur du HTML et du CSS pour afficher du contenu à leurs utilisateurs mais aussi sur un serveur (un "backend") afin de pouvoir leur offrir plus (e.g. une authentification, de la persistance, etc…).

Ces serveurs sont à l'origine d'une grande partie des "actions" effectuées par une application (que l'on parle de site web, application mobile ou tout autre application ayant recours à un service) et permettent de retourner des données ainsi que parfois en sauvegarder dans une base de données. Le serveur web parfait a donc plusieurs atouts. Parmi eux on compte :

La performance : un serveur lent impliquera des requêtes qui traînent dans le temps et par conséquent une expérience utilisateur dégradée.
La sécurité : un serveur non sécurisé pourra voir ses données volées ou modifiées.
La stabilité : un serveur buggé dégradera encore une fois l'expérience utilisateur allant parfois jusqu'à rendre un service totalement inutilisable.

Les technologies du web ont beaucoup évolué ces dernières années. Là où le PHP était un standard il y a 10/15 ans on observe maintenant une grande diversité dans les langages et les outils nous permettant de construire des services web. Parmi les langages on peut notamment citer Ruby, Java, Python, Javascript et bien d'autres ! Si chacun a bien évidemment ses avantages, ils sont évidemment aussi livrés avec leurs mauvais côtés. Ainsi un langage comme le Ruby, très facile d'accès et avec lequel on peut faire beaucoup de choses très rapidement, ne sera pas aussi performant qu'un langage compilé comme le C# par exemple.

Le Rust

Bon, c'est bien beau tout ça mais où est-ce que tu veux en venir ?

Et bien tout simplement au Rust. Pour ceux qui ne connaissent pas le Rust, c'est un langage développé initialement chez Mozilla (dans le but de construire un nouveau moteur web nommé "Servo") puis soutenu par la "Rust Foundation" depuis 2020. La promesse du Rust est d'offrir un langage performant, fiable et productif.

Les performances du Rust se rapprochent de celles du C, la référence en terme de rapidité.
Le langage est, grâce à son système de typing et d'ownership, thread safe et memory safe; ce qui limite un grand nombre d'erreurs.
Enfin Rust dispose d'une excellente documentation, d'un compilateur bienveillant, avec des messages d'erreur utiles, et d'outils de premier ordre, le tout assurant une excellente expérience de code.

En bref, le Rust a su tirer des leçons de ses prédécesseurs afin de profiter des points forts de chacun tout en y ajoutant ses propres atouts. C'est pour cette raison qu'il est devenu un choix de premier ordre pour les backends web.

Dans cette série d'articles, nous étudierons comment monter un serveur web en Rust, de la mise en place du workspace jusqu'à la mise en production, en passant par l'authentification ou la connexion à une base de données.

Une connaissance de base du langage Rust est requise afin de suivre au mieux les différentes étapes. Si ce n'est pas votre cas, n'hésitez pas à ouvrir le Book Rust sur un autre onglet pendant votre lecture !

Dans la prochaine partie, nous installerons notre workspace afin de pouvoir coder dans les meilleures conditions possibles.

Mise en place du workspace

Thibaut Roche — Tue, 30 Aug 2022 10:31:00 +0000

Installation de Rust

Tout d'abord, nous devons installer Rust. Pour cela, je recommande d'utiliser rustup afin de pouvoir facilement gérer et mettre à jours nos toolchains.

Si vous êtes un utilisateur Linux, vous pouvez simplement lancer cette commande dans votre terminal : curl - proto '=https' - tlsv1.2 -sSf https://sh.rustup.rs | sh.

Si vous utilisez Windows, vous devez télécharger et installer l'exécutable d'installation.

Un fois installé, vous pouvez vérifier le succès de la procédure en tapant rustup -v dans un terminal. Cela devrait afficher à la fois la version de rustup (gestionnaire de toolchains) ainsi que de rustc (compilateur).

Maintenant, il n'en tient qu'à vous de décider de la toolchain que vous souhaitez utiliser.

Stable : limiter un maximum les bugs.
Nightly : accéder aux dernières fonctionnalités.
Beta : un mix des deux.

Pour cet article, supposons que nous souhaitons travailler avec la version "nightly" de Rust :

rustup default nightly

Installation de VSCode & Rust Analyzer

Quand il s'agit d'écrire du code en Rust, je recommande souvent l'utilisation de Rust Analyzer. En effet, cet outil améliore votre IDE sur de nombreux aspects. Par exemple :

Complétion de code
Auto-import
Types des variables et paramètres inline
Highliting semantique de la syntaxe
Et bien d'autres…

VSCode étant l'éditeur le mieux supporté, c'est celui-ci que nous utiliserons dans cet article. Cependant, Rust Analyzer s'intègre aussi avec d'autres éditeurs. Je vous encourage donc à consulter le manuel si vous souhaitez l'intégrer à votre IDE favori.

Une fois VSCode installé, afin d'installer Rust Analyzer, il suffit de se rendre dans l'onglet des plugins à gauche de la fenêtre.

Aussi vous trouverez ci-après quelques autres plugins pouvant rendre votre vite plus facile lors du développement en Rust :

Better TOML : Pratique pour les fichiers de configuration, ajoute le support des fichiers toml.
crates : Vous permet de gérer les versions de vos crates directement depuis l'IDE.
GitLens : Ajoute une intégration git directement dans VSCode.

Création de notre projet

Nous sommes maintenant prêt à créer notre projet. Pour celà rien de plus simple, il suffit de taper cargo new <project_name> --bin. L'option --bin est là pour indiquer que nous souhaitons créer un programme et non une lib (--lib). A noter qu'un dépôt git est initialisé par défaut.
Votre arborescence devrait ressembler à ça :

├── Cargo.toml
└── src
    └── main.rs

Dans le prochain article, nous verrons comment mettre au point notre première route en Rust avec Rocket !