Aller au contenu
Encyclopédie informatique Édition 2026

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

Derrière une application de livraison de repas ou de vidéo à la demande ne se cache pas un programme, mais des dizaines, voire des centaines de petits services qui dialoguent en permanence : l’un gère les comptes, un autre le catalogue, un autre les paiements, un autre les recommandations. C’est l’architecture en microservices, qui a permis aux géants du Web de faire travailler des milliers de développeurs en parallèle. Cet article explique comment découper une application, comment les services communiquent, par des API REST, GraphQL ou gRPC, ou par des messages, comment éviter qu’une panne se propage de proche en proche, quand cette architecture est un bon choix et quand elle ne l’est pas, et pourquoi chaque service est une porte d’entrée de plus à protéger.

Rubrique
Développement
Niveau
Intermédiaire à avancé
Lecture
17 min (essentiel)
23 min (complet)
Révision
27 octobre 2026
Niveau de lecture :

En bref

  • Une architecture en microservices découpe une application en petits services autonomes, chacun avec ses données, qui se déploient séparément et communiquent par des API ou des messages.
  • Ils communiquent de façon synchrone, par des API REST, GraphQL, qui permet au client de choisir les données voulues, ou gRPC, rapide et compact, ou de façon asynchrone, par des événements publiés sur un bus de messages.
  • Dans un système distribué, les pannes sont inévitables : délais d’expiration, nouveaux essais, disjoncteurs et observabilité empêchent qu’une panne locale ne devienne générale.
  • Les microservices apportent indépendance et souplesse aux grandes organisations, au prix d’une complexité élevée ; pour beaucoup de projets, un monolithe bien organisé est préférable.
  • Chaque service et chaque API sont des cibles : authentification entre services, contrôle des droits sur chaque objet et protection du réseau interne sont indispensables.

Prérequis conseillés : Les API et les services web · Les conteneurs : Docker et Kubernetes

1Définition

Une architecture en microservices organise une application comme un ensemble de petits services autonomes. Chacun est responsable d’une fonction précise, le catalogue, le panier, le paiement, la livraison ; il possède ses propres données ; il est développé, testé et déployé indépendamment des autres, souvent par une petite équipe ; et il communique avec les autres uniquement par des interfaces bien définies, des API (voir les API) ou des messages. On l’oppose au monolithe, une application construite et déployée d’un seul bloc, dont toutes les fonctions partagent le même code et la même base de données.

Les microservices ont fait évoluer les API elles-mêmes. Au style REST, fondé sur les ressources et les méthodes du protocole HTTP (voir HTTP), se sont ajoutés GraphQL, qui laisse le client choisir précisément les données voulues, et gRPC, conçu pour des échanges très rapides entre services, ainsi que la communication par événements. Cet article les présente en détail, avec les techniques qui rendent un tel système fiable, observable et sûr.

2Du monolithe aux microservices

Pendant longtemps, la plupart des applications d’entreprise étaient des monolithes, et beaucoup le restent. Dans les années 2000, l’architecture orientée services chercha à faire communiquer les applications d’une entreprise par des services Web normalisés (voir les API). Au début des années 2010, des entreprises du Web comme Amazon, Netflix ou Spotify poussent l’idée plus loin : leurs applications géantes, modifiées chaque jour par des milliers de développeurs, ne peuvent plus être livrées d’un bloc. Elles les découpent en centaines de services indépendants. Le terme « microservices » se répand vers 2012, et un article de James Lewis et Martin Fowler en fixe la définition en 2014.

Deux évolutions techniques ont rendu ce modèle praticable : les conteneurs, qui permettent d’emballer et de lancer chaque service de façon identique partout, et les orchestrateurs comme Kubernetes, qui gèrent automatiquement des milliers de conteneurs (voir les conteneurs) ; et l’intégration et le déploiement continus, qui automatisent la mise en production (voir DevOps). Après une décennie d’enthousiasme, le mouvement connaît un retour de balancier : beaucoup d’équipes ont découvert le coût de cette complexité, et redécouvrent les vertus d’un monolithe bien organisé (section 9).

3Découper une application

Dans un monolithe, les modules partagent une base de données et s’appellent directement ; dans une architecture en microservices, chacun possède ses données et n’y donne accès que par son API (figure 1). Une passerelle d’API reçoit les requêtes des clients et les dirige vers le bon service ; un bus d’événements permet aux services de s’informer mutuellement de ce qui se passe.

MONOLITHE une seule application catalogue panier paiement livraison une base un seul déploiement MICROSERVICES passerelle d’API catalogue sa base panier sa base paiement sa base livraison sa base bus d’événements : « commande payée », « colis expédié »… chaque service se déploie seul, à son rythme
Figure 1. Le monolithe partage tout ; les microservices ne partagent que leurs API et leurs événements.

Où tracer les frontières ? La méthode la plus utilisée vient de la conception pilotée par le domaine (en anglais Domain-Driven Design), décrite par Eric Evans en 2003 : on identifie des contextes délimités, des parties du métier dans lesquelles les mots ont un sens précis et stable. Le mot « produit » ne recouvre pas la même chose pour le catalogue, qui s’intéresse à sa description et à ses photos, pour l’entrepôt, qui s’intéresse à son poids et à son emplacement, et pour la comptabilité, qui s’intéresse à son taux de TVA, la taxe sur la valeur ajoutée. Chaque contexte devient un candidat au rôle de service. Un bon découpage minimise les échanges entre services : si deux services doivent toujours être modifiés ensemble, ou s’appellent à chaque opération, ils devraient probablement n’en faire qu’un (exercice 1).

Le découpage a aussi une dimension humaine. Selon la loi de Conway, formulée en 1968, l’architecture d’un système tend à reproduire la structure de communication de l’organisation qui le conçoit (anecdote). Les entreprises qui adoptent les microservices organisent donc souvent leurs équipes autour des services : chaque équipe est responsable d’un ou de quelques services, de leur conception à leur exploitation en production.

La règle « une base de données par service » est la plus contraignante. Elle garantit l’indépendance, puisqu’un service peut changer la structure de ses données sans casser les autres, mais elle interdit les jointures et les transactions entre services (voir les bases de données). Pour une commande qui doit réserver le stock, débiter le client et planifier la livraison, on ne peut plus tout valider ou tout annuler d’un coup. On utilise alors une saga : une suite d’étapes locales, chacune dans un service, avec pour chaque étape une action de compensation qui l’annule si une étape ultérieure échoue, par exemple rembourser le client si la livraison est impossible. Pendant le déroulement de la saga, les données des différents services peuvent être momentanément incohérentes : on parle de cohérence à terme.

Pour s’exercer

Exercice 1 : un découpage douteux

Une équipe a créé un service « Clients » et un service « Adresses des clients ». Chaque requête vers l’un appelle l’autre, et toute modification de l’un oblige à modifier l’autre. Qu’en penser ?

Voir la réponse

C’est le signe d’un mauvais découpage : les deux services forment un même contexte, l’adresse étant une partie de la fiche client. Les séparer ajoute des appels réseau, des pannes possibles et des déploiements coordonnés, sans aucun bénéfice d’indépendance. Il faut les fusionner. Un bon service correspond à une capacité métier cohérente, que l’on peut faire évoluer seule, et non à une table de base de données.