Microservice-based Application Research Articles

Deployment and Analysis of Microservice-Based Application in Different Cloud Environment

Deployment and Analysis of Microservice-Based Application in Different Cloud Environment

Secure software development and testing: A model-based methodology

Modern industries widely rely upon software and IT services, in a context where cybercrime is rapidly spreading in more and more sectors. Unfortunately, despite greater general awareness of security risks and the availability of security tools that can help to cope with those risks, many organizations (especially medium/small-size ones) still lag when it comes to building security into their services. This is mainly due to the limited security skills of common developers/IT project managers and to the typically high costs of security procedures. In fact, while automated tools exist to perform code analysis, vulnerability scanning, or security testing, the manual intervention of security experts is still required not only for security analysis and design, but also to configure and elaborate the output of the security testing tools.In this paper, we propose a novel secure software development methodology aimed at supporting developers from security design to security testing, suitable for integration within modern DevOps pipelines according to a DevSecOps (or SecDevOps) approach. The proposed methodology leverages a model-based process that enables identifying existing threats, selecting appropriate countermeasures to enforce, and verify their mitigation effectiveness through both static assessment procedures and targeted security tests. To demonstrate our approach's feasibility and concretely illustrate the devised activities, we provide a step-by-step description of the whole process concerning a containerized microservice-based application case study. In addition, we discuss the application of the proposed methodology, in its threat modeling and security testing phases, to a well-known vulnerable web application widely used for security training purposes, to illustrate that we can identify most of the existing vulnerabilities and determine appropriate test plans to assess and mitigate such vulnerabilities.

Estimating Multiclass Service Demand Distributions Using Markovian Arrival Processes

Building performance models for software services in DevOps is costly and error-prone. Accurate service demand distribution estimation is critical to precisely modeling queueing behaviors and performance prediction. However, current estimation methods focus on capturing the mean service demand, disregarding higher-order moments of the distribution that still can largely affect prediction accuracy. To address this limitation, we propose to estimate higher moments of the service demand distribution for a microservice from monitoring traces. We first generate a closed queueing model to abstract software performance and use it to model the departure process of requests completed by the software service as a Markovian arrival process (MAP). This allows formulating the estimation of service demand into an optimization problem, which aims to find the first multiple moments of the service demand distribution that maximize the likelihood of the MAP using generated the measured inter-departure times. We then estimate the service demand distribution for different classes of service with a maximum likelihood algorithm and novel heuristics to mitigate the computational cost of the optimization process for scalability. We apply our method to real traces from a microservice-based application and demonstrate that its estimations lead to greater prediction accuracy than exponential distributions assumed in traditional service demand estimation approaches for software services.

Adaptive Management of Volatile Edge Systems at Runtime With Satisfiability

Edge computing offers the possibility of deploying applications at the edge of the network. To take advantage of available devices’ distributed resources, applications often are structured as microservices, often having stringent requirements of low latency and high availability. However, a decentralized edge system that the application may be intended for is characterized by high volatility, due to devices making up the system being unreliable or leaving the network unexpectedly. This makes application deployment and assurance that it will continue to operate under volatility challenging. We propose an adaptive framework capable of deploying and efficiently maintaining a microservice-based application at runtime, by tackling two intertwined problems: (i) finding a microservice placement across device hosts and (ii) deriving invocation paths that serve it. Our objective is to maintain correct functionality by satisfying given requirements in terms of end-to-end latency and availability, in a volatile edge environment. We evaluate our solution quantitatively by considering performance and failure recovery.

Swarm-Like Distributed Algorithm for Scheduling a Microservice-Based Application to the Cloud Servers

Introduction of virtualization containers and container orchestrators fundamentally changed the landscape of cloud application development. Containers provide an ideal way for practical implementation of microservice-based architecture, which allows for repeatable, generic patterns that make the development of reliable, distributed applications more approachable and efficient. Orchestrators allow for shifting the accidental complexity from inside of an application into the automated cloud infrastructure. Existing container orchestrators are centralized systems that schedule containers to the cloud servers only at their startup. In this paper, we propose a swarm-like distributed cloud management system that uses live migration of containers to dynamically reassign application components to the different servers. It is based on the idea of “pheromone” robots. An additional mobile agent process is placed inside each application container to control the migration process. The number of parallel container migrations needed to reach an optimal state of the cloud is obtained using models, experiments, and simulations. We show that in the most common scenarios the proposed swarm-like algorithm performs better than existing systems, and due to its architecture it is also more scalable and resilient to container death. It also adapts to the influx of containers and addition of new servers to the cloud automatically.

