De REST à GraphQL : pourquoi et comment j'ai fait le changement

En tant qu'ingénieur logiciel avec 4 ans d'expérience dans la création d'API REST, j'ai toujours apprécié la simplicité et la fiabilité que REST apporte. Qu'il s'agisse de concevoir des points de terminaison ou de structurer des réponses, REST était ma solution de prédilection.

Mais plus tôt cette année, tout a changé. J'ai été chargé de me lancer dans un projet qui nécessitait de gérer des sources de données volumineuses, complexes et interdépendantes. Il ne s'agissait pas seulement de récupérer une liste d'utilisateurs ou de mettre à jour un seul enregistrement, cela exigeait de la flexibilité, de la précision et une efficacité à une échelle que REST avait du mal à fournir.

Entrez GraphQL. ?

Au début, j'étais sceptique. Pourquoi réparer quelque chose qui n’est pas cassé ? Mais au fur et à mesure que j’approfondissais, GraphQL n’a pas seulement répondu aux besoins du projet : il a redéfini ma façon de penser les API. Avec sa capacité à :

• Renvoyer les données dans une structure flexible définie par le client,
• Fonctionner via un point de terminaison d'URL unique,
• Rejeter les requêtes invalides basées sur un schéma fortement typé, et
• Fournir les données dans formats prédéterminés et mutuellement compris,

GraphQL est rapidement devenu plus qu'une solution : il est devenu mon nouveau standard en matière de conception d'API.

Cela dit, le but de cet article est de ne pas discréditer les API REST au profit de GraphQL. En fait, je pense que les deux peuvent se compléter à merveille. REST joue toujours un rôle crucial dans mes projets, notamment pour des cas d'utilisation spécifiques où un point de terminaison REST dédié est plus pratique qu'une requête GraphQL.

Dans cet article, je partagerai :

1. Pourquoi j'ai fait le passage de REST à GraphQL,
2. Les avantages que j'ai expérimentés de première main, et
3. Un guide simple pour vous aider à créer votre tout premier serveur GraphQL.

Que vous soyez un débutant curieux de connaître GraphQL ou un ingénieur expérimenté cherchant à faire la transition, cet article vous montrera pourquoi GraphQL mérite votre attention et comment il peut transformer vos projets sans remplacer complètement REST.

Mon parcours de REST à GraphQL

Pendant des années, les API REST étaient mon gagne-pain. Je comptais sur eux pour créer des systèmes robustes, gérer les données et fournir des fonctionnalités. Mais à mesure que mes projets devenaient plus complexes, des fissures ont commencé à apparaître.

Défis liés aux API REST

Une frustration récurrente était la récupération excessive et insuffisante des données. Soit j’obtiendrais trop d’informations dont je n’avais pas besoin, soit je devrais faire plusieurs demandes pour obtenir tout ce que j’avais fait. La gestion de nombreux points de terminaison ajoute à la complexité, faisant des mises à jour et de la maintenance une corvée.

Découverte de GraphQL

Plus tôt cette année, j'ai rejoint un projet qui devait travailler avec de grandes sources de données interconnectées. REST ne suffisait pas, et l'équipe a suggéré GraphQL. Au départ, j'étais sceptique, mais la promesse de demander exactement ce qui était nécessaire à partir d'un seul point de terminaison m'a intrigué.

Premières impressions de GraphQL

Commencer avec GraphQL n’a pas été sans défis. Les schémas et les résolveurs semblaient intimidants, mais la flexibilité et le contrôle qu'ils offraient en valaient la peine. Au fil du temps, j'ai réalisé à quel point il résolvait de manière transparente les problèmes auxquels je faisais face avec REST.

Bien que j'utilise toujours REST pour des cas spécifiques, GraphQL est devenu mon outil préféré pour répondre aux exigences de données complexes et dynamiques.

Pourquoi j'ai fait le changement

Au fur et à mesure que j'approfondissais GraphQL, quelques avantages clés sont ressortis, rendant la transition une évidence :

