Un guide pour des apps et une infrastructure plus saines
La méthodologie 12-factor peut être votre feuille de route. Elle vous aide à éviter les pièges et à créer des applications résilientes et scalables.
Il s'agit d'adopter des pratiques qui améliorent la maintenabilité et la scalabilité. Ces pratiques n'ont rien d'exotique. Ce sont de petites habitudes. Elles ne coûtent pas cher à adopter au début. Elles coûtent cher à rattraper une fois que l'application tourne en production avec de vrais utilisateurs.
Voici les quatre facteurs par lesquels je commence toujours avec une nouvelle équipe. Chaque facteur supprime une dépendance cachée : une dépendance à une machine, à un chemin de fichier, ou à une session gardée en mémoire. Chaque dépendance supprimée rend l'application plus facile à déplacer, à tester et à scaler.
Comment garder la configuration hors du code ?
La config est le premier facteur. Stockez-la dans l'environnement, pas dans le code.
La configuration, c'est tout ce qui change d'un déploiement à l'autre : l'adresse de la base de données, les clés d'API, l'URL d'un service de paiement externe. Ces valeurs ne sont pas les mêmes sur le laptop d'un développeur, dans un environnement de test et en production. Quand elles vivent dans le code, chaque environnement a besoin de sa propre version du code. Et chaque version est un endroit de plus où un secret peut fuiter.
✅ Le mot de passe de la base de données est lu dans une variable d'environnement que la plateforme définit au moment du déploiement. ❌ Le mot de passe de la base de données est écrit dans un fichier de paramètres commité dans le dépôt.
La première option permet au même build de tourner dans tous les environnements. La seconde impose un nouveau build à chaque changement de paramètre. Cette approche n'est pas seulement plus sûre. Elle est aussi plus facile à gérer, et indépendante de l'OS. Elle rend votre application plus flexible et plus sûre.
Pourquoi un processus ne doit-il garder aucun état ?
Le stateless est le deuxième facteur. Visez des processus stateless, share-nothing.
Imaginez trois copies de la même application derrière un load balancer. Un utilisateur se connecte, et sa session vit dans la mémoire de la première copie. La requête suivante arrive sur la deuxième copie, qui n'a jamais vu cette session. L'utilisateur est déconnecté sans raison visible. Le défaut n'apparaît que lorsque le trafic est réparti entre les copies. C'est exactement le moment où le système doit marcher.
Ajouter des copies, c'est ça le scaling horizontal. Et ça ne marche que si les copies sont interchangeables. Un processus qui ne partage rien peut être démarré, arrêté et remplacé à tout moment, et n'importe quelle copie peut servir n'importe quelle requête. Le résultat : une meilleure scalabilité et une meilleure résilience.
Si des données doivent persister, les bases de données sont là pour ça ! Gardez l'état dans un backing service, et laissez le processus jetable.
Où doivent aller les logs ?
Les logs sont le troisième facteur. Traitez-les comme des flux d'événements.
Un log est la trace de ce qui s'est passé, écrite un événement après l'autre. Une application qui écrit ses logs dans des fichiers doit aussi connaître les chemins des fichiers, la politique de rotation et l'espace disque qui reste sur la machine. Dans un conteneur, le système de fichiers est en général jeté quand le conteneur est remplacé. Les logs écrits dedans disparaissent donc avec lui, souvent au moment où vous en avez le plus besoin.
L'approche twelve-factor retire ce travail à l'application. Le processus écrit chaque événement sur sa sortie standard. L'environnement collecte ce flux et l'envoie vers l'outil qui le stocke ou qui permet d'y chercher. Votre app n'a pas à se soucier de l'endroit où ces logs sont stockés. Le même code tourne alors sur un laptop, dans un conteneur et sur un serveur, sans aucun changement.
Vous y gagnez un meilleur monitoring et un meilleur debugging, et vous voyez comment votre application se comporte. Une fois que tous les événements passent par un seul flux, vous pouvez poser vos questions à toutes les copies de l'application en même temps.
Comment rendre l'application autonome ?
Le port binding est le quatrième facteur. Rendez votre app autonome : elle expose ses services en se liant à un port.
L'application embarque son propre serveur web et écoute sur un port. Elle ne dépend pas d'un serveur que la plateforme lui injecte. Le numéro de port lui-même vient de la configuration. Le même processus tourne donc sur n'importe quel hôte capable d'ouvrir ce port. Tout ce qui peut démarrer le processus peut servir du trafic : un conteneur, une machine virtuelle, le laptop d'un développeur.
Votre application devient plus indépendante et plus adaptable. Le processus que vous testez sur votre machine est celui que vous faites tourner en production. Une différence de plus entre les environnements disparaît.
Comment appliquer les quatre facteurs dans une nouvelle équipe ?
Voici les étapes, une par facteur :
- Trouvez chaque paramètre qui change d'un environnement à l'autre, et déplacez-le dans des variables d'environnement.
- Trouvez chaque valeur gardée en mémoire d'une requête à l'autre, et déplacez-la dans un backing service.
- Remplacez chaque fichier de log par un flux d'événements écrit sur la sortie standard.
- Liez le processus à son propre port, et supprimez toute dépendance à un serveur injecté.
- Vérifiez que le dépôt pourrait devenir public sans exposer un seul identifiant.
Quand ces facteurs ne s'appliquent-ils pas ?
Chaque règle a sa condition. Un script qui tourne une fois par mois n'a pas besoin d'un port. Un prototype utilisé par trois personnes n'a pas besoin d'un message broker. Appliquer toute la méthodologie à un outil qui ne quitte jamais une machine coûte du temps et rapporte peu.
Le trade-off joue aussi dans l'autre sens. Stateless ne veut pas dire aucun état du tout. Un système qui garde un gros cache en mémoire pour la vitesse doit concevoir ce cache exprès. Et le cache ne doit pas devenir, sans bruit, l'endroit où vivent les sessions. Appliquez les facteurs à fond là où l'application tourne comme un service réseau, sur une plateforme qui la scale. Ailleurs, faites preuve de jugement.
💡Coder, ce n'est pas seulement répondre à des exigences. C'est écrire du code prêt pour les défis du monde réel !
Ressources et bibliographie
- Adam Wiggins, The Twelve-Factor App (12factor.net, 2011–2017). https://12factor.net/
- Jez Humble, David Farley, Continuous Delivery: Reliable Software Releases through Build, Test, and Deployment Automation (Addison-Wesley, 2010). https://continuousdelivery.com/
- Michael T. Nygard, Release It! Design and Deploy Production-Ready Software, 2nd edition (Pragmatic Bookshelf, 2018). https://pragprog.com/titles/mnee2/release-it-second-edition/
- Martin Kleppmann, Designing Data-Intensive Applications (O'Reilly, 2017). https://dataintensive.net/
Publié d'abord sur LinkedIn : le post d'origine
