Search

Container-based virtualization is a popular technique, e.g., to realize microservice architectures. Recently, containers became popular in Industry 4.0 / IIoT systems, which typically consist of hundreds of (edge) devices and machines. In such setups, efficient management of containers is essential as offered by container orchestrators like Kubernetes. However, currently no specific overviews discussing orchestrator capabilities for Industry 4.0 are available. In this paper, we analyze nine open source container orchestrators for their application in Industry 4.0 or IIoT settings as a basis for future research and development. We contribute a systematic literature review to identify 23 basic orchestration requirements. We complement this by insights from an intensive requirements collection in a research project on intelligent industrial production, as well as selected features from a published generic orchestrator analysis. From these 66 requirements, we derive a requirements/feature taxonomy, which we use to analyze the nine open source orchestrators including Kubernetes. We show that there is, e.g., still a lack of support regarding edge devices, IIoT protocols, security mechanisms, and specialized resources for artificial intelligence. [ABSTRACT FROM AUTHOR]

Kubernetes is a well-known open source project that provides a powerful orchestration platform for containerized applications. To ensure high scalability and availability of services, redundant deployment is usually adopted in Kubernetes clusters, creating multiple replicas for each application. Each replica of a stateful application needs to persistently store data and use a leader-based consistency maintenance mechanism to ensure strong consistency among replicas. In this mechanism, the elected leader is responsible for updating data and synchronizing it to the followers, which results in a higher workload for the leader. When there are multiple stateful applications, the Kubernetes leader election algorithm does not consider the distribution of multiple leaders among nodes, which may lead to the phenomenon of too many leaders on some nodes. This can reduce system performance due to the high workload of the leaders themselves. To address this problem, we propose a balanced leader election algorithm based on replica distribution, which enables multiple stateful application leaders to be evenly distributed among the cluster's worker nodes. The algorithm effectively solves the problem of system performance degradation caused by leader concentration and achieves load balancing among nodes. We verify the effectiveness of the algorithm through experiments. [ABSTRACT FROM AUTHOR]

Edge computing is an emerging paradigm that enables low-latency and high-performance computing at the network edge. However, effectively scheduling complex and interdependent tasks on heterogeneous and dynamic edge computing nodes presents a significant challenge in meeting users' real-time response requirements. To solve this problem, a DGCQN scheduling network that leverages reinforcement learning and graph convolutional neural networks to learn an optimal scheduling strategy is proposed in this paper. The proposed method embeds the graph structure of Directed Acyclic Graph (DAG) tasks and node information of Kubernetes (K8s) clusters into a Q value function, guiding the DQN network in selecting the best action at each step. The method is evaluated across various DAG tasks and edge computing scenarios. Compared with HEFT, DQN, and GOSU, the task completion time of the proposed method is reduced by about 20, 10, and 1.5%, respectively. The results demonstrate the effectiveness of the proposed method. [ABSTRACT FROM AUTHOR]

In recent years, containerization is becoming more and more popular for deploying applications and services and it has significantly contributed to the expansion of edge computing. The demand for effective and scalable container image management, however, increases as the number of containers deployed grows. One solution is to use a localized Docker registry at the edge, where the images are stored closer to the deployment site. This approach can considerably reduce the latency and bandwidth required to download images from a central registry. In addition, it acts as a proactive caching mechanism by optimizing the download delays and the network traffic. In this paper, we introduce an edge-enabled storage framework that incorporates a localized Docker registry. This framework aims to streamline the storage and distribution of container images, providing improved control, scalability, and optimized capabilities for edge deployment. Four demanding XR applications are employed as use cases to experiment with the proposed solution. [ABSTRACT FROM AUTHOR]

As the demand for container technology and platforms increases due to the efficiency of IT resources, various workloads are being containerized. Although there are efforts to integrate various workloads into Kubernetes, the most widely used container platform today, the nature of containers makes it challenging to support persistence for memory-centric workloads like in-memory databases. In this paper, we discuss the drawbacks of one of the persistence support methods used for in-memory databases in a Kubernetes environment, namely, the data snapshot. To address these issues, we propose a compromise solution of using container checkpoints. Through this approach, we can perform checkpointing without incurring additional memory usage due to CoW, which is a problem in fork-based data snapshots during snapshot creation. Additionally, container checkpointing induces up to 7.1 times less downtime compared to the main process-based data snapshot. Furthermore, during database recovery, it is possible to achieve up to 11.3 times faster recovery compared to the data snapshot method. [ABSTRACT FROM AUTHOR]

This work describes an approach to enhance container orchestration platforms with an autonomous and dynamic rescheduling system that aims at improving application service time by co-locating highly interdependent containers for network delay reduction. Unreasonable container consolidation may however lead to host CPU saturation, in turn impairing the service time. The multiobjective approach proposed in this work aims to improve application service-time by minimizing both inter-server network traffic and CPU throttling on overloaded servers. To this extent, the Simulated Annealing combinatorial optimization heuristic is used and compared on its relative performance towards the optimal solution obtained by Mathematical Programming. Additionally, the impact of the proposed system is validated on a Kubernetes cluster hosting three concurrent applications, and this under varying load scenarios. The proposed rescheduling system systematically i) improves the application service-time (up to 27.2% from our experiments) and ii) surpasses the improvement reached by the Kubernetes descheduler. [ABSTRACT FROM AUTHOR]

