As agencies consider microservices to increase reuse, decrease complexity and improve flexibility and scalability, deciding how to start often becomes the challenge. Much has been written about the benefits of a microservice-oriented architecture as well as on how to implement a microservice from scratch. Unfortunately, most of this literature simply misses the bus…the enterprise service bus, that is.
We tend to think of ESBs as outdated platforms, primarily used to integrate disparate systems. But in fact, they may be the best platform for implementing microservices. Why? Because an ESB offers a technology stack that inherently supports microservices implementations and embodies attributes needed for long-term scalability.
Below are the seven top features to have in a technology stack that supports microservices:
1. Lightweight containers. Make sure to have a lightweight, dynamic container. Typical J2EE application servers are too cumbersome and heavy, presenting too little value for today’s applications.
2. Polyglot programming environment. The platform itself should never force a particular programming model, style or language. Instead it should be language-agnostic and deliver multichannel, multicontainer capabilities wherein a single instance can host native code, .NET, Java and Spring, etc.
3. Out-of-the-box capabilities. This is critical because out-of-the-box capabilities will reduce implementation overhead. For example, the platform must have the capability to generate most of the boilerplate code for implementing the microservice. If not, it can create a late binding between the interface and the service implementation.
4. Security. Every platform must be standardized to decouple security from the microservice implementation so service developers are not responsible for implementing security correctly. The platform itself should provide capabilities for certificate management, support for different styles of credentials and authentication and authorization leveraging a role-based access control model.
5. Mediation and intelligent routing. All microservices-based architectures end up having multiple instances of the same kind of functionality to support scaling. Therefore, one of the challenges is how to effectively route the right request to the right instance of a microservice. The system must know how to manage that traffic, which can be addressed through a mediation and intelligent routing process.
6. Hot “swap-ability.” Having hot-swapping support is important for getting a container provisioned at run time or replacing, deprecating or adding new microservices. This feature is especially essential when addressing mission-critical bug patches.
7. Monitoring and manageability. Microservices can be hard to manage, control and isolate because of the highly distributed architecture style. How will IT operations figure out where any problem resides? How will they monitor the system to discover what’s failing, what’s working well and what’s not? How will they perform upgrades and corrections? Any technology platform, therefore, should include the ability to monitor the end-to-end implementation based on microservices in a way that doesn’t require any instrumentation to be put into the microservice itself by developers.
Some leading ESB vendors provide a way to create microservices with little to no programming, by generating much of the boilerplate code that many developers struggle with when implementing microservices from scratch. Some vendors also offer web service interfaces on top of existing legacy systems and services that can turn a legacy system into a set of reusable microservices with all of the security and other benefits that go along with it.
If you haven’t considered an ESB, it’s time to start. ESBs are lightweight containers that provide many out-of-the-box capabilities, including security, extensive monitoring and management necessary to scale for IT challenges of today and tomorrow. Don’t miss the bus! Catch up and modernize your IT systems by employing a microservice-based architecture.
About the Author
Chris Steel is chief solutions architect at Software AG Government Solutions.
Article was originally published on GCN.com.