Microservices Architecture in DevOps

The Microservice Architecture Style (MSA) has emerged as a significant computing paradigm in software engineering, with companies increasingly restructuring their monolithic systems to enhance digital performance and competitiveness. However, the migration process, particularly the microservice identification phase, presents complex challenges that require careful consideration. This study aimed to provide developers and researchers with a practical roadmap for microservice identification during legacy system migration while highlighting crucial migration steps and research requirements. Through a systematic mapping study following Kitchenham and Petersen’s guidelines, we analyzed various microservice identification approaches and developed a middleweight ontology that can be queried for key inputs, data modeling, identification algorithms, and performance evaluation metrics. Our research makes several significant contributions: a comprehensive analysis of existing identification methodologies, a multi-dimensional framework for categorizing and evaluating approaches, an examination of current research trajectories and literature gaps, an ontological framework specifically designed for microservice identification, and an outline of pressing challenges and future research directions. The study concluded that microservice identification remains a significant barrier in system migration efforts, highlighting the need for more research focused on developing effective identification techniques that consider various aspects, including roles and dependencies within a microservice architecture. This comprehensive analysis provides valuable insights for professionals and researchers working on microservice migration projects.

Unveiling the microservices testing methods, challenges, solutions, and solutions gaps: A systematic mapping study

Microservice architecture (MSA) is a type of software and systems architecture that is based on the modularization principle. It proposes designing systems employing small-scaled, loosely coupled, and independently deployable microservices. There are several benefits of microservices architecture in terms of maintainability, scalability, and productivity which have led to rise in its popularity. Even though there are several studies about development in MSA, the studies on the quality of the microservice-based systems are limited. In this study, we propose a quality model based on fuzzy logic to measure and assess quality attributes of systems in MSA that can be used by software architects, developers, and project managers. We focus on maintainability of microservices because it is one of the most important quality attributes of software systems. We identified sub-characteristics and properties of microservices that affect maintainability, and constructed a hierarchical quality model based on ISO/IEC 250xy standard SQuaRE (System and Software Quality Requirements and Evaluation). Our fuzzy model measures maintainability of microservices in three levels, i.e., low, medium, and high. We provided a basis for the development and application of quality models in industrial practice as well as a basis for further extension. To demonstrate and evaluate our methodology, we used open-source applications designed in MSA. The results show that our method can assess maintainability of microservices realistically.

The microservices architecture is a set of small, autonomous services that can work together to form a single application that has seen widespread adoption by practitioners. However, deploying this architecture creates several technical challenges. This study examines the state of the art of microservices deployment in the literature, informing researchers and practitioners about the techniques and technologies used in the deployment of microservices and, practices used in the DevOps culture. We conducted a systematic mapping study driven by four research questions related to the deployment of microservices and DevOps practices, and 21 studies were identified from which information was synthesized using the meta-aggregation method. With the information synthesis, 43 findings were extracted and classified into seven categories. We can summarize the findings of this study as follows: (i) We identified the essential DevOps practices in the deployment of microservices. (ii) We defined the stack of technologies with the highest incidence in the studies. (iii) We found three groups of challenges in microservices deployment. (iv) Finally, we present a set of recommendations for microservices deployment.

SummaryContext: Software performance is crucial for ensuring the quality of software products. As one of the non‐functional requirements, the few efforts devoted to software performance have often been neglected until a later phase in the software development life cycle (SDLC). The lack of clarity of what software performance research literature is available prevents researchers from understanding what software performance research fields are available. It also creates difficulty for practitioners to adopt state‐of‐the‐art software performance techniques. Software performance research is not as organized as other established research topics such as software testing. Thus, it is essential to conduct a systematic mapping study as a first step to provide an overview of the latest research literature available in software performance. Objective: The objective of this systematic mapping study is to survey and map software performance research literature into suitable categories and to synthesize the literature data for future access and reference. Method: This systematic mapping study conducts a manual examination by querying research literature in noble journals and proceedings in software engineering in the past decade. We examine each paper manually and identify primary studies for further analysis and synthesis according to the pre‐defined inclusion criteria. Lastly, we map the primary studies based on their corresponding classification category. Results: This systematic mapping study provides a state‐of‐the‐art literature mapping in software performance research. We have carefully examined 222 primary studies out of 2000+ research literature. We have identified six software performance research categories and 15 subcategories. We generate the primary study mapping and report five research findings. Conclusions: Unlike established research fields, it is unclear what types of software performance research categories are available to the community. This work takes the systematic mapping study approach to survey and map the latest software performance research literature. The study results provide an overview of the paper distribution and a reference for researchers to navigate research literature on software performance.

