Openwhisk Runtime Java

Apache OpenWhisk Runtime Java supports Apache OpenWhisk functions written in Java and other JVM-hosted languages
Alternatives To Openwhisk Runtime Java
Project NameStarsDownloadsRepos Using ThisPackages Using ThisMost Recent CommitTotal ReleasesLatest ReleaseOpen IssuesLicenseLanguage
2 hours ago388apache-2.0Scala
Apache OpenWhisk is an open source serverless cloud platform
Incubator Teaclave703
a month ago53apache-2.0Rust
Apache Teaclave (incubating) is an open source universal secure computing platform, making computation on privacy-sensitive data safe and simple.
Openwhisk Deploy Kube283
9 months ago42apache-2.0Shell
The Apache OpenWhisk Kubernetes Deployment repository supports deploying the Apache OpenWhisk system on Kubernetes and OpenShift clusters.
Openwhisk Devtools168
9 months ago22apache-2.0JavaScript
Development tools for building and deploying Apache OpenWhisk
Openwhisk Cli99
5 months ago13March 26, 2021110apache-2.0Go
Apache OpenWhisk Command Line Interface (CLI)
Openwhisk Client Js8353950a month ago57August 22, 202224apache-2.0JavaScript
JavaScript client library for the Apache OpenWhisk platform
Openwhisk Wskdeploy75
7 months ago8April 07, 2021178apache-2.0Go
Apache OpenWhisk utility for deploying and managing OpenWhisk projects and packages
Openwhisk Apigateway61
9 months ago35apache-2.0Lua
Apache OpenWhisk API Gateway service for exposing actions as REST interfaces.
Openwhisk Composer60419 months ago6January 22, 20208apache-2.0JavaScript
Apache OpenWhisk Composer provides a high-level programming model in JavaScript for composing serverless functions
Openwhisk Runtime Nodejs59
11 days ago6apache-2.0JavaScript
Apache OpenWhisk Runtime NodeJS supports Apache OpenWhisk functions written in JavaScript for NodeJS
Alternatives To Openwhisk Runtime Java
Select To Compare

Alternative Project Comparisons

Apache OpenWhisk runtimes for java

License Continuous Integration


Quick Java Action

A Java action is a Java program with a method called main that has the exact signature as follows:

public static main(;

For example, create a Java file called with the following content:


public class Hello {
    public static JsonObject main(JsonObject args) {
        String name = "stranger";
        if (args.has("name"))
            name = args.getAsJsonPrimitive("name").getAsString();
        JsonObject response = new JsonObject();
        response.addProperty("greeting", "Hello " + name + "!");
        return response;

In order to compile, test and archive Java files, you must have a JDK 8 installed locally.

Then, compile into a JAR file hello.jar as follows:

jar cvf hello.jar Hello.class

Note: google-gson must exist in your Java CLASSPATH when compiling the Java file.

You need to specify the name of the main class using --main. An eligible main class is one that implements a static main method as described above. If the class is not in the default package, use the Java fully-qualified class name, e.g., --main com.example.MyMain.

If needed you can also customize the method name of your Java action. This can be done by specifying the Java fully-qualified method name of your action, e.q., --main com.example.MyMain#methodName

Not only support return JsonObject but also support return JsonArray, the main function would be:


public class HelloArray {
    public static JsonArray main(JsonObject args) {
        JsonArray jsonArray = new JsonArray();
        return jsonArray;

And support array result for sequence action as well, the first action's array result can be used as next action's input parameter.

So the function would be:


public class Sort {
    public static JsonArray main(JsonArray args) {
        return args;

Create the Java Action

To use as a docker action:

wsk action update helloJava hello.jar --main Hello --docker openwhisk/java8action

This works on any deployment of Apache OpenWhisk

To use on a deployment of OpenWhisk that contains the runtime as a kind:

wsk action update helloJava hello.jar --main Hello --kind java:8

Invoke the Java Action

Action invocation is the same for Java actions as it is for Swift and JavaScript actions:

wsk action invoke --result helloJava --param name World
      "greeting": "Hello World!"

Local development


  • Gradle
  • Docker Desktop (local builds)

Build and Push image to a local Docker registry

  1. Start Docker Desktop (i.e., Docker daemon)

  2. Build the Docker runtime image locally using Gradle:

./gradlew core:java8:distDocker

This will produce the image whisk/java8action and push it to the local Docker Desktop registry with the latest tag.

  1. Verify the image was registered:
$ docker images whisk/*
REPOSITORY           TAG     IMAGE ID            CREATED             SIZE
whisk/java8action    latest  35f90453905a        7 minutes ago       521MB

Build and Push image to a remote Docker registry

Build the Docker runtime image locally using Gradle supplying the image Prefix and Registry domain (default port):

docker login
./gradlew core:java8:distDocker -PdockerImagePrefix=$prefix-user

Deploying the Java runtime image to OpenWhisk

Deploy OpenWhisk using ansible environment that contains the kind java:8 Assuming you have OpenWhisk already deployed locally and OPENWHISK_HOME pointing to root directory of OpenWhisk core repository.

Set ROOTDIR to the root directory of this repository.

Redeploy OpenWhisk

cd $OPENWHISK_HOME/ansible
ANSIBLE_CMD="ansible-playbook -i ${ROOTDIR}/ansible/environments/local"
$ANSIBLE_CMD setup.yml
$ANSIBLE_CMD couchdb.yml
$ANSIBLE_CMD initdb.yml
$ANSIBLE_CMD wipe.yml
$ANSIBLE_CMD openwhisk.yml

Or you can use wskdev and create a soft link to the target ansible environment, for example:

ln -s ${ROOTDIR}/ansible/environments/local ${OPENWHISK_HOME}/ansible/environments/local-java
wskdev fresh -t local-java


Install dependencies from the root directory on $OPENWHISK_HOME repository

./gradlew install

Using gradle to run all tests

./gradlew :tests:test

Using gradle to run some tests

./gradlew :tests:test --tests *ActionContainerTests*

Using IntelliJ:

  • Import project as gradle project.
  • Make sure working directory is root of the project/repo

Using container image to test

To use as docker action push to your own dockerhub account

docker tag whisk/java8action $user_prefix/java8action
docker push $user_prefix/java8action

Then create the action using your the image from dockerhub

wsk action update helloJava hello.jar --main Hello --docker $user_prefix/java8action

The $user_prefix is usually your dockerhub user id.


Gradle build fails with "Too many files open"

This may occur on MacOS as the default maximum # of file handles per session is 256. The gradle build requires many more and is unable to open more files (e.g., For example, you may see something like:

> /Users/XXX/.gradle/caches/4.6/scripts-remapped/build_4mpzm2wl8gipqoxzlms7n6ctq/7gdodk7z6t5iivcgfvflmhqsm/cp_projdf5583fde4f7f1f2f3f5ea117e2cdff1/ (Too many open files)

You can see this limit by issuing:

$ ulimit -a
open files                      (-n) 256

In order to increase the limit, open a new terminal session and issue the command (and verify):

$ ulimit -n 10000

$ ulimit -a
open files                      (-n) 10000

Gradle Task fails on :core:java8:tagImage

Docker daemon is not started and the Task is not able to push the image to your local registry.


Apache 2.0

Popular Apache Projects
Popular Functions As A Service Projects
Popular Web Servers Categories
Related Searches

Get A Weekly Email With Trending Projects For These Categories
No Spam. Unsubscribe easily at any time.
Functions As A Service
Serverless Functions
Serverless Architectures