Microservices Architectural Style Research Articles

A distributed tracing pipeline for improving locality awareness of microservices applications

AbstractThe microservices architectural style aims at improving software maintenance and scalability by decomposing applications into independently deployable components. A common criticism about this style is the risk of increasing response times due to communication, especially with very granular entities. Locality‐aware placement of microservices onto the underlying hardware can contribute to keeping response times low. However, the complex graphs of invocations originating from users' calls largely depend on the specific workload (e.g., the length of an invocation chain could depend on the input parameters). Therefore, many existing approaches are not suitable for modern infrastructures where application components can be dynamically redeployed to take into account user expectations. This paper contributes to overcoming the limitations of static or off‐line techniques by presenting a big data pipeline to dynamically collect tracing data from running applications that are used to identify a given number of microservices groups whose deployment allows keeping low the response times of the most critical operations under a defined workload. The results, obtained in different working conditions and with different infrastructure configurations, are presented and discussed to draw the main considerations about the general problem of defining boundary, granularity, and optimal placement of microservices on the underlying execution environment. In particular, they show that knowing how a specific workload impacts the constituent microservices of an application, helps achieve better performance, by effectively lowering response time (e.g., up to a reduction), through the exploitation of locality‐driven clustering strategies for deploying groups of services.

MicroProf : Code-level Attribution of Unnecessary Data Transfer in Microservice Applications

The microservice architecture style has gained popularity due to its ability to fault isolation, ease of scaling applications, and developer’s agility. However, writing applications in the microservice design style has its challenges. Due to the loosely coupled nature, services communicate with others through standard communication APIs. This incurs significant overhead in the application due to communication protocol and data transformation. An inefficient service communication at the microservice application logic can further overwhelm the application. We perform a grey literature review showing that unnecessary data transfer is a real challenge in the industry. To the best of our knowledge, no effective tool is currently available to accurately identify the origins of unnecessary microservice communications that lead to significant performance overhead and provide guidance for optimization. To bridge the knowledge gap, we propose MicroProf , a dynamic program analysis tool to detect unnecessary data transfer in Java-based microservice applications. At the implementation level, MicroProf proposes novel techniques such as remote object sampling and hardware debug registers to monitor remote object usage. MicroProf reports the unnecessary data transfer at the application source code level. Furthermore, MicroProf pinpoints the opportunities for communication API optimization. MicroProf is evaluated on four well-known applications involving two real-world applications and two benchmarks, identifying five inefficient remote invocations. Guided by MicroProf , API optimization achieves an 87.5% reduction in the number of fields within REST API responses. The empirical evaluation further reveals that the optimized services experience a speedup of up to 4.59×.

Actor-Driven Decomposition of Microservices through Multi-level Scalability Assessment

The microservices architectural style has gained widespread acceptance. However, designing applications according to this style is still challenging. Common difficulties concern finding clear boundaries that guide decomposition while ensuring performance and scalability. With the aim of providing software architects and engineers with a systematic methodology, we introduce a novel actor-driven decomposition strategy to complement the domain-driven design and overcome some of its limitations by reaching a finer modularization yet enforcing performance and scalability improvements. The methodology uses a multi-level scalability assessment framework that supports decision-making over iterative steps. At each iteration, architecture alternatives are quantitatively evaluated at multiple granularity levels. The assessment helps architects to understand the extent to which architecture alternatives increase or decrease performance and scalability. We applied the methodology to drive further decomposition of the core microservices of a real data-intensive smart mobility application and an existing open-source benchmark in the e-commerce domain. The results of an in-depth evaluation show that the approach can effectively support engineers in ( i ) decomposing monoliths or coarse-grained microservices into more scalable microservices and ( ii ) comparing among alternative architectures to guide decision-making for their deployment in modern infrastructures that orchestrate lightweight virtualized execution units.

Architecture for IoT applications based on reactive microservices: A performance evaluation

