DEV Community: Luiz Ferreira

The 12 Factors: When was the last time you reviewed these concepts?

Luiz Ferreira — Tue, 11 Apr 2023 09:02:06 +0000

Hello everyone! Welcome to my blog!

Today, I'm going to share with you a revolutionary methodology that has been changing the way we develop and manage modern applications: the 12 factors. Inspired by the books of the legendary Martin Fowler, these principles bring numerous advantages for developers and DevOps/SRE professionals. Let's explore together the importance, gains, and advantages of these factors, and how they make our day-to-day work easier.

The Importance of the 12 Factors

The 12 factors aim to improve the quality, scalability, and maintainability of applications. With the increasing complexity and growing demand for cloud-based solutions, it is essential to adopt practices and principles that guarantee the stability and performance of our applications.

Gains and Advantages

By following the 12 factors methodology, you will be ensuring several benefits, such as:

Development Agility: Projects based on the 12 factors have faster and more efficient development cycles, allowing new features and fixes to be delivered more frequently.
Scalability: Applications developed with this methodology are naturally scalable, making it easier to meet demands for growth and traffic.
Resilience and availability: Applications built based on the 12 factors are more resilient to failures and guarantee greater availability for users.
Portability: The adoption of the 12 factors allows greater flexibility and cost reduction, as applications are easily portable between different environments and cloud providers.

How does this make my work easier?

The 12 factors simplify the development and management of applications, bringing benefits to both developers and DevOps/SRE professionals:

Better collaboration between teams: The 12 factors methodology promotes more effective communication and cooperation between development and operations teams.
Efficient monitoring and problem-solving: The 12 factors facilitate monitoring and problem-solving, helping teams identify and quickly correct any issues that may arise.
Reduction of errors: The adoption of the 12 factors helps reduce errors and inconsistencies between development, testing, and production environments, leading to more reliable and stable software.

Companies that use the 12 Factors

The 12 factors methodology is widely adopted by companies and organizations of all sizes, including technology giants such as Netflix, Spotify, Airbnb, and Salesforce. These companies recognize the value of the 12 factors in building modern, scalable, and resilient applications, and apply these principles in their own development and operations practices.

List of articles on the 12 Factors

Check out our detailed articles on each of the 12 factors:

Stay tuned!

Now that you understand the power and importance of the 12 factors, be sure to follow luizferreira.dev to stay on top of best practices and trends in the world of modern application development and operations.

Also, follow me on social networks and join our community of enthusiasts and professionals! We are always sharing tips, tricks and valuable knowledge to help you succeed in your career and projects.

And remember, knowledge is power! The more you know about the 12 factors, the better prepared you will be to face the challenges and opportunities of the tech world. So, keep exploring, learning and growing with us!

12 Factors: Revisiting the 7th Factor - Port Binding

Luiz Ferreira — Tue, 04 Apr 2023 15:50:19 +0000

Welcome to my blog!

Hello everyone! In this article, we will continue our series on the 12 factors for the development of modern applications, inspired by the books of the legendary Martin Fowler. If you missed our previous articles, feel free to check out the other factors.

Today, we will cover the seventh factor:

Port Binding

The seventh factor states that the application should communicate with the outside world through a bound port. This means that the application must be able to accept incoming connections and communicate with other services and components through this port.

Why is Port Binding Important?

Binding a port ensures that the application is easy to deploy, configure, and integrate with other services and components. In addition, port binding allows the application to run in different environments and platforms without the need to change the source code.

Key Principles for Port Binding

Be platform-agnostic: Your application should be able to communicate with other services and components, regardless of the platform or environment they are running on.
Use standard protocols: Use standard protocols, such as HTTP, to ensure compatibility and facilitate integration with other services and components.
Flexible configuration: Allow the bound port to be easily configured, whether through environment variables, configuration files, or command-line arguments.
Treat the port as a scarce resource: The application must be able to handle the possibility that the desired port is already in use and be able to find an alternative port if necessary.

