Serverless Architecture: What is it?

As organizations and their technology ecosystems mature, they often find managing architecture challenging. Rather than becoming professionals at managing a platform, software teams would rather devote their time and resources to applications and development. The new alternative is serverless architecture. But what is serverless architecture? And is it the right move for you?

What is Serverless Architecture?

Serverless is a cloud-native development model that enables software teams to build and deploy applications without directly managing servers and their requirements. While the architecture appears to function without a server, an underlying server is abstracted away from the application. The cloud provider handles the routine tasks of provisioning, maintaining, and scaling the server, while the user only pays for the execution time of their code on the machine.

Serverless applications are much lighter than traditional server-oriented applications. They can scale up and down very fast and are metered on demand through an event-driven model. This is why when a serverless application is idle, it does not cost anything to the user.

Serverless is a broad term to describe various cloud offerings that do not involve a server in the picture. When we go deeper into it, there are two significant categories of serverless applications – Backend as a Service (BaaS) & Function as a Service (Faas). Both of these are very different from each other.

BaaS refers to a setup in which backend systems are available for direct use as an online service. The most common categories of such systems include authentication, databases, file storage, etc. Google’s Firebase and Amazon’s Amplify are good examples of the same.

FaaS refers to a setup in which users can package and deploy functions written in a programming language to a remote server that they can then invoke via APIs or events. These functions are identical to the native functions that you can write on your local computer, and they are invoked every time the FaaS API receives a request or an event.

How does it work?

Servers allow users to communicate with an application and access its business logic, but managing servers takes considerable time and resources. Teams have to maintain the server hardware, take care of software and security updates, and create backups in case of failure. By adopting serverless architecture, developers can offload these responsibilities to a third-party provider, enabling them to focus on writing application code.

One of the most popular serverless architectures is Function as a Service (FaaS), where developers write their application code as a set of discrete functions. Each function will perform a specific task when triggered by an event, such as an incoming email or an HTTP request. After the customary stages of testing, developers then deploy their functions, along with their triggers, to a cloud provider account. When a function is invoked, the cloud provider either executes the function on a running server or, if there is no server currently running, it spins up a new server to execute the function. This execution process is abstracted away from the view of developers, who focus on writing and deploying the application code.

Advantages of Serverless Architecture

Less Maintenance

Serverless allows developers to focus on coding rather than manipulation. With serverless, your development team doesn’t have to provision, operate, patch, or upgrade your infrastructure. Even if you are operating in the cloud, these are operations that require time and attention from DevOps teams.

In addition, serverless providers have a backend infrastructure that can automatically scale horizontally and vertically to meet demand, with no need for manual configuration, maintenance, or monitoring of scaling activity. In an IaaS model, autoscaling capabilities are available but they require expertise to set up and require ongoing management.

Lower Costs

Serverless allows organizations to use resources exactly when needed, instead of renting a fixed number of servers for a predefined period of time. In a serverless model, companies pay according to metrics like code execution count, memory used, and execution time, and not for the idle time when code is not running. This can save costs substantially compared to an IaaS model.

Disadvantages of Serverless Architecture

Vendor Lock-In

With serverless, organizations lose control over their infrastructure. Entire applications may be written against a serverless framework with proprietary APIs, which makes it very difficult to migrate to another provider. Google’s support for open-source frameworks like Knative is a step towards resolving this problem.

Performance

Many teams getting started with serverless ignore application performance metrics because they don’t have servers to manage. However, serverless applications still experience latency issues, as a result of connectivity problems, code inefficiencies, or problems with systems that generate events upstream.

It’s important to remember there is a server behind a serverless system, but it is not visible to the organization. Organizations using serverless applications need to monitor and control traffic so that users do not experience performance issues, and they need new ways to diagnose performance issues without having access to the physical server.

Why Serverless Architecture?

Hosting a software application on the internet usually involves managing some kind of server infrastructure. Typically this means a virtual or physical server that needs to be managed, as well as the operating system and other web server hosting processes required for your application to run. Using a virtual server from a cloud provider such as Amazon or Microsoft does mean the elimination of the physical hardware concerns, but still requires some level of management of the operating system and the web server software processes.

With a serverless architecture, you focus purely on the individual functions in your application code. Services such as AWS Lambda or Microsoft Azure Functions take care of all the physical hardware, virtual machine operating system, and web server software management. You only need to worry about your code.

Challenges of Serverless Architecture

There are also some challenges associated with serverless architectures:

Loss of Control

In serverless environments, you lack control over the software stack that your code runs on. If a hardware fault, data center outage, or other issue impacts one of your servers, you’re dependent on a cloud provider to fix it.

Security

A cloud provider may run code from several of their customers on the same server at the same time. If the shared server isn’t configured properly, your application data could be exposed.

Performance Impact

Cold starts are common in serverless environments, adding several seconds of latency to code execution when functions are invoked after a period of inactivity.

Testing

Developers can run unit tests on function code, but integration tests, which evaluate how frontend and backend components interact, are difficult to perform in a serverless environment.

Vendor Lock-In

Large cloud providers like AWS offer several services – such as databases, messaging queues, and APIs – that you can use in harmony to run serverless applications. Although it’s possible to mix and match elements from different vendors, services from a single provider are designed to integrate almost seamlessly.

Conclusion

You should especially consider using a serverless provider if you have a small number of functions that you need to be hosted. If your application is more complex, a serverless architecture can still be beneficial, but you will need to architect your application very differently. This may not be feasible if you have an existing application. It may make more sense to migrate small pieces of the application into serverless functions over time.