What is serverless computing?

Serverless computing is a cloud computing model that enables developers to build and run code on servers that are managed by the cloud provider and available on demand. Serverless computing frees developers from backend infrastructure management and provides a scalable and flexible environment for companies. With serverless computing, cloud providers provision the infrastructure to meet demand by scaling up or down as needed, and manage the infrastructure by performing any routine maintenance, updates, patchwork, and security monitoring.

Serverless computing does not mean that there are no servers involved. Rather, serverless means that infrastructure management has been outsourced to the cloud provider. This is the reason for the benefits and challenges of serverless monitoring. Companies can focus their resources on business logic, but the trade-off is less control and visibility on what goes on in the back end.

Serverless vs. FaaS

Function-as-a-Service (FaaS) refers to computing services that offload backend infrastructure management to keep the focus on building and running front-end code. Serverless and FaaS are often used interchangeably, but FaaS specifically refers to the code execution ability it provides developers. As event-driven architecture, FaaS is a subset of serverless and is only one of the services that serverless provides.

Serverless services also include serverless storage and databases, event streaming and messaging, and API gateways.

Serverless vs. BaaS

Backend-as-a-Service (BaaS) is, like FaaS, a subset of serverless. BaaS is a cloud computing model which enables developers to focus on the front end. BaaS comes with ready-made software for typical backend activities such as user authentication, push notifications, cloud storage, and database management.

Serverless works with both FaaS and BaaS.

Serverless vs. SaaS

Software-as-a-Service (SaaS) refers to a computing service in which a provider licenses and delivers ready-to-use software applications to companies over the Internet. Serverless computing offers a scalable and flexible infrastructure for developers to build and deploy applications without worrying about server management.

Serverless computing’s event-driven architecture and third-party infrastructure also call for a dedicated monitoring solution. Serverless monitoring solutions can help businesses gain visibility over their entire operations and are an important component of any serverless computing model.

There are several key components to serverless architecture, which sets it aside from traditional infrastructure models.

• The role of cloud providers is important:
  • Cloud providers are key to the serverless environment as they take on infrastructure management. In a traditional architecture computing model, your IT team would normally have to take on the time and labor-intensive task of running and managing servers. With serverless, the cloud provider takes on that responsibility, freeing up your developers. Cloud providers provision the servers, databases, and storage.
• Event-driven programming:
  • Serverless is triggered by events, rather than through polling. A serverless environment is an event-driven architecture (EDA). An event is any change of state that occurs in the environment, such as a user-end request. These events invoke functions, which are programmed by developers to trigger tasks.
• Trigger-based tasks:
  • Serverless only performs tasks when triggered by a function, which is invoked by an event. As a result, serverless only uses the resources it needs when they are called upon.
• Asynchronous programming:
  • The event-driven architecture and stateless nature of serverless enable asynchronous programming. Stateless means there is no data saved between interactions. So, multiple tasks can be performed at once, without the need to wait for a task to finish before another can be performed. The possibility of asynchronous programming also provides developers with flexibility as they write and test new code. The speed of deployment increases.
• RESTful APIs:
  • Serverless communicates between web services through the use of RESTful APIs. REST stands for representational state transfer. An API is an application performance interface. As a stateless architecture environment, serverless uses RESTful APIs to translate or represent a client-end (backend) resource to a user who made a request through HTTP.
• DevOps (CI/CD):
  • Serverless enables developers to take the Ops out of DevOps with CI/CD. CI/CD introduces automation into the development of applications. CI refers to continuous integration, and CD refers to continuous deployment or continuous delivery. With backend monitoring outsourced to the cloud providers, a serverless environment contributes to agile application development because developers can automate portions of the development pipeline, and spend less time worrying about the effects of deployment.
• Auto-scaling:
  • Serverless is inherently scalable. It automatically scales up or down to meet demand. A serverless environment will only spin up containers when functions are invoked. As such, it automatically responds to usage increases or decreases.
• Self-healing:
  • Serverless applications can be programmed to automatically identify and fix errors as they occur. This type of capability improves an application’s resilience and increases its availability.

Serverless uses both Backend-as-a-Service (BaaS) and Function-as-a-Service (FaaS) to fulfill requests. The environment as a whole is event-driven, which means an event triggers a response, such as authentication, or a function.

The FaaS portion of serverless works with user requests or events. A request is processed in the application performance interface (API) gateway, which then invokes a function. In turn, the function communicates with the database. This string of activities represents a single application task. In a serverless environment, applications are modular because tasks are programmed as separate functions.

Developers write serverless application code that is deployed in containers on an on-demand basis. The cloud provider will either execute the function on a running server or spin up a new server to execute the function.

Serverless provides developers a great deal of flexibility because it is stateless, meaning all invocations are independent. No data is stored from previous interactions. Serverless only uses resources as needed. Once a function is no longer needed, the container in which the code was deployed disappears. This contributes to the flexibility that serverless offers developers.

Additional considerations in serverless applications:

