Exploring Performance and Energy Optimization in Serverless Computing: A Review

Serverless architecture encompasses many things, and before jumping into creating serverless applications, it is important to understand exactly what serverless computing is, how it works, and the benefits and use cases for serverless computing. Generally, when people think of serverless computing, they tend to think of applications with back-ends that run on third-party services, also described as code running on ephemeral containers. In my experience, many businesses and people who are new to serverless computing will consider serverless applications to be simply “in the cloud.” While most serverless applications are hosted in the cloud, it’s a misperception that these applications are entirely serverless. The applications still run on servers that are simply managed by another party. Two of the most popular examples of this are AWS Lambda and Azure functions. We will explore these later with hands-on examples and will also look into Google’s Cloud functions.

Auto-scaling mechanisms in serverless computing: A comprehensive review

As organizations increasingly shift to the cloud, the adoption of serverless computing has emerged as a promising solution to optimize cloud infrastructure costs while maintaining scalability and performance. This article explores the cost benefits of serverless computing by examining how this cloud model differs from traditional infrastructure approaches, such as Infrastructure as a Service (IaaS) and Platform as a Service (PaaS). Serverless computing operates on a pay-as-you-go model, enabling organizations to eliminate the overhead of idle resources and reduce the complexity of infrastructure management. Through a combination of case studies, industry data, and performance metrics, this article analyzes the cost savings associated with serverless adoption across different organizational sizes and sectors. Key findings reveal that serverless computing can lead to significant reductions in infrastructure costs, with small to medium enterprises experiencing up to 40% savings. However, challenges such as cold start latency and vendor lock-in are also discussed. The article concludes by offering recommendations for businesses considering serverless computing, including strategies to mitigate potential risks and maximize cost benefits.

A comparison of using proprietary cloud platform Google Cloud Functions and open source platform Apache OpenWhisk for writing serverless applications based on the Google Cloud Platform was made. The following criteria were chosen for comparison: supported programming languages, convenience and speed of development and deployment of functions, possible ways to pass parameters to functions, options for monitoring the status of functions, speed of the cold start. As a result, main advantages and disadvantages of each platform were identified. Recommendations for use cases are given based on the features of the platforms. The results of the study can be used for further studies in the field of FaaS technologies, as there are a lot of solutions in this area that also need to be compared.

The article provides a comprehensive analysis of architectural patterns for serverless applications in the context of modern cloud platforms. The study covers three key patterns: Strangler Fig for gradual migration of monolithic systems, Event-Driven for asynchronous event processing, and Saga for distributed transaction management. A detailed comparative analysis of the patterns is presented according to the criteria of complexity of implementation, type of interaction, areas of application and potential risks. Particular attention is paid to the practical aspects of implementing a serverless architecture, including cold start issues, function execution time constraints, and distributed system monitoring issues. Based on the analysis of modern FaaS platforms (AWS Lambda, Azure Functions, Google Cloud Functions), recommendations have been formulated for choosing the optimal architectural approach depending on business requirements and load characteristics. The results of the study demonstrate that choosing the right architectural pattern can significantly increase the scalability, fault tolerance, and cost-effectiveness of cloud applications.

In order to effectively manage varying workloads, serverless computing in cloud settings requires dynamic resource allocation, which is addressed by the deployment of an auto-scaling system. Serverless computing is an affordable option for cloud-based apps since users are only charged for the resources that are really used. However, complex techniques are needed to dynamically scale resources up or down in response to real-time traffic patterns in order to manage the scalability of serverless functions, particularly when demand is variable. In order to optimize resource allocation in serverless systems, this study suggests an adaptive auto-scaling method that makes use of real-time monitoring and predictive analytics. In order to minimize idle resources and guarantee high availability, the suggested system dynamically modifies the number of function instances. Workload monitoring, performance metrics analysis, and the use of machine learning models to forecast future demand and optimize scaling choices are important elements of the mechanism. The system is made to manage different computing job levels while striking a balance between cost effectiveness and responsiveness. When compared to static scaling models, the outcomes of putting this auto-scaling mechanism into practice show better responsiveness, cost savings, and resource usage. Furthermore, the suggested method easily adjusts to the evolving needs of the application, which makes it appropriate for a variety of cloud-based applications, ranging from tiny services to major business solutions. This study demonstrates how intelligent scaling can improve serverless computing's adaptability and effectiveness in cloud settings.

