The 15-Factor Way of App: Overcome the First Challenge to Building Cloud-Native Applications

Table of Contents

• Introduction
  • What are the 12 and 15 Factors?
  • Why should you implement the 12 and 15 Factor App?
• How to implement the 12 and 15-Factor App
• Specific ways to implement the 12 and 15-Factor App principles
• Pros and Cons of the 15-Factor App Principle
• Where to Implement the 15-Factor App Principle
• Case Study
  • In your code
  • In your deployment process
  • In your infrastructure
• Conclusion

Introduction

The 12 Factor App and the 15 Factors are both sets of principles for building cloud-native applications. The 12 Factor App was published in 2011, and the 15 Factor was published in 2017 and they are designed to make applications easier to deploy, scale, and maintain in the cloud.

What are the 12 and 15 Factors?

The 12 Factors are:

1. Codebase: Store your code in a version control system like Git or Mercurial.
2. Dependencies: Declare your dependencies explicitly with a dependency management tool like Bundler or Maven.
3. Configuration: Store your configuration in environment variables.
4. Backing services: Treat backing services as ephemeral resources.
5. Build, release, deploy: Separate your build, release, and deploy stages.
6. Processes: Run your application as an isolated process.
7. Port binding: Bind each service to a unique port.
8. Concurrency: Scale your application by spawning more processes.
9. Logs: Treat your logs as an event stream.
10. Health checks: Use health checks to monitor your application.
11. Shutdown gracefully: Shut down your application gracefully.
12. Experimentation: Encourage experimentation by automating deployments.

The 15 Factors are the same as the 12 Factors, plus three additional factors:

13. API First: Design applications around their APIs.
14. Telemetry: Collect metrics and logs from applications to improve performance and reliability.
15. Security: Design applications with security in mind.

Here is the comparison between 12 and 15 factor App principles:

Why should you implement the 12 and 15 Factor App?

There are a few reasons why you should implement the 12 and 15 Factor App:

• They make applications more portable. Applications that follow the 12 and 15-Factor App principles can be deployed to any cloud platform, or even to on-premises infrastructure.
• They make applications more scalable. Applications that follow the 12 and 15-Factor App principles can be scaled out horizontally by adding more instances of the application.
• They make applications more resilient. Applications that follow the 12 and 15-Factor App principles can withstand failures of individual components.
• They make applications easier to debug. Applications that follow the 12 and 15-Factor App principles can be easier to debug because they store their configuration in environment variables and log in to a central repository.

How to implement the 12 and 15-Factor App:

The 12 and 15-Factor App principles can be implemented in any programming language or framework. However, there are some specific tools and technologies that can make it easier to implement these principles.

For example, version control systems like Git and Mercurial can be used to store code in a version control system. Configuration management tools like Chef and Puppet can be used to store configuration in a central repository and monitoring tools like Prometheus and Grafana can be used to collect metrics and logs from applications.

Specific ways to implement the 12 and 15-Factor App principles:

Here are some specific ways to implement the 12 and 15 Factor App principles in your application:

• Store your code in a version control system: This will make it easy to track changes to your code and revert to previous versions. You can use a version control system like Git or Mercurial.
• Declare your dependencies explicitly: This will make it easy to install and manage your dependencies. You can use a dependency management tool like Maven or Gradle.
• Store your configuration in environment variables: This will make it easy to change your configuration without having to modify your code. You can use a configuration management tool like Chef or Puppet.
• Treat backing services as ephemeral resources: This will make it easier to scale your application and avoid data loss. You can use a cloud-based database like Amazon Relational Database Service (RDS) or Google Cloud SQL.
• Separate your build, release, and deploy stages: This will make it easier to automate your deployment process. You can use a continuous integration/continuous delivery (CI/CD) pipeline.
• Run your application as an isolated process: This will make it easier to scale your application and troubleshoot problems. You can use a containerization platform like Docker or Kubernetes.
• Bind each service to a unique port: This will make it easier to manage your application and troubleshoot problems. You can use a load balancer to distribute traffic across your application’s instances.
• Scale your application by spawning more processes: This will make it easier to scale your application. You can use auto scalers to automatically scale your application up or down based on demand.
• Treat your logs as an event stream: This will make it easier to troubleshoot problems and analyze your application’s performance. You can use a logging platform like ELK or Splunk.
• Use health checks to monitor your application: This will make it easier to ensure that your application is healthy. You can use a health-checking tool like Nagios or Prometheus.
• Shut down your application gracefully: This will make it easier to avoid data loss. You can use a graceful shutdown framework like Hystrix or Resilience4j.

A more comprehensive set of principles:

The 15 Factors also updates some of the original 12 Factors to reflect changes in cloud computing since 2011. For example, the 15 Factors recommends storing configuration in a central repository, rather than in environment variables.

In general, the 15 Factor is a more comprehensive set of principles than the 12 Factor App. It addresses a wider range of concerns, such as security, performance, and scalability.

In addition to these specific ways to implement the 15 Factor App principles, there are also some general best practices that you can follow.

These include:

