Unlocking API Enablement with Microservices Architecture | Sensedia

Unlocking API Enablement with Microservices Architecture

Microservices architecture, often managed through a robust API management platform, has gained tremendous popularity in the software development industry. This represents a paradigm shift towards agile software development, offering a unique developer experience that promotes modularization. Developing teams gain newfound flexibility by breaking down applications into a series of services. 

This modular approach, supported by a comprehensive API strategy, empowers developers to handpick the most suitable technologies for addressing specific issues. Moreover, the inherent design of Microservices architecture facilitates scalability, allowing for seamless integration of features like auto-scaling and micro-containers.

APIs and microservices are inherently intertwined, with a profound emphasis on RESTful interfaces. However, a different set of hurdles emerges when faced with the challenge of legacy system integration that lacks the necessary protocols, such as WebServices or RESTful interfaces. 

In this blog post, we'll delve into strategies for surmounting these integration challenges and making the most of the Microservices revolution.

The Challenge and the Microservices Approach

Many companies dream of sharing information through APIs, little helpers that allow different systems to talk to each other. However, their current systems, like big books or old languages, were made for different jobs. These include: 

• Monolithic web applications with a single database (e.g., Java with Oracle database).
• Products or platforms like SAP ERP.
• High-level applications are written in Cobol.
• Client-server applications implemented in VB6 and SQL Server.

A specialized tool, known as an adapter, is utilized to enhance operational efficiency. This component, along with advanced API lifecycle management tools, plays a crucial role in making diverse systems work together seamlessly. 

The adapter ensures effective communication by facilitating the systems to understand each other's unique language and protocols, thereby promoting organized processes and swift initiation. 

That component should look like the diagram presented below:

To ensure standardization, the following principles should be considered:

1. Full compatibility with RESTful standards.
2. Organization by business domains.
3. Scalability.
4. Lightweight packages with quick initialization.

Microservices architecture aligns well with these requirements to create an application with a simple and scalable integration model. This recommendation is particularly relevant when your Backend doesn't rely on the HTTP protocol, as most API Gateways can efficiently route and transform messages for backend communication. 

Other scenarios where microservices architecture shines include:

• Orchestration: Routing and executing services based on specific conditions.
• Composition: Executing multiple services to compose and return a response.
• Transformation of Complex Messages: Using advanced algorithms to generate a response.

Lastly, Microservices should be organized within your business domains. This approach offers an opportunity to break down the monolithic structure of your business, resulting in a more robust architecture, such as the design presented below:

Microservices Implementation Strategy

When implementing Microservices, certain features are crucial for success:

• Lightweight packages with low memory consumption.
• Fast application initialization to create new container or server instances rapidly.
• Development based on the Swagger specification for simplicity.
• Security features, such as OAuth2.

Recommended frameworks include:

Java:

• Spring Boot
• Spark Framework
• Play Framework
• Dropwizard
• Apache Camel

JavaScript:

• Node.js

Another crucial feature when implementing APIs using Microservices is the ability to integrate with legacy systems. This essential capability necessitates a dedicated framework that adheres to the standards of business integration, commonly known as EAI patterns. In this scenario, leveraging the Java Apache Camel framework for optimal legacy system integration is recommended.

After implementing the Microservices package and ensuring it is ready, one should implement it to be available for use. The most commonly recommended strategy is to use PaaS (Platform as a service) to implement the Microservices packages. That is because this type of service offers some exciting features like:

• Use of containers
• Orchestration of containers
• Storage (file system and database)
• Real-time monitoring
• Logging and tracking

Two additional critical features to consider are:

• Being able to scale to support transportation
• Offering APIs for automating the implementation process

The main PaaS offers in the market for an implementation strategy should be evaluated, including:

1. Pivotal Cloud Foundry
2. Red Hat OpenShift
3. SalesForce Heroku

Amazon Elastic Beanstalk and Google App Engine are also viable options, offering native integration with cloud and infrastructure services.

However, consider Sensedia API Suite, which features BaaS (Backend as a Service) for a comprehensive Microservices implementation. BaaS leverages PaaS service capabilities and streamlines Microservices integration with legacy systems. Supported technologies for BaaS include: 

• Java
• Node.js
• Apache Camel

It is important to remember that if you can use this platform to run your microservices, it is not only those that enable the integration with legacies. A comprehensive API Management Platform can serve as your official microservice execution platform.

Microservices and API Management Platforms

After the Microservices are running correctly, the APIs that expose the Microservices must be well managed, and some of the essential features that most platforms of this type offer are:

• Security and Resilience: Protecting your backend from people or applications not enabled to consume those APIs is necessary. When an API is opened to integrate with partners, its Microservices must be protected against transport peaks so that it is not out of service. 

Hence, it is necessary to have control of the traffic limit (Rate Limit and Spike Arrest) and the size limit of the message body (Payload Size).

• Access Control: API consumers must be authorized users, and thus, one should use market standards such as OAuth 2.0 or JSON Web Tokens.

• Monitoring and Tracking: one should engage in API monitoring for all types of requests made on their platform; in addition, one should have a powerful log mechanism to find the errors in their API.

All the above capabilities are expected in an API Integration Platform, but some other crucial features for the complete management of its APIs are:

• Caching: it should avoid unnecessary requests in one's API, offering a much better latency for one's requests, saving even the cost of one's backend infrastructure.

• Analytics: using the API monitored in real-time is very important, both to monitor consumption and to offer insights on how to sell, monetize, and use API in the best way.

As mentioned, some API management platforms fully integrate the microservices execution platform. This type of functionality offers a total management of all the solution parts, not requiring a separate infrastructure. In that way, its architecture will be as shown in the figure below:

‍

Conclusion

Utilizing microservices architecture is a powerful way to develop RESTful interfaces for exposing legacy systems that lack native HTTP interfaces. The choice of tools and frameworks depends on your specific scenario, but some of the most commonly used options have been discussed in this article. When selecting your development kit, consider your unique needs.

For a comprehensive solution, Sensedia API Suite offers Backend as a Service (BaaS) and a full-featured Integration Platform with caching and analytics. The recommendation is to use integrated platforms that facilitate total management of your Microservices and the APIs they expose, ensuring a robust and efficient agile architecture that allows for legacy modernization.

References

[1] Microservices – https://www.martinfowler.com/articles/microservices.html
‍[2] Apache Camel – https://camel.apache.org/
‍[3] PaaS Comparator – https://paasfinder.org/filter
‍[4] Twelve-Factor App – https://12factor.net/
‍[5] Sensedia API Management Platform- https://www.sensedia.com/product/api-management
‍[6] API Gateway Pattern – https://www.nginx.com/blog/building-microservices-using-an-api-gateway/