No items found.

Inline Framing Microservices API Calls: The Benefits and Challenges

Inline Framing Microservices API Calls: The Benefits and Challenges.

Written by
June 15, 2022

Inline Framing Microservices API Calls The Benefits and Challenges

Image Source: Unsplash‍

When it comes to developing an application with microservices, there is a lot to consider. One important factor is how to effectively make API calls between services. Inline framing is an essential practice that helps developers create an efficient and secure architecture for microservice communication. This guide provides an introduction to inline framing and how it can be used to effectively make API calls between microservices. It outlines the benefits of inline framing and provides practical tips and best practices for implementing it in your application. With the information provided here, developers will be well-equipped to build a reliable, secure, and performant system for their microservice application.

What is inline framing?

Inline framing is a communication pattern that uses the same channels for request and response messages. This is best illustrated through an example. Let’s say that you have a microservice that needs to send a request to another microservice to get some data. The best way to make this request would be to send a message via the same channel that this data was previously sent to the sending microservice. If we were sending data over HTTP in XML, then you’d want to use HTTP in XML to send the request. This is inline framing. It is essentially using the same protocol, port, and type of framing for both request and response messages. In this case, you’d be sending and receiving XML with the same content type, protocol, and port.

Benefits of using inline framing

Inline framing is an essential communication pattern that helps deliver a number of benefits when it comes to building a microservice architecture. These benefits include security, performance, and portability. Security - One of the largest benefits of inline framing is that it makes it harder for malicious actors to break into your system. This is because when you are using the same protocol, port, and framing for both request and response messages, it becomes much more challenging to spoof a message. This is because the attacker would have to know the exact details of the protocol and framing mechanisms in order to effectively spoof a message. Performance - One reason to use inline framing is that it is more performant than other message-exchange patterns. This is because it uses fewer network hops. Portability - Another benefit of inline framing is that it can make it easier to move your application to another system. This is because the same framing used for messages can be used for the new system.

Steps for implementing inline framing

If you are building a new application, you should consider using inline framing from the beginning. If you are building an application that already uses a microservice architecture, you can retrofit your system to use inline framing. First, decide whether you want to use a synchronous or asynchronous message exchange. The most common synchronous patterns are Remote Procedure Calls (RPCs) and Message-driven Architecture (MDA). The most common asynchronous patterns are asynchronous Remote Procedure Calls (ARPCs) and Asynchronous Message-driven Architecture (AMDA). Once you have decided on the pattern, you need to decide which ports and protocols to use.

Best practices for inline framing

The following are some best practices to keep in mind when implementing inline framing in your microservice application. - Keep it simple - Try to keep things as simple as possible. The more complicated the framing is, the more difficult it will be to debug, maintain, and understand. - Use a standard - You can make the framing more robust by using a standard. This could be a standard developed by a community, a standard from a company, or a standard you create yourself. - Use consistent framing - Make sure that you are using consistent framing across all of your microservices. This will make it easier to debug problems and also move the application to another system. - Use framing to enforce policy - Framing can also be used to enforce security and policy rules. For example, you could use it to require that all messages be encrypted, or only certain ports be used. - Use framing to route between services - You can use framing to route messages between services. For example, you can use a network routing table to route messages to a specific port. This can be helpful if you have a service that needs to be accessed by multiple applications.

Examples of inline framing

Let’s say you have a microservice architecture that is composed of three microservices. The first microservice is responsible for getting customer data from an external API, the second microservice sends customer data to an external API, and the third microservice is responsible for sending data to a message queue. In this scenario, the first microservice is responsible for getting customer data from the external API. This microservice is going to be sending an HTTP request to the API, so the first microservice will also be receiving an HTTP request from the API. For this reason, the first microservice will use HTTP in both the request and response. The same port used to send the request will also be used to receive the response. The other two microservices will also be using HTTP in both the request and response because they are communicating with the first microservice. This is a basic example of how to use inline framing.

Alternatives to inline framing

Inline framing is the most common and recommended way to make API calls between microservices. However, there are a couple of alternatives that you can consider. These include using REST over HTTP and using a message bus. REST over HTTP - In some cases, it is possible to use just REST over HTTP to make API calls. However, this is generally not recommended as it does not provide the same level of security as inline framing does. Message bus - You could also use a message bus. However, message buses can be more difficult to scale and manage than inline framing.


When building a microservice application, you need to consider the best way to communicate between microservices. Inline framing is an essential communication pattern that provides a number of benefits when it comes to building a microservice architecture. Using a standard, reliable, and secure communication pattern like inline framing can help you build a reliable and secure system.

Get started with HapPhi today

Access all HapPhi features free with 5 free GB, then decide whether you love HapPhi or want to marry HapPhi.

First 1000 people on the list get 100 free tokens.

Thank you! Your submission has been received!
Oops! Something went wrong while submitting the form.