Formerly known as Wikibon
Close this search box.

Evaluating Serverless Frameworks for the True Private Cloud


Serverless computing environments execute microservices that are stateless, event-driven, and asynchronous. Though typically associated with public cloud services, serverless computing is coming to private clouds as well. A growing range of open-source and other serverless frameworks are entering the market, providing options for enterprises that wish to deploy them entirely inside their private clouds or hybrid private/public serverless computing architectures.


Serverless computing is the foundation for functions as a service in the modern enterprise. When deployed to serverless clouds, functionally programmed code spares developers from needing to write the logic that manages containers, virtual machines, and other back-end runtime engines to which execution of microservices will be dynamically allocated.

Serverless computing also reduces most dependencies on underlying infrastructure, provides a polyglot development platform, and can boost the density and efficiency of cloud CPU, memory, storage, and other resource usage. Currently, the principal serverless offerings on the market are from public-cloud services from AWS, Google, IBM, and Microsoft. Nevertheless, a growing range of private-cloud serverless platforms are coming to market, making it possible to implement entirely on-premises serverless environments and even private-public serverless hybrids.

Deploying serverless capabilities across hybrid clouds need not dilute the service levels that users have come to expect from similar capabilities deployed on-premises in enterprise environments. The private-cloud-grade experience can remain intact even as data, models, code, workloads, and other application artifacts are moved back and forth in complex, hybrid multi-cloud environments. This robust hybrid-cloud experience is the essence of what Wikibon calls the “True Private Cloud.”

Depending on their programming, application, and IT infrastructure, developers may be able to bridge disparate serverless environments—public and private–via API calls, API gateways, message-oriented middleware, or shared mutable databases.

For implementing the private segment of a serverless hybrid cloud, there are a growing range of open-source frameworks in various states of maturity and development. The principal frameworks so far are Apache OpenWhisk, Fission, Gestalt, Nuclio, Fn, and IronFunctions.

Apache OpenWhisk

The Apache OpenWhisk incubating project implements a serverless framework for executing functions in response to events at any scale. Written mainly in Scala, OpenWhisk accepts input from HTTP requests and other triggers, then executes code in response. The executed code may be a snippet in Swift or JavaScript, or a binary in a Docker container. It allows multiple actions to be chained together from a single trigger. It also supports development of rules can describe which triggers can initiate which actions. Developer can integrate OpenWhisk with external API services or with any service that offers webhooks or API endpoints.


The Fission open-source project allows developers and other IT professionals to build and optimize their own serverless environments as well as write and execute functional code in those environments.

Developed by Platform9, Gestalt uses Kubernetes clusters—which may run in private datacenters, in public clouds, or on developer laptops–as the serverless infrastructure. It  maintains a pool of containers so that functions can have typical startup latencies below 100msec. It automatically handles function deployment, routing, scalability, and availability; creates API backends for web and mobile apps; and leverages Kubernetes’ service discovery and networking to interoperate with other services; and supports use of webhooks to integrate function code with third-party services.

By supporting subscriptions to Kubernetes watches, Fission lets developers write custom automation for their Kubernetes serverless infrastructures to monitor resources such as Pods and Services, and execute arbitrary functions when the watched set of resources change. Developers can write short-lived functions in many languages and map them to HTTP requests or other event triggers.

Fission’s currently supported languages include Python, Node.js, Go, C#, and PHP, with Fission extensible to others. It allows triggers to run functions that are provisioned in Docker containers, without the need for developers to build containers (though it gives them to option to do so) or manage Docker registries.


The Gestalt framework, currently in beta, allows developers and other IT professionals to build and optimize their own serverless environments as well as write and execute functional code in those environments.

Developed by Galactic Fog, Gestalt is a set of pre-integrated microservices for running functions as a service in as a simple process or in a Docker container. Gestalt can be deployed in a Kubernetes cluster or Mesosphere DC/OS. Gestalt’s Lambda Engine executes functionally programmed code asynchronously in response to events. Gestalt’s event service supports Kafka, exposes a REST interface, and supports standardized message semantics.

Gestalt provides an abstraction layer and microservices to manage integration with most enterprise systems, and comes pre-integrated with pluggable authentication, configuration management, change management, notification, auditing, and enterprise service bus services. Functions may be written in JavaScript, .Net, Python, Go, Ruby, and Scala. It includes a generalized infrastructure layer that runs both the Gestalt services and any client function code in a scalable, resilient manner in bare metal, virtualized, and cloud environments. It can automatically restart any application service that dies, or restart a service on a different server if the original dies, using a distributed file system to ensure that when the service is restarted on another node it has access to all the state information required to resume functioning. It automates scaling and load balancing across all application services.


The Nuclio framework, under development by Iguazio, supports low-latency serverless processing of data and real-time events in private or public clouds. A Nuclio processor listens on event sources and parallelizes user-function execution through a constellation of workers. It is deployable as a standalone binary for IoT devices and other nodes, as a microservice that can be containerized in Docker, and orchestrated with Kubernetes. A Nuclio function instance can process hundreds of thousands of HTTP requests or data records per second. This is 10–100 times faster than some other frameworks. Nuclio abstracts data resources from function code, enabling code portability and data-path acceleration. Developers use the Nuclio SDK to write, test, and submit their code, without the need for the entire nuclio source tree.


Oracle’s Fn project is an open-source serverless functions platform. Licensed under Apache 2.0, Fn is an extensible platform that can be deployed anywhere that a Docker container can be run. It supports any programming language supported by Docker and can orchestrate containerized functions with KubernetesMesosphere or Docker Swarm. Fn includes out-of-box support for Java, Go, Ruby, Python, PHP, Node.js, and Lambda functions. And Fn incorporates a smart load balancer for routing traffic to functions.


The IronFunctions framework is for any cloud or other platform that can run a Docker container. Developed by, IronFunctions executes functional code in Docker and will support any language runtime that can be packaged as such. Optionally, functional code can be deployed in Kubernetes or any other orchestration environment. IronFunctions supports cross-integration of orchestrated functions with AWS Lambda, with the ability to import functions directly from AWS Lambda.

Action Item

Developers should explore the possibility of running functionally programmed microservices in serverless private clouds or in private/public serverless hybrids. Doing so can boost the density and efficiency of cloud CPU, memory, storage, and other resource usage across enterprise “True Private Clouds.” However, the marketplace for serverless private-cloud platforms is immature, with the available development frameworks still new to market and not yet implemented widely. Consequently, enterprise IT professionals who implement serverless within their on-premises environments must acknowledge the risks of being early adopters in this regard.

Book A Briefing

Fill out the form , and our team will be in touch shortly.
Skip to content