Source-linked AI summary
The server is dead, long live the server: Rise of Serverless Computing, Overview of Current State and Future Trends in Research and Industry
Paul Castro, Vatche Ishakian, Vinod Muthusamy, Aleksander Slominski
TL;DR
Serverless computing addresses the operational and resource-utilization burdens of cloud application deployment. The paper surveys its evolution, architecture, characteristics, and use cases, drawing on workshops with academics and industry experts to identify challenges. It reports substantial cost savings in one use case and promising performance for compute-intensive applications, while highlighting restrictions and unresolved research opportunities.
Problem
Cloud application deployment leaves developers responsible for scaling and operational complexity, while allocated cloud resources can substantially exceed actual utilization.
Method
The paper provides an overview of serverless computing and identifies technical challenges through discussions with academics and industry experts in organized serverless workshops.
Results
Serverless reduced Heavywater’s costs by 70%, while early compute-intensive applications achieved performance close to specialized optimized solutions and AWS Lambda reached up to 40 TFLOPS peak performance for MapReduce jobs.
Takeaways & Limitations
Serverless offers simplified, pay-as-you-go cloud application deployment, but its benefits come with restricted functionality and substantial technical challenges for platforms and applications.
Takeaways & Limitations
Applications must relinquish design decisions concerning QoS monitoring, scaling, and fault tolerance to the platform provider.
Abstract
from arXiv · showhide
Serverless computing -- an emerging cloud-native paradigm for the deployment of applications and services -- represents an evolution in cloud application development, programming models, abstractions, and platforms. It promises a real pay-as-you-go billing (with millisecond granularity) with no waste of resources, and lowers the bar for developers by asking them to delegate all their operational complexity and scalability to the cloud provider. Delivering on these promises comes at the expense of restricting functionality. In this article we provide an overview of serverless computing, its evolution, general architecture, key characteristics and uses cases that made it an attractive option for application development. Based on discussions with academics and industry experts during a series of organized serverless computing workshops (WoSC), we also identify the technical challenges and open problems.
PREPRINT ARTICLE
Serverless computing is a cloud-native model that hides server management, automatically scales execution, and charges for runtime rather than allocated infrastructure. It simplifies application deployment and improves resource efficiency, but restricts control over scaling, fault tolerance, monitoring, and state.
- Motivation and evolution: Cloud resource studies show a substantial gap between resources customers allocate and pay for and their actual CPU and memory utilization.Serverless targets this mismatch by charging for execution time rather than resource allocation and avoiding payment for idle servers.
- Motivation and evolution: Serverless emerged alongside containers and microservices, offering pay-as-you-go deployment without manually starting or stopping servers.The model is positioned as closer to treating cloud computing like a utility.
- Trade-offs and limitations: The serverless model transfers operational decisions to providers, requiring developers to relinquish control over QoS monitoring, scaling, and fault-tolerance properties.Applications may later face conflicts between their requirements and the platform’s capabilities.
- Definition and characteristics: Serverless computing hides server usage from developers and runs code on demand with automatic scaling and billing only while code executes.Its two defining features are pay-as-you-go cost and elasticity from zero to “infinity”.
- Programming model: FaaS packages computation as short-lived functions triggered by events or HTTP requests, while persistent state must be maintained through external services.Limiting execution time and disallowing persistent function state makes these platforms easier for providers to maintain and scale.
- Definition and characteristics: Serverless is broader than using functions as the unit of computation, distinguishing the overall computing paradigm from FaaS platforms.The authors explicitly distinguish their definition from providing functions as the computational unit.
Tools and Frameworks
Serverless tools and frameworks support event-driven, composable, and highly parallel applications while shifting deployment, scaling, and operational management to the platform. Their economic advantages are strongest for bursty or compute-intensive workloads, whereas I/O-bound functions may underuse paid compute resources.
- Tooling challenges: Serverless adoption is slowed by a lack of tools spanning development, testing, debugging, and deployment.Several solutions have been proposed, but the passage identifies tooling gaps as a major challenge.
- Framework capabilities: Frameworks let developers define functions, triggers, and required services, then handle deployment to the cloud provider.Cloud-based IDEs and plugins also support serverless function development.
- Workload fit: Bursty workloads benefit from platform-managed elasticity and scale-to-zero, which eliminates consumer cost while idle.Compute-intensive workloads are also considered appropriate because invocation prices are generally proportional to function runtime.
- Workload fit: I/O-bound functions may pay for compute resources they do not fully use, making multiplexed multi-tenant server applications potentially cheaper.The comparison concerns current serverless pricing, where invocation cost is tied to running time.
- Programming model: Event-driven and flow-like processing patterns fit the stateless programming model of serverless functions.Examples include image processing, API composition, stream processing, data transformation, chatbots, and web applications.
Use Case 3: Map-Reduce style analytics
PyWren applies serverless infrastructure to highly parallel MapReduce analytics, reducing the development and management overhead of running such jobs. Using AWS Lambda with Amazon S3, it reports peak performance of up to 40 TFLOPS.
- Use Case 3: Map-Reduce style analytics: PyWren is a Python-based system that uses a serverless framework for highly parallel MapReduce analytics workloads.It uses AWS S3 for storage and caching.
- Use Case 3: Map-Reduce style analytics: PyWren helps users avoid significant development and management overhead when running MapReduce jobs.The system is presented as a serverless approach to MapReduce-style analytics.
- Use Case 3: Map-Reduce style analytics: 40 TFLOPS peak performance is reported for PyWren running on AWS Lambda.The figure describes peak performance rather than a general sustained-performance guarantee.
- Use Case 3: Map-Reduce style analytics: Figure 5 depicts a PyWren Map plus monolithic Reduce example implementing the ImageNet Large Scale Visual Recognition Challenge.The figure illustrates the MapReduce structure of the use case.
Use Case 4: Multi-tenant cloud services
Multi-tenant cloud services use serverless functions and cloud services to provide secure, scalable backend functionality while isolating users. Their architectures authenticate frontend requests, route them to functions or cloud services, and compose additional functions as needed.
- Serverless cloud services can provide each user with isolated backend functionality such as payment processing or email delivery.The resulting solutions are described as multi-tenant, secure, highly available, and scalable.
- A typical request flow begins in a frontend application, passes through external authentication, and is routed to a cloud service or serverless function.Functions customize requests and may invoke other functions or cloud services.
- Programming models and tooling: More than 150 serverless functions can compose a single application, making debugging and bottleneck identification harder.Traditional monitoring tools that assume server access or root privileges do not apply directly, creating demand for new tooling.
- Lack of standards and vendor lock-in: Serverless platforms lack established standards, so developers need tools that support interchangeable use of different providers.Standards are expected to emerge as the area matures.
Research Opportunities
The paper identifies research opportunities arising from serverless computing’s novelty and from unresolved challenges in programming, state, quality of service, edge deployment, and system design. These opportunities include adapting legacy software, supporting stateful applications, coordinating dependent services, and developing abstractions and applications suited to serverless environments.
- Serverless computing is a new area with many opportunities for the research community.The authors organize these opportunities and challenges based on workshops and academic and industrial surveys.
- System-level research and new applications: Research is needed on reducing cold starts while scaling to zero and on whether containers or smaller-footprint abstractions such as unikernels best fit serverless applications.The paper also encourages new applications using the serverless programming model, including scientific computing and AI chatbots.
- Legacy code in serverless: Existing legacy code must potentially be decomposed into smaller-granularity pieces to take advantage of serverless designs.Serverless application designs differ fundamentally from typical legacy applications, despite the economic value of existing code.
- Stateful serverless and SLAs: Current platforms are mostly stateless, leaving open whether inherently stateful applications can provide different quality-of-service levels without sacrificing scalability and fault tolerance.Providing QoS guarantees is also difficult when applications depend on identity providers, queues, and persistence services outside the platform’s control.
- Serverless at the edge: Edge serverless deployments may require redefining cost priorities because energy usage can matter more than speed.The paper connects serverless functions with edge-generated events and movement between devices and cloud environments.
market https://www.businesswire.com/news/home/20170227006262/en/7.72-Billion-Funct
The supplied passage is a market-source reference concerning Function-as-a-Service.
- The passage references an external Function-as-a-Service market source.
- The passage provides a market reference rather than substantive findings.
- No quantitative market result is stated in the supplied passage.