Aller au contenu
Encyclopédie informatique Édition 2026

Les microservices et les API modernes : REST, GraphQL et gRPC

Partie 2 sur 3

Niveau de lecture :

4Faire communiquer les services

4.1Synchrone ou asynchrone

Dans une communication synchrone, un service en appelle un autre et attend sa réponse, comme lors d’un appel téléphonique : c’est le cas des API REST, GraphQL et gRPC. Simple à comprendre, ce mode crée une dépendance forte : si le service appelé est lent ou en panne, l’appelant l’est aussi. Dans une communication asynchrone, un service publie un message, « la commande 42 est payée », sur un bus de messages, et les services intéressés le traitent quand ils le peuvent, comme on laisse un courrier : l’entrepôt prépare le colis, la comptabilité émet la facture, le service de fidélité ajoute des points. L’émetteur ne connaît pas ses destinataires, et une panne de l’un d’eux n’empêche pas la commande d’aboutir : le message attendra.

Les bus de messages les plus connus sont RabbitMQ, qui distribue des messages dans des files d’attente, et Kafka, créé chez LinkedIn et publié en 2011, qui conserve un journal ordonné de tous les événements, que chaque service lit à son rythme et peut relire. La plupart des systèmes combinent les deux modes : synchrone quand l’utilisateur attend une réponse immédiate, asynchrone pour tout ce qui peut se faire en arrière-plan.

Les architectures fondées sur les événements obéissent à quelques règles. Un bus de messages garantit en général que chaque message sera livré au moins une fois, mais peut le livrer deux fois, après une panne par exemple : les services qui les traitent doivent donc être idempotents. Un service qui enregistre une donnée puis publie un événement court le risque de tomber en panne entre les deux, laissant la base modifiée sans que personne n’en soit informé : la technique de la boîte d’envoi transactionnelle (en anglais outbox) consiste à enregistrer l’événement dans la même transaction que la donnée, dans une table dédiée, puis à le publier ensuite (exercice 8). Certains systèmes vont plus loin avec la source d’événements (en anglais event sourcing) : au lieu de stocker l’état actuel, on stocke la suite complète des événements, « compte ouvert », « 50 € déposés », « 20 € retirés », et l’on reconstitue l’état en les rejouant, ce qui fournit un historique complet et permet de répondre à des questions que l’on ne s’était pas posées au départ.

4.2Passerelle d’API et maillage de services

Les clients, navigateurs ou applications mobiles, ne parlent pas directement aux dizaines de services : ils s’adressent à une passerelle d’API, qui authentifie les requêtes, applique des limites de débit et les dirige vers le bon service. À l’intérieur, les communications entre services peuvent être confiées à un maillage de services (en anglais service mesh) : un petit programme mandataire, placé à côté de chaque service, intercepte tous ses échanges et prend en charge, de façon uniforme, le chiffrement, l’authentification mutuelle, les nouveaux essais, les délais d’expiration et la collecte de mesures. Les développeurs n’ont plus à programmer ces fonctions dans chaque service, au prix d’une infrastructure supplémentaire à maîtriser.

4.3Trouver les autres services

Dans un système où les services démarrent, s’arrêtent et se multiplient en permanence, leurs adresses changent sans cesse. La découverte de services résout ce problème : chaque service s’inscrit dans un annuaire en démarrant, et ceux qui veulent l’appeler y cherchent ses adresses du moment. Dans Kubernetes, ce mécanisme est intégré : on appelle un service par son nom, et l’orchestrateur répartit les requêtes entre ses instances en bonne santé, en écartant automatiquement celles qui ne répondent plus aux vérifications régulières.

Pour s’exercer

Exercice 2 : la disponibilité en chaîne

Pour afficher une page, un service doit appeler en série cinq autres services, chacun disponible 99,9 % du temps. Quelle est la disponibilité de la page ? Et avec vingt services ? Que faire ?

Voir la réponse

Si les pannes sont indépendantes, la page ne fonctionne que si les cinq services fonctionnent : 0,9995 ≈ 0,995, soit 99,5 %, environ 44 heures d’indisponibilité par an au lieu de 9. Avec vingt services : 0,99920 ≈ 0,980, soit 98 %, plus de 7 jours par an. Remèdes : réduire les dépendances synchrones, passer en asynchrone ce qui peut l’être, mettre en cache, et surtout prévoir des modes dégradés, pour que l’indisponibilité d’un service secondaire n’empêche pas l’affichage de la page.

Exercice 3 : payer deux fois ?

Le service de commandes appelle le service de paiement. La réponse se perd à cause d’un incident réseau ; le service de commandes réessaie. Le client risque-t-il d’être débité deux fois ? Comment l’éviter ?