Edge cloud technologies working in conjunction with AI-powered solutions can help surmount the challenges associated with the distributed execution of immersive services and contribute to delivering a positive end-user experience. Intelligent resource management, orchestration, and predictive systems can enhance service deployment, adapt to changing demands, and ensure seamless service operation. This paper introduces an innovative architectural paradigm that enables multi-domain edge orchestration for highly distributed immersive services by leveraging various AI solutions and technological tools to support multi-domain edge deployments. The proposed architecture is designed to function based on multi-level specification blueprints, separating high-level user-intent infrastructure definition from AI-driven orchestration and the final execution plan. This architectural design enables the incorporation of AI solutions to be conducted in a modular manner. Furthermore, the Application Management Framework provides a visual language and tool as an alternative to formal methods for creating intent blueprints. The proposed architecture is evaluated within the frame of an immersive virtual touring use-case scenario. [ABSTRACT FROM AUTHOR]

Microservices are containerized, loosely coupled, interactive smaller units of the application that can be deployed, reused, and maintained independently. In a microservices-based application, allocating the right computing resources for each containerized microservice is important to meet the specific performance requirements while minimizing the infrastructure cost. Microservices-based applications are easy to scale automatically based on incoming workload and resource demand automatically. However, it is challenging to identify the right amount of resources for containers hosting microservices and then allocate them dynamically during the auto-scaling. Existing auto-scaling solutions for microservices focus on identifying the appropriate time and number of containers to be added/removed dynamically for an application. However, they do not address the issue of selecting the right amount of resources, such as CPU cores, for individual containers during each scaling event. This paper presents a novel approach to dynamically allocate the CPU resources to the containerized microservice during the autoscaling events. Our proposed approach is based on the machine learning method, which can identify the right amount of CPU resources for each container, dynamically spawning for the microservices over time to satisfy the application's response time requirements. The proposed solution is evaluated using a benchmark microservices-based application based on real-world workloads on the Kubernetes cluster. The experimental results show that the proposed solution outperforms by yielding a 40% to 60% reduction in violating the response time requirements with 0.5 × to 1.5 × less cost compared to the state-of-art baseline methods. [ABSTRACT FROM AUTHOR]

The utilization of cloud computing in Internet of Things (IoT) applications has become widespread. However, it presents challenges for latency-sensitive scenarios due to data transmission to the centralized cloud structure, which leads to increased network traffic and service delays. To address this, fog computing has emerged as an intermediary layer between the cloud and IoT, ensuring low-latency interactions. A pivotal challenge within the fog computing paradigm is the service placement problem, involving assigning services to appropriate nodes, which is recognized as NP-hard. Recognizing the intricate nature of service placement, this study introduces a multi-objective optimization approach tailored for dynamic service placement within container-based fog computing environments. Considering multiple objectives is imperative due to the complex interplay of performance metrics in fog computing scenarios. A two-tier resource management framework based on Kubernetes is proposed to manage these diverse yet interrelated objectives effectively. The framework harnesses the power of the multi-objective, non-dominated sorting genetic algorithm II (NSGA-II) to reconcile conflicting objectives and facilitate optimal service placement decisions. Incorporating multi-objective optimization enables a comprehensive evaluation of service placement solutions, ensuring a balanced trade-off between latency, cost-efficiency, and energy consumption. Empirical evaluations demonstrate that the proposed method improves cost, average latency time, and energy consumption by 8% to 36% compared to state-of-the-art methods. [ABSTRACT FROM AUTHOR]

MotionInsights facilitates object detection and tracking from multiple video streams in real-time. Leveraging the distributed stream processing capabilities of Apache Flink and Apache Kafka (as an intermediate message broker), the system models video processing as a data flow stream processing pipeline. Each video frame is split into smaller blocks, which are dispatched to be processed in parallel by a number of Flink operators. In the first stage, each block undergoes background subtraction and component labeling. The connected components from each frame are grouped, and the eligible components are merged into objects. In the last stage of the pipeline, all objects from each frame are concentrated to produce the trajectory of each object. The Flink application is deployed as a Kubernetes cluster in the Google Cloud Platform. Experimenting in a Flink cluster with 7 machines, revealed that MotionInsights achieves up to 6 times speedup compared to a monolithic (nonparallel) implementation while providing accurate trajectory patterns. The highest (i.e., more than 6 times) speed-up was observed with video streams of the highest resolution. Compared to existing systems that use custom or proprietary architectures, MotionInsights is independent of the underlying hardware platform and can be deployed on common CPU architectures and the cloud. [ABSTRACT FROM AUTHOR]

Most existing autoscaling approaches help to avoid violating the performance-related Service Level Objectives (SLO). However, these solutions do not aim to recover the SLO. The proposed novel autoscaling solution covers both SLO violation avoidance and recovery. The SLO failure avoidance part of the solution aims to avoid SLO violations by adjusting autoscaling thresholds based on compliance with SLO. It also dynamically selects the required CPU threshold, cooldown intervals and the number of replicas based on load velocity. The recovery part of the solution aims to recover SLO by additional resource provisioning if SLO is violated due to a delay or resource underestimation. The proposed implementation of the solution targets embarrassingly parallel workloads. It is compared with two autoscaling solutions in five workload scenarios, evaluating the ability of the solution to operate close to the defined SLO values. The results show that the proposed solution provides sufficient resources to support or recover performance-based SLOs. [ABSTRACT FROM AUTHOR]

