Serverless Computing Really Means Less Server [Customer Responsibility]

This blog post provides perspective on the term serverless as it relates to computing, especially in the context of web solutions and headless content management systems. For background, concerns, and related information, especially regarding serverless computing with .NET, see the blog post Implications and Considerations for Serverless ASP.NET –, much of which applies to platforms other than .NET.

“Serverless computing is a cloud computing execution model in which the cloud provider allocates machine resources on demand, taking care of the servers on behalf of their customers” (Serverless computing – Wikipedia).

Just as there are heads in headless CMS solutions, there servers in serverless computing. The difference is who is responsible for what. In headless CMS, the vendor is responsible for the CMS environment, UI, and content delivery services; the customer is responsible for the content delivery solution. In serverless computing, the cloud vendor is responsible for computing infrastructure; the customer is responsible for the solution deployed to that infrastructure.

For web solutions, there are at least three possible definitions of server: a specific hardware or a virtual machine, HTTP server software such as Apache for serving files in response to HTTP requests, or application server software such as ASP.NET running in the context of an HTTP server to respond to HTTP requests. Responding to HTTP requests requires software running on a machine (server) to serve a response. Even for solutions that consist only of static files that Content Delivery Networks (CDNs) can cache completely, web server software runs on a machine of origin to serve the data to cache.

The term serverless seems misleading unless you think of it as less server. Traditionally, organizations hosting web solutions managed web and application server software running on specific machines. Serverless indicates that with certain cloud computing models, organizations can be unaware of the machines, web server software hosts, application servers, and other resources used by the solution. Developers manage environment definitions that specify platform requirements and deploy their solutions to the cloud; cloud vendors instantiate web server and application server software on machines that they provision and administer to host the solution for the organization. In this context, serverless means that organizations are less aware of the servers.

In a way, Content Delivery Networks may be an early example of serverless computing. CDNs provided by vendors scale HTTP services without user intervention by the organizations that use them (less web server responsibility, hopefully less machine resources required to host the solution).

Serverless architectures can reduce the amount of server machine resources required to implement a solution (less server). Traditionally, organizations had to provision enough computing resources to meet their projected peak loads and other worst-case scenarios. For applications implemented vertically, with all functionality on individual hosts, it was not always feasible to scale certain application facilities without scaling related resources. Serverless suggests a computing model that separates an application into collections of services, each of which can be implemented with different technologies, hosted on different infrastructure (even in different locations), and scaled separately, again with no knowledge by the organization responsible for the solution. Developers using serverless infrastructure use services to compose relatively lightweight applications that run in browsers, mobile devices, application servers, and elsewhere.

For web solutions that use a CDN to serve a static solution from origin, there is no application server (less server).

Since it takes less processing power to serve files as opposed to invoking application server logic, static files use computing resources efficiently (less servers).

In fact, many serverless solutions depend on service-oriented architectures, which clearly depend on servers. Serverless solutions cannot expect data to remain in memory between operations and require special consideration for long-running processes.

If you have perspective on the term serverless, please comment on this blog post.

One thought on “Serverless Computing Really Means Less Server [Customer Responsibility]

Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s

<span>%d</span> bloggers like this: