Application configuration settings management is becoming an increasingly significant part of modern application development. Configurations are typically saved alongside their associated application code repositories, and any changes necessitate the deployment of a new version of the code. This holds true even if only one configuration setting is altered. CaC (configuration-as-code) decouples configuration from application code. Application settings are frequently saved in their own repository and controlled independently of the primary codebase. In this post, we will define configuration-as-code and discuss the advantages of using version control for your setup.
Table of Contents
What is configuration-as-code?
Configuration-as-Code (CaC) is a collection of procedures and techniques that will help you save time, improve your flexibility, and prolong the uptime of your system. Configuration-as- Code keeps application code and configuration separate.
In contrast to the main codebase, application settings are frequently maintained and stored in their own repository. In order for your program or product to function differently based on the platform, hardware, and other factors, configuration files give information. It enhances the functionality and versatility of the actual code. Your release pipeline may be streamlined if you version and save configuration files the same way you do code.
Why is configuration-as-code important?
Teams can benefit from implementing configuration-as-code in a number of ways:
Similar to IaC, handling configuration changes as code enables teams to add, update, and manage config files from a single centralized location while utilizing a standardized deployment approach. You require configuration files for each of your storage options, for instance, if you are developing USB devices.
You might have hundreds of variations if you combine these files with the required tools. A consistent, centralized, and reliable source control that can be accessed from many steps in your CI/CD pipeline is necessary to manage these differences.
You are able to use all of your development best practices, such as linting and security scanning, when configuration is written like source code. Before they are submitted, config files must be reviewed and tested to guarantee that modifications adhere to your team’s standards. This can maintain the stability and consistency of your setups if you have a complicated microservices architecture. A predetermined process in place makes it easier for services to collaborate.
Setting up settings as code necessitates the use of version control. For your code and configuration files, you require a strong system that can conveniently store and track changes. Your release quality may improve as a result. You have the ability to identify the bug’s origin if it does get through. To rapidly identify the issue and rectify it, you can diff the versioned configuration files.
Your build pipeline becomes simpler when configurations are converted to managed code. It boosts output for end users and IT alike. Your administrators can use a single version control system to pull everything into a release or build. Developers are confident in the accuracy of their changes because every component of your workflow has been tested in concert.
The advantages of configuration-as-code
The versioned migration of configurations between various environments is what Config as Code refers to. What does this strategy give an organization, aside from complicating the build and deployment procedures already in place?
- Security: Separating user access encourages least-privilege permissions and increased access auditability.
- Traceability: It is simpler to trace updates and changes when a separate version control repository is used just for configurations.
- Manageability: To assure non-breaking changes, build and deployment processes tailored to configurations may contain additional approval, validation, and testing steps.
Moving configuration management into its own distinct process has several advantages. Even if complexity is added and setup and configuration are required to eliminate configuration from a codebase, the work is worthwhile in the long run.
How to implement Configuration-as-Code
Configuration Data Simplified
Simplicity is a blessing when configurations are managed resources that are migrated between all of your environments. During development, it should be possible to recognize that configuration and maintain consistency with it. Containers have made something that was once nearly impossible, possible, and even natural.
Your workflow may be simpler if all of your files are in one repository. However, if you are treating configuration files as source code, any change to a setting can result in a fresh build. This might not be necessary and might even make your team work more slowly.
Not every configuration change requires a build. Your system would need to be configured so that updates to configuration files could be integrated. Then, for next testing, they might be sent to one of your pre-production settings.
Because everything is code, it might be challenging to distinguish between configuration files and source code when performing an audit. Establishing a naming convention that is uniform across teams is crucial.
Component-based development and microservices
Teams divide their code into various repos for a variety of reasons. Config files are kept and versioned in this model alongside the particular microservice or component.
Even though you might get a similar problem with trigger builds, it might be simpler to handle. Work with your DevOps teams if you intend to version configuration files along with their microservice or component. Plan how configuration changes will be distributed.
Individual Repositories for Configuration Files
Regardless of how you keep your source code organized, some teams prefer to keep their configuration code in a separate repository. Although it can seem like a nice concept, most programs cannot use it.
Just a few thousand configuration files may exist for even the most complicated projects. Therefore, they would only occupy a little percentage of a whole repo. Your build pipeline would need to be set up, which would take time for your administration. For audits, rollbacks, and reviews, this paradigm can be useful, but you might want to look at other possibilities.
IaS vs CaC
Infrastructure as Code (IaC) and Configuration-as-Code (CasC or CAC) are frequently used interchangeably. They aren’t and there’s a good explanation why they’re two different terms. IaC is about controlling your IT setup. Servers, networking, load balancing, and security are all part of this. How your software’s components communicate with one another is governed by Configuration-as-Code. Your application or product can be produced and tested earlier in the pipeline and released with greater assurance if a configuration is changed.
However, Config as Code and Infrastructure as Code still have advantages over one another and are frequently used together. A few configurations, for instance, can and ought to be controlled in the configuration process before being used by the infrastructure processes. An organization may quickly understand complex configurations and how they’re managed by using each strategy in this manner.
3 rules of CaC
There aren’t many official explanations of how to use Configuration-as-Code available. However, we can consider how we handle source code and how we manage configurations. After that, we can decide on a set of guidelines for writing Configuration-as-Code.
CAC Does Not Ship Apps With Configurations
You might add a configs folder and the files to your release package if you just superficially interpret Configuration-as-Code. That strategy would be incorrect and harmful. That answer indicates that a configuration change necessitates an application release. This accomplishes the objective of creating an audit trail for configurations, but by combining them with code changes, it creates confusion.
This might make sense if a new feature calls for both a code update and a configuration change. What if, though, you are merely making a configuration change? What happens if you simply raise the cache setting in production? This should be tested in at least one of your pre-production settings. Additionally, you should compare your code to the most recent release. When you are certain that the change will succeed, you should spread the word about it. You can get the necessary traceability from Configuration-as-Code. You can discover the modification in your configuration repository, look at it, and determine what happened.
What happens if you have to undo a code change but leave a configuration that was added after it in the release stream? You are currently handling source control merges or fixes. You can release and roll back configuration separately by keeping it in distinct repositories. It is simpler to synchronize them as needed than to disconnect them instantly.
CAC Is Not Shipping Containers With Configurations
You can begin baking your configurations into your containers if you use them. Yes, that is configuration represented as code. No. Not at all.
This firstly creates the identical circumstance as before. A new release of the container is necessary for any configuration update. Therefore, mixing the configs and code in the container creates an unwanted reliance, even if you maintain them in separate locations.
Your containers are also now fragile. This might not be a problem if you only have one environment or if all of your surroundings are uniform in appearance. But the first thing you’ll need to improve is your build process when it’s time to add a new environment or move to a different cloud provider.
CAC Maintains a Separate Configuration Pipeline
Maintaining a distinct release pipeline for configuration requires implementing Configuration-as-Code. As a unique artifact, configuration is migrated between environments. It can be thought of as a distinct entity because it is tracked independently. You can undo configuration changes without affecting subsequent versions if they don’t work. The relationship is obvious and unmistakable whether it depends on another release or another version. This is accomplished using configuration information stored in the same repository as the application. Even though it’s preferable to keep them distinct, you can still mix them in VCS provided you’re careful about how you handle the repository. Make sure your setups are saved in separate commits and identified as such.
Best practices of configuration-as-code
What does really using Configuration-as-Code mean? There are numerous ways to put it into effect, but not all of them are appropriate for every type of business. See if the broad strokes provided below meet your specific requirements:
Making use of certain configuration source control repositories
Usually, the code that is delivered includes an application configuration package as well. The complete codebase must be deployed to implement a modification when a configuration value is modified. The configuration settings are typically kept in a flat file, so even while this indicates a versioned change, it may be challenging to track down the precise change performed, especially in a bigger code contribution.
You gain the following by keeping configuration in its own repository and versioning it:
- Independent configuration modifications’ advantages.
- A certain deployment procedure
- Simple auditing changes
- A developer may not need access to additional security measures, which are typically used for application secrets.
- Constructing a customized build and deployment procedure
There’s a chance that an application’s deployment procedure won’t work for basic configuration adjustments. The build and deployment procedure for configurations is frequently streamlined. A configuration change may not be subject to the same level of testing and validation as a code update would.
Additional validation processes can be incorporated into a particular configuration deployment process. This can get rid of a lot of phases in the process that are unnecessary for configuration-specific deployments. For instance, configuration items like format and substance may need to be validated; this can then be taken care of in a build and deployment process that is particular to configuration.
Establishing test environments with precise configurations
For a straightforward configuration update, sometimes firing up a testing environment for the entire application code is not necessary. An enterprise can save time and money by narrowing the scope of a test environment to the requirements of the configuration deployment process.
This can also imply that many changes can take place simultaneously. While a configuration modification is being tested, application developers can test their code. You can operate and manage the environment more effectively with this capacity for parallel testing.
Ensuring the existence of systems for approval and quality control
A different team’s input and approval may be required before altering an API key or endpoint URI. If the configurations themselves were hidden deep within the coding of the program, this approval process would normally not be necessary. The customized development and deployment process can be combined with approvals and quality assurance to guarantee that the proper configurations are deployed where they should be.
Configurations for managing secrets
The majority of settings will have information that should not be widely known, such as secrets required to access databases, key stores, or file locations. It can be challenging to restrict access to only the right people when configurations are placed with application code in a flat file. By using Config as Code, you can convert these encrypted values that are subject to multiple permission and verification procedures into independent protected secrets. This improves the security of your apps and significantly lowers the likelihood of infrastructure or code intrusions.
As a result, adding configuration-as-a-code to your development process can have a significant positive impact on your development team. It automates the procedure for implementing configurations across environments, making it simpler to implement updates and guarantee that everything functions as intended. A powerful tool for managing and controlling intricate infrastructure and pipelines and for enhancing the creation and deployment of programs is Configuration-as-Code.