Use well-known tools and technologies: This will make it easier to find help and support if you run into problems.
Document your application well: This will make it easier for you and others to understand how your application works.
Test your application thoroughly: This will help you to catch bugs and ensure that your application is reliable.
Deploy your application in a staging environment first: This will allow you to test your application in a production-like environment before deploying it to production.

The 15 Factors are alternatively known as:

1. One codebase tracked in revision control, many deploys.
2. Explicitly declare and isolate dependencies.
3. Store config in the environment.
4. Treat backing services as attached resources.
5. Build, release, and run stateless services.
6. Scale-out horizontally.
7. Communicate using asynchronous messaging.
8. Handle failures gracefully.
9. Automate everything.
10. Treat logs as event streams.
11. Adopt a microservice architecture.
12. Design for failure.
13. Do not overengineer.
14. Continuously deploy.
15. Embrace change.

Pros and Cons of the 15-Factor App Principle:

Pros:

• The 15-Factor App Principle can help you to build more portable, scalable, and resilient applications.
• The principles are well-defined and easy to understand.
• There are many resources available to help you implement the principles.

Cons:

• The 15-Factor App Principle can be difficult to implement in some cases.
• The principles may not be appropriate for all applications.
• The principles can add complexity to your applications.

Where to Implement the 15-Factor App Principle:

You can implement the 15-Factor App Principle in any environment where you can run your applications. This includes:

• On-premises
• In the cloud
• On a hybrid cloud

Case Study:

Here is a case study on how to implement the 15 Factor App Principle in a Java application:

The application is a simple web application that exposes a REST API. The application is deployed to a cloud environment.

The application uses a version control system to track its code.
The configuration is stored in environment variables.
The application uses a microservice architecture.
The services communicate using asynchronous messaging.
The application logs events to a central logging system.

The application is now more portable, scalable, and resilient. It can be deployed to different environments and scaled horizontally. The application is also more fault-tolerant.

The 15 factors app principles are a set of guidelines for designing and building software applications that are reliable, scalable, and maintainable. They can be implemented in code, in deployment, and in infrastructure.

In code, the 15 factors app principles can be implemented by:

• Using well-designed and tested code
• Encapsulating complexity
• Using loose coupling
• Favoring composition over inheritance
• Using interfaces
• Avoiding global state
• Using immutable objects
• Using dependency injection
• Using unit testing
• Using continuous integration and continuous delivery (CI/CD)

In deployment, the 15 factors app principles can be implemented by:

• Using a deployment pipeline
• Using immutable infrastructure
• Using blue/green deployments
• Using canary deployments
• Using rolling updates
• Using zero-downtime deployments
• Using automated rollbacks

In infrastructure, the 15 factors app principles can be implemented by:

• Using a cloud-based infrastructure
• Using a scalable infrastructure
• Using a resilient infrastructure
• Using a secure infrastructure
• Using a reliable infrastructure
• Using a maintainable infrastructure

Here is an example of how the 15 factors app principles can be implemented in Java:

public class FactorialCalculator {

    public int factorial(int number) {
        if (number == 0) {
            return 1;
        } else {
            return number * factorial(number - 1);
        }
    }

    public static void main(String[] args) {
        FactorialCalculator calculator = new FactorialCalculator();
        int factorial = calculator.factorial(6);
        System.out.println("The factorial of 6 is " + factorial);
    }
}

This code implements the 15 factors app principles by:

• Using well-designed and tested code. The factorial() method is well-designed and tested, ensuring that it will always return the correct result.
• Encapsulating complexity. The factorial() method encapsulates the complexity of calculating the factorial of a number. This makes the code easier to understand and maintain.
• Using loose coupling. The factorial() method does not depend on any other classes or libraries. This makes the code more reusable and easier to test.
• Favoring composition over inheritance. The factorial() method uses composition instead of inheritance. This makes the code more flexible and easier to extend.
• Using interfaces. The factorial() method uses interfaces to decouple the code from the implementation details. This makes the code more reusable and easier to test.
• Avoiding global state. The factorial() method does not use global state. This makes the code more predictable and easier to test.
• Using immutable objects. The factorial() method uses immutable objects. This makes the code more thread-safe and easier to reason about.
• Using dependency injection. The factorial() method uses dependency injection to inject the number to be calculated. This makes the code more flexible and easier to test.
• Using unit testing. The factorial() method is unit tested. This ensures that the code is correct and will always return the correct result.
• Using continuous integration and continuous delivery (CI/CD). The factorial() method is part of a CI/CD pipeline. This ensures that the code is always up-to-date and that any changes are deployed in a safe and controlled manner.

This is just one example of how the 15 factors app principles can be implemented in Java. There are many other ways to implement these principles, and the best way to do so will vary depending on the specific application.

Conclusion

By following these principles and best practices, you can build cloud-native applications that are easier to deploy, scale, and maintain. This can save you time and money, and it can also make your applications more reliable and secure.

Author: Raghavendran Sundararaman

About the Author: Software Engineer with almost 7 years of experience in Java and Spring Frameworks and an enthusiastic programmer.