Decreasing carbon emissions of data centers while guaranteeing Quality of Service (QoS) is one of the major challenges for efficient resource management of large-scale cloud infrastructures and societal sustainability. Previous works in the area of carbon reduction mostly focus on decreasing overall energy consumption, replacing energy sources with renewable ones, and migrating workloads to locations where lower emissions are expected. These measures do not consider the energy mix of the power used for the data center. In other words, all KWh of energy are considered the same from the point of view of emissions, which is rarely the case in practice. In this paper, we overcome this deficit by proposing a novel practical CO2-aware workload scheduling algorithm implemented in the Kubernetes orchestrator to shift non-critical jobs in time. The proposed algorithm predicts future CO2 emissions by using historical data of energy generation, selects time-shiftable jobs, and creates job schedules utilizing greedy sub-optimal CO2 decisions. The proposed algorithm is implemented using Kubernetes' scheduler extender solution due to its ease of deployment with little overheads. The algorithm is evaluated with real-world workload traces and compared to the default Kubernetes scheduling implementation on several actual scenarios. [ABSTRACT FROM AUTHOR]

Edge architectures provide local, decentralized services, enabling balancing network traffic and distributing hardware resources. Later, many new use cases can be implemented by combining the advantages of the edge computing concept with the services of 5G systems. One of the biggest beneficiaries of this could be the Vehicle-to-Cloud (V2C) technology, where it is necessary to efficiently process large amounts of data resulting from Vehicle-to-Everything communication (V2X) services. In specific use cases, this makes it possible to process sensor data collectively, enhanced by fusion, which promotes a more effective virtual representation of the real world. The effective implementation of these technologies is a complex task. One of the most important steps before tests on actual infrastructures with real vehicles is evaluating and validating edge cloud systems. We present a solution for this problem, the Cloud-in-the-Loop (CiL) simulation framework. It can orchestrate a real-size, telco-grade level, Kubernetes-based edge cloud infrastructure based on information gathered from a traffic simulator and performing fine-grained benchmarking and data collection. In addition to the performance analysis of the edge system, it also enables an in-depth examination of cloud-native applications serving complex automotive use cases. In this paper, we focus on presenting the developed framework and its capabilities by utilizing the system with implemented test applications, and give an example of testing QoS and QoE aspects of the edge cloud-based V2C concept. [ABSTRACT FROM AUTHOR]

The internet has reached a mature stage of development, and Online Social Media (OSM) platforms such as Twitter and Facebook have become vital channels for public communication and discussion on matters of public interest. However, these platforms are often plagued by improper statements or content, propagated by anonymous users and trolls, which negatively impact both the platforms and their users. Existing methods for dealing with inappropriate information rely on (semi)-manual offline assessments, which do not fully account for the streaming nature of OSM feeds. In this paper, we implement a robust and decoupled system that considers social media data as streaming data. With a publisher and consumer model, our system can process more than 179 MB of data per second with only 166.3 ms latency using Apache Kafka. Accordingly, we deploy a well-trained transfer learning model to classify incoming data streams, with an accuracy of 0.836. Our proposed architecture has the potential to assist online communities in developing more constructive and flawless OSM platforms. We believe that our contribution will help address the challenges associated with improper content on OSM platforms and pave the way for the development of more effective and efficient solutions. [ABSTRACT FROM AUTHOR]

Cloud applications developed using a microservices approach require a scaling policy that adapts dynamically to the changing resource demand of the microservice while satisfying the application's quality of service (QoS) agreement. Current cloud technologies, including Kubernetes Horizontal Pod Autoscaler (HPA), autoscale microservices based on predefined autoscaling metrics, which require a very good knowledge of the application's resource usage. There is no built-in QoS autoscaling mechanism. In this work, we introduce an intelligent autoscaling module for the horizontal autoscaling of microservices in the cloud. We develop, train, validate, and deploy reinforcement learning (RL) agents on a real-time application using response time as a QoS. The agents, deployed on Google Cloud, can learn the microservices autoscaling resource usage metrics from the cloud environment and customize the Kubernetes HPA while minimizing response time. Our results show a decrease in response time compared to the default Kubernetes HPA. The agents provide an extendible autoscaling plug-in module that can adapt to new QoS metrics. [ABSTRACT FROM AUTHOR]

The microservice architecture has several advantages over conventional monolithic architectures, such as the ability to develop and deploy services independently and flexibility in dealing with bottlenecks. Most existing works in this field have focused on methodologies by which to divide monolithic systems into microservices, paying little or no attention to the target platform or migration tools, despite the profound effects that they can have on system migration. For a monolithic and service-oriented application, the go-to frameworks and platforms for migration to a microservice architecture are Spring Cloud and Kubernetes. This paper compares the pros and cons of the two approaches and presents experiments involving a stress-testing tool to elucidate performance and scalability under various conditions. [ABSTRACT FROM AUTHOR]

Recent WebAssembly advancements including better programming language support and the introduction of both the WebAssembly System Interface, and the WebAssembly Component Model, have transformed it from primarily a client-side technology to a server-side one as well. The advantages associated with WebAssembly, such as cross platform portability, small software artifacts sizes, fast start up times, and per execution isolation make it a good fit for serverless scenarios. While there are existing initiatives for using WebAssembly in such serverless contexts, orchestration is still an open question. To overcome this issue, we present a way for extending Kubernetes, allowing it to orchestrate natively executed WebAssembly modules, in addition to containers. We describe an extension to an existing WebAssembly software shim for containerd and a new Kubernetes WebAssembly operator. Benchmarking results from the proposed solution obtained using 9 serverless functions packaged both as WebAssembly modules and OpenFaaS functions running in containers, show that WebAssembly has clear advantages for frequently executed serverless functions which require elasticity. WebAssembly functions enjoy two times faster deployment times and at least an order of magnitude smaller artifact sizes while still offering comparable execution performance. However, when it comes to sustained performance for long running serverless functions with processor intensive workloads, containers are the preferred choice, compensating for the increased cold start times with faster execution times. [ABSTRACT FROM AUTHOR]

