Microservice Design Research Articles

English

English

Softwarized and containerized microservices-based network management analysis with MSN

Microservice architecture is a service-oriented paradigm that enables the decomposition of cumbersome monolithic-based software systems. Using microservice design principles, it is possible to develop flexible, scalable, reusable, and loosely coupled software that could be containerized and deployed in a distributed edge/cloud environment. The flexible deployment of microservices in an edge environment increases system performance in terms due to dynamic service function placement and chaining possibly resulting in latency reduction, fault tolerance, scalability, efficient resource utilization, cost reduction, and energy consumption reduction. On the other hand, virtualization and containerization of microservices add processing and communication overheads. Therefore, to evaluate end-to-end microservices-based system performance, we need to have an end-to-end mathematical formulation of the overall microservice-based network system. Incorporating the virtualization overhead, here we provide end-to-end mathematical formulation considering system parameters: latency, throughput, computational resource usage, and energy consumption. We then evaluate the formulation in a testbed environment with the Microservice-based SDN (MSN) framework that decomposes the Software-defined Networking (SDN) controller in microservices with Docker Container. The final result validates the presented mathematical modeling of the system’s dynamic behavior which can be used to design a microservice-based system.

LEGALSEARCH.IO- Simplifying LEGAL SERVICES

Abstract:-LegalSearch.io is a proposed legal service platform aimed at revolutionizing the way individuals and businesses access legal assistance. In this abstract, we present a comprehensive research model for the development andimplementation of LegalSearch.io, focusing on the principles of modularity, interoperability, and scalability.The research model adopts a Loosely Coupled Model, emphasizing the decomposition of the platform into modular components, each responsible for specific functionalities. Through needs assessment, content audit, technical feasibility study, gamification research, and other research phases, we gather insights and recommendations to inform platform design and optimization.Key components of the research model include a modular architecture, API-driven integration, microservices design, service-oriented principles, continuous integration and delivery, containerization, orchestration, and scalability strategies. These components enable LegalSearch.io to build a flexible and extensible platform that meets the diverse. Index Term- stramlining legal services, legal securities , affodable service.

Railway Cloud: Management and Orchestration Functionality Designed as Microservices

The cloudification and virtualisation of railway functions have the potential to improve railway operation efficiency, reliability, safety, and security, as well as to enhance passenger experience by offering innovative services. This paper considers issues related to the management and orchestration of railway clouds that host cloudified railway functions. A microservices-based approach to the design of railway cloud management and orchestration functionality is proposed. The basic railway cloud concepts were defined, and functionality related to the basic orchestration of the railway cloud and deployments is analysed in order to derive the requirements of platform resources and workload management. This functionality is further designed in the form of microservices, meaning that they could possibly be used in orchestration applications to enable improvements in scalability, fault isolation, and data security. The design of microservices follows the principles of the Representational State of Transfer (REST) application programming interface (API) as a set of interlinked resources. Resources related to railway cloud orchestration are identified with their associated data, relationships to other resources, and applicable methods. The resources’ methods are used in railway applications to implement the required orchestration functionality and to maintain the state of railway cloud orchestration processes. To verify the synthesised microservices, the common orchestration application logic and microservices’ logic were modelled, and it was proved that the orchestration processes, which run concurrently, expose equivalent behaviour. The proposed approach was validated using a simulation, aiming to evaluate injected latency as a key performance indicator for the reliability and safety of railway operations. Additionally, some safety and security issues related to railway cloud management and orchestration are considered.

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×.

A dependable and secure consensus algorithm for blockchain assisted microservice architecture

One of the integral components in the architectural design and development of Internet of Things (IoT) is Microservice. Microservices are basically an architectural and organizational approach in the process of software development where the software is composed of small but independent services that would communicate over well-defined APIs (Application Programming Interfaces). It is quite challenging to ensure data integrity and data availability in the architecture design of microservices. As Blockchain technology has emerged as a panacea to many of the other domains, the distributed microservice architecture can also utilize it. We know that the consensus algorithms are used in the Blockchain technology to validate the transactions alongside providing extra level of security. Taking the advantage of consensus algorithms in blockchain-based architecture models, in this paper, we propose TCA (Trustworthy Consensus Algorithm), which is designed to solve the data integrity and availability challenges in microservice architectures. We have evaluated the proposed algorithm against the known alternatives and it shows good level of efficiency.

