Skip to main content
Redhat Developers  Logo
  • Products

    Platforms

    • Red Hat Enterprise Linux
      Red Hat Enterprise Linux Icon
    • Red Hat AI
      Red Hat AI
    • Red Hat OpenShift
      Openshift icon
    • Red Hat Ansible Automation Platform
      Ansible icon
    • View All Red Hat Products

    Featured

    • Red Hat build of OpenJDK
    • Red Hat Developer Hub
    • Red Hat JBoss Enterprise Application Platform
    • Red Hat OpenShift Dev Spaces
    • Red Hat OpenShift Local
    • Red Hat Developer Sandbox

      Try Red Hat products and technologies without setup or configuration fees for 30 days with this shared Openshift and Kubernetes cluster.
    • Try at no cost
  • Technologies

    Featured

    • AI/ML
      AI/ML Icon
    • Linux
      Linux Icon
    • Kubernetes
      Cloud icon
    • Automation
      Automation Icon showing arrows moving in a circle around a gear
    • View All Technologies
    • Programming Languages & Frameworks

      • Java
      • Python
      • JavaScript
    • System Design & Architecture

      • Red Hat architecture and design patterns
      • Microservices
      • Event-Driven Architecture
      • Databases
    • Developer Productivity

      • Developer productivity
      • Developer Tools
      • GitOps
    • Automated Data Processing

      • AI/ML
      • Data Science
      • Apache Kafka on Kubernetes
    • Platform Engineering

      • DevOps
      • DevSecOps
      • Ansible automation for applications and services
    • Secure Development & Architectures

      • Security
      • Secure coding
  • Learn

    Featured

    • Kubernetes & Cloud Native
      Openshift icon
    • Linux
      Rhel icon
    • Automation
      Ansible cloud icon
    • AI/ML
      AI/ML Icon
    • View All Learning Resources

    E-Books

    • GitOps Cookbook
    • Podman in Action
    • Kubernetes Operators
    • The Path to GitOps
    • View All E-books

    Cheat Sheets

    • Linux Commands
    • Bash Commands
    • Git
    • systemd Commands
    • View All Cheat Sheets

    Documentation

    • Product Documentation
    • API Catalog
    • Legacy Documentation
  • Developer Sandbox

    Developer Sandbox

    • Access Red Hat’s products and technologies without setup or configuration, and start developing quicker than ever before with our new, no-cost sandbox environments.
    • Explore Developer Sandbox

    Featured Developer Sandbox activities

    • Get started with your Developer Sandbox
    • OpenShift virtualization and application modernization using the Developer Sandbox
    • Explore all Developer Sandbox activities

    Ready to start developing apps?

    • Try at no cost
  • Blog
  • Events
  • Videos

The evolution of serverless and FaaS: Knative brings change

March 26, 2019
Don Schenck
Related topics:
ContainersMicroservicesKubernetesServerless
Related products:
Red Hat OpenShift