The Internet has evolved from a network interconnecting computers to a complex ecosystem integrating devices of the most varied types, and enabling the amalgamation of the physical and virtual worlds. Integrating these heterogeneous devices fosters novel services and applications that generate value-added information and actionable knowledge for the end-user. Several challenges are involved in the design and building of IoT ecosystems, which have fostered research in the field, in search of patterns, guidelines, methods and tools that support such activities. In terms of architectural patterns, the microservice architectural style has been increasingly adopted in the development of IoT applications and services. Its adoption promotes some essential properties in IoT, such as scalability and extensibility. As there are always tradeoffs involved in every architectural decision, it is important to analyze whether the benefits brought by the use of microservices do not come at the expense of some loss or degradation of application performance. Recent research has analyzed the performance interference of microservices based on edge computing applications. However, a comprehensive assessment of the performance impact of characteristics inherent to the use of reactive microservices on IoT applications is still missing in the literature. In this paper, we present an experimental evaluation of the performance of IoT applications that make use of an architecture based on reactive microservices. The architecture was proposed by our group in a previous work and was tailored for reliable IoT applications running at the edge of the network. The experiments presented in this paper analyze the application performance based on various benchmark scenarios. In addition, we performed load and scalability testing of an IoT application that adopts the architecture components in a hybrid scenario (real devices and emulated devices). The results obtained were promising. The architecture had a good response to the increase in the workload, not presenting errors, crashes or instabilities due to the increase in IoT data traffic. Moreover, analyzing the overhead generated by the architecture components, there was no performance reduction or service unavailability. Such results point to the fact that the adoption of microservices in the construction of IoT systems can bring effective benefits without jeopardizing their performance due to eventually generated overheads.

Kubernetes in Microservices

The move towards the microservice grounded armature is well underway. In this architectural style, small and approximately coupled modules are developed, stationed, and gauged singly to compose pall-native operations. still, for carrier- grade service providers to resettle to the microservices architectural style, vacuity remains a concern. Kubernetes is an open source platform that defines a set of structure blocks which inclusively give mechanisms for planting, maintaining, spanning, and healing containerized microservices. therefore, Kubernetes hides the complexity of microservice unity while managing their vacuity. In this paper, we probe further infrastructures and conduct further trials to estimate the vacuity that Kubernetes delivers for its managed microservices. We present different infrastructures for public and private shadows. We estimate the vacuity attainable through the mending capability of Kubernetes. We probe the impact of adding redundancy on the vacuity of microservice grounded operations. We conduct trials under the dereliction configuration of Kubernetes as well as under its most responsive bone . We also perform a relative evaluation with the Vacuity operation Framework( AMF), which is a proven result as a middleware service for managing high- vacuity. The results of our examinations show that in certain cases, the service outage for operations managed with Kubernetes is significantly high

From legacy to microservices: A type‐based approach for microservices identification using machine learning and semantic analysis

AbstractThe microservices architecture (MSA) style has been gaining interest in recent years because of its high scalability, ability to be deployed in the cloud, and suitability for DevOps practices. While new applications can adopt MSA from their inception, many legacy monolithic systems must be migrated to an MSA to benefit from the advantages of this architectural style. To support the migration process, we propose MicroMiner, a microservices identification approach that is based on static‐relationship analyses between code elements as well as semantic analyses of the source code. Our approach relies on machine learning (ML) techniques and uses service types to guide the identification of microservices from legacy monolithic systems. We evaluate the efficiency of our approach on four systems and compare our results to ground‐truths and to those of two state‐of‐the‐art approaches. We perform a qualitative evaluation of the resulted microservices by analyzing the business capabilities of the identified microservices. Also a quantitative analysis using the state‐of‐the‐art metrics on independence of functionality and modularity of services was conducted. Our results show the effectiveness of our approach to automate one of the most time‐consuming steps in the migration of legacy systems to microservices. The proposed approach identifies architecturally significant microservices with a 68.15% precision and 77% recall.

