To see the other types of publications on this topic, follow the link: Microservices.
Journal articles on the topic 'Microservices'
Create a spot-on reference in APA, MLA, Chicago, Harvard, and other styles
Consult the top 50 journal articles for your research on the topic 'Microservices.'
Next to every source in the list of references, there is an 'Add to bibliography' button. Press on it, and we will generate automatically the bibliographic reference to the chosen work in the citation style you need: APA, MLA, Harvard, Chicago, Vancouver, etc.
You can also download the full text of the academic publication as pdf and read online its abstract whenever available in the metadata.
Browse journal articles on a wide variety of disciplines and organise your bibliography correctly.
1
Park, Joonseok, Daeho Kim, and Keunhyuk Yeom. "An Approach for Reconstructing Applications to Develop Container-Based Microservices." Mobile Information Systems 2020 (January 29, 2020): 1–23. http://dx.doi.org/10.1155/2020/4295937.
Full textAbstract:
Microservices are small-scale services that can operate independently. An application consisting of microservice units can be developed independently as a service unit, and it can handle individual logic without being affected by other services. In addition, it is possible to rapidly distribute the configured microservices by a container, and a container orchestration technology that manages the distributed multiple containers can be realized; thus, it is possible to update and distribute the microservices separately. Therefore, many companies are moving away from existing monolithic structures and attempting to switch to microservices. In this paper, we present a method for reconstructing a monolithic application into a container-based microservice unit. The microservices of data units are derived through the collection and analysis of monolithic design data. Furthermore, we propose a method to generate a template script based on deployment design data so that the derived microservice and support distribution can be implemented in a container environment. The results of a case study conducted verified that the container-based microservices deployed in this study work properly. In addition, for the development of monolithic applications and the development of container-based microservices presented in this paper, we confirmed that developing on the basis of microservices is efficient by conducting execution time performance evaluation for API calls at various iterations. Finally, we show that microservices constructed using the proposed method have higher reusability than those constructed using existing methods.
2
Li, David Chunhu, Chiing-Ting Huang, Chia-Wei Tseng, and Li-Der Chou. "Fuzzy-Based Microservice Resource Management Platform for Edge Computing in the Internet of Things." Sensors 21, no. 11 (May 31, 2021): 3800. http://dx.doi.org/10.3390/s21113800.
Full textAbstract:
Edge computing exhibits the advantages of real-time operation, low latency, and low network cost. It has become a key technology for realizing smart Internet of Things applications. Microservices are being used by an increasing number of edge computing networks because of their sufficiently small code, reduced program complexity, and flexible deployment. However, edge computing has more limited resources than cloud computing, and thus edge computing networks have higher requirements for the overall resource scheduling of running microservices. Accordingly, the resource management of microservice applications in edge computing networks is a crucial issue. In this study, we developed and implemented a microservice resource management platform for edge computing networks. We designed a fuzzy-based microservice computing resource scaling (FMCRS) algorithm that can dynamically control the resource expansion scale of microservices. We proposed and implemented two microservice resource expansion methods based on the resource usage of edge network computing nodes. We conducted the experimental analysis in six scenarios and the experimental results proved that the designed microservice resource management platform can reduce the response time for microservice resource adjustments and dynamically expand microservices horizontally and vertically. Compared with other state-of-the-art microservice resource management methods, FMCRS can reduce sudden surges in overall network resource allocation, and thus, it is more suitable for the edge computing microservice management environment.
3
Jhingran, Sushant, and Nitin Rakesh. "Performance Analysis of Microservices Behavior in Cloud vs Containerized Domain based on CPU Utilization." International Journal on Recent and Innovation Trends in Computing and Communication 11, no. 6s (June 13, 2023): 509–16. http://dx.doi.org/10.17762/ijritcc.v11i6s.6959.
Full textAbstract:
Enterprise application development is rapidly moving towards a microservices-based approach. Microservices development makes application deployment more reliable and responsive based on their architecture and the way of deployment. Still, the performance of microservices is different in all environments based on resources provided by the respective cloud and services provided in the backend such as auto-scaling, load balancer, and multiple monitoring parameters. So, it is strenuous to identify Scaling and monitoring of microservice-based applications are quick as compared to monolithic applications [1]. In this paper, we deployed microservice applications in cloud and containerized environments to analyze their CPU utilization over multiple network input requests. Monolithic applications are tightly coupled while microservices applications are loosely coupled which help the API gateway to easily interact with each service module. With reference to monitoring parameters, CPU utilization is 23 percent in cloud environment. Additionally, we deployed the equivalent microservice in a containerized environment with extended resources to minimize CPU utilization to 17 percent. Furthermore, we have shown the performance of the application with “Network IN” and “Network Out” requests.
4
Karlingannavar, Rakshata, and Dr Nagaraj Bhat. "Orchestration of Micro services Using Conductor." Journal of University of Shanghai for Science and Technology 23, no. 06 (June 4, 2021): 250–55. http://dx.doi.org/10.51201/jusst/21/05254.
Full textAbstract:
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.
5
Pimparkhede, Kunal. "Client side and Server Side Load Balancing." International Journal for Research in Applied Science and Engineering Technology 9, no. 11 (November 30, 2021): 30–31. http://dx.doi.org/10.22214/ijraset.2021.38748.
Full textAbstract:
Abstract: In the microservice architecture it is vital to distribute loads across replicated instances of microservices. Load distribution such that no single instance is overloaded is called as load balancing. Often the instances of microservices are replicated across different racks, different data centers or even different geographies. Modern cloud based platforms offer deployment of microservices across different server instances which are geographically disperse. Having a system that will balance the load across service instances becomes a key success criteria for accurate functioning of distributed software architecture Keywords: Load Balancing, Microservices, Distributed software system
6
Shamsuddeen Rabiu, Abubakar Abba, and Mustapha Ahmed Abubakar. "Autonomous workload distribution for container-based micro services environments." World Journal of Advanced Engineering Technology and Sciences 9, no. 2 (August 30, 2023): 242–50. http://dx.doi.org/10.30574/wjaets.2023.9.2.0226.
Full textAbstract:
Microservice architecture represents a cloud application design approach that transfers the intricacies from the conventional monolithic applications to the infrastructure. It involves breaking down the application into small, containerized microservices, each responsible for a specific functional requirement. These microservices can be independently deployed, scaled, and tested through automated orchestration systems. Our paper introduces an autonomous system for distributing workloads among containerized microservices within the cloud like a swarm, designed specifically for microservices operating within OpenVZ containers. This system has the potential to enhance performance compared to existing centralized container orchestration systems.
7
Vera-Rivera, Fredy H., Carlos Gaona, and Hernán Astudillo. "Defining and measuring microservice granularity—a literature overview." PeerJ Computer Science 7 (September 8, 2021): e695. http://dx.doi.org/10.7717/peerj-cs.695.
Full textAbstract:
Background Microservices are an architectural approach of growing use, and the optimal granularity of a microservice directly affects the application’s quality attributes and usage of computational resources. Determining microservice granularity is an open research topic. Methodology We conducted a systematic literature review to analyze literature that addresses the definition of microservice granularity. We searched in IEEE Xplore, ACM Digital Library and Scopus. The research questions were: Which approaches have been proposed to define microservice granularity and determine the microservices’ size? Which metrics are used to evaluate microservice granularity? Which quality attributes are addressed when researching microservice granularity? Results We found 326 papers and selected 29 after applying inclusion and exclusion criteria. The quality attributes most often addressed are runtime properties (e.g., scalability and performance), not development properties (e.g., maintainability). Most proposed metrics were about the product, both static (coupling, cohesion, complexity, source code) and runtime (performance, and usage of computational resources), and a few were about the development team and process. The most used techniques for defining microservices granularity were machine learning (clustering), semantic similarity, genetic programming, and domain engineering. Most papers were concerned with migration from monoliths to microservices; and a few addressed green-field development, but none address improvement of granularity in existing microservice-based systems. Conclusions Methodologically speaking, microservice granularity research is at a Wild West stage: no standard definition, no clear development—operation trade-offs, and scarce conceptual reuse (e.g., few methods seem applicable or replicable in projects other than their initial proposal). These gaps in granularity research offer clear options to investigate on continuous improvement of the development and operation of microservice-based systems.
8
Mugeraya, Sanath, and Kailas Devadkar. "Dynamic Task Scheduling and Resource Allocation for Microservices in Cloud." Journal of Physics: Conference Series 2325, no. 1 (August 1, 2022): 012052. http://dx.doi.org/10.1088/1742-6596/2325/1/012052.
Full textAbstract:
Abstract With the emergence of new companies and the expansion of the information technology sector, the need for Cloud Computing becomes apparent. Currently, the enterprises are rapidly transitioning from monolithic architecture to microservice-driven architecture. This research study has discovered that all task scheduling algorithms were designed for a specific (set) number of virtual machines, which resulted in the bottleneck problem, where multiple tasks were assigned to the microservice scheduler and the execution time of processing the tasks was significantly increased. Therefore, to address this issue, a novel model was designed based on the number of tasks and accordingly the number of virtual machines were dynamically generated to send the tasks to the microservice scheduler one by one, and the difficulties with execution time were also addressed. The study also discovered that due to the multiple workloads on the microservices, resource allocation becomes extremely difficult. To address this issue, containerized microservices were discovered. Here, the microservices would be distributed in containers. To implement the dynamic work scheduling technique, a cloud microservice translator would be developed, where a user may upload a text file and quickly get it dynamically translated. The main aim of this research work is to improve the task scheduling and resource allocation in microservices.
9
Nadaf, Sarah R., and H. K. Krishnappa. "Kubernetes in Microservices." International Journal of Advanced Science and Computer Applications 2, no. 1 (November 12, 2022): 7–18. http://dx.doi.org/10.47679/ijasca.v2i1.19.
Full textAbstract:
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
10
Laigner, Rodrigo, Yongluan Zhou, Marcos Antonio Vaz Salles, Yijian Liu, and Marcos Kalinowski. "Data management in microservices." Proceedings of the VLDB Endowment 14, no. 13 (September 2021): 3348–61. http://dx.doi.org/10.14778/3484224.3484232.
Full textAbstract:
Microservices have become a popular architectural style for data-driven applications, given their ability to functionally decompose an application into small and autonomous services to achieve scalability, strong isolation, and specialization of database systems to the workloads and data formats of each service. Despite the accelerating industrial adoption of this architectural style, an investigation of the state of the practice and challenges practitioners face regarding data management in microservices is lacking. To bridge this gap, we conducted a systematic literature review of representative articles reporting the adoption of microservices, we analyzed a set of popular open-source microservice applications, and we conducted an online survey to cross-validate the findings of the previous steps with the perceptions and experiences of over 120 experienced practitioners and researchers. Through this process, we were able to categorize the state of practice of data management in microservices and observe several foundational challenges that cannot be solved by software engineering practices alone, but rather require system-level support to alleviate the burden imposed on practitioners. We discuss the shortcomings of state-of-the-art database systems regarding microservices and we conclude by devising a set of features for microservice-oriented database systems.
11
Valdivi, José Ali, Alonso Lora-Gonzalez, Xavier Limón, Karen Cortes-Verdin, and Jorge Octavio Ocharán-Hernández. "Patterns Related to Microservice Architecture: a Multivocal Literature Review." Proceedings of the Institute for System Programming of the RAS 33, no. 1 (2021): 81–96. http://dx.doi.org/10.15514/ispras-2021-33(1)-6.
Full textAbstract:
A Microservice Architecture enables the development of distributed systems using a set of highly cohesive, independent, and collaborative services, ready for current cloud computing demands. Each microservice can be implemented in different technologies, sharing common communication channels, which results in heterogeneous distributed systems that exhibit high scalability, maintainability, performance, and interoperability. Currently, there are many options to build microservices; some of them led by patterns that establish common structures to solve recurrent problems. Nevertheless, as microservices are an emerging trend, the relationship between quality attributes, metrics, and patterns is not clearly defined, which is a concern from a software engineering point of view, since such understanding is fundamental to correctly design systems using this architecture. This paper aims to extend the knowledge on the design of microservices-based systems by presenting a multivocal systematic literature review for microservices related patterns, tying them together with quality attributes and metrics, as can be found in academic and industry research.
12
Dave, Chitrak Vimalbhai. "Microservices Software Architecture: A Review." International Journal for Research in Applied Science and Engineering Technology 9, no. 11 (November 30, 2021): 1494–96. http://dx.doi.org/10.22214/ijraset.2021.39036.
Full textAbstract:
Abstract: Architecting is an indispensable activity in all spheres and paradigms of Software Engineering. DevOps, a portmanteau of Development and Operations, has a major adoption challenge in context to Microservices Architecture. Architecture refers to the most important aspect of internal design of a software. Architecture must be good otherwise; it will become slow and much more expensive to add new proficiencies in future. This paper has presented a review of microservices architecture and implementation patterns. Microservice approach is a new concept in software architecture patterns and has leapt up over past few years for describing a certain method to design software applications as collections of individualistically deployable services. In this paper we are looking to discover the role of microservices software architecture in DevOps. It is found that adopting DevOps may carry many challenges/issues like organizational values, immaturity of the tools and infrastructural support with it for architecting with it. Keywords: Microservices Architecture, Microservice, Service Oriented Architecture (SOA), Software Architecture, DevOps
13
Rusek, Marian, and Joanna Landmesser. "Time Complexity of an Distributed Algorithm for Load Balancing of Microservice-oriented Applications in the Cloud." ITM Web of Conferences 21 (2018): 00018. http://dx.doi.org/10.1051/itmconf/20182100018.
Full textAbstract:
Microservice architecture is a relatively new cloud application design pattern. Each microservice has a single responsibility in terms of functional requirement, and that can be managed independently from other microservices. This is done using automated cloud orchestration systems. In this paper we analyze the time complexity of an simple swarm-like decentralized load balancing algorithm for microservices running inside OpenVZ virtualization containers. We show that it can offer performance improvements with respect to the existing centralized container orchestration systems.
14
Volushkova, Vera L'vovna, and Aleksandra Yurievna Volushkova. "A Single Specification Format as a Microservice API Artifact when Using API-First." Программные системы и вычислительные методы, no. 4 (April 2022): 54–62. http://dx.doi.org/10.7256/2454-0714.2022.4.39235.
Full textAbstract:
The object of research is the interaction protocols (API - Application Programming Interface) of microservices. The microservices API is an important development object because each microservice can be a client for any other microservice and be created by a separate team. To build a unified system of interaction between microservices, the API-First methodology for synchronizing communication protocols for server applications was used. The aim of the work is to create a way to develop API microservices of server java applications using spring-boot, spring-web, openapi-generator, springdoc libraries. The method is based on the fact that the API is the most important part of the product and therefore is created at the initial design stage. An approach based on a single microservices API and TDD testing technique is proposed, which increases the efficiency of managing the development of server-side java applications. The microservices API is built using the specification as the API artifact. The developed technique allows: use the created API by another team, regardless of the development language; increase the productivity of development teams; to carry out a qualitative description of methods and models; reduce the amount of routine code by generating code from the specification; identify API design errors earlier than with the standard development approach (API after implementation) by applying TDD and working with the API before it is implemented.
15
Xu, Hanyi, Guozhen Cheng, Xiaohan Yang, Wenyan Liu, Dacheng Zhou, and Wei Guo. "Multi-Dimensional Moving Target Defense Method Based on Adaptive Simulated Annealing Genetic Algorithm." Electronics 13, no. 3 (January 24, 2024): 487. http://dx.doi.org/10.3390/electronics13030487.
Full textAbstract:
Due to the fine-grained splitting of microservices and frequent communication between microservices, the exposed attack surface of microservices has exploded, facilitating the lateral movement of attackers between microservices. To solve this problem, a multi-dimensional moving target defense method based on an adaptive simulated annealing genetic algorithm (MD2RS) is proposed. Firstly, according to the characteristics of microservices in the cloud, a microservice attack graph is proposed to quantify the attack scenario of microservices in the cloud so as to conveniently and intuitively observe the vulnerability of microservices in the cloud and the dependency relationship between microservices. Secondly, the security gain and resource cost are quantified for the key nodes selected by measuring the degree of dependence of each node according to the degree centrality. Finally, the Adaptive Simulated Annealing Genetic Algorithm (ASAGA) is used to solve the optimal security configuration information of the moving target defense, that is, the combination of the number of copies of the multi-copy deployment and the rotation cycle of the dynamic rotation of microservices, in order to quickly evaluate the security risks of microservices and optimize the security policy. Experiments show that the defense return rate of MD2RS is 85.95% higher than that of the mainstream methods, and the experimental results are conducive to applying this method to the dynamic defense of microservices in the cloud.
16
Hossen, Md Rajib. "PEMA+: A Comprehensive Resource Manager for Microservices." ACM SIGMETRICS Performance Evaluation Review 51, no. 3 (January 3, 2024): 10–12. http://dx.doi.org/10.1145/3639830.3639836.
Full textAbstract:
Motivation. Microservices architecture has become more prevalent in cloud-based applications where small, looselycoupled service components work together to handle user requests [1]. This architecture differs greatly from traditional monolithic deployments and provides advantages such as agile resource management, better fault tolerance, and platform compatibility [2, 3]. The figure 1 shows the difference between monolithic and microservice architecture. However, microservices come with their own set of challenges, particularly in the area of resource management. Resource management for microservices-based applications is more challenging than for monolithic applications due to the larger configuration space and complex communication topology [4, 5]. Additionally, existing resource management techniques for monolithic applications must manage microservices effectively. The resource management challenges for microservices must be addressed as more production cloud services adopt this architecture [6, 7].
17
Hamza, Muhammad. "Transforming Monolithic Systems to a Microservices Architecture." ACM SIGSOFT Software Engineering Notes 48, no. 1 (January 10, 2023): 67–69. http://dx.doi.org/10.1145/3573074.3573091.
Full textAbstract:
Context: microservices architecture enables organizations to develop an application as a suite of loosely coupled small and independent services that can be developed, tested, and deployed independently. Various organizations are re-architecting their existing monolithic systems with microservices architecture. However, re-architecting the entire system can bring some indefinite challenges. Objective: the goal of this research project is to investigate (i) the need for migration from monolithic to microservices architecture, (ii) architectural description for adopting microservices, (iii) refactoring tools and methods (iv) potential challenges while transforming to microservices, and (v) effective patterns and strategies to adopt microservice successfully. Methodology: the industrial empirical (interviews, case study, and questionnaire survey) approach will be used to meet the research objective. Possible outcomes: the expected outcomes would be (i) an evidence-based decision-making framework for transforming monolithic architecture (ii) strategies to refactor the monolithic architecture (iii) prioritization-based taxonomy of challenges while transforming to microservices. Finally, (iv) the development of a decision model for selecting patterns and strategies for successful implementation of the microservices system.
18
Dell’Immagine, Giorgio, Jacopo Soldani, and Antonio Brogi. "KubeHound: Detecting Microservices’ Security Smells in Kubernetes Deployments." Future Internet 15, no. 7 (June 26, 2023): 228. http://dx.doi.org/10.3390/fi15070228.
Full textAbstract:
As microservice-based architectures are increasingly adopted, microservices security has become a crucial aspect to consider for IT businesses. Starting from a set of “security smells” for microservice applications that were recently proposed in the literature, we enable the automatic detection of such smells in microservice applications deployed with Kubernetes. We first introduce possible analysis techniques to automatically detect security smells in Kubernetes-deployed microservices. We then demonstrate the practical applicability of the proposed techniques by introducing KubeHound, an extensible prototype tool for automatically detecting security smells in microservice applications, and which already features a selected subset of the discussed analyses. We finally show that KubeHound can effectively detect instances of security smells in microservice applications by means of controlled experiments and by applying it to existing, third-party applications.
19
Vera-Rivera, Fredy H., Eduard Gilberto Puerto Cuadros, Boris Perez, Hernán Astudillo, and Carlos Gaona. "SEMGROMI—a semantic grouping algorithm to identifying microservices using semantic similarity of user stories." PeerJ Computer Science 9 (May 12, 2023): e1380. http://dx.doi.org/10.7717/peerj-cs.1380.
Full textAbstract:
Microservices is an architectural style for service-oriented distributed computing, and is being widely adopted in several domains, including autonomous vehicles, sensor networks, IoT systems, energy systems, telecommunications networks and telemedicine systems. When migrating a monolithic system to a microservices architecture, one of the key design problems is the “microservice granularity definition”, i.e., deciding how many microservices are needed and allocating computations among them. This article describes a semantic grouping algorithm (SEMGROMI), a technique that takes user stories, a well-known functional requirements specification technique, and identifies number and scope of candidate microservices using semantic similarity of the user stories’ textual description, while optimizing for low coupling, high cohesion, and high semantic similarity. Using the technique in four validation projects (two state-of-the-art projects and two industry projects), the proposed technique was compared with domain-driven design (DDD), the most frequent method used to identify microservices, and with a genetic algorithm previously proposed as part of the Microservices Backlog model. We found that SEMGROMI yields decompositions of user stories to microservices with high cohesion (from the semantic point of view) and low coupling, the complexity was reduced, also the communication between microservices and the estimated development time was decreased. Therefore, SEMGROMI is a viable option for the design and evaluation of microservices-based applications. The proposed semantic similarity-based technique (SEMGROMI) is part of the Microservices Backlog model, which allows to evaluate candidate microservices graphically and based on metrics to make design-time decisions about the architecture of the microservices-based application.
20
Pakrijauskas, Kęstutis, and Dalius Mažeika. "A Method of Transparent Graceful Failover in Low Latency Stateful Microservices." Electronics 11, no. 23 (November 28, 2022): 3936. http://dx.doi.org/10.3390/electronics11233936.
Full textAbstract:
Microservice architecture is a preferred way to build applications. Being flexible and loosely coupled, it allows to deploy code at a high pace. State, or, in other words, data is not only a commodity but crucial to any business. The high availability and accessibility of data enables companies to remain competitive. However, maintaining low latency stateful microservices, for example, performing updates, is difficult compared to stateless microservices. Making changes to a stateful microservice requires a graceful failover, which has an impact on the availability budget. The method of graceful failover is proposed to improve availability of a low latency stateful microservice when performing maintenance. By observing database connection activity and forcefully terminating idle client connections, the method allows to redirect database requests from one node to another with negligible impact on the client. Thus, the proposed method allows to keep the precious availability budget untouched while performing maintenance operations on low latency stateful microservices. A set of experiments was performed to evaluate stateful microservice availability during failover and to validate the method. The results have shown that near-zero downtime was achieved during a graceful failover.
21
Zuki, Siti Zulaikha Mohd, Radziah Mohamad, and Nor Azizah Saadon. "Containerized Event-Driven Microservice Architecture." Baghdad Science Journal 21, no. 2(SI) (February 25, 2024): 0584. http://dx.doi.org/10.21123/bsj.2024.9729.
Full textAbstract:
Microservice architecture offers many advantages, especially for business applications, due to its flexibility, expandability, and loosely coupled structure for ease of maintenance. However, there are several disadvantages that stem from the features of microservices, such as the fact that microservices are independent in nature can hinder meaningful communication and make data synchronization more challenging. This paper addresses the issues by proposing a containerized microservices in an asynchronous event-driven architecture. This architecture encloses microservices in containers and implements an event manager to keep track of all the events in an event log to reduce errors in the application. Experiment results show a decline in response time compared to two other benchmark architectures, as well as a lessening in error rate.
22
Aden, Abdiaziz Abdullahi. "Microservice Architecture in E-commerce Platforms using Docker and Kubernetes." INTERANTIONAL JOURNAL OF SCIENTIFIC RESEARCH IN ENGINEERING AND MANAGEMENT 08, no. 04 (April 26, 2024): 1–5. http://dx.doi.org/10.55041/ijsrem31735.
Full textAbstract:
software development and deployment by increasing modularity, scalability, and flexibility. This technique divides apps into smaller, independent services that communicate over HTTP APIs. Docker plays an important role in containerizing these services, guaranteeing consistent operation across several settings. Docker containers are lightweight, use the host kernel, and start quicker than typical virtual machines, making them perfect for microservices. Kubernetes, Google's open-source technology, enhances microservices by automating container deployment, scaling, and administration across host clusters. This combination creates a stable environment for delivering microservices, allowing for continuous integration and deployment (CI/CD). This article investigates the synergistic usage of microservices, Docker, and Kubernetes, showing their combined efficiency in developing, deploying, and scaling applications across many environments. Keywords— microservice, architecture, Monolithic Architecture, Kubernetes, Docker
23
de Almeida, Murilo Góes, and Edna Dias Canedo. "Authentication and Authorization in Microservices Architecture: A Systematic Literature Review." Applied Sciences 12, no. 6 (March 16, 2022): 3023. http://dx.doi.org/10.3390/app12063023.
Full textAbstract:
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.
24
Yu, Hang, Xiulei Wang, Changyou Xing, and Bo Xu. "A Microservice Resilience Deployment Mechanism Based on Diversity." Security and Communication Networks 2022 (June 1, 2022): 1–13. http://dx.doi.org/10.1155/2022/7146716.
Full textAbstract:
The microservice architecture has many advantages, such as technology heterogeneity, isolation, scalability, simple deployment, and convenient optimization. These advantages are important as we can use diversity and redundancy to improve the resilience of software system. It is necessary to study the method of improving the resilience of software system by diversity implementation and redundant deployment of software core components based on microservice framework. How to optimize the diversity deployment of microservices is a key problem to maximize system resilience and make full use of resources. To solve this problem, an efficient microservice diversity deployment mechanism is proposed in this paper. Firstly, we creatively defined a load balancing indicator and a diversity indicator. Based on this, a diversified microservices deployment model is established to maximize the resilience and the resource utilization of the system. Secondly, combined with load balancing, a microservice deployment algorithm based on load balance and diversity is proposed, which reduces the service’s dependence on the underlying mirror by enriching diversity and avoids the overreliance of microservices on a single node through decentralized deployment, while taking into account load balancing. Finally, we conduct experiments to evaluate the performance of the proposed algorithm. The results demonstrate that the proposed algorithm outperforms other algorithms.
25
Salvadori, Ivan Luiz, Alexis Huf, Bruno C. N. Oliveira, Ronaldo dos Santos Mello, and Frank Siqueira. "Improving entity linking with ontology alignment for semantic microservices composition." International Journal of Web Information Systems 13, no. 3 (August 21, 2017): 302–23. http://dx.doi.org/10.1108/ijwis-04-2017-0029.
Full textAbstract:
Purpose This paper aims to propose a method based on Linked Data and Semantic Web principles for composing microservices through data integration. Two frameworks that provide support for the proposed composition method are also described in this paper: Linkedator, which is responsible for connecting entities managed by microservices, and Alignator, which aligns semantic concepts defined by heterogeneous ontologies. Design/methodology/approach The proposed method is based on entity linking principles and uses individual matching techniques considering a formal notion of identity. This method imposes two major constraints that must be taken into account by its implementation: architectural constraints and resource design constraints. Findings Experiments were performed in a real-world scenario, using public government data. The obtained results show the effectiveness of the proposed method and that, it leverages the independence of development and composability of microservices. Thereby, the data provided by microservices that adopt heterogeneous ontologies can now be linked together. Research limitations/implications This work only considers microservices designed as data providers. Microservices designed to execute functionalities in a given application domain are out of the scope of this work. Originality/value The proposed composition method exploits the potential data intersection observed in resource-oriented microservice descriptions, providing a navigable view of data provided by a set of interrelated microservices. Furthermore, this study explores the applicability of ontology alignments for composing microservices.
26
Tuglular, Tugkan, Deniz Egemen Coşkun, Ömer Gülen, Arman Okluoğlu, and Kaan Algan. "Behavior-Driven Development of Microservice Applications." International Journal of Computers 15 (December 9, 2021): 130–37. http://dx.doi.org/10.46300/9108.2021.15.20.
Full textAbstract:
As the number of microservice applications rises, different development methodologies for them are under consideration. In this manuscript, we propose a behavior-driven development method for microservice applications. The proposed method starts with writing end-to-end tests at the system or application level and then moves down to the microservice level, where component and unit tests are written. Next, code that passes these tests is developed one by one for each level. Once user stories are covered, our method loops again to integrate negative tests to achieve holistic testing for the microservices and the application. Finally, the proposed method is validated with an application with five microservices. Results confirm that the proposed method matches with the generally accepted test pyramid.
27
Iqbal, Muhammad, Wiwin Handoko, and Abdul Karim Syahputra. "Optimalisasi E-Learning Melalui Implementasi Microservice Untuk Peningkatan Skalabilitas Dan Efisiensi Pembelajaran Online." Jurdimas (Jurnal Pengabdian Kepada Masyarakat) Royal 6, no. 3 (July 26, 2023): 439–44. http://dx.doi.org/10.33330/jurdimas.v6i3.2496.
Full textAbstract:
The increased use of technology in education has encouraged the development of e-learning platforms that can provide effective and affordable learning experiences. However, the scalability and viability of e-learning platforms is often a challenge in the face of an increasing number of users and workloads. In this dedication, we propose the use of mi-croservice architecture in e-learning platforms to optimize scalability and maintain platform viability. We design and implement a microservice-based e-learning platform consisting of independent microservices, such as user management, course management, content management, and grading systems. We implement standardized API mechanisms for interactions between these microservices. We also vertically increase CPU capacity on each microservice instance to address increased workloads. We also observed that the use of microservices architecture makes it easy to maintain, develop, and integrate new features into the platform. In this overall dedication, we show that the implementation of microservices on e-learning platforms is able to provide optimal scalability and maintain the continuity of the platform in the face of increasing user needsKeywords: e-learning; microservice; skalabilitas; kinerja; monolitik Abstract: Peningkatan penggunaan teknologi dalam pendidikan telah mendorong perkembangan platform e-learning yang dapat memberikan pengalaman pembelajaran yang efektif dan terjangkau. Namun, skalabilitas dan kelangsungan platform e-learning sering menjadi tantangan dalam menghadapi peningkatan jumlah pengguna dan beban kerja. SMK Swasta As-Syifa Kisaran menggunakan platform E-learning berbasis monolitik yang menyebabkan semakin banyak aktivitas platform digunakan semakin berat. Beberapa tahapan dilakukan dimulai dengan identifikasi masalah, perencanaan dan desain program, pelaksanaan, evaluasi dan analisis, serta penyusunan dan publikasi laporan. Arsitektur monolitik sebelumnya yang diterapkan perlu diperbaharui dengan arsitektur microservice bertujuan untuk mengoptimalkan skalabilitas dan menjaga kelangsungan platform E-Learning. Permasalahan pada penggunaan traffic yang tinggi dan berfokus pada satu server semakin lama semakin membebani server. Berdasarkan masalah tersebut maka layanan dipecah menjadi beberapa layanan webservice menggunakan arsitektur microservice yang terdiri dari layanan-microservice independen, seperti manajemen pengguna, kursus, konten, dan sistem penilaian. Peningkatan kapasitas CPU secara vertikal diperlukan sehingga microservice dapat mengatasi peningkatan beban kerja server. Hasil implementasi microservice yang diterapkan pada platform e-learning SMK As-Syifa mampu memberikan skalabilitas yang optimal untuk kelangsungan platform dalam menghadapi peningkatan kebutuhan pengguna Kata kunci: e-learning; microservice; scalability; performance; monolitik
28
Saboor, Abdul, Mohd Fadzil Hassan, Rehan Akbar, Syed Nasir Mehmood Shah, Farrukh Hassan, Saeed Ahmed Magsi, and Muhammad Aadil Siddiqui. "Containerized Microservices Orchestration and Provisioning in Cloud Computing: A Conceptual Framework and Future Perspectives." Applied Sciences 12, no. 12 (June 7, 2022): 5793. http://dx.doi.org/10.3390/app12125793.
Full textAbstract:
Cloud computing is a rapidly growing paradigm which has evolved from having a monolithic to microservices architecture. The importance of cloud data centers has expanded dramatically in the previous decade, and they are now regarded as the backbone of the modern economy. Cloud-based microservices architecture is incorporated by firms such as Netflix, Twitter, eBay, Amazon, Hailo, Groupon, and Zalando. Such cloud computing arrangements deal with the parallel deployment of data-intensive workloads in real time. Moreover, commonly utilized cloud services such as the web and email require continuous operation without interruption. For that purpose, cloud service providers must optimize resource management, efficient energy usage, and carbon footprint reduction. This study presents a conceptual framework to manage the high amount of microservice execution while reducing response time, energy consumption, and execution costs. The proposed framework suggests four key agent services: (1) intelligent partitioning: responsible for microservice classification; (2) dynamic allocation: used for pre-execution distribution of microservices among containers and then makes decisions for dynamic allocation of microservices at runtime; (3) resource optimization: in charge of shifting workloads and ensuring optimal resource use; (4) mutation actions: these are based on procedures that will mutate the microservices based on cloud data center workloads. The suggested framework was partially evaluated using a custom-built simulation environment, which demonstrated its efficiency and potential for implementation in a cloud computing context. The findings show that the engrossment of suggested services can lead to a reduced number of network calls, lower energy consumption, and relatively reduced carbon dioxide emissions.
29
Walker, Andrew, Dipta Das, and Tomas Cerny. "Automated Code-Smell Detection in Microservices Through Static Analysis: A Case Study." Applied Sciences 10, no. 21 (November 3, 2020): 7800. http://dx.doi.org/10.3390/app10217800.
Full textAbstract:
Microservice Architecture (MSA) is becoming the predominant direction of new cloud-based applications. There are many advantages to using microservices, but also downsides to using a more complex architecture than a typical monolithic enterprise application. Beyond the normal poor coding practices and code smells of a typical application, microservice-specific code smells are difficult to discover within a distributed application setup. There are many static code analysis tools for monolithic applications, but tools to offer code-smell detection for microservice-based applications are lacking. This paper proposes a new approach to detect code smells in distributed applications based on microservices. We develop an MSANose tool to detect up to eleven different microservice specific code smells and share it as open-source. We demonstrate our tool through a case study on two robust benchmark microservice applications and verify its accuracy. Our results show that it is possible to detect code smells within microservice applications using bytecode and/or source code analysis throughout the development process or even before its deployment to production.
30
Zhou, Xueyun, Xinling Wu, and Yihong Chen. "High-Concurrency and High-Performance Application of Microservice Order System Based on Big Data." Security and Communication Networks 2022 (June 28, 2022): 1–11. http://dx.doi.org/10.1155/2022/3424283.
Full textAbstract:
The order system plays the role of the central nervous system in the integrated logistics operation. Theoretically speaking, the whole operation process of logistics service is to complete the order, the order information runs through all the links of the whole logistics, and the order processing efficiency affects the logistics process. This paper studies the high-concurrency and high-performance applications of the microservice order system based on big data, which prove that on the basis of big data technology, the performance of the microservice order system will be greatly improved. To this end, the analysis provides an overview of big data technologies and related content of microservices. It describes their application scenarios and then combines the development of the order system with a comprehensive analysis to prove its feasibility. At the same time, we compared multiple algorithms applied in microservices and found the most suitable algorithm for the order system and applied it, so that the order system can achieve high concurrency and high performance. The big data-based microservices control system proved to be useful for reasonable resource planning and for improving system performance in experiments. The final experiment found that in the microservice order system using big data, its transaction average response time was 0.01 s, and the success rate was 100%.
31
Díaz-Sánchez, Daniel, Andrés Marín-Lopez, Florina Almenárez Mendoza, and Patricia Arias Cabarcos. "DNS/DANE Collision-Based Distributed and Dynamic Authentication for Microservices in IoT †." Sensors 19, no. 15 (July 26, 2019): 3292. http://dx.doi.org/10.3390/s19153292.
Full textAbstract:
IoT devices provide real-time data to a rich ecosystem of services and applications. The volume of data and the involved subscribe/notify signaling will likely become a challenge also for access and core networks. To alleviate the core of the network, other technologies like fog computing can be used. On the security side, designers of IoT low-cost devices and applications often reuse old versions of development frameworks and software components that contain vulnerabilities. Many server applications today are designed using microservice architectures where components are easier to update. Thus, IoT can benefit from deploying microservices in the fog as it offers the required flexibility for the main players of ubiquitous computing: nomadic users. In such deployments, IoT devices need the dynamic instantiation of microservices. IoT microservices require certificates so they can be accessed securely. Thus, every microservice instance may require a newly-created domain name and a certificate. The DNS-based Authentication of Named Entities (DANE) extension to Domain Name System Security Extensions (DNSSEC) allows linking a certificate to a given domain name. Thus, the combination of DNSSEC and DANE provides microservices’ clients with secure information regarding the domain name, IP address, and server certificate of a given microservice. However, IoT microservices may be short-lived since devices can move from one local fog to another, forcing DNSSEC servers to sign zones whenever new changes occur. Considering DNSSEC and DANE were designed to cope with static services, coping with IoT dynamic microservice instantiation can throttle the scalability in the fog. To overcome this limitation, this article proposes a solution that modifies the DNSSEC/DANE signature mechanism using chameleon signatures and defining a new soft delegation scheme. Chameleon signatures are signatures computed over a chameleon hash, which have a property: a secret trapdoor function can be used to compute collisions to the hash. Since the hash is maintained, the signature does not have to be computed again. In the soft delegation schema, DNS servers obtain a trapdoor that allows performing changes in a constrained zone without affecting normal DNS operation. In this way, a server can receive this soft delegation and modify the DNS zone to cope with frequent changes such as microservice dynamic instantiation. Changes in the soft delegated zone are much faster and do not require the intervention of the DNS primary servers of the zone.
32
Mushtaq, zaigham, Najia Saher, Faisal Shazad, Sana Iqbal, and Anam Qasim. "A Review on Transformation of Monolithic Applications towards Microservices Environment." Vol 4 Issue 1 4, no. 1 (January 22, 2022): 1–18. http://dx.doi.org/10.33411/ijist/2022040101.
Full textAbstract:
The traditional monolithic approach is widely employed in centralized software development, deployment, and reusability, as the modules are tightly connected, causing several challenges in programming. The study utilized different techniques for the easy transformation of several running monolithic applications to micro services including, Angular 2, REST API, Web application and several other architectural approaches are discussed. This review paper highlights the significance of microservices and the transformation of monolithic applications towards microservices. As multiple software applications are an integral part of a traditional monolithic application, the modules cannot be extended separately, and different modules cannot use various technology stacks. So, monolithic source code must be migrated to the microservice platform in order to extend `the lifecycle of applications in today's environment. However, due to structural complexity, scattered application logic, and dependency upon external framework libraries, the transformation towards a microservices platform is quite challenging. A Microservice architecture is a container of loosely coupled independent services making a flexible system. In this study, potential areas for the transformation of monolithic application source code are highlighted. Furthermore, key challenges and open research issues in this area are highlighted, requiring the research community's attention. The study concludes that Microservices are not a one-size-fits-all solution for every challenging situation. Monolithic transformation requires significant amount of time and effort on the part of everyone in the business.
33
Siagian, Noplin, Tiarro Elprida Tamba, Hansen Henok O. Situmorang, and Hernawati Samosir. "APLIKASI APOTEK BERBASIS WEB MENGGUNAKAN ARSITEKTUR MICROSERVICES (STUDI KASUS APOTEK GLEN, KAB.TOBA)." Journal of Applied Technology and Informatics Indonesia 1, no. 2 (November 30, 2021): 22–28. http://dx.doi.org/10.54074/jati.v1i2.35.
Full textAbstract:
Dalam bidang kesehatan, teknologi informasi berkembang pesat bagi masyarakat khususnya di pedesaan. Salah satu penerapannya di bidang kesehatan pada sistem informasi. Apotek Glen merupakan salah satu toko obat di wilayah Kabupaten Toba. Saat ini sistem layanan apotek seperti transaksi penjualan obat-obatan masih dilakukan dengan cara manual yaitu dengan mencatat ke dalam buku sehingga dibangun aplikasi Apotek Glen berbasis web yang menggunakan arsitektur microservices. Alasan Aplikasi Apotek menggunakan arsitektur microservices adalah karena lebih skalabel (terukur) dan fleksibel sehingga dapat memenuhi kebutuhan pengguna. Namun pada umumnya beberapa aplikasi dibangun menggunakan arsitektur monolitik karena banyak diimplementasikan oleh developer.Tujuan utama penelitian dari aplikasi apotek yang dibangun adalah untuk mengimplementasikan arsitektur microservices dan menganalisis kedua arsitektur tersebut berdasarkan beberapa indikator yaitu struktur aplikasi, bahasa pemrograman, database dan deployment. Metode penelitian yang digunakan dalam pengembangan aplikasi apotek Glen berbasis web dilihat dari arsitektur microservices, dan arsitektur monolitik. Aplikasi yang menggunakan arsitektur monolitik diuji secara manual, sedangkan aplikasi yang menggunakan arsitektur microservices diuji menggunakan Postman. Hasil dari penelitian ini adalah aplikasi apotek berbasis web menggunakan arsitektur microservice dan perbedaan arsitektur microservices dengan arsitektur monolitik yang masing-masing memiliki karakteristik tersendiri. Arsitektur monolitik merupakan sebuah arsitektur yang menjalankan semua layanan yang berada dalam sebuah server sedangkan arsitektur microservices merupakan sebuah arsitektur yang bersifat independent yang terdiri dari berbagai service kecil yang memiliki tanggung jawab sendiri dan setiap service dapat saling berkomunikasi satu sama lain menggunakan API (Application Programming Interface).
34
Doljenko, Alexey, Irina Shpolianskaya, and Sergey Glushenko. "Fuzzy production network model for quality assessment of an information system based on microservices." Business Informatics 14, no. 4 (December 31, 2020): 36–46. http://dx.doi.org/10.17323/2587-814x.2020.4.36.46.
Full textAbstract:
This article describes the analysis of the quality of microservice architectures, which are one of the main approaches to the creation and maintenance of modern information systems capable of quickly respond to changes in business demands. The implementation of continuous delivery of software components for dynamic business processes of information systems can be carried out by various sets of microservices, the optimal choice of which is a complex multi-alternative task. The paper presents a review of existing approaches to solving the problem, which showed that the development of models for assessing the quality of microservices of information systems requires further elaboration in terms of accounting for uncertainty in the initial data and modes of operation. The authors have proposed an approach to solving the problem of analyzing the quality of a microservice architecture which is implemented on the basis of a fuzzy production network model. The model allows for comprehensive accounting of various parameters (qualitative and quantitative). The article shows the implementation process of the fuzzy production network that was developed to analyze the functional quality of the microservice architecture for processing customer orders using fuzzy modeling software. The results of the analysis will allow managers and system architects to make an informed choice of the microservice architecture of the information system, as well as use it in their reports when arguing the need for scaling the system and increasing the availability of microservices.
35
Aksakalli, Isil Karabey, Turgay Celik, Ahmet Burak Can, and Bedir Tekinerdogan. "A Model-Driven Architecture for Automated Deployment of Microservices." Applied Sciences 11, no. 20 (October 15, 2021): 9617. http://dx.doi.org/10.3390/app11209617.
Full textAbstract:
Microservice architecture consists of a collection of loosely coupled, self-contained services that can be deployed independently. Given the limited capacity of the resources for a large number of services, the deployment of the services does not scale well and leads to operational complexity and runtime overhead. This paper proposes a model-driven approach for the automated deployment of microservices to minimize the execution cost and communication costs among the microservices. The identification of the feasible deployment is defined at the architecture design level based on the provided capacity of the resources and the collection of microservices. The corresponding tool support using Eclipse Modeling Environment is described, and a case study on book shopping is used to illustrate the approach.
36
Mochniej, Kacper, and Marcin Badurowicz. "Performance comparison of microservices written using reactive and imperative approaches." Journal of Computer Sciences Institute 28 (September 30, 2023): 242–47. http://dx.doi.org/10.35784/jcsi.3698.
Full textAbstract:
The purpose of this paper is to compare the performance of microservices based on reactive and imperative approaches. For this purpose, two microservice applications written in Java using the Spring programming framework were developed. The Spring Web and Spring Webflux modules were used for the conventional and reactive versions, respectively. During the tests, functionalities related to operations of retrieving and inserting records into the database, data processing, and file transfer were invoked. The Gatling tool was used to conduct the tests. The tests showed that reactive microservices can be more efficient in particular when there are delays in communication with services or the database. Otherwise, it depends on the complexity of the operations being performed. Microservices based on the reactive paradigm also use less RAM compared to conventional counterparts.
37
Stojanov, Zeljko, Ilija Hristoski, Jelena Stojanov, and Aleksandra Stojkov. "Research Trends and Recommendations for Future Microservices Research." Proceedings of the Institute for System Programming of the RAS 36, no. 1 (2024): 105–30. http://dx.doi.org/10.15514/ispras-2024-36(1)-7.
Full textAbstract:
Microservices are the most promising direction for developing heterogeneous distributed software systems capable of adapting to dynamic changes in business and technology. In addition to the development of new software systems, the migration from legacy monolithic systems to microservice architectures is also a prominent aspect of microservices use. These trends resulted in an increasing number of primary and secondary studies on microservices, stressing the need for systematization of research at a higher level. The objective of this study is to comprehensively analyze secondary studies in the field of microservices with objectives to inquire about publishing trends, research trends, domains of implementation, and future research directions. The study follows the guidelines for conducting a systematic literature review, which resulted in the findings derived from 44 secondary studies. The study findings are structured to address the proposed research objectives. Recommendations for further literature reviews relate to the improvement of quality assessment of selected studies to increase the validity of findings, a more detailed review of human and organizational factors through the microservices life cycle, the use of social science qualitative methods for more detailed analysis of selected studies, and inclusion of gray literature that will bring the real opinions and experiences of experts from industry.
38
Chimakurthi, Venkata Naga Satya Surendra. "Risks of Multi-Cloud Environment: Micro Services Based Architecture and Potential Challenges." ABC Research Alert 5, no. 3 (December 31, 2017): 33—xx. http://dx.doi.org/10.18034/abcra.v5i3.590.
Full textAbstract:
Over the most recent couple of years, a modified programming engineering style has been created to plan new programming applications. This engineering style is especially appropriate for use cases in the avionic business, from an autonomously deployable programming administration. These administrations are worked around business and mission capacities and are freely deployable by completely computerized apparatus. With microservices, a few sorts of uses become simpler to construct and keep up with when they are separated into more modest, composable pieces that cooperate. This is rather than a conventional, "solid" application that is completely evolved in one piece. This paper will talk about, a few parts of microservices-based engineering, including a few potential use cases for the aeronautic trade. The qualities of microservice-based engineering like componentization, association, endpoints, and informing systems. The specialized execution of microservices by auditing containerization, administrations correspondence, and related design parts. Explicit open-source tasks and parts that can be used to fabricate the microservices-based design. An example set of utilization cases.
39
Chimakurthi, Venkata Naga Satya Surendra. "Risks of Multi-Cloud Environment: Micro Services Based Architecture and Potential Challenges." ABC Research Alert 5, no. 3 (December 31, 2017): States. http://dx.doi.org/10.18034/ra.v5i3.590.
Full textAbstract:
Over the most recent couple of years, a modified programming engineering style has been created to plan new programming applications. This engineering style is especially appropriate for use cases in the avionic business, from an autonomously deployable programming administration. These administrations are worked around business and mission capacities and are freely deployable by completely computerized apparatus. With microservices, a few sorts of uses become simpler to construct and keep up with when they are separated into more modest, composable pieces that cooperate. This is rather than a conventional, "solid" application that is completely evolved in one piece. This paper will talk about, a few parts of microservices-based engineering, including a few potential use cases for the aeronautic trade. The qualities of microservice-based engineering like componentization, association, endpoints, and informing systems. The specialized execution of microservices by auditing containerization, administrations correspondence, and related design parts. Explicit open-source tasks and parts that can be used to fabricate the microservices-based design. An example set of utilization cases.
40
Hassan, Sara, Rami Bahsoon, Leandro Minku, and Nour Ali. "Dynamic Evaluation of Microservice Granularity Adaptation." ACM Transactions on Autonomous and Adaptive Systems 16, no. 2 (June 30, 2021): 1–35. http://dx.doi.org/10.1145/3502724.
Full textAbstract:
Microservices have gained acceptance in software industries as an emerging architectural style for autonomic, scalable, and more reliable computing. Among the critical microservice architecture design decisions is when to adapt the granularity of a microservice architecture by merging/decomposing microservices. No existing work investigates the following question: How can we reason about the trade-off between predicted benefits and cost of pursuing microservice granularity adaptation under uncertainty? To address this question, we provide a novel formulation of the decision problem to pursue granularity adaptation as a real options problem. We propose a novel evaluation process for dynamically evaluating granularity adaptation design decisions under uncertainty. Our process is based on a novel combination of real options and the concept of Bayesian surprises. We show the benefits of our evaluation process by comparing it to four representative industrial microservice runtime monitoring tools, which can be used for retrospective evaluation for granularity adaptation decisions. Our comparison shows that our process can supersede and/or complement these tools. We implement a microservice application—Filmflix—using Amazon Web Service Lambda and use this implementation as a case study to show the unique benefit of our process compared to traditional application of real options analysis.
41
Zholmyrza, B. N., and A. M. Smaiyl. "CITY TRAFFIC SIMULATION ON MICROSERVICES." Bulletin of Shakarim University. Technical Sciences, no. 1(13) (March 29, 2024): 11–15. http://dx.doi.org/10.53360/2788-7995-2024-1(13)-2.
Full textAbstract:
Population growth and urbanization in Kazakhstan have led to significant traffic management problems in large urban areas. Initiatives such as intelligent road systems, real-time traffic information, and traffic management have been implemented to address these issues. However, congestion and delays remain as major problems. Effective traffic modeling is necessary to understand traffic patterns, identify bottlenecks, and implement effective solutions for reducing congestion. Microservice architecture has recently become a trend owing to its advantages, and the authors of this paper propose the use of microservices for urban traffic modeling to solve these problems. In this study, any moving object between two points: a car, a bicyclist, or a pedestrian – was presented as an actor. Each actor is represented as a microservice. They communicate their movements through city microservice. After sending their movements, a red line is displayed on the map, indicating their travel paths. This solution helps to simulate movement more realistically because each microservice is independent and can move randomly.
42
Spasiteleva, Svitlana, Ivan Chychkan, Svitlana Shevchenko, and Yulia Zhdanovа. "DEVELOPMENT OF SECURE CONTAINERIZED APPLICATIONS WITH A MICROSERVICES ARCHITECTURE." Cybersecurity: Education, Science, Technique 1, no. 21 (2023): 193–210. http://dx.doi.org/10.28925/2663-4023.2023.21.193210.
Full textAbstract:
The article analyzes approaches to software development that allow creating complex container applications with a microservice architecture based on automation tools and flexible development methods. The development of cloud technologies, the global strategy of containerization, the modernization of the application architecture, and the increase in security requirements have led to a change in the application development methodology. The study aims to determine approaches to increase the speed of development, security and quality of software code of containerized applications by implementing security principles and automation tools at all stages of the life cycle. Features and development prospects of microservice applications deployed in a container environment are considered. The advantages of the container infrastructure are defined: mobility, scalability, an additional level of microservice security. Containers provide an isolated environment for running a microservices, this reduces the risk of security vulnerabilities and simplifies interaction between microservices. The article identifies the security problems of microservice applications and the main vulnerabilities associated with the use of containers. It is determined that DevSecOps methodology allows implementing modern practice of continuous integration, continuous delivery, continuous application deployment and integration of security tools at all life cycle stages. DevSecOps describes development processes, deployment and operation processes using Security as Code and Infrastructure as Code practices. The research describes the model for developing and deploying microservice applications with containerization, defines the security domains, and the security controls for DevSecOps development pipeline. Based on this model, the main security control tools that must be used at all development and deployment pipeline stages are defined. The article proves that the considered technique regulates the implementation of given security procedures at all stages of the pipeline, allows to reduce development time and improve code quality for container applications with a microservices architecture.
43
Pontarolli, Ricardo Pasquati, Jeferson André Bigheti, Lucas Borges Rodrigues de Sá, and Eduardo Paciencia Godoy. "Microservice-Oriented Architecture for Industry 4.0." Eng 4, no. 2 (April 19, 2023): 1179–97. http://dx.doi.org/10.3390/eng4020069.
Full textAbstract:
Industry 4.0 (I4.0) is characterized by the integration of digital technologies into manufacturing processes and highlights new requirements for industrial systems such as greater interoperability, decentralization, modularization, and independence. The traditional hierarchical architecture of Industrial Automation Systems (IAS) does not fulfill these requirements and is evolving to incorporate information technologies in order to support I4.0 applications. The integration among these technologies, equipment, and systems at different industry levels requires a migration from the legacy vertical architecture to a flat architecture based on services. Service-oriented architecture (SOA) and, more recently, microservices play a critical role in I4.0 by providing a framework for integrating complex systems and meeting those requirements. This paper presents the development of a Microservice-Oriented Architecture for Industry 4.0 (MOAI), initially focused on evolving IAS to the I4.0. The objective is to describe the development, deployment, and testing of an IAS architecture based on microservices prepared for I4.0 applications. On the contrary to developing the whole software for the industrial SOA, the MOAI was developed on top of the Moleculer framework, which allowed focusing on creating services and applications for the automation and process control industry context. The development of several microservices and security mechanisms for the MOAI is presented, as is the deployment of IAS applications as services such as process control, SCADA, discrete automation, among others. The MOAI was implemented in a process control pilot plant for experimentation. Experimental results of the MOAI for IAS applications are investigated, the microservice communication performance is evaluated, and the pros and cons of microservices for I4.0 are discussed.
44
Gavrilin, D. N., I. A. Kustova, and A. V. Mantsivoda. "Object Models as Microservices: a Query Language." Bulletin of Irkutsk State University. Series Mathematics 42 (2022): 121–37. http://dx.doi.org/10.26516/1997-7670.2022.42.121.
Full textAbstract:
We are designing an application development technology based on an extended object-oriented approach, in which object models are enriched to the functionality of microservices. This variation is called microservice object-oriented programming. An object model as a microservice is an autonomous information system that behaves as a persistent storage and interacts with other models and external actors through the API. Moreover, understanding object models as microservices provides a fundamentally new low-code technology based on model visualization. This paper presents a query language for object models that works efficiently with persistent models. It is a subset of the Libretto language. The logical semantics of the language is described, as well as the method of compiling it into SQL, based on the use of an intermediate relational language. A SQL query language compiler has been implemented within the Ontobox platform. It shows high efficiency and is now actively used in real-life application development tasks solving.
45
Suljkanović, Alen, Branko Milosavljević, Vladimir Inđić, and Igor Dejanović. "Developing Microservice-Based Applications Using the Silvera Domain-Specific Language." Applied Sciences 12, no. 13 (July 1, 2022): 6679. http://dx.doi.org/10.3390/app12136679.
Full textAbstract:
Microservice Architecture (MSA) is a rising trend in software architecture design. Applications based on MSA are distributed applications whose components are microservices. MSA has already been adopted with great success by numerous companies, and a significant number of published papers discuss its advantages. However, the results of recent studies show that there are several important challenges in the adoption of microservices such as finding the right decomposition approach, heterogeneous technology stacks, lack of relevant skills, out-of-date documentation, etc. In this paper, we present Silvera, a Domain-Specific Language (DSL), and a compiler for accelerating the development of microservices. Silvera is a declarative language that allows users to model the architecture of microservice-based systems. It is designed so that it can be used both by inexperienced and experienced developers. The following characteristics distinguish Silvera from similar tools: (i) lightweight and editor-agnostic language, (ii) built with heterogeneity in mind, (iii) uses microservice-tailored metrics to evaluate the architecture of the designed system, and (iv) automatically generates the documentation. Silvera’s retargetable compiler transforms models into runnable code and produces the documentation for each microservice in the model. The compiler can produce code for any programming language or framework since code generators are registered as plugins. We present a case study that illustrates the use of Silvera and also discuss some current limitations and development directions. To evaluate Silvera, we conducted a survey based on A Framework for Qualitative Assessment of DSLs (FQAD), where we focused on the following DSL characteristics: functional suitability, usability, reliability, productivity, extendability, and expressiveness. Overall, the survey results show that Silvera satisfies these characteristics.
46
Petrakis, Euripides G. M., Vasileios Skevakis, Panayiotis Eliades, Alkiviadis Aznavouridis, and Konstantinos Tsakos. "ModSoft-HP: Fuzzy Microservices Placement in Kubernetes." Electronics 13, no. 1 (December 22, 2023): 65. http://dx.doi.org/10.3390/electronics13010065.
Full textAbstract:
The growing popularity of microservices architectures generated the need for tools that orchestrate their deployment in containerized infrastructures, such as Kubernetes. Microservices running in separate containers are packed in pods and placed in virtual machines (nodes). For applications with multiple communicating microservices, the decision of which services should be placed in the same node has a certain impact on both the running time and the operation cost of an application. The default Kubernetes scheduler is not optimal in that case. In this work, the service placement problem is treated as graph clustering. An application is modeled using a graph with nodes and edges representing communicating microservices. Graph clustering partitions the graph into clusters of microservices with high-affinity rates. Then, the microservices of each cluster are placed in the same Kubernetes node. A class of methods resorts to hard clustering (i.e., each microservice is placed in exactly one node). We advocate that graph clustering should be fuzzy to allow high-utilized microservices to run in more than one instance (i.e., pods) in different nodes. ModSoft-HP Scheduler is a custom Kubernetes scheduler that takes scheduling decisions based on the results of the ModSoft fuzzy clustering method followed by heuristic packing (HP). For proof of concept, the workloads of two applications (i.e., an e-commerce application, eShop, and an IoT architecture) are given as input to the default Kubernetes Scheduler, the Bisecting K-means, and the Heuristic First Fit (hard) clustering schedulers and to the ModSoft-HP fuzzy clustering method. The experimental results demonstrate that ModSoft-HP can achieve up to 90% reduction of egress traffic, up to 20% savings in response time, and up to 25% less hosting costs compared to service placement with the default Kubernetes Scheduler in the Google Kubernetes Engine.
47
Li, Zheng, Diego Seco, and Alexis Sánchez Rodríguez. "Microservice-Oriented Platform for Internet of Big Data Analytics: A Proof of Concept." Sensors 19, no. 5 (March 6, 2019): 1134. http://dx.doi.org/10.3390/s19051134.
Full textAbstract:
The ubiquitous Internet of Things (IoT) devices nowadays are generating various and numerous data from everywhere at any time. Since it is not always necessary to centralize and analyze IoT data cumulatively (e.g., the Monte Carlo analytics and Convergence analytics demonstrated in this article), the traditional implementations of big data analytics (BDA) will suffer from unnecessary and expensive data transmissions as a result of the tight coupling between computing resource management and data processing logics. Inspired by software-defined infrastructure (SDI), we propose the “microservice-oriented platform” to break the environmental monolith and further decouple data processing logics from their underlying resource management in order to facilitate BDA implementations in the IoT environment (which we name “IoBDA”). Given predesigned standard microservices with respect to specific data processing logics, the proposed platform is expected to largely reduce the complexity in and relieve inexperienced practices of IoBDA implementations. The potential contributions to the relevant communities include (1) new theories of a microservice-oriented platform on top of SDI and (2) a functional microservice-oriented platform for IoBDA with a group of predesigned microservices.
48
Huang, Hsin-Yu, Yong-Yi Fanjiang, Chi-Huang Hung, Hsing-Yu Tsai, and Bing-Hong Lin. "Evaluation of a Smart Intercom Microservice System Based on the Cloud of Things." Electronics 12, no. 11 (May 25, 2023): 2406. http://dx.doi.org/10.3390/electronics12112406.
Full textAbstract:
This research migrates a monolithic smart intercom system to a microservice architecture, making the system more secure, stable, and scalable. The security mechanisms of the instant messaging platform are combined with microservices to improve the security of the system. The stability and performance of microservices are shown to be better than those of monolithic services through experimental tests. Residents can use different instant messaging software instead of the handset to improve the convenience of using this system. This system also implements community broadcasts, platform broadcasts, unit broadcasts, and family broadcasts to exchange messages across different instant messaging platforms. This paper proposes OpenAPI for other smart intercoms to integrate this system’s services and resources. In addition, this study deploys two microservice architectures using a native load balancer with a kube proxy and a service mesh load balancer with an istio proxy. Experiments were conducted during which residents tested the kube proxy and the istio proxy using stress testing tools on two microservice architectures, and the results showed that the kube proxy was slightly better than the istio proxy.
49
Stojkov, Aleksandra, and Zeljko Stojanov. "Review of methods for migrating software systems to microservices architecture." Journal of Engineering Management and Competitiveness 11, no. 2 (2021): 152–62. http://dx.doi.org/10.5937/jemc2102152s.
Full textAbstract:
Majority of software systems in business use, known as legacy systems, have monolithic structure hard to maintain and upgrade with new features. The most common option to overcome this situation is reengineering of existing software systems, which can be perform in different ways and with different outcomes. One of the recent most popular approaches is migration to microservices architectures, which makes distribution of software functionalities in small and independent units possible. Each unit, called microservice is self-contained and independent, which makes system manipulation and modification easier. Several methods for migration to microservice architecture have recently been proposed. This article presents a review of methods for migrating existing systems towards microservices. In addition, this article presents software artifacts affected by migration methods and used algorithms. Implications and benefits of the presented study, as well as validity issues are discussed, followed with concluding remarks and future research directions.
50
Kim, Gu Min, Song Heon Jeong, and Kyung Baek Kim. "Open Policy Agent based Multilateral Microservice Access Control Policy." Korean Institute of Smart Media 12, no. 9 (October 30, 2023): 60–71. http://dx.doi.org/10.30693/smj.2023.12.9.60.
Full textAbstract:
A microservice architecture that accommodates the heterogeneity of various development environments and enables flexible maintenance can secure business agility to manage services in line with rapidly changing requirements. Due to the nature of MSA, where communication between microservices within a service is frequent, the boundary security that has been used in the past is not sufficient in terms of security, and a Zerotrust system is required. In addition, as the size of microservices increases, definition of access control policies according to the API format of each service is required, and difficulties in policy management increase, such as unnecessary governance overhead in the process of redistributing services. In this paper, we propose a microservice architecture that centrally manages policies by separating access control decision and enforcement with a general-purpose policy engine called OPA (Open Policy Agent) for collective and flexible policy management in Zerotrust security-applied environments.