XenonStack Recommends


Inter-Process Communication in Microservice | Quick Guide

Navdeep Singh Gill | 09 March 2022

Inter-Process Communication in Microservice

Introduction to Microservices

Microservices architecture manages each application as an independent service that can be modified, updated or downgraded without interrupting the entire application. Applications were traditionally designed as pieces of monolithic software. Adding new features requires redesigning and updating everything from process and communication to security within the app. Traditional monolithic applications have longer life cycles, are constantly updated, and often affect the entire application. This costly and complex process delays development and updates in the development of business applications.

Architecture is designed to solve this problem. All services are individually created and used separately from each other. This architectural style allows measurement services based on specific business needs. Services can be changed quickly without touching other parts of the app. Continuous delivery is one of the many benefits of microservices.

A form of service-oriented architecture style wherein applications are built as a collection of different smaller services rather than one whole app. Click to explore about, Java Microservices for Scalable Applications

What is Inter-process Communication in a Microservice Architecture?

The parts are intertwined using the language-level method or function calls in a monolithic application. In contrast, a microservices-based application is a distributed system that works on multiple machines. Each service event is usually a process. Therefore, the following diagram shows that services should be integrated using the inter-process communication (IPC) method.

What is the interaction styles in Microservice Architecture?

When choosing an IPC service method, it is helpful to think first about how the services work together. There is a variety of customer interaction styles of service. They can be divided into two categories. The first dimension is one-to-one or more-to-more interaction:

  • One-to-one - A single service model processes each client request.
  • One to many - Each request is processed by multiple service conditions.

The second major whether the interaction is synchronized or asynchronous:

  • Synchronous - The client is waiting for a timely response from the service and may be blocked while waiting.
  • Asynchronous - The client does not block while waiting for a response, and the response, if any, is not immediately sent.

There are the following types of one-to-one interactions:

  • Request / Response - The client requests a service and waits for a response. The client expects the response to arrive on time. In a network-based application, the application string may be blocked while waiting.
  • Notification (a.k.a. one way request) - The client sends a request to the service, but no response is expected or sent.
  • Unsolicited request/response - Client sends a request to the service, which responds accordingly. The client do not block while waiting and is designed to assume that response may not come immediately.

There are the following types of one-to-many interactions:

  • Publish / Subscribe - The client publishes a notification message used by zero or more exciting services.
  • Publish / inconsistent responses - The client publishes a request message and waits for a certain amount of time to receive responses from interested services.

Each service usually uses a combination of these interactive styles. For some services, one IPC method is sufficient. Some services may require the use of a combination of IPC methods. The following diagram shows how resources in a taxi stand can be shared when a user requests a trip.

Services that use a combination of notifications, request/response, and publishing/subscription. For example, a passenger smartphone sends a notification to the Trip Management service to request a download. The Travel Management Service verifies that the passenger account is activated through request/response to request Passenger Service. The Travel Management Service has been touring and publishing/subscriptions to notify other services, including Dispatcher, making the driver available.

Microservices are the Single Responsibility Principle at the codebase level. Click to explore about, Java Serverless Microservices

What are APIs?

A service API is a contract between a service and its customers. In addition to your choice of IPC method, it is important to clearly define the service API using a specific interface language identifier (IDL). There is also a good deal of controversy over using the first API to define services. You start the service development by writing a description of the interface and reviewing it with client developers only after duplicating the API description when you use the service. Doing this design in advance increases your chances of building a service that meets the needs of its customers.

As you will see later in this blog, the nature of the API definition depends on which IPC method you use. When using a message, the API contains message channels and message types. The API contains URLs and request formats and responses if you are using HTTP. Later, we will explain some of the IDLs in detail.

What is the future of APIs?

The service API changes from time to time. Changing the API and updating all callers in a monolithic application is usually simple. In a microservices-based application, it is very difficult, even if all your API clients are other services in the same app. You usually cannot force all clients to upgrade when you are stuck with the service. Also, you will be increasingly releasing new service versions so that older and newer versions of the service will work simultaneously. There must be a strategy to deal with these problems.

How you handle API changes depends on the size of the change. Some minor changes and reversals are consistent with previous versions. You can, for example, add attributes to the requests or responses. It makes sense to design clients and services to maintain a strong goal. Clients using the old API should continue to work with the new version of the service. The service provides the default values ​​for missing application attributes, and customers experience additional accounting qualities. It is essential to use the IPC method and message format to modify your APIs easily.

Sometimes, however, you have to make major changes that are not compatible with the API. Since you will not be able to force clients to upgrade quickly, the service should support older API versions for some time. If you are using an HTTP-based method such as REST, one method is to embed the version number in the URL. Each service event may handle multiple versions at the same time. Alternatively, you can use different situations to handle a particular version.

A very High-performance API gateway, it's Open Source in nature and provides a very reliable entry point for clients to microservices. Click to explore about, KrakenD API Gateway for Microservices

What are the IPC Technologies?

There are many different IPC technologies to choose from. Services may use request-based communication methods such as HTTP-based REST or Thrift. Alternatively, they can use incompatible communication methods based on messages such as AMQP or STOMP. There are also different types of message formats. Services can use human-readable formats based on scripts such as JSON or XML. Alternatively, they can use a binary (highly efficient) format such as Avro or Protocol Buffers. Later we will look at the Synchronous IPC methods, but first, let's talk about the Asynchronous IPC processes.

Asynchronous, Message‑Based Communication

When using a message, processes are interacted by exchanging messages. The client requests the service by sending them a message. When a service is expected to respond, it sends a different message back to the client. Since communication is inconsistent, the client does not prevent you from waiting for a response. Instead, the client is written, considering that the response will not be accepted immediately.

The message contains the titles (metadata-like sender) and body of the message. Messages are exchanged via channels. Any number of producers can send messages to the channel. Similarly, any number of customers can receive messages from the channel. There are two types of channels, point-to-point and publish-subscription. A point-by-point channel conveys a message to consumers exactly reading the channel. Services use the point and point channels of the previously defined interaction styles. The publishing channel delivers individual messages to all attached buyers. Apps use publishing channels to get the collaborative styles described above.

Synchronous, Request/Response IPC

When using a compliant IPC method, based on request/response, the client sends a request to the service. The service is processing the request and returning the response. The request string is blocked for many clients while waiting for a response. Some clients may use an unconventional, event-driven client code possibly installed on Futures or Rx Observables. However, unlike texting, the client assumes that the response will be timely. There are many protocols to choose from. Two popular protocols are REST and Thrift. Let's first look at the REST.


It is fashionable to develop APIs in the RESTful style. REST is an IPC machine (almost always) that uses HTTP. The main concept in REST is a resource, usually representing a business object such as a Customer or Product or a set of business items. REST uses HTTP actions to run applications identified using a URL. For example, the GET request returns a representation of the application, which may be an XML document or a JSON object. Post request creates a new app, and PUT request updates the app.

Java vs Kotlin
Managed services for Enterprises to facilitate Automated Security Alerts, Single Click Deployments and Monitoring Solutions. Click for our Managed Services for Microservices


Microservices must communicate using a method of communication between processes. When designing how your services will communicate, you need to consider a variety of issues: how the services work together, how to specify the API for each service, how to change APIs, and how to handle minor failures. There are two types of IPC methods that can be used by microservices, compatible messaging and related application / response.