Microservices are central to a cloud-native architecture because they structure applications as a collection of services that are easy to maintain and test. Microservices are loosely coupled, meaning that constituent parts can be updated and swapped, and each can be deployed independently. Importantly, they are organised around business capabilities and generally owned by a small, expert team.
These attributes allow a microservices-based architecture to deliver large, complex applications quickly, frequently and reliably. The architecture enables organisations to evolve their technology stack but without requiring a specific technical framework to build and use microservices, just to follow key principles.
Solutions for self-contained logic
Developers typically use one or more microservice frameworks such as SpringBoot, Node.JS, Vert.X, etc., which are code-centric. This means developers write code for the business logic of a microservice – an approach that works well when the use case involves self-contained logic. Examples include tax rules, calculating discounts and managing business entities such as account, customer profile, product information and so on.
Within enterprises, most customer journeys and use-cases cut across multiple systems of record, connect to partner systems and extract data from a cloud service. Typically, enterprise use-cases depend on external resources in some form. If the use-case requires complex composition and orchestration with multiple integration points, product families such as an enterprise service bus (ESB) or an integration Platform-as-as-Service (iPaaS) are good choices to build services.
On the other hand, where use cases are mostly self-contained, but rely on data from external systems for some scenarios, a micro-integrator is a better option. This is because a micro-integrator framework provides the best of both worlds: the visual flow design of integration product families like iPaaS or an ESB, plus the cloud-native characteristics of a microservices framework like containerization, scalability and more.
Coupler is micro-integrator tool that enables users to visually model integration flows and deploy them as a containerized microservice (see schematic below). It offers an alternative, simpler method to build microservices using a low-code/no-code approach by providing building blocks to model, map and integrate external data sources and applications. Its containerization adds high scalability and extensibility.
Here are Coupler’s key features:
- Support for the representational state transfer (REST) set of architectural principles, the simple object access protocol (SOAP), Secure Socket Layer (SSL), Transport Layer Security (TLS) and IoT protocols.
- Protocol conversion
- Hybrid, cloud and multi-environment support
- Real-time error handling
- Transaction management
- Visual model for flow design
- A library of pre-built nodes
- Software-development kit (SDK) to develop custom connectors
How Coupler can be containerized and deployed as a microservice is shown below. Containers can package an application with all the parts it needs, such as libraries and other dependencies, and ship them out as one package. Docker is a tool designed to make it easier to create, deploy, and run applications using containers.
A container orchestration tool is used to deploy and manage containers, providing container runtime and orchestration, container-centric infrastructure orchestration, self-healing mechanisms, service discovery and load balancing. Container orchestration is used to deploy, scale, manage and compose application containers across clusters of hosts. Kubernetes and OpenShift are common, open-source platforms for container orchestration.
The aims of container orchestration are faster deployment and start times, with easier management and being able to scale containers across various operating systems. These attributes help make better use of computing resources, and simplify and speed up configuration and security. It also provide capabilities for multi-cloud platforms.
Coupler can be easily integrated with containers and their orchestration tools. The diagram below illustrates how Coupler can integrate with a legacy system and microservices built on containers (Docker) and be deployed using a container orchestration platform (Kubernetes).
In most enterprises, there will be a co-existence of different integration tools and frameworks to simultaneously support legacy integration technologies (such as ESB and messaging middleware) and modern, cloud-native and cloud-centric integration technologies like iPaaS and microservices.
Analysts call this model the ‘hybrid-integration landscape’ and Coupler is a perfect fit for this landscape, offering a simpler, alternative way to create microservices that can be deployed immediately.