Microservices Identification in Monolith Systems: Functionality Redesign Complexity and Evaluation of Similarity Measures

As monolithic applications grow in size and complexity, they tend to show symptoms of monolithic hell, such as scalability and maintainability problems. To help suppressing these problems, the microservices architectural style is applied. However, identifying the services within the monolith is not an easy task, and current research approaches emphasize different qualities of microservices. In this paper we present an approach for the automatic identification of microservices, which minimizes the cost of the monolith’s functionalities redesign. The decompositions are generated based on similarity measures between the persistent domain entities of the monolith. An extensive analysis of the decompositions generated for 121 monolith systems is done. As result of the analysis we conclude that there is not a similarity measure, neither a combination of similarity measures, that provides better decomposition results in terms of complexity associated with the functionalities migration. However, we prove that it is possible to follow an incremental migration process of monoliths. Additionally, we conclude that there is a positive correlation between coupling and complexity, and that it is not possible to conclude on the existence of a correlation between cohesion and complexity.

An approach to modeling and simulating resiliency in multidisciplinary microservice networks

Microservice-based software networks consist of a large number of critical, multidisciplinary, and interdependent elements in which the failure of critical microservices will have a destructive effect on the system reliability and resiliency. We overcome this problem by identifying critical microservices that play a vital role and then propose a fault-tolerant candidate for each critical microservice. The approach finds critical microservices based on the proposed parameter-based greedy strategies and analyzes the vulnerability of the software design in terms of resiliency while removing the important microservices from the software network. We examine our proposed microservice architectural style to fit the requirements of a smart city in cloud-native applications using a new metric introduced in terms of a microservice runtime degree (RD) and aggregative importance links. The results show the decline rate of network efficiency is maximum with removing the nodes based on this new structural metric. Furthermore, the resilience loss triangle metric based on RD, which corresponds to the shaded area between the expected and full performance of the observed curves, will have a greater value than other metrics.

Authentication and Authorization in Microservices Architecture: A Systematic Literature Review

The microservice architectural style splits an application into small services, which are implemented independently, with their own deployment unit. This architecture can bring benefits, nevertheless, it also poses challenges, especially about security aspects. In this case, there are several microservices within a single system, it represents an increase in the exposure of the safety surface, unlike the monolithic style, there are several applications running independently and must be secured individually. In this architecture, microservices communicate with each other, sometimes in a trust relationship. In this way, unauthorized access to a specific microservice could compromise an entire system. Therefore, it brings a need to explore knowledge about issues of security in microservices, especially in aspects of authentication and authorization. In this work, a Systematic Literature Review is carried out to answer questions on this subject, involving aspects of the challenges, mechanisms and technologies that deal with authentication and authorization in microservices. It was found that there are few studies dealing with the subject, especially in practical order, however, there is a consensus that communication between microservices, mainly due to its individual and trustworthy characteristics, is a concern to be considered. To face the problems, mechanisms such as OAuth 2.0, OpenID Connect, API Gateway and JWT are used. Finally, it was found that there are few open-source technologies that implement the researched mechanisms, with some mentions of the Spring Framework.

Modeling Performance of Microservices Systems with Growth Theory