• Flexibilité : Avec GraphQL, je pouvais récupérer exactement les données dont j'avais besoin, ni plus, ni moins. Plus besoin de jongler avec plusieurs points de terminaison ou de gérer une récupération excessive.
• Efficacité : Une seule requête peut remplacer plusieurs appels d'API REST, améliorant ainsi considérablement les performances. Cela a eu un impact particulièrement important dans les applications comportant des données complexes et interdépendantes.
• Expérience du développeur : Le schéma fortement typé, l'introspection et les meilleurs outils de débogage ont rendu le développement plus fluide et moins sujet aux erreurs.
• Support de l'écosystème et de la communauté : Des outils comme Apollo Client et GraphQL ont enrichi l'expérience, facilitant l'apprentissage et l'intégration de GraphQL dans mon flux de travail.

Comment j'ai effectué le changement

Le voyage n’a pas été sans défis, mais le diviser en étapes a rendu la transition gérable :

Étape 1 : Comprendre les bases de GraphQL

J'ai commencé par apprendre les concepts de base :

• Requêtes pour récupérer des données.
• Mutations pour modifier les données.
• Résolveurs pour connecter les définitions de schéma aux sources de données réelles.

Cette compréhension fondamentale a été essentielle à la création de mon premier serveur GraphQL.

Étape 2 : Créer mon premier serveur GraphQL

Pour mettre la main à la pâte, j'ai construit un serveur simple en utilisant Node.js et Apollo Server. Le processus ressemblait à ceci :

1. Configurer un projet Node.js : Initialiser le projet avec npm init et ajouter les dépendances essentielles.
2. Installer les dépendances GraphQL : Apollo-server et graphql installés.
3. Écrire un schéma de base et un résolveur : Définir un schéma pour décrire les données et écrire des résolveurs pour les récupérer.
4. Exécutez le serveur : Lancez-le et testez les requêtes à l'aide de GraphQL.

Le voir fonctionner pour la première fois était exaltant ? L’effort en valait la peine.

Étape 3 : Transition des API REST existantes

L'étape suivante consistait à intégrer GraphQL dans un projet REST existant. J'ai suivi une approche progressive :

1. Points de terminaison REST clés identifiés à remplacer par des requêtes ou des mutations GraphQL.
2. Création de schémas et de résolveurs GraphQL correspondants.
3. Maintien des points de terminaison REST aux côtés de GraphQL pendant la transition pour garantir la stabilité.

Cette approche hybride m'a permis de déployer GraphQL progressivement sans perturber les fonctionnalités existantes.

Guide de démarrage rapide : créez votre premier serveur GraphQL

Démarrer avec GraphQL est plus simple qu'il n'y paraît. Voici un guide rapide pour configurer un serveur de base à l'aide de Node.js et Apollo Server :

Étape 1 : Installer les dépendances

Commencez par initialiser un projet Node.js et installer les packages nécessaires :

npm init -y  
npm install apollo-server graphql  

Étape 2 : Définir un schéma et un résolveur

Créez un fichier appelé index.js et ajoutez le code suivant :

const { ApolloServer, gql } = require('apollo-server');  

// Simulated user data  
const users = [  
  { id: '1', name: 'John Doe', email: 'john@example.com' },  
  { id: '2', name: 'Jane Smith', email: 'jane@example.com' },  
  { id: '3', name: 'Alice Johnson', email: 'alice@example.com' },  
];  

// Define schema  
const typeDefs = gql`  
  type User {  
    id: ID  
    name: String  
    email: String  
  }  

  type Query {  
    users: [User]  
    user(id: ID!): User  
  }  
`;  

// Define resolvers  
const resolvers = {  
  Query: {  
    users: () => users,  
    user: (_, { id }) => users.find((user) => user.id === id),  
  },  
};  

// Create server  
const server = new ApolloServer({ typeDefs, resolvers });  

// Start server  
server.listen().then(({ url }) => {  
  console.log(`? Server ready at ${url}`);  
});  

Étape 3 : Exécutez le serveur et testez

Démarrez le serveur avec :

node index.js  

Ouvrez l'URL fournie dans votre navigateur ou dans un outil comme GraphQL et testez les requêtes :

Interroger tous les utilisateurs :

query {  
  users {  
    id  
    name  
    email  
  }  
}  

Interroger un seul utilisateur par ID :

query {  
  user(id: "1") {  
    name  
    email  
  }  
}  

Félicitations?? Vous venez de créer votre premier serveur GraphQL !

Leçons apprises

Le passage à GraphQL m'a appris des leçons inestimables :

Ce qui s'est bien passé