Microservice architecture is becoming the de facto industry standard for building new enterprise applications. In order to remain competitive, companies have started to modernize their legacy monolithic systems by decomposing them into microservices. However, extracting microservices from legacy monolithic software is extremely complex task, which consists of many different issues such as microservices identification, code decomposition, communication establishment between decomposed microservices, independent deployment, data storage adaptation and etc. Although the topic of monolithic software migration into microservice architecture has already been explored by scientists and software engineers, it is a complex and relatively new research topic. The primary focus of most investigations is the microservice identification within monolith application as well as source code decomposition into microservices. A novel approach to migrate legacy monolithic applications into microservices is proposed in this paper. It includes not only code decomposition stage, but also covers communication establishment between microservices and data management.

The microservice architectural style is an emerging trend in software engineering that allows building highly scalable and flexible systems. However, current state of the art provides only limited insight into the particular security concerns of microservice system. With this paper, we seek to unravel some of the mysteries surrounding microservice security by: providing a taxonomy of microservices security; assessing the security implications of the microservice architecture; and surveying related contemporary solutions, among others Docker Swarm and Netflix security decisions. We offer two important insights. On one hand, microservice security is a multi-faceted problem that requires a layered security solution that is not available out of the box at the moment. On the other hand, if these security challenges are solved, microservice architectures can improve security; their inherent properties of loose coupling, isolation, diversity, and fail fast all contribute to the increased robustness of a system. To address the lack of security guidelines this paper describes the design and implementation of a simple security framework for microservices that can be leveraged by practitioners. Proof-of-concept evaluation results show that the performance overhead of the security mechanisms is around 11%.

Despite the importance of software qualities, they are not well understood, especially in the context of the interrelationships between qualities. A number of systematic mapping studies have been conducted prior to 2015 to summarize the literature on the topic and to identify research gaps. To provide a better understanding of the current state of the art, we conducted a systematic mapping study on relevant studies from 2015 to 2019 through a database search and a subsequent snowballing approach. In total, 18 studies were selected as the study subjects wherein we evaluated the types of software quality interrelationships and the qualities that comprise them. Based on our findings, we report on the progress made to address previously identified research gaps.

Cloud computing technologies are being used highly successfully in large-scale businesses. Therefore, it is useful for governments to adopt cloud-driven multi-channel, and multiple devices to offer their services such as e-tax, e-vote, e-health, etc. Since these applications require open, flexible, interoperable, collaborative, and integrated architecture, service-oriented architecture approach can be usefully adopted to achieve flexibility and multi-platform and multi-channel integration. However, its adoption needs to be systematic, secure, and privacy-driven. In this context, micro services architecture (MSA), a direct offshoot of SOA, is also a highly attractive mechanism for building and deploying enterprise-scale applications. This chapter proposes a systematic framework for cloud e-government services based on the cloud software engineering approach and suggests a cloud adoption model for e-government, leveraging the benefits of MSA patterns. The proposed model is based on a set of evaluated application characteristics that, in turn, support emerging IT-based technologies.

