OpenWhisk is the first OSS Serverless platform

IBM announced OpenWhisk as an experimental event-driven compute platform earlier this year. As one of the latest FaaS solutions on the market, it offers some unique functionalities worth exploring.

The project is completely open-source, and you can deploy it on any infrastructure, and always on the IBM Bluemix platform.

 

IBM Bluemix

 

What is IBM Bluemix?

IBM Bluemix went live at the beginning of 2014. It is based on the Cloud Foundry open-source technology, on top of the SoftLayer infrastructure.

Interestingly, Cloud Foundry was initially developed by VMWare, and it’s built in Ruby and Go, while OpenWhisk’s code base is mostly Scala and Python.

Bluemix offers a wide suite of private and hybrid Cloud solutions, including bare metal servers, virtual serverscontainer management, object storage, data analytics, machine learning powered by Watson, a browser-based Swift sandbox, and OpenWhisk. It only supports three regions for now: the southern U.S., Sydney, and the UK.

In this article, I will showcase OpenWhisk and compare it to the main Serverless/FaaS alternatives. I already compared Google Cloud Functions and AWS Lambda, and I’ll be working on more comparison articles soon.

OpenWhisk main concepts

The OpenWhisk model defines five basic concepts:

  • Actions: Actions correspond to Functions, which means your code plus an additional abstraction layer to make every function language-agnostic, thanks to a shared JSON interface.
  • Sequences: You can connect and chain multiple actions and leverage reusability and composability.
  • Triggers: An easy way to organize your event sources.
  • Rules: Connect Triggers and Actions with firing rules.
  • Packages: Packages allow you to bundle together a set of actions and share them with others.

As we will see, you can manipulate, share and interact with these objects in many ways to build your services catalog and automate their cooperation. And naturally, you can do so without managing, patching, or maintaining any server.

How can you interact with OpenWhisk?

You can use OpenWhisk on the official Bluemix web console, which provides a modern and user-friendly visual experience that is well integrated with the rest of the Bluemix suite.

In spite of looking beautiful and user-friendly, you cannot perform every operation directly from the console. I would highly recommend the OpenWhisk CLI (wsk) for automating operations. You can download the wsk executable here.

By default, every OpenWhisk action corresponds to a unique RESTful endpoint. You can access this endpoint via secure HTTPS requests (only POST, apparently). This pattern is compliant with the JSON input/output interface.

Additionally, you can also install the official iOS SDK. By using the mobile SDK, you can invoke your actions from any iOS device. In addition to OpenWhisk, the SDK also contains the code to access other Bluemix services, such as Mobile Data, Push, and Mobile Application Security.

OpenWhisk Welcome

What makes OpenWhisk unique?

OpenWhisk is still in Beta, and it currently covers the basic requirements to be a viable FaaS solution.

Some of its core concepts and functionalities make it different and unique compared to its FaaS competitors. Here is a non-exhaustive list:

1) Language support

The native support for specific programming languages can affect a FaaS platform’s adoption. I think IBM chose to be quite specific but also flexible at the same time.

You can currently choose one of the following options:

  • Node.js 0.12
  • Node.js 6
  • Python 2.7
  • Swift 2
  • Swift 3
  • Docker Images

The interesting options here are Swift and Docker.

Swift is an interesting choice because it allows iOS developers to build their mobile backend with the same client-side language that they are already familiar with.

On the other hand, Docker allows you to implement actions in any language, as long as you are compliant with the interface. I would say this is very flexible and powerful, although I would love to see native support for a wider set of languages, such as Java, Scala, PHP, Ruby, and Python 3, etc.

2) Built-in composability & reusability

The ability to connect, chain, and reuse your functions is a weak aspect of many FaaS solutions. The IBM team decided to make it a built-in feature. Indeed, you can create Sequences of Actions so that the output of the previous one will be the input of the next one.

