Introduction #
Explication des principes des applications 12 facteurs, une méthodologie conçue pour les applications modernes et les microservices, permettant une meilleure maintenabilité, scalabilité et déploiement en continu.
Codebase #
Une seule base de code par application avec gestion de versions.
Principe #
Chaque application doit avoir une seule base de code versionnée dans un dépôt, même si elle est déployée dans plusieurs environnements. Cela garantit la cohérence du code entre les environnements.
Gestion des versions #
L'utilisation de systèmes de contrôle de version (ex. Git) permet de maintenir des versions de l'application et de faciliter le suivi des modifications.
Bénéfices #
Améliore la traçabilité, la collaboration et la gestion des versions pour les équipes, surtout en environnement agile.
Dépendances #
Déclarer explicitement et isoler les dépendances de l'application.
Déclaration explicite #
Spécifiez toutes les dépendances de l'application dans un fichier de configuration (comme requirements.txt pour Python ou package.json pour Node.js) pour faciliter l'installation et la maintenance.
Isolation des dépendances #
Utiliser des environnements isolés pour chaque application (ex. virtualenv en Python, conteneurs Docker) pour éviter les conflits de dépendances entre projets.
Configuration #
Externaliser les configurations pour séparer le code et les paramètres d'environnement.
Variables d'environnement #
Utiliser des variables d'environnement pour stocker les configurations de l'application, comme les clés API, URL de base de données, etc. Cela évite d'exposer des informations sensibles dans le code.
Flexibilité et sécurité #
Les configurations par environnement permettent de déployer la même base de code dans différents environnements (dev, prod) sans modification du code.
Backing Services #
Traiter les services externes (base de données, files d'attente) comme des ressources attachées.
Ressources interchangeables #
Les services externes doivent être facilement remplaçables sans modifier le code, en changeant uniquement la configuration. Cela facilite la migration vers de nouvelles solutions.
Portabilité #
En utilisant des services basés sur des configurations externes, il devient facile de déplacer l'application vers d'autres environnements ou fournisseurs.
Build, Release, Run #
Distinguer les étapes de build, release et run pour une meilleure gestion des déploiements.
Processus de build #
Le processus de build compile le code et regroupe toutes les dépendances, générant une version déployable de l'application.
Processus de release #
Associe le build à des configurations spécifiques et enregistre cette version prête pour le déploiement. Chaque release doit être immuable et identifiable (ex. par un numéro de version ou un tag).
Processus de run #
L'étape où le code est exécuté dans l'environnement de production. Cette séparation améliore la gestion des versions et facilite les rollbacks en cas de besoin.
Processes #
Exécuter l'application sous forme de processus stateless pour favoriser la scalabilité.
État dans les services #
Les processus ne doivent pas conserver d'état ; ils doivent utiliser des services externes (comme une base de données) pour stocker l'état de l'application.
Scalabilité horizontale #
Les processus stateless permettent d'ajouter ou retirer facilement des instances, augmentant la capacité d'accueil sans impact sur la cohérence des données.
Port Binding #
L'application doit être auto-contenue et exposée via un port spécifique.
Communication via le réseau #
L'application doit être accessible directement via un port, facilitant le déploiement dans des environnements comme Docker ou Kubernetes.
Flexibilité des services #
Permet de combiner différents services dans un même environnement en les assignant chacun à un port spécifique.
Concurrency #
Optimiser l'application pour fonctionner avec plusieurs processus concurrents.
Modèle de process horizontal #
Utiliser des processus indépendants et scalables en parallèle, ce qui facilite la gestion de charges de travail variables.
Multiprocessing #
Adopter des modèles de traitement parallèle pour maximiser l'utilisation des ressources.
Disposability #
Faciliter le démarrage et l'arrêt rapides des processus.
Démarrage rapide #
Les processus doivent démarrer rapidement pour être réactifs face aux charges de travail fluctuantes.
Gestion de l'arrêt #
En cas d'arrêt, les processus doivent cesser de façon contrôlée pour éviter les corruptions de données.
Dev/Prod Parity #
Maintenir une parité forte entre les environnements de développement, staging et production.
Parité des environnements #
Éviter les divergences entre les différents environnements pour minimiser les risques d’erreurs lors des déploiements.
Amélioration des tests #
Une parité de configuration améliore la fiabilité des tests en garantissant que ce qui est testé en développement fonctionnera en production.
Logs #
Les logs sont un flux d'événements à centraliser pour une analyse efficace.
Flux continu #
Les logs doivent être traités comme un flux d'événements continus, collectés et centralisés, sans être enregistrés localement dans le fichier système.
Centralisation #
Envoyer les logs vers un service centralisé facilite la surveillance et le dépannage des applications en production.
Admin Processes #
Les tâches administratives sont gérées en tant que processus one-off.
Processus ponctuels #
Exécuter les tâches de maintenance ou d'administration comme des processus isolés, ex. en utilisant des scripts one-off pour des migrations de base de données ou des traitements ponctuels.
Sécurité et stabilité #
Les processus one-off évitent les interférences avec le code en cours d’exécution et garantissent la stabilité de l'application.