Debugging--the process of identifying, localizing and fixing bugs--is a key activity in software development . Due to issues such as non-determinism and difficulties of reproducing failures, debugging concurrent software is significantly more challenging than debugging sequential software. A number of methods, models and tools for debugging concurrent and multicore software have been proposed, but the body of work partially lacks a common terminology and a more recent view of the problems to solve. This suggests the need for a classification, and an up-to-date comprehensive overview of the area. This paper presents the results of a systematic mapping study in the field of debugging of concurrent and multicore software in the last decade (2005---2014). The study is guided by two objectives: (1) to summarize the recent publication trends and (2) to clarify current research gaps in the field. Through a multi-stage selection process, we identified 145 relevant papers. Based on these, we summarize the publication trend in the field by showing distribution of publications with respect to year, publication venues, representation of academia and industry, and active research institutes. We also identify research gaps in the field based on attributes such as types of concurrency bugs, types of debugging processes, types of research and research contributions. The main observations from the study are that during the years 2005---2014: (1) there is no focal conference or venue to publish papers in this area; hence, a large variety of conferences and journal venues (90) are used to publish relevant papers in this area; (2) in terms of publication contribution, academia was more active in this area than industry; (3) most publications in the field address the data race bug; (4) bug identification is the most common stage of debugging addressed by articles in the period; (5) there are six types of research approaches found, with solution proposals being the most common one; and (6) the published papers essentially focus on four different types of contributions, with "methods" being the most common type. We can further conclude that there are still quite a number of aspects that are not sufficiently covered in the field, most notably including (1) exploring correction and fixing bugs in terms of debugging process; (2) order violation, suspension and starvation in terms of concurrency bugs; (3) validation and evaluation research in the matter of research type; (4) metric in terms of research contribution. It is clear that the concurrent, parallel and multicore software community needs broader studies in debugging. This systematic mapping study can help direct such efforts.

SummaryMicroservices have gained wide recognition and acceptance in software industries as an emerging architectural style for autonomic, scalable, and more reliable computing. The transition to microservices has been highly motivated by the need for better alignment of technical design decisions with improving value potentials of architectures. Despite microservices' popularity, research still lacks disciplined understanding of transition and consensus on the principles and activities underlying that transition. In this paper, we report on a systematic mapping study that consolidates various views, approaches and activities that commonly assist in the transition to microservices. The study aims to provide a better understanding of the transition; it also contributes a working definition of the transition and technical activities underlying it. We term the transition and technical activities leading to microservice architectures as microservitization. We then shed light on a fundamental problem of microservitization: microservice granularity and reasoning about its adaptation as first‐class entities. This study reviews state‐of‐the‐art and ‐practice related to reasoning about microservice granularity; it reviews modeling approaches, aspects considered, guidelines and processes used to reason about microservice granularity. This study identifies opportunities for future research and development related to reasoning about microservice granularity.

Organizations throughout time accumulate applications, which, given their old age, are generally designed in monolithic architecture. Given technological advances, enterprise has the necessity to modernize these applications, being the migration from a monolithic architecture towards microservice architecture a good alternative, however according to our research many failed attempts were found. We performed a Systematic Mapping Study in order to obtain studies to show how to migrate or modernize monolithic applications towards microservices based on some principle of Software Engineering. As a result, we found that there are different types of approaches of studies, such as: (a) solution proposals, (b) experience reports, (c) validations research and (d) opinion articles. Between the studies found, there are no studies related to migration process that is based on a Software Engineering principle, nor the Information Hiding Principle. This research indicates that there is a lack of a theoretical foundation with guidelines on how to perform a decomposition of a monolithic application towards microservices. Given this gap, we propose to migrate a monolithic application to microservices following the principles of the Information Hiding Principle.