ContextThe microservices architectural style is gaining momentum in the IT industry. This style does not guarantee that a target system can continuously meet acceptable performance levels. The ability to study the violations of performance requirements and eventually predict them would help practitioners to tune techniques like dynamic load balancing or horizontal scaling to achieve the resilience property.ObjectiveThe goal of this work is to study the violations of performance requirements of microservices through time series analysis and provide practical instruments that can detect resilient and non-resilient microservices and possibly predict their performance behavior.MethodWe introduce a new method based on growth theory to model the occurrences of violations of performance requirements as a stochastic process. We applied our method to an in-vitro e-commerce benchmark and an in-production real-world telecommunication system. We interpreted the resulting growth models to characterize the microservices in terms of their transient performance behavior.ResultsOur empirical evaluation shows that, in most of the cases, the non-linear S-shaped growth models capture the occurrences of performance violations of resilient microservices with high accuracy. The bounded nature associated with this models tell that the performance degradation is limited and thus the microservice is able to come back to an acceptable performance level even under changes in the nominal number of concurrent users. We also detect cases where linear models represent a better description. These microservices are not resilient and exhibit constant growth and unbounded performance violations over time. The application of our methodology to a real in-production system identified additional resilience profiles that were not observed in the in-vitro experiments. These profiles show the ability of services to react differently to the same solicitation. We found that when a service is resilient it can either decrease the rate of the violations occurrences in a continuous manner or with repeated attempts (periodical or not).ConclusionsWe showed that growth theory can be successfully applied to study the occurences of performance violations of in-vitro and in-production real-world systems. Furthermore, the cost of our model calibration heuristics, based on the mathematical expression of the selected non-linear growth models, is limited. We discussed how the resulting models can shed some light on the trend of performance violations and help engineers to spot problematic microservice operations that exhibit performance issues. Thus, meaningful insights from the application of growth theory have been derived to characterize the behavior of (non) resilient microservices operations.

A Framework for Implementing Micro Frontend Architecture

Web applications are an indispensable part of any enterprise information system. In the recent past, we have seen maturity in technologies that enable the separation of frontend and backend, with the backend adopting microservices architecture style. The front end has maintained the traditional monolithic architecture. Micro frontends have come up as a solution to the conventional monolithic frontend, which has received much attention. Still, so far, there is no straightforward approach to implementation that satisfies different practical requirements of a modern web application. This paper proposes an architectural pattern for implementing micro frontends to address challenges experienced in earlier implementations, such as inconsistent user experience, managing security, and complexity. We developed two simple web applications, one using the proposed architectural pattern, and another using the monolithic architecture and compared the performance. We used Google lighthouse to measure the performance of two applications. The landing page for the application developed using micro frontend architecture showed a higher performance score of 99 against 86 for a similar page in an application developed using the monolithic architecture. The proposed framework showed outstanding performance in handling the issues of consistent layout with a Cumulative Layout shift of 0. Breaking down the frontend with lazy loading of micro frontends improved the web application's performance, while the proposed framework reduced development complexity. However, more research is needed to provide seamless integration of micro frontends into the main application with the support of loading shared libraries in the main application; this will significantly reduce the payload size.

Monitoring-Aware Optimal Deployment for Applications Based on Microservices

Modern cloud applications are required to be distributed, scalable, and reliable. The microservice architectural style enables developers to achieve this goal with reduced effort. Nonetheless, microservices deployment is not trivial due to the heterogeneity of the microservices in terms of both functional and non-functional requirements. This is also true when considering the monitoring requirements that are specific to each microservice and must be satisfied in order to enable the verification of the application objectives satisfaction. However, not all providers offer the same set of metrics with the same quality. The goal of this paper is to provide an approach for supporting the deployment of microservices in multi-cloud environments focusing on the Quality of Monitoring. Adopting a multi-objective mixed integer linear optimisation problem, our approach supports the application owner in finding the optimal deployment for satisfying all the constraints and maximising the quality of monitored data, while minimising the costs. To this end, a knowledge base is introduced to mediate between the perspectives of the cloud provider and the application owner, while a Bayesian Network is adopted to enhance the provider’s monitoring capabilities by estimating metrics requested by the application owners that the cloud provider is not able to monitor.

A Prescriptive Model for Migration to Microservices Based on SDLC Artifacts

