"12-Factor App" Summary

I recently had a chance to go through the principles of the 12-Factor App as listed on 12factor.net. It's written by some of the fine folk at Heroku. The principles describe the best practices they see for how to get a modern web app deployed properly. It's a short read. This summary is even shorter.

1. Codebase
  • Always in src ctrl

  • One codebase per app (many repos = distributed system)

  • A deploy = instance of app running

2. Dependencies
  • All app and system dependencies explicitly declared

  • Do not dep on implicit existence of system tools (eg, ImageMagick)

  • Required sys tools vendored into app

3. Config
  • Strict separation between code and config

  • Config stored in env vars

4. Backing Services
  • Should be loosely coupled, swappable

  • Changes in services (eg, db) should not require code change

5. Build, release, run
  • Strict separation: build (binary), release (binary + env config), run (exec runtime)

  • Ordered -- can't make change upstream

  • Every release has unique id

6. Processes
  • Independent, stateless, share nothing

  • Sharing happens in backing service (eg, db)

  • No sticky sessions w/ process affinity

7. Port Binding
  • Can talk a protocol (eg, HTTP) by binding comm to a port

  • Allows an app to become a backing service for another app via a url

  • What does the alternative look like here? Seems like a given.

8. Concurrency
  • Process is first-class citizen patterned after unix service daemons

  • Process can multiplex internally (eg, threads or something like node.js)

  • Scaling becomes a simple addition of the same process

9. Disposability
  • Startups are fast

  • Requests are short

  • Shutdowns are graceful; requests can finish; jobs returned to queue

10. Dev/Prod Parity
  • Time from dev to prod deploy should be short (eg, hrs)

  • Devs who wrote the code should be around to op the code

  • Toolchains and tech stacks should be as similar as possible

  • Backing servies should be the same, even if adapters supposedly abstract implementations

11. Logs
  • Logs are treated as streams, simply written by an app to stdout

  • Let log storage, collating, and analysis be done in the env or or w/ other tools

  • Logs should provide visibility to how an app works over time

12. Admin Processes
  • Run as one-off processes in REPL

  • Env shares same code and config as long-running processes

If you have the extra little time required, I encourage you to check out 12factor.net and draw some of your own conclusions.

What other insights do you have on these principles?