There’s a lot of buzz around microservices—and for good reason. Microservices offer teams and businesses many advantages, notably the ability to make small changes to code quickly and efficiently, and with minimum risk.
Microservices constitute a software architectural style that approaches a single application as a suite of small services, organized around business capabilities. Each service runs its own process and communicates with lightweight mechanisms, such as an HTTP-based API. The services are small, highly decoupled and focus on doing a single task. They lend themselves well to Continuous Delivery.
The big question for tech teams and C-level business folks alike is: where do you start using them?
Whatever you do, don’t try a complete re-architecting of your existing software infrastructure, unless you want to raise everyone’s stress levels and are not afraid to to fail splendidly. In most cases, the only thing a “big bang” re-architecture guarantees is a likewise big bang headache.
Start Small with Something Meaningful
Common sense and common practice suggest you start small. What’s perhaps a little harder to feel comfortable with is choosing something meaningful, something that should help your business, rather than just a “harmless” sandbox project. The key point here is that it’s important that your experiment demonstrates that it can work for a “real” piece of business capability, not just a “hello world” example. Choose a business capability that is a good candidate for improvement and that can be isolated from your existing software infrastructure by finding a layer that you can abstract out into the service interface.
Two very important issues to consider: make sure the business capability is not business-critical, and make sure you run a heavily tested (and re-tested) pilot version before you go live in the real world. This “homework”, which will enable you to see how the technology integrates with your software infrastructure, will give you and your team the institutional learning that is vital to understanding and accepting new technology; this is a key prerequisite for a successful microservices transformation.
If all goes well, you are ready to:
- Introduce microservices (ideally via tools that gel easily with your existing software delivery tooling and processes);
- Run sufficient automated tests so that you can replace the existing functionality with the new, microservices-based interface with confidence; and
- Remove the old code from the system.
Once you’ve done all that, you’re well on your way to integrating microservices into your organization. Some people call this step zero. Success at step zero means you have progressed to the point where you feel like: yes, this technology is going to work at our organization.
After Step Zero, Follow the Example of Large Companies
A proven way to integrate microservices into your organization is to follow the example of how large, successful organizations have trodden the path before you.
Many companies—among them eBay, Google and Amazon—adopted microservices by focusing on business capabilities in order of their contribution to revenue.
After successfully deploying microservices in one area, they rinsed and repeated the approach in the next area, until they had re-architected the systems that made a significant contribution to the business, leaving only those with negligible impact as legacy monoliths. This is not done overnight, of course—it’s a process that can take years and usually can’t be rushed.
It is vital that you start the “serious” phase of your microservices transformation with something that has significant impact. Otherwise, your foray into microservices will never get widespread visibility within the company and will find it difficult to progress beyond being just an experiment. You’ve got to deliver business results that all employees can relate to and feel inspired by.
Throughout the process, you should continually test the state of your system landscape against the business objectives of the transformation. Start small and stay targeted, keep a strong emphasis on testing to ensure you don’t crash and burn at an early stage, learn continuously along the way, and never lose focus of what microservices can do for your business.
The big takeaway: to do microservices properly start small but with a business-relevant problem. Hone your microservices skills before you apply them to something critical. Once you have succeed with this “step zero”, begin integrating microservices into business-critical areas, starting with the most important one and working your way down the list.
About the Author
Andrew Phillips heads up product management at XebiaLabs. Andrew is an evangelist and thought leader in the DevOps, Cloud and Continuous Delivery space. He sits on the management team and drives product direction, positioning and planning.