Microservices Design and Development for The Basic Logistic Functionalities in The Unified Process

The software development process has gone through significant change in the recent years. Now delivering a system that merely satisfies functional requirements is no longer enough. Companies want their systems to be easily maintained, scalable, fault tolerant, available, integrated, and other attributes. The microservice architecture was designed to create such a robust system where a big monolith system is broken down into multiple small services that communicate each other to fulfill the requirements. One area of functional requirements that exist and needed in almost all kind of companies is the logistic part. This paper will discuss how microservices architecture can be designed and implemented to support logistic functionality that can be reused in a lot of companies as the base system.

Microservice extraction based on knowledge graph from monolithic applications

• Propose a novel method for microservice extraction from monolithic applications ; • Define four types of entities and entity-entity relationships to construct the knowledge graph of the monolithic application, which improves the universality and stability of the method; • Introduce constraints to the Louvain algorithm for graph clustering to determine microservice candidates; • Automatically extract information from the existing design resources of the original monolithic application; • The proposed method can be used as an auxiliary means to check the rationality of the original design of the monolithic application. Re-architecting monolithic systems with microservice architecture is a common trend. However, determining the "optimal" size of individual services during microservice extraction has been a challenge in software engineering. Common limitations of the literature include not being reasonable enough to be put into practical application; relying too much on human experience; neglection of the impact of hardware environment on the performance. To address these problems, this paper proposes a novel method based on knowledge-graph to support the extraction of microservices during the initial phases of re-architecting existing applications. According to the microservice extraction method based on the AKF principle which is a widely practiced microservice design principle in the industry, four kinds of entities and four types of entity-entity relationships are designed and automatically extracted from specification and design artifacts of the monolithic application to build the knowledge graph. A constrained Louvain algorithm is proposed to identify microservice candidates. Our approach is tested based on two open-source projects with the other three typical methods: the domain-driven design-based method, the similarity calculation-based method, and the graph clustering-based method . Conducted experiments show that our method performs well concerning all the evaluation metrics.

RABBITMQ MICROSERVICE WITH ASP.NET CORE WEB API FOR ASYNC OPERATIONS

Nowadays, developers prefer to create apps using a microservice design rather than a monolithic system. The entire functionality is typically included in a single system in monolithic architecture, which is frequently huge, complicated, and closely connected. In other hand, microservice architecture works with independent and decoupled services. A message broker plays pivotal role in microservice architecture. One of the most widely used message-broker services is RabbitMQ. Most important is RabbitMQ is Open-Source message broker. RabbitMQ helps microservices to exchange data while staying independent. This article focuses on implementation of RabbitMQ with ASP.Net core and its advantages for asynchronous operations.

Conformance assessment of Architectural Design Decisions on API endpoint designs derived from domain models

Context:Domain-driven design (DDD) is commonly used to design microservices. A crucial aspect of microservice design is API design, which includes the design of API endpoints. Objective:Our objective is to automate the assessment of conformance to Architectural Design Decisions (ADDs) on the interrelation of DDD and APIs. In particular, we studied link mapping, API operation design, and resource segregation as API endpoint design issues that are linked to domain model design. We particularly aim to address conformance checking in the context of frequent release practices, as frequent manual conformance checking is difficult or infeasible. Methods:We suggest a new approach for the automated assessment of conformance to ADD options. The approach suggests automated detectors to detect ADD options selected in a given API endpoint design, as well as an assessment scoring scheme based on empirical results. For the evaluation of our approach, we first manually created a ground truth for 12 cases in a multi-case study, and then compared the results of our automated detectors to the ground truth for each of those cases. Results:With our approach, all ADD options in our multi-case study possibly can be automatically detected. Without further improvements, our approach identifies 83% of the decision points in the multi-case study correctly. A statistical analysis of our data shows only a negligible effect size for differences to the ground truth. Conclusion:Our new approach provides a pragmatic method for automated detection of conformance to ADDs on the interrelation of DDD and APIs. The approach can support the continuous analysis of API endpoint designs.

