Aller au contenu
Encyclopédie informatique Édition 2026

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

Partie 3 sur 3

Niveau de lecture :

7Résister aux pannes

Dans un système distribué, quelque chose est toujours en panne : un serveur redémarre, un réseau sature, un service ralentit. Le danger est la panne en cascade : un service lent fait attendre ceux qui l’appellent, qui accumulent les requêtes en attente, épuisent leurs ressources et deviennent lents à leur tour, jusqu’à paralyser tout le système. Plusieurs techniques l’évitent :

  • le délai d’expiration : ne jamais attendre une réponse indéfiniment ; au-delà d’un délai, on abandonne et l’on traite l’erreur ;
  • les nouveaux essais, espacés de plus en plus et avec un peu de hasard, pour ne pas que tous les clients réessaient au même instant et achèvent le service qui se relève ;
  • le disjoncteur (en anglais circuit breaker), qui, comme son homologue électrique, coupe les appels vers un service qui échoue trop souvent, puis les rétablit prudemment (figure 3) ;
  • les cloisons, qui réservent des ressources séparées à chaque dépendance, pour qu’un service défaillant n’accapare pas tout ;
  • le mode dégradé : si le service de recommandations ne répond pas, la page s’affiche quand même, sans recommandations ;
  • l’idempotence : concevoir les opérations pour qu’une répétition n’ait pas d’effet supplémentaire, afin qu’un nouvel essai ne débite pas deux fois le client (exercice 3).
fermé les appels passent normalement ouvert les appels échouent aussitôt, sans attendre semi-ouvert quelques appels d’essai passent trop d’échecs délai écoulé les essais réussissent : retour à la normale un essai échoue Le disjoncteur évite qu’un service en panne n’entraîne tous ceux qui l’appellent.
Figure 3. Le disjoncteur laisse un service en difficulté se rétablir au lieu de l’assaillir de requêtes.

Voici le principe des nouveaux essais avec délai croissant, en Python :

for essai in range(4):
    try:
        return appeler_service(delai_max=2.0)          # jamais d'attente infinie
    except ServiceIndisponible:
        attente = 0.2 * 2 ** essai + random.uniform(0, 0.1)
        time.sleep(attente)                            # 0,2 s, 0,4 s, 0,8 s, 1,6 s
raise ServiceIndisponible("abandon après 4 essais")

Netflix a poussé la logique jusqu’à provoquer volontairement des pannes en production, pour vérifier que ses systèmes y résistent : c’est l’ingénierie du chaos (anecdote).

8Observer, tester, faire évoluer

Quand une requête traverse dix services, comment savoir où elle a échoué, ou pourquoi elle a été lente ? L’observabilité repose sur trois sources : les journaux de chaque service, les métriques, comme le nombre de requêtes, le taux d’erreurs et les temps de réponse, et les traces distribuées, qui suivent une requête de service en service grâce à un identifiant transmis à chaque appel (voir l’observabilité). La norme ouverte OpenTelemetry permet de collecter ces trois types de données de façon uniforme, quel que soit le langage de chaque service.

Les tests changent aussi. Les tests de chaque service ne suffisent pas, et les tests de bout en bout du système entier sont lents et fragiles. On ajoute des tests de contrat : chaque service consommateur décrit ce qu’il attend d’une API, et le service fournisseur vérifie automatiquement, avant chaque déploiement, qu’il respecte toujours ces attentes. Enfin, faire évoluer une API utilisée par d’autres équipes exige de la discipline : ajouter sans retirer, maintenir les anciennes versions le temps que les clients migrent, annoncer les changements, et ne jamais modifier le sens d’un champ existant.

Chaque service ayant son propre cycle de vie, les mises en production sont fréquentes, parfois plusieurs dizaines par jour dans une grande organisation. Pour qu’elles soient sans risque, on les rend progressives. Le déploiement canari, nommé d’après les canaris qu’emportaient les mineurs pour détecter les gaz, envoie d’abord une petite part du trafic vers la nouvelle version, et n’étend le déploiement que si les indicateurs restent bons. Le déploiement bleu-vert prépare la nouvelle version à côté de l’ancienne, puis bascule tout le trafic d’un coup, avec la possibilité de revenir en arrière instantanément. Les drapeaux de fonctionnalité permettent enfin de livrer du code désactivé, puis de l’activer pour certains utilisateurs seulement, indépendamment du déploiement.

9Faut-il des microservices ?

Les microservices résolvent avant tout un problème d’organisation : permettre à de nombreuses équipes de livrer indépendamment, et de faire évoluer chaque partie à son rythme, avec la technologie de son choix. Ils facilitent aussi le passage à l’échelle d’une fonction particulière, en multipliant seulement les instances du service le plus sollicité. Mais ils ont un coût élevé : appels réseau plus lents et moins fiables que des appels de fonctions, données réparties et cohérence à terme, infrastructure de déploiement, de surveillance et de sécurité bien plus lourde, débogage difficile. Un découpage mal pensé produit un monolithe distribué, qui cumule les inconvénients des deux approches : tout doit encore être modifié et déployé ensemble, mais à travers le réseau.

Pour une petite équipe, un nouveau produit dont le périmètre n’est pas stabilisé ou une application de taille moyenne, un monolithe modulaire est souvent le meilleur choix : un seul programme, un seul déploiement, mais un code organisé en modules aux frontières nettes, qui communiquent par des interfaces internes. Si un module a un jour besoin de vivre sa vie, il pourra être extrait en service. Même chez les géants du Web, certaines équipes ont fait le chemin inverse et regroupé des composants trop éclatés (anecdote). La bonne question n’est pas « microservices ou monolithe ? », mais « quel découpage minimal permet à nos équipes de travailler efficacement ? ». Et ce découpage peut évoluer avec l’entreprise : commencer simple n’empêche pas de découper plus tard, à condition d’avoir gardé un code bien structuré.