Voir la réponse

Oui : le premier appel a peut-être abouti, seule la réponse s’est perdue. Pour éviter le double débit, on rend l’opération idempotente : le service de commandes génère une clé unique pour ce paiement et l’envoie avec chaque essai ; le service de paiement mémorise les clés déjà traitées et, s’il reçoit à nouveau la même, renvoie le résultat du premier traitement sans débiter une seconde fois. Les grands services de paiement en ligne proposent exactement ce mécanisme, sous le nom de clé d’idempotence.

Exercice 4 : le problème N + 1

Une requête GraphQL demande les 50 dernières commandes avec le nom de leur client. Le résolveur des commandes fait une requête à la base, puis le résolveur du client fait une requête par commande. Combien de requêtes au total ? Comment améliorer ?

Voir la réponse

1 requête pour les commandes, plus 50 pour les clients : 51 requêtes, d’où le nom de problème « N + 1 ». La solution consiste à regrouper : pendant le traitement de la requête, on collecte les identifiants des clients demandés, puis on les charge en une seule requête, du type « tous les clients dont l’identifiant est dans cette liste » : 2 requêtes au lieu de 51. Ce regroupement s’accompagne en général d’une mémorisation, pour ne pas charger deux fois le même client dans une même requête.

Exercice 5 : synchrone ou asynchrone ?

Pour chacune de ces opérations, choisissez une communication synchrone ou asynchrone : (a) vérifier qu’un code promotionnel est valide pendant que le client attend ; (b) envoyer le courriel de confirmation de commande ; (c) mettre à jour les statistiques de ventes ; (d) vérifier le stock avant de valider le panier.

Voir la réponse

(a) et (d) : synchrone, car l’utilisateur attend la réponse pour continuer, avec un délai d’expiration et un mode dégradé, par exemple accepter la commande et vérifier le stock juste après en cas de panne passagère. (b) et (c) : asynchrone, par un événement « commande validée » : le client n’a pas à attendre l’envoi du courriel ni le calcul des statistiques, et une panne de ces services ne doit pas bloquer les ventes.

Exercice 6 : la commande d’un autre

Une API répond à GET /api/commandes/1043 en vérifiant seulement que l’utilisateur est connecté. Un utilisateur remplace 1043 par 1044. Que se passe-t-il ? Comment corriger ?

Voir la réponse

Il obtient la commande d’un autre client, avec son nom, son adresse et le contenu de son achat. C’est la faille la plus répandue des API, classée en tête du palmarès de l’OWASP : l’absence de contrôle d’autorisation au niveau de chaque objet. Le service doit vérifier, à chaque requête, que l’objet demandé appartient bien à l’utilisateur ou que celui-ci a le droit d’y accéder, et ce contrôle doit être fait dans le service qui détient les données, pas seulement dans la passerelle. Des identifiants difficiles à deviner compliquent l’attaque, mais ne remplacent jamais ce contrôle.

Exercice 7 : choisir un style d’API

Quel style d’API choisir pour : (a) une API publique destinée à des milliers de développeurs externes ; (b) une application mobile dont les écrans combinent de nombreuses données ; (c) les échanges, des milliers par seconde, entre un service de calcul de prix et un service de catalogue internes ?

Voir la réponse

(a) REST, documenté avec OpenAPI : le style le plus connu, facile à tester avec un simple navigateur ou un outil en ligne de commande, et qui profite du cache du Web. (b) GraphQL : chaque écran demande exactement ce dont il a besoin, en une requête, ce qui ménage les connexions mobiles. (c) gRPC : messages binaires compacts, contrat strict, code généré, connexions multiplexées, idéal pour des échanges internes intensifs.

Exercice 8 : l’événement perdu

Le service de commandes enregistre une commande dans sa base, puis publie l’événement « commande créée » sur le bus de messages. Un jour, le service s’arrête brutalement juste entre les deux opérations. Que se passe-t-il ? Comment l’éviter ?

Voir la réponse

La commande existe dans la base, mais l’événement n’a jamais été publié : l’entrepôt ne prépare pas le colis, la facture n’est pas émise, et personne ne s’en aperçoit. Inverser l’ordre ne résout rien : on risquerait alors de publier l’événement d’une commande jamais enregistrée. La solution est la boîte d’envoi transactionnelle : dans une même transaction de base de données, le service enregistre la commande et une ligne « événement à publier » dans une table dédiée. Les deux réussissent ou échouent ensemble. Un processus séparé lit ensuite cette table et publie les événements, en réessayant jusqu’au succès ; les consommateurs, idempotents, ignorent les éventuels doublons.

5GraphQL

