Source-linked AI summary
Serverless Computing: Current Trends and Open Problems
Ioana Baldini, Paul Castro, Kerry Chang, Perry Cheng, Stephen Fink, Vatche Ishakian, Nick Mitchell, Vinod Muthusamy, Rodric Rabbah, Aleksander Slominski, Philippe Suter
TL;DR
Serverless computing addresses the challenge of deploying scalable cloud applications while abstracting operational management from developers. The chapter surveys its programming model, architecture, platforms, workloads, and open problems, finding that suitability depends on workload and cost characteristics while major system challenges remain.
Problem
Deploying cloud applications requires operational concerns such as provisioning, monitoring, scaling, and fault tolerance that serverless seeks to abstract from developers.
Method
The chapter surveys serverless platforms, explains their event-processing architecture and use cases, and synthesizes technical challenges and open research problems.
Results
Serverless is especially suited to infrequent, bursty workloads with horizontal scaling needs, while steady workloads depend on execution frequency and warm-container caching for economy and speed.
Takeaways & Limitations
Serverless supports distributed application patterns such as compute-intensive event-processing pipelines and has attracted substantial industry investment and attention.
Takeaways & Limitations
Key unresolved challenges include cost, cold starts, resource limits, security, scaling with limited application knowledge, and hybrid-cloud interoperability.
Abstract
from arXiv · showhide
Serverless computing has emerged as a new compelling paradigm for the deployment of applications and services. It represents an evolution of cloud programming models, abstractions, and platforms, and is a testament to the maturity and wide adoption of cloud technologies. In this chapter, we survey existing serverless platforms from industry, academia, and open source projects, identify key characteristics and use cases, and describe technical challenges and open problems.
1 Introduction
Serverless computing is an emerging cloud-application paradigm that simplifies deployment by shifting operational responsibilities to providers, while introducing control and platform challenges.
- Definition and motivation: Charging for execution time rather than resource allocation can lower deployment costs and support rapid delivery of small cloud-native code pieces.
- Definition and motivation: Serverless functions execute in response to events and can coordinate microservice compositions that would otherwise run on clients or dedicated middleware.
- Challenges: This abstraction requires developers to relinquish platform-level decisions concerning quality-of-service monitoring, scaling, and fault tolerance.
- Definition and motivation: Serverless abstracts most operational concerns from developers, including resource provisioning, monitoring, maintenance, scalability, and fault tolerance.
- Definition and motivation: Function-based serverless, or FaaS, uses stateless functions as deployment units while allowing arbitrary code rather than only prepackaged applications.
- Chapter scope: The chapter surveys serverless architectures, programming models, suitable workloads, and open research challenges across industry, academia, and open source.
2 Evolution
Serverless evolved from progressively higher cloud abstraction layers, extending earlier server-side code-execution approaches beyond mobile and application-specific contexts.
- Evolution: Serverless followed virtual-machine and container adoption by introducing lighter-weight computation units for resource consumption, cost, and development speed.
- Prior approaches: Mobile Backend as-a-Service offered cloud functions without server management, but those functions were typically restricted to mobile use cases.
- Prior approaches: SaaS platforms could execute user-provided functions, but execution remained bounded by the application domain or external API integrations.
3 Architecture
Serverless platforms disconnect computation from server management by automatically provisioning capacity and processing events through managed function lifecycles. The chapter compares platform characteristics, implementations, and tradeoffs while identifying operational challenges around cost, scalability, fault tolerance, and developer control.
- Architecture: Serverless platforms automatically provision capacity and disconnect stateless computation from the servers on which it runs.Developers relinquish control over resource provisioning, monitoring, maintenance, scalability, and fault tolerance.
- Architecture: An event-processing system routes incoming events to existing or newly created function instances, collects responses and logs, and stops idle functions.The platform also manages event queues, scheduling, resource deallocation, and failures.
- Platform dimensions: Platform comparisons use cost, performance and limits, programming languages, deployment, security, and monitoring as distinguishing dimensions.Usage is typically metered by execution resources, while concurrency and runtime resource limits vary among providers.
- Platform survey: Commercial and open-source platforms provide varied function runtimes, integrations, composition mechanisms, and licensing models.AWS Lambda emphasizes the AWS ecosystem, Azure Functions supports multiple languages and local development, OpenWhisk supports composition and arbitrary containerized binaries, and OpenLambda targets challenges including startup time and stateful interactions.
- Benefits and drawbacks: Serverless architectures trade control and flexibility for execution-based costs and reduced infrastructure management.Developers must consider code cost when modularizing applications, while some applications may be constrained by available runtimes or libraries.
- Platform ecosystem: Platform ecosystems simplify integration and rapid deployment but can encourage vendor lock-in, although open-source solutions may span multiple clouds.Current platforms make it easiest to use services native to their own ecosystems.
4 Programming model
The serverless programming model uses small, stateless functions that respond to events and rely on surrounding services for persistent state and integration. This design supports scaling and rapid deployment, but limits expressiveness and shifts important operational concerns to the platform and its ecosystem.
- Programming model: Serverless functions are small, stateless units whose composition is tailored to cloud elasticity and scaling.Functions do not retain state between executions; developers retrieve and update required state explicitly.
- Programming model: A function can receive parameters and execution context, then return a structured response.The example accepts params and context and returns a payload containing a greeting assembled from input fields.
- Ecosystem: Because functions are limited and stateless, successful applications require scalable services for persistent storage, identity, messaging, and other integrations.Underlying services must provide reliability and quality-of-service guarantees, while their on-demand scaling remains outside the serverless platform’s control.
- Frameworks: Frameworks group functions for joint deployment and updates, while abstractions can reduce dependence on individual service providers.Frameworks may also adapt existing programming models or hide provider-specific low-level details.
5 Use cases and workloads
Serverless is most suitable when workload characteristics and cost align with stateless, event-driven execution. Use cases include event processing, API composition and aggregation, flow control, and workloads benefiting from elasticity or decomposition.
- Workloads and cost: Bursty, compute-intensive workloads benefit most because functions can scale to zero and charge according to invocation running time.I/O-bound functions may be less economical because they pay for compute resources they do not fully use.
- Event processing: Event-driven image processing connects storage events to a stateless, idempotent thumbnail-generation function that can be safely retried after failure.The example combines event-based programming with a bursty, compute-intensive workload.
- API composition: Serverless functions can compose APIs by moving filtering, aggregation, and glue logic from mobile clients to the backend.This reduces multiple API invocations over potentially resource-constrained mobile network connections.
- API aggregation to reduce API calls: API aggregation can simplify mobile clients and reduce the calls needed to administer services such as OpenStack.The client otherwise must obtain a token, resolve the service URL, and invoke the required API call.
- Flow control and discussion: Serverless composition can stage feedback between a scalable database and a lower-volume issue tracker, while cost considerations may motivate decomposing I/O-bound functions.Such decomposition can be more complex to develop and debug but cheaper to operate.
- Workloads and cost: Workload frequency affects serverless economics because warm-container caching can accelerate steady workloads, whereas infrequent workloads may incur cold-container execution.These performance and cost characteristics help guide serverless adoption decisions.
6 Challenges and open problems
The chapter identifies system-level challenges and open research questions spanning resource management, tooling, service boundaries, state, composition, legacy integration, and edge execution.
- System-level challenges: Cost, cold starts, and enforceable resource limits remain fundamental systems challenges for serverless platforms.Cold starts arise from scaling to zero, while limits may cover memory, execution time, bandwidth, CPU usage, and aggregate platform resources.
- System-level challenges: Security requires strong function isolation, while scaling must provision elastically with little or no application-level knowledge.Platforms may infer load from request queues but cannot see the nature of those requests.
- System-level challenges: Traditional server-based tools do not directly transfer to serverless, creating needs for declarative deployment, monitoring, debugging, and developer-productivity tools.The smaller granularity and shorter lifetimes of serverless artifacts make monitoring and debugging more difficult.
- Open problems: Open questions include whether serverless boundaries extend beyond FaaS, how service models and pricing should mix, and how server-aware and serverless models relate.The chapter frames these as largely unexplored research areas and notes a possible continuum from server-aware to serverless computing.
- Open problems: The research agenda includes legacy-code decomposition, stateful serverless services, composable function patterns, concurrency and recovery semantics, and alternative code granularities.These questions address how existing systems and low-granularity building blocks can be integrated into larger serverless solutions.
- Open problems: Serverless may need to extend beyond traditional data centers to IoT, mobile devices, browsers, and edge or fog computing.The proposed scope includes distributing computing, storage, control, and networking resources beyond conventional cloud settings.
7 Conclusions
The chapter presents serverless as an evolution toward higher-level cloud abstractions, exemplified by stateless functions whose execution complexity is managed by the platform. It concludes that broad technical and conceptual research opportunities remain, with potential implications for programming models, languages, and platform architectures.
- Conclusions: Serverless evolves cloud programming models toward higher abstraction, with FaaS using small stateless snippets and platform-managed scalable, fault-tolerant execution.The chapter describes FaaS as the current exemplar of this evolution.
- Conclusions: Despite its restrictive model, serverless supports distributed application patterns such as compute-intensive event processing pipelines.Large cloud vendors have released serverless platforms, accompanied by substantial industry investment and attention.
- Conclusions: Research opportunities span infrastructure problems such as cold starts, composable programming models, and philosophical questions about state in distributed applications.The chapter contrasts this technically deep agenda with a comparatively limited level of research-community interest.
- Conclusions: Serverless may lead to new programming models, languages, and platform architectures for the research community to explore.The conclusion frames these developments as a future area for research participation and contribution.