An Empirical Study on Virtual English Teaching System Based on the Microservice Architecture with Wireless Internet Sensor Network

We design in this paper a virtual English teaching system based on a wireless sensor network using the features of microservice architecture such as low coupling, lightweight, and high autonomy. This paper explains the characteristics of microservice architecture, uses the wireless sensor network as a carrier, uses the technology provided by Spring Cloud ecology to practice microservices, and makes a specific design and implementation of microservice architecture. The system allows teachers and students to upload and download English course resources, adopts the knowledge map to classify and manage course resources, realizes the diversified search and sorting function of course resources, greatly facilitates users to query and manage course resources, and improves the utilization rate. The internal functional modules of the platform are reasonably divided with the microservice design principle and are developed and deployed independently. For the security of the system, the authentication mechanism of the device and the authentication and authentication strategy of the application interface are designed, respectively. Finally, functional and nonfunctional tests were conducted on the system through the built test environment. The test results show that the virtual English teaching system designed and implemented in this paper has good feasibility and scalability. Through the research of this paper, it brings great help to the wireless sensor network virtual English teaching system and also improves the learning efficiency of students.

Design and implementation of a cloud-based event-driven architecture for real-time data processing in wireless sensor networks

The growth of the Internet of Things (IoTs) and the number of connected devices is driven by emerging applications and business models. One common aim is to provide systems able to synchronize these devices, handle the big amount of daily generated data and meet business demands. This paper proposes a cost-effective cloud-based architecture using an event-driven backbone to process many applications’ data in real-time, called REDA. It supports the Amazon Web Service (AWS) IoT core, and it opens the door as a free software-based implementation. Measured data from several wireless sensor nodes are transmitted to the cloud running application through the lightweight publisher/subscriber messaging transport protocol, MQTT. The real-time stream processing platform, Apache Kafka, is used as a message broker to receive data from the producer and forward it to the correspondent consumer. Micro-services design patterns, as an event consumer, are implemented with Java spring and managed with Apache Maven to avoid the monolithic applications’ problem. The Apache Kafka cluster co-located with Zookeeper is deployed over three availability zones and optimized for high throughput and low latency. To guarantee no message loss and to simulate the system performances, different load tests are carried out. The proposed architecture is reliable in stress cases and can handle records goes to 8000 messages in a second with low latency in a cheap hosted and configured architecture.

Orchestration of Micro services Using Conductor

The Microservices architectural design is widely used today which helps one to build an application as a set of services that can be developed and deployed independently. Each service is independent and gives a set of functions or features that can be individually serviced. In spite of the fact that microservices design has been advanced as the fix just for all cutting-edge application development ailments and is viewed as the replacement for API first application advancement, its execution needs undeniably more idea and practicality. In order for these independent services to work together towards a common goal, we need something that will stitch them together because they cannot work in complete isolation and need to share data and interact with one another. There are two ways to do this – microservice choreography and microservice orchestration. This paper tries to explain the difference between choreography and orchestration of microservices, and why the latter is better. We will then discuss the orchestration of microservices using an open-sourced microservices orchestrator – Conductor.

Enhancing Performance of Distributed Transactions in Microservices via Buffered Serialization

Although the Microservices Architecture comes with a number of benefits, it is a challenge to design an efficient transaction management for multi-agent transactions that span across multiple services. Since microservices design require a loose coupling between service logic and resources, data used by a distributed transaction is spread across different nodes, there is need to an effective way to ensure data portability, speed consistency for transaction in microservices. Therefore this research addresses both the issue of improving transaction performance and maintaining data portability for distributed transactions in microservices. A novel approach to transaction management termed ‘buffered serialization’ is proposed in this research as a way to improve transaction management by the use serialization libraries. This work has a three-part objective which are (1) to highlight the challenges of distributed transaction management in microservices, (2) to propose an enhanced approach to transaction management through the use of buffered serialization between services (3) to provide a proof of concept for this novel approach. Obtained result indicate a 60% improvement in transaction failure recovery time, 10% higher success rate for load tests but an insignificantly higher resource utilization values.