In addition to Sequences, you also have a shared library of utility functions to make chainability easier. These functions will allow you to build smaller and more reusable building blocks. Plus, you can bundle and share these sets of functions as Packages.

3) Shared catalog of Packages

OpenWhisk comes with a ready-to-use set of Actions to automate 3rd party integrations and to simplify the interaction with other Bluemix services.

For example, you can bind GitHub, Slack, Weather, Watson, Cloudant, Mobile Push, WebSockets, and more to your sequences.

OpenWhisk Catalog

4) Language-agnostic default parameters

It might seem like a trivial feature, but it makes a developer’s life easier. Indeed, you can define default parameters for any function and language without changing the action’s code.

For example, you may define default parameters via CLI as follows:

This way, your function will be given a JSON object containing the default value “John” for your “name” parameter. Of course, you can pass a different value at invocation time and it will overwrite the default value. As you can see, this won’t change your JavaScript, Python, or Swift code at all.

5) Native HTTP integration

Another interesting detail is that you don’t need to configure anything at all to expose your actions via HTTP. OpenWhisk will automatically create an HTTP endpoint for each action. At the moment, you can only invoke actions via POST requests and Basic Authentication headers. As a complementary downside, it seems like this configuration cannot be customized.

For example, you would invoke your actions via cURL as follows:

What’s still missing?

As with any beta release, OpenWhisk is still missing some critical features.

I will mention just a few:

1) Versioning and staging

I think the platform needs a clear and flexible way to deal with multiple Versions of the same Action. It also needs a mechanism to bind a version to specific endpoints and environments (e.g. dev, prod, etc.).

For now, you can only define Organizations and Spaces at the Bluemix account level, which might help work around the problem but it won’t make your life any easier.

2) HTTP customizations

It’s currently not possible to design a RESTful API. You can’t define custom paths or bind different Actions to each HTTP method (i.e. GET, POST, PUT, etc.). As mentioned above, the current HTTP integration is completely automatic and very easy to use, but it’s not aligned with the REST principles yet.

3) Lack of documentation

The official documentation doesn’t cover some major details about the CLI yet. For example, I couldn’t find how to deal with code packaging for Python and Swift dependencies.

I am personally quite hopeful about this, since the documentation is open source too, and everyone can contribute. I have already fixed a typo myself with a PR on Github.

4) Server-side Swift issues

As for the official documentation, Swift actions run in a Linux environment and use the latest available release, which is not necessarily stable. It means that the Swift version might be different from the stable releases of XCode.

I would assume that this will need to change sometime soon to make OpenWhisk a real mobile backend alternative.

OpenWhisk Technical Limitations

Every FaaS solution comes with different technical limitations and constraints that might affect how you develop your functions.

Here is a summary of the main limitations, which may change in the future once OpenWhisk goes out of Beta:

  • Execution time: max 5min
  • Memory allocation: max 512MB
  • Logs size: max 10MB
  • Code size: max 48MB
  • Payload size: max 1MB
  • Parameters size: max 1MB
  • Concurrent invocations per Namespace: max 1000
  • Invocations per minute: max 5000
  • Triggers firing per minute: max 5000

I think that the biggest constraint, compared to other FaaS competitors, is the maximum code size. In some cases, your code might weight more than 48MB if you need many auxiliary files or large libraries.

I guess these limits will change after the Beta and I’m also looking forward to the official pricing.

Conclusion

I think that OpenWhisk has great potential. Its GitHub project reached 45 contributors in less than nine months and the community seems to be growing fast. Transparency and customizability may be its winning points, although the ability to provide high-quality performance and unique features will play an important role too.

In my next article, I will compare OpenWhisk to the main serverless alternatives, including, AWS Lambda, Azure Functions, Google Cloud Functions, and others.

If you are interested in Serverless technologies, you may want to re-watch the webinar Introduction to the Serverless Paradigm by Austen Collins and me, or read my previous Google Cloud Functions VS AWS Lambda comparison.