• A cold start can occur when a function is invoked for the first time or after a period of inactivity. This can cause some latency.
• Cloud providers determine the number of functions that can run simultaneously. This is the concurrency limit.
• A timeout refers to the amount of time a cloud provider allots to a function before terminating it.

Serverless technology is important because it offers significant business benefits by enabling automatic scaling and allows developers to be more productive and deliver applications more quickly. As such, it is a cost-effective technology: it empowers developers to focus on production rather than operations, and as a consumption-based model, relieves the cost of running and managing physical servers.

Serverless technology has been around for over a decade. In 2014, AWS launched its first FaaS, AWS Lambda. Google has Google Cloud Functions, while Microsoft has Azure Functions. As most businesses rely on cloud computing, serverless technology is synonymous with business operations. So, as the role of cloud providers becomes crucial to businesses, so too does serverless technology.

Serverless functions provide a number of benefits to developers and clients alike.

• Cost-effective: Cloud providers offer serverless as a consumption-based model, only charging you for the resources and functions you use. Due to the stateless nature of serverless—if a container is not in use, it disappears—there is no idle time. And as a result, you never pay for idle time. This makes a dramatic difference to cost efficiency.
• Scale: Serverless enables you to scale up and down as needed due to its event-driven architecture. If there is more demand, the cloud provider enables you to scale up by spinning up more resources as needed. They run and manage those resources for you, so you can focus on growing.
• Reduce overhead: With serverless functions, cloud providers take on the management and monitoring of your infrastructure. This means you offload the cost and human resources of management to the cloud provider and can redistribute your resources to development and deployment.
• Performance and availability: As an event-driven environment, serverless increases performance because it never uses unnecessary resources. This also means that resources are available as needed. The cloud provider enables you to scale as needed by spinning up servers and containers when called for, so you never have to worry about server or storage availability.
• Developer productivity: Developers benefit from serverless functions because a cloud provider takes on the operations portion of DevOps. This frees developers up to focus on writing code. The serverless environment promotes development agility and productivity by enabling CI/CD automation in the development pipeline.

Despite the obvious benefits of cost efficiency and accelerated development, serverless computing comes with a set of challenges. Some serverless computing disadvantages include:

• Vendor lock-in: The nature of serverless means that you are committed to a single cloud provider for code deployment. As a result, developers are forced into the model offered by the vendor. The provider dictates resource use such as concurrency limits. For these reasons, vendor lock-in can mean a lack of flexibility.
• Monitoring and debugging from a code perspective: Because the cloud provider manages the infrastructure, you have little to no visibility into the backend of your operations. As a result, it is very difficult to monitor a serverless environment without a dedicated serverless monitoring tool. The event-driven architecture of a serverless environment also means that identifying, re-creating, and correcting bugs can be a challenge.
• Latency: Due to the stateless nature of applications in a serverless environment, latency can occur when a function is invoked for the first time or after a long period of inactivity. Latency can also occur due to a timeout, or when too many functions are running simultaneously. In that instance, the provider might kill one of the functions, leading to a failure. On the user end, this causes latency.
• Limited customization and control: Since serverless providers manage the underlying infrastructure, there may be limitations on customization and control over the environment, such as available runtime versions, memory allocation, and execution time limits.
• Security concerns: While serverless computing reduces the attack surface, it can introduce new security risks. Developers need to be aware of the risks associated with third-party services, function-level permissions, and vulnerabilities in the application code.
• Statelessness: Serverless functions are stateless, which means they don't retain any data between invocations. This can make it difficult to manage the application state, requiring developers to rely on external storage or databases to maintain the state.
• Cost predictability: Although serverless computing can be cost-effective, it can be difficult to predict costs, as they depend on factors such as the number of invocations, memory, and execution time. Unexpected spikes in usage can lead to increased costs.
• Integration with existing systems: Integrating serverless functions with existing systems and architectures can be challenging, particularly when dealing with legacy applications or complex systems.
• Learning curve: Adopting serverless computing requires developers to learn new concepts, tools, and best practices, which can add complexity to the development process.

The benefits afforded by serverless computing, including scalability and reduced administration, make it well-suited to several use cases.

• Web application development: Serverless computing is well suited to web application development because it is an environment in which developers can test quickly. The consumption-based model offered by cloud providers also means that web application development is cheaper in serverless. You only pay for the resources you use, and you don’t spend time or human resources on the management of infrastructure. This allows your developers to focus on the front end. Serverless services like databases, API gateways, and event-driven architecture (EDA), enable developers to build web applications by solely writing code.
• Data processing and analytics: Serverless works well with structured text, audio, image, and video data. Serverless enables the processing and analysis of large, disparate datasets. Like any traditional computing model, a serverless environment contains a variety of siloed datasets. Developers can write an application to gather and process data from all business channels in a single database. Serverless computing is ideal for processing large amounts of data, such as ETL (Extract, Transform, Load) operations, log analysis, or data validation, as it can scale horizontally to handle the required workload.
• APIs and microservices: Serverless functions can be used to build and deploy APIs and microservices quickly, enabling developers to focus on writing application logic without worrying about infrastructure management.
• Real-time file processing: Serverless functions can process files in real time when they are uploaded to cloud storage services, enabling image resizing, video transcoding, or text extraction.
• Event-driven workflows: Serverless computing can be used to build event-driven workflows that respond to specific events, such as changes in a database, IoT device data streams, or messages from a message queue.
• Scheduled tasks and cron jobs: Serverless functions can be used to schedule tasks and run them at specific intervals, like nightly backups, report generation, or data synchronization.
• Chatbots and virtual assistants: Serverless functions can be used to create chatbots or virtual assistants that process and respond to user inputs, integrating with messaging platforms, and natural language processing services.
• IoT data processing: Serverless computing can process and analyze data generated by IoT devices, allowing for real-time monitoring, anomaly detection, and data aggregation.

