As AWS Lambda approaches its 10th anniversary this year, the realm of serverless computing is expanding beyond its initial Function as a Service (FaaS) concept. Today, serverless denotes cloud services that eliminate manual provisioning, offer on-demand auto-scaling, and operate on consumption-based pricing models. This shift is indicative of a broader evolution in cloud computing, with serverless technology continually transforming. This article explores the future beyond serverless, investigating the evolving landscape and its implications for developers and operations teams. We will delve into the top three trends shaping this evolution.
 |
1. From Primitives to Constructs as a Service
In software development, the term "module" or "component" traditionally refers to a self-contained unit of software performing a cohesive set of actions. This aligns seamlessly with the microservice architecture, typically running on long-running compute services like Virtual Machines (VMs) or container services. The introduction of scalable, accessible cloud resources, such as AWS EC2, provided the infrastructure needed for the widespread adoption of microservices architecture, decomposing monolithic applications into independently deployable microservice units.
The concept of Function as a Service (FaaS), where code executes in response to events without managing infrastructure, predates AWS Lambda. Services like Google App Engine, Azure WebJobs, IronWorker, and AWS Elastic Beanstalk had hinted at this idea. However, Lambda's emergence as a major commercial implementation acted as a catalyst, transforming microservices into smaller, individually scalable, event-driven operations.
Rather than replacing functions with basic programming elements, the trend is moving towards the minimization and eventual replacement of functions by configurable cloud constructs. These constructs, mirroring programming constructs like conditionals, loops, exception handling, and user-defined data structures, enable the composition of distributed applications and the management of data flow between them.
Examples from AWS demonstrate this transition from Lambda function code to cloud constructs, such as API Gateway for request routing, Event Source Mapping for event triggering, and EventBridge Pipes for event transformation and enrichment.
2. From Hyperscale to Hyperspecialization
In the post-serverless cloud era, the cloud market is shifting towards hyperspecialized vertical multi-cloud services. These services offer fine-grained features tailored specifically to developers' needs, going beyond generic cloud primitives. This shift represents a move from hyperscaling a generic cloud service for a broad user base to hyperspecialization, providing advanced constructs and features to more demanding users.
Hyperscalers like AWS, Azure, and GCP are well-positioned to identify new user needs and constructs. However, the increased complexity of providing granular developer constructs leads to the rise of vertical multi-cloud services specializing in one area. Examples include Confluent Cloud for Kafka services, MongoDB Atlas versus DocumentDB, and Vercel for streamlined web application deployment.
This trend extends beyond established cloud companies, with startups focusing on a single multi-cloud primitive and enriching it with developer constructs. The competition in cloud services will shift from infrastructure primitives to a combination of core cloud primitives and developer-centric constructs.
3. From Infrastructure to Composition as Code (CaC)
Cloud constructs are blurring the boundaries between application and infrastructure responsibilities, leading to a shift left in cloud automation. The evolution from Infrastructure as Code (IaC) to Composition as Code (CaC) is unfolding, integrating application and automation codes in terms of tools and responsibilities.
While IaC simplified the provisioning and management of infrastructure, the shift towards more developer-centric programmable constructs is evident. New tools like Pulumi and AWS Cloud Development Kit (CDK) support general-purpose programming languages, allowing developers to define dynamic, logic-driven cloud constructs using languages like TypeScript, Python, C#, Go, and Java.
This transition marks a significant milestone in the evolution of IaC, acknowledging the application code's integration into cloud constructs. It paves the way for a more dynamic, code-driven approach, blurring the lines between application code and infrastructure, and giving rise to Composition as Code.
Conclusion
In summary, the trends in cloud computing point towards an increasing integration of programming constructs into cloud services. The evolution from serverless to configurable cloud constructs, hyperspecialized vertical multi-cloud services, and Composition as Code reflects a developer-first approach in the cloud. The future landscape is shaping up to be hyperspecialized, focused on developer-centric cloud services, and seamlessly blending application code with infrastructure configuration. As we move beyond the serverless era, these trends will continue to reshape the cloud computing landscape, offering more streamlined, efficient, and developer-friendly practices.