In case of an emergency situation, it is required to come up with solutions quickly. The supporting decision-making process should therefore be based on relevant data sources which are fed to data processing pipelines. These data sources may however be located in different domains of distinct organizations. Although the technical realisation of cross-organizational data pipelines is possible, for example using a federated Kubernetes cluster managed by a central operator, it is unclear how those pipelines should be scheduled among the participating organizations. Firstly, the cross-organizational infrastructure is unknown and highly heterogeneous, and secondly, there may be undiscovered scheduling preferences present. The first issue can be solved using software probes, while the second issue will be solved through an extension of this probing concept. During the proposed inter-domain scheduling process, organizations may specify monetary reward requirements and requirements on the maximum load they wish to bear. The former allows administrators to specify a lower limit with respect to payment they request for their contribution, the latter allows the specification of an upper limit on the workload an organization wishes to process. This way, mismatching expectations on contribution level, which may potentially cause harm from the hosting organization perspective, are prevented, increasing the trust level of contributors. These kinds of requirements have nothing to do with the technical assessment of a node, but they do impact scheduling decisions and performance of an application, as shown in our evaluation. The proposed scheduling flow not only allows organizations to steer scheduling decisions, but also to negotiate requirements among each other, giving rise to ad hoc conflict resolution all the while collaborating in solving the emergency situation. [ABSTRACT FROM AUTHOR]

As cloud services expand, the need to improve the performance of data center infrastructure becomes more important. High-performance computing, advanced networking solutions, and resource optimization strategies can help data centers maintain the speed and efficiency necessary to provide high-quality cloud services. Running containerized applications is one such optimization strategy, offering benefits such as improved portability, enhanced security, better resource utilization, faster deployment and scaling, and improved integration and interoperability. These benefits can help organizations improve their application deployment and management, enabling them to respond more quickly and effectively to dynamic business needs. Kubernetes is a container orchestration system designed to automate the deployment, scaling, and management of containerized applications. One of its key features is the ability to schedule the deployment and execution of containers across a cluster of nodes using a scheduling algorithm. This algorithm determines the best placement of containers on the available nodes in the cluster. In this paper, we provide a comprehensive review of various scheduling algorithms in the context of Kubernetes. We characterize and group them into four sub-categories: generic scheduling, multi-objective optimization-based scheduling, AI-focused scheduling, and autoscaling enabled scheduling, and identify gaps and issues that require further research. [ABSTRACT FROM AUTHOR]

With the development of cloud-native technologies, Kubernetes becomes the standard of fact for container scheduling. Kubernetes provides service discovery and scheduling of containers, load balancing, service self-healing, elastic scaling, storage volumes, etc. Although Kubernetes is mature with advanced features, it does not consider reducing the cost in Kubernetes clouds using the factor of communication frequent between pods while scheduling pods, nor does it have a rescheduling mechanism to save cost. Hence, we propose a cost-efficient scheduling algorithm and a rescheduling algorithm to reduce the cost of communication-intensive and periodically changing web applications deployed in Kubernetes, respectively. Network communication-intensive pods are scheduled to the same node by the scheduling algorithm based on Improved Beetle Antennae Search. According to the changing pod intimacy relationship, the rescheduling algorithm is completed through the replacement of new and old pods to reduce the cost. In addition, this paper evaluates the proposed algorithms in terms of cost and performance on a Kubernetes cloud. The result shows that the cost consumption of Kubernetes clusters in cloud environment is reduced by 20.97% on average compared with the default Kubernetes framework. [ABSTRACT FROM AUTHOR]

The popularization of Hadoop as the the-facto standard platform for data analytics in the context of Big Data applications has led to the upsurge of SQL-on-Hadoop systems, which provide scalable query execution engines allowing the use of SQL queries on data stored in HDFS. In this context, Kubernetes appears as the leading choice to simplify the deployment and scaling of containerized applications; however, there is a lack of studies about the performance of SQL-on-Hadoop systems deployed on Kubernetes, and this is the gap we intend to fill in this paper. We present an experimental study involving four representative SQL scalable platforms: Apache Drill, Apache Hive, Apache Spark SQL and Trino. Concretely, we analyze the performance of these systems when they are deployed on a Hadoop cluster with Kubernetes by using the TPC-H benchmark. The results of our study can help practitioners and users about what they can expect in terms of performance if they plan to use the advantages of Kubernetes to deploy applications using the analyzed SQL scalable platforms. [ABSTRACT FROM AUTHOR]

Video2Flink is a distributed highly scalable video processing system for bounded (i.e., stored) or unbounded (i.e., continuous) and real-time video streams with the same efficiency. It shows how complicated video processing tasks can be expressed and executed as pipelined data flows on Apache Flink, an open-source stream processing platform. Video2Flink uses Apache Kafka to facilitate the machine-to-machine (m2m) communication between the video production and the video processing system that runs on Apache Flink. Features that make the combination of Apache Kafka and Apache Flink a desirable solution to the problem of video processing are the ease of customization, portability, scalability, and fault tolerance. The application is deployed on a Flink cluster of worker machines that run on Kubernetes in the Google Cloud Platform. The experimental results support our claims of speed showing excellent speed-up results for all tested video resolutions. The highest (i.e., more than seven times) speed-up was observed with the videos of the highest resolutions and in real time. [ABSTRACT FROM AUTHOR]