Microservices Backlog–A Genetic Programming Technique for Identification and Evaluation of Microservices From User Stories

The microservice granularity directly affects the quality attributes and usage of computational resources of the system, determining optimal microservice granularity is an open research topic. Microservices granularity is defined by the number of operations exposed by the microservice, the number of microservices that compose the whole application, and its complexity and dependencies. This paper describes “Microservice Backlog (MB)”, a semiautomatic model for defining and evaluating the granularity of microservice-based applications; MB uses genetic programming technique to calculate at design time the granularity of each microservice from the user stories in the “product backlog” or release planning; the genetic algorithm combined coupling, cohesion, granularity, semantic similarity, and complexity metrics to define the number of microservices, and the user stories associated with each microservice. MB decomposes the candidate microservices, allowing to analyze graphically the size of each microservice, as well as its complexity, dependencies, coupling, cohesion metrics, and the number of calls or requests between microservices. The resulting decomposition (number of microservices and their granularity) performed by MB shows less coupling, higher cohesion, less complexity, fewer user stories associated with each microservice, and fewer calls among microservices. MB was validated against three existing methods, using two state-of-the-art applications (Cargo Tracking and JPet-Store), and one real-life application (Foristom Conferences). The development team and/or architect can use metrics to identify the critical points of the system and determine at design time how the microservice-based application will be implemented.

Systematic Approach for Generation of Feasible Deployment Alternatives for Microservices

Microservice architectures rely on the development of modular and independent software units, which typically address a single task and communicate with other microservices via well-defined interfaces. This has several benefits such as easier maintenance and update of services. However, deploying a microservice-based application is often more complicated than a monolithic application. While a monolithic application can be deployed one at a time on a group of similar servers behind a load balancer, a microservice-based application consists of different microservices and each microservice usually has more than one runtime instance that needs to be configured and deployed. For a small number of microservices and applications, the deployment could be done manually. However, a large number of microservices are frequently observed in practice. In such cases, the deployment becomes cumbersome and error-prone and does not scale with the increased number of services. To cope with this problem, we present a systematic approach and the corresponding tool support for enabling the deployment of microservices to resources that have limited capacity. Hereby, we model and define the design space given the deployment parameters and automatically derive the feasible deployment solution. The approach is validated using a taxi-hailing system case study inspired by Uber which has spread all over the world in recent years.

Detecting anomalies in microservices with execution trace comparison

More and more developers and companies have adopted the concept of microservice. Detecting anomalies and locating root causes are important for improving the reliability of microservices. Current approaches typically monitor the metrics of physical resources, and manually set alarm rules. However, they often require domain knowledge to detect anomalies, and cannot locate faulty microservices causing the anomalies accurately. To address the above issues, we propose an anomaly detection approach for microservice application by comparing execution traces. First, we use dynamic instrumentations to collect execution traces across microservices, and then use call trees to describe an application’s execution traces. Then, we calculate the anomaly degree of traces with tree edit distance to detect structural anomalies, and then analyze the difference between traces to locate the components causing the anomalies. Third, we locate suspicious component calls causing the response time fluctuation with principal component analysis to detect response time anomalies. Finally, we have evaluated the approach with a TPC-W based benchmark called as Bench4Q and a typical microservice-based application called as Social Network. The results demonstrate that the approach achieves 81%–97% precision and 75%–99% recall in detecting anomalies caused by injected CPU, network, memory and service faults.

Application deployment using containers with auto-scaling for microservices in cloud environment