A Metrics Framework for Evaluating Microservices Architecture Designs

Microservices are becoming a more popular software architecture among companies and developers. Therefore, there is a need to develop methods for quantifying the process of measuring the quality of microservices design. This paper has created a novel set of metrics for microservices architecture applications. The proposed metrics are the Service Granularity Metric “SGM”, the Lack of Cohesion Metric “LCOM”, and the Number of Operations “NOO”. The proposed metrics measure the granularity, cohesion, and complexity of individual microservices through analyzing the application programming interface “API”. Using these metrics, it is possible to evaluate the overall quality of the design of microservices applications. The proposed metrics were measured on 5 applications with different sizes and business cases. This research found that the value for the SGM metric needs to be between 0.2 and 0.6. Besides, the value of LCOM metric for a microservice needs to be between 0 and 0.8 with less than ten operations per microservice. These findings can be applied in the decomposition process of monolithic applications as well.

Impacts of Decomposition Techniques on Performance and Latency of Microservices

Micro service architecture (MSA) has undoubtedly become the most popular modern-day architecture, often used in conjunction with the rapidly advancing public cloud platforms to reap the best benefits of salability, elasticity and agility. Though MSA is highly advantageous and comes with a huge set of benefits, it has its own set of challenges. To achieve the separation of concerns and optimal performance, defining the boundaries for the services clearly and their underlying persistent stores is quintessential. But logically segregating the services is a major challenge faced while designing the MSA. Some of the guiding principles like Single responsibility principle (SRP) and common closure principle (CCP) are put in place to drive the design and separation of microservices. With the use of these techniques the service layer can be designed either by (i) Building the services related to a business subdomain and packaging them as a microservice; (ii) or Defining the entity relationship model and then building the services based on the business capabilities which are grouped together as a microservice; (iii) or understanding the big picture of the application scope and combining both the strategies to achieve the best of both worlds. This paper explains these decomposition approaches in detail by comparing them with the real-world use cases and explains which pattern is suitable under which circumstances and at the same time examines the impacts of these approaches on the performance and latency using a research project.

Winventory: microservices architecture case study

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.

Performance Analysis of Microservice Design Patterns

Microservice-based solutions are currently gaining momentum because they do not have the disadvantages of traditional monolithic architectures. Business interest in microservices is increasing since the microservice architecture brings a lightweight, independent, reuse-oriented, and fast service deployment approach that minimizes infrastructural risks. This approach is at an early stage of its development, and in view of this, it is important to understand the performance of its design patterns. In this article, we obtained performance results related to query response time, efficient hardware usage, hosting costs, and packet-loss rate, for three microservice design patterns practiced in the software industry.

Microservices in Audiovisual Archives

This document describes and examines strategies for designing lightweight microservice environments for the processing of digital, file-based, audiovisual data within an archive. The document presumes an overview understanding of the Reference Model for an Open Archival Information System (OAIS). The document also makes references to programming archival routines in command languages, but seeks to provide examples in pseudo-code rather than favoring any particular computer language. Since the document intends to focus on archival routines for audiovisual content, an introduction to ffmpeg can be helpful.
 Additionally, this document does not intend to purport to be a standard for the design of audiovisual microservices but seeks to contribute to and build upon the work and dialogue of many audiovisual archives that has been exploring and successfully implementing microservices in audiovisual archives; see in particularly the compiled, collaborative documentation at https://github.com/amiaopensource/open-workflows.

The pains and gains of microservices: A Systematic grey literature review

The design, development, and operation of microservices are picking up more and more momentum in the IT industry. At the same time, academic work on the topic is at an early stage, and still on the way to distilling the actual “Pains & Gains” of microservices as an architectural style. Having witnessed this gap, we set forth to systematically analyze the industrial grey literature on microservices, to identify the technical/operational pains and gains of the microservice-based architectural style. We conclude by discussing research directions stemming out from our analysis.