A group of organizations wishing to collaborate urgently, for example in case of a crisis, need to have a way to quickly deploy applications which enable them to speed up a potentially crisis-resolving decision-making process. A cross-organizational Kubernetes cluster, which is orchestrated by a central operator, allows to initiate these deployments in an ad hoc way. Performance issues may however arise at runtime, for example, a video pipeline belonging to a CCTV camera may produce a too low number of frames per second. The ad hoc cross-organizational collaboration case is especially prone to such issues as the set of candidate nodes and the environment in which they run may not be fully known to the operator. This article therefore motivates and describes the usage of a probe swarm architecture, which allows the operator to quickly generate an overview of the resource capabilities of a set of nodes, by executing code fragments locally. The obtained measurements can then enable the operator to decide on rescheduling operations. Evaluation of an illustrative probe swarm intervention shows that the performance of an example application could improve with factor five, ten or hundred when the pod would be rescheduled. This indicates that the proposed probe swarm architecture may complement other performance bottleneck detection techniques to improve performance of applications that need to be deployed urgently. [ABSTRACT FROM AUTHOR]

Cloud service providers can operate several execution instances on a single physical server using virtualization technology, which improves resource utilization. In recent years, container-based virtualization has been developed as a remarkably lightweight alternative to virtual machines. Containers consume less memory than virtual machines, enabling faster setup and portability. Cloud-based applications require dynamic resource allocation in response to fluctuations in the number of incoming requests. Most articles on proactive autoscaling in cloud computing have shortcomings in two ways. 1) During feature extraction, the temporal patterns of the data are ignored, and the historical sequences are assigned equal weight. 2) Existing research omits cool down time (CDT) from the planning phase. 3) Scaling operations can be performed at any time depending only on the current input workload, resulting in a large number of contradicting scaling actions. In response to the above shortcomings, this paper presents a proactive autoscaling method for web applications in Kubernetes using an attention-based gated recurrent unit (GRU) encoder-decoder (K-AGRUED), which predicts the resource usage of several future steps based on CDT. The results demonstrate that the proposed method reduces prediction error by 2–25% compared to state of the art methods. Our approach significantly reduces scaling operations and under-provisioning compared to the standard horizontal pod autoscaler (HPA) of Kubernetes and two previous studies. The K-AGRUED increases the scaling speedup by a factor of up to five in a real environment. [ABSTRACT FROM AUTHOR]

Container orchestration systems simplify the deployment and maintenance of container-based applications, but developing efficient and well-defined orchestration systems is a challenge. Nowadays, Kubernetes is a leading open-source container orchestration platform that has become the de facto standard. The aim of this paper is to provide a comprehensive overview of the Kubernetes orchestrator and grasp the current research emphasis by using a bibliometric analysis. Bibliometrix software was adopted as bibliometric analysis tools to find hot research topics and guide the future researching in the area. The Web of Science core collection database was used as the primary source for data collection. Data were collected from 803 articles published from 2014 to September 2022. In particular, publication outputs and research areas can provide insight into the development trends and current domains in terms of Kubernetes research. The most influential and productive authors, institutions, countries and journals contributed to this bibliometric analysis. The hottest research topics on Kubernetes are mainly centered on “cloud/fog/edge computing and Internet of Things (IoT)”, “containers and virtualization”, “docker”, “resource scheduling”, “microservices” and “artificial intelligent (AI)”. A cluster analysis was conducted from a keyword perspective to obtain emerging trends and frontiers for Kubernetes. The results showed that future research should focus on “automation”, “5G”, “scalability”, “resource scheduling”, “serverless”, “service mesh” and “blockchain”. Therefore, this paper aims to assist academics and practitioners in gaining a comprehensive understanding of the status quo and trends in Kubernetes research. [ABSTRACT FROM AUTHOR]

With the widespread acceptance of the cloud-native concept and the emergence of a large number of dedicated cloud-native applications, the service stacks of cloud-native applications have received extensive attention in the industry. To analyze the extensibility problems of service stacks, a cloud-native light-cone model is proposed, which focuses on the dimensions of application, infrastructure, tenant and workflow, and provides a perspective view that reflects the concerns of stakeholders. Based on this model, various challenges in designing extensible cloud-native service stacks are identified by classification. To solve these challenges, a holistic architecture and a set of key technologies are designed, involving unified runtime abstraction, cluster bootstrapped creation, application-specific controllers, etc. Furthermore, the OMStack (Oriental Mind Stack) is implemented, which integrates these technologies and provides a group of PaaS and SaaS services for container cluster (OMCC), artificial intelligence (OMAI), big data (OMBD) and so on. Experimental analysis and production applications demonstrate the practicality, efficiency and reliability of the proposed architecture, stack and services. [ABSTRACT FROM AUTHOR]

Serverless computing, especially when deployed at the edge of the network, is seen as an enabling technology for the future development of more complex Internet of Things systems. However, special care must be taken when deploying new edge infrastructures for serverless workloads in terms of resource usage and network connectivity. Inefficient utilization of the available computing resources might easily cancel out the benefits acquired by moving the equipment closer to the edge, namely the reduced communication latency. Containers, together with the Kubernetes container orchestrator, are used by many serverless platforms today. We evaluate the performance of three different Kubernetes distributions—full-fledged Kubernetes, K3s, and MicroK8s when deployed in a resource constrained environment at the edge. We use the OpenFaaS serverless platform and employ 14 different benchmarks divided into three separate categories to evaluate various aspects of the execution performance of the distributions. Four different test types are performed focusing on cold start latency, serial execution performance, parallel execution using a single replica, and parallel execution utilizing different autoscaling strategies. Our results show that the edge-oriented K3s and MicroK8s distributions offer better performance in the majority of the tests, while a full-fledged deployment exhibits noticeable advantages for sustained loads such as parallel function invocation using a single replica. [ABSTRACT FROM AUTHOR]