This research paper examines the evolution and current state of serverless computing frameworks for deploying artificial intelligence (AI) models in real-time applications. As AI adoption accelerates across industries, the need for efficient, scalable, and cost-effective deployment solutions has become increasingly critical. Serverless computing offers a promising approach for AI model deployment by providing on-demand computational resources without infrastructure management overhead. This study evaluates five prominent serverless computing frameworks—AWS Lambda, Google Cloud Functions, Azure Functions, OpenWhisk, and Knative—against key performance metrics relevant to AI workloads. Through empirical testing with various AI model types and sizes, we analyze cold start latency, execution time, throughput, cost efficiency, and resource utilization. Our findings indicate that while all frameworks demonstrate viable paths for AI deployment, significant differences exist in their performance characteristics depending on model complexity, input size, and concurrency requirements. We identify specific optimization strategies and architectural patterns that enhance real-time AI deployment on serverless platforms and propose a decision framework to guide implementation choices based on application requirements and constraints.

In serverless computing, applications are executed under lightweight virtualization and isolation environments, such as containers or micro virtual machines. Typically, their memory allocation is set by the user before deployment. All other resources, such as CPU, are allocated by the provider statically and proportionally to memory allocations. This contributes to either under-utilization or throttling. The former significantly impacts the provider, while the latter impacts the client. To solve this problem and accommodate both clients and providers, a solution is dynamic CPU allocation achieved through autoscaling. Autoscaling has been investigated for long-running applications using history-based techniques and prediction. However, serverless applications are short-running workloads, where such techniques are not well suited. In this paper, we investigate tiny autoscalers and how dynamic CPU allocation techniques perform for short-running serverless workloads. We experiment with Kubernetes as the underlying platform and implement using its vertical pod autoscaler several dynamic CPU rightsizing techniques. We compare these techniques using state-of-the-art serverless workloads. Our experiments show that dynamic CPU allocation for short-running serverless functions is feasible and can be achieved with lightweight algorithms that offer good performance.

Nowadays, Cloud providers revise the terms of their Service Level Agreements (SLAs) to include security provisions due to their criticality for their customers. In order to speed up their adoption by service providers and consumers and to make them more actionable, security SLAs monitoring should be described in a machine-processable, agile and extensible way. Several tools for SLA management are available on the market but most deal with performance metrics and do not refer to security properties. There are other tools for monitoring cloud security, in a non-SLA way. However, they are not associated with SLA management systems. We propose an extension to an SLA language (i.e., rSLA) to enable the description of security requirements in an SLA document. We also extend the rSLA framework by a security methodology that makes use of known tools and that enables continuously checking that the security requirements are respected during runtime according to the SLA document.

During the past few years, serverless computing has changed the paradigm of application development and deployment in the cloud and edge due to its unique advantages, including easy administration, automatic scaling, built-in fault tolerance, etc. Nevertheless, serverless computing is also facing challenges such as long latency due to the cold start. In this paper, we present an in-depth performance analysis of cold start in the serverless framework and propose HotC, a container-based runtime management framework that leverages the lightweight containers to mitigate the cold start and improve the network performance of serverless applications. HotC maintains a live container runtime pool, analyzes the user input or configuration file, and provides available runtime for immediate reuse. To precisely predict the request and efficiently manage the hot containers, we design an adaptive live container control algorithm combining the exponential smoothing model and Markov chain method. Our evaluation results show that HotC introduces negligible overhead and can efficiently improve the performance of various applications with different network traffic patterns in both cloud servers and edge devices.

Many corporate WAN architects are considering migrating from costly leased line circuits to 'private IP' services. In order to do so IP service providers must provide service level agreements (SLA) that offer robust assurances that cover service availability and performance. The industry direction is to model IP SLA after those offered by frame relay networks. The reality however is that the SLA surrounding today's private IP services only loosely mirror frame relay SLA. In this paper, we examine the intent and limitations of current IP SLA. We explore the feasibility of two significant enhancements. First we study the feasibility of reducing the time scales associated with the performance assessment to something that is meaningful to the corporate end user. Second we explore the potential benefits of extending current performance assessment methods with application level performance metrics. We present preliminary results suggesting that it is possible to offer performance assurances based on carefully chosen latency objectives as long as the average utilization of the access link is less than 50% over time scales identical to those used by the performance metrics. We introduce a Web-oriented performance metric (the Web Response Time metric) and show promising benefits over traditional ping based metrics. However, for either ping or Web-based performance metrics, due to the inherent nature of a best-effort IP service, IP performance assurances are only practical when applied over long time scales.

