The 12 Factor App is a methodology for building software-as-a-service apps that emphasizes portability, scalability, and maintainability. Developed by engineers at Heroku, the 12-factor methodology is intended to standardize and streamline app development and deployment. Below are the twelve factors in detail:
1. Codebase
One codebase tracked in revision control, many deploys
There should be a single codebase for a project, which is tracked in a version control system like Git. Multiple environments (e.g., production, staging, development) should be different deployments of the same codebase.
2. Dependencies
Explicitly declare and isolate dependencies
All dependencies should be declared explicitly in a dependency declaration file (e.g., requirements.txt for Python, package.json for Node.js). Use a dependency management tool to ensure these dependencies are isolated and versioned properly.
3. Config
Store config in the environment
Configuration that varies between deploys (such as credentials or resource handles) should be stored in the environment. This separates config from code, allowing for different configurations in different environments.
4. Backing Services
Treat backing services as attached resources
Backing services (e.g., databases, messaging systems, caches) should be treated as attached resources that can be attached and detached as needed, without making changes to the app’s code.
5. Build, Release, Run
Strictly separate build and run stages
The build stage converts a code repo into an executable bundle (e.g., compiling code). The release stage takes the build and combines it with the current config to create a release. The run stage runs the app in the execution environment.
6. Processes
Execute the app as one or more stateless processes
The app should run as stateless processes, with any persistent data stored in a stateful backing service. This allows for easy scaling and resilience.
7. Port Binding
Export services via port binding
The app should be self-contained and make services available by listening on a port. This makes the app independent of the execution environment and easy to run.
8. Concurrency
Scale out via the process model
The app should be designed to scale out by running multiple instances of its processes. Use a process management tool to manage these processes effectively.
9. Disposability
Maximize robustness with fast startup and graceful shutdown
The app’s processes should start up quickly and shut down gracefully. This improves resilience and allows for rapid deployment of changes.
10. Dev/Prod Parity
Keep development, staging, and production as similar as possible
Minimize the differences between development and production environments to catch issues early and ensure smoother deployments.
11. Logs
Treat logs as event streams
The app should not manage or write log files. Instead, it should treat logs as event streams that are sent to a centralized logging service for aggregation and analysis.
12. Admin Processes
Run admin/management tasks as one-off processes
Administrative or management tasks (e.g., database migrations) should be run as one-off processes in the same environment as the app, using the same codebase and config.
Adhering to these principles helps developers create applications that are more scalable, maintainable, and portable across different environments, ensuring a smoother development and deployment process.
