Les microservices et les API modernes : REST, GraphQL et gRPC
Partie 3 sur 3
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).
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é.