• La transition a considérablement amélioré l'efficacité de la récupération des données. Fini la sous-récupération ou la sur-récupération !
• Le schéma fortement typé réduit les erreurs d'exécution et facilite le débogage.
• Les outils de l'écosystème (comme Apollo Client) ont amélioré la productivité des développeurs.

Ce que je ferais différemment

• Apprenez progressivement : J'ai plongé la tête la première, ce qui était écrasant. Adopter une approche progressive et se concentrer d’abord sur les requêtes et les mutations aurait été plus fluide.
• Commencez petit : Je commencerais par remplacer un seul point de terminaison REST par GraphQL pour avoir une idée du flux de travail.

Conseils pour les autres

• N'abandonnez pas complètement REST : REST et GraphQL peuvent coexister. Utilisez REST pour les opérations simples et GraphQL pour les besoins de données complexes et interdépendants.
• Tirez parti de la communauté : GraphQL dispose d'une communauté active et d'excellentes ressources. N’hésitez pas à demander de l’aide ou à apprendre des expériences des autres.

La transition vers GraphQL ne consiste pas seulement à changer d'outils, il s'agit de repenser la façon dont vous interagissez avec les données. Commencez petit, expérimentez et profitez du voyage !

REST vs GraphQL : une comparaison rapide

Lorsque vous décidez entre REST et GraphQL, comprendre les principales différences peut vous aider à faire le bon choix pour votre projet. Voici une ventilation rapide :

Fonctionnalité API REST GraphQL ête>

Feature	REST API	GraphQL
Data Fetching	Fixed data structure for endpoints; can lead to over-fetching or under-fetching.	Flexible queries; fetch exactly what you need.
Endpoint Management	Multiple endpoints for different resources.	Single endpoint for all queries and mutations.
Flexibility	Limited flexibility; requires custom endpoints for specific data needs.	Highly flexible; client defines data requirements.
Type Safety	Relies on documentation; no built-in type enforcement.	Strongly-typed schema ensures predictable data.
Error Handling	Custom error formats; inconsistent across APIs.	Standardized error responses from schema validation.
Tooling	Varied and often endpoint-specific tools.	Rich ecosystem with tools like Apollo, GraphQL, and Relay.

Récupération de données Structure de données fixe pour les points de terminaison ; peut conduire à une récupération excessive ou insuffisante. Requêtes flexibles ; récupérez exactement ce dont vous avez besoin. Gestion des points de terminaison Plusieurs points de terminaison pour différentes ressources. Point de terminaison unique pour toutes les requêtes et mutations. Flexibilité Flexibilité limitée ; nécessite des points de terminaison personnalisés pour des besoins de données spécifiques. Très flexible ; le client définit les exigences en matière de données. Type Sécurité S'appuie sur la documentation ; aucune application de type intégrée. Un schéma fortement typé garantit des données prévisibles. Gestion des erreurs Formats d'erreur personnalisés ; incohérent entre les API. Réponses d'erreur standardisées issues de la validation du schéma. Outillage Outils variés et souvent spécifiques aux points de terminaison. Un écosystème riche avec des outils comme Apollo, GraphQL et Relay.

Bien que les API REST soient fiables et largement prises en charge, GraphQL brille dans les scénarios nécessitant des données complexes et interdépendantes et de la flexibilité.
Approfondissez les différences dans mon article précédent

Conclusion

La transition de REST vers GraphQL a changé la donne pour moi. La flexibilité, l'efficacité et l'expérience améliorée des développeurs ont rendu mes projets plus robustes et évolutifs. Cela dit, je crois fermement que les API REST et GraphQL peuvent coexister, se complétant pour différents cas d'utilisation.

Si vous envisagez de faire le changement, je vous encourage à commencer petit, à expérimenter et à intégrer progressivement GraphQL dans votre pile. C’est un voyage qui vaut la peine d’être entrepris et j’ai hâte de voir comment vous vous l’approprierez.

Ressources pour commencer

Voici quelques outils et guides pour vous aider à vous plonger dans GraphQL :

• Documentation GraphQL
• Guide du serveur Apollo
• Terrain de jeu GraphQL

Bentil ici ?
Êtes-vous passé de REST à GraphQL ou envisagez-vous de faire la transition ? Quels défis ou succès avez-vous rencontrés en cours de route ? N'hésitez pas à partager vos réflexions, questions ou expériences dans les commentaires ci-dessous. Grandissons et apprenons ensemble ! ?

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!