Architectural Design Patterns 8 – Serverless (Function as a Service – FaaS)

Architectural Design Patterns 8 – Serverless (Function as a Service – FaaS)

Today’s topic is a quite popular one, a fuzzy word getting more and more popular once it used to be a niche architectural pattern only.

When we think about building software, a lot of the time and energy is spent thinking about where and how it will run. Serverless architecture, also known as Function as a Service or FaaS, helps this to change. Instead of planning the environment to run, developers mainly write functions and let cloud providers like AWS or Azure handle where it runs.

Briefly describing, Serverless is an architectural model where cloud providers fully manage code execution. Developers write the code, and the chosen cloud platform executes and even scales the application depending on the need. This technique allows developers to concentrate on what they are good at, in other words code development. And handling operational concerns like scaling and infrastructure management will be “outsourced” to the cloud platforms.

Serverless has got a a lot of benefits which are:

Cost-Efficiency: The easily-seen advantage of Serverless is the pay-as-you-go pricing model. This means that you are charged only for resources you have spent, the compute time your application consumes. If your application is idle for some time, there are no charges for server time, for example. This can lead to a significant cost saving, especially for the applications don’t have a consistent patterns for load. For instance, an application publishing football matches will be extremely busy during a live event for a few hours, and will be quiet for all other times.

Rapid Deployment and Updates: Serverless architectures allow for faster deployment and updates. Because the infrastructure is managed by the cloud provider itself, the time and effort spent in setting up and managing servers are reduced significantly. This enables a quicker release of applications and features fastens the development cycle.

Reduced Management Overhead: For the sake of not repeating myself I will keep this point short, with Serverless the cloud provider takes care of infrastructure maintenance tasks. This reduces a significant amount of operational burden from the development team.

Automatic Scalability: Serverless platforms automatically scale your application depending on the incoming traffic. Whether your app experiences sudden spikes in usage or steady increases over time, the Serverless infrastructure adjusts automatically and it ensures that the application is available without manual intervention.

Built-in High Availability: Many Serverless platforms offer high availability and error tolerance out of the box. Applications are deployed across multiple data centres which ensures that they continue to operate even if one or more servers fail.

Simplified Backend Code: In a Serverless environment, developers can simplify backend code by relying on the cloud provider to manage complex infrastructure tasks. This can lead to cleaner, more focused application code that is easier to maintain and update.

Enhanced Flexibility: Serverless architecture offers the flexibility to build applications using a variety of programming languages. This allows teams to use the best tools for their specific requirements without being constrained by infrastructure considerations.

However, it’s not all sunshine. Serverless also have following disadvantages and potential pitfalls:

Dependence on Cloud Providers: One of the primary disadvantages of Serverless is relying on service providers. If the provider experiences downtime, technical issues, or changes in their price and service policies, it directly impacts your application’s performance and availability. This dependency also raises concerns about vendor lock-in.

Complexity in Managing Functions: As applications grow and the number of functions increases, managing these individual functions becomes more and more complex. Organizing, monitoring, and ensuring the harmony of numerous functions requires a well-planned architecture and maintenence. It can also lead to increased overhead in both development and maintenance cycles.

Cold Start Issues: Serverless functions may suffer from what is known as ‘cold start’. This happens when a function is invoked after being idle for some time, it requires some time to wake up since it causes a delay as the cloud provider allocates resources. While this may not be an important for some applications, it can be a critical issue for application requiring real-time responsiveness.

Limited Control and Customization: Since the cloud provider manages the infrastructure, there is a limited control over the underlying servers and environment. This can be an obstacle for applications requiring specific configurations or customization at the server level.

Security Concerns: Security in Serverless architecture has its challenges due to its widened attack surface. While cloud providers secure the infrastructure, developers must ensure the security of application code and configurations. This requires careful attention to function-specific permissions, updates to dependencies, and securing API gateways. Implementing best practices like strict access controls, continuous monitoring, code reviews, and data encryption is essential to minimize the risks in a Serverless environment.

Testing and Debugging Challenges: Testing and debugging Serverless applications can be more difficult compared to on-premise systems. The distributed nature of these applications requires special tools and techniques for effective debugging and testing.

Performance Constraints: Serverless platforms often comes with their limitations on resources such as memory, execution time, and concurrent executions. These constraints can affect the performance of applications, or exceeding the budget particularly for tasks requiring heavy usage of resources.

Networking and Integration Issues: Integrating Serverless functions with existing applications or third-party services can sometimes be complex due to networking and communication constraints. This integration complexity can impact the overall architecture and design of the system.

It’s easy to see why Serverless is gaining fans. It’s fast, cost-effective, and great for businesses that don’t want to deal with the nuts and bolts of server management.

No doubt, AWS and Azure are two frontrunners in the Serverless computing. They both offer robust platforms for developers. AWS Lambda is a very popular Serverless service which easily integrates into AWS services. Azure Functions is Microsoft’s answer to Serverless computing. Similar to AWS Lambda, Azure Functions allows developers to execute code triggered by certain events, but within the Azure ecosystem. This integration with Azure’s other services.

It is not only these two. Other cloud providers like Google Cloud, DigitalOcean, IBM Cloud, and Oracle Cloud offer their own Serverless platforms. Google Cloud Functions provides a highly scalable and event-driven service, ideal for applications already using the Google Cloud’s infrastructure. DigitalOcean which is a cloud platforms has been taking my attention recently, offers a straightforward and cost-effective Serverless platform called DigitalOcean Functions and it supports variety of languages. As two of the traditional companies, IBM Cloud Functions again supports various programming languages and integrates well with IBM’s cloud services. Oracle Cloud Functions is also a suitable choice for enterprises looking to leverage Oracle ecosystem. In short, each platform provides similar features they all have their pros and cons for different needs and different customers.

On the other hand, what if you are not on the cloud? Can you do Serverless on-premise? This is a question asked to me in one of the recent job interviews. Even though it is challenging, it is possible. There are several tools and platforms which makes the Serverless experience possible in on-premise setups. For example, OpenFaaS (Functions as a Service) is an open-source project that provides a framework for building Serverless functions on top of containers, allowing you to run and scale those functions inside your own infrastructure. Similarly, Kubeless (unfortunately not being maintained by VMWare anymore) runs on top of your Kubernetes cluster and leverages its resources, bringing the Serverless experience without requiring an external cloud provider. Nevertheless, while these tools provide the basic Serverless functionalities, they might not offer the same features and ease of use as cloud providers. It’s essential to consider the trade-offs between flexibility, cost, and feature set when deciding on an on-premise Serverless solution.

Suleyman Cabir Ataman, PhD

Architectural Design Patterns 1 – Layered (or Tiered) Pattern

Here in this first post of the blog, I want to also start with the first part of a series. Read more

Architectural Design Patterns 2 – Model-View-Controller (MVC)

When you're diving into the world of software design, you'll often hear about the Model-View-Controller, or MVC for short. It's Read more

Azure Blob Storage and C# Integration

Azure Blob Storage is one of Microsoft Azure's storage solutions. Think of it as a massive cupboard in the cloud Read more

Architectural Design Patterns 3 – Microservices

In this article, we will be talking about Microservices, a design pattern that has gained attraction for its approach to Read more

Sharing on social media:

Suleyman Cabir Ataman

Leave a Reply