
Apache OpenWhisk – A serverless, open-source cloud platform - based2
https://openwhisk.apache.org/
======
cocktailpeanuts
Nowadays when someone claims to be "serverless", there can be two
interpretations:

1\. It's a server actually. It's just that the server serves up functions,
without state. So a more correct terminology would be "stateless servers"

2\. Truly P2P (Like blockchain), therefore there truly are no "servers".

Used to think Amazon did a great job coming up with the jargon that's great
for marketing, but lately as we see more and more option 2s which are TRULY
"serverless", the option 1s increasingly sound like imposters.

After all in option 1, there ARE servers. To be able to claim you're
"serverless", you really shouldn't have servers.

~~~
CharlesW
Like "cloud computing", the name "serverless" doesn't make much sense when
used literally. It doesn't mean that there are no servers involved, just that
there are none to be directly managed by the developer.

P2P also doesn't mean "no servers", but that every node is as much server as
client.

Amazon popularized but didn't invent the term "serverless", which appears to
have been first used in 2012.[1]

[1] [http://readwrite.com/2012/10/15/why-the-future-of-
software-a...](http://readwrite.com/2012/10/15/why-the-future-of-software-and-
apps-is-serverless/)

~~~
_hyn3
> It doesn't mean that there are no servers involved, just that there are none
> to be directly managed by the developer.

They already had stuff like that. S3. RDS. Elasticache. At least _the cloud_
gives you the nebulous feeling of servers off in the ether somewhere.

But _serverless_ is neither specific nor accurate. It doesn't work. It's
nothing more than lazy marketing-speak.

~~~
gr__or
> S3. RDS. Elasticache.

A requirement for serverless would be having access to a general programming
language which is why those examples don't really apply.

------
alexellisuk
Probably a good time to mention the CNCF Serverless Workgroup and the
Serverless landscape. It lists all the Kubernetes-native Serverless frameworks
as well as the proprietary ones.

OpenWhisk was one of the first projects in this space and is written entirely
in Scala. Good to see a Kubernetes integration emerging.

[https://medium.com/memory-leak/serverless-cloud-native-
lands...](https://medium.com/memory-leak/serverless-cloud-native-landscape-
new-from-redpoint-ventures-and-the-cloud-native-computing-181711d885f7)

Other notable projects: Oracle's Fn, Bitnami's Kubeless, Platform 9's Fission,
Iguazio's Nuclio and OpenFaaS (community project). (there are more)

~~~
lima
Red Hat is participating as well:

[https://developers.redhat.com/blog/2017/06/07/red-hat-and-
ap...](https://developers.redhat.com/blog/2017/06/07/red-hat-and-apache-
openwhisk/)

They're really invested in Kubernetes with their open source OpenShift PaaS.

~~~
rabbah
You can except more commitment to Kube from OpenWhisk.

------
masukomi
Can someone explain to me WHERE the servers exist for this "serverless"
platform? Is this code i run on lamda and lamda competitors? Is apache hosting
it? Do i have to set up my own servers to run the code?

All the intro docs and FAQs seem to assume that "serverless" is literally no
servers, just magical cloud fairies or something.

I get that it uses docker containers, but where can i / am i expected to run
those?

~~~
cnj
This is open source, so "someone" has to run it.

This someone could be e.g. IBM or RedHat, it could also be someone like Adobe
that wants to offer a FaaS integrated into their main product.

It could also be your own company, e.g. you could have an infrastructure team
that provides it for all other teams.

~~~
doppel
I find mentions of “deployments”, but unlike a platform like Kubernetes I
can’t seem to find any mention of how to set up the “serverless servers”
anywhere. And until then it’s just a really neat local CLI

~~~
bri3d
It looks like OpenWhisk right now deploys onto JVM application servers you
provision yourself, using runc+Docker and Akka clustering under the hood to
orchestrate everything. I think they have plans to target Kubernetes as well.
FaaS/"serverless" (a terrible name) is just a layer over an
orchestration/deployment system (like Kube) that spins up instances in
response to triggers / events and handles routing and scheduling of the
instances in a way that's supposed to be transparent to the end-user.
[https://github.com/apache/incubator-
openwhisk/blob/master/do...](https://github.com/apache/incubator-
openwhisk/blob/master/docs/deploy.md)

------
andybak
So serverless is essentially a return to the PHP/CGI execution model... What's
changed to turn a bad idea into a good idea again?

~~~
paulgb
Was it ever a bad idea, or did it just go out of fashion? I'm not a PHP fan,
but I miss the simplicity of low-end deployments on a LAMP stack by literally
dragging files over FTP. It seems like something has been lost with the total
embrace of more modern web frameworks.

