Microservices are taking the software industry by storm, but that doesn’t mean monolithic applications are becoming extinct. While SRE is more commonly associated with modern architectures, Google is providing some insight into how enterprises can use SRE to manage their monoliths.
“When and why to choose monolithic architecture is usually a matter of what works best for each business. Whatever the reason for using monolithic services, you still have to support them. They do, however, bring their own reliability and scaling challenges,” Eric Harvieux, SRE systems engineer at Google, wrote in a post.
RELATED CONTENT: Transitiong to SRE
According to Harvieux, the most common problems that come with monoliths is operating them. As monolith applications grow or scale, problems include code base complexity, release process difficulty, capacity, and operational difficulty.
In order to apply SRE to these challenges, Google explained enterprises have to treat monoliths as a platform. “Doing so helps address the operational challenges inherent in this type of design,” wrote Harvieux. “First, it establishes responsibility for the service. The platform itself should have clear owners who define policy and ensure that the underlying functionality is available for the various use cases. Second, it helps frame decisions about how to deploy and run code in a way that balances reliability with development velocity.”
Some recommendations include:
- Plug-in architecture: Structure code to be modular and support service functional requirements
- Policies for new code and backends: Be clear about new functionality requirements
- Bucket SLOs: Bucket requests based on similarities and characteristics
- Setting up traffic filtering: Be able to filter traffic using different characteristics
- Using feature flags: This helps with incident response and being able to throttle down or turn off threatening features
- Flavors of monoliths: “Once you have feature flags, it’s possible to run different pools of the same binary, with each pool configured to handle different types of requests,” wrote Harvieux.
“Regardless of where your code sits on the monolith-microservice spectrum, your service’s reliability and users’ experience are what ultimately matters. At Google, we’ve learned—sometimes the hard way—from the challenges that various design patterns bring. In spite of these challenges, we continue to serve our users 24/7 by calling to mind SRE principles, and putting these principles into practice,” Harvieux added.