Microservices architectural style is gaining popularity in industry and is being widely adopted by large corporations like Amazon, Netflix, Spotify, eBay, and many more. Several other organizations are also preferring to migrate their existing enterprise scale applications to microservices architecture. Researchers have proposed various approaches for microservices decomposition to be used in migrating or rebuilding a monolithic application to microservices. Applying any available approach to an existing monolithic application is not a straightforward decision; thus, there is a need for guidelines that assist in the migration process. There are various challenges in a migration process because different migration approaches use different sets of input data to identify microservices. Since the available migration techniques are not structured, logically, selection of an appropriate migration strategy is a difficult decision for any system architect. So, it is a recurrent open research question – which migration technique should be adopted to get microservices for a legacy monolithic application? This paper addresses this research challenge by examining existing approaches for microservices migration and groups them based on software development life cycle (SDLC) artifacts. Our research also proposes a microservices prescriptive model (MPM) from the existing prominent microservice migration techniques. This model provides recommendation (1) for refactoring an existing legacy system to microservices, and (2) for new microservices development projects. Our study also helps in gaining more insight about greenfield and brownfield development approaches in microservices applications. Moreover, researchers and practitioners of the field can benefit from this model to further validate their migration approaches based on the available system artifacts.

Deployment and communication patterns in microservice architectures: A systematic literature review

Context:Microservice is an architectural style that separates large systems into small functional units to provide better modularity. A key challenge of microservice architecture design frequently discussed in the literature is the identification and decomposition of the service modules. Besides this, two other key challenges can be identified, including the deployment of the modules on the corresponding execution platform, and adopted communication patterns. Objective:This study aims to identify and describe the reported deployment approaches, and the communication platforms for microservices in the current literature. Furthermore, we aim to describe the identified obstacles of these approaches as well as the corresponding research directions. Method:A systematic literature review (SLR) is conducted using a multiphase study selection process in which we reviewed a total of 239 papers. Among these, we selected 38 of them as primary studies related to the described research questions. Results:Based on our study, we could identify three types of deployment approaches and seven different communication patterns. Moreover, we have identified eight challenges related to the deployment and six challenges related to the communication concerns. Conclusion:Our study shows that in addition to the identification of modules, the deployment and communication approaches are equally crucial for a successful application of the microservice architecture style. Various deployment approaches and communication patterns appear to be useful for different contexts. The identified research directions in the literature study show that still more research is needed to cope with the current challenges.

A systematic gray literature review: The technologies and concerns of microservice application programming interfaces

AbstractThe microservice application programming interface (API) becomes a growing concern in the IT industry, as a result of the increasing usage of microservice architecture style. There exist many successful practices among companies, communities, and so on. In contrast, the related academic research is still at an early stage, where lacks an overview of technologies for the design, implementation and operation of microservice APIs, as well as a general picture of concerns. In this article, we try to fill this gap by eliciting the technologies and concerns on microservice APIs and establishing a microservice API description model, with the intention of aiding researchers to gain an overview of this field and find possible research directions, and helping practitioners to better understand microservice APIs and be aware of the existing approaches for daily work. Twelve academic papers and 38 gray literatures are selected and analyzed following the systematic literature review approach. Besides, we give our observations from this study. For researchers, our findings show the most cared concerns of practitioners, and our description model can be used as a reference for new theories, experiments, and future research dimensions. For practitioners, our study can be used as a guideline for microservices experimentation and a starting point for practice.

Towards a Software Architecture for Internet of Things based System of Systems

The Smart City vision is becoming a reality with the widespread adaption of Internet of Things (IoT). In this context, several architectural styles like service-oriented and microservice architecture have widely been used in the development of IoT-based systems. However, less amount of work is done for IoT-based system of systems. The recognition of system of systems (SoS) as a system with its unique features such as operationally and administratively independence has been considered a new trend of distributed software systems. The collaboration of the SoS independent system helps to build a larger and more complex system. The characteristics and domain constraints of SoS make some quality attributes critical, especially when SoS is based on IoT. These quality attributes should be considered while designing such systems. To fill this gap, this article presents a novel software architecture based on microservices architectural style, while considering the important quality attributes required for IoT-based SoS. The applicability of the proposed architecture is demonstrated through a smart city case study. In addition, the design quality is evaluated in terms of scalability and maintainability. The results show that the design developed using the proposed architecture is better in terms of these two quality attributes than the existing approach.

