The Business Benefits of Microservices and Cloud Foundry
Large enterprises cannot innovate as quickly as small start-ups. What makes things worse, technologies and needs are now changing faster than ever before. Many are trying to use Agile, but their software was still built using the waterfall workflow, so it simply cannot keep up. Fortunately, dividing complex architectures into smaller parts—called microservices—can help to drive innovation, but how does it work in real life? Watch the video below to find out who is using microservices and what results they have achieved.
Although separate services are smaller and simpler than monolithic apps, microservices architectures are highly complex and may be hard to manage, unless you use the right tools. This talk explains what is wrong with monolithic apps, how microservices support innovation, and why you should run them on top of a PaaS, such as Cloud Foundry.
What we need is to enable innovation
Enabling innovation is the key to long-term success—that seems to be the main point that Russ Miles makes in his talk, delivered at the 2014 CF Summit. He stresses that it is not agility, clouds, or even PaaS that is going to matter ten years from now, but how fast we can innovate. The metaphor he uses to illustrate this is that most companies “are dead already,” because things are evolving extremely fast. However large an organization is, it has to innovate and move quickly enough to beat the competition, such as Uber and Netflix.
That is clear, but why is it so hard for software to keep up with the pace of change? Russ Miles explains that there are several things that drag down large organizations and keep them from innovating. The first one is the assumption that it is possible to build an ideal architecture that will never have to be changed. The second one is the monolithic applications that have to be shoved forward by hundreds of operations engineers. Third is the idea that success can be based on building bigger things, larger teams, etc.
“What we want to do is enable innovation and for the first time in history we actually got an architectural style that supports it.” —Russ Miles, Simplicity Itself
How microservices drive innovation
What can help to enable innovation, Russ Miles argues, is “darwinian selection.” Different parts of the same system should have a possibility to compete with each other. Organizations need a way to try and test things, so that they know what works and what doesn’t.
Microservices are a bizarrely simple way to create these possibilities, if they are implemented with a PaaS that takes away the pain associated with managing distributed systems. The question is, how do we define microservices and what makes them different from SOAs (service-oriented architectures)? Here are some of the characteristics of microservices listed by Russ Miles:
- Small. Microservices need to be small and simple. They need to provide the right kind of granularity for the system to evolve.
- Single-purpose. Every service should be responsible for doing just one thing.
- Polyglot. You should be able to use any language and framework to build the services.
- Pipelines. Microservices are not about creating hierarchies of abstraction, like in SOAs. They need to be “peer services that manifest pipelines and data flows”.
- Scalable. Monoliths are hard to scale. In contrast to that, scaling microservices can be “a system condition.” Each service should be able to scale at its own rate—this can be handled entirely by a PaaS.
- Options. There should be multiple service instances for failover. The same functionality may be provided by different components.
- Antifragility. Microservices-based systems benefit from and thrive on change. The more change, the more you have to improve, the better you become.
Microservices are simple, but they may be challenging in terms of management. This is why Russ Miles recommends to implement them with a PaaS, such as Cloud Foundry. A cloud platform can cover up all the concerns inherent to this type of architecture, so you can focus on building and improving each service. The productivity will “go through the roof”, as well.
“Your competitor is probably doing this. And if they aren’t, they are probably gonna phone me up at some point and ask me how to do it.” —Russ Miles, Simplicity Itself
At Altoros, we love microservices, but despite all the benefits, this approach is not perfect. While eliminating many of the issues inherent to monolith apps, microservices may actually create some serious challenges, for example:
Implicit interfaces. When splitting a monolith into several collaborating components, you need to enable communication between different parts of the system. Microservices-based applications use interfaces for this purpose. For the communication to work flawlessly, messages must have a format and semantics that all your interfaces can read. Since all components are interrelated, when modifying one interface, you need to adjust all the other interfaces, as well. Otherwise, they will not be able to see the changes. So, if you use a microservices environment, simple cross-cutting changes will require modification of many different components.
Significant operational overhead. Using a microservices architecture may increase operating overhead. With this approach, your deployment may require significantly more resources. As a result, you may need more time and effort to create the infrastructure.
DevOps skills are required. Since the microservices model allows for using various tools and solutions to implement different services of the same system, you may need to use different data stores for different services. Your database administrator might have to be replaced by a developer with experience in deploying, running, and optimizing NoSQL databases (a developer with DevOps skills).
Operational complexity. In general, it is more difficult to control a microservices architecture, since it consists of multiple instances and services that must be managed in production. To address this, you need to provide a high level of automation.
You can find more on microservices, their pros/cons, and how to implement them with Cloud Foundry in this guide.
Want details? Watch the video!
Table of contents
- Code Sample of Microservices Using Java and Spring Boot
- Microservices vs. Monolithic Architectures: The Pros, Cons, and CF Examples
About the expert
To stay tuned with the latest updates, subscribe to our blog or follow @altoros.