Serverless Platform

It’s a cloud computing service category that captures two main selling points of the "as-a-service" model: it offers computation that is nearly fully automated and where you only pay for what you use.

What is it about?

It’s a cloud-based development model that enables the design and execution of applications without the need for server management.

Although servers are still used, they are isolated from the application development phase. The cloud provider handles routine tasks such as setup, maintenance, and infrastructure adjustments. Developers only need to package code into containers for deployment.

Once serverless applications are deployed, they respond to demand and scale up or down automatically as needed. Typically, public cloud providers offer these technologies at a cost measured via an event-based execution model, charging only as requested. So, when a function remains idle, no charges are incurred.

 

What Is It?

Serverless computing allows developers to build applications faster since they don’t have to manage the infrastructure. With serverless applications, the cloud service provider automatically provisions, scales, and manages the necessary infrastructure to run the code.

To understand the concept of serverless computing, it’s important to note that servers still run the code. The term "serverless" means that provisioning and infrastructure management tasks are invisible to the developer. This approach allows developers to focus more on business logic and provide greater value to the business core.

Serverless computing helps teams increase productivity and bring products to market faster, while allowing organizations to better optimize resources and maintain their focus on innovation.

 

What Is Its Internal Structure Like?

What differentiates serverless computing from other cloud computing models is that the cloud provider manages both the cloud infrastructure and application scaling. Serverless applications are deployed in containers that automatically start when requested.

In standard cloud computing models like Infrastructure as a Service (IaaS), users acquire a certain capacity upfront, meaning they pay a public cloud provider for specific server elements that run continuously to support their applications. The user is responsible for scaling capacity during high-demand periods and reducing it when no longer needed. The required cloud infrastructure to run the applications remains active even when unused.

In contrast, serverless architecture only runs when necessary. When an event triggers the application code to execute, the public cloud provider dynamically allocates the necessary resources, and the user stops being charged once execution ends. Serverless computing not only offers cost and efficiency benefits but also allows developers to offload routine, low-value tasks associated with server deployment and application scalability.

The cloud service provider manages the operating system and file system, runs security patches, load balances, manages capacity, adapts resources, logs activity, and monitors the system.

It’s a cloud computing service category that captures two main selling points of the "as-a-service" model: it offers computation that is nearly fully automated and where you only pay for what you use.

 

How does it work?

In serverless computing, there is no virtual infrastructure for the user to manage, and the user is only billed when their code is executing, down to the nearest 100 milliseconds. Everything is managed — from scaling to fault tolerance and redundancy of the underlying infrastructure. Servers are involved, of course; it’s just that the user doesn’t need to worry about any aspect of their management, as the cloud service provider handles all of that.

Serverless computing services are designed to run small pieces of code that perform a single, short-lived task. These small, self-contained blocks of code, known as functions, have no dependencies on any other code and, as such, can be deployed and run whenever and wherever needed.

Unlike a cloud application where backend code is more monolithic and can handle multiple tasks, the code running in serverless services like Lambda is more typical of what’s found in a microservices software architecture. Under this model, applications are divided into their core functions, which are written to run independently and communicate via APIs.

These small functions executed by serverless services are triggered by what are called events. The function runs every time one of these relevant events is triggered. Once the function has executed, the cloud service reduces the underlying infrastructure. This approach bills users only for the time the code is running.

In some ways, while the technology behind serverless computing is relatively new, the concept is not. In fact, it has existed since the beginning of the information age.

 

What Role Does the Cloud Provider Play in Serverless Computing?

In serverless computing models, cloud providers run the physical servers and dynamically allocate resources for users who deploy code directly to production.

Typically, serverless computing offerings fall into two categories: Backend as a Service (BaaS) and Function as a Service (FaaS).

The former provides developers access to various external applications and services. For instance, a cloud provider may offer authentication services, additional encryption, cloud-accessible databases, and highly reliable usage information. Serverless functions are typically requested via application programming interfaces (API) calls.

However, when developers talk about serverless computing, they generally refer to the FaaS model, where they write custom server-side logic that runs in containers fully managed by the cloud service provider.

All major public cloud providers offer one or more FaaS options. These include Amazon Web Services with AWS Lambda, Microsoft Azure with Azure Functions, Google Cloud with several offerings, and IBM Cloud, which includes IBM Cloud Functions, among others.

Some companies choose to manage their own FaaS environments using open-source serverless platforms, such as Red Hat® OpenShift® Serverless, which is based on the Knative project for Kubernetes.