Towards Microservice Identification Approaches for Architecting Data Science Workflows

Abstract In order to support fast development cycles and deploying software components in productive environments, there are three crucial trends in data science. These are agile process models, development of many technologies and increasing usage of cloud platforms. Therefore, effective architectures are needed to support this trend in data science context. This paper explores and evaluates first approaches for, why and how microservice architecture style can support fast development cycles for data science workflows. Microservices are becoming a popular architectural style for designing modern applications due to several advantages like scalability, reliability and maintainability. First, this paper points out the research gap on why microservices could be a suitable way to design data science workflows. Second, it defines relevant research questions for future research that addresses challenges of the microservice architectural style in the data science context. An essential prerequisite for this architecture style is to identify the “right context” of a microservice for data science workflows.

Building orchestrated microservice systems using declarative business processes

The microservices architecture style proposes a solution for efficiently scaling computational resources and solving other problems presented in the traditional monolithic architecture. Despite providing benefits, microservices bring challenges when there is a need to manage business processes that expand across the boundaries of an individual microservice. Traditional approaches such as workflows are not suitable to manage business processes in microservice systems, and existing solutions have limitations in dealing with the dynamic location of microservices. To fill that gap, this work proposes the use of declarative business processes to facilitate the modeling and execution of microservice orchestration from the perspective of data flow processes. To this end, we use Beethoven, a platform composed of a reference architecture, and a domain-specific language for expressing microservice communication flows. Finally, we demonstrate the feasibility of Beethoven in orchestrating an existing microservice application and assess its impact on the performance of the orchestrated application.

Research on Microservice Application Performance Monitoring Framework and Elastic Scaling Mode

Compared with the traditional monolithic architecture, the microservice architecture style divides a system into different microservices which run in the distributed system. The complex dependencies between services bring new challenges to the monitoring analysis and quality assurance of system performance. According to the characteristics of microservice application, a performance monitoring framework based on big data is designed in this paper. It monitors and controls the microservice performance through data collection, big data storage, elastic scaling management, integrated scheduling and so on. Furthermore, an elastic scaling mode based on time sliding window and scene driven is proposed. Experiments show that this mode could realize resource expansion prediction and resources saving. This research is helpful to real-time monitoring and continuous optimization for microservices, which will effectively promote the integration process of development, testing and maintenance for microservice application in SGCC (State Grid Corporation of China).

Implementing secure applications in smart city clouds using microservices

Smart Cities make use of ICT technology to address the challenges of modern urban management. The cloud provides an efficient and cost-effective platform on which they can manage, store and process data, as well as build applications performing complex computations and analyses. The quickly changing requirements in a Smart City require flexible software architectures that let these applications scale in a distributed environment such as the cloud. Smart Cities have to deal with huge amounts of data including sensitive information about infrastructure and citizens. In order to leverage the benefits of the cloud, in particular in terms of scalability and cost-effectiveness, this data should be stored in a public cloud. However, in such an environment, sensitive data needs to be encrypted to prevent unauthorized access. In this paper, we present a software architecture design that can be used as a template for the implementation of Smart City applications. The design is based on the microservice architectural style, which provides properties that help make Smart City applications scalable and flexible. In addition, we present a hybrid approach to securing sensitive data in the cloud. Our architecture design combines a public cloud with a trusted private environment. To store data in a cost-effective manner in the public cloud, we encrypt metadata items with CP-ABE (Ciphertext-Policy Attribute-Based Encryption) and actual Smart City data with symmetric encryption. This approach allows data to be shared across multiple administrations and makes efficient use of cloud resources. We show the applicability of our design by implementing a web-based application for urban risk management. We evaluate our architecture based on qualitative criteria, benchmark the performance of our security approach, and discuss it regarding honest-but-curious cloud providers as well as attackers trying to access user data through eavesdropping. Our findings indicate that the microservice architectural style fits the requirements of scalable Smart City applications while the proposed security approach helps prevent unauthorized access.