API GraphQL avec Rust : tutoriel pas à pas pour créer un service web

API GraphQL avec Rust : tutoriel étape par étape

GraphQL est un langage de requête pour les API qui permet aux clients d'obtenir uniquement les données nécessaires. Rust, quant à lui, est réputé pour ses performances et sa sécurité mémoire. Dans ce tutoriel, nous allons créer une API GraphQL complète en Rust en utilisant les bibliothèques Juniper et Actix-web. Vous apprendrez à configurer le serveur, définir le schéma, implémenter des requêtes et des mutations, ainsi qu'à tester l'API.

Ce contenu sera utile aux développeurs familiers avec les bases de Rust et du développement web. Nous nous concentrerons sur l'implémentation pratique, en évitant la théorie superflue.

Configuration du projet et installation des dépendances

Commençons par créer un nouveau projet Rust :

cargo new rust-graphql-apicd rust-graphql-api

Ajoutons les dépendances nécessaires dans le fichier Cargo.toml :

[dependencies]actix-web = "4"actix-rt = "2"serde = { version = "1", features = ["derive"] }serde_json = "1"juniper = "0.16"juniper_actix = "2"

Ici, actix-web est le framework web, et juniper est la bibliothèque pour travailler avec GraphQL. juniper_actix assure l'intégration entre eux.

Création du schéma GraphQL de base

Définissons maintenant un modèle de données et un schéma simples. Pour l'exemple, nous allons créer un système de gestion des utilisateurs et des publications.

Créons le fichier src/schema.rs :

use juniper::{GraphQLObject, GraphQLInputObject, RootNode};

#[derive(GraphQLObject)]#[graphql(description = "Utilisateur du système")]pub struct User {    pub id: i32,    pub name: String,    pub email: String,}

#[derive(GraphQLInputObject)]#[graphql(description = "Données d'entrée pour la création d'un utilisateur")]pub struct NewUser {    pub name: String,    pub email: String,}

#[derive(GraphQLObject)]#[graphql(description = "Publication d'un utilisateur")]pub struct Post {    pub id: i32,    pub title: String,    pub body: String,    pub author_id: i32,}

pub struct QueryRoot;

#[juniper::object]impl QueryRoot {    fn users() -> Vec<User> {        vec![            User { id: 1, name: "Alexeï".into(), email: "alex@example.com".into() },            User { id: 2, name: "Maria".into(), email: "maria@example.com".into() },        ]    }

    fn posts() -> Vec<Post> {        vec![            Post { id: 1, title: "Première publication".into(), body: "Texte de la publication".into(), author_id: 1 },        ]    }}

pub struct MutationRoot;

#[juniper::object]impl MutationRoot {    fn create_user(new_user: NewUser) -> User {        User {            id: 3,            name: new_user.name,            email: new_user.email,        }    }}

pub type Schema = RootNode<'static, QueryRoot, MutationRoot>;

Nous avons défini deux objets racine : QueryRoot pour les requêtes (récupération de données) et MutationRoot pour les mutations (modification de données). #[derive(GraphQLObject)] génère automatiquement les types GraphQL à partir des structures Rust.

Configuration du serveur web et intégration avec Actix-web

Créons maintenant le fichier principal src/main.rs pour lancer le serveur :

mod schema;

use actix_web::{web, App, HttpServer, HttpResponse, middleware};use juniper_actix::{graphql_handler, playground_handler};use std::sync::Arc;

use crate::schema::Schema;

async fn graphql_route(    req: actix_web::HttpRequest,    payload: actix_web::web::Payload,    schema: web::Data<Arc<Schema>>,) -> actix_web::Result<HttpResponse> {    let context = ();    graphql_handler(&schema, &context, req, payload).await}

async fn playground_route() -> actix_web::Result<HttpResponse> {    playground_handler("/graphql", None).await}

#[actix_web::main]async fn main() -> std::io::Result<()> {    let