Share:

    Are serverless and Function as a Service (FaaS) the same thing?

    No, they're not.

    Wait. Yes, they are.

    Frustrating, right? With terms being thrown about at conferences, in articles (I'm looking at myself right now), conversations, etc., things can be confusing (or, sadly, sometimes misleading). Let’s take a look at some aspects of serverless and FaaS to see where things stand.

    What is serverless anyway?

    That's simple: It's computing without a server. It’s magic.

    Actually, no; that’s not true. Of course, there is a server (or many servers) involved. One of the tenants of serverless is that the developer need not be concerned with server “stuff.” No need to fuss over RAM usage and scaling and so on. Simply (now that is a loaded word, “simply”) deploy your code and it works.

    Here’s the official definition from the Cloud Native Computing Foundation:

    "Serverless computing refers to the concept of building and running applications that do not require server management. It describes a finer-grained deployment model where applications, bundled as one or more functions, are uploaded to a platform and then executed, scaled, and billed in response to the exact demand needed at the moment."

    An important point is the last sentence about executing, scaling, and billing on demand. Until recently—that is, until Knative appeared on the scene—a microservice ran 24x7 and was not, by the above definition, serverless.

    Since serverless and FaaS have traditionally been used as interchangeable terms, they were considered one and the same. This much was constant: They both did not describe a typical microservice that is available all the time. In fact, discussions (arguments?) surfaced about the use of FaaS and/or microservices, with some even going so far as to claim that all microservices should, in fact, be serverless functions. While that may seem extreme to some, it has almost become a moot point. Why?

    Enter Knative serving

    At the time when Google announced the availability of Knative, Kubernetes-based platform, FaaS offerings were typically based on small pieces of source code that ran as functions. Compiling them wasn't often necessary. OpenWhisk—an open source FaaS platform—uses the command wsk action create... to turn, for example, a Node.js file into a function (they're called "Actions" in OpenWhisk parlance). One small file and one command and you have a function. You don't even need to code any HTTP handlers or routes; it's all built into the platform. And there's one and only one route. The function has one entry and exit point; it's not a complex RESTful service with multiple URIs.

    Knative disrupted all that by making any service available as a function, in that Knative allows a service to scale to zero after a configured period of time. In other words, the service stops running, which means no CPU cycles, no disk activity, and no billing activity during its idle time. That's not a small thing. It is the essence of serverless functions, and suddenly a RESTful service that handles, say, four different routes could now be considered a serverless function.

    True, scaling to zero has its own challenge: how to minimize restart time. That’s another article altogether.

    So, by definition, any service that can scale to zero and respond on demand is serverless (or FaaS or serverless function).

    But wait, there's more

    Knative also brings other functionality to the developer: building, eventing, and serving are the three parts of Knative. I briefly discussed serving, but building and eventing are important as well.

    Eventing, for instance, allows you to fire off services by using events. Put events into a queue and you have a truly event-driven architecture application. If you've ever built apps on a message-based platform (for example, Windows desktop applications) you're familiar with the idea of events and messages "flying all around," making a system work. When done right, it's a beautiful symphony of harmonious code.

    (OK, that last part was a bit over the top, but you get the idea.)

    Knative leverages advanced and fast technologies, including Istio service mesh and gRPC. Although a developer probably won't need to be aware of these things, someone does, and it does matter. In short, Knative is more of a platform rather than simply an implementation. It gives you a broad and robust foundation for your own implementation of functions.

    Which one should I use?

    There are reasons for both Knative and, say, something like OpenWhisk. Knative is speeding the evolution (and, likely, the adoption) of serverless/FaaS solutions, while existing technologies such as OpenWhisk remain useful. Further, it remains to be seen if and how traditional FaaS platforms embrace Knative.

    As with any technology, it’s up to you to determine what mix of the two is best for you. Armed with knowledge and enabled with opportunities to test these technologies for zero cost, you're in a good position to choose and move forward. As the technology evolves, so will your solutions.

    For more information about Knative, visit the GitHub repo and the Knative documentation.

    Last updated: May 2, 2019

    Recent Posts

    • Migrating Ansible Automation Platform 2.4 to 2.5

    • Multicluster resiliency with global load balancing and mesh federation

    • Simplify local prototyping with Camel JBang infrastructure

    • Smart deployments at scale: Leveraging ApplicationSets and Helm with cluster labels in Red Hat Advanced Cluster Management for Kubernetes

    • How to verify container signatures in disconnected OpenShift

    Red Hat Developers logo LinkedIn YouTube Twitter Facebook

    Products

    • Red Hat Enterprise Linux
    • Red Hat OpenShift
    • Red Hat Ansible Automation Platform

    Build

    • Developer Sandbox
    • Developer Tools
    • Interactive Tutorials
    • API Catalog

    Quicklinks

    • Learning Resources
    • E-books
    • Cheat Sheets
    • Blog
    • Events
    • Newsletter

    Communicate

    • About us
    • Contact sales
    • Find a partner
    • Report a website issue
    • Site Status Dashboard
    • Report a security problem

    RED HAT DEVELOPER

    Build here. Go anywhere.

    We serve the builders. The problem solvers who create careers with code.

    Join us if you’re a developer, software engineer, web designer, front-end designer, UX designer, computer scientist, architect, tester, product manager, project manager or team lead.

    Sign me up

    Red Hat legal and privacy links

    • About Red Hat
    • Jobs
    • Events
    • Locations
    • Contact Red Hat
    • Red Hat Blog
    • Inclusion at Red Hat
    • Cool Stuff Store
    • Red Hat Summit
    © 2025 Red Hat

    Red Hat legal and privacy links

    • Privacy statement
    • Terms of use
    • All policies and guidelines
    • Digital accessibility

    Report a website issue