~~~
diggan
It's just a difference in scale. I mean, you can still setup a FTP and drag
and drop your files to deploy, if you want to. But companies with many
developers deploying multiple changes per day, needs something that works
better and faster. Not saying that serverless is for them, but that's why
things get more complex sometimes. But you're still able to choose "older"
things.

~~~
paulgb
Definitely, I guess I just miss having a platform (LAMP) that scaled down as
well as up. I think it's really cool that some of the most trafficked websites
run WordPress and MediaWiki which can also be installed in a few clicks on a
$5/month shared host. I recently wrote a Python web app that uses Dynamodb and
Lambda and even though it's open source it feels way less portable.

------
goliatone
I have been interested in running a serverless setup for a while now, so I’ve
been looking at different open source alternatives to AWS lambda. I considered
OpenWhisk but felt IronFunctions would be quicker to setup and easier to run.
Anyone has experience deploying/using both? Would anyone that is running
OpenWhisk comment on the process to get it running?

~~~
thomasj
OpenWhisk can be started using Docker Compose locally with a single command
(make quickstart) using this repo: [https://github.com/apache/incubator-
openwhisk-devtools/tree/...](https://github.com/apache/incubator-openwhisk-
devtools/tree/master/docker-compose)

It can also be deployed on k8s with minimal effort:
[https://github.com/apache/incubator-openwhisk-deploy-
kube](https://github.com/apache/incubator-openwhisk-deploy-kube)

There's also instructions for using VMs as the infrastructure layer:
[https://github.com/apache/incubator-openwhisk#quick-
start](https://github.com/apache/incubator-openwhisk#quick-start)

If you have any issues open an issue or join us on the slack
([http://openwhisk.incubator.apache.org/slack.html](http://openwhisk.incubator.apache.org/slack.html)).

(I'm a committer on the project).

~~~
goliatone
In my previous quick search I did not find the incubator-openwhisk-devtools
repo, that left me with the impression that I had to run k8s which for my
purposes is too heavy handed. A docker setup is more in line with my needs
(run on vpc for quick side projects). thank you!

------
faizshah
If anyone else was wondering, this seems to originate from IBM in
collaboration with Adobe. More information on the architecture here:
[https://thenewstack.io/behind-scenes-apache-openwhisk-
server...](https://thenewstack.io/behind-scenes-apache-openwhisk-serverless-
platform/)

~~~
aisofteng
OpenWhisk is what runs IBM Cloud Functions:
[https://console.bluemix.net/openwhisk/](https://console.bluemix.net/openwhisk/)

~~~
rabbah
Also Adobe I/O runtime
[https://www.adobe.io/apis/cloudplatform/runtime.html](https://www.adobe.io/apis/cloudplatform/runtime.html).

------
tw1010
To anyone who has a good feel for this space. Where do you think all this is
heading in a 3-5 year time period? What is the medium-term vision like? I'm
just curious.

~~~
TuringNYC
I'm currently migrating to Kubernetes. Hard to tell where things go in 3yrs
(the pace of change is so high, a year seems like forever)...BUT...a couple of
things that drove me to the migration:

1 - Less stickiness to AWS since the serverless architecture would abstract
away the provider and i could theoretically even grab the cheapest spot
instances across providers (AWS, Google Cloud, SoftLayer, Azure) 2 - Lower
compute bills (due to better usage and being able to more tightly pack stuff
into nodes) 3 - Lower HR bills due to a lot of stuff just scaling up without
effort rather than dozens of deployment/babysitting staff

Hard to know for sure, but these are the three things that drove me to
Kubernetes.

~~~
BatFastard
But I find some type of persistence of data usually figures into my serverless
calls. And those tend to lock you into a vendor. Especially when you want to
start analysing the data you have.

Even if you could separate them it would add latency. Now if it JUST
compute... and I can see that as a possibility for some CV applications.

------
bontoJR
I am somewhat confused about this product. I think the Function as a Service
approach has really some good advantages on more classic approaches sometimes,
but if I want to go that path, what is the advantage to actually use an open
source product and maintain the server with all the maintenance required
(security updates, platform updates, handling scale, etc...)?

Wouldn't be an out of the box solution provided by AWL Lambda, Google Cloud
Functions, etc... a better and more straightforward option on this space?

I am just wondering if I am the only one with this opinion, what is your
experience on this topic?

~~~
themihai
Freedom to deploy anywhere is quite important to some people. One can truly
appreciate it only after gets burned by one of these "cloud" provides(i.e.
Google appengine/cloud).

------
ralusek
"Um, how is this SERVERLESS? Clearly it's running on a SERVER. I'm so sick of
this marketing jargon."

\- HackerNews, every time.

~~~
dominotw
Everytime

------
tmikaeld
I'm new to serverless, but I've wondered what happens if:

\- The function get stuck and run forever?

\- It causes a request to loop?

And you have hundreds or thousands of these "functions" deployed?

Couldn't that cause sky-high costs if it goes undetected or even unwanted DDOS
against other's infrastructure?

~~~
jedberg
The first one is easy, you just have a hard limit on runtime per invocation.

The second is harder. Last I checked, AWS Lambda for example would allow a
loop between two functions to run forever. You have to build loop detection
into your software.

------
polskibus
Excellent, more competition in serverless means increased adoption. Even
better if it is open source, in contrast to GOOG/AMZN/MSFT offerings! Seems
like an undercutting attempt on the IBM side?

Could someone with production-level serverless experience share his insights
on OpenWhisk capabilities and roadmap? What's missing from the G/A/M stacks?

~~~
thomasj
Apache OpenWhisk has a number of differences to other serverless platforms (as
well as being open-source) including...

\- Excellent "out of the box" runtime support including Node.js, Java, PHP,
Swift, Python, any binary runtime (Go, Rust, etc..). \- Custom runtime support
using Docker images. Allowing custom images as the execution environment makes
it easy to use (almost) anytime on the platform without needing this to come
built-in. Custom images can be used to add large libraries or other resources.
\- Integrated API Gateway. Makes it simple to expose custom routes to
functions. \- Multiple built-in event sources including HTTP events, CouchDB,
Kafka and more. Platform supports registering custom event providers to add
any external data feed or event source. \- Higher-order function composition
patterns including sequences.

There are numerous open-source serverless platforms but OpenWhisk is the most
mature and one of the only open-source platforms powering commercial
serverless offerings, being used by IBM Cloud Functions, Adobe and Red Hat. It
has used by IBM's offering with customers since early 2016.

Development is all public with the project being in the Apache incubation
phase. Upcoming features being worked on include Swift 4 support, on-going k8s
integration and better higher-order functional composition patterns. Check out
the Github PRs and issues for details.

(Disclosure: OpenWhisk committer and IBMer).

~~~
jacques_chester
I'd point out that supporting languages "out of the box" and having
extensibility via docker images is more or less table stakes at this point.

A lot of the other things you listed are present in other FaaSes too in
varying degrees.

No questioning that OpenWhisk was the first major opensource project in this
space, though.

~~~
thomasj
Docker extensibility is common in the open-source faas projects but not in
any(?) of the commercial serverless offerings (Google, Amazon or Microsoft).

Runtime support (upload code not a container) is more common in the commercial
offerings that most of the Docker-based faas frameworks, which use a container
as the packaging.

OpenWhisk is more flexible than most of the platforms with respect to
packaging IMO (Wanna deploy code? Great. Prefer containers? Sure. Wanna use
code and a custom image? No problem!)

Event support is more common in the commercial offerings (as they have cloud
services for you to use), whereas the "faas" framework seem more bare bones.
You'll have to configure event integration manually. Same goes for API
gateways.

OpenWhisk supports numerous open-source event providers with a extensible API
for integrating new providers. This is more complete that lots of the other
projects in this respect.

Over time these features will become default in all projects but there does
seem a split in focus between the commercial offerings and "faas" frameworks
at the moment. I'm biased :) but I think OpenWhisk has a comparible feature
set to Lambda (having been around for over two years) whilst still benefiting
from the open-source docker story.

------
mwea
Does anyone have informations about the scalability of FaaS models ?

Despite the monitoring part that must be quite hard.. I wonder about the
network saturation in case of services that get millions of requests per
minutes and having, in this model, function interactions going through the
network

------
retr0grad3
If you're run k8s on your infrastructure there's a pretty slick alternative
called Open FaaS:
[https://github.com/openfaas/faas](https://github.com/openfaas/faas)

~~~
jacques_chester
There are a number of alternatives targeting Kubernetes. I work on one -
Project Riff. Others I've peeked at are Kubeless, Fission and Fn. Some are
pure k8s systems (like Riff) and others like OpenFaaS aim to be portable
across orchestrators.

I believe OpenWhisk is being steered towards running on Kubernetes at some
point, but I am not qualified to say. When we looked at it last year as part
of the research which led to Riff, we were struck mostly by how many moving
parts are involved.

Disclosure: As I noted, I work on one of these things for Pivotal.

~~~
thomasj
OpenWhisk supports Kubernetes as a "first-class" deployment platform. Red Hat
have been doing lots of work on this since adopting the project
([https://developers.redhat.com/blog/2017/06/07/red-hat-and-
ap...](https://developers.redhat.com/blog/2017/06/07/red-hat-and-apache-
openwhisk/)).

See here for more details: [https://github.com/apache/incubator-openwhisk-
deploy-kube](https://github.com/apache/incubator-openwhisk-deploy-kube)

(Disclosure: I'm a committer on Apache OpenWhisk).

------
alpb
"an open source cloud platform" is probably an overstatement.

~~~
dzimine
It's what OpenStack has been - "opensource cloud platform". But yes, I agree,
overstatement for OpenWhisk.

------
djhworld
Is anyone actually using this (and other open source solutions that do similar
things) for anything?

The cloud providers offer "serverless" billing for AWS Lambda/GCP
Functions/Azure Functions in the sense that you pay just for the compute time
and don't manage the underlying infrastructure.

Outside of vendor lock in, what advantage does running a service like this
really offer? To make a system like this usable you'll probably need at least
a couple of boxes available 24/7

~~~
tedmiston
Run on top of k8s it, and similar projects like Riff, allow you to run Lambda-
style FaaS outside of clouds / on bare metal. That's the main benefit I see
currently, besides that many companies what to abstract their code to be as
cloud agnostic as possible.

Also, if you're running lots of function iterations, it can be cheaper to run
this way than Lambda etc.

------
maniacalrobot
People hear server-less, and go straight to thinking about hardware … in my
mind, server-less apps are missing the "application server" software, or it's
extracted away so far as to appear to be the operating system from the server-
less functions point of view.

------
softinio
I am excited about this project especially as its built using AKKA which I am
a big fan of.

------
elvinyung
Is there something to bridge the gap between serverful and serverless? Is
there a good enough framework that lets me write Rails-like code and have it
compile into a bunch of serverless jobs?

~~~
Willson50
I don't know about rails, but there's a good Flask -> Lambda project called
Zappa [https://github.com/Miserlou/Zappa](https://github.com/Miserlou/Zappa)

~~~
elvinyung
Close enough -- I'll look into it, thanks!

~~~
tedmiston
AWS Chalice is similar to Zappa as well.

~~~
dzimine
Similar but if you try the two side-by-side, you likely like Zappa much
more... unless you work for AWS :)

------
rabbah
Contribute on GitHub [https://github.com/apache/incubator-
openwhisk](https://github.com/apache/incubator-openwhisk)

------
ausjke
so, serverless is (fastcgi + container) these days? at least fastcgi website
is down for long time, and seems abandoned already along with cgi.

~~~
BraveNewCurency
Yes, FastCGI would work, as long as you don't mind wasting money.

But what happens when you have billions of scripts, each executed
infrequently? You need some way of fetching the scripts dynamically (they are
changing constantly), and way to time-multiplex their execution so you don't
waste RAM on inactive scripts. Oh, and load-balancing suddenly becomes non-
trivial because you prefer to route to one script spun up on one box (as long
as the usage doesn't justify multiple boxes), instead of accidentally spinning
up that script on every box.

What's new is the layer that is managing fetching, starting, and stopping the
scripts. For developers, it's 'kinda the same'. But for operators, it's a
massive change in how things work that enables a different paradigm.

------
deepnotderp
Any way to compute in HPC clusters using FaaS?

~~~
shaunray
Not where you can bring your own image as of yet. Although Thomasj above
mentions you can do this in OpenWhisk.

The closest to scientific HPC I have used personally is pywren
[https://github.com/pywren/pywren](https://github.com/pywren/pywren)

Which is attempting to add more cloud backends. It's out of Berkley
University.

~~~
stochastician
Hi! Pywren project lead here, we're working on more and more fun HPC-style
projects! We're also interested in expanding to more and more backends, so
please feel free to reach out if there's something you'd like to see.

------
amelius
Since it's serverless, I assume it runs on the client. How does it scale then?
And is the client really the right place to run these functions, in view of
performance, and perhaps battery use?

~~~
jacques_chester
"Serverless" is a marketing term invented by Amazon for what might in
retrospect have been better described as mini-PaaS.

It doesn't literally mean "without servers". It means that the developer
doesn't care about them. AWS have energetically pushed the line that in The
One True and Holy Definition of Serverless _operators_ don't care either.

Which, gee whiz, what a coincidence, distinguishes Lambda from opensource
projects like this.

Disclosure: I work on a FaaS, Project Riff, for Pivotal. So I guess we're
kinda competing with AWS? -ish?

~~~
zokier
> "Serverless" is a marketing term invented by Amazon for what might in
> retrospect have been better described as mini-PaaS.

Almost. Imho "serverless" describes more the architecture of applications, in
contrast to "mini-PaaS" which would then describe the platform on which such
applications are deployed.

~~~
jacques_chester
What about the architecture is different, in your view?

