Developers are using Microservices architecture to design and build highly scalable, “lightweight” applications, and while the system may have it’s drawbacks, popularity of microservices has gained momentum over the past several years. This means that you need to know how DevOps are leveraging the architecture to deliver applications in an agile new way.
What the Heck is Microservice Architecture?
Microservices can be defined more by the characteristics of the method of developing software applications, sort of similar to the way you identify blackholes in space; by the behavior of the objects around it. Microservice architecture employs a host of independently deployable, small, modular services in which each service runs a unique process and communicates through a defined, lightweight mechanism to serve a business goal. Gartner inc. touches upon the topic in their blog post, “Microservices: Building Services with the Guts on the Outside“, by Gary Olliffe.
“I want to introduce you to what I think is an important clarification of microservice architecture: the distinction between simpler “inner architecture” and more complex “outer architecture”. First, some level-setting. Microservice architectures promise to deliver flexibility and scalability to the development and deployment of service-based applications. But how is that promise delivered? In short, by adopting an architecture that allows individual services to be built and deployed independently and dynamically; an architecture that embraces DevOps practices.”
Back to our blackhole reasoning, it helps to consider Microservice’s polar opposite: Monolithic Architectural style, to understand the process better. SmartBear, an organization that helps software teams create apps and APIs from code to live, describes Monolithic Architecture in their blog, “What is Microservices Architecture?“, and how it saves developers a ton of headache.
“A monolith application is always built as a single, autonomous unit. In a client-server model, the server-side application is a monolith that handles the HTTP requests, executes logic, and retrieves/updates the data in the underlying database. The problem with a monolithic architecture, though, is that all change cycles usually end up being tied to one another. A modification made to a small section of an application might require building and deploying an entirely new version. If you need to scale specific functions of an application, you may have to scale the entire application instead of just the desired components. This is where creating microservices can come to the rescue.”
Microservices architecture is flexible and resilient. The services themselves are simple, by focusing on doing only one task makes them easier to test. Each service can be built with the best suited technologies and tools present at the time, so in the event of an upgrade, developers don’t have to be stuck with an early choice of technology for the rest of the project. This allows much more space to move and experiment. The benefits don’t stop there; microservices provide fault isolation so that in the event that a service goes down, parts that directly depend on it will leave the other parts able to function.
Common drawbacks of the architecture, you’ll hear developers describe on forums like Reddit Microservices: That this technology is not for the novice, asserting that substantial DevOps skills are required to make it successful. It’s also commonly mentioned that Microservices creates significant operations overhead. In a post by Benjamin Wootton, CTO of Contino consultancy, who specialize in applying DevOps and Continuous Delivery to software delivery projects, Wootton explains that operating and orchestrating all these services can be a daunting task.
“Productizing all of this needs high quality monitoring and operations infrastructure. Keeping an application server running can be a full time job, but we now have to ensure that tens or even hundreds of processes stay up, don’t run out of disk space, don’t deadlock, stay performant.”
Professionals in the space also commonly assert that the architecture makes asynchronicity and testability, challenging. Wootton warns users:
“Microservices are not a free lunch! I am currently involved in architecting a system based around Microservices, and whilst the individual services are very simple, a lot of complexity exists at a higher level level in terms of managing these services and orchestrating business processes throughout them. Microservices one of these ideas that are nice in practice, but all manner of complexity comes out when it meets reality.”
By implementing microservices architecture, developers are able to build apps as a host of small, semi-autonomous processes that perform specific tasks and use APIs to communicate with each other. Microservices are gaining popularity because of the easy to use nature, and scalability that the architecture offers.