Netflix, Amazon, Google, PayPal, and Facebook have more in common than them being the absolute behemoths of their niches. They all follow the microservices architecture along with DevOps.
These giants of the digital world turn out to be built on the building block of microservices. And they use DevOps guidelines to ensure things turn out to be the way they are supposed to be (or perhaps need to be).
Principles of DevOps put forward this great idea that all the teams involved in the software development cycle should work in unison and sync better. And microservices turn out to be one of the better strategies to bring the idea to fruition.
Let’s throw some more light on the subject and find out how the microservices architecture can help you stay adhered to the lessons of DevOps playbook.
1. Microservices in DevOps – Smaller teams, better communication
There used to be vast communication gaps between development, production, and testing teams. It was only after one team was done with the code that the others got their hands on it, and no one ever seemed to know the other side of the story. DevOps came in with the agenda of bridging this gap using proper communication and encouraging everyone to work towards the common goal.
Microservices do not require large teams with tons of members in every department. The relatively smaller size of the microservice leads to smaller groups, and thus, much better communication. Everybody knows everyone else, and also the challenges faced by other members of the team.
When Jeff Bezos came up with the idea of two-pizza teams, the idea was to take down the lengthy and tedious communication mechanisms. Smaller cross-functional teams do not need to take much care of communication logs, and yet all of them understand the needs and challenges of other members of the team, a lot better. And isn’t it a great convenience if all it takes to keep the team happy is two pizzas? :)
2. Use what’s best for the job
Netflix is one of the early birds to implement microservices architecture. They put forward a great template as to how one should go about adopting it. And for the benefits of microservices, Netflix itself is a living breathing example of what one can achieve with them.
The DevOps culture emphasizes creating the product with the end in mind. In the waterfall way, each process is just a link in the long chain, and it will usually have a lot to do with pre and post processes. It adds up to the responsibilities of the caretakers of that process and adds up to the entropy.
Adrian Cockroft, the then Director of Web Engineering and Cloud Architect at Netflix, has explained the entire process of Netflix implementing microservices in great detail in many conferences. You can almost sense a feeling of relief on his face when he describes how they didn’t need to worry much about the programming language used to build a microservice. He explained that they were okay with it as long as it worked well with their deployment mechanism. They focused on the end product.
With a microservices architecture in place, the teams will be able to use the best possible resources needed for the job. They can make most of their decisions with the end product in mind, something that will only improve the quality of your software or service.
However, you should also not get carried away with this freedom. Using multiple languages can make things increasingly complicated if you don’t exercise proper caution.
3. Better accountability
Let’s suppose you have hundreds of developers in the company, and they all contribute to a single piece of code- something that you usually see in a monolithic architecture. You make the code go live, and let’s suppose something goes wrong with it. What’d you do now? The first set of headaches would be to find out what’s wrong, and then there will be the blame-game.
You know the kind of ordeal we are talking about, and you might’ve gone through it at some point. The DevOps principles propose eliminating this constant juggle of responsibility. You don’t want to spend time determining if it was a fault of the development team or the operations team. You’d rather channel all that energy into eliminating the issue.
Microservices architecture does a great job of making teams responsible. You will not find the developers and testers going back and forth on the problem but working together to make the product work. In the end, it will be their collective responsibility if the software is working or not. And you won’t be pulling your hair as it’s you who needs to make the service work and find the epicenter of the problem at the same time.
4. Autonomy isn’t that bad
With great power comes greater responsibility. And microservices architecture doesn’t miss out on the “power” side of things. After all, it would be only unfair of you bashing a team for a defect when you didn’t let them work the way they would’ve preferred.
Microservices provide a great deal of authority to teams. They don’t need to look up to the authorities each time there is a crucial decision to be made. The team can easily decide the next step when they come across a roadblock and make things work.
When we talk about cross-functional autonomous teams under DevOps, the motive is to bring in all the flexibility needed in the project. And what better way to introduce autonomy other than creating a vertical of sorts. A microservices architecture allows teams to steer the ship in any direction, as long as they reach the destination within the stipulated time and budget. And perhaps you can also throw in a rule that they are not allowed to go on foreign waters. :P
5. Helps to create user-centric products
A modern-day interpretation of Conway’s law would be that the end product ends up reflecting the internal structure of the organization. If you want to come up with products that do well on all the ends, then it should reflect in the structure of the team creating the software.
The microservices architecture allows you to reverse engineer Conway’s law and start by building a team that can justify the aspirations of your end-user. Recruiting a DevOps engineer doesn’t necessarily mean you are following its principles. It’s more of a culture than anything. And that culture says you need to continuously improve the processes and products with the end-user in mind.
Microservices give you a great start by allowing you to assemble a team and resources that seem necessary. You can then modify them as needed. The fact that you can keep on making changes without affecting much of the system helps too. Since a microservice is relatively independent of other functions of the service, you won’t have much difficulty introducing the changes. The cycle of continuous improvement can keep on going until you have a satisfactory product for the user.
6. Receptive to automation and testing
There is a great deal of emphasis on continuous improvement and automating everything that you can, under the principles of DevOps. Before the advent of microservices, testing used to happen after the grueling software development cycle. And just like other steps of the process in a monolithic architecture, it used to consume a lot of time.
Microservices breaks down the application stack into smaller and relatively independent services. This smaller service is usually supposed to take care of only one function. Therefore, unit testing ends up being a lot faster and easier to automate.
It is because of these microservices that we are now seeing multiple micro-releases within a day. What used to take months is now taking weeks, and what used to take hours now only needs a few seconds. And easier testing and automation for microservices has a lot to do with it. And one sweet byproduct of this increased frequency of testing and release is much lower costs.
DevOps is this great idea which sounds right to pretty much everyone. But when it comes to implementation, people often find themselves in tricky situations. The microservices architecture makes it a lot easier for one to stick to the principles of DevOps.
Better communication, more automation, and improved accountability are some of the overlapping areas of DevOps and microservices. And for the rest of the virtues of DevOps such as focus on the end product and continuous improvement, you can rest assured that microservices is the perfect catalyst to propel you in that direction.