Serverless computing, also known simply as "serverless," represents a significant transformation in how applications are designed, deployed, and executed. Contrary to traditional methods where developers manage servers, serverless allows them to focus only on coding, trusting cloud providers with infrastructure responsibilities. This paradigm shift results in dynamic resource allocation, where users are billed based on actual resource consumption rather than pre-allocated capacities. The article elucidates serverless computing's nature, highlighting its core components - Function as a Service (FaaS) and Backend as a Service (BaaS). The benefits of serverless are underscored, including cost efficiency, inherent scalability, rapid development, and reduced operational demands. Yet, it is not without limitations. Concerns such as "cold starts," potential vendor lock-in, restricted customization, and specific security vulnerabilities are discussed. Practical serverless applications include web applications, data processing, IoT backends, chatbots, and ephemeral tasks. In conclusion, while serverless computing heralds a new age in cloud technology, businesses are encouraged to discerningly evaluate its pros and cons, mainly as the landscape evolves. The future is serverless, prompting organizations to determine their readiness for this revolution.

Cloud computing has evolved from the provisioning of virtual machines to the provisioning of complex services, delivered to customers under the terms of Service-Level Agreements (SLAs). SLAs specify the Quality of Service (QoS) that should be provided to customers as well as the billing model. A main concern for cloud service providers is to maintain the agreed SLA terms in order to avoid losses and penalties. Maintaining the SLA in turn requires translating the QoS to configurations of low-level mechanisms, able to enforce the agreed terms. Current systems provide no integrated support for SLA specification, translation, and enforcement. In this paper, we propose an approach for specifying and enforcing SLAs for cloud service providers. The approach covers the creation of SLA templates under a billing model, the design of performance and fault-tolerance QoS assurance mechanisms as well as the translation of QoS to appropriate configurations of those mechanisms. We demonstrate the feasibility of our approach by using the Qu4DS framework for PaaS cloud providers. Moreover, we evaluate the impact of failures on the provider profit. The experiments were carried out on the Grid5000 testbed and demonstrate the effectiveness of ensuring fault tolerance in different scenarios.

In the next twenty years, service-oriented computing will play an important role in sharing the industry and the way business is conducted and services are delivered and managed. This paradigm is expected to have major impact on service economy; the service sector includes health services (e-health), financial services, government services, etc.With increased dependencies on Information and Communications Technology (ICT) in their realization, major advances are required in user (Quality of Services) QoS based allocation of resources to competing applications in a shared environment provisioning though secure virtual machines. In this paper, we pointed in addressing the problem of enabling Service Level Agreement (SLA) oriented resources allocation in data centers to satisfy competing applications demand for computing services. e-Health offers a QoS Health Report designed to compare performance variables to QoS parameters and indicate when a threshold has been crossed. e-Health graphs relevant performance metrics on the same axes as thresholds indicative of SLAs or equivalent requirements. We suggest a methodology which helps in SLA evaluation and comparison. The methodology was found on the adoption of policies both for service behavior and SLA description and on the definition of a metric function for evaluation and comparison of policies. In addition, this paper contributes a new philosophy to evaluate the agreements between user and service provider by monitoring the measurable and immeasurable qualities to extract the decision by using artificial neural networks (ANN).

In this paper, we provide a multivocal literature review of Function as a Service (FaaS) infrastructures. FaaS is an important, emerging category of cloud computing, which requires that software applications are designed and deployed using distributed, highly-decoupled service-based architectures, one example of which is the microservices architecture paradigm. FaaS is associated with on-demand functionality and allows developers to build applications without the overhead associated with server management. As such, FaaS is a type of serverless provisioning model wherein a provider dynamically manages and allocates machine resources, with the developers deploying source code into a production environment. This research provides an analysis of scalability, cost, execution times, integration support, and the constraints associated with FaaS services provided by several vendors: AWS Lambda, Google Cloud Functions, and Azure Functions. We discuss the implications of the findings for software developers.