Sécurité de l’information

Le coin cyber

Découper une application en dizaines de services multiplie les API, les connexions réseau, les secrets et les composants à mettre à jour. Chaque service est une porte d’entrée possible, et ce qui circulait autrefois à l’intérieur d’un programme passe désormais par le réseau. Les attaques sont décrites ici dans leur principe seulement.

C.1Ne pas faire confiance au réseau interne

Une erreur fréquente consiste à protéger soigneusement la passerelle d’API, puis à laisser les services internes communiquer sans authentification, en supposant que le réseau interne est sûr. Un attaquant qui compromet un seul service, par une faille ou une dépendance piégée, peut alors interroger tous les autres. Les architectures modernes appliquent le modèle « zéro confiance » (voir le modèle zéro confiance) : chaque service possède une identité, prouvée par un certificat, toutes les communications sont chiffrées et authentifiées dans les deux sens, c’est l’authentification mutuelle TLS, du nom du protocole de chiffrement du Web, et chaque service n’est autorisé à appeler que ceux dont il a réellement besoin.

C.2Les failles propres aux API

Le classement des dix principaux risques des API, publié par l’OWASP en 2023, place en tête l’absence de contrôle d’autorisation sur chaque objet : modifier un identifiant dans une requête permet d’accéder aux données d’un autre (exercice 6). Viennent ensuite les défauts d’authentification, l’exposition de propriétés qui ne devraient pas l’être, comme un champ « administrateur » modifiable, l’absence de limites de consommation, ou encore les API oubliées, anciennes versions jamais retirées et toujours accessibles. Dans une architecture en microservices, où chaque équipe publie ses propres API, l’inventaire de toutes les API exposées est un préalable à leur protection (voir les attaques contre les applications Web).

C.3Les abus de GraphQL

La souplesse de GraphQL profite aussi aux attaquants. L’introspection, qui permet d’interroger le schéma, leur livre la carte complète de l’API, y compris des opérations non documentées. Une requête très imbriquée, demandant les amis des amis des amis, peut épuiser le serveur. Le regroupement de nombreuses opérations dans une seule requête permet de tester des milliers de mots de passe en contournant les limites de débit par requête. Protections : désactiver l’introspection en production quand l’API n’est pas publique, limiter la profondeur et le coût calculé des requêtes, appliquer des limites par opération, et, pour les applications maison, n’accepter que des requêtes préenregistrées.

C.4La falsification de requêtes côté serveur

Beaucoup de services téléchargent des ressources à partir d’adresses fournies par l’utilisateur : une image de profil, un aperçu de lien, un fichier à importer. Si l’adresse n’est pas contrôlée, un attaquant peut faire appeler par le serveur des adresses internes, inaccessibles depuis l’extérieur : un autre service sans authentification, ou le service de métadonnées de l’hébergeur en nuage, qui distribue des identifiants d’accès. C’est la falsification de requêtes côté serveur (en anglais Server-Side Request Forgery, SSRF), à l’origine de plusieurs fuites massives de données, dont celle d’une grande banque américaine en 2019, qui a touché plus de cent millions de clients. Parades : listes d’adresses autorisées, interdiction des adresses internes, versions protégées des services de métadonnées, et droits minimaux pour chaque service.

C.5Idée reçue

« Derrière la passerelle d’API, tout est protégé. » Faux. La passerelle filtre ce qui arrive de l’extérieur, mais ne voit ni les échanges entre services, ni les failles de logique, comme l’accès à la commande d’un autre client, que seul le service qui détient les données peut détecter. Chaque service doit authentifier ses appelants et vérifier les droits sur chaque objet, comme s’il était exposé directement sur Internet.

C.6Bonnes pratiques

Développeur

  • Vérifier l’autorisation sur chaque objet, dans le service qui détient les données.
  • Valider toutes les entrées, y compris celles qui viennent d’autres services.
  • Limiter la profondeur et le coût des requêtes GraphQL ; contrôler les adresses appelées par le serveur.

Organisation

  • Tenir l’inventaire des API et retirer les versions obsolètes.
  • Authentifier et chiffrer toutes les communications entre services ; donner à chacun des droits minimaux.
  • Centraliser les secrets dans un coffre-fort et journaliser les appels.

Référentiels : OWASP, API Security Top 10 (2023) · OWASP, GraphQL Cheat Sheet · NIST SP 800-204, Security Strategies for Microservices-based Application Systems (2019).

Références

  1. J. Lewis, M. Fowler, « Microservices: a definition of this new architectural term », 2014.
  2. S. Newman, Building Microservices, 2e édition, O’Reilly, 2021.
  3. E. Evans, Domain-Driven Design: Tackling Complexity in the Heart of Software, Addison-Wesley, 2003.
  4. M. Nygard, Release It!, 2e édition, Pragmatic Bookshelf, 2018.
  5. M. Conway, « How Do Committees Invent? », Datamation, 1968.
  6. Spécification GraphQL, GraphQL Foundation ; documentation de gRPC et de Protocol Buffers.

Voir aussi

Citer cet article

« Les microservices et les API modernes : REST, GraphQL et gRPC », Encyclopédie informatique, révision du 27 octobre 2026.