Skip to content

What is 12 factor in Cloud Native

homepage-banner

What is Cloud Native

Cloud Native was first proposed by Matt Stine of Pivotal in 2013. Pivotal has open-sourced the Java development framework SpringBoot and Spring Cloud. Later, Google established CNCF (CloudNative Computing Foundation) in 2015, which has attracted more and more attention to Cloud Native.

Essentially, Cloud Native is a design pattern that requires Cloud Native applications to have availability and scalability, the ability to automatically deploy and manage, and can run anywhere. It can improve the efficiency of research and development, testing, and release through continuous integration and continuous delivery tools.

Twelve Factors of Cloud Native

“The Twelve-Factor App” was proposed by Adam Wiggins, the founder of Heroku in 2012. The characteristics mentioned in the twelve factors are not specific to cloud providers, platforms, or languages. These factors represent a set of guidelines or best practices for portable elastic applications (especially “software as a service” applications) that are thriving in the cloud environment.

  1. Codebase: One codebase, many deploys
  2. Dependencies: Explicitly declare dependencies
  3. Configuration: Store configuration in the environment
  4. Backing services: Treat backing services as attached resources
  5. Build, release, run: Strictly separate build and run stages
  6. Processes: Execute the app as one or more stateless processes
  7. Port binding: Export services via port binding
  8. Concurrency: Scale out via the process model
  9. Disposability: Maximize robustness with fast startup and graceful shutdown
  10. Dev/prod parity: Keep development, staging, and production as similar as possible
  11. Logs: Treat logs as event streams
  12. Admin processes: Run admin/management tasks as one-off processes

Advanced Twelve Factors

After the release of the twelve factors, Kevin Hoffman, who works at Pivotal, published the book “Beyond the Twelve-Factor App”, which not only elaborated on the original twelve factors in more detail but also added three new factors.

  1. API First: Prioritize API design like a contract, which should be changed as little as possible once it takes effect. If it is modified after being put into use, its impact may be difficult to control and may affect many external systems.
  2. Telemetry: For applications deployed in the cloud environment, their system environment is closed and isolated. When problems occur, you should not log in to problematic physical servers to observe and collect the application’s status.
  3. Authentication and Authorization: It is dangerous to completely leave security issues to the cloud platform, so it is recommended to use more complete security mechanisms such as OAuth2 authentication and RBAC authorization.

Reference

  1. https://12factor.net
  2. Future Architecture: From Service to Cloud Native
  3. Cloud Native Architecture Advanced Practice
  4. Scalable Architecture (2nd Edition): High Availability and Risk Management in Cloud Environments
  5. https://zhuanlan.zhihu.com/p/243404169
  6. https://architecturenotes.co/12-factor-app-revisited/
Feedback







Disclaimer
  • Welcome to visit the knowledge base of SRE and DevOps!
  • License under CC BY-NC 4.0
  • Made with Material for MkDocs and improve writing by generative AI tools
  • Copyright issue feedback me#imzye.com, replace # with @