Kubernetes makes it easier to automate deployment and scale containerized applications to achieve a near-native performance. However, there is still a lack of systematic performance studies on how Spark applications perform on Kubernetes. In this paper, we first propose a model to capture the execution behavior of tasks, stages, and jobs, and present an implementation of a prototype system based on the model. The system is then used to collect and analyze various types of performance and system metrics, such as execution time and CPU utilization. Second, with the use of various Spark applications, we evaluate the performance of Spark on Kubernetes by comparing it with its baseline, i.e., Spark on bare metal. Based on the comparison and leveraging the system, we locate what stages suffer from the performance loss of these applications on Kubernetes, and then reveal the root causes of the loss by analyzing their work-flows, execution time and costs of system resources. Through extensive measurements, we find that Spark on Kubernetes falls behind its baseline in the range of - 2.9 % to 83.9%. There are several root causes of the performance loss and benefits of Spark on Kubernetes. First, data locality deterioration by pods is a crucial root cause of the loss. To address the problem, we propose an approach to schedule tasks by taking both data locality and the utilization of executors into account. Experiments show that this approach increases the performance of Spark on Kubernetes by up to 32.2%. Second, the lower CPU usages of executors are another root cause of the performance loss, even if they have an equivalent CPU configuration on both Kubernetes and bare metal. In contrast, with the same memory configuration, executors use more memory on Kubernetes than on bare metal, contributing to the performance benefit of Spark on Kubernetes in some stages. Our research efforts in this paper benefit developers and researchers when they make valuable decisions on deploying Spark applications on Kubernetes for a better performance. [ABSTRACT FROM AUTHOR]

Container-based virtualization techniques are becoming an alternative to traditional virtual machines, due to less overhead and better scaling. As one of the most widely used open-source container orchestration systems, Kubernetes provides a built-in mechanism, that is, horizontal pod autoscaler (HPA), for dynamic resource provisioning. By default, scaling pods only based on CPU utilization, a single performance metric, HPA may create more pods than actually needed. Through extensive measurements of a containerized n-tier application benchmark, RUBBoS, we find that excessive pods consume more CPU and memory and even deteriorate response times of applications, due to interference. Furthermore, a Kubernetes service does not balance incoming requests among old pods and new pods created by HPA, due to stateful HTTP. In this paper, we propose a bi-metric approach to scaling pods by taking into account both CPU utilization and utilization of a thread pool, which is a kind of important soft resource in Httpd and Tomcat. Our approach collects the utilization of CPU and memory of pods. Meanwhile, it makes use of ELBA, a milli-bottleneck detector, to calculate queue lengths of Httpd and Tomcat pods and then evaluate the utilization of their thread pools. Based on the utilization of both CPU and thread pools, our approach could scale up less replicas of Httpd and Tomcat pods, contributing to a reduction of hardware resource utilization. At the same time, our approach leverages preStop hook along with liveness and readiness probes to relieve load imbalance among old Tomcat pods and new ones. Based on the containerized RUBBoS, our experimental results show that the proposed approach could not only reduce the usage of CPU and memory by as much as 14% and 24% when compared with HPA, but also relieve the load imbalance to reduce average response time of requests by as much as 80%. Our approach also demonstrates that it is better to scale pods by multiple metrics rather than a single one. [ABSTRACT FROM AUTHOR]

This research paper sets forward an autoscaler, called EPMA, (Elastic Platform for Microservice-based Applications). Its main objective corresponds to resource optimization. The basic contributions of EPMA are twofold. First, an analysis module that correctly detects and identifies the root cause of performance degradation while considering a cross-layer approach. The detected problems may be related to request issues such as a workload increase or a specific request consuming a lot of resources. Other problems related to container and VM (Virtual Machine) layers are also considered. Second, a planning module that considers the above detected problems and offers an optimized elasticity plan avoiding useless resource provisioning and thus permitting resource optimization. Thus, our planning module selects the appropriate microservices to which resources should be added as well as the optimized amount of resources that should be incorporated to correct the situation. Experimental results conducted on two concrete use cases revealed that EPMA autoscaler detects and identifies different problems generating the overload state and launching an optimized resource provisioning that reduces computing resources. [ABSTRACT FROM AUTHOR]

Today's industry has gradually realized the importance of lifting efficiency and saving costs during the life-cycle of an application. In particular, we see that most of the cloud-based applications and services often consist of hundreds of micro-services; however, the traditional monolithic pattern is no longer suitable for today's development life-cycle. This is due to the difficulties of maintenance, scale, load balance, and many other factors associated with it. Consequently, people switch their focus on containerization—a lightweight virtualization technology. The saving grace is that it can use machine resources more efficiently than the virtual machine (VM). In VM, a guest OS is required to simulate on the host machine, whereas containerization enables applications to share a common OS. Furthermore, containerization facilitates users to create, delete, or deploy containers effortlessly. In order to manipulate and manage the multiple containers, the leading Cloud providers introduced the container orchestration platforms, such as Kubernetes, Docker Swarm, Nomad, and many others. In this paper, a rigorous study on Kubernetes from an administrator's perspective is conducted. In a later stage, serverless computing paradigm was redefined and integrated with Kubernetes to accelerate the development of software applications. Theoretical knowledge and experimental evaluation show that this novel approach can be accommodated by the developers to design software architecture and development more efficiently and effectively by minimizing the cost charged by public cloud providers (such as AWS, GCP, Azure). However, serverless functions are attached with several issues, such as security threats, cold start problem, inadequacy of function debugging, and many other. Consequently, the challenge is to find ways to address these issues. However, there are difficulties and hardships in addressing all the issues altogether. Respectively, in this paper, we simply narrow down our analysis toward the security aspects of serverless. In particular, we quantitatively measure the success probability of attack in serverless (using Attack Tree and Attack–Defense Tree) with the possible attack scenarios and the related countermeasures. Thereafter, we show how the quantification can reflect toward the end-to-end security enhancement. In fine, this study concludes with research challenges such as the burdensome and error-prone steps of setting the platform, and investigating the existing security vulnerabilities of serverless computing, and possible future directions. [ABSTRACT FROM AUTHOR]