Examples and Tools

Here are some examples of tools and technologies that can help implement port binding in your application:

Express.js: Express.js is a minimalist framework for Node.js that makes it easy to create web applications and APIs. It allows for simple and efficient port binding.
Flask: Flask is a micro-framework for Python that allows for the rapid and easy creation of web applications and APIs. It also supports port binding.
Apache: Apache is a widely-used web server that allows for port binding and flexible configuration of web applications and APIs.
Nginx: Nginx is a high-performance web server and reverse proxy that supports port binding and is easy to configure.

Stay Tuned

In the next article, we will cover the eighth factor of the 12 factors. Stay tuned and don't miss the next part of this informative series!

If you enjoyed this article, please share it with your colleagues and friends on social media. Also, don't forget to leave a comment below with your questions,

12 Factors: Revisiting the 6th Factor - Processes

Luiz Ferreira — Mon, 03 Apr 2023 05:39:38 +0000

Hello everyone! Welcome again!

In this article, we will continue our series on the 12 factors for the development of modern applications, inspired by the books of the legendary Martin Fowler. If you missed our previous articles, feel free to check out the other factors.

Today, we will cover the sixth factor:

Processes

The sixth factor states that the application should be executed as one or more stateless processes, with data being stored in backing services. This is important to ensure scalability, portability, and ease of deployment.

Stateless Processes

Stateless processes are those that do not store information about the current state of the application, which means they do not maintain data in memory or local storage. Instead, any required state information is stored in backing services, such as databases, caches, or messaging systems.

The main advantage of using stateless processes is that they can be easily scaled horizontally, adding more instances of the process as needed to handle the load. Additionally, as each process is independent and does not store state information, they can be restarted or replaced without affecting the overall operation of the application.

Key Principles for Processes

Avoid storing data in memory or local storage: As mentioned earlier, processes should be stateless and should not store state information. This ensures that processes are independent and can be easily scaled.
Store data in backing services: State data should be stored in appropriate backing services, such as databases, messaging systems, or caches. This allows processes to be restarted or replaced without losing important information.
Scale horizontally: Stateless processes allow the application to be scaled horizontally, adding more instances as needed to handle the load. This helps ensure that the application can meet traffic demands and provide consistent performance.
Monitor processes: Monitor your application's processes to ensure they are functioning correctly and identify potential issues or bottlenecks. This can include monitoring resource usage, response time, and error rates.
Ensure portability: As processes are independent and stateless, they should be portable and able to run in different environments and platforms. This makes deploying and maintaining the application easier.

Examples and Tools

Here are some examples of tools and technologies that can help implement stateless processes in your application:

Docker: Docker is a containerization platform that allows packaging applications and their dependencies into containers, which can be run in different environments and platforms. This makes creating stateless and portable processes easier.
Kubernetes: Kubernetes is a container orchestration system that manages the deployment, scaling, and operation of container-based applications. It facilitates the creation of stateless processes, ensuring the necessary instances are always running and managing horizontal scalability.
Redis: Redis is an in-memory data store, used as a database, cache, and message broker. It is useful for storing state information in backing services, ensuring processes remain stateless.
RabbitMQ: RabbitMQ is an open-source message broker that implements the Advanced Message Queuing Protocol (AMQP). It can be used to store temporary state information, such as messages and events, helping to keep processes stateless.
Amazon S3: Amazon S3 is a simple storage service that allows storing and retrieving any amount of data, at any time, from anywhere on the web. It can be used to store state data in backing services, ensuring processes are independent and stateless.

In summary, the sixth factor of the 12 factors is "Processes". It highlights the importance of running applications as one or more stateless processes, with data being stored in backing services. This ensures scalability, portability, and ease of application deployment. The tools and technologies mentioned above can help you achieve this goal.

In the next article, we will cover the seventh factor of the 12 factors. Stay tuned!

