In my previous article, I covered the core building blocks of DevOps in Microservices environment. As part of this article, I highlight the major pitfalls of each building block – pitfalls that need to be addressed to do away with issues in the Microservices architecture.
As we already know that following are the core building blocks of DevOps-
- Continuous Integration
- Continuous Deployment
Let’s see the issues of each one of them below.
- Maintaining single code repository for all the services implementation, for any service deployment, need to build all services code.
- Latest Continuous Integration tools didn’t exist or having monolithic CI for monolithic application build.
- It is not recommended to skip the daily code commit, we may have code loss or running application don’t have the latest code applied.
- Not having a suite of tests to validate the recent release code changes to make sure they didn’t break any existing functionality.
- Low priority for broken build, there was no much importance even though build Job failed.
- Not covering all the stages of the journey from code to production deployment.
- Tailoring CI tools to do CD work, there were no dedicated CI and CD tools and used CI tools to do the CD tasks as well.
- Technology specific CD tools, What were the CD tools exist, they were tightly coupled with specific technology.
- Generating artifacts separately for each stage, single artifacts could be used for DEV, Staging, Production environments deployment instead of generating separate artifacts of each environment.
- Not having a configuration server, There could be a specific configuration server where all configurations would be maintained and they could be reflected in application instead hard coded them in the code itself.
- Not having images for each service – There is a single code repository for all services, so no separate image for specific server.
- Lack of versioning for artifacts, there was a challenge to maintain the versions for images.
- Lack of containerization, Used Physical servers or VMs instead of containers while scaling.
- Inadequate Image management, there was no proper application artifacts image maintenance.
- No link between metrics and scale
- No or Semi automation of scaling, there advanced scaling mechanism based on the load on the application.
- No simpler mechanism to configure scaling based on the metrics
- Services don’t having enough clarity of its own metrics to track the details.
- No aggregation or drill down option for service and host level metrics
- Insufficient storage system for metrics to store them on the filesystem.
- No builtin mechanism to log service execution time
- No standard way to track the failed requests and no of requests per second
- No mechanism to upfront know the underlying problem before end user gets affected
- Lack of standardization in logs, there was no proper standards to follow while logging.
- Watching logs from specific hosts
- Lack of tracing mechanism for sequence of events
- No mechanism to check the health of downstream dependencies
The impact of the continuous software delivery model is widespread, especially in enterprises that work on Agile for their software implementation since it has proven to be scalable and cost-efficient. The pitfalls of core building blocks highlighted in this blog are helpful to address them in the Microservices architecture.