The Compact Muon Solenoid (CMS) experiment heavily relies on the CMSWEB cluster to host critical services for its operational needs. The cluster is deployed on virtual machines (VMs) from the CERN OpenStack cloud and is manually maintained by operators and developers. The release cycle is composed of several steps, from building RPMs to their deployment, validation, and integration tests. To enhance the sustainability of the CMSWEB cluster, CMS decided to migrate its cluster to a containerized solution based on Docker and orchestrated with Kubernetes (K8s). This allows us to significantly speed up the release upgrade cycle, follow the end-to-end deployment procedure, and reduce operational cost. In this paper, we give an overview of the CMSWEB VM cluster and the issues we discovered during this migration. We discuss the architecture and the implementation strategy in the CMSWEB Kubernetes cluster. Even though Kubernetes provides horizontal pod autoscaling based on CPUs and memory, in this paper, we provide details of horizontal pod autoscaling based on the custom metrics of CMSWEB services. We also discuss automated deployment procedure based on the best practices of continuous integration/continuous deployment (CI/CD) workflows. We present performance analysis between Kubernetes and VM based CMSWEB deployments. Finally, we describe various issues found during the implementation in Kubernetes and report on lessons learned during the migration process. [ABSTRACT FROM AUTHOR]

Novel applications will require extending traditional cloud computing infrastructure with compute resources deployed close to the end user. Edge and fog computing tightly integrated with carrier networks can fulfill this demand. The emphasis is on integration: the rigorous delay constraints, ensuring reliability on the distributed, remote compute nodes, and the sheer scale of the system altogether call for a powerful resource provisioning platform that offers the applications the best of the underlying infrastructure. We therefore propose Kubernetes-edge-scheduler that provides high reliability for applications in the edge, while provisioning less than 10% of resources for this purpose, and at the same time, it guarantees compliance with the latency requirements that end users expect. We present a novel topology clustering method that considers application latency requirements, and enables scheduling applications even on a worldwide scale of edge clusters. We demonstrate that in a potential use case, a distributed stream analytics application, our orchestration system can reduce the job completion time to 40% of the baseline provided by the default Kubernetes scheduler. [ABSTRACT FROM AUTHOR]

Recently, emerging edge computing technology has been proposed as a new paradigm that compensates for the disadvantages of the current cloud computing. In particular, edge computing is used for service applications with low latency while using local data. For this emerging technology, a neural network approach is required to run large-scale machine learning on edge servers. In this paper, we propose a pod allocation method by adding various graphics processing unit (GPU) resources to increase the efficiency of a Kubernetes-based edge server configuration using a GPU-based embedded board and a TensorFlow-based neural network service application. As a result of experiments performed on the proposed edge server, the following are inferred: 1) The bandwidth, according to the time and data size, changes in local (20.4–42.4 Mbps) and Internet environments (6.31–25.5 Mbps) for service applications. 2) When two neural network applications are run on an edge server consisted with Xavier, TX2 and Nano, the network times of the object detection application are from 112.2 ms (Xavier) to 515.8 ms (Nano); the network times of the driver profiling application are from 321.8 ms (Xavier) to 495.7 ms (Nano). 3) The proposed pod allocation method demonstrates better performance than the default pod allocation method. We observe that the number of allocatable pods on three worker nodes increases from five to seven, and compared to other papers, the proposed offloading shows similar or better response times in environments where multiple deep learning applications are implemented. [ABSTRACT FROM AUTHOR]

The combination of edge and cloud computing is going to make the Internet of Things (IoT) rapid, light, and more reliable. IoT and cloud-edge computing are distinct disciples that have evolved separately over time. However, they are increasingly becoming interdependent, and are what the future holds. A crucial aspect is how to design a compound of cloud and edge computing architectures, and implement IoT effectively. In this paper, we proposed a combination of Cloud and Edge Computing architecture and built a set of an intelligent air-quality monitoring system in Tunghai University as a case study. In this case, we implemented container-based virtualization which constructs Kubernetes Minion (Nodes) in the Docker container service independently for each service on the Edge side. Finally, to monitor the high-performance computing systems, clusters, and networks, we used Ganglia Monitoring System. Ganglia collects relevant information such as Central Processing Unit (CPU), memory, network and usage of Protocol Data Unit (PDU) to monitor the power consumption and makes a measurement and evaluation for Kubernetes Pods. [ABSTRACT FROM AUTHOR]

Containerisation demonstrates its efficiency in application deployment in Cloud Computing. Containers can encapsulate complex programs with their dependencies in isolated environments making applications more portable, hence are being adopted in High Performance Computing (HPC) clusters. Singularity, initially designed for HPC systems, has become their de facto standard container runtime. Nevertheless, conventional HPC workload managers lack micro-service support and deeply-integrated container management, as opposed to container orchestrators. We introduce a Torque-Operator which serves as a bridge between HPC workload manager (TORQUE) and container orchestrator (Kubernetes). We propose a hybrid architecture that integrates HPC and Cloud clusters seamlessly with little interference to HPC systems where container orchestration is performed on two levels. [ABSTRACT FROM AUTHOR]

