kentoh - Fotolia


Achieve reactive microservices architecture with minimal effort

Reactive systems philosophy lends itself to microservices architecture because it stresses four core principles of responsivity, resilience, elasticity and message-driven communication.

When it comes to program design and implementation, a reactive approach to microservices refers to reactive systems architecture, and it is actually something quite proactive, despite its name.

Reactive systems architecture is based on a philosophy of design -- established in the Reactive Manifesto -- that emphasizes consistently rapid response along with a high degree of fault tolerance, flexibility and scalability. Reactive design achieves these goals by applying four basic principles: responsivity, resilience, elasticity and message-driven communication.

What is a reactive microservices architecture?

Each of the four primary principles of reactive systems lends itself to microservices architecture. In many ways, microservices-based design is considered both the most complete expression of and the most natural platform for reactive design principles. By adhering to these principles, a reactive microservices architecture isolates failed components, communicates asynchronously, performs autonomously and sustains mobility.


High responsivity should already be an essential trait of microservices applications, and if it isn't, there may be a fundamental design problem. The Reactive Manifesto calls not only for rapid response, but also for consistency in the speed of response. This responsivity is important both in terms of users' needs and to maintain the system in a healthy state, since it enables the rapid detection, identification and handling of errors.

Microservices architecture tends to minimize response time by eliminating or reducing overhead -- the limits of which are determined by the responsivity of the individual microservices, rather than that of a monolithic application -- and by providing multiple instances of individual microservices based on demand.

A microservices-based application can meet the reactive approach's standard for responsivity by making sure to identify and eliminate potential bottlenecks at the architecture level and by deploying and orchestrating sufficient instances of each microservice. This will effectively provide consistent and high response times based on user traffic and activity patterns.


Resilient systems continue to function even when they encounter serious problems. According to the standards of reactive systems, proper resilience consists of continued responsivity, recovery from failure and continued availability of components that are not directly affected by a failure while the affected components recover.

Microservices were designed exactly for this level of resilience. Successful microservices design requires services to be functionally isolated in discrete components -- both at the microservices level and higher -- so that the damage from failure remains within component boundaries. In addition, reactive standards require that a separate component handles the recovery of failed components.

Orchestration tools are key elements in supporting resilience, as they detect a lack of response from a failed microservice and direct traffic to responsive instances of the required services. Above all, a responsive reactive microservices architecture means that sufficient instances of a given microservice are available, even when there is a relatively high rate of failure among individual services.


If developers follow good microservices design standards for their application architectures, then they are already more than halfway toward the goals of the Reactive Manifesto.

Built-in rapid response scalability is yet another capability that's required for all microservices-based applications. Systems should deploy microservices in response to demand, not just for overall traffic, but also for specific services. In a microservices environment, the speed at which this happens should effectively match the speed at which user demand fluctuates.

To be fully consistent with reactive standards, incorporate real-time performance and demand monitoring and analytics in order to predict changes in demand and automatically scale to meet those changes. These proactive features are also a perfect example of how the reactive moniker is truly contradictory.

Message-driven communication

Communication between components is as fundamental to a functioning reactive microservices architecture as the internal behavior of the components. The Reactive Manifesto calls for asynchronous message passing as the basic standard of communication between components. This establishes a system of communication that is independent of hardware or location and that the orchestration and management system can use in handling infrastructure-level tasks, such as failure response, scaling, load balancing and control of data traffic.

The discrete nature of microservices makes this kind of communication a practical necessity; reactive standards provide a framework for systematic, service-oriented and infrastructure-friendly message passing.

If developers follow good microservices design standards for their application architectures, then they are already more than halfway toward the goals of the Reactive Manifesto. Fulfill your application's full potential for responsivity, resilience, scalability and internal efficiency of operation by going all-in on the reactive approach.

Dig Deeper on Application development and design

Software Quality
Cloud Computing