Avec une API REST classique, afficher une commande avec le nom du client et le détail des articles peut demander trois requêtes, qui renvoient chacune l’objet complet, y compris des champs inutiles (figure 2). Sur un téléphone, avec une connexion lente, ces allers-retours coûtent cher. C’est ce problème qu’a voulu résoudre Facebook en créant GraphQL, utilisé en interne dès 2012 et publié en 2015 : le client envoie, à une adresse unique, une requête qui décrit exactement la forme des données voulues, et le serveur renvoie une réponse qui a cette forme, ni plus ni moins.

AVEC REST : TROIS ALLERS-RETOURS GET /commandes/42 tout l’objet GET /clients/7 tout l’objet GET /articles?ids=3,9 tout l’objet des champs inutiles, plusieurs attentes réseau AVEC GRAPHQL : UNE REQUÊTE SUR MESURE query {   commande(id: 42) {     date     client { nom }     articles { nom prix }   } } exactement les champs demandés Le client décrit la forme des données voulues ; le serveur assemble la réponse.
Figure 2. Avec GraphQL, le client demande en une fois exactement ce dont il a besoin.

Une API GraphQL est décrite par un schéma, qui définit les types de données et les opérations possibles :

type Commande {
  id: ID!
  date: String!
  client: Client!
  articles: [Article!]!
}

type Query {
  commande(id: ID!): Commande
}

type Mutation {
  annulerCommande(id: ID!): Commande
}

Le point d’exclamation signifie qu’une valeur est obligatoire, les crochets désignent une liste. Les requêtes (query) lisent des données, les mutations les modifient, et les abonnements (subscription) permettent de recevoir des mises à jour en temps réel. Côté serveur, chaque champ est calculé par une fonction appelée résolveur, qui peut aller chercher la donnée dans une base ou dans un autre service. Le schéma sert aussi de documentation, et des outils permettent d’explorer l’API et de composer des requêtes en bénéficiant de la complétion automatique.

Cette souplesse a des contreparties. Une requête innocente peut déclencher des centaines d’accès à la base : pour 100 commandes, le résolveur du client est appelé 100 fois, une par commande, en plus de la requête initiale ; c’est le problème dit « N + 1 », que l’on résout en regroupant les accès, par exemple avec un outil qui collecte les identifiants demandés et les charge en une seule requête (exercice 4). La mise en cache est plus difficile qu’avec REST, puisque toutes les requêtes passent par la même adresse et diffèrent toutes. Et un client peut composer des requêtes très coûteuses, ce qui ouvre la porte aux dénis de service (coin cyber). Pour les grandes organisations, la fédération permet à chaque équipe de gérer une partie du schéma, servie par son propre service, tandis qu’une passerelle assemble le tout en un graphe unique.

6gRPC

gRPC, publié par Google en 2015, renoue avec l’idée d’appel de procédure à distance : appeler une fonction d’un autre service comme si elle était locale. Les échanges sont décrits dans un fichier au format Protocol Buffers, à partir duquel des outils génèrent automatiquement le code client et serveur dans de nombreux langages :

syntax = "proto3";

service Catalogue {
  rpc LirePrix (DemandePrix) returns (Prix);
  rpc SuivreStock (Reference) returns (stream NiveauStock);
}

message DemandePrix { string reference = 1; }
message Prix        { int64 centimes = 1; string devise = 2; }

Les messages sont encodés en binaire, bien plus compact et rapide à traiter que le texte JSON, le format de données habituel des API REST, et transportés par HTTP/2, la deuxième version du protocole du Web, qui permet de faire passer de nombreux appels simultanés dans une même connexion. gRPC gère aussi les flux : le mot-clé stream indique ici que le service envoie en continu les variations du stock, sans que le client ait à redemander. Les numéros associés aux champs permettent de faire évoluer les messages, en ajoutant des champs, sans casser les clients existants. En contrepartie, les messages binaires ne se lisent pas à l’œil nu, et les navigateurs ne parlent pas directement gRPC, qui sert donc surtout entre services, à l’intérieur d’un centre de données, et pour les applications mobiles.

Tableau 1. Trois styles d’API comparés.
CritèreRESTGraphQLgRPC
Principedes ressources, manipulées par les méthodes HTTPune requête qui décrit les données vouluesdes appels de fonctions à distance
Formattexte, le plus souvent JSONtexte JSONbinaire, Protocol Buffers
Contratfacultatif, souvent OpenAPIschéma obligatoirefichier .proto obligatoire
Cachesimple, celui du Webplus difficileà gérer soi-même
Usage typiqueAPI publiques, intégrationsapplications aux écrans riches, mobilecommunications internes rapides