В настоящее время широкое распространение получила микросервисная архитектура, появляется множество приложений (микросервисов), которые так или иначе между собой взаимодействуют. Микросервисы, как правило, объединяются в целые платформы. Встает острый вопрос взаимодействия их друг с другом, хранения и обмена справочными данными. Эталонного решения данной проблемы не существует, на данный момент, но в данной работе описан симбиоз различных подходов, а также приведена конкретная реализация – унифицированная модель справочников в микросервисной платформе, которая позволяет обмениваться справочными данными десяткам микросервисов (на момент написания статьи количество сервисов в платформе составляет 57 штук). Была спроектирована метамодель, с помощью которой описываются сущности справочников: справочники, категории, связи между справочниками и между сущностями справочников. Архитектура такой модели микросервиса справочников позволяет абстрагироваться от конкретных реализаций СУБД, таким образом не происходит «сильной связности» с SQL или NoSQL базой данных. Данный микросервис имеет искусственно введеные ограничения запись данных от сторонних микросервисов. Миграция данных осуществляется вручную посредством Liquibase скриптов, что позволяет поддерживать справочники в одинаковом состоянии на всех стендах разработки, быстро и легко восстанавливать до любого состояния слепки справочников. Дальнейшее развитие микросервиса справочников может иметь следующий вид: разработка UI форм для ручного заполнения справочников и сохранение новых данных в модели или в скрипты Liquibase, что уже на данном этапе является очень актуальной проблемой для группы сопровождения и администраторов микросервисной платформы. Today, the microservice architecture has become widespread and most popular in software engineering; many applications (microservices) are forced to communicate with each other. In the future, microservices are combined into entire application platforms. The acute issue of interaction of microservices with each other, storage and exchange of dictionary data have appeared in the minds of developers. A standard solution to this problem does not exist at the moment, but this article describes the symbiosis of various approaches, and also provides a specific implementation - a unified data model of dictionary in a microservice platform. It allows dozens of microservices to exchange dictionary data (now, the number of services in the platform is 57 pieces). This article describes the metamodel which help to design and create entities of dictionary, there are: category of dictionary, relations between categories and between directories. Such data model architecture of microservice allowed me to abstract from specific DBMS implementations, i.e. I am not hard tied on SQL or NoSQL database. This microservice has artificially introduced restrictions on data recording by other microservices. Data migration is carried out manually by Liquibase scripts, which allows maintaining dictionaries in the same state at all development stands, quickly and easily restore dictionaries to any state. Further evolution of the dictionary microservice could be as follows: the development of a user interface for filling dictionaries by administrator`s hands and saving new data in unify data models or auto generation Liquibase scripts. At this stage this problem is very urgent for the support group and administrators of the microservice platform.

In the CERN laboratory, users have access to a large number of different licensed software assets. The landscape of such assets is very heterogeneous including Windows operating systems, office tools and specialized technical and engineering software. In order to improve management of the licensed software and to better understand the needs of the users, it was decided to develop a Winventory application. The Winventory is a tool that gathers and presents statistics of software assets on CERN Windows machines and facilitates interaction with their individual users. The system was built based on microservices architecture pattern, an increasingly popular approach to web application development. The microservices architecture pattern separates the application into multiple independently deployable units that can be individually developed, tested and deployed. This paper presents the microservices architecture and design choices made in order to achieve a modern, maintainable and extensible system for managing licensed software at CERN.


 Microservices architecture is widely used because of the ease of maintaining its microservices, as opposed to encapsulating functionality in a monolithic, which may negatively impact the development process when the application continues to grow. The migration process from a monolithic architecture to microservices became necessary, but it often relies on the architect's intuition only, which may cost many resources. A method to assist developers in decomposing monolithic into microservices is proposed to address that problem. Unlike the existing methods that often rely on non-source code artifacts which may lead into inaccurate decomposition if the artifacts do not reflect the latest condition of the monolith, the proposed method relies on analyzing the application source code to produce a grouping recommendation for building microservices. By using specific keyword extraction followed by Breadth First Search traversal with certain rules, the proposed method decomposed the monolith's component into several cluster whose majority of cluster’s members have uniform business domain. Based on the experiment, the proposed method got an 0.81 accuracy mean in grouping monolithic's components with similar business domain, higher than the existing decomposition method's score. Further research is recommended to be done to increase the availability of the proposed method.