DevOps is one of the biggest trends in tech today, but it wouldn’t be half of what it is without microservices architecture.
Last week we told you all about DevOps, the buzz-generating fusion between Development and Operations teams, and explained how IT automation is making DevOps transformations possible. Now, we’re back to explain another of the major building blocks of a successful DevOps transformation: microservices architecture.
What are Microservices?
Microservices are the secret sauce that let DevOps teams be disruptive, agile, and nimble, among other buzzwords.
One of my favorite definitions of Microservices comes from Tim King, over at Solutions Review: “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.”
At Microsoft, Sam Guckenheimer describes it less poetically, but quite effectively: “Microservices describes the architectural pattern of composing a distributed application from separately deployable services that perform specific business functions and communicate over web interfaces.”
So, in plain English, microservices are basically a new way of creating applications, wherein applications are broken down into independent services, which are not dependent on specific coding languages, and can be redeployed in different contexts as needed to create new applications.
The Lego Explanation: Flexibility and Scalability
Think of it like building a structure out of Legos vs. building one from scratch out of wood—with Legos the individual building blocks are already there for you to build whatever you want, rather than having to carve and build custom pieces from wood. And, when you’re finished, you can disassemble the Lego blocks and reassemble them into whatever else you may desire, whereas your wooden toy is purpose-built, and stuck as it is.
Microservices, like Legos, are specialized building blocks—individual pieces with individual functionalities. And, like Legos, microservices are scalable—they can be combined, typically via APIs, to build something bigger. Additionally, each single microservice component can be scaled independently, so if you need additional file transfer capability, you can simply scale the file transfer microservice.
Un-Lego: Removing Single Points of Failure
There is one area of microservices where my Lego analogy fails: If you take away a piece from your Lego tower, the whole structure could fall. That’s what’s commonly known as a single point of failure. Unlike like Lego, microservices has no such flaw. With a microservices architecture, if you take away a single piece, such as when one service crashes, the entire structure does not fail. That’s because, microservices while microservices are open to interface with one another, they cannot be modified by the other services they connect to. As Guckenheimer explains, because each microservice is implemented and versioned independently, microservices architecture removes the issue of a single point of failure by guaranteeing that issues in one service cannot crash or otherwise impact other parts of an application.
Faster Velocity = Continuous Delivery = A DevOps Love Story
So this is all well and good, but you may be asking yourself, where exactly does DevOps come into this? Well, to answer your question, the lego-ness of microservices means that it is extremely easy to build and app out of them. Much faster than the traditional, monolithic approach to app development. This agility makes microservices essential to the continuous integration and continuous delivery mindsets that are at the core of DevOps.