Don't forget to share this article with your colleagues and leave a comment below if you have any questions or suggestions.

See you next time!

12 Factors: Revisiting the 5th Factor - Build, Deploy, and Run

Luiz Ferreira — Thu, 30 Mar 2023 14:31:18 +0000

Hello everyone! In this article, we will continue our series on the 12 factors for the development of modern applications, inspired by the legendary Martin Fowler's books. If you missed our previous articles, feel free to check out the other factors.

Today, we will cover the fifth factor:

Build, Deploy, and Run

The fifth factor emphasizes the importance of separating the stages of building, deploying, and running an application. This separation ensures that the application can be consistently built, deployed, and run in different environments, improving maintainability, portability, and scalability.

Key Principles for Build, Deploy, and Run

Build: The build stage involves compiling the source code, processing assets, and creating an executable or package that can be deployed to various environments. It is essential to have a reproducible build process that generates consistent artifacts across different environments.
Deploy: The deployment stage involves taking the build artifacts and deploying them to a specific environment, such as staging or production. It should be automated, consistent, and have a clear separation between environments.
Run: The run stage is when the application is actually executed in the target environment. It should be easy to start, stop, and restart the application, and it should be able to run consistently across different environments.

Tools and Examples

Here are some tools and technologies that can help you implement the Build, Deploy, and Run factor in your application:

Git: Git is a widely-used version control system that can help you manage your source code and assets, making it easier to build and deploy your application consistently.
Docker: Docker is a containerization platform that allows you to package your applications and their dependencies into containers, which can run consistently across different environments and platforms. This makes it easier to deploy and run your application.
Jenkins: Jenkins is an open-source automation server that can help you automate the build, deployment, and run stages of your application. This ensures that your application can be consistently built, deployed, and run in different environments.
Kubernetes: Kubernetes is a container orchestration system that can manage the deployment, scaling, and operation of container-based applications. It can help you run your application consistently across different environments and scale it as needed.
Ansible: Ansible is an open-source automation tool that can help you automate the deployment and configuration of your application across different environments. This ensures that your application can be consistently deployed and run in various environments.

In summary, the fifth factor of the 12 factors is "Build, Deploy, and Run." It highlights the importance of separating the stages of building, deploying, and running an application, ensuring that the application can be consistently built, deployed, and run in different environments. The tools and technologies mentioned above can help you achieve this goal.

In the next article, we will cover the sixth factor of the 12 factors. Stay tuned!

Don't forget to share this article with your colleagues and leave a comment below if you have any questions or suggestions.

See you next time!

12 Factors: Revisiting the 4th Factor - Backing Services

Luiz Ferreira — Wed, 29 Mar 2023 07:52:07 +0000

We continue with our series of study and review of the 12 factors for the development of modern applications, inspired by the books of the legendary Martin Fowler.

In previous articles, we discussed the first three factors: Codebase, Dependency Management, and Configurations. Today, we will address the fourth factor:

Backing Services

Backing services are external resources used by your application, such as databases, messaging systems, caching services, and other APIs. These services are usually managed by third parties or other teams and are essential for the functioning of your application.

Treat Backing Services as Attached Resources

One of the main practices of the fourth factor is to treat backing services as attached resources, that is, consume them as if they were an integral part of your application. This implies a consistent approach to accessing and using these services, regardless of their type or provider.

To follow this practice, you should:

Abstract access to services: Create abstraction layers that hide the specific details of each backing service. This makes it easy to switch providers or migrate to other services without the need for major modifications to the code.
Use configurations to specify backing services: As mentioned in the third factor, configurations should be separated from the code. Thus, it is essential to store connection information to backing services, such as URLs and credentials, in environment variables or other configuration mechanisms.
Decouple backing services: Ensure that your application can function even if some backing services are not available. Decoupling the application from backing services increases resilience and allows you to continue operating even when facing problems with any of these services.
Monitor and track communication with backing services: Track and monitor the use and performance of backing services to detect possible bottlenecks, failures, and performance improvements.

