Article Preview
Top1. Introduction
Cloud computing is a promising model to provide software-related services (Pragati, 2018). It is roughly a tremendous collection of resources (CPUs, memory, storage and bandwidth) that can be reached through the internet, which significantly increases their accessibility range. In this field, there are generally two parts that may be made available under the client control: the application code and the underlying infrastructure hosting that application. In this context, Serverless computing provides a great opportunity for developers seeking relief from the burden of infrastructure (Ioana, et al., 2017).The use of Serverless computing is very promising (Rajan, et al., 2019), in various fields such as the security domain (Reisman, et al., 2019), IoT(Hall, et al., 2019; Anand, et al., 2019; Sanjay, et al.,2020), Autonomic systems (Xavier, et al., 2019), edge computing (Baresi, et al., 2019), Fog Computing (Bin, et al., 2019; Grossman, et al., 2019), optimization purposes (Aytekin, et al., 2019; Kaium, et al., 2019), Big data (Werner, et al., 2018). This computing model allows building and running applications and services without having to manage infrastructure. In fact, Serverless Computing is an event-driven approach that abstracts the infrastructure management away from the client. Aspects like scalability, provisioning and fault tolerance are automatically handled by a Serverless platform, while the Cloud user focuses only on his functional code (Ioana, et al., 2017). This code comes in the form of a set of stateless functions that are agnostic of where they are going to be executed (Ioana, et al., 2017). Serverless platforms adopt a pay-per-execution billing strategy, i.e., contrarily to traditional Cloud platforms that host the client program in a listening running server (hence, the client pays as long as the server is running even if there are no requests), a Serverless platform does not start a server until a request is made. In this way, the client is billed for each invocation, meaning that no payment if no requests (Jorn, et al., 2017). The Serverless architecture is relatively a new paradigm and only few pioneers have investigated this domain. Amazon AWS Lambda is a compute service that supports many languages like node.js, C#, Python and Java on AWS infrastructure. Source code is provided as ZIP file and deployed in a container that is allocated the necessary hardware resources. The combination of code, configuration and dependencies is what is called a Lambda function (Peter, et al., 2017). The authors admit that a Lambda function can only run for a maximum of five minutes. Azure Functions (Praveen, et al., 2017) is Microsoft’s version of a Serverless platform. They provide a technique named the consumption plan to enhance function scalability during execution (Microsoft Docs, 2018). A function in such plan is limited (by default) to five minutes, but this value can be increased up to ten minutes (Microsoft Docs, 2018). Google Cloud Functions (Maddie, 2018) is another promising Serverless platform which limits the function to nine minutes max (Google cloud, 2018). Moreover, according to (Geoffrey, et al., 2017), Serverless platforms are still hosting short-running functions due to the faced difficulty of scheduling long-running tasks and their SLA (Service Level Agreements) management, but the authors advocate that it is possible in the future that Serverless platforms will host such tasks. Current procedure to execute long-duration workloads is not to provision them as Serverless functions (e.g. as a listening server) (Geoffrey, et al., 2017; Peter, et al., 2017).
Consequently, in recent Serverless platforms, the function execution should be within a short duration (five minutes max in most Cloud provider platforms), after which the function is abruptly terminated even if it has not completed its task. This leads to prevent functions requiring longer time from being adopted as Serverless functions.
In the aim to overcome this drawback, we take advantage from Multi-cloud paradigm features and propose a distributed migration-based approach which promotes the execution of long-duration Serverless functions.