Explore Observability with Elastic

The main difference between serverless and traditional architecture is that your company's IT team does not run or manage physical servers. That is offloaded to a cloud provider.

Traditionally, a business would use bare metal (BM) servers to run applications. This requires time and resources to procure hardware and a physical location to install it, power it, and cool it. BM requires racking, installing, and configuring hardware. The IT team also takes on the time-consuming responsibilities of configuring the environment for code deployment, installing operating systems, and maintaining and managing the servers.

BM servers have evolved into virtual machines (VM). Companies must still install and configure hardware, but benefit from the fact that multiple machines can run on the same hardware. This means compute resources are better utilized. The technical team can deploy multiple servers through hypervisors, and like for BM, the team has to install operating systems and ensure maintenance and management. The installation of operating systems is automated with the use of VM templates and automation tools.

Containers evolved from VMs. Containers are code packages that allow applications to run in a given operating environment, making them portable. Unlike VMs, containers all run on the same operating system and container runtime and their compute resources are divided in the kernel user space. This greatly simplifies the management of these services as there are fewer operating systems to manage. Containers are automated through platforms like Kubernetes, which deliver flexibility where containers are deployed, making them portable and easily deployed and destroyed when needed.

Serverless architecture frees IT teams up to focus on code writing and deployment because all infrastructure management has been offloaded to a cloud provider.

As cloud technology continues to evolve, so too will serverless computing. Providers have already started improving serverless computing by adding parts to make serverless convenient for general-purpose business workloads.

Explore serverless monitoring with Elastic

What is serverless?

Serverless is a cloud computing model in which the cloud provider provisions and manages underlying infrastructure so the client can focus on front-end development. Serverless is made up of FaaS and BaaS. The two services work together to provide a flexible environment that enables developers to quickly deploy code.

What is an example of serverless computing?

A user at an endpoint is browsing the client’s website. By doing this, they interact with two serverless functionalities—BaaS and FaaS. To continue browsing, the user enters their information. The BaaS portion of the serverless environment performs user authentication. The user continues browsing the website and makes a purchase. This is an event. This event is processed by a gateway API, which invokes a function to send a receipt email. To do that, the cloud provider spins up a container that has the application code and performs the task. That’s the FaaS.

Why is it called serverless?

Serverless is a misnomer that describes a cloud computing environment in which the cloud provider provisions and manages the servers needed to run the client’s applications. The client doesn’t have servers—they pay the cloud provider to use theirs.

• API Gateway: An Application Programming Interface (API) gateway is a communication link that reads a request and routes it to a backend service. It then translates the backend data to the user on the front end.
• BaaS: Backend-as-a-Service is a cloud computing model that uses built software to provide services like user authentication or data storage. It is a subset of serverless.
• Cloud Computing: Cloud computing refers to computing models that are native to the cloud environment. Any type of computing that occurs in a cloud is referred to as cloud computing.
• Cloud Native: Cloud-native refers to any application or service that is built specifically for the cloud. It takes into account the scalability and elasticity of a cloud environment.
• Cold Starts: A cold start occurs when a function is invoked for the first time or after a period of inactivity. It’s the first time the cloud provider spins up a container to fulfill the function.
• Container: Containers are lightweight, portable, and self-sufficient code packages with their dependencies, allowing them to run consistently across different computing environments.
• Event-driven architecture: Event-driven architecture is a software architecture model that uses events (requests, changes in state, updates) to trigger communication between services. Event-driven is a programming approach, not a programming language.
• FaaS: Function-as-a-Service is an event-driven cloud computing model that allows developers to build and run the front-end without managing back-end infrastructure.
• Microservices: Microservices are a type of software architecture model, in which software is broken up into separate services. These services communicate via APIs and enable development flexibility.
• Multicloud: Multicloud refers to multiple clouds, such as Google Cloud, AWS, and Microsoft Azure. Most companies are multi-cloud, meaning that they use the services of several cloud providers simultaneously. For example, a company uses the Google Office suite for email and AWS Lambda for its serverless functions.
• Stateless: Stateless refers to a computing trait of applications, protocols, or processes that handle operations independently. Serverless computing, for instance, is inherently stateless, which means that no data is kept between invocations.