Examples and Tools

Here are some examples of backing services and tools that you can use in your project:

Databases: PostgreSQL, MySQL, MongoDB, and Redis are examples of backing services in the form of databases. They can be used to store and manage data for your application.
Messaging services: RabbitMQ, Kafka, and Amazon SQS are messaging services that enable asynchronous communication between components of your application, aiding in scalability and decoupling processes.
Storage services: Amazon S3, Google Cloud Storage, and Azure Blob Storage are examples of storage services that can be used to store files and other resources for your application.
External APIs: Some applications may rely on external APIs to obtain information, such as geolocation, weather forecasts, or financial data. These APIs are also considered backing services and should be treated according to the practices mentioned earlier.
Monitoring tools: Tools like New Relic, Datadog, and Prometheus can be used to monitor and track communication with backing services, helping to identify issues and improve application performance.
Caching services: Redis, Memcached, and Amazon ElastiCache are examples of caching services that can be used to enhance the performance and speed of your application's responses by storing temporary or frequently used data.
Search services: Elasticsearch, Solr, and Amazon CloudSearch are search services that can be used to index and search data in your application, providing a faster and more efficient search experience for users.
Authentication and authorization services: Auth0, Okta, and Firebase Authentication are examples of services that help manage authentication and authorization of users in your application, ensuring the security and privacy of data.
Logging platforms: Graylog, Logstash, and Amazon CloudWatch are examples of logging services that can be used to collect, analyze, and store logs from your application, aiding in the identification of issues and performance analysis.
Continuous Integration and Continuous Delivery (CI/CD): Jenkins, GitLab CI/CD, and GitHub Actions are examples of services that can be used to automate the process of integration, testing, and deployment of your application, improving code quality and streamlining the development cycle.

When using backing services, it is important to follow best practices mentioned, such as treating resources as attached resources and ensuring portability between execution environments. Also, when choosing a backing service, consider factors such as scalability, ease of use, cost, support, and the developer community behind the service.

Remember that choosing the right backing service for your project can have a significant impact on the success of your application. Therefore, it is crucial to research and compare different options before making a decision.

Stay tuned

In this article, we covered the sixth factor of the 12 factors of software development, which is the use of backing services. Using backing services allows you to focus on developing the core functionalities of your application, delegating secondary tasks to specialized and reliable services.

We will continue our journey through the 12 factors in the upcoming articles, exploring even more essential concepts and practices for the development of modern applications. Stay tuned and follow our blog to learn more!

Until next time!

12 Factors: Revisiting the 3rd Factor - Configuration

Luiz Ferreira — Mon, 20 Mar 2023 14:55:38 +0000

Welcome to my blog!

We continue our journey of studying and reviewing the 12 factors for modern application development, inspired by the books of the legendary Martin Fowler.

Don't forget to visit my website and follow the new posts there. Contact me through social networks so we can talk more about these cool topics.

In previous articles, we discussed the first and second factors, Codebase and Dependency Management. Today, we will address the third factor:

Configurations

The configurations of an application are all the options and parameters that can vary between different environments (development, testing, production, etc.). These parameters include, for example, database connection information, API keys, and access credentials.

Separate Configurations from Code and Use Environment Variables

One of the main practices of the third factor is to separate configurations from code. This means that configurations should not be stored in the same repository as the application's source code, nor should they be hardcoded directly into the code.

A common and efficient way to store and manage configurations is to use environment variables. Environment variables are a means of storing information outside of the source code, making it easier to maintain and ensuring greater security.

Benefits

By following the practice of separating configurations from code and using environment variables, you can achieve the following benefits:

Security: Prevents the leakage of sensitive information, such as API keys and access credentials.
Flexibility: Allows easy adaptation of the application to different environments, without the need to change the source code.
Versioning: Avoids the need to version configurations, since they are not part of the application's source code.
Facilitates collaboration: Facilitates collaboration between developers and teams, as each can have their own local configurations without affecting the environment of other team members.
Simplified deployment: Facilitates the deployment and configuration of new environments, as configurations can be easily adjusted without the need to change the source code.
Audit and traceability: Facilitates tracking and auditing configuration changes, as they are managed independently of the code.
Scalability: Allows for quick adaptation of configurations when the application needs to be scaled, without the need to modify the source code.

Examples and Tools

In addition to environment variables, there are several tools and libraries available to help with configuration management in different languages and frameworks, such as:

dotenv (Node.js): Loads environment variables from a .env file in your project.

Example of using dotenv:

// Load the dotenv library
require('dotenv').config();

// Access environment variable
const apiKey = process.env.API_KEY;

python-dotenv (Python): Allows the use of .env files to store and manage environment variables in Python projects, facilitating the separation between configuration and code, and keeping sensitive configurations out of the version control system.

Example of using python-dotenv:

# app.py
import os
from flask import Flask
from dotenv import load_dotenv

load_dotenv()
app = Flask(__name__)
port = os.environ.get('PORT', 5000)

@app.route('/')
def hello_world():
    return 'Hello, World!'

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=port)

Viper (Golang): Manages application configurations in Go using a variety of sources, such as JSON, TOML, YAML, HCL, among others.

Example of using Viper:

package main

import (
    "fmt"
    "github.com/spf13/viper"
)

func main() {
    viper.SetConfigName("config")
    viper.AddConfigPath(".")
    err := viper.ReadInConfig()

    if err != nil {
        panic(fmt.Errorf("Error reading configuration: %s", err))
    }

    apiKey := viper.GetString("api_key")
    fmt.Println("API Key:", apiKey)
}

config-rs (Rust): Configuration library for Rust that supports JSON, TOML, YAML, HJSON, and INI files, among others.

Example of using config-rs:

use config::{Config, File, Environment};
use serde::Deserialize;

#[derive(Debug, Deserialize)]
struct Settings {
    api_key: String,
}

fn main() {
    let mut settings = Config::default();

    settings
        .merge(File::with_name("config"))
        .unwrap()
        .merge(Environment::with_prefix("APP"))
        .unwrap();

    let settings: Settings = settings.try_into().unwrap();
    println!("API Key: {:?}", settings.api_key);
}

Conclusion

In this article, we covered the third factor of the 12 factors of software development, which is configuration management. Following the practices presented here can help ensure the security, flexibility, and scalability of your application.

Stay tuned for the next articles, where we will continue our journey through the 12 factors, delving even deeper into the concepts and practices that make them up.

Until next time!

12 Factors: Revisiting the 2nd Factor - Dependencies

Luiz Ferreira — Fri, 10 Mar 2023 09:16:44 +0000

Welcome to my blog!

I'm starting this project as a way to revisit some important concepts, study a bit, and share some of the knowledge I've accumulated on my journey so far!

Don't forget to visit my website and follow the new posts there. Contact me through social networks so we can talk more about these cool topics.

In this first phase of study, I'd like to revisit the concepts used in the study of the 12 factors for modern application development, inspired by the books of the legendary Martin Fowler.

In our last article, we talked about the first factor of the 12 factors of software development, Codebase. Today, we're going to talk about the second factor:

Dependency Management

Dependency Management is an essential practice to ensure that your code is compatible and scalable. By using package management systems and the practice of isolating dependencies from the environment, you ensure that your application runs safely and reliably in different environments. This allows you to focus on creating new features without worrying about compatibility issues between application dependencies.

Use Package Management Systems
An important practice for managing dependencies is to use package management systems, such as NPM for Node.js or Maven for Java. These systems allow dependencies to be installed automatically, through a configuration file that specifies the application dependencies and their versions.