The evolution of Internet of Things (IoT) technology has led to an increased emphasis on edge computing for Cyber-Physical Systems (CPS), in which applications rely on processing data closer to the data sources, and sharing the results across heterogeneous clusters. This has simplified the data exchanges between IoT/CPS systems, the cloud, and the edge for managing low latency, minimal bandwidth, and fault-tolerant applications. Nonetheless, many of these applications administer data collection on the edge and offer data analytic and storage capabilities in the cloud. This raises the problem of separate software stacks between the edge and the cloud with no unified fault-tolerant management, hindering dynamic relocation of data processing. In such systems, the data must also be preserved from being corrupted or duplicated in the case of intermittent long-distance network connectivity issues, malicious harming of edge devices, or other hostile environments. Within this context, the contributions of this paper are threefold: (i) to propose a new Internet of Things Edge-Cloud Federation (IoTEF) architecture for multi-cluster IoT applications by adapting our earlier Cloud and Edge Fault-Tolerant IoT (CEFIoT) layered design. We address the fault tolerance issue by employing the Apache Kafka publish/subscribe platform as the unified data replication solution. We also deploy Kubernetes for fault-tolerant management, combined with the federated scheme, offering a single management interface and allowing automatic reconfiguration of the data processing pipeline, (ii) to formulate functional and non-functional requirements of our proposed solution by comparing several IoT architectures, and (iii) to implement a smart buildings use case of the ongoing Otaniemi3D project as proof-of-concept for assessing IoTEF capabilities. The experimental results conclude that the architecture minimizes latency, saves network bandwidth, and handles both hardware and network connectivity based failures. [ABSTRACT FROM AUTHOR]

Autoscaling of containers can leverage performance measures from the different layers of the computational stack. This paper investigate the problem of selecting the most appropriate performance measure to activate auto-scaling actions aiming at guaranteeing QoS constraints. First, the correlation between absolute and relative usage measures and how a resource allocation decision can be influenced by them is analyzed in different workload scenarios. Absolute and relative measures could assume quite different values. The former account for the actual utilization of resources in the host system, while the latter account for the share that each container has of the resources used. Then, the performance of a variant of Kubernetes' auto-scaling algorithm, that transparently uses the absolute usage measures to scale-in/out containers, is evaluated through a wide set of experiments. Finally, a detailed analysis of the state-of-the-art is presented. [ABSTRACT FROM AUTHOR]

Hosting applications in the cloud has become very popular. In this context, automatic application scaling, health checking and bootstrapping required services has never been easier. However, there are some types of services that require direct communication between a server and a client, bypassing the cloud. Popular examples include data grids (distributed caching solutions) and gaming servers. Most of these services use custom network protocols based on TCP or UDP transport, along with client-side load balancing, for optimizing network traffic. Unfortunately, most cloud vendors use HTTP-based reverse proxies and are unable to route custom protocols effectively. The major contribution of this paper is a proposed method for using a single load balancer per application instance (replica) to solve the problem of effective communication between a clustered application deployed within the cloud, and a client hosted in the outside world. [ABSTRACT FROM AUTHOR]

Dubbo is a high-performance, lightweight Java Remote Procedure Call (RPC) framework developed by Alibaba, which provides interface-oriented remote method call, intelligent fault tolerance and automatic service registration. Since Dubbo is extensively applied as an excellent representative RPC framework, it is of great significance to formally analyze Dubbo. In this paper, we use Communicating Sequential Processes (CSP) to model and formalize Dubbo. In order to enhance the reliability of the call, we use token authentication mechanism in the modeling process. Moreover, we put the CSP description of the established model into the model checker Process Analysis Toolkit (PAT) for simulation and verification. We verify whether the five properties are valid, including Deadlock Freedom, Connectivity, Robustness, Parallelism and Consistency. Our final verification results show that the model can satisfy these properties, thus we can conclude the framework can guarantee the highly available remote call. [ABSTRACT FROM AUTHOR]

Smart manufacturing has become a big trend of a new industrial revolution in the manufacturing industry. The advancement of the Internet of Things has made production more efficient and effective through the automated collecting data system and Big Data technology. Dealing with a large amount of real-time production data will be a significant issue for intelligent manufacturing. This paper uses Apache Kafka’s high-performance, low-latency data stream processing platform to process data collection and store it in the Big Data System. Kafka was deployed through Kubernetes, where it has improved on the architecture’s scalability and applies this architecture to the aerospace manufacturing autoclave. These data are then used to analyze the autoclave equipment anomaly. Testing performed on the Kafka Producer Throughput demonstrates that in the event that all other parameters remain unchanged, the real throughput will increase along with the increase in the throughput limit that is being used. For instance, when the throughput limit is 1.2 million, the maximum throughput of this experiment is reached at 1.13 million transactions per second, while the transfer rate is 552.88 megabytes per second (MB/s). The value of the fetch size parameter is set to 10,48,576 by default (1 M). It takes half a time and a quarter of a time down, and it takes up to 2.5 times the value that was preset before you can witness the change in the parameters that affect the performance. The performance achieves its peak of 1.43 million data transferred per second at a speed of 347.93 megabytes per second, and the performance after that has a tendency to remain consistent. [ABSTRACT FROM AUTHOR]