Lessons Learned in Highly Configurable Software
Through the use of Highly Configurable Software in our large scale, enterprise applications, we have evolved our implementation and learned from our mistakes along the way. These are the lessons that we have gained from integrating Highly Configurable Software into our software and processes.
- Coding for the cloud should eliminate host specific Key Configuration Points (KCP). Containers/servers in the cloud are ephemeral and should be consistent, so custom configuration across each individual deployable unit should reduce to zero.
- There are Key Configuration Points (KCP) that are better suited as local environmental setup instead of hierarchical, URI based KCPs. Remember that hierarchical, URI based KCPs should be:
- Configurable URIs
- External Service Connection Information
- Differences between Environments.
- Local environment configuration like Security settings are better suited outside of KCPs, since this will most likely be needed to access the Configuration Service (specifically SSL/TLS configuration). Some environment configuration are better solved by following convention over configuration.
- Be careful when bulk loading all KCPs up front on initial load.
- IE, Five-thousand KCPs per one-hundred servers == Fifty-thousand requests to the Configuration Service, which will essentially DDoS the service.
- We have found that staggered starts, bulk requests or caching will help to solve this problem
- Remember to include a local set of development default KCPs. This will increase your fault tolerance, and ensure that services can continue using non-production configuration if the Configuration Service is not available.
- Maintaining a history of the KCPs and their changes is vital to long term sustainability. This includes versioning, as well as who/when the KCPs.
- Spring-Cloud-Config defaults to Git as a data store, which provides this functionality out of the box.
- Bulk Loading/Caching takes its toll on who last accessed each property, be careful when setting this up! The last accessed is extremely helpful in understanding if a key configuration point is still being used; however, bulk loading can miss represent if a property is being used by the application.
- Ensure that the Highly Configurable Software solution remains well documented and easy to use. This increases the maintainability of the solution tenfold. The team that maintains the application must understand the strategy and be able to mentor others on its implementation.
- Ensure there is a documented process for migrating existing projects. Keep the process simple!
- Maintain a lightweight architecture, one example being Microservices.
- Remember that the Configuration must be its own service, or start up before all other applications due to dependence
- Remember that security should be completed via locally environment, as this can become a Chicken-and-Egg situation otherwise.
- Keep Application level configuration in your Configuration Service, and outside of your application server.
- Spring-Boot eases this pain point by using an embedded server JAR in its Microservices.
Feel free to reach out with questions, or contact us with feedback!