Serverless and Functions-as-a-Service (FaaS) are often conflated with one another but the truth is that FaaS is actually a subset of serverless.

Serverless is focused on any service category, be it compute, storage, database, messaging and api gateways where configuration, management and billing of servers are invisible to the user.

However, faaS while perhaps the most central technology in serverless architectures, is focused on the event-driven computing paradigm wherein application code or containers only run in response to events or requests.

FaaS is a valuable tool for efficient and cost-effective application migration to the cloud. Here are some more benefits:

• Focus more on code, not infrastructure: With FaaS, you can divide the server into functions that can be scaled automatically and independently so you don’t have to manage infrastructure. This feature allows you to focus on the app code and can dramatically reduce time-to-market.
  
  
• Pay only for the resources you use, when you use them: With FaaS, you pay only when an action occurs. When the action is done, everything stops—no code runs, no server idles, no costs are incurred. Therefore, FaaS is cost-effective, especially for dynamic workloads or scheduled tasks. FaaS also offers a superior total-cost-of-ownership for high-load scenarios.
  
  
• Scale up or down automatically: With FaaS, functions are scaled automatically, independently and instantaneously, as needed. When demand drops, FaaS automatically scales back down.
  
  
• Get all the benefits of robust cloud infrastructure: FaaS offers inherently high availability because it is spread across multiple availability zones per geographic region and can be deployed across any number of regions without incremental costs.

There are several best practices that you can follow to make using FaaS easier to deploy and more effective:

• Make each function perform only one action: FaaS functions should be designed to do a single piece of work in response to an event. Make your code scope limited, efficient and lightweight so functions load and run quickly.
  
  
• Don’t make functions call other functions: The value of FaaS is in the isolation of functions. Too many functions increase your costs and remove the value of the isolation of your functions.
  
  
• Use as few libraries in your functions as possible: Using too many libraries can slow down functions and make them harder to scale.

Because it enables transactions to be isolated and scaled easily, FaaS is good for high-volume and embarrassingly parallel workloads. It can also be used to create backend systems or for activities such as data processing, format conversion, encoding or data aggregation.

FaaS is also a good tool for web apps, backends, data or stream processing, or for creating online chatbots or back ends for IoT devices. FaaS can help you manage and use third-party services. If you’re considering Android app development, for example, you can adopt a FaaS approach to keep your costs in check. Because you’re only charged when your app connects to the cloud for a specific function like batch processing, costs can be considerably lower than they would when using a traditional approach.

FaaS can also dramatically boost computing performance. For example, two students recently worked with IBM engineers to explore how to use IBM Cloud Functions for Monte Carlo simulations (mathematical methods used to estimate the future outcomes of certain hard-to-predict events) to estimate stock prices. Monte Carlo simulations are considered an important high-performance computing workload.

The combination of Monte Carlo and IBM Cloud Functions enabled the team to run computations on a massive scale and allowed them to focus on the business logic. Using FaaS, the team completed an entire Monte Carlo simulation in about 90 seconds with 1,000 concurrent invocations. Comparatively, running the same flow over a laptop with four CPU cores took 247 minutes and almost 100% CPU utilization.

FaaS, PaaS (Platform-as-a-Service), containers and virtual machines (VMs) all play a critical role in the serverless ecosystem. Because FaaS is the most central and most definitional element of the serverless stack, it’s worth exploring how FaaS differs from other common models of compute on the market today across key attributes:

• Provisioning time: Milliseconds, compared to minutes and hours for the other models.
  
  
• Ongoing administration: None, compared to a sliding scale from easy to hard for PaaS, containers and VMs.
  
  
• Elastic scaling: Each action is instantly and inherently scaled, compared to the other models that offer automatic—but slow—scaling that requires careful tuning of auto-scaling rules.
  
  
• Capacity planning: None required, compared to the other models requiring a mix of some automatic scaling and some capacity planning.
  
  
• Persistent connections and state: Limited ability to persist connections and state must be kept in an external service or resource. The other models can use http, keep an open socket or connection for long periods of time, and can store state in memory between calls.
  
  
• Maintenance: The FaaS provider manages all maintenance. This is also true for PaaS. Containers and VMs require significant maintenance that includes updating and managing operating systems, container images, connections and more.
  
  
• High availability (HA) and disaster recovery (DR): Again, HA is inherent in the FaaS model with no extra effort or cost. The other models require more cost and management effort. In the case of both VMs and containers, infrastructure can be restarted automatically.
  
  
• Resource utilization: Resources are not idle—they are invoked only upon request. All other models feature at least some degree of idle capacity.
  
  
• Resource limits: FaaS is the only model that has resource limits on code size, concurrent activations, memory, run length and more.
  
  
• Charging granularity and billing: Per blocks of 100 milliseconds, compared to by the hour (and sometimes minute) of other models.

Kubernetes and Knative are one implementations of “plumbing” behind FaaS. Kubernetes is an open source, container orchestration tool that is critical to the managing of cloud applications. Knative lets you run serverless within a Kubernetes cluster.

The combination of Knative and Kubernetes means you can take advantage of Kubernetes functions like monitoring, security, logging and authentication and combine them with Knative benefits such as automated container build, full portability and working across hybrid environments.

Creators of this technology believed that developers should not have to choose between serverless and containers when building cloud apps. The goal was to augment the availability and consistency of containers with the powerful scaling and on-demand access of serverless.