A microservice-based application is composed of a set of small services that run within their own processes and communicate with a lightweight mechanism. Processing the microservices efficiently with minimum processing time and cost, while utilizing the computing resources efficiently, is a challenging task in a cloud environment. To address this challenge, in this paper, we propose a new container-aware application scheduling strategy with an auto-scaling policy. The proposed strategy deploys the requested applications on the best-fit lightweight containers, with minimum deployment time, based on the resource requirements. Another important issue of the container-aware cloud environment is the cold start effect, which is solved using a rule-based policy in the proposed work for minimizing deployment time and cost of the applications. Furthermore, a dynamic bin-packing strategy is designed for deploying the applications to the minimum number of physical machines (PMs) with efficient utilization of the computing resources. Finally, a heuristic-based auto-scaling policy has been designed for minimizing the wastage of the computing resources in the cloud data center. Through numerical evaluation, we have shown the superiority of the proposed method over the existing state-of-the-art algorithms in terms of processing time, processing cost, resource utilization, and required numbers of PMs.

Performance Modeling and Workflow Scheduling of Microservice-Based Applications in Clouds

Microservice has been increasingly recognized as a promising architectural style for constructing large-scale cloud-based applications within and across organizational boundaries. This microservice-based architecture greatly increases application scalability, but meanwhile incurs an expensive performance overhead, which calls for a careful design of performance modeling and task scheduling. However, these problems have thus far remained largely unexplored. In this paper, we develop a performance modeling and prediction method for independent microservices, design a three-layer performance model for microservice-based applications, formulate a Microservice-based Application Workflow Scheduling problem for minimum end-to-end delay under a user-specified Budget Constraint (MAWS-BC), and propose a heuristic microservice scheduling algorithm. The performance modeling and prediction method are validated and justified by experimental results generated through a well-known microservice benchmark on disparate computing nodes, and the performance superiority of the proposed scheduling solution is illustrated by extensive simulation results in comparison with existing algorithms.

A lightweight decentralized service placement policy for performance optimization in fog computing

A decentralized optimization policy for service placement in fog computing is presented. The optimization is addressed to place most popular services as closer to the users as possible. The experimental validation is done in the iFogSim simulator and by comparing our algorithm with the simulator’s built-in policy. The simulation is characterized by modeling a microservice-based application for different experiment sizes. Results showed that our decentralized algorithm places most popular services closer to users, improving network usage and service latency of the most requested applications, at the expense of a latency increment for the less requested services and a greater number of service migrations.

KaliGreen: A distributed Scheduler for Energy Saving

A commonplace issue with portable technology is battery efficiency. While many industries are trying their best to improve battery life without sacrificing a products quality and efficiency, we believe that further can be done to improve battery consumption on ones mobile devicefrom tablets to smartphones to laptops to everything else. Many applications on these devices are based on a microservice architecture.In this article, we introduce a new algorithm KaliGreen that can maneuver the microservices within a network of devices in order to maximize the run-time of a microservice-based application; moreover, KaliGreen allows a 54% increase in the average run-time of an application by shifting microservices from 6 devices (as example) with low battery or inefficient processing ratios to devices in better conditions. To achieve this, KaliGreen utilizes KaliMucho middleware, which is able manipulate microservices in run-time. This algorithm provides a plausible solution to maximizing energy consumption within a network of devices.

Method for Designing Scalable Microservice-based Application Systematically: A Case Study

Microservice is a new transformation of Service-Oriented Architecture (SOA) which is gaining momentum in both academic and industry. The success of microservice began when giant companies like Netflix used them as a service architecture for the purpose of serving customers. Monolithic architecture used by Netflix previously was no longer able to cope with business development and it is difficult to scale to meet user demands. Although Netflix has been successful with microservice architecture, there is no systematic method introduced to produce microservice. Academic studies related to microservice are still in the early stages and have not yet reached maturity. Microservice is seen to require a method that helps organizations to systematically design microservices and replicate the success achieved by Netflix. In forming a method for this systematic microservice then the methods for building an existing microservice are studied. Based on the Design Science Research method, two research artefacts have been produced. The first artefact is a systematic design of microservice that has four main steps. The second artefact is the instantiation by applying the proposed microservice design method to the case studies, namely, MyFlix. Next the evaluation is made on the new method produced by obtaining expert opinions through the process of demonstration and interviewing. The expert assessment results found that the proposed method was able to produce a systematic microservice design based on the six proposed principles and the four main steps. This method can also produce a complete feature microservice such as cohesive, loose coupling, distributed and decentralized that will contribute to the production of scalable system.