Serverless Computing - what it is and why should you care?

Of late, we have been hearing the term serverless computing quite often. In fact, this particular architecture has been gaining momentum in recent times and is rising in popularity at a steady pace.

With that said, what exactly do we mean by serverless architecture? Is it any different from the existing models that we have? More importantly, does it work, literally, without a server?

It is only natural to have many questions and doubts regarding serverless architecture. In spite of the fact that it has been around for quite a while, many enterprises and agencies are still apprehensive about the benefits of serverless computing.

In this article, we will be learning more about serverless architecture to better understand what it is, and how it can prove useful.

What is Serverless Architecture?

Before going any further, let's clarify one basic point here -- the term "serverless" itself is a misnomer.

Now, in very practical terms, serverless architecture refers to a cloud computing model wherein the service provider can dynamically control the allocation of resources as and when needed.

Here is Wikipedia:

Serverless computing.... referring to a cloud-computing execution model in which the cloud provider runs the server, and dynamically manages the allocation of machine resources. Pricing is based on the actual amount of resources consumed by an application, rather than on pre-purchased units of capacity. It can be a form of utility computing.

Now, let us try to understand the concept of serverless computing in a better manner.

In the simplest of terms, serverless architecture is a method of providing access to the server's services on an as-and-when-used basis. This means that if a user signs up for a serverless plan, they are charged on the basis of their usage. There is no requirement to pay for a fixed amount of allocated bandwidth or storage space.

In other words, if your application requires heavier server usage in a given billing cycle, the pricing will vary from when it might require minimal usage of the server resources. Such scalability is at the core of serverless architecture and serverless computing.

Now, let us compare this with the traditional model of server management. In general, users are required to pay for a given amount of bandwidth and server resources that theri application or website might use. Such limits are rarely crossed by the user, effectively implying that they are paying for server resources which they are not fully making use of.

On the other hand, in a serverless scenario, the user is paying for resources that are actually used. With a scalable setup, there is no fear of ever "overstepping" the allocated resources, nor is there a need to calculate well in advance how much bandwidth will the project ever require. All of it is done in realtime, and the developers do not have to worry about the server-side resources.

What Makes Serverless Architecture Better?

Once again, it is worth noting that a serverless computing structure does not mean that the server is absent. In fact, a physical server is indeed present, albeit its resources are dynamically allocated. It is fairly obvious that no hardware can exist without a physical presence, isn't it?

In serverless setup, the developers do not need to worry about server management or a fixed pool of resources. They can simply start building their applications, and as and when their app grows, so does their quota of resources.

Let us now look at some of the major advantages that serverless computing brings to the table:

Scalability and Flexibility

The biggest advantage, therefore, that one might associated with a serverless architecture is its scalability. A serverless architecture can be used to scale up or down as per the requirements of the project. This provides the end user with greater control over their bills, and the server admin can make use of greater flexibility when allocating and managing resources.

Serverless apps are scalable in every sense of the term. Need to fire up multiple instances of a function? The server can start the instances up, run them and then end the same as and when required, all the while maintaining efficient use of resources.

A traditional architecture is often overwhelmed with a spike in resource usage. In serverless setup, no such issues exist as the server itself is setup such that it can handle spikes in traffic easily. This is why on non-cloud and non-serverless platforms, a sudden surge in traffic often leads to server errors for the users. On a serverless platform, such errors are absent.

Reduced Costs

Beyond that, a serverless architecture is almost always more cheaper and cost effective in the long run. Since you are paying only for the resources that you actually use, and not bound by any arbitrary limit set in by the server company, you can control virtually every aspect of your bills.

In a traditional server scenario, you are required to compute well in advance how much bandwidth and other resources you might need. Then, you must pay for the said quota upfront. So if you think you might use a maximum off 500 GB in a given month, you must pay for 500+ GB of bandwidth - keeping in mind that it is wiser to pay for an extra allocation perchance you end up using more than expected amount of resources. Obviously, even if your app uses barely 200 GB of bandwidth, you are still paying for the full quota of 500+ GB.

However, in the serverless world, you do not have to do any of that. Instead, you can just pay-as-you-go, depending on the requirements of your code and application. So if your application uses just 50 GB in a given month, and 1000 GB in the next one, you pay for the actual usage limits, not the quota or plan limits.

Easy Deployment

A serverless instance can be deployed within few minutes. All that is needed, more often than not, is a matter of few clicks. There is no need to upload bulk code to the server, or setup multiple layers production stack.

In fact, serverless computing treats the code as a collection of functions and methods. In comparison, traditional architecture often views apps as a monolithic stack. Thus, in the serverless world, code can easily be updated, modified, tweaked or edited as and when required, without having to "take the server down" or engage in lengthy downtime. This is why it is not uncommon for developers to keep updating their code one function at a time, whilst running their production app simultaneously.

Conclusion

As can be seen, serverless architecture has various advantages associated with it. If properly implemented, it can make life easier for the end users and developers alike, as applications can be deployed within a few clicks, and are easily scalable as per the needs and requirements of the developers. Furthermore, there are reduced costs of operation and there are no stringent limits on the resources either.

However, with all of that said, are there any downsides associated with serverless computing?

Well, in certain cases, serverless architecture might prove to be problematic. This is especially if the project or app in question requires heavier debugging on the server-side. Because developers do not really have absolute access to the backend, debugging on the server-side becomes tough in serverless computing.

More importantly, if the server vendor and service provider is not abreast with the latest security practices, the security and integrity of the entire architecture can be compromised. Since the developers do not have access to the backend, they can only vet the security of their functions and code objects. The security and hardening of the backend and server itself rests with the service provider. Any decent server management company will ensure that its servers and serverless architecture are fully hardened and up to date with the latest security fixes. As such, it is worth the effort to ensure that you pick the right service provider from the first day itself.

Serverless computing, at the end of the day, has more advantages than disadvantages. It is a rather novel concept that can reduce performance issues as well as operational costs. As a result, it is not surprising to see more and more developers turning towards serverless computing for their applications.

Have you given serverless computing a spin? How has your experience been, and what aspect of it do you love the most? Share your views in the comments below!