Documentation

There are many resources for learning about OpenWhisk; this page attempts to organize, describe, index and link to the essential information, wherever it resides, to help users in getting started. In general, much of the best information is in the actual project repositories and we encourage you to seek detailed and in-depth information there.

Project Structure

OpenWhisk is comprised of multiple repositories that can be found in Apache GitHub (using a name query by repository):

https://github.com/apache?q=openwhisk

For convenience, here is a listing of current Apache OpenWhisk project repositories (by category).

Note: OpenWhisk repositories follow a naming convention where all repo starts with incubator, for example, openwhisk-cli GitHub repository is named incubator-openwhisk-cli.

Platform

Primary source code repositories including platform code, run books, tests and more.

openwhisk

openwhisk-cli

openwhisk-apigateway

openwhisk-catalog

Packages

Several common service integrations are made available as packages. By default they are registered in the OpenWHisk catalog, under the /whisk.system/ namespace, and include:

openwhisk-package-alarms

openwhisk-package-cloudant

openwhisk-package-kafka

openwhisk-package-deploy

openwhisk-package-pushnotifications

openwhisk-package-rss

openwhisk-package-jira

openwhisk-package-template

Clients and SDK

Here are the clients to access to OpenWhisk API:

openwhisk-client-go

openwhisk-client-js

openwhisk-client-swift

openwhisk-client-python

Others

Few other misc. but crucial repositories.

openwhisk-release

openwhisk-website

openwhisk-external-resources

OpenWhisk documentation is organized by the following roles:
  • Operators: users who deploy, configure, and host the Apache OpenWhisk Function-as-a-Service platform for development, testing and/or production.
  • Developers: end users developing functions/actions, creating packages, feeds, and feed provider services using project APIs, clients and tooling.
  • Contributors: developers designing and developing backend architectural components and tooling that comprise the OpenWhisk platform and its project ecosystem.

Operators

OpenWhisk Architecture

OpenWhisk Architecture

The above diagram depicts the high-level architecture of OpenWhisk. From Nginx to Kafka to Docker, multiple technologies are powering Apache OpenWhisk - Open Source Serverless Cloud Platform. You can read about the list of OpenWhisk components and its internal flow of processing here.

OpenWhisk Deployment

OpenWhisk supports different installation methods for core OpenWhisk platform components. You can choose one of the following deployment methods based on your platform:

Docker Compose

The easiest way to start deploying OpenWhisk is to get Docker installed on Mac, Windows or Linux. This does not give you a production deployment but gives you enough of the pieces to start writing functions and seeing them executing.

$ git clone https://github.com/apache/incubator-openwhisk-devtools.git
$ cd incubator-openwhisk-devtools/docker-compose
$ make quick-start

For more detailed instructions, see the OpenWhisk with Docker Compose project.

Kubernetes

OpenWhisk can be installed on Minikube, or on a managed Kubernetes cluster provisioned from a public cloud provider, or on a Kubernetes cluster you manage yourself. Please refer to Deploy OpenWhisk to a Kubernetes Cluster for detailed deployment instructions.

Mesos

Deploy OpenWhisk to a Mesos Cluster is under active development.

OpenShift

Here are the instructions and details on how to deploy OpenWhisk on OpenShift.

Ansible

Deploying OpenWhisk using Ansible is generally done for creating a development environment. Most of the OpenWhisk tools follow this method of deployment in their CI/CD (Travis) pipeline. The OpenWhisk playbooks are structured such that it allows cleaning, deploying, or re-deploying a single component as well as the entire OpenWhisk stack.

Vagrant

A Vagrant machine is also available to run OpenWhisk on Mac, Windows PC or GNU/Linux. Downloading and install VirtualBox and Vagrant for your operating system and architecture. You can follow the steps under Vagrant Setup to run your first OpenWhisk action using Vagrant.

There are many different deployment methods available but we recommend Deploy OpenWhisk to a Kubernetes Cluster as its the most easy and quickest way of getting OpenWhisk deployed.

Administrative Operations

This section contains a list of resources which can be utilized to administer the running OpenWhisk instance.

Developers

The OpenWhisk project and programming model supports different kinds of developers that may wish to user different runtimes and tooling. Here is the developer relevant content to find the information you may need.

Pre-requisites

Please make sure you have access to working instance of OpenWhisk. If not, refer to OpenWhisk Deployment for detailed instructions on how to install and configure OpenWhisk.

Using OpenWhisk

OpenWhisk Deployment has a guest account configured with the authentication key available at https://github.com/apache/incubator-openwhisk/blob/master/ansible/files/auth.guest. Also, use the 192.168.33.13 address as the whisk API host.

OpenWhisk CLI (wsk)

OpenWhisk offers the wsk Command Line Interface (CLI) to easily create, run, and manage OpenWhisk entities.

Installing
Install the wsk with Homebrew (Mac & Linux)

To easily install the OpenWhisk CLI (wsk) you can use Homebrew for Mac or Homebrew for Linux.

$ brew update
$ brew install wsk

Then you can invoke the OpenWhisk CLI by just typing wsk.

Install the wsk CLI from a tar.gz (Mac & Linux):

If for any reason you can't or don't want to use one of the previous installation method, you can still download the OpenWhisk CLI in a standalone .tar.gz file with everything you need to get started.

The latest files can be found on the Releases page at GitHub: https://github.com/apache/incubator-openwhisk-cli/releases

Download the file for your platform and uncompress it. Inside it you will have a wsk executable.

To make it simpler to use, you can move the binary into your PATH:

$ sudo mv [full path to downloaded wsk] /usr/local/bin/wsk

Then you can invoke the OpenWhisk CLI by just typing wsk.

Install the wsk CLI from a tar.gz (Windows):

The latest files can be found on the Releases page at GitHub: https://github.com/apache/incubator-openwhisk-cli/releases

Download the file for your platform and uncompress it. Inside it you will have a wsk.exe executable.

To make it simpler to use, you should add it to your PATH.

Then you can invoke the OpenWhisk CLI by just typing wsk.

Verifying
  • CLI Help: To get the CLI command help, execute the following command:
    $ wsk --help
Configuring
  • Authenticate wsk CLI

    You can configure wsk CLI to use your OpenWhisk credentials in few different ways:

    • With wsk property setup

      Run the following command to set whisk API HOST and authorization key to create the configuration file:

      $ wsk property set --apihost <API_HOST> --auth <AUTH_KEY> --namespace guest

      Credentials are stored in ~/.wskprops, which you can edit directly if needed.

    • Environment Variables Setup

      Access credentials can be provided using properties file as environment variable:

      $ export WSK_CONFIG_FILE=<your-config-file>
      $ wsk list

Whisk Deploy (wskdeploy)

Whisk Deploy is a utility, named wskdeploy, to help deploy and manage all your OpenWhisk Packages, Actions, Triggers, Rules and APIs using a single command.

  • Download the Whisk Deploy: Binaries of wskdeploy are available for download on the project's GitHub release page: https://github.com/apache/incubator-openwhisk-wskdeploy/releases.
  • wskdeploy Help: Start by verifying the utility can display the command line help:
    $ wskdeploy --help
  • Create Package Manifest File manifest.yaml: Please refer to the Whisk Deploy Programming Guide for all manifest file grammar and syntax. This programming guide has step-by-step instructions for deploying OpenWhisk applications using wskdeploy.
  • Deploy your Application:
    • Note: Before you proceed with the deployment, please make sure you have the authentication setup as described here.
    • Deploying an OpenWhisk Manifest file:
      $ wskdeploy -m manifest.yaml

OpenWhisk REST API

After your OpenWhisk environment is enabled, you can use OpenWhisk with your web apps or mobile apps with REST API calls. For more details about the APIs for actions, activations, packages, rules, and triggers, see the OpenWhisk API documentation.

OpenWhisk Clients

OpenWhisk provides a wrapper around the OpenWhisk APIs in multiple different languages.:

Actions

What is an OpenWhisk action? Actions are stateless functions (code snippets) that run on the OpenWhisk platform. Actions encapsulates application logic to be executed in response to events. You can find more details on specifics of an action in main OpenWhisk GitHub repo at incubator-openwhisk.

Which programming language can I use to write an OpenWhisk action? An action can be created from a function written using any of the supported runtimes. Here is the list of runtimes supported by OpenWhisk:

  • JavaScript - OpenWhisk runtime for Node.js v6 and v8
  • Docker - OpenWhisk runtime for Docker Actions using SDK
  • Go - OpenWhisk runtime for Go lang
  • PHP - OpenWhisk runtime for PHP 7.2 and 7.1
  • Python - OpenWhisk runtime for Python 2.7 and 3
  • Swift - OpenWhisk runtime for Swift 3 and 4
  • Java - OpenWhisk runtime for Java 8
  • Ruby - OpenWhisk runtime for Ruby 2.5

While the actual function code will be specific to a language and runtime, the OpenWhisk operations to create, invoke and manage an action are the same regardless of the implementation choice. OpenWhisk wsk CLI and Whisk Deploy specified in Using OpenWhisk section supports action management on OpenWhisk platform.

What if your preferred language/runtime is not supported by OpenWhisk? If your favorite language is not listed above, you may find the Docker action or native binary path more suitable. The OpenWhisk platform is extensible and you can add new languages or runtimes (with custom packages and third-party dependencies) following the guide described here. Please reach out to other whiskers on dev mailing list at dev@openwhisk.incubator.apache.org. once you have followed the guide on creating a new language/runtimes. Here are some examples of runtimes added by community:

After you create an action, how can you invoke that action? You can invoke actions manually using OpenWhisk CLI or fire a trigger with which your action is associated with. If you are not faimiliar with triggers, we are looking into triggers in next section.

Can an application logic be divided into multiple actions? Multiple actions from different languages may be composed together to create a longer processing pipeline called a sequence. Sequence can be treated as an action in terms of it creation and invocation.

Please read OpenWhisk Actions for further details.

NodeJs

Creating and Invoking NodeJS actions

Let's look at how to write a sample hello world action in NodeJS. You can visit Creating and Invoking NodeJS actions page for further details.

Note: We will be using wsk CLI in this section. If you don't have it installed and configured, please refer to the section on Configure the wsk CLI to configure it.

  1. Create a file named hello.js:
    1
    2
    3
    function main() {
        return {payload: 'Hello world'};
    }
    
  2. Create an action called helloJS using hello.js:
    $ wsk action create helloJS hello.js
    ok: created action helloJS
  3. Invoke the helloJS action as a blocking activation:
    $ wsk action invoke helloJS --blocking
    {
      "result": {
          "payload": "Hello world"
        },
        "status": "success",
        "success": true
    }
  4. Deploy using wskdeploy:

    Note: We will be using wskdeploy in this section. If you don't have the binary, please refer to the section on Whisk Deploy to download it.

    1. Create manifest.yaml with the following YAML content:
      1
      2
      3
      4
      5
      packages:
          default:
              actions:
                  helloJS:
                      function: hello.js
      
      Or

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
              packages:
          default:
              actions:
                  helloJS:
                      code: |
                          function main() {
                              return {payload: 'Hello world'};
                          }
                      runtime: nodejs:6
      
      
              
      
    2. Run deployment with wskdeploy:
      $ wskdeploy -m manifest.yaml
OpenWhisk Runtime for NodeJS

OpenWhisk supports Node.js 6 and Node.js 8 runtimes where Node.js 6 being default pick by wsk CLI and Whisk Deploy. If you wish to learn more about NodeJS runtime along with the libraries that are supported or "built-in" by default, please visit NodeJS Runtime GitHub Repository.

Additional Resources

Python

Creating And Invoking Python actions

Let's look at how to write a sample hello world action in Python. You can visit Creating and Invoking Python actions page for further details.

Note: We will be using wsk CLI in this section. If you don't have it installed and configured, please refer to the section on Configure the wsk CLI to configure it.

  1. Create a file named hello.py:
    1
    2
    3
    4
    5
    6
    7
    8
    def main(dict):
        if 'name' in dict:
            name = dict['name']
        else:
            name = "stranger"
        greeting = "Hello " + name + "!"
        print(greeting)
        return {"greeting": greeting}
    
  2. Create an action called helloPy using hello.py:
    $ wsk action create helloPy hello.py
    ok: created action helloPy
  3. Invoke the helloPy action using command-line parameters:
    $ wsk action invoke helloPy --blocking --param name World
    {
        "greeting": "Hello World!"
    }
  4. Deploy using wskdeploy:

    Note: We will be using wskdeploy in this section. If you don't have the binary, please refer to the section on Whisk Deploy to download it.

    1. Create manifest.yaml with the following YAML content:
      1
      2
      3
      4
      5
      packages:
          default:
              actions:
                  helloPy:
                      function: hello.py
      
      Or

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      packages:
          default:
              actions:
                  helloPy:
                      code: |
                          import sys
                          def main(dict):
                              if 'name' in dict:
                                  name = dict['name']
                              else:
                                  name = "stranger"
                              greeting = "Hello " + name + "!"
                              print(greeting)
                              return {"greeting": greeting}
                      runtime: python:2
      
    2. Run deployment with wskdeploy:
      $ wskdeploy -m manifest.yaml
OpenWhisk Runtime for Python

OpenWhisk supports Python 2 and Python 3 runtimes where Python 2 being default pick by wsk CLI and Whisk Deploy. If you wish to learn more about Python runtime along with the libraries that are supported or "built-in" by default, please visit Python Runtime GitHub Repository.

Additional Resources

Go

Creating And Invoking Go actions

Let's look at how to write a sample hello world action in Go. You can visit Creating and Invoking Go actions page for further details.

Note: We will be using wsk CLI in this section. If you don't have it installed and configured, please refer to the section on Configure the wsk CLI to configure it.

  1. Create a file named hello.go:
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    package main
    
    import "encoding/json"
    import "fmt"
    import "os"
    
    func main() {
        //program receives one argument: the JSON object as a string
        arg := os.Args[1]
    
        // unmarshal the string to a JSON object
        var obj map[string]interface{}
        json.Unmarshal([]byte(arg), &obj)
    
        // can optionally log to stdout (or stderr)
        fmt.Println("hello Go action")
    
        name, ok := obj["name"].(string)
        if !ok { name = "Stranger" }
    
        // last line of stdout is the result JSON object as a string
        msg := map[string]string{"msg": ("Hello, " + name + "!")}
        res, _ := json.Marshal(msg)
        fmt.Println(string(res))
    }
    
  2. Create an executable called exec using hello.go:
    $ GOOS=linux GOARCH=amd64 go build -o exec
    $ zip exec.zip exec
  3. Create an action helloGo:
    $ wsk action create helloGo --native exec.zip
  4. Invoke an action helloGo:
    $ wsk action invoke helloGo -r -p name gopher
    {
        "msg": "Hello, gopher!"
    }
  5. Deploy using wskdeploy:

    Note: We will be using wskdeploy in this section. If you don't have the binary, please refer to the section on Whisk Deploy to download it.

    1. Create a directory called actions with hello.go from step 1 above.
    2. Create an executable called exec using hello.go:
      $ cd actions/
      $ GOOS=linux GOARCH=amd64 go build -o exec
    3. Create manifest.yaml with the following YAML content:
      1
      2
      3
      4
      5
      6
      packages:
          default:
              actions:
                  helloGo:
                      function: actions/
                      native: true
      
    4. Run deployment with wskdeploy:
      $ wskdeploy -m manifest.yaml
OpenWhisk Runtime for Go

If you wish to learn more about Go runtime along with the libraries that are supported or "built-in" by default, please visit Go Runtime GitHub Repository.

Additional Resources

Java

Creating and Invoking Java actions

Let's look at how to write a sample hello world action in Java. You can visit Creating and Invoking Java actions page for further details.

Note: We will be using wsk CLI in this section. If you don't have it installed and configured, please refer to the section on Configure the wsk CLI to configure it.

  1. Create a file named Hello.java:
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    package hello;
    
    import com.google.gson.JsonObject;
    
    public class Hello {
        public static JsonObject main(JsonObject args)
            String name;
    
            try {
                name = args.getAsJsonPrimitive("name").getAsString();
            } catch(Exception e) {
                name = "stranger";
            }
    
            JsonObject response = new JsonObject();
            response.addProperty("greeting", "Hello " + name + "!");
            return response;
        }
    }
    
  2. Compile Hello.Java into a JAR file hello.jar as follows
    $ javac Hello.java
    $ jar cvf hello.jar Hello.class
  3. Create an action called helloJava using hello.jar:
    $ wsk action create helloJava hello.jar --main Hello
    ok: created action helloJava
  4. Invoke an action helloJava:
    $ wsk action invoke helloJava --blocking --result
    {
        "greeting": "Hello stranger!"
    }
OpenWhisk Runtime for Java

OpenWhisk supports Java 8 runtime. If you wish to learn more about NodeJS runtime along with the libraries that are supported or "built-in" by default, please visit Java Runtime GitHub Repository.

Additional Resources

PHP

Creating and Invoking PHP actions

Let's look at how to write a sample hello world action in PHP. You can visit Creating and Invoking PHP actions page for further details.

Note: We will be using wsk CLI in this section. If you don't have it installed and configured, please refer to the section on Configure the wsk CLI to configure it.

  1. Create a file named hello.php:
    1
    2
    3
    4
    5
    6
    7
    8
    9
    <?php
    function main(array $args) : array
    {
        $name = $args["name"] ?? "stranger";
        $greeting = "Hello $name!";
        echo $greeting;
        return ["greeting" => $greeting];
    }
    ?>
    
  2. Create an action called helloPHP using hello.php:
    $ wsk action create helloPHP hello.php
    ok: created action helloPHP
  3. Invoke an action helloPHP:
    $ wsk action invoke helloPHP --blocking --result --param name World
    {
        "greeting": "Hello World!"
    }
  4. Deploy using wskdeploy:

    Note: We will be using wskdeploy in this section. If you don't have the binary, please refer to the section on Whisk Deploy to download it.

    1. Create manifest.yaml with the following YAML content:
      1
      2
      3
      4
      5
      packages:
          default:
              actions:
                  helloPHP:
                      function: hello.php
      
      Or

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      packages:
          default:
              actions:
                  helloPHP:
                      code: |
                          <?php
                          function main(array $args) : array
                          {
                              $name = $args["name"] ?? "stranger";
                              $greeting = "Hello $name!";
                              echo $greeting;
                              return ["greeting" => $greeting];
                          }
                      runtime: php:7.1
      
    2. Run deployment with wskdeploy:
      $ wskdeploy -m manifest.yaml
OpenWhisk Runtime for PHP

OpenWhisk supports PHP 7.2 and PHP 7.1 runtimes where PHP 7.2 being default pick by wsk CLI and Whisk Deploy. If you wish to learn more about PHP runtime, please visit PHP Runtime GitHub Repository.

Additional Resources

Ruby

Creating and Invoking Ruby actions

Let's look at how to write a sample hello world action in Ruby. You can visit Creating and Invoking Ruby actions page for further details.

Note: We will be using wsk CLI in this section. If you don't have it installed and configured, please refer to the section on Configure the wsk CLI to configure it.

  1. Create a file named hello.rb:
    1
    2
    3
    4
    5
    def main(params = {})
      name = params["name"] || "stranger"
      greeting = "Hello #{name}!"
      { "greeting": greeting }
    end
    
  2. Create an action called hello_ruby using hello.rb:
    $ wsk action create hello_ruby hello.rb
    ok: created action hello_ruby
  3. Invoke an action hello_ruby:
    $ wsk action invoke hello_ruby --blocking --result --param name World
    {
        "greeting": "Hello World!"
    }
OpenWhisk Runtime for Ruby

OpenWhisk supports Ruby 2.5 runtime. If you wish to learn more about Ruby runtime, please visit Ruby Runtime GitHub Repository.

Additional Resources
  • Coming soon...

Managing Actions with OpenWhisk Packages

What is a package? In OpenWhisk, you can use packages to bundle together a set of related actions, and share them with others. OpenWhisk comes with a list of packages You can get more details on OpenWhisk packages here.

Does OpenWhisk comes with any pre-installed packages? OpenWhisk comes with a list of pre-installed public packages which can be used by anyone. OpenWhisk has created a dedicated shared namespace /whisk.system for all the public packages.

Which all packages are available under /whisk.system? You can get a list of packages available in shared namespace by using wsk CLI:

  • Get a list of packages:
    $ wsk package list /whisk.system
  • Get a list of entities in a package:
    $ wsk package get --summary /whisk.system/<package-name>

How do I invoke an action from a public package? There are two way to invoke an action from a package, (1) Invoking an action directly from a package (2) Creating a package binding and then invoking an action in the binding.

  • Invoking an action from a public package:
    • Get a description of the /whisk.system/samples/greeting action:
      $ wsk action get --summary /whisk.system/samples/greeting
      action /whisk.system/samples/greeting: Returns a friendly greeting
          (parameters: name, place)
    • Invoking action in a package:
      $ wsk action invoke --result /whisk.system/samples/greeting
      {
          "payload": "Hello, stranger from somewhere!"
      }
    • Invoke the action with parameters:
      $ wsk action invoke --result /whisk.system/samples/greeting --param name Bernie --param place Vermont
      {
          "payload": "Hello, Bernie from Vermont!"
      }
  • Creating package binding and invoking action from the binding:
    • Creating and using package bindings:
      $ wsk package bind /whisk.system/samples valhallaSamples --param place Valhalla
      ok: created binding valhallaSamples
    • Invoke an action in the package binding:
      $ wsk action invoke --result valhallaSamples/greeting --param name Odin
      {
          "payload": "Hello, Odin from Valhalla!"
      }

Where do I get more information on packages? Please read OpenWhisk Packages for further details.

Connecting Actions to Event Sources

Why do I need to connect actions to event sources? OpenWhisk is based on event-driven architecture in which actions/functions should be connected to external/internal event sources such as message queues, database changes, webhooks, etc. When these events happen, functions/actions are automatically invoked without explicitly invoking them unlike we saw before in Creating And Invoking Actions. Now, events from these internal/external event sources are channeled through a trigger.

What is a trigger? Triggers are the class of events like published messages, document uploads to a website, GitHub commits, etc that are emitted by event sources.

How to create and fire triggers?

  • Create a trigger to send user location updates:
    $ wsk trigger create locationUpdate
  • Check you have created the trigger by listing the set of triggers:
    $ wsk trigger list
    triggers
    /someNamespace/locationUpdate                            private
  • Fire the trigger by specifying its name and parameters:
    $ wsk trigger fire locationUpdate --param name Bob --param place NYC
    ok: triggered locationUpdate

    Firing a trigger like this currently does not do anything. We need to associate this trigger with an action. This kind of association is called a rule.

What are the rules? Rules are used to associate a trigger with an action. After this kind of association is created, each time a trigger event is fired, the action is invoked.

  • Please make sure you have the hello action created. If not, you can follow instruction in the section above with the following hello.js.
    1
    2
    3
    function main(params) {
        return {payload: 'Hello, ' + params.name + ' from ' + params.place};
    }
    
    $ wsk action create hello hello.js
    $ wsk action invoke --result hello --param name Bernie --param place Vermont
    {
        "payload": "Hello, Bernie from Vermont"
    }
  • Create the rule:
    $ wsk rule create myRule locationUpdate hello
    ok: created rule myRule
  • Fire the locationUpdate trigger:
    $ wsk trigger fire locationUpdate --param name Bob --param place NYC
    ok: triggered /_/locationUpdate with id abcd...
  • Verify that the action was invoked by checking the activations list:
    $ wsk activation list --limit 2
    activations
    1234.... hello
    abcd.... locationUpdate
    
  • Retrieving the trigger activation record:
    $ wsk activation result 1234....
    {
        "payload": "Hello, Bob from NYC"
    }
    You can see that the hello action received the event payload and returned the expected string.

Please read Creating Triggers and Rules for further details.

Using OpenWhisk Enabled Services

OpenWhisk offers a catalog of packages which gives you can easy way to enhance your application with useful capabilities, and to access external services in the ecosystem. Examples of external services which are OpenWhisk-enabled include Slack, GitHub, Alarms, etc.

The catalog is available as packages under /whisk.system namespace. Using the following command, you can get a list of packages under /whisk.system:

$ wsk package list /whisk.system
packages
/whisk.system/alarms                                shared
/whisk.system/system                                shared
/whisk.system/utils                                 shared
/whisk.system/samples                               shared
/whisk.system/slack                                 shared
/whisk.system/github                                shared
...

Each of the packages under OpenWhisk Catalog is hosted in a GitHub repo. Please refer to these package repositories for further details:

Sample OpenWhisk Applications

GitHub Slack Bot

incubator-openwhisk-GitHubSlackBot demonstrates integration of GitHub Pull Request management with Slack and using Alarms.

Serverless Message Archiver To Object Storage (MATOS) Sample Application

incubator-openwhisk-sample-matos demonstrates an implementation of a simple pipeline that reads messages from a Message Hub topic and archives them in batches into an Object Storage folder.

Slackbot for OpenWhisk:

incubator-openwhisk-sample-slackbot a proof-of-concept Slackbot to invoke OpenWhisk actions.

openwhisk-slackinvite:

incubator-openwhisk-slackinvite implements invitations for Apache OpenWhisk Slack Community.

Tutorial and Workshop

OpenWhisk Tutorial

incubator-openwhisk-tutorial contains an interactive tutorials for the OpenWhisk CLI.

OpenWhisk Workshop

incubator-openwhisk-workshop provides a series of exercises to help you understand how to use OpenWhisk to build serverless applications.

Development Tools

The OpenWhisk Debugger

incubator-openwhisk-debugger supports debugging OpenWhisk actions. The debugger will arrange things so that the actions you wish to debug will be offloaded from the main OpenWhisk servers and instead run locally on your laptop. You can then, from within the debugger, inspect and modify values.

Other Resources

  • Events - list of past OpenWhisk events
  • Awesome OpenWhisk - list of OpenWhisk resources and tips including articles, books, videos, presentations, podcasts, etc.

Frequently Asked Questions