In the case of Python, a widely used package management system is Pip. Pip is an easy-to-use tool that allows for quick and practical installation of packages and dependencies. In addition, Pip offers various features, such as the creation of virtual environments and the installation of packages from files.

In the case of Go, the default package management system is Go Modules. It was introduced in version 1.11 of Go and is responsible for managing source code packages and dependencies. Go Modules offers various features, such as version control and compatibility checking of dependencies.

In Rust, the default package management system is Cargo. Cargo allows for automated package installation and dependency management. In addition, Cargo offers features such as project creation, code compilation, and management of installed packages.

Isolating Dependencies from the Environment

Another important practice is the isolation of dependencies, which involves installing application dependencies in an environment that is isolated from the local machine. This is done using tools like Python's Virtualenv, Ruby's RVM, or asdf, which is a tool for managing language and package versions.

asdf allows you to install and manage multiple language versions, such as Python, Ruby, Node.js, and Erlang, as well as packages related to these languages. With this, it is possible to have different versions of the same language or package installed in the same environment without interfering with each other.

In addition, asdf also allows for the creation of specific virtual environments for different infrastructure tools such as Terraform, Terragrunt, Helm, among others. These virtual environments allow you to isolate specific dependencies for each tool and configure them separately, avoiding conflicts and ensuring the stability of your environment.

For example, when using Terraform, you can create an asdf virtual environment specifically for Terraform and install only the necessary dependencies for your project's execution. This ensures that you do not have conflicts between the dependencies of Terraform and the dependencies of other projects running in the same environment.

In addition, asdf is an easy-to-install and use tool, with support for various operating systems and an active community of developers, ensuring a large number of plugins available for different languages and tools.

Stay Tuned

Did you like our article? We hope so! Stay tuned for upcoming posts, where we'll talk about the other factors of the 12 factors of software development. And don't forget to follow us on social media to stay up-to-date with more programming tips and information.

Until next time!

12 Factors: Revisiting the 1st Factor

Luiz Ferreira — Tue, 10 May 2022 10:33:04 +0000

Welcome to my blog!

I'm starting this project as a way to revisit some important concepts, study a little and share some of the knowledge I've accumulated with my trajectory so far!

In this first phase of studies, I would like to revisit the concepts employed in the studies about the 12 factors for modern application development, inspired by the books of the legendary Martin Fowler.

This study was coordinated by developers of Heroku, a platform focused on delivering SaaS (Software as a Service) type applications.

So let's get to know the first factor:

Codebase

Every application should have an active version control system, some options are Git, Mercurial or Subversion.

A copy of this database is known as a code repository, repository or just the nice repo.

This is where we will store the code for our application, and this codebase always has a 1:1 relationship with the application, i.e., each application has its own codebase.

This codebase can be shared with another application but as a part of its own codebase. When this situation occurs we have a distributed application and not an application. A distributed application is a composition of several highly linked applications.

For a distributed application to be suitable for the 12-factor model it would be necessary to break this application into libraries and thus create the correct dependency between the application and the appropriate packages.

However, this does not mean that we cannot have multiple environments running the same code, in fact, this is one of the advantages of the 12 factors. We can create our own environments for development, testing, staging, and production.

Each environment can run a version of this repository, and each environment has its own reason, for the developer an environment for making changes, an environment for testing and checking with production-like data, and the production environment, which is the ideal version for the client, free of bugs and fully functional.

We call the distribution of the repository to the environments deployment or just deployment.

This image shows these environments well:

Summarizing the image, we can have the same application running different versions, each with a reason for existing.

When it comes to versioning tools, Git is widely used, becoming almost a standard in most companies. Not only that but Git was developed by Linus Torvalds, the same creator of the Linux kernel. 😁

When searching in Google trends we can see its popularity:

In a future post, we can talk more about this fantastic tool